integration.h

Go to the documentation of this file.

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

#ifndef PCL_APPS_IN_HAND_SCANNER_INTEGRATION_H
#define PCL_APPS_IN_HAND_SCANNER_INTEGRATION_H

#include <stdint.h>

#include <pcl/pcl_exports.h>
#include <pcl/apps/in_hand_scanner/common_types.h>

// Forward declarations

namespace pcl
{
  template <typename PointT>
  class KdTree;
} // End namespace pcl

// Integration

namespace pcl
{
  namespace ihs
  {
    class PCL_EXPORTS Integration
    {
      public:

        typedef pcl::PointXYZRGBNormal              PointXYZRGBNormal;
        typedef pcl::PointCloud <PointXYZRGBNormal> CloudXYZRGBNormal;
        typedef CloudXYZRGBNormal::Ptr              CloudXYZRGBNormalPtr;
        typedef CloudXYZRGBNormal::ConstPtr         CloudXYZRGBNormalConstPtr;

        typedef pcl::ihs::Mesh            Mesh;
        typedef pcl::ihs::MeshPtr         MeshPtr;
        typedef pcl::ihs::MeshConstPtr    MeshConstPtr;
        typedef Mesh::VertexIndex         VertexIndex;
        typedef Mesh::VertexIndices       VertexIndices;

        Integration ();

        bool
        reconstructMesh (const CloudXYZRGBNormalConstPtr& cloud_data,
                         MeshPtr&                         mesh_model) const;

        bool
        merge (const CloudXYZRGBNormalConstPtr& cloud_data,
               MeshPtr&                         mesh_model,
               const Eigen::Matrix4f&           T) const;

        void
        age (const MeshPtr& mesh, const bool cleanup=true) const;

        void
        removeUnfitVertices (const MeshPtr& mesh, const bool cleanup=true) const;

        void  setMaxSquaredDistance (const float squared_distance);
        float getMaxSquaredDistance () const;
        void  setMaxAngle (const float angle);
        float getMaxAngle () const;
        void         setMaxAge (const unsigned int age);
        unsigned int getMaxAge () const;
        void         setMinDirections (const unsigned int directions);
        unsigned int getMinDirections () const;
      private:

        typedef pcl::PointXYZ              PointXYZ;
        typedef pcl::PointCloud <PointXYZ> CloudXYZ;
        typedef CloudXYZ::Ptr              CloudXYZPtr;
        typedef CloudXYZ::ConstPtr         CloudXYZConstPtr;

        typedef pcl::ihs::PointIHS         PointIHS;
        typedef pcl::ihs::CloudIHS         CloudIHS;
        typedef pcl::ihs::CloudIHSPtr      CloudIHSPtr;
        typedef pcl::ihs::CloudIHSConstPtr CloudIHSConstPtr;

        typedef pcl::KdTree <PointXYZ>           KdTree;
        typedef boost::shared_ptr <KdTree>       KdTreePtr;
        typedef boost::shared_ptr <const KdTree> KdTreeConstPtr;

        uint8_t
        trimRGB (const float val) const;

        void
        addToMesh (const PointIHS& pt_0,
                   const PointIHS& pt_1,
                   const PointIHS& pt_2,
                   const PointIHS& pt_3,
                   VertexIndex&    vi_0,
                   VertexIndex&    vi_1,
                   VertexIndex&    vi_2,
                   VertexIndex&    vi_3,
                   const MeshPtr&  mesh) const;

        void
        addToMesh (const PointIHS& pt_0,
                   const PointIHS& pt_1,
                   const PointIHS& pt_2,
                   VertexIndex&    vi_0,
                   VertexIndex&    vi_1,
                   VertexIndex&    vi_2,
                   const MeshPtr&  mesh) const;

        bool
        distanceThreshold (const PointIHS& pt_0,
                           const PointIHS& pt_1,
                           const PointIHS& pt_2) const;

        bool
        distanceThreshold (const PointIHS& pt_0,
                           const PointIHS& pt_1,
                           const PointIHS& pt_2,
                           const PointIHS& pt_3) const;

        // Members

        KdTreePtr kd_tree_;

        float max_squared_distance_;

        float max_angle_;

        float min_weight_;

        unsigned int max_age_;

        unsigned int min_directions_;
    };
  } // End namespace ihs
} // End namespace pcl

#endif // PCL_APPS_IN_HAND_SCANNER_INTEGRATION_H