patty.save() - Code Metrics - NLeSC/PattyAnalytics - Measure and Improve Code Quality continuously with Scrutinizer

patty.save() F
last analyzed 2016-03-07 10:18 UTC

↳ Parent: Project

Complexity

Conditions

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	7
CRAP Score	11.187

Metric	Value
cc	9
dl	0
loc	30
ccs	7
cts	10
cp	0.7
crap	11.187
rs	3

'''
Pointcloud functions for reading/writing LAS files, and functions for dealing
with the spatial reference system.
'''

from __future__ import print_function
import liblas
import pcl
import os
import numpy as np
import time
from patty.srs import force_srs, is_registered

from sklearn.decomposition import PCA


def _check_readable(filepath):
    """
    Test whether filepath is readable, raises IOError otherwise
    """
    with open(filepath):
        pass


def _check_writable(filepath):
    """
    Test whether filepath is writable, raises IOError otherwise
    """
    # either the path exists but is not writable, or the path does not exist
    # and the parent is not writable.
    filepath = os.path.abspath(filepath)
    if (os.path.exists(filepath) and (
            not os.path.isfile(filepath) or
            not os.access(filepath, os.W_OK)
            )) or not os.access(os.path.dirname(filepath), os.W_OK | os.X_OK):
        raise IOError("Cannot save to " + filepath)


def clone(pc):
    """
    Return a copy of a pointcloud, including registration metadata

    Arguments:
        pc: pcl.PointCloud()
    Returns:
        cp: pcl.PointCloud()
    """

    cp = pcl.PointCloud(np.asarray(pc))
    if is_registered(pc):
        force_srs(cp, same_as=pc)

    return cp


def load(path, format=None, load_rgb=True):
    """
    Read a pointcloud file.

    Supports LAS and CSV files, and lets PCD and PLY files be
    read by python-pcl.

    Arguments:
        path : string
            Filename.
        format : string, optional
            File format: "PLY", "PCD", "LAS", "CSV",
            or None to detect the format from the file extension.
        load_rgb : bool
            Whether RGB is loaded for PLY and PCD files. For LAS files, RGB is
            always read.

    Returns:
        pc : pcl.PointCloud
    """
    if format == 'las' or format is None and path.endswith('.las'):
        pc = _load_las(path)
    elif format == 'las' or format is None and path.endswith('.csv'):
        pc = _load_csv(path)
    else:
        _check_readable(path)
        pc = pcl.load(path, format=format, loadRGB=load_rgb)

    return pc


def save(cloud, path, format=None, binary=False, las_header=None):
    """Save a pointcloud to file.

    Supports LAS and CSV files, and lets PCD and PLY
    files be saved by python-pcl.

    Arguments:
        cloud : pcl.PointCloud or pcl.PointCloudXYZRGB
            Pointcloud to save.
        path : string
            Filename.
        format : string
            File format: "PLY", "PCD", "LAS", "CSV",
            or None to detect the format from the file extension.
        binary : boolean
            Whether PLY and PCD files are saved in binary format.
        las_header: liblas.header.Header
            LAS header to use. When none, a default header is created by
            make_las_header(). Default: None
    """
    if format == 'las' or format is None and path.endswith('.las'):
        _save_las(path, cloud, header=las_header)
    elif format == 'csv' or format is None and path.endswith('.csv'):
        _save_csv(path, cloud)
    else:
        _check_writable(path)
        if is_registered(cloud) and cloud.offset != np.zeros(3):
            cloud_array = np.asarray(cloud)
            cloud_array += cloud.offset
        pcl.save(cloud, path, format=format, binary=binary)


