pcd_io.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010-2011, 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 the copyright holder(s) 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$
 *
 */

#ifndef PCL_IO_PCD_IO_H_
#define PCL_IO_PCD_IO_H_

#include <pcl/point_cloud.h>
#include <pcl/io/file_io.h>

namespace pcl
{
  class PCL_EXPORTS PCDReader : public FileReader
  {
    public:
      PCDReader () : FileReader () {}
      ~PCDReader () {}

      enum
      {
        PCD_V6 = 0,
        PCD_V7 = 1
      };

      int 
      readHeader (const std::string &file_name, pcl::PCLPointCloud2 &cloud,
                  Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version,
                  int &data_type, unsigned int &data_idx, const int offset = 0);


      int 
      readHeader (const std::string &file_name, pcl::PCLPointCloud2 &cloud, const int offset = 0);

      int 
      read (const std::string &file_name, pcl::PCLPointCloud2 &cloud,
            Eigen::Vector4f &origin, Eigen::Quaternionf &orientation, int &pcd_version, const int offset = 0);

      int 
      read (const std::string &file_name, pcl::PCLPointCloud2 &cloud, const int offset = 0);

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

        // If no error, convert the data
        if (res == 0)
          pcl::fromPCLPointCloud2 (blob, cloud);
        return (res);
      }

      EIGEN_MAKE_ALIGNED_OPERATOR_NEW
  };

  class PCL_EXPORTS PCDWriter : public FileWriter
  {
    public:
      PCDWriter() : FileWriter(), map_synchronization_(false) {}
      ~PCDWriter() {}

      void
      setMapSynchronization (bool sync)
      {
        map_synchronization_ = sync;
      }

      std::string
      generateHeaderBinary (const pcl::PCLPointCloud2 &cloud,
                            const Eigen::Vector4f &origin, 
                            const Eigen::Quaternionf &orientation);

      std::string
      generateHeaderBinaryCompressed (const pcl::PCLPointCloud2 &cloud,
                                      const Eigen::Vector4f &origin, 
                                      const Eigen::Quaternionf &orientation);

      std::string
      generateHeaderASCII (const pcl::PCLPointCloud2 &cloud,
                           const Eigen::Vector4f &origin, 
                           const Eigen::Quaternionf &orientation);

      template <typename PointT> static std::string
      generateHeader (const pcl::PointCloud<PointT> &cloud, 
                      const int nr_points = std::numeric_limits<int>::max ());

      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);

      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 ());

      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 ());

      inline int
      write (const std::string &file_name, const pcl::PCLPointCloud2 &cloud,
             const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
             const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
             const bool binary = false)
      {
        if (binary)
          return (writeBinary (file_name, cloud, origin, orientation));
        else
          return (writeASCII (file_name, cloud, origin, orientation, 8));
      }

      inline int
      write (const std::string &file_name, const pcl::PCLPointCloud2::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> int 
      writeBinary (const std::string &file_name, 
                   const pcl::PointCloud<PointT> &cloud);

      template <typename PointT> int 
      writeBinaryCompressed (const std::string &file_name, 
                             const pcl::PointCloud<PointT> &cloud);

      template <typename PointT> int 
      writeBinary (const std::string &file_name, 
                   const pcl::PointCloud<PointT> &cloud, 
                   const std::vector<int> &indices);

      template <typename PointT> int 
      writeASCII (const std::string &file_name, 
                  const pcl::PointCloud<PointT> &cloud,
                  const int precision = 8);

      template <typename PointT> int 
      writeASCII (const std::string &file_name, 
                  const pcl::PointCloud<PointT> &cloud,
                  const std::vector<int> &indices,
                  const int precision = 8);

      template<typename PointT> inline int
      write (const std::string &file_name, 
             const pcl::PointCloud<PointT> &cloud, 
             const bool binary = false)
      {
        if (binary)
          return (writeBinary<PointT> (file_name, cloud));
        else
          return (writeASCII<PointT> (file_name, cloud));
      }

      template<typename PointT> inline int
      write (const std::string &file_name, 
             const pcl::PointCloud<PointT> &cloud, 
             const std::vector<int> &indices,
             bool binary = false)
      {
        if (binary)
          return (writeBinary<PointT> (file_name, cloud, indices));
        else
          return (writeASCII<PointT> (file_name, cloud, indices));
      }

    protected:
      void
      setLockingPermissions (const std::string &file_name,
                             boost::interprocess::file_lock &lock);

      void
      resetLockingPermissions (const std::string &file_name,
                               boost::interprocess::file_lock &lock);

    private:
      bool map_synchronization_;
  };

  namespace io
  {
    inline int 
    loadPCDFile (const std::string &file_name, pcl::PCLPointCloud2 &cloud)
    {
      pcl::PCDReader p;
      return (p.read (file_name, cloud));
    }

    inline int 
    loadPCDFile (const std::string &file_name, pcl::PCLPointCloud2 &cloud,
                 Eigen::Vector4f &origin, Eigen::Quaternionf &orientation)
    {
      pcl::PCDReader p;
      int pcd_version;
      return (p.read (file_name, cloud, origin, orientation, pcd_version));
    }

    template<typename PointT> inline int
    loadPCDFile (const std::string &file_name, pcl::PointCloud<PointT> &cloud)
    {
      pcl::PCDReader p;
      return (p.read (file_name, cloud));
    }

    inline int 
    savePCDFile (const std::string &file_name, const pcl::PCLPointCloud2 &cloud,
                 const Eigen::Vector4f &origin = Eigen::Vector4f::Zero (), 
                 const Eigen::Quaternionf &orientation = Eigen::Quaternionf::Identity (),
                 const bool binary_mode = false)
    {
      PCDWriter w;
      return (w.write (file_name, cloud, origin, orientation, binary_mode));
    }

    template<typename PointT> inline int
    savePCDFile (const std::string &file_name, const pcl::PointCloud<PointT> &cloud, bool binary_mode = false)
    {
      PCDWriter w;
      return (w.write<PointT> (file_name, cloud, binary_mode));
    }

    template<typename PointT> inline int
    savePCDFileASCII (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
    {
      PCDWriter w;
      return (w.write<PointT> (file_name, cloud, false));
    }

    template<typename PointT> inline int
    savePCDFileBinary (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
    {
      PCDWriter w;
      return (w.write<PointT> (file_name, cloud, true));
    }

    template<typename PointT> int
    savePCDFile (const std::string &file_name, 
                 const pcl::PointCloud<PointT> &cloud,
                 const std::vector<int> &indices, 
                 const bool binary_mode = false)
    {
      // Save the data
      PCDWriter w;
      return (w.write<PointT> (file_name, cloud, indices, binary_mode));
    }


    template<typename PointT> inline int
    savePCDFileBinaryCompressed (const std::string &file_name, const pcl::PointCloud<PointT> &cloud)
    {
      PCDWriter w;
      return (w.writeBinaryCompressed<PointT> (file_name, cloud));
    }

  }
}

#include <pcl/io/impl/pcd_io.hpp>

#endif  //#ifndef PCL_IO_PCD_IO_H_