narf.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2010, 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.
 *
 */

/* \author Bastian Steder */

#ifndef PCL_NARF_H_
#define PCL_NARF_H_

#include <vector>
#include <Eigen/Geometry>
#include <pcl/common/common_headers.h>
#include <pcl/point_representation.h>

namespace pcl {

// Forward declarations
class RangeImage;
struct InterestPoint;

#define NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE 10

class Narf
{
  public:
    // =====CONSTRUCTOR & DESTRUCTOR=====
    Narf();
    Narf(const Narf& other);
    ~Narf();
    
    // =====Operators=====
    const Narf& operator=(const Narf& other);

    // =====STATIC=====
    static void extractFromRangeImageAndAddToList(const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size,
                                                  float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
    static void extractFromRangeImageAndAddToList(const RangeImage& range_image, float image_x, float image_y, int descriptor_size,
                                                  float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
    static void extractForInterestPoints(const RangeImage& range_image, const PointCloud<InterestPoint>& interest_points,
                                         int descriptor_size, float support_size, bool rotation_invariant, std::vector<Narf*>& feature_list);
    static void extractForEveryRangeImagePointAndAddToList(const RangeImage& range_image, int descriptor_size, float support_size,
                                                    bool rotation_invariant, std::vector<Narf*>& feature_list);
    
    // =====PUBLIC METHODS=====
    bool extractFromRangeImage(const RangeImage& range_image, const Eigen::Affine3f& pose, int descriptor_size, float support_size,
                               int surface_patch_world_size=NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE);
    
    bool extractFromRangeImage(const RangeImage& range_image, float x, float y, int descriptor_size, float support_size);

    bool extractFromRangeImage(const RangeImage& range_image, const InterestPoint& interest_point, int descriptor_size, float support_size);

    bool extractFromRangeImage(const RangeImage& range_image, const Eigen::Vector3f& interest_point, int descriptor_size, float support_size);

    bool extractFromRangeImageWithBestRotation(const RangeImage& range_image, const Eigen::Vector3f& interest_point,
                                               int descriptor_size, float support_size);
    
    /* Get the dominant rotations of the current descriptor
     * \param rotations the returned rotations
     * \param strength values describing how pronounced the corresponding rotations are
     */
    void getRotations(std::vector<float>& rotations, std::vector<float>& strengths) const;
    
    /* Get the feature with a different rotation around the normal
     * You are responsible for deleting the new features!
     * \param range_image the source from which the feature is extracted
     * \param rotations list of angles (in radians)
     * \param rvps returned features
     */
    void getRotatedVersions(const RangeImage& range_image, const std::vector<float>& rotations, std::vector<Narf*>& features) const;
    
    inline float getDescriptorDistance(const Narf& other) const;
    
    inline int getNoOfBeamPoints() const { return lrint(ceil(0.5f*float(surface_patch_pixel_size_))); }
    
    inline void copyToNarf36(Narf36& narf36) const;
    
    void saveBinary(const std::string& filename) const;
    void saveBinary(std::ostream& file) const;
    
    void loadBinary(const std::string& filename);
    void loadBinary(std::istream& file);
    
    bool extractDescriptor(int descriptor_size);
    
    // =====GETTERS=====
    inline const float* getDescriptor() const { return descriptor_;}
    inline float* getDescriptor() { return descriptor_;}
    inline const int& getDescriptorSize() const { return descriptor_size_;}
    inline int& getDescriptorSize() { return descriptor_size_;}
    inline const Eigen::Vector3f& getPosition() const { return position_;}
    inline Eigen::Vector3f& getPosition() { return position_;}
    inline const Eigen::Affine3f& getTransformation() const { return transformation_;}
    inline Eigen::Affine3f& getTransformation() { return transformation_;}
    inline const int& getSurfacePatchPixelSize() const { return surface_patch_pixel_size_;}
    inline int& getSurfacePatchPixelSize() { return surface_patch_pixel_size_;}
    inline const float& getSurfacePatchWorldSize() const { return surface_patch_world_size_;}
    inline float& getSurfacePatchWorldSize() { return surface_patch_world_size_;}
    inline const float& getSurfacePatchRotation() const { return surface_patch_rotation_;}
    inline float& getSurfacePatchRotation() { return surface_patch_rotation_;}
    inline const float* getSurfacePatch() const { return surface_patch_;}
    inline float* getSurfacePatch() { return surface_patch_;}
    
    // =====SETTERS=====
    inline void setDescriptor(float* descriptor) { descriptor_ = descriptor;}
    inline void setSurfacePatch(float* surface_patch) { surface_patch_ = surface_patch;}
    
    // =====PUBLIC MEMBER VARIABLES=====
    
    // =====PUBLIC STRUCTS=====
    struct FeaturePointRepresentation : public PointRepresentation<Narf*>
    {
      typedef Narf* PointT;
      FeaturePointRepresentation(int nr_dimensions) { this->nr_dimensions_ = nr_dimensions; }
      virtual void copyToFloatArray (const PointT& p, float* out) const { memcpy(out, p->getDescriptor(), sizeof(*p->getDescriptor())*this->nr_dimensions_); }
    };
    
  protected:
    // =====PROTECTED METHODS=====
    void reset();
    void deepCopy(const Narf& other);
    float* getBlurredSurfacePatch(int new_pixel_size, int blur_radius) const;
    
    void saveHeader(std::ostream& file) const;
    int loadHeader(std::istream& file) const;
    
    // =====PROTECTED STATIC METHODS=====
    static const std::string getHeaderKeyword() { return "NARF"; }
    
    // =====PROTECTED STATIC VARIABLES=====
    const static int VERSION = 1;

    // =====PROTECTED MEMBER VARIABLES=====
    Eigen::Vector3f position_;
    Eigen::Affine3f transformation_;
    float* surface_patch_;
    int surface_patch_pixel_size_;
    float surface_patch_world_size_;
    float surface_patch_rotation_;
    float* descriptor_;
    int descriptor_size_;

    // =====STATIC PROTECTED=====
    
  public:
    EIGEN_MAKE_ALIGNED_OPERATOR_NEW
};
#undef NARF_DEFAULT_SURFACE_PATCH_PIXEL_SIZE

}  // end namespace pcl

#include "pcl/features/narf.hpp"

#endif  //#ifndef PCL_NARF_H_

---

pcl
Author(s): See http://pcl.ros.org/authors for the complete list of authors.
autogenerated on Fri Jan 11 09:55:22 2013