range_image_planar.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Point Cloud Library (PCL) - www.pointclouds.org
 *  Copyright (c) 2010, Willow Garage, Inc.
 *  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_RANGE_IMAGE_PLANAR_H_
#define PCL_RANGE_IMAGE_PLANAR_H_

#include <pcl/range_image/range_image.h>

namespace pcl
{
  class RangeImagePlanar : public RangeImage
  {
    public:
      // =====TYPEDEFS=====
      typedef RangeImage BaseClass;
      typedef boost::shared_ptr<RangeImagePlanar> Ptr;
      typedef boost::shared_ptr<const RangeImagePlanar> ConstPtr;
      
      // =====CONSTRUCTOR & DESTRUCTOR=====
      PCL_EXPORTS RangeImagePlanar ();
      PCL_EXPORTS virtual ~RangeImagePlanar ();

      virtual RangeImage* 
      getNew () const { return new RangeImagePlanar; }

      PCL_EXPORTS virtual void
      copyTo (RangeImage& other) const;
      
      // =====PUBLIC METHODS=====
      inline Ptr 
      makeShared () { return Ptr (new RangeImagePlanar (*this)); } 
      
      PCL_EXPORTS void
      setDisparityImage (const float* disparity_image, int di_width, int di_height,
                         float focal_length, float base_line, float desired_angular_resolution=-1);
      
      PCL_EXPORTS void
      setDepthImage (const float* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
                     float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
      
      PCL_EXPORTS void
      setDepthImage (const unsigned short* depth_image, int di_width, int di_height, float di_center_x, float di_center_y,
                     float di_focal_length_x, float di_focal_length_y, float desired_angular_resolution=-1);
      
      template <typename PointCloudType> void
      createFromPointCloudWithFixedSize (const PointCloudType& point_cloud,
                                         int di_width, int di_height, float di_center_x, float di_center_y,
                                         float di_focal_length_x, float di_focal_length_y,
                                         const Eigen::Affine3f& sensor_pose,
                                         CoordinateFrame coordinate_frame=CAMERA_FRAME, float noise_level=0.0f,
                                         float min_range=0.0f);
      
      // Since we reimplement some of these overloaded functions, we have to do the following:
      using RangeImage::calculate3DPoint;
      using RangeImage::getImagePoint;
      
      virtual inline void
      calculate3DPoint (float image_x, float image_y, float range, Eigen::Vector3f& point) const;
      
      virtual inline void 
      getImagePoint (const Eigen::Vector3f& point, float& image_x, float& image_y, float& range) const;
      
      PCL_EXPORTS virtual void
      getSubImage (int sub_image_image_offset_x, int sub_image_image_offset_y, int sub_image_width,
                   int sub_image_height, int combine_pixels, RangeImage& sub_image) const;
      
      PCL_EXPORTS virtual void 
      getHalfImage (RangeImage& half_image) const;
      
      inline float
      getFocalLengthX () const { return focal_length_x_; }
      
      inline float
      getFocalLengthY () const { return focal_length_y_; }
      
      inline float
      getCenterX () const { return center_x_; }
      
      inline float
      getCenterY () const { return center_y_; }


    protected:
      float focal_length_x_, focal_length_y_; 
      float focal_length_x_reciprocal_, focal_length_y_reciprocal_;  
      float center_x_, center_y_;      
  };
}  // namespace end


#include <pcl/range_image/impl/range_image_planar.hpp>  // Definitions of templated and inline functions

#endif  //#ifndef PCL_RANGE_IMAGE_H_