#include "LaneDetector.hh"
#include "mcv.hh"
#include "InversePerspectiveMapping.hh"
#include "LaneDetectorOpt.h"
#include "ranker.h"
#include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <math.h>
#include <cv.h>
#include <highgui.h>

Include dependency graph for LaneDetector.cpp:

Namespaces
	LaneDetector

Macros
#define	LOCAL_MAX_IGNORE (int(MAX_IGNORE/4))

#define	MAX_IGNORE 0

#define	MCV_CUM_SUM(type)

#define	MCV_GET_NZ_POINTS(inMatType, outMatType)

#define	MCV_MAT_LOCAL_MAX(type)

#define	MCV_MAT_MAX(type)

#define	MCV_THRESHOLD_LOWER(type)

#define	MCV_VECTOR_LOCAL_MAX(type)

#define	MCV_VECTOR_MAX(type)

Functions
void	LaneDetector::dummy ()

CvPoint2D32f	LaneDetector::mcvAddVector (CvPoint2D32f v1, CvPoint2D32f v2)

void	LaneDetector::mcvBinarizeImage (CvMat *inImage)

void	LaneDetector::mcvCheckLaneWidth (vector< Line > &lines, vector< float > &scores, float wMu, float wSigma)
	This function takes a bunch of lines, and check which 2 lines can make a lane. More...

bool	LaneDetector::mcvCheckMergeLines (const Line &line1, const Line &line2, float thetaThreshold, float rThreshold)

bool	LaneDetector::mcvCheckMergeSplines (const Spline &sp1, const Spline &sp2, float thetaThreshold, float rThreshold, float meanThetaThreshold, float meanRThreshold, float centroidThreshold)

int	LaneDetector::mcvCheckPoints (const CvMat *points)

int	LaneDetector::mcvCheckSpline (const Spline &spline, float curvenessThreshold, float lengthThreshold, float thetaDiffThreshold, float thetaThreshold)

int	LaneDetector::mcvChooseBestPeak (const vector< CvPoint2D32f > &peaks, const vector< float > &peakVals, CvPoint2D32f &peak, float &peakVal, float contThreshold, const CvPoint2D32f &tangent, const CvPoint2D32f &prevPoint, float angleThreshold)

void	LaneDetector::mcvCumSum (const CvMat inMat, CvMat outMat)

void	LaneDetector::mcvDrawLine (CvMat *image, Line line, CvScalar color, int width)

void	LaneDetector::mcvDrawRectangle (CvMat *image, CvRect rect, CvScalar color, int width)

void	LaneDetector::mcvDrawSpline (CvMat *image, Spline spline, CvScalar color, int width)

void	LaneDetector::mcvDrawText (CvMat image, char str, CvPoint point, float size, CvScalar color)

CvMat *	LaneDetector::mcvEvalBezierSpline (const Spline &spline, float h, CvMat *tangents)

CvMat *	LaneDetector::mcvExtendPoints (const CvMat im, const CvMat inPoints, float angleThreshold, float meanDirAngleThreshold, int linePixelsTangent, int linePixelsNormal, float contThreshold, int deviationThreshold, CvRect bbox, bool smoothPeaks)

void	LaneDetector::mcvFilterLines (const CvMat inImage, CvMat outImage, unsigned char wx, unsigned char wy, FLOAT sigmax, FLOAT sigmay, LineType lineType)

Spline	LaneDetector::mcvFitBezierSpline (CvMat *points, int degree)

void	LaneDetector::mcvFitRansacLine (const CvMat image, int numSamples, int numIterations, float threshold, float scoreThreshold, int numGoodFit, bool getEndPoints, LineType lineType, Line lineXY, float lineRTheta, float lineScore)

void	LaneDetector::mcvFitRansacSpline (const CvMat image, int numSamples, int numIterations, float threshold, float scoreThreshold, int numGoodFit, int splineDegree, float h, Spline spline, float splineScore, int splineScoreJitter, float splineScoreLengthRatio, float splineScoreAngleRatio, float splineScoreStep, vector< Spline > prevSplines)

void	LaneDetector::mcvFitRobustLine (const CvMat points, float lineRTheta, float *lineAbc)

void	LaneDetector::mcvGet2DerivativeGaussianKernel (CvMat *kernel, unsigned char w, FLOAT sigma)