def _load_las(lasfile):
    """Read a LAS file

    Returns:
        registered pointcloudxyzrgb

    The pointcloud has color and XYZ coordinates, and the offset and precision
    set.
    """
    _check_readable(lasfile)

    las = None
    try:
        las = liblas.file.File(lasfile)
        lsrs = las.header.get_srs()
        lsrs = lsrs.get_wkt()

        n_points = las.header.get_count()
        precise_points = np.zeros((n_points, 6), dtype=np.float64)

        for i, point in enumerate(las):
            precise_points[i] = (point.x, point.y, point.z,
                                 point.color.red / 256,
                                 point.color.green / 256,
                                 point.color.blue / 256)

        # reduce the offset to decrease floating point errors
        bbox = BoundingBox(points=precise_points[:, 0:3])
        center = bbox.center
        precise_points[:, 0:3] -= center

        pointcloud = pcl.PointCloudXYZRGB(precise_points.astype(np.float32))
        force_srs(pointcloud, srs=lsrs, offset=center)

    finally:
        if las is not None:
            las.close()

    return pointcloud


def _load_csv(path, delimiter=','):
    """
    Load a set of points from a CSV file as a pointcloud

    Returns:
        pc : pcl.PointCloud
    """
    precise_points = np.genfromtxt(path, delimiter=delimiter, dtype=np.float64)
    offset = np.mean(precise_points, axis=0, dtype=np.float64)
    pc = pcl.PointCloud(np.array(precise_points - offset, dtype=np.float32))

    force_srs(pc, offset=offset)
    return pc


def _save_csv(path, pc, delimiter=', '):
    """
    Write a pointcloud to a CSV file.

    Arguments:
        path: string
            Output filename
        pc: pcl.PointCloud
            Pointcloud to save
        delimiter: string
            Field delimiter to use, see np.savetxt documentation.

    """
    if not hasattr(pc, 'offset'):
        offset = np.zeros(3)
    else:
        offset = pc.offset

    np.savetxt(path, np.asarray(pc) + offset, delimiter=delimiter)


def extract_mask(pointcloud, mask):
    """Extract all points in a mask into a new pointcloud.

    Arguments:
        pointcloud : pcl.PointCloud
            Input pointcloud.
        mask : numpy.ndarray of bool
            mask for which points from the pointcloud to include.
    Returns:
        pointcloud with the same registration (if any) as the original one."""
    pointcloud_new = pointcloud.extract(np.where(mask)[0])
    if is_registered(pointcloud):
        force_srs(pointcloud_new, same_as=pointcloud)
    return pointcloud_new


def make_las_header(pointcloud):
    """Make a LAS header for given pointcloud.

    If the pointcloud is registered, this is taken into account for the
    header metadata.

    LAS rounds the coordinates on writing; this is controlled via the
    'precision' attribute of the input pointcloud. By default this is
    0.01 in units of the projection.

    Arguments:
        pointcloud : pcl.PointCloud
            Input pointcloud.
    Returns:
        header : liblas.header.Header
            Header for writing the pointcloud to a LAS file.
    """
    schema = liblas.schema.Schema()
    schema.time = False
    schema.color = True

    # FIXME: this format version assumes color is present
    head = liblas.header.Header()
    head.schema = schema
    head.dataformat_id = 3
    head.major_version = 1
    head.minor_version = 2

    if is_registered(pointcloud):
        try:
            lsrs = liblas.srs.SRS()
            lsrs.set_wkt(pointcloud.srs.ExportToWkt())
            head.set_srs(lsrs)
        except liblas.core.LASException:
            pass

    if hasattr(pointcloud, 'offset'):
        head.offset = pointcloud.offset
    else:
        head.offset = np.zeros(3)

    # FIXME: need extra precision to reduce floating point errors. We don't
    # know exactly why this works. It might reduce precision on the top of
    # the float, but reduces an error of one bit for the last digit.
    if not hasattr(pointcloud, 'precision'):
        precision = np.array([0.01, 0.01, 0.01], dtype=np.float64)
    else:
        precision = np.array(pointcloud.precision, dtype=np.float64)
    head.scale = precision * 0.5

    pc_array = np.asarray(pointcloud)
    head.min = pc_array.min(axis=0) + head.offset
    head.max = pc_array.max(axis=0) + head.offset
    return head


