lineSegment.hpp

#ifndef LINE_SEGMENT
#define LINE_SEGMENT

#include <cmath>
#include <vector>

#include <image/Image.hpp>

#include "lines/histogram.hpp"
#include "lines/lsMisc.hpp"
#include "lines/lineSegmentSet.hpp"
#include "lines/lsPredictor2D.hpp"


namespace jafar{
  namespace lines{
    
    class LineSegmentSet;


    class LineSegment{
      public:

        LineSegment();
      

        LineSegment(int _numberOfNeighbours);
        
        LineSegment(const LineSegment& ls);
        
        ~LineSegment();
        

        static bool calcSupportingLine(double x1, double y1, double x2, double y2, double& alpha, double& y0);
        

        static bool calcEndpointsOfSupportingLine(double alpha, double y0, int height, int width, double& x1, double& y1, double& x2, double& y2);
        

        static double mahaDistLines(LineSegment &lA, LineSegment &lB, double varEP, double varDir, double varGrey, double varVGrey);
    

        void extractGreyscale(jafar::image::Image* image, int parallel_flag=0);
        

        void extractGradientscale(jafar::image::Image* image, int gradientimage, int parallel_flag=0);
        

        void extractLaplacescale(jafar::image::Image* image, int laplaceimage, int parallel_flag=0);
        

        void setPoints(double _x1, double _y1, double _x2, double _y2, bool resetFlag=1); 
        
        LineSegment& operator=(const LineSegment &ls);
        

        void setNumberOfNeighbours(int number);
        

        double assignContourPts(jafar::image::Image* image);
    

        void changePointOrder();
        

        void orientLine(jafar::image::Image* image);
    

        void calcHistogramDescriptor(jafar::image::Image* image,int nParallels=1, int d=3, jafar::image::Image* colorImage=0);
        

        void calcHistogramDescriptor();
        

        void normaliseHistogramDescriptor();


        void calcGreyspaceDescriptor(jafar::image::Image* image);
    

        static double compareGreyspace( std::vector<int>& greyA, std::vector<int>& greyB);
        

        static double compareAvLR(LineSegment& lsA, LineSegment& lsB);
        

        bool fitLine(jafar::image::Image* image, int gradientimage = 0, int nPoints=20, int pDist=25, jafar::image::Image* colorImage=0);
        

        int fitLineCandidates(jafar::image::Image* image, int gradientimage,std::vector<CvPoint>& startPts, std::vector<CvPoint>& endPts, int nPoints, int pDist, int nIter, jafar::image::Image* colorImage);
        

        bool fitLineOrientation(LineSegmentSet& lsSet, jafar::image::Image* gradX, jafar::image::Image* gradY, int nPoints=10, int pDist=25, double aDist=M_PI*0.5, double minLength=0, double extend=0, jafar::image::Image* colorImage=0);
      

        void searchGradMax(CvPoint p1, CvPoint p2, std::vector<CvPoint>& points, std::vector<double>& pointGrads, jafar::image::Image* gradX, jafar::image::Image* gradY, int nPoints, double pDist);
      

        void interpolateLineRansac(std::vector<LineSegment> lines, std::vector<CvPoint>& points, std::vector<double>& pointGrads, jafar::image::Image* gradX, jafar::image::Image* gradY, int nPoints, int nIt, double minInlierRate, double minLength, jafar::image::Image* colorImage);
      

        void interpolateLineGrowline(std::vector<LineSegment>& lines, std::vector<CvPoint>& points, std::vector<double>& pointGrads, jafar::image::Image* gradX, jafar::image::Image* gradY, int nPoints, double minLength,double aDist, jafar::image::Image* colorImage);
    

        static double chi2TestLocalPolarCOS(LineSegment &lsA, LineSegment &lsB, double* pDiffRho=0);

        

        static int tryMergeLinesChiSq(LineSegment &lA, LineSegment &lB, double maxGap=0);
        

        static void mergeLinesProb(LineSegment& lsA, LineSegment& lsB);
        

        static int mergeLinesEP(LineSegment& lsA, LineSegment& lsB);
        

        static double sizeOfGap(LineSegment& lsA, LineSegment& lsB);
        

        double getEPPredictionByRhoThetaPrediction(double x1Old, double y1Old, double x2Old, double y2Old, double& x1Pred, double& y1Pred, double& x2Pred, double& y2Pred);
        

        double getEPPrediction(double& _x1Pred, double& _y1Pred, double& _x2Pred, double& _y2Pred);

        

        bool growLineParallel(jafar::image::Image* image, int dist=3, int thresh=5, int distThresh=20);
        

        bool growLine( jafar::image::Image* image, int gapThresh=1, int thresh=40, int maxOffset=2);
    
        
        void drawLine(jafar::image::Image* image, CvScalar color, int width=1);
      
        unsigned int getId(){return id;}  
        double getX1(){return x1;}  
        double getY1(){return y1;}  
        double getX2(){return x2;}  
        double getY2(){return y2;}  
        double getMx(){return mx;}  
        double getMy(){return my;}  
        double getAlpha(){return alpha;}  
        double getOAlpha(){return oAlpha;}  
        double getEucLength(){return eucLength;}  
      
        bool isValid(){return validFlag;}   
        void setValid(){validFlag=1;}       
        void setInvalid(){validFlag=0;}     
      
        int length; 
      
        CvScalar color; 
    
        std::vector<int> greyscale;      
        std::vector<int> gradientscale;  
        std::vector<int> laplacescale;   
    
        int numberOfNeighbours;   
    
        LineSegment **parallels;  
      
        jafar::lines::Histogram* histogramB;    
        jafar::lines::Histogram* histogramD;    
      
      
        std::vector<int> greyspace;    
        std::vector<int> greyspaceL;   
        std::vector<int> greyspaceR;   
      
        double avL;   
        double avR;   
        double varL;  
        double varR;  
    
      // values for polar coordinates and covariance matrix for polar coordinates
        double polarD;      
        double polarAlpha;  
        double covDD;       
        double covAA;       
        double covAD;       
      
        double covXX;       
        double covXY;       
        double covYY;       
        double covAlpha;    
        double covXA;       
        double covYA;       
      
        double covXX_M;     
        double covXY_M;     
        double covYY_M;     
        double covXA_M;     
        double covYA_M;     
      
        double u;           
        double v;           
      
        uint id;    
      
        std::vector<std::vector<CvPoint> > contourPoints;   
        int param1;                   
        std::vector<int> parameters;  
      
        jafar::lines::LsPredictor2D predictor;  
      

        void setPredictionPolar(double rho, double theta, double covRR, double covRT, double covTT){
          rhoPred = rho;
          thetaPred = theta;
          covRRpred = covRR;
          covRTpred = covRT;
          covTTpred = covTT;
          predFlag = 1;

        }
        
        double rhoPred;     
        double thetaPred;   
        double covRRpred;   
        double covRTpred;   
        double covTTpred;   
        bool predFlag;      
        

        void setPrediction(double x1P, double y1P, double x2P, double y2P, double cov1xxP, double cov1xyP, double cov1yyP, double cov2xxP, double cov2xyP, double cov2yyP);
        

        
        double x1Pred;  
        double y1Pred;  
        double x2Pred;  
        double y2Pred;  
        double rangePred; 
        
      private:
        bool validFlag;
        double x1;      
        double y1;      
        double x2;      
        double y2;      
        double mx;      
        double my;      
        double slope;   
        double eucLength;   
        double alpha;   
        double oAlpha;  
    };
  } // namespace lines
} // namespace jafar
#endif