1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
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
|