CvMat *	LaneDetector::mcvGetBezierSplinePixels (Spline &spline, float h, CvSize box, bool extendSpline)

Line	LaneDetector::mcvGetExtendedNormalLine (CvPoint2D32f &curPoint, CvPoint2D32f &tangent, int linePixelsTangent, int linePixelsNormal, CvPoint2D32f &nextPoint)

void	LaneDetector::mcvGetGaussianKernel (CvMat *kernel, unsigned char w, FLOAT sigma)

void	LaneDetector::mcvGetHoughTransformLines (const CvMat inImage, vector< Line > lines, vector< FLOAT > *lineScores, FLOAT rMin, FLOAT rMax, FLOAT rStep, FLOAT thetaMin, FLOAT thetaMax, FLOAT thetaStep, bool binarize, bool localMaxima, FLOAT detectionThreshold, bool smoothScores, bool group, FLOAT groupThreshold)

void	LaneDetector::mcvGetHVLines (const CvMat inImage, vector< Line > lines, vector< FLOAT > *lineScores, LineType lineType, FLOAT linePixelWidth, bool binarize, bool localMaxima, FLOAT detectionThreshold, bool smoothScores)

vector< int >	LaneDetector::mcvGetJitterVector (int maxJitter)

void	LaneDetector::mcvGetLanes (const CvMat inImage, const CvMat clrImage, vector< Line > lanes, vector< FLOAT > lineScores, vector< Spline > splines, vector< float > splineScores, CameraInfo cameraInfo, LaneDetectorConf stopLineConf, LineState *state)

float	LaneDetector::mcvGetLineAngle (const Line &line)

void	LaneDetector::mcvGetLineExtent (const CvMat *im, const Line &inLine, Line &outLine)

float	LaneDetector::mcvGetLinePeak (const CvMat *im, const Line &line, vector< CvPoint2D32f > &peaks, vector< float > &peakVals, bool positivePeak, bool smoothPeaks)

CvMat *	LaneDetector::mcvGetLinePixels (const Line &line)

void	LaneDetector::mcvGetLines (const CvMat image, LineType lineType, vector< Line > &lines, vector< float > &lineScores, vector< Spline > &splines, vector< float > &splineScores, LaneDetectorConf lineConf, LineState *state)

void	LaneDetector::mcvGetLinesBoundingBoxes (const vector< Line > &lines, LineType type, CvSize size, vector< CvRect > &boxes)
	This function extracts bounding boxes from lines. More...

double	LaneDetector::mcvGetLocalMaxSubPixel (double val1, double val2, double val3)

void	LaneDetector::mcvGetMatLocalMax (const CvMat *inMat, vector< double > &localMaxima, vector< CvPoint > &localMaximaLoc, double threshold)

void	LaneDetector::mcvGetMatMax (const CvMat *inMat, vector< double > &maxima, vector< CvPoint > &maximaLoc, double threshold)

CvMat *	LaneDetector::mcvGetNonZeroPoints (const CvMat *inMat, bool floatMat)

LineColor	LaneDetector::mcvGetPointsColor (const CvMat im, const CvMat points, int window, float numYellowMin, float rgMin, float rgMax, float gbMin, float rbMin, bool rbf, float rbfThreshold)

void	LaneDetector::mcvGetPointsFeatures (const CvMat points, CvPoint2D32f centroid, float theta, float r, float length, float meanTheta, float meanR, float curveness)

CvPoint2D32f	LaneDetector::mcvGetPointsMeanVector (const CvMat *points, bool forward)

FLOAT	LaneDetector::mcvGetQuantile (const CvMat *mat, FLOAT qtile)

void	LaneDetector::mcvGetRansacLines (const CvMat im, vector< Line > &lines, vector< float > &lineScores, LaneDetectorConf lineConf, LineType lineType)

void	LaneDetector::mcvGetRansacSplines (const CvMat im, vector< Line > &lines, vector< float > &lineScores, LaneDetectorConf lineConf, LineType lineType, vector< Spline > &splines, vector< float > &splineScores, LineState *state)

void	LaneDetector::mcvGetSplineFeatures (const Spline &spline, CvPoint2D32f centroid, float theta, float r, float length, float meanTheta, float meanR, float *curveness)

