file_io.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2009, Willow Garage, Inc.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * 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.
 *   * Neither the name of Willow Garage, Inc. 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 OWNER 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.
 *
 * $Id: file_io.h 4932 2012-03-07 07:10:07Z rusu $
 *
 */

#ifndef PCL_IO_FILE_IO_H_
#define PCL_IO_FILE_IO_H_

#include <pcl/pcl_macros.h>
#include <pcl/common/io.h>
#include <boost/numeric/conversion/cast.hpp>
#include <cmath>
#include <sstream>

namespace pcl
{
  class PCL_EXPORTS FileReader
  {
    public:
      FileReader() {}
      virtual ~FileReader() {}
      virtual int 
      readHeader (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, 
                  int &file_version, int &data_type, unsigned int &data_idx, const int offset = 0) = 0;

      virtual int 
      read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, 
            Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &file_version, 
            const int offset = 0) = 0;

      int 
      read (const std::string &file_name, sensor_msgs::PointCloud2 &cloud, const int offset = 0)
      {
        Eigen::Vector4f origin;
        Eigen::Quaternionf orientation;
        int file_version;
        return (read (file_name, cloud, origin, orientation, file_version, offset));
      }

      template<typename PointT> inline int
      read (const std::string &file_name, pcl::PointCloud<PointT> &cloud, const int offset  =0)
      {
        sensor_msgs::PointCloud2 blob;
        int file_version;
        int res = read (file_name, blob, cloud.sensor_origin_, cloud.sensor_orientation_, 
                        file_version, offset);

        // Exit in case of error
        if (res < 0)
          return res;
        pcl::fromROSMsg (blob, cloud);
        return (0);
      }
  };

  class PCL_EXPORTS FileWriter
  {
    public:
      FileWriter () {}

      virtual ~FileWriter () {}

      virtual int
      write (const std::string &file_name, const sensor_msgs::PointCloud2 &cloud, 
             const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
             const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
             const bool binary = false) = 0;

      inline int
      write (const std::string &file_name, const sensor_msgs::PointCloud2::ConstPtr &cloud, 
             const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
             const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
             const bool binary = false)
      {
        return (write (file_name, *cloud, origin, orientation, binary));
      }

      template<typename PointT> inline int
      write (const std::string &file_name, 
             const pcl::PointCloud<PointT> &cloud, 
             const bool binary = false)
      {
        Eigen::Vector4f origin = cloud.sensor_origin_;
        Eigen::Quaternionf orientation = cloud.sensor_orientation_;

        sensor_msgs::PointCloud2 blob;
        pcl::toROSMsg (cloud, blob);

        // Save the data
        return (write (file_name, blob, origin, orientation, binary));
      }
  };

  template <typename Type> inline void
  copyValueString (const sensor_msgs::PointCloud2 &cloud, 
                   const unsigned int point_index, 
                   const int point_size, 
                   const unsigned int field_idx, 
                   const unsigned int fields_count, 
                   std::ostream &stream)
  {
    Type value;
    memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
    if (pcl_isnan (value))
      stream << "nan";
    else
      stream << boost::numeric_cast<Type>(value);
  }
  template <> inline void
  copyValueString<int8_t> (const sensor_msgs::PointCloud2 &cloud, 
                           const unsigned int point_index, 
                           const int point_size, 
                           const unsigned int field_idx, 
                           const unsigned int fields_count, 
                           std::ostream &stream)
  {
    int8_t value;
    memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (int8_t)], sizeof (int8_t));
    if (pcl_isnan (value))
      stream << "nan";
    else
      // Numeric cast doesn't give us what we want for int8_t
      stream << boost::numeric_cast<int>(value);
  }
  template <> inline void
  copyValueString<uint8_t> (const sensor_msgs::PointCloud2 &cloud, 
                            const unsigned int point_index, 
                            const int point_size, 
                            const unsigned int field_idx, 
                            const unsigned int fields_count, 
                            std::ostream &stream)
  {
    uint8_t value;
    memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (uint8_t)], sizeof (uint8_t));
    if (pcl_isnan (value))
      stream << "nan";
    else
      // Numeric cast doesn't give us what we want for uint8_t
      stream << boost::numeric_cast<int>(value);
  }

  template <typename Type> inline bool
  isValueFinite (const sensor_msgs::PointCloud2 &cloud, 
                 const unsigned int point_index, 
                 const int point_size, 
                 const unsigned int field_idx, 
                 const unsigned int fields_count)
  {
    Type value;
    memcpy (&value, &cloud.data[point_index * point_size + cloud.fields[field_idx].offset + fields_count * sizeof (Type)], sizeof (Type));
    if (!pcl_isfinite (value))
      return (false);
    return (true);
  }

  template <typename Type> inline void
  copyStringValue (const std::string &st, sensor_msgs::PointCloud2 &cloud,
                   unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
  {
    Type value;
    if (st == "nan")
    {
      value = std::numeric_limits<Type>::quiet_NaN ();
      cloud.is_dense = false;
    }
    else
    {
      std::istringstream is (st);
      is.imbue (std::locale::classic ());
      is >> value;
    }

    memcpy (&cloud.data[point_index * cloud.point_step + 
                        cloud.fields[field_idx].offset + 
                        fields_count * sizeof (Type)], reinterpret_cast<char*> (&value), sizeof (Type));
  }

  template <> inline void
  copyStringValue<int8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
                           unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
  {
    int8_t value;
    if (st == "nan")
    {
      value = static_cast<int8_t> (std::numeric_limits<int>::quiet_NaN ());
      cloud.is_dense = false;
    }
    else
    {
      int val;
      std::istringstream is (st);
      is.imbue (std::locale::classic ());
      is >> val;
      value = static_cast<int8_t> (val);
    }

    memcpy (&cloud.data[point_index * cloud.point_step + 
                        cloud.fields[field_idx].offset + 
                        fields_count * sizeof (int8_t)], reinterpret_cast<char*> (&value), sizeof (int8_t));
  }

  template <> inline void
  copyStringValue<uint8_t> (const std::string &st, sensor_msgs::PointCloud2 &cloud,
                           unsigned int point_index, unsigned int field_idx, unsigned int fields_count)
  {
    uint8_t value;
    if (st == "nan")
    {
      value = static_cast<uint8_t> (std::numeric_limits<int>::quiet_NaN ());
      cloud.is_dense = false;
    }
    else
    {
      int val;
      std::istringstream is (st);
      is.imbue (std::locale::classic ());
      is >> val;
      value = static_cast<uint8_t> (val);
    }

    memcpy (&cloud.data[point_index * cloud.point_step + 
                        cloud.fields[field_idx].offset + 
                        fields_count * sizeof (uint8_t)], reinterpret_cast<char*> (&value), sizeof (uint8_t));
  }
}

#endif  //#ifndef PCL_IO_FILE_IO_H_