181 lines
8.9 KiB
C++
181 lines
8.9 KiB
C++
/*
|
|
* Software License Agreement (BSD License)
|
|
*
|
|
* Robot Operating System code by the University of Osnabrück
|
|
* Copyright (c) 2015, University of Osnabrück
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
*
|
|
* 1. Redistributions of source code must retain the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer.
|
|
*
|
|
* 2. Redistributions in binary form must reproduce the above
|
|
* copyright notice, this list of conditions and the following
|
|
* disclaimer in the documentation and/or other materials provided
|
|
* with the distribution.
|
|
*
|
|
* 3. Neither the name of the copyright holder nor the names of its
|
|
* contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
|
|
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
|
|
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
|
|
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
|
|
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
|
|
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
|
|
* OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
|
|
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
|
|
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
|
|
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
*
|
|
*
|
|
* point_field_conversion.h
|
|
*
|
|
* Created on: 16.07.2015
|
|
* Authors: Sebastian Pütz <spuetz@uni-osnabrueck.de>
|
|
*/
|
|
|
|
#ifndef SENSOR_MSGS_POINT_FIELD_CONVERSION_H
|
|
#define SENSOR_MSGS_POINT_FIELD_CONVERSION_H
|
|
|
|
/**
|
|
* \brief This file provides a type to enum mapping for the different
|
|
* PointField types and methods to read and write in
|
|
* a PointCloud2 buffer for the different PointField types.
|
|
* \author Sebastian Pütz
|
|
*/
|
|
namespace sensor_msgs{
|
|
/*!
|
|
* \Enum to type mapping.
|
|
*/
|
|
template<int> struct pointFieldTypeAsType {};
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT8> { typedef int8_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT8> { typedef uint8_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT16> { typedef int16_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT16> { typedef uint16_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::INT32> { typedef int32_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::UINT32> { typedef uint32_t type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT32> { typedef float type; };
|
|
template<> struct pointFieldTypeAsType<sensor_msgs::PointField::FLOAT64> { typedef double type; };
|
|
|
|
/*!
|
|
* \Type to enum mapping.
|
|
*/
|
|
template<typename T> struct typeAsPointFieldType {};
|
|
template<> struct typeAsPointFieldType<int8_t> { static const uint8_t value = sensor_msgs::PointField::INT8; };
|
|
template<> struct typeAsPointFieldType<uint8_t> { static const uint8_t value = sensor_msgs::PointField::UINT8; };
|
|
template<> struct typeAsPointFieldType<int16_t> { static const uint8_t value = sensor_msgs::PointField::INT16; };
|
|
template<> struct typeAsPointFieldType<uint16_t> { static const uint8_t value = sensor_msgs::PointField::UINT16; };
|
|
template<> struct typeAsPointFieldType<int32_t> { static const uint8_t value = sensor_msgs::PointField::INT32; };
|
|
template<> struct typeAsPointFieldType<uint32_t> { static const uint8_t value = sensor_msgs::PointField::UINT32; };
|
|
template<> struct typeAsPointFieldType<float> { static const uint8_t value = sensor_msgs::PointField::FLOAT32; };
|
|
template<> struct typeAsPointFieldType<double> { static const uint8_t value = sensor_msgs::PointField::FLOAT64; };
|
|
|
|
/*!
|
|
* \Converts a value at the given pointer position, interpreted as the datatype
|
|
* specified by the given template argument point_field_type, to the given
|
|
* template type T and returns it.
|
|
* \param data_ptr pointer into the point cloud 2 buffer
|
|
* \tparam point_field_type sensor_msgs::PointField datatype value
|
|
* \tparam T return type
|
|
*/
|
|
template<int point_field_type, typename T>
|
|
inline T readPointCloud2BufferValue(const unsigned char* data_ptr){
|
|
typedef typename pointFieldTypeAsType<point_field_type>::type type;
|
|
return static_cast<T>(*(reinterpret_cast<type const *>(data_ptr)));
|
|
}
|
|
|
|
/*!
|
|
* \Converts a value at the given pointer position interpreted as the datatype
|
|
* specified by the given datatype parameter to the given template type and returns it.
|
|
* \param data_ptr pointer into the point cloud 2 buffer
|
|
* \param datatype sensor_msgs::PointField datatype value
|
|
* \tparam T return type
|
|
*/
|
|
template<typename T>
|
|
inline T readPointCloud2BufferValue(const unsigned char* data_ptr, const unsigned char datatype){
|
|
switch(datatype){
|
|
case sensor_msgs::PointField::INT8:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr);
|
|
case sensor_msgs::PointField::UINT8:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr);
|
|
case sensor_msgs::PointField::INT16:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr);
|
|
case sensor_msgs::PointField::UINT16:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr);
|
|
case sensor_msgs::PointField::INT32:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr);
|
|
case sensor_msgs::PointField::UINT32:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr);
|
|
case sensor_msgs::PointField::FLOAT32:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr);
|
|
case sensor_msgs::PointField::FLOAT64:
|
|
return readPointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr);
|
|
}
|
|
// This should never be reached, but return statement added to avoid compiler warning. (#84)
|
|
return T();
|
|
}
|
|
|
|
/*!
|
|
* \Inserts a given value at the given point position interpreted as the datatype
|
|
* specified by the template argument point_field_type.
|
|
* \param data_ptr pointer into the point cloud 2 buffer
|
|
* \param value the value to insert
|
|
* \tparam point_field_type sensor_msgs::PointField datatype value
|
|
* \tparam T type of the value to insert
|
|
*/
|
|
template<int point_field_type, typename T>
|
|
inline void writePointCloud2BufferValue(unsigned char* data_ptr, T value){
|
|
typedef typename pointFieldTypeAsType<point_field_type>::type type;
|
|
*(reinterpret_cast<type*>(data_ptr)) = static_cast<type>(value);
|
|
}
|
|
|
|
/*!
|
|
* \Inserts a given value at the given point position interpreted as the datatype
|
|
* specified by the given datatype parameter.
|
|
* \param data_ptr pointer into the point cloud 2 buffer
|
|
* \param datatype sensor_msgs::PointField datatype value
|
|
* \param value the value to insert
|
|
* \tparam T type of the value to insert
|
|
*/
|
|
template<typename T>
|
|
inline void writePointCloud2BufferValue(unsigned char* data_ptr, const unsigned char datatype, T value){
|
|
switch(datatype){
|
|
case sensor_msgs::PointField::INT8:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::INT8, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::UINT8:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::UINT8, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::INT16:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::INT16, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::UINT16:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::UINT16, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::INT32:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::INT32, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::UINT32:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::UINT32, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::FLOAT32:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT32, T>(data_ptr, value);
|
|
break;
|
|
case sensor_msgs::PointField::FLOAT64:
|
|
writePointCloud2BufferValue<sensor_msgs::PointField::FLOAT64, T>(data_ptr, value);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif /* point_field_conversion.h */
|