lzf_image_io.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2012-, Open Perception, 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.
 *
 */

#ifndef PCL_LZF_IMAGE_IO_H_
#define PCL_LZF_IMAGE_IO_H_

#include <pcl/pcl_macros.h>
#include <pcl/point_cloud.h>
#include <vector>

namespace pcl
{
  namespace io
  {
    struct CameraParameters
    {
      double focal_length_x;
      double focal_length_y;
      double principal_point_x;
      double principal_point_y;
    };

    class PCL_EXPORTS LZFImageReader
    {
      public:
        LZFImageReader ();
        virtual ~LZFImageReader () {}

        bool
        readParameters (const std::string &filename);

        inline void
        setParameters (const CameraParameters &parameters)
        {
          parameters_ = parameters;
        }

        inline CameraParameters
        getParameters () const
        {
          return parameters_;
        }

        inline uint32_t
        getWidth () const
        {
          return (width_);
        }

        inline uint32_t
        getHeight () const
        {
          return (height_);
        }

        inline std::string
        getImageType () const
        {
          return (image_type_identifier_);
        }

      protected:
        virtual bool
        readParameters (std::istream&) { return (false); }

        bool
        loadImageBlob (const std::string &filename,
                       std::vector<char> &data,
                       uint32_t &uncompressed_size);

        bool
        decompress (const std::vector<char> &input, 
                    std::vector<char> &output); 

        uint32_t width_;

        uint32_t height_;

        std::string image_type_identifier_;

        CameraParameters parameters_;
    };

    class PCL_EXPORTS LZFDepth16ImageReader : public LZFImageReader
    {
      public:
        using LZFImageReader::readParameters;

        LZFDepth16ImageReader () 
          : LZFImageReader () 
          , z_multiplication_factor_ (0.001)      // Set default multiplication factor
        {}

        virtual ~LZFDepth16ImageReader () {}

        template <typename PointT> bool
        read (const std::string &filename, pcl::PointCloud<PointT> &cloud);
        
        template <typename PointT> bool
        readOMP (const std::string &filename, pcl::PointCloud<PointT> &cloud, 
                 unsigned int num_threads=0);

        virtual bool
        readParameters (std::istream& is);

      protected:
        double z_multiplication_factor_;
    };

    class PCL_EXPORTS LZFRGB24ImageReader : public LZFImageReader
    {
      public:
        using LZFImageReader::readParameters;

        LZFRGB24ImageReader () : LZFImageReader () {}
        virtual ~LZFRGB24ImageReader () {}

        template<typename PointT> bool
        read (const std::string &filename, pcl::PointCloud<PointT> &cloud);
        
        template <typename PointT> bool
        readOMP (const std::string &filename, pcl::PointCloud<PointT> &cloud, 
                 unsigned int num_threads=0);

        virtual bool
        readParameters (std::istream& is);

      protected:
    };

    class PCL_EXPORTS LZFYUV422ImageReader : public LZFRGB24ImageReader
    {
      public:
        using LZFRGB24ImageReader::readParameters;

        LZFYUV422ImageReader () : LZFRGB24ImageReader () {}
        ~LZFYUV422ImageReader () {}

        template<typename PointT> bool
        read (const std::string &filename, pcl::PointCloud<PointT> &cloud);
        
        template <typename PointT> bool
        readOMP (const std::string &filename, pcl::PointCloud<PointT> &cloud, 
                 unsigned int num_threads=0);
    };

    class PCL_EXPORTS LZFBayer8ImageReader : public LZFRGB24ImageReader
    {
      public:
        using LZFRGB24ImageReader::readParameters;

        LZFBayer8ImageReader () : LZFRGB24ImageReader () {}
        ~LZFBayer8ImageReader () {}

        template<typename PointT> bool
        read (const std::string &filename, pcl::PointCloud<PointT> &cloud);

        template <typename PointT> bool
        readOMP (const std::string &filename, pcl::PointCloud<PointT> &cloud, 
                 unsigned int num_threads=0);
    };

    class PCL_EXPORTS LZFImageWriter
    {
      public:
        LZFImageWriter () {}
        virtual ~LZFImageWriter () {}

        virtual bool
        write (const char* data,
               uint32_t width, uint32_t height,
               const std::string &filename) = 0;

        virtual bool
        writeParameters (const CameraParameters &parameters,
                         const std::string &filename) = 0;

        virtual bool
        write (const char* data,
               uint32_t width, uint32_t height,
               const CameraParameters &parameters,
               const std::string &filename_data,
               const std::string &filename_xml)
        {
          bool res1 = write (data, width, height, filename_data);
          bool res2 = writeParameters (parameters, filename_xml);
          return (res1 && res2);
        }

        bool
        writeParameter (const double &parameter, const std::string &tag, 
                        const std::string &filename);
      protected:
        bool
        saveImageBlob (const char* data, size_t data_size, 
                       const std::string &filename);

        uint32_t
        compress (const char* input, uint32_t input_size, 
                  uint32_t width, uint32_t height,
                  const std::string &image_type,
                  char *output);
    };

    class PCL_EXPORTS LZFDepth16ImageWriter : public LZFImageWriter
    {
      public:
        LZFDepth16ImageWriter () 
          : LZFImageWriter ()
          , z_multiplication_factor_ (0.001)      // Set default multiplication factor
        {}

        virtual ~LZFDepth16ImageWriter () {}

        virtual bool
        write (const char* data,
               uint32_t width, uint32_t height,
               const std::string &filename);

        virtual bool
        writeParameters (const CameraParameters &parameters,
                         const std::string &filename);

      protected:
        double z_multiplication_factor_;
    };

    class PCL_EXPORTS LZFRGB24ImageWriter : public LZFImageWriter
    {
      public:
        LZFRGB24ImageWriter () : LZFImageWriter () {}
        virtual ~LZFRGB24ImageWriter () {}

        virtual bool
        write (const char *data, 
               uint32_t width, uint32_t height,
               const std::string &filename);

        virtual bool
        writeParameters (const CameraParameters &parameters,
                         const std::string &filename);

      protected:
    };

    class PCL_EXPORTS LZFYUV422ImageWriter : public LZFRGB24ImageWriter
    {
      public:
        LZFYUV422ImageWriter () : LZFRGB24ImageWriter () {}
        virtual ~LZFYUV422ImageWriter () {}

        virtual bool
        write (const char *data, 
               uint32_t width, uint32_t height,
               const std::string &filename);
    };

    class PCL_EXPORTS LZFBayer8ImageWriter : public LZFRGB24ImageWriter
    {
      public:
        LZFBayer8ImageWriter () : LZFRGB24ImageWriter () {}
        virtual ~LZFBayer8ImageWriter () {}

        virtual bool
        write (const char *data, 
               uint32_t width, uint32_t height,
               const std::string &filename);
    };
  }
}

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

#endif  //#ifndef PCL_LZF_IMAGE_IO_H_