quadric.h

Go to the documentation of this file.

/*
 * Software License Agreement (BSD License)
 *
 *  Copyright (c) 2015, Andreas ten Pas
 *  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.
 *
 *  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 QUADRIC_H
#define QUADRIC_H

#include <Eigen/Dense>
#include <pcl/point_cloud.h>
#include <pcl/point_types.h>
#include <pcl/visualization/pcl_visualizer.h>
#include <vector>

extern "C" void dggev_(const char* JOBVL, const char* JOBVR, const int* N, const double* A, const int* LDA,
                       const double* B, const int* LDB, double* ALPHAR, double* ALPHAI, double* BETA, double* VL,
                       const int* LDVL, double* VR, const int* LDVR, double* WORK, const int* LWORK, int* INFO);

class Quadric
{
public:

  Quadric()
  {
  }

  Quadric(const std::vector<Eigen::Matrix4d, Eigen::aligned_allocator<Eigen::Matrix4d> >& T_cams,
          const pcl::PointCloud<pcl::PointXYZ>::Ptr& input, const Eigen::Vector3d& sample, bool is_deterministic);
  
  void findTaubinNormalAxis(const std::vector<int> &indices, const Eigen::VectorXi& cam_source);
        
        void fitQuadric(const std::vector<int>& indices);

        void setInputCloud(const pcl::PointCloud<pcl::PointXYZ>::Ptr& input)
        {
                this->input_ = input;
        }
        
        void print();
        
        void plotAxes(void* viewer_void, int id) const;
        
        const Eigen::Vector3d& getSample() const
        {
                return sample_;
        }
        
        const Eigen::Vector3d& getBinormal() const
        {
                return binormal_;
        }
        
        const Eigen::Vector3d& getCurvatureAxis() const
        {
                return curvature_axis_;
        }
        
        const Eigen::Vector3d& getNormal() const
        {
                return normal_;
        }


private:

        void findAverageNormalAxis(const Eigen::MatrixXd& normals);
        
        void unpackQuadric();
        
  bool solveGeneralizedEigenProblem(const Eigen::MatrixXd& A, const Eigen::MatrixXd& B, Eigen::MatrixXd& v,
                                    Eigen::MatrixXd& lambda);

  bool is_deterministic_; 
  Eigen::Matrix3Xd cam_origins_; 
  Eigen::Vector3d sample_; 
  int majority_cam_source_; 
  pcl::PointCloud<pcl::PointXYZ>::Ptr input_; 
  Eigen::Vector3d curvature_axis_, normal_, binormal_; 
  Eigen::Matrix<double, 10, 1> parameters_; 
  Eigen::Vector3d centroid_; 
  Eigen::Matrix3d covariance_matrix_; 
  double normals_ratio_; 
  
  static const int TAUBIN_MATRICES_SIZE = 10; 
};

#endif // PCL_FEATURES_CURVATURE_ESTIMATION_TAUBIN_H_