apoorva/greenhouse
2
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Experimental changes to point_cloud.h

Browse Source
This commit is contained in:
William Woodall 2013-07-08 16:36:46 -07:00 committed by Paul Bovbel
parent a931106c5b
commit 746a8faf65
1 changed files with 60 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

62
pcl_ros/include/pcl_ros/point_cloud.h
View File

@ -5,7 +5,8 @@
#include <pcl/point_cloud.h> #include <pcl/point_cloud.h>
#include <pcl/point_traits.h> #include <pcl/point_traits.h>
#include <pcl/for_each_type.h> #include <pcl/for_each_type.h>
#include <pcl/ros/conversions.h> #include <pcl/conversions.h>
#include <pcl_conversions/pcl_conversions.h>
#include <sensor_msgs/PointCloud2.h> #include <sensor_msgs/PointCloud2.h>
#include <boost/mpl/size.hpp> #include <boost/mpl/size.hpp>
#include <boost/ref.hpp> #include <boost/ref.hpp>
@ -109,6 +110,61 @@ namespace ros
}; };
template<typename T> struct HasHeader<pcl::PointCloud<T> > : TrueType {}; template<typename T> struct HasHeader<pcl::PointCloud<T> > : TrueType {};
// This is bad because it will only work for pcl::PointXYZ, but I can't
// find another way around ambiguous partial template specialization...
template<>
struct TimeStamp<pcl::PointCloud<pcl::PointXYZ> >
{
// This specialization could be dangerous, but it's the best I can do.
// If this TimeStamp struct is destroyed before they are done with the
// pointer returned by the first functions may go out of scope, but there
// isn't a lot I can do about that. This is a good reason to refuse to
// returning pointers like this...
static ros::Time* pointer(pcl::PointCloud<pcl::PointXYZ> &m) {
header_.reset(new std_msgs::Header());
pcl_conversions::fromPCL(m.header, *(header_));
return &(header_->stamp);
}
static ros::Time const* pointer(const pcl::PointCloud<pcl::PointXYZ>& m) {
header_const_.reset(new std_msgs::Header());
pcl_conversions::fromPCL(m.header, *(header_const_));
return &(header_const_->stamp);
}
static ros::Time value(const pcl::PointCloud<pcl::PointXYZ>& m) {
return pcl_conversions::fromPCL(m.header).stamp;
}
private:
static boost::shared_ptr<std_msgs::Header> header_;
static boost::shared_ptr<std_msgs::Header> header_const_;
};
template<>
struct TimeStamp<pcl::PointCloud<pcl::Normal> >
{
// This specialization could be dangerous, but it's the best I can do.
// If this TimeStamp struct is destroyed before they are done with the
// pointer returned by the first functions may go out of scope, but there
// isn't a lot I can do about that. This is a good reason to refuse to
// returning pointers like this...
static ros::Time* pointer(pcl::PointCloud<pcl::Normal> &m) {
header_.reset(new std_msgs::Header());
pcl_conversions::fromPCL(m.header, *(header_));
return &(header_->stamp);
}
static ros::Time const* pointer(const pcl::PointCloud<pcl::Normal>& m) {
header_const_.reset(new std_msgs::Header());
pcl_conversions::fromPCL(m.header, *(header_const_));
return &(header_const_->stamp);
}
static ros::Time value(const pcl::PointCloud<pcl::Normal>& m) {
return pcl_conversions::fromPCL(m.header).stamp;
}
private:
static boost::shared_ptr<std_msgs::Header> header_;
static boost::shared_ptr<std_msgs::Header> header_const_;
};
} // namespace ros::message_traits } // namespace ros::message_traits
namespace serialization namespace serialization
@ -156,7 +212,9 @@ namespace ros
template<typename Stream> template<typename Stream>
inline static void read(Stream& stream, pcl::PointCloud<T>& m) inline static void read(Stream& stream, pcl::PointCloud<T>& m)
{ {
stream.next(m.header); std_msgs::Header header;
pcl_conversions::fromPCL(m.header, header);
stream.next(header);
stream.next(m.height); stream.next(m.height);
stream.next(m.width); stream.next(m.width);