def _save_las(lasfile, pointcloud, header=None):
    """Write a pointcloud to a LAS file

    Arguments:
        lasfile : string
            Filename.

        pointcloud : pcl.PointCloud

        header : liblas.header.Header, optional
            See :func:`make_las_header`. If not given, makes a header using
            that function with default settings.
    """
    _check_writable(lasfile)

    if header is None:
        header = make_las_header(pointcloud)

    # deal with color
    if len(pointcloud[0]) > 3:
        do_rgb = True
    else:
        do_rgb = False

    precise_points = np.array(pointcloud, dtype=np.float64)
    precise_points /= header.scale

    las = None
    try:
        las = liblas.file.File(lasfile, mode="w", header=header)

        for i in xrange(pointcloud.size):
            point = liblas.point.Point()
            point.x, point.y, point.z = precise_points[i]
            if do_rgb:
                red, grn, blu = pointcloud[i][3:6]
                point.color = liblas.color.Color(
                    red=int(red) * 256,
                    green=int(grn) * 256,
                    blue=int(blu) * 256)
            las.write(point)
    finally:
        if las is not None:
            las.close()


class BoundingBox(object):
    '''A bounding box for a sequence of points.

    Center, size and diagonal are updated when the minimum or maximum are
    updated.

    Constructor usage: either set points (any object that is converted to an
    NxD array by np.asarray, with D the number of dimensions) or a fixed min
    and max.
    '''

    def __init__(self, points=None, min=None, max=None):
        if min is not None and max is not None:
            self._min = np.asarray(min, dtype=np.float64)
            self._max = np.asarray(max, dtype=np.float64)
        elif points is not None:
            points_array = np.asarray(points)
            self._min = points_array.min(axis=0)
            self._max = points_array.max(axis=0)
        else:
            raise TypeError("Need to give min and max or matrix")

        self._reset()

    def __str__(self):
        return 'BoundingBox <%s - %s>' % (self.min, self.max)

    def _reset(self):
        self._center = None
        self._size = None

    @property
    def min(self):
        return self._min

    @min.setter
    def min(self, new_min):
        self._reset()
        self.min = new_min

    @property
    def max(self):
        return self._max

    @max.setter
    def max(self, new_max):
        self._reset()
        self.max = new_max

    @property
    def center(self):
        ''' Center point of the bounding box'''
        if self._center is None:
            self._center = (self.min + self.max) / 2.0
        return self._center

    @property
    def size(self):
        ''' N-dimensional size array '''
        if self._size is None:
            self._size = self.max - self.min
        return self._size

    @property
    def diagonal(self):
        ''' Length of the diagonal of the box. '''
        return np.linalg.norm(self.size)

    def contains(self, pos):
        ''' Whether the bounding box contains given position. '''
        return np.all((pos[0:3] >= self.min) & (pos[0:3] <= self.max))


def log(*args, **kwargs):
    """Simple logging function that prints to stdout"""
    print(time.strftime("[%F %H:%M:%S]", time.gmtime()), *args, **kwargs)


def measure_length(pointcloud):
    """Returns the length of a point cloud in its longest direction."""
    if len(pointcloud) < 2:
        return 0

    pca = PCA(n_components=1)
    pc_array = np.asarray(pointcloud)
    pca.fit(pc_array)
    primary_axis = np.dot(pc_array, np.transpose(pca.components_))[:, 0]
    return np.max(primary_axis) - np.min(primary_axis)


def downsample_voxel(pc, voxel_size=0.01):
    '''Downsample a pointcloud using a voxel grid filter.
    Resulting pointcloud has the same SRS and offset as the input.

    Arguments:
        pc         : pcl.PointCloud
                     Original pointcloud
        float      : voxel_size
                     Grid spacing for the voxel grid
    Returns:
        pc : pcl.PointCloud
             filtered pointcloud
    '''
    pc_filter = pc.make_voxel_grid_filter()
    pc_filter.set_leaf_size(voxel_size, voxel_size, voxel_size)
    newpc = pc_filter.filter()

    force_srs(newpc, same_as=pc)

    return newpc


def downsample_random(pc, fraction, random_seed=None):
    """Randomly downsample pointcloud to a fraction of its size.

    Returns a pointcloud of size fraction * len(pc), rounded to the nearest
    integer.  Resulting pointcloud has the same SRS and offset as the input.

    Use random_seed=k for some integer k to get reproducible results.
    Arguments:
        pc : pcl.PointCloud
            Input pointcloud.
        fraction : float
            Fraction of points to include.
        random_seed : int, optional
            Seed to use in random number generator.

    Returns:
        pcl.Pointcloud
    """
    if not 0 < fraction <= 1:
        raise ValueError("Expected fraction in (0,1], got %r" % fraction)

    rng = np.random.RandomState(random_seed)

    k = max(int(round(fraction * len(pc))), 1)
    sample = rng.choice(len(pc), k, replace=False)
    new_pc = pc.extract(sample)

    force_srs(new_pc, same_as=pc)

    return new_pc


1		'''
2		Pointcloud functions for reading/writing LAS files, and functions for dealing
3		with the spatial reference system.
4		'''
5
6	1	from __future__ import print_function
7	1	import liblas
8	1	import pcl
9	1	import os
10	1	import numpy as np
11	1	import time
12	1	from patty.srs import force_srs, is_registered
13
14	1	from sklearn.decomposition import PCA
15
16
17	1	def _check_readable(filepath):
18		"""
19		Test whether filepath is readable, raises IOError otherwise
20		"""
21	1	with open(filepath):
22	1	pass
23
24
25	1	def _check_writable(filepath):
26		"""
27		Test whether filepath is writable, raises IOError otherwise
28		"""
29		# either the path exists but is not writable, or the path does not exist
30		# and the parent is not writable.
31	1	filepath = os.path.abspath(filepath)
32	1	if (os.path.exists(filepath) and (
33		not os.path.isfile(filepath) or
34		not os.access(filepath, os.W_OK)
35		)) or not os.access(os.path.dirname(filepath), os.W_OK \| os.X_OK):
36		raise IOError("Cannot save to " + filepath)
37
38
39	1	def clone(pc):
40		"""
41		Return a copy of a pointcloud, including registration metadata
42
43		Arguments:
44		pc: pcl.PointCloud()
45		Returns:
46		cp: pcl.PointCloud()
47		"""
48
49		cp = pcl.PointCloud(np.asarray(pc))
50		if is_registered(pc):
51		force_srs(cp, same_as=pc)
52
53		return cp
54
55
56	1	def load(path, format=None, load_rgb=True):
57		"""
58		Read a pointcloud file.
59
60		Supports LAS and CSV files, and lets PCD and PLY files be
61		read by python-pcl.
62
63		Arguments:
64		path : string
65		Filename.
66		format : string, optional
67		File format: "PLY", "PCD", "LAS", "CSV",
68		or None to detect the format from the file extension.
69		load_rgb : bool
70		Whether RGB is loaded for PLY and PCD files. For LAS files, RGB is
71		always read.
72
73		Returns:
74		pc : pcl.PointCloud
75		"""
76	1	if format == 'las' or format is None and path.endswith('.las'):
77	1	pc = _load_las(path)
78	1	elif format == 'las' or format is None and path.endswith('.csv'):
79		pc = _load_csv(path)
80		else:
81	1	_check_readable(path)
82	1	pc = pcl.load(path, format=format, loadRGB=load_rgb)
83
84	1	return pc
85
86
87	1	def save(cloud, path, format=None, binary=False, las_header=None):
88		"""Save a pointcloud to file.
89
90		Supports LAS and CSV files, and lets PCD and PLY
91		files be saved by python-pcl.
92
93		Arguments:
94		cloud : pcl.PointCloud or pcl.PointCloudXYZRGB
95		Pointcloud to save.
96		path : string
97		Filename.
98		format : string
99		File format: "PLY", "PCD", "LAS", "CSV",
100		or None to detect the format from the file extension.
101		binary : boolean
102		Whether PLY and PCD files are saved in binary format.
103		las_header: liblas.header.Header
104		LAS header to use. When none, a default header is created by
105		make_las_header(). Default: None
106		"""
107	1	if format == 'las' or format is None and path.endswith('.las'):
108	1	_save_las(path, cloud, header=las_header)
109	1	elif format == 'csv' or format is None and path.endswith('.csv'):
110		_save_csv(path, cloud)
111		else:
112	1	_check_writable(path)
113	1	if is_registered(cloud) and cloud.offset != np.zeros(3):
114		cloud_array = np.asarray(cloud)
115		cloud_array += cloud.offset
116	1	pcl.save(cloud, path, format=format, binary=binary)
117
118
119	1	def _load_las(lasfile):
120		"""Read a LAS file
121
122		Returns:
123		registered pointcloudxyzrgb
124
125		The pointcloud has color and XYZ coordinates, and the offset and precision
126		set.
127		"""
128	1	_check_readable(lasfile)
129
130	1	las = None
131	1	try:
132	1	las = liblas.file.File(lasfile)
133	1	lsrs = las.header.get_srs()
134	1	lsrs = lsrs.get_wkt()
135
136	1	n_points = las.header.get_count()
137	1	precise_points = np.zeros((n_points, 6), dtype=np.float64)
138
139	1	for i, point in enumerate(las):
140	1	precise_points[i] = (point.x, point.y, point.z,
141		point.color.red / 256,
142		point.color.green / 256,
143		point.color.blue / 256)
144
145		# reduce the offset to decrease floating point errors
146	1	bbox = BoundingBox(points=precise_points[:, 0:3])
147	1	center = bbox.center
148	1	precise_points[:, 0:3] -= center
149
150	1	pointcloud = pcl.PointCloudXYZRGB(precise_points.astype(np.float32))
151	1	force_srs(pointcloud, srs=lsrs, offset=center)
152
153		finally:
154	1	if las is not None:
155	1	las.close()
156
157	1	return pointcloud
158
159
160	1	def _load_csv(path, delimiter=','):
161		"""
162		Load a set of points from a CSV file as a pointcloud
163
164		Returns:
165		pc : pcl.PointCloud
166		"""
167		precise_points = np.genfromtxt(path, delimiter=delimiter, dtype=np.float64)
168		offset = np.mean(precise_points, axis=0, dtype=np.float64)
169		pc = pcl.PointCloud(np.array(precise_points - offset, dtype=np.float32))
170
171		force_srs(pc, offset=offset)
172		return pc
173
174
175	1	def _save_csv(path, pc, delimiter=', '):
176		"""
177		Write a pointcloud to a CSV file.
178
179		Arguments:
180		path: string
181		Output filename
182		pc: pcl.PointCloud
183		Pointcloud to save
184		delimiter: string
185		Field delimiter to use, see np.savetxt documentation.
186
187		"""
188		if not hasattr(pc, 'offset'):
189		offset = np.zeros(3)
190		else:
191		offset = pc.offset
192
193		np.savetxt(path, np.asarray(pc) + offset, delimiter=delimiter)
194
195
196	1	def extract_mask(pointcloud, mask):
197		"""Extract all points in a mask into a new pointcloud.
198
199		Arguments:
200		pointcloud : pcl.PointCloud
201		Input pointcloud.
202		mask : numpy.ndarray of bool
203		mask for which points from the pointcloud to include.
204		Returns:
205		pointcloud with the same registration (if any) as the original one."""
206	1	pointcloud_new = pointcloud.extract(np.where(mask)[0])
207	1	if is_registered(pointcloud):
208		force_srs(pointcloud_new, same_as=pointcloud)
209	1	return pointcloud_new
210
211
212	1	def make_las_header(pointcloud):
213		"""Make a LAS header for given pointcloud.
214
215		If the pointcloud is registered, this is taken into account for the
216		header metadata.
217
218		LAS rounds the coordinates on writing; this is controlled via the
219		'precision' attribute of the input pointcloud. By default this is
220		0.01 in units of the projection.
221
222		Arguments:
223		pointcloud : pcl.PointCloud
224		Input pointcloud.
225		Returns:
226		header : liblas.header.Header
227		Header for writing the pointcloud to a LAS file.
228		"""
229	1	schema = liblas.schema.Schema()
230	1	schema.time = False
231	1	schema.color = True
232
233		# FIXME: this format version assumes color is present
234	1	head = liblas.header.Header()
235	1	head.schema = schema
236	1	head.dataformat_id = 3
237	1	head.major_version = 1
238	1	head.minor_version = 2
239
240	1	if is_registered(pointcloud):
241		try:
242		lsrs = liblas.srs.SRS()
243		lsrs.set_wkt(pointcloud.srs.ExportToWkt())
244		head.set_srs(lsrs)
245		except liblas.core.LASException:
246		pass
247
248	1	if hasattr(pointcloud, 'offset'):
249		head.offset = pointcloud.offset
250		else:
251	1	head.offset = np.zeros(3)
252
253		# FIXME: need extra precision to reduce floating point errors. We don't
254		# know exactly why this works. It might reduce precision on the top of
255		# the float, but reduces an error of one bit for the last digit.
256	1	if not hasattr(pointcloud, 'precision'):
257	1	precision = np.array([0.01, 0.01, 0.01], dtype=np.float64)
258		else:
259		precision = np.array(pointcloud.precision, dtype=np.float64)
260	1	head.scale = precision * 0.5
261
262	1	pc_array = np.asarray(pointcloud)
263	1	head.min = pc_array.min(axis=0) + head.offset
264	1	head.max = pc_array.max(axis=0) + head.offset
265	1	return head
266
267
268	1	def _save_las(lasfile, pointcloud, header=None):
269		"""Write a pointcloud to a LAS file
270
271		Arguments:
272		lasfile : string
273		Filename.
274
275		pointcloud : pcl.PointCloud
276
277		header : liblas.header.Header, optional
278		See :func:`make_las_header`. If not given, makes a header using
279		that function with default settings.
280		"""
281	1	_check_writable(lasfile)
282
283	1	if header is None:
284	1	header = make_las_header(pointcloud)
285
286		# deal with color
287	1	if len(pointcloud[0]) > 3:
288	1	do_rgb = True
289		else:
290	1	do_rgb = False
291
292	1	precise_points = np.array(pointcloud, dtype=np.float64)
293	1	precise_points /= header.scale
294
295	1	las = None
296	1	try:
297	1	las = liblas.file.File(lasfile, mode="w", header=header)
298
299	1	for i in xrange(pointcloud.size):
300	1	point = liblas.point.Point()
301	1	point.x, point.y, point.z = precise_points[i]
302	1	if do_rgb:
303	1	red, grn, blu = pointcloud[i][3:6]
304	1	point.color = liblas.color.Color(
305		red=int(red) * 256,
306		green=int(grn) * 256,
307		blue=int(blu) * 256)
308	1	las.write(point)
309		finally:
310	1	if las is not None:
311	1	las.close()
312
313
314	1	class BoundingBox(object):
315		'''A bounding box for a sequence of points.
316
317		Center, size and diagonal are updated when the minimum or maximum are
318		updated.
319
320		Constructor usage: either set points (any object that is converted to an
321		NxD array by np.asarray, with D the number of dimensions) or a fixed min
322		and max.
323		'''
324
325	1	def __init__(self, points=None, min=None, max=None):
326	1	if min is not None and max is not None:
327		self._min = np.asarray(min, dtype=np.float64)
328		self._max = np.asarray(max, dtype=np.float64)
329	1	elif points is not None:
330	1	points_array = np.asarray(points)
331	1	self._min = points_array.min(axis=0)
332	1	self._max = points_array.max(axis=0)
333		else:
334		raise TypeError("Need to give min and max or matrix")
335
336	1	self._reset()
337
338	1	def __str__(self):
339		return 'BoundingBox <%s - %s>' % (self.min, self.max)
340
341	1	def _reset(self):
342	1	self._center = None
343	1	self._size = None
344
345	1	@property
346		def min(self):
347	1	return self._min
348
349	1	@min.setter
350		def min(self, new_min):
351		self._reset()
352		self.min = new_min
353
354	1	@property
355		def max(self):
356	1	return self._max
357
358	1	@max.setter
359		def max(self, new_max):
360		self._reset()
361		self.max = new_max
362
363	1	@property
364		def center(self):
365		''' Center point of the bounding box'''
366	1	if self._center is None:
367	1	self._center = (self.min + self.max) / 2.0
368	1	return self._center
369
370	1	@property
371		def size(self):
372		''' N-dimensional size array '''
373		if self._size is None:
374		self._size = self.max - self.min
375		return self._size
376
377	1	@property
378		def diagonal(self):
379		''' Length of the diagonal of the box. '''
380		return np.linalg.norm(self.size)
381
382	1	def contains(self, pos):
383		''' Whether the bounding box contains given position. '''
384		return np.all((pos[0:3] >= self.min) & (pos[0:3] <= self.max))
385
386
387	1	def log(args, *kwargs):
388		"""Simple logging function that prints to stdout"""
389		print(time.strftime("[%F %H:%M:%S]", time.gmtime()), args, *kwargs)
390
391
392	1	def measure_length(pointcloud):
393		"""Returns the length of a point cloud in its longest direction."""
394	1	if len(pointcloud) < 2:
395	1	return 0
396
397	1	pca = PCA(n_components=1)
398	1	pc_array = np.asarray(pointcloud)
399	1	pca.fit(pc_array)
400	1	primary_axis = np.dot(pc_array, np.transpose(pca.components_))[:, 0]
401	1	return np.max(primary_axis) - np.min(primary_axis)
402
403
404	1	def downsample_voxel(pc, voxel_size=0.01):
405		'''Downsample a pointcloud using a voxel grid filter.
406		Resulting pointcloud has the same SRS and offset as the input.
407
408		Arguments:
409		pc : pcl.PointCloud
410		Original pointcloud
411		float : voxel_size
412		Grid spacing for the voxel grid
413		Returns:
414		pc : pcl.PointCloud
415		filtered pointcloud
416		'''
417	1	pc_filter = pc.make_voxel_grid_filter()
418	1	pc_filter.set_leaf_size(voxel_size, voxel_size, voxel_size)
419	1	newpc = pc_filter.filter()
420
421	1	force_srs(newpc, same_as=pc)
422
423	1	return newpc
424
425
426	1	def downsample_random(pc, fraction, random_seed=None):
427		"""Randomly downsample pointcloud to a fraction of its size.
428
429		Returns a pointcloud of size fraction * len(pc), rounded to the nearest
430		integer. Resulting pointcloud has the same SRS and offset as the input.
431
432		Use random_seed=k for some integer k to get reproducible results.
433		Arguments:
434		pc : pcl.PointCloud
435		Input pointcloud.
436		fraction : float
437		Fraction of points to include.
438		random_seed : int, optional
439		Seed to use in random number generator.
440
441		Returns:
442		pcl.Pointcloud
443		"""
444	1	if not 0 < fraction <= 1:
445	1	raise ValueError("Expected fraction in (0,1], got %r" % fraction)
446
447	1	rng = np.random.RandomState(random_seed)
448
449	1	k = max(int(round(fraction * len(pc))), 1)
450	1	sample = rng.choice(len(pc), k, replace=False)
451	1	new_pc = pc.extract(sample)
452
453	1	force_srs(new_pc, same_as=pc)
454
455		return new_pc
456

NLeSC / PattyAnalytics

patty.save() F last analyzed 2016-03-07 10:18 UTC

Complexity

Size

Duplication

Code Coverage

Duplication Side-by-Side

Filter issues like

patty.save() F
last analyzed 2016-03-07 10:18 UTC