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
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
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"
|
