a_shape.h

Go to the documentation of this file.

/*
         Copyright 2010-2020 Pierre SMARS (smars@yuntech.edu.tw)
         This program is free software: you can redistribute it and/or modify
         it under the terms of the GNU General Public License as published by
         the Free Software Foundation, either version 2 of the License, or
         (at your option) any later version.
 
         This program is distributed in the hope that it will be useful,
         but WITHOUT ANY WARRANTY; without even the implied warranty of
         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
         GNU General Public License for more details.
 
         You should have received a copy of the GNU General Public License
         along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _SHAPE_H_
#define _SHAPE_H_
 
// .NAME a_shape
// .SECTION Author
// Pierre Smars
#include <vector> 
#include <string> 
#include <time.h> 
#include "a_base.h"
#include "a_point.h"
#include <vnl/vnl_vector.h>
#include <vnl/vnl_least_squares_function.h>
 
class a_shape: public a_base
{
        public:
                a_shape(int n_parameters): P_(0.99), verbose_(false) {verysmall_=1000.;para_.set_size(n_parameters);srand(time(NULL));};
                virtual ~a_shape();
                virtual const std::string classname() const {return "a_shape";}
                static const std::string help();
                //a point reasonably belongs to the shape if its distance from the shape is smaller than verysmall_
                void P(const double P) {P_=P;}
                double P() const {return P_;}
                unsigned int npara() const {return para_.size();}
                virtual a_point closest_point(const a_point p) const = 0;
                //distance between a point and the shape
                virtual double dist_point(const a_point p) const = 0;
                //a reasonable guess based from the point cloud
                virtual void random_hint(const std::vector<a_point>& pts) = 0;
                //sum of the distance for all points of the cloud
                double dist_cloud(const std::vector<a_point>& pts);
                double average_dist_cloud(const std::vector<a_point>& pts);
                double rms_dist_cloud(const std::vector<a_point>& pts);
                int threshold_cloud(const std::vector<a_point>& pts, std::vector<a_point>& pts2);
                //reasonable guess maximising the number of fits
                int best_fitting_cloud(const std::vector<a_point>& pts, std::vector<a_point>& pts2);
                void fit_cloud(const std::vector<a_point>& pts, vnl_least_squares_function& fn);
                virtual void fit_cloud(std::vector<a_point>& pts, short nl=1) = 0;
                vnl_vector<double> getparameters() const {return para_;}
                void para(const int i, const double val) {para_[i] = val;}
                //: input/output
                //        friend   std::istream&    operator>> (std::istream& i, a_shape& s);
                void export_inliers(const std::vector<a_point>& pts);
                void export_outliers(const std::vector<a_point>& pts);
                void verbose(bool v) {verbose_=v;}
                virtual void init_dist() {}
                friend   std::ostream&    operator<< (std::ostream& o, const a_shape& s);
 
        protected:
                double P_; //probability to get a sample of 100% inliers (used to calculate the minimum number of RANSAC samples)
                vnl_vector<double> para_;
                bool verbose_;
};
 
#endif