hough3d.hpp

#ifndef HOUGH_3D_HPP
#define HOUGH_3D_HPP



#include "model3d/point3D.hpp"
#include "model3d/plane3D.hpp"
#include "model3d/point3DVar.hpp"
#include "model3d/Image3D.hpp"

namespace jafar {
  namespace model3d {


    void extractMainPlane3dHought(std::vector<Point3D>* pPoints, 
                                  float fRhoMax,
                                  float rhoStep,
                                  float angleStep,
                                  Plane3D& plane3D);
    
    // extract N planes (in maximum) which have the bigger score in
    // the vote phase
    // N will return also the actual number of found planes
    void extractPlanes3dHought(std::vector<Point3D>* pPoints,
                               float fRhoMax,
                               float rhoStep,
                               float angleStep,
                               float fThresholdOfMaxVote,
                               float fMinDistanceOfTowPlane,
                               float fMinCosDihedralAngle,
                               int &N,
                               std::vector<Plane3D>& vPlane3D,
                               std::vector<Point3D>& vP1,
                               std::vector<Point3D>& vP2,
                               std::vector<Point3D>& vP3,
                               std::vector<Point3D>& vP4);
    
    // using a Progressive Probabilistic Hough Transformation to
    // extract N planes (in maximum) which have the bigger score in
    // the vote phase
    // N will return also the actual number of found planes
    void ProgressiveProbabHough(std::vector<Point3D>* pPoints,
                                float fRhoMax,
                                float rhoStep,
                                float angleStep,
                                float fThresholdOfMaxVote,
                                float fMinDistanceOfTowPlane,
                                float fMinCosDihedralAngle,
                                int &N,
                                int minPointNumberThreshold,
                                int minFinalVoteThreshold,
                                std::vector<Plane3D>& vPlane3D,
                                std::vector<Point3D>& vP1,
                                std::vector<Point3D>& vP2,
                                std::vector<Point3D>& vP3,
                                std::vector<Point3D>& vP4);
    
    
/*    void extractPointOfFloor(std::vector<Point3D>* pPoints,
                             std::list<int>* vOuterIndex,
                             std::list<int>* vInnerIndex,
                             Plane3D& plane3dFloor,
                             double delta);*/
    
    // for testing only
    void testing();

  } // namesopace model3d
} // namespace jafar


#endif // HOUGH_3D_HPP