40 #ifndef PCL_IO_PCD_IO_IMPL_H_
41 #define PCL_IO_PCD_IO_IMPL_H_
43 #include <boost/algorithm/string/trim.hpp>
48 #include <pcl/common/io.h>
49 #include <pcl/console/print.h>
50 #include <pcl/io/low_level_io.h>
51 #include <pcl/io/pcd_io.h>
53 #include <pcl/io/lzf.h>
56 template <
typename Po
intT> std::string
59 std::ostringstream oss;
60 oss.imbue (std::locale::classic ());
62 oss <<
"# .PCD v0.7 - Point Cloud Data file format"
66 const auto fields = pcl::getFields<PointT> ();
68 std::stringstream field_names, field_types, field_sizes, field_counts;
69 for (
const auto &field : fields)
71 if (field.name ==
"_")
74 field_names <<
" " << field.name;
76 if (
"rgb" == field.name)
77 field_types <<
" " <<
"U";
80 int count = std::abs (
static_cast<int> (field.count));
81 if (count == 0) count = 1;
82 field_counts <<
" " << count;
84 oss << field_names.str ();
85 oss <<
"\nSIZE" << field_sizes.str ()
86 <<
"\nTYPE" << field_types.str ()
87 <<
"\nCOUNT" << field_counts.str ();
89 if (nr_points != std::numeric_limits<int>::max ())
90 oss <<
"\nWIDTH " << nr_points <<
"\nHEIGHT " << 1 <<
"\n";
92 oss <<
"\nWIDTH " << cloud.
width <<
"\nHEIGHT " << cloud.
height <<
"\n";
101 if (nr_points != std::numeric_limits<int>::max ())
102 oss <<
"POINTS " << nr_points <<
"\n";
104 oss <<
"POINTS " << cloud.
size () <<
"\n";
110 template <
typename Po
intT>
int
116 PCL_WARN (
"[pcl::PCDWriter::writeBinary] Input point cloud has no data!\n");
119 std::ostringstream oss;
120 oss << generateHeader<PointT> (cloud) <<
"DATA binary\n";
122 data_idx =
static_cast<int> (oss.tellp ());
125 HANDLE h_native_file = CreateFileA (file_name.c_str (), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
126 if (h_native_file == INVALID_HANDLE_VALUE)
128 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during CreateFile!");
132 int fd =
io::raw_open (file_name.c_str (), O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
135 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during open!");
140 boost::interprocess::file_lock file_lock;
141 setLockingPermissions (file_name, file_lock);
143 auto fields = pcl::getFields<PointT> ();
144 std::vector<int> fields_sizes;
145 std::size_t fsize = 0;
146 std::size_t data_size = 0;
149 for (
const auto &field : fields)
151 if (field.name ==
"_")
156 fields_sizes.push_back (fs);
157 fields[nri++] = field;
161 data_size = cloud.
size () * fsize;
165 HANDLE fm = CreateFileMappingA (h_native_file, NULL, PAGE_READWRITE, 0, (DWORD) (data_idx + data_size), NULL);
168 throw pcl::IOException(
"[pcl::PCDWriter::writeBinary] Error during memory map creation ()!");
171 char *map =
static_cast<char*
>(MapViewOfFile (fm, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, data_idx + data_size));
177 if (allocate_res != 0)
180 resetLockingPermissions (file_name, file_lock);
181 PCL_ERROR (
"[pcl::PCDWriter::writeBinary] raw_fallocate(length=%zu) returned %i. errno: %d strerror: %s\n",
182 data_idx + data_size, allocate_res, errno, strerror (errno));
184 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during raw_fallocate ()!");
188 char *map =
static_cast<char*
> (::mmap (
nullptr, data_idx + data_size, PROT_WRITE, MAP_SHARED, fd, 0));
189 if (map ==
reinterpret_cast<char*
> (-1))
192 resetLockingPermissions (file_name, file_lock);
193 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during mmap ()!");
199 memcpy (&map[0], oss.str ().c_str (), data_idx);
202 char *out = &map[0] + data_idx;
203 for (
const auto& point: cloud)
206 for (
const auto &field : fields)
208 memcpy (out,
reinterpret_cast<const char*
> (&point) + field.offset, fields_sizes[nrj]);
209 out += fields_sizes[nrj++];
215 if (map_synchronization_)
216 msync (map, data_idx + data_size, MS_SYNC);
221 UnmapViewOfFile (map);
223 if (::munmap (map, (data_idx + data_size)) == -1)
226 resetLockingPermissions (file_name, file_lock);
227 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during munmap ()!");
233 CloseHandle (h_native_file);
237 resetLockingPermissions (file_name, file_lock);
242 template <
typename Po
intT>
int
248 PCL_WARN (
"[pcl::PCDWriter::writeBinaryCompressed] Input point cloud has no data!\n");
251 std::ostringstream oss;
252 oss << generateHeader<PointT> (cloud) <<
"DATA binary_compressed\n";
254 data_idx =
static_cast<int> (oss.tellp ());
257 HANDLE h_native_file = CreateFileA (file_name.c_str (), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
258 if (h_native_file == INVALID_HANDLE_VALUE)
260 throw pcl::IOException (
"[pcl::PCDWriter::writeBinaryCompressed] Error during CreateFile!");
264 int fd =
io::raw_open (file_name.c_str (), O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
267 throw pcl::IOException (
"[pcl::PCDWriter::writeBinaryCompressed] Error during open!");
273 boost::interprocess::file_lock file_lock;
274 setLockingPermissions (file_name, file_lock);
276 auto fields = pcl::getFields<PointT> ();
277 std::size_t fsize = 0;
278 std::size_t data_size = 0;
280 std::vector<int> fields_sizes (fields.size ());
282 for (
const auto &field : fields)
284 if (field.name ==
"_")
288 fsize += fields_sizes[nri];
292 fields_sizes.resize (nri);
296 data_size = cloud.
size () * fsize;
300 if (data_size * 3 / 2 > std::numeric_limits<std::uint32_t>::max ())
302 PCL_ERROR (
"[pcl::PCDWriter::writeBinaryCompressed] The input data exceeds the maximum size for compressed version 0.7 pcds of %l bytes.\n",
303 static_cast<std::size_t
> (std::numeric_limits<std::uint32_t>::max ()) * 2 / 3);
312 char *only_valid_data =
static_cast<char*
> (malloc (data_size));
322 std::vector<char*> pters (fields.size ());
323 std::size_t toff = 0;
324 for (std::size_t i = 0; i < pters.size (); ++i)
326 pters[i] = &only_valid_data[toff];
327 toff +=
static_cast<std::size_t
>(fields_sizes[i]) * cloud.
size();
331 for (
const auto& point: cloud)
333 for (std::size_t j = 0; j < fields.size (); ++j)
335 memcpy (pters[j],
reinterpret_cast<const char*
> (&point) + fields[j].offset, fields_sizes[j]);
337 pters[j] += fields_sizes[j];
341 char* temp_buf =
static_cast<char*
> (malloc (
static_cast<std::size_t
> (
static_cast<float> (data_size) * 1.5f + 8.0f)));
342 unsigned int compressed_final_size = 0;
343 if (data_size != 0) {
346 static_cast<std::uint32_t
> (data_size),
348 static_cast<std::uint32_t
> (
static_cast<float>(data_size) * 1.5f));
350 if (compressed_size > 0)
352 char *header = &temp_buf[0];
353 memcpy (&header[0], &compressed_size,
sizeof (
unsigned int));
354 memcpy (&header[4], &data_size,
sizeof (
unsigned int));
355 data_size = compressed_size + 8;
356 compressed_final_size =
static_cast<std::uint32_t
> (data_size) + data_idx;
363 resetLockingPermissions (file_name, file_lock);
364 PCL_WARN(
"[pcl::PCDWriter::writeBinaryCompressed] Error during compression!\n");
371 compressed_final_size = 8 + data_idx;
372 auto *header =
reinterpret_cast<std::uint32_t*
>(&temp_buf[0]);
380 HANDLE fm = CreateFileMapping (h_native_file, NULL, PAGE_READWRITE, 0, compressed_final_size, NULL);
381 char *map =
static_cast<char*
>(MapViewOfFile (fm, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, compressed_final_size));
387 if (allocate_res != 0)
390 resetLockingPermissions (file_name, file_lock);
391 PCL_ERROR (
"[pcl::PCDWriter::writeBinaryCompressed] raw_fallocate(length=%u) returned %i. errno: %d strerror: %s\n",
392 compressed_final_size, allocate_res, errno, strerror (errno));
394 throw pcl::IOException (
"[pcl::PCDWriter::writeBinaryCompressed] Error during raw_fallocate ()!");
398 char *map =
static_cast<char*
> (::mmap (
nullptr, compressed_final_size, PROT_WRITE, MAP_SHARED, fd, 0));
399 if (map ==
reinterpret_cast<char*
> (-1))
402 resetLockingPermissions (file_name, file_lock);
403 throw pcl::IOException (
"[pcl::PCDWriter::writeBinaryCompressed] Error during mmap ()!");
409 memcpy (&map[0], oss.str ().c_str (), data_idx);
411 memcpy (&map[data_idx], temp_buf, data_size);
415 if (map_synchronization_)
416 msync (map, compressed_final_size, MS_SYNC);
421 UnmapViewOfFile (map);
423 if (::munmap (map, (compressed_final_size)) == -1)
426 resetLockingPermissions (file_name, file_lock);
427 throw pcl::IOException (
"[pcl::PCDWriter::writeBinaryCompressed] Error during munmap ()!");
434 CloseHandle (h_native_file);
438 resetLockingPermissions (file_name, file_lock);
440 free (only_valid_data);
446 template <
typename Po
intT>
int
452 PCL_WARN (
"[pcl::PCDWriter::writeASCII] Input point cloud has no data!\n");
457 throw pcl::IOException (
"[pcl::PCDWriter::writeASCII] Number of points different than width * height!");
462 fs.open (file_name.c_str (), std::ios::binary);
464 if (!fs.is_open () || fs.fail ())
466 throw pcl::IOException (
"[pcl::PCDWriter::writeASCII] Could not open file for writing!");
471 boost::interprocess::file_lock file_lock;
472 setLockingPermissions (file_name, file_lock);
474 fs.precision (precision);
475 fs.imbue (std::locale::classic ());
477 const auto fields = pcl::getFields<PointT> ();
480 fs << generateHeader<PointT> (cloud) <<
"DATA ascii\n";
482 std::ostringstream stream;
483 stream.precision (precision);
484 stream.imbue (std::locale::classic ());
486 for (
const auto& point: cloud)
488 for (std::size_t d = 0; d < fields.size (); ++d)
491 if (fields[d].name ==
"_")
494 int count = fields[d].count;
498 for (
int c = 0; c < count; ++c)
500 switch (fields[d].datatype)
505 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (
bool),
sizeof (
bool));
506 stream << boost::numeric_cast<std::int32_t>(value);
512 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::int8_t),
sizeof (std::int8_t));
513 stream << boost::numeric_cast<std::int32_t>(value);
519 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::uint8_t),
sizeof (std::uint8_t));
520 stream << boost::numeric_cast<std::uint32_t>(value);
526 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::int16_t),
sizeof (std::int16_t));
527 stream << boost::numeric_cast<std::int16_t>(value);
533 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::uint16_t),
sizeof (std::uint16_t));
534 stream << boost::numeric_cast<std::uint16_t>(value);
540 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::int32_t),
sizeof (std::int32_t));
541 stream << boost::numeric_cast<std::int32_t>(value);
547 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::uint32_t),
sizeof (std::uint32_t));
548 stream << boost::numeric_cast<std::uint32_t>(value);
554 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::int64_t),
sizeof (std::int64_t));
555 stream << boost::numeric_cast<std::int64_t>(value);
561 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (std::uint64_t),
sizeof (std::uint64_t));
562 stream << boost::numeric_cast<std::uint64_t>(value);
572 if (
"rgb" == fields[d].name)
575 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (
float),
sizeof (
float));
576 stream << boost::numeric_cast<std::uint32_t>(value);
580 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (
float),
sizeof (
float));
581 if (std::isnan (value))
584 stream << boost::numeric_cast<float>(value);
590 memcpy (&value,
reinterpret_cast<const char*
> (&point) + fields[d].offset + c *
sizeof (
double),
sizeof (
double));
591 if (std::isnan (value))
594 stream << boost::numeric_cast<double>(value);
598 PCL_WARN (
"[pcl::PCDWriter::writeASCII] Incorrect field data type specified (%d)!\n", fields[d].datatype);
602 if (d < fields.size () - 1 || c <
static_cast<int> (fields[d].count - 1))
607 std::string result = stream.str ();
608 boost::trim (result);
610 fs << result <<
"\n";
613 resetLockingPermissions (file_name, file_lock);
619 template <
typename Po
intT>
int
624 if (cloud.
empty () || indices.empty ())
626 PCL_WARN (
"[pcl::PCDWriter::writeBinary] Input point cloud has no data or empty indices given!\n");
629 std::ostringstream oss;
630 oss << generateHeader<PointT> (cloud,
static_cast<int> (indices.size ())) <<
"DATA binary\n";
632 data_idx =
static_cast<int> (oss.tellp ());
635 HANDLE h_native_file = CreateFileA (file_name.c_str (), GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
636 if (h_native_file == INVALID_HANDLE_VALUE)
638 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during CreateFile!");
642 int fd =
io::raw_open (file_name.c_str (), O_RDWR | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
645 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during open!");
650 boost::interprocess::file_lock file_lock;
651 setLockingPermissions (file_name, file_lock);
653 auto fields = pcl::getFields<PointT> ();
654 std::vector<int> fields_sizes;
655 std::size_t fsize = 0;
656 std::size_t data_size = 0;
659 for (
const auto &field : fields)
661 if (field.name ==
"_")
666 fields_sizes.push_back (fs);
667 fields[nri++] = field;
671 data_size = indices.size () * fsize;
675 HANDLE fm = CreateFileMapping (h_native_file, NULL, PAGE_READWRITE, 0, data_idx + data_size, NULL);
676 char *map =
static_cast<char*
>(MapViewOfFile (fm, FILE_MAP_READ | FILE_MAP_WRITE, 0, 0, data_idx + data_size));
682 if (allocate_res != 0)
685 resetLockingPermissions (file_name, file_lock);
686 PCL_ERROR (
"[pcl::PCDWriter::writeBinary] raw_fallocate(length=%zu) returned %i. errno: %d strerror: %s\n",
687 data_idx + data_size, allocate_res, errno, strerror (errno));
689 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during raw_fallocate ()!");
693 char *map =
static_cast<char*
> (::mmap (
nullptr, data_idx + data_size, PROT_WRITE, MAP_SHARED, fd, 0));
694 if (map ==
reinterpret_cast<char*
> (-1))
697 resetLockingPermissions (file_name, file_lock);
698 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during mmap ()!");
704 memcpy (&map[0], oss.str ().c_str (), data_idx);
706 char *out = &map[0] + data_idx;
708 for (
const auto &index : indices)
711 for (
const auto &field : fields)
713 memcpy (out,
reinterpret_cast<const char*
> (&cloud[index]) + field.offset, fields_sizes[nrj]);
714 out += fields_sizes[nrj++];
720 if (map_synchronization_)
721 msync (map, data_idx + data_size, MS_SYNC);
726 UnmapViewOfFile (map);
728 if (::munmap (map, (data_idx + data_size)) == -1)
731 resetLockingPermissions (file_name, file_lock);
732 throw pcl::IOException (
"[pcl::PCDWriter::writeBinary] Error during munmap ()!");
738 CloseHandle(h_native_file);
743 resetLockingPermissions (file_name, file_lock);
748 template <
typename Po
intT>
int
754 if (cloud.
empty () || indices.empty ())
756 PCL_WARN (
"[pcl::PCDWriter::writeASCII] Input point cloud has no data or empty indices given!\n");
761 throw pcl::IOException (
"[pcl::PCDWriter::writeASCII] Number of points different than width * height!");
766 fs.open (file_name.c_str (), std::ios::binary);
767 if (!fs.is_open () || fs.fail ())
769 throw pcl::IOException (
"[pcl::PCDWriter::writeASCII] Could not open file for writing!");
774 boost::interprocess::file_lock file_lock;
775 setLockingPermissions (file_name, file_lock);
777 fs.precision (precision);
778 fs.imbue (std::locale::classic ());
780 const auto fields = pcl::getFields<PointT> ();
783 fs << generateHeader<PointT> (cloud,
static_cast<int> (indices.size ())) <<
"DATA ascii\n";
785 std::ostringstream stream;
786 stream.precision (precision);
787 stream.imbue (std::locale::classic ());
790 for (
const auto &index : indices)
792 for (std::size_t d = 0; d < fields.size (); ++d)
795 if (fields[d].name ==
"_")
798 int count = fields[d].count;
802 for (
int c = 0; c < count; ++c)
804 switch (fields[d].datatype)
809 memcpy (&value,
reinterpret_cast<const char*
> (&cloud.
points[index]) + fields[d].offset + c * sizeof (
bool),
sizeof (
bool));
810 stream << boost::numeric_cast<std::int32_t>(value);
816 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::int8_t),
sizeof (std::int8_t));
817 stream << boost::numeric_cast<std::int32_t>(value);
823 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::uint8_t),
sizeof (std::uint8_t));
824 stream << boost::numeric_cast<std::uint32_t>(value);
830 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::int16_t),
sizeof (std::int16_t));
831 stream << boost::numeric_cast<std::int16_t>(value);
837 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::uint16_t),
sizeof (std::uint16_t));
838 stream << boost::numeric_cast<std::uint16_t>(value);
844 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::int32_t),
sizeof (std::int32_t));
845 stream << boost::numeric_cast<std::int32_t>(value);
851 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (std::uint32_t),
sizeof (std::uint32_t));
852 stream << boost::numeric_cast<std::uint32_t>(value);
858 memcpy (&value,
reinterpret_cast<const char*
> (&cloud.
points[index]) + fields[d].offset + c * sizeof (std::int64_t),
sizeof (std::int64_t));
859 stream << boost::numeric_cast<std::int64_t>(value);
865 memcpy (&value,
reinterpret_cast<const char*
> (&cloud.
points[index]) + fields[d].offset + c * sizeof (std::uint64_t),
sizeof (std::uint64_t));
866 stream << boost::numeric_cast<std::uint64_t>(value);
876 if (
"rgb" == fields[d].name)
879 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (
float),
sizeof (
float));
880 stream << boost::numeric_cast<std::uint32_t>(value);
885 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (
float),
sizeof (
float));
886 if (std::isnan (value))
889 stream << boost::numeric_cast<float>(value);
896 memcpy (&value,
reinterpret_cast<const char*
> (&cloud[index]) + fields[d].offset + c *
sizeof (
double),
sizeof (
double));
897 if (std::isnan (value))
900 stream << boost::numeric_cast<double>(value);
904 PCL_WARN (
"[pcl::PCDWriter::writeASCII] Incorrect field data type specified (%d)!\n", fields[d].datatype);
908 if (d < fields.size () - 1 || c <
static_cast<int> (fields[d].count - 1))
913 std::string result = stream.str ();
914 boost::trim (result);
916 fs << result <<
"\n";
920 resetLockingPermissions (file_name, file_lock);
An exception that is thrown during an IO error (typical read/write errors)
int writeBinary(const std::string &file_name, const pcl::PCLPointCloud2 &cloud, const Eigen::Vector4f &origin=Eigen::Vector4f::Zero(), const Eigen::Quaternionf &orientation=Eigen::Quaternionf::Identity())
Save point cloud data to a PCD file containing n-D points, in BINARY format.
int writeASCII(const std::string &file_name, const pcl::PCLPointCloud2 &cloud, const Eigen::Vector4f &origin=Eigen::Vector4f::Zero(), const Eigen::Quaternionf &orientation=Eigen::Quaternionf::Identity(), const int precision=8)
Save point cloud data to a PCD file containing n-D points, in ASCII format.
static std::string generateHeader(const pcl::PointCloud< PointT > &cloud, const int nr_points=std::numeric_limits< int >::max())
Generate the header of a PCD file format.
int writeBinaryCompressed(const std::string &file_name, const pcl::PCLPointCloud2 &cloud, const Eigen::Vector4f &origin=Eigen::Vector4f::Zero(), const Eigen::Quaternionf &orientation=Eigen::Quaternionf::Identity())
Save point cloud data to a PCD file containing n-D points, in BINARY_COMPRESSED format.
PointCloud represents the base class in PCL for storing collections of 3D points.
Eigen::Quaternionf sensor_orientation_
Sensor acquisition pose (rotation).
std::uint32_t width
The point cloud width (if organized as an image-structure).
std::uint32_t height
The point cloud height (if organized as an image-structure).
Eigen::Vector4f sensor_origin_
Sensor acquisition pose (origin/translation).
std::vector< PointT, Eigen::aligned_allocator< PointT > > points
The point data.
int getFieldSize(const int datatype)
Obtains the size of a specific field data type in bytes.
int getFieldType(const int size, char type)
Obtains the type of the PCLPointField from a specific size and type.
int raw_fallocate(int fd, long length)
int raw_open(const char *pathname, int flags, int mode)
PCL_EXPORTS unsigned int lzfCompress(const void *const in_data, unsigned int in_len, void *out_data, unsigned int out_len)
Compress in_len bytes stored at the memory block starting at in_data and write the result to out_data...
IndicesAllocator<> Indices
Type used for indices in PCL.