void	LaneDetector::mcvGetSplinesBoundingBoxes (const vector< Spline > &splines, LineType type, CvSize size, vector< CvRect > &boxes)
	This function extracts bounding boxes from splines. More...

float	LaneDetector::mcvGetSplineScore (const CvMat *image, Spline &spline, float h, int jitterVal, float lengthRatio, float angleRatio)

void	LaneDetector::mcvGetStopLines (const CvMat inImage, vector< Line > stopLines, vector< FLOAT > lineScores, const CameraInfo cameraInfo, LaneDetectorConf *stopLineConf)

void	LaneDetector::mcvGetVectorLocalMax (const CvMat *inVec, vector< double > &localMaxima, vector< int > &localMaximaLoc)

void	LaneDetector::mcvGetVectorMax (const CvMat inVector, double max, int *maxLoc, int ignore)

float	LaneDetector::mcvGetVectorNorm (const CvPoint2D32f &v)

void	LaneDetector::mcvGroupBoundingBoxes (vector< CvRect > &boxes, LineType type, float groupThreshold)
	This function groups together bounding boxes. More...

void	LaneDetector::mcvGroupLines (vector< Line > &lines, vector< float > &lineScores, float groupThreshold, CvSize bbox)

void	LaneDetector::mcvGroupSplines (vector< Spline > &splines, vector< float > &scores)

void	LaneDetector::mcvInitLaneDetectorConf (char const fileName, LaneDetectorConf stopLineConf)

void	LaneDetector::mcvIntersectLineRThetaWithBB (FLOAT r, FLOAT theta, const CvSize bbox, Line *outLine)

void	LaneDetector::mcvIntersectLineRThetaWithRect (FLOAT r, FLOAT theta, const Line &rect, Line &outLine)

void	LaneDetector::mcvIntersectLineWithBB (const Line inLine, const CvSize bbox, Line outLine)

bool	LaneDetector::mcvIsPointInside (FLOAT_POINT2D point, CvSize bbox)

bool	LaneDetector::mcvIsPointInside (FLOAT_POINT2D &point, const Line &rect)

bool	LaneDetector::mcvIsPointInside (FLOAT_POINT2D &point, const CvRect &rect)

bool	LaneDetector::mcvIsValidPeak (const CvPoint2D32f &peak, const CvPoint2D32f &tangent, const CvPoint2D32f &prevPoint, float angleThreshold)

void	LaneDetector::mcvLines2Mat (const vector< Line > lines, CvMat mat)

void	LaneDetector::mcvLinesImIPM2Im (vector< Line > &lines, IPMInfo &ipmInfo, CameraInfo &cameraInfo, CvSize imSize)

void	LaneDetector::mcvLineXY2RTheta (const Line &line, float &r, float &theta)

Spline	LaneDetector::mcvLineXY2Spline (const Line &line, int degree)

void	LaneDetector::mcvLocalizePoints (const CvMat im, const CvMat inPoints, CvMat *outPoints, int numLinePixels, float angleThreshold)

void	LaneDetector::mcvMat2Lines (const CvMat mat, vector< Line > lines)

void	LaneDetector::mcvMatInt2Float (const CvMat inMat, CvMat outMat)

CvPoint2D32f	LaneDetector::mcvMultiplyVector (CvPoint2D32f v, float s)

CvPoint2D32f	LaneDetector::mcvNormalizeVector (const CvPoint2D32f &v)

CvPoint2D32f	LaneDetector::mcvNormalizeVector (const CvPoint &v)

CvPoint2D32f	LaneDetector::mcvNormalizeVector (float x, float y)

void	LaneDetector::mcvPostprocessLines (const CvMat image, const CvMat clrImage, const CvMat rawipm, const CvMat fipm, vector< Line > &lines, vector< float > &lineScores, vector< Spline > &splines, vector< float > &splineScores, LaneDetectorConf lineConf, LineState state, IPMInfo &ipmInfo, CameraInfo &cameraInfo)

void	LaneDetector::mcvSampleWeighted (const CvMat cumSum, int numSamples, CvMat randInd, CvRNG *rng)

void	LaneDetector::mcvSetMat (CvMat *inMat, CvRect mask, double val)

void	LaneDetector::mcvSortPoints (const CvMat inPoints, CvMat outPoints, int dim, int dir)

void	LaneDetector::mcvSplinesImIPM2Im (vector< Spline > &splines, IPMInfo &ipmInfo, CameraInfo &cameraInfo, CvSize imSize)

CvPoint2D32f	LaneDetector::mcvSubtractVector (const CvPoint2D32f &v1, const CvPoint2D32f &v2)

void	LaneDetector::mcvThresholdLower (const CvMat inMat, CvMat outMat, FLOAT threshold)

void	LaneDetector::SHOW_LINE (const Line line, char str[])

void	LaneDetector::SHOW_SPLINE (const Spline spline, char str[])

Variables
int	LaneDetector::DEBUG_LINES = 0

Detailed Description

Author: Mohamed Aly malaa.nosp@m.@cal.nosp@m.tech..nosp@m.edu

Date: Thu 26 Jul, 2007

Definition in file LaneDetector.cpp.

Macro Definition Documentation

#define LOCAL_MAX_IGNORE (int(MAX_IGNORE/4))

#define MAX_IGNORE 0

#define MCV_CUM_SUM ( type )

Value:

/*row vector*/                                  \
    if(inMat->rows == 1)                                \
        for (int i=1; i<outMat->cols; i++)              \
            CV_MAT_ELEM(*outMat, type, 0, i) +=         \
                CV_MAT_ELEM(*outMat, type, 0, i-1);     \
    /*column vector*/                                   \
    else                                                \
        for (int i=1; i<outMat->rows; i++)              \
            CV_MAT_ELEM(*outMat, type, i, 0) +=         \
                CV_MAT_ELEM(*outMat, type, i-1, 0);

#define MCV_GET_NZ_POINTS	(	inMatType,
		outMatType
	)

Value:

/*loop and allocate the points*/ \
     for (int i=0; i<inMat->rows; i++) \
        for (int j=0; j<inMat->cols; j++) \
            if (CV_MAT_ELEM(*inMat, inMatType, i, j)) \
            { \
                CV_MAT_ELEM(*outMat, outMatType, 0, k) = j; \
                CV_MAT_ELEM(*outMat, outMatType, 1, k) = i; \
                CV_MAT_ELEM(*outMat, outMatType, 2, k) = \
                  (outMatType) CV_MAT_ELEM(*inMat, inMatType, i, j); \
                k++; \
            } \

#define MCV_MAT_LOCAL_MAX ( type )

#define MCV_MAT_MAX ( type )

Value:

/*loop on the matrix and get points that are larger than their*/ \
    /*neighboring 8 pixels*/ \
    for(int i=1; i<inMat->rows-1; i++) \
        for (int j=1; j<inMat->cols-1; j++) \
        { \
            /*get the current value*/ \
            val = CV_MAT_ELEM(*inMat, type, i, j); \
            /*check if it's larger than threshold*/ \
            if (val >= threshold) \
            { \
                /*found a maxima, put it in the return vector*/ \
                /*in decending order*/ \
                /*iterators for the two vectors*/ \
                vector<double>::iterator k; \
                vector<CvPoint>::iterator l; \
                /*loop till we find the place to put it in descendingly*/ \
                for(k=maxima.begin(), l=maximaLoc.begin(); \
                    k != maxima.end()  && val<= *k; k++,l++); \
                /*add its index*/ \
                maxima.insert(k, val); \
                maximaLoc.insert(l, cvPoint(j, i)); \
            } \
        }

#define MCV_THRESHOLD_LOWER ( type )

Value:

for (int i=0; i<inMat->height; i++) \
        for (int j=0; j<inMat->width; j++) \
            if ( CV_MAT_ELEM(*inMat, type, i, j)<threshold) \
                CV_MAT_ELEM(*outMat, type, i, j)=(type) 0; /*check it, was: threshold*/\

#define MCV_VECTOR_LOCAL_MAX ( type )

This function gets the local maxima in a vector and their positions

Parameters

inVec	input vector
localMaxima	the output vector of local maxima
localMaximaLoc	the vector of locations of the local maxima,

Definition at line 1108 of file LaneDetector.cpp.

#define MCV_VECTOR_MAX ( type )

This function gets the maximum value in a vector (row or column) and its location

Parameters

inVector	the input vector
max	the output max value
maxLoc	the location (index) of the first max

Definition at line 916 of file LaneDetector.cpp.

Namespaces

Macros

Functions

Variables

Detailed Description

Macro Definition Documentation