Rect RotatedRect::boundingRect() const
{
Point2f pt[4];
points(pt);
Rect r(cvFloor(std::min(std::min(std::min(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
cvFloor(std::min(std::min(std::min(pt[0].y, pt[1].y), pt[2].y), pt[3].y)),
cvCeil(std::max(std::max(std::max(pt[0].x, pt[1].x), pt[2].x), pt[3].x)),
cvCeil(std::max(std::max(std::max(pt[0].y, pt[1].y), pt[2].y), pt[3].y)));
r.width -= r.x - 1;
r.height -= r.y - 1;
return r;
}
void AbstractTextureRenderer::init(const cv::Rect& imageRect)
{
m_textureWidth = cvCeil(imageRect.width / 512.0) * 512;
m_textureHeight = cvCeil(imageRect.height / 512.0) * 512;
m_textureData = new XuColorPixel[m_textureWidth * m_textureHeight];
glGenTextures(1, &m_textureID);
m_imageRect = imageRect;
m_isLocked = FALSE;
setupBatch();
}
// base for window size quantization, R orientation channels, and feature window size (_W, _W)
Objectness::Objectness(DataSetVOC &voc, double base, int W, int NSS)
: _voc(voc)
, _base(base)
, _W(W)
, _NSS(NSS)
, _logBase(log(_base))
, _minT(cvCeil(log(10.)/_logBase))
, _maxT(cvCeil(log(500.)/_logBase))
, _numT(_maxT - _minT + 1)
, _Clr(MAXBGR)
{
setColorSpace(_Clr);
}
cv::Mat
HsvExtractor::render(const arma::fmat& histogram) const {
int width = 512, height = 200; // size of the rendered image
cv::Mat image(height, width, CV_8UC3, cv::Scalar::all(0));
// background color
cv::rectangle(image, cv::Rect(0, 0, width, height), cv::Scalar(210, 210, 210), CV_FILLED);
int bins = histogram.size();
int binw = cvRound(static_cast<double>(width)/bins);
cv::Mat normalized;
normalize(arma2cv(histogram), normalized, 0, height, cv::NORM_MINMAX);
cv::MatConstIterator_<float> it = normalized.begin<float>(), end = normalized.end<float>();
for (int bin = 0; it < end; ++it, ++bin) {
int binh = cvCeil(*it);
if (binh == 0) continue;
cv::Rect rect(binw*bin, height - binh, binw, binh);
cv::rectangle(image, rect, colorLevel(bin, levels), CV_FILLED);
}
return image;
}
TheTest & test_float_math()
{
typedef typename V_RegTrait128<LaneType>::int_reg Ri;
Data<R> data1, data2, data3;
data1 *= 1.1;
data2 += 10;
R a1 = data1, a2 = data2, a3 = data3;
Data<Ri> resB = v_round(a1),
resC = v_trunc(a1),
resD = v_floor(a1),
resE = v_ceil(a1);
Data<R> resF = v_magnitude(a1, a2),
resG = v_sqr_magnitude(a1, a2),
resH = v_muladd(a1, a2, a3);
for (int i = 0; i < R::nlanes; ++i)
{
EXPECT_EQ(cvRound(data1[i]), resB[i]);
EXPECT_EQ((typename Ri::lane_type)data1[i], resC[i]);
EXPECT_EQ(cvFloor(data1[i]), resD[i]);
EXPECT_EQ(cvCeil(data1[i]), resE[i]);
EXPECT_COMPARE_EQ(std::sqrt(data1[i]*data1[i] + data2[i]*data2[i]), resF[i]);
EXPECT_COMPARE_EQ(data1[i]*data1[i] + data2[i]*data2[i], resG[i]);
EXPECT_COMPARE_EQ(data1[i]*data2[i] + data3[i], resH[i]);
}
return *this;
}
static void computeOrientation(const cv::Mat& image,
std::vector<cv::KeyPoint>& keypoints,
int halfPatchSize)
{
std::vector<int> umax(halfPatchSize + 2);
int v, v0, vmax = cvFloor(halfPatchSize * sqrt(2.f) / 2 + 1);
int vmin = cvCeil(halfPatchSize * sqrt(2.f) / 2);
for (v = 0; v <= vmax; ++v)
umax[v] = cvRound(sqrt((double)halfPatchSize * halfPatchSize - v * v));
// Make sure we are symmetric
for (v = halfPatchSize, v0 = 0; v >= vmin; --v)
{
while (umax[v0] == umax[v0 + 1])
++v0;
umax[v] = v0;
++v0;
}
// Process each keypoint
for (std::vector<cv::KeyPoint>::iterator keypoint = keypoints.begin(),
keypointEnd = keypoints.end(); keypoint != keypointEnd; ++keypoint)
{
keypoint->angle = IC_Angle(image, halfPatchSize, keypoint->pt, umax);
}
}
main( int argc, char* argv[] ) {
// Choose a negative floating point number. Take its absolute value,
// round it, and then take its ceiling and floor.
double a = -1.23;
printf( "CV_IABS(a) = %d\n", CV_IABS(a) );
printf( "cvRound(a) = %d\n", cvRound(a) );
printf( "cvCeil(a) = %d\n", cvCeil(a) );
printf( "cvFloor(a) = %d\n", cvFloor(a) );
// Generate some random numbers.
CvRNG rngState = cvRNG(-1);
for (int i = 0; i < 10; i++) {
printf( "%u %f\n", cvRandInt( &rngState ),
cvRandReal( &rngState ) );
}
// Create a floating point CvPoint2D32f and convert it to an integer
// CvPoint.
CvPoint2D32f point_float1 = cvPoint2D32f(1.0, 2.0);
CvPoint point_int1 = cvPointFrom32f( point_float1 );
// Convert a CvPoint to a CvPoint2D32f.
CvPoint point_int2 = cvPoint(3, 4);
CvPoint2D32f point_float2 = cvPointTo32f( point_int2 );
}
const vector<int> Index::createUMax()
{
int patchSize = ROTATION_PATCH_SIZE;
// Make sure we forget about what is too close to the boundary
//edge_threshold_ = std::max(edge_threshold_, patch_size_/2 + kKernelWidth / 2 + 2);
// pre-compute the end of a row in a circular patch
int halfPatchSize = patchSize / 2;
vector<int> u_max(halfPatchSize + 2);
int v, v0, vmax = cvFloor(halfPatchSize * sqrt(2.f) / 2 + 1);
int vmin = cvCeil(halfPatchSize * sqrt(2.f) / 2);
for (v = 0; v <= vmax; ++v)
u_max[v] = cvRound(sqrt((double)halfPatchSize * halfPatchSize - v * v));
// Make sure we are symmetric
for (v = halfPatchSize, v0 = 0; v >= vmin; --v)
{
while (u_max[v0] == u_max[v0 + 1])
++v0;
u_max[v] = v0;
++v0;
}
return u_max;
}
void operator()(const Range& range) const
{
int i, i1 = range.start, i2 = range.end;
double minScale = i1 > 0 ? levelScale[i1] : i2 > 1 ? levelScale[i1+1] : std::max(img.cols, img.rows);
Size maxSz(cvCeil(img.cols/minScale), cvCeil(img.rows/minScale));
Mat smallerImgBuf(maxSz, img.type());
vector<Point> locations;
vector<double> hitsWeights;
for( i = i1; i < i2; i++ )
{
double scale = levelScale[i];
Size sz(cvRound(img.cols/scale), cvRound(img.rows/scale));
Mat smallerImg(sz, img.type(), smallerImgBuf.data);
if( sz == img.size() )
smallerImg = Mat(sz, img.type(), img.data, img.step);
else
resize(img, smallerImg, sz);
hog->detect(smallerImg, locations, hitsWeights, hitThreshold, winStride, padding);
Size scaledWinSize = Size(cvRound(hog->winSize.width*scale), cvRound(hog->winSize.height*scale));
mtx->lock();
for( size_t j = 0; j < locations.size(); j++ )
{
rec->push_back(Rect(cvRound(locations[j].x*scale),
cvRound(locations[j].y*scale),
scaledWinSize.width, scaledWinSize.height));
if (scales)
{
scales->push_back(scale);
}
}
mtx->unlock();
if (weights && (!hitsWeights.empty()))
{
mtx->lock();
for (size_t j = 0; j < locations.size(); j++)
{
weights->push_back(hitsWeights[j]);
}
mtx->unlock();
}
}
}
Mat InversePerspectiveMapper::MapInversePerspectiveFromVanishingPoint(const Mat &image, const Point2f &vanishingPoint)
{
float abstand = abs(vanishingPoint.y - (image.rows / 2.0f));
float focalLength = 575;
float alphaKlein = 23 * CV_PI_F / 180;
float alphaGross = 29 * CV_PI_F / 180;
float cameraTilt = atan(abstand / focalLength);
float remainingHeight = image.rows - cvRound(vanishingPoint.y);
float xDistance = cvCeil(image.cols / 3.0f);
float yDistance = cvCeil(remainingHeight / 3.0f);
pair<vector<cv::Point2f>, vector<cv::Point2f> > sourceDestinationPairs;
for (int i = 0; i < 2; i++)
{
for (int j = 0; j < 2; j++)
{
float x = xDistance + i * xDistance;
float y = vanishingPoint.y + yDistance + j * yDistance;
float u = 22 * HTWKMath::cotf((cameraTilt - alphaKlein) + y * (2 * alphaKlein / (image.rows - 1))) *
sinf(-alphaGross + x * (2 * alphaGross / (image.cols - 1))) - 3;
float v = 22 * HTWKMath::cotf((cameraTilt - alphaKlein) + y * (2 * alphaKlein / (image.rows - 1))) *
cosf(-alphaGross + x * (2 * alphaGross / (image.cols - 1))) - 50;
// set from 50 to 55 remove hood for car 20 after crash
// Moved coordinates to IPM
u = u + 150;
v = 200 - v;
sourceDestinationPairs.first.push_back(Point2f(x, y));
sourceDestinationPairs.second.push_back(Point2f(u, v));
}
}
Mat lambda = getPerspectiveTransform(sourceDestinationPairs.first, sourceDestinationPairs.second);
Mat output(200, 300, CV_8UC1, CV_RGB(0, 0, 0));
warpPerspective(image, output, lambda, output.size(), INTER_LINEAR, BORDER_CONSTANT, CV_RGB(5, 5, 5));
return output.clone();
}
/*
Finds the element of a specified rank in an array using the linear time
median-of-medians algorithm by Blum, Floyd, Pratt, Rivest, and Tarjan.
The elements of the array are re-ordered by this function.
@param array an array; the order of its elelemts is reordered
@param n number of elements in array
@param r the zero-based rank of the element to be selected
@return Returns the element from array with zero-based rank r.
*/
double rank_select( double* array, int n, int r )
{
double* tmp, med;
int gr_5, gr_tot, rem_elts, i, j;
/* base case */
if( n == 1 )
return array[0];
/* divide array into groups of 5 and sort them */
gr_5 = n / 5;
gr_tot = cvCeil( n / 5.0 );
rem_elts = n % 5;
tmp = array;
for( i = 0; i < gr_5; i++ )
{
insertion_sort( tmp, 5 );
tmp += 5;
}
insertion_sort( tmp, rem_elts );
/* recursively find the median of the medians of the groups of 5 */
tmp = calloc( gr_tot, sizeof( double ) );
for( i = 0, j = 2; i < gr_5; i++, j += 5 )
tmp[i] = array[j];
if( rem_elts )
tmp[i++] = array[n - 1 - rem_elts/2];
med = rank_select( tmp, i, ( i - 1 ) / 2 );
free( tmp );
/* partition around median of medians and recursively select if necessary */
j = partition_array( array, n, med );
if( r == j )
return med;
else if( r < j )
return rank_select( array, j, r );
else
{
array += j+1;
return rank_select( array, ( n - j - 1 ), ( r - j - 1 ) );
}
}
void SimplestCB(Mat& in, Mat& out, float percent) {
assert(in.channels() == 3);
assert(percent > 0 && percent < 100);
float half_percent = percent / 200.0f;
vector<Mat> tmpsplit; split(in,tmpsplit);
for(int i=0;i<3;i++) {
//find the low and high precentile values (based on the input percentile)
Mat flat; tmpsplit[i].reshape(1,1).copyTo(flat);
cv::sort(flat,flat,CV_SORT_EVERY_ROW + CV_SORT_ASCENDING);
int lowval = flat.at<uchar>(cvFloor(((float)flat.cols) * half_percent));
int highval = flat.at<uchar>(cvCeil(((float)flat.cols) * (1.0 - half_percent)));
cout << lowval << " " << highval << endl;
//saturate below the low percentile and above the high percentile
tmpsplit[i].setTo(lowval,tmpsplit[i] < lowval);
tmpsplit[i].setTo(highval,tmpsplit[i] > highval);
//scale the channel
normalize(tmpsplit[i],tmpsplit[i],0,255,NORM_MINMAX);
}
merge(tmpsplit,out);
}
/* cvDetectNewBlobs
* Return 1 and fill blob pNewBlob with
* blob parameters if new blob is detected:
*/
int CvBlobDetectorCC::DetectNewBlob(IplImage* /*pImg*/, IplImage* pFGMask, CvBlobSeq* pNewBlobList, CvBlobSeq* pOldBlobList)
{
int result = 0;
CvSize S = cvSize(pFGMask->width,pFGMask->height);
/* Shift blob list: */
{
int i;
if(m_pBlobLists[SEQ_SIZE-1]) delete m_pBlobLists[SEQ_SIZE-1];
for(i=SEQ_SIZE-1; i>0; --i) m_pBlobLists[i] = m_pBlobLists[i-1];
m_pBlobLists[0] = new CvBlobSeq;
} /* Shift blob list. */
/* Create contours and add new blobs to blob list: */
{ /* Create blobs: */
CvBlobSeq Blobs;
CvMemStorage* storage = cvCreateMemStorage();
if(m_Clastering)
{ /* Glue contours: */
cvFindBlobsByCCClasters(pFGMask, &Blobs, storage );
} /* Glue contours. */
else
{ /**/
IplImage* pIB = cvCloneImage(pFGMask);
CvSeq* cnts = NULL;
CvSeq* cnt = NULL;
cvThreshold(pIB,pIB,128,255,CV_THRESH_BINARY);
cvFindContours(pIB,storage, &cnts, sizeof(CvContour), CV_RETR_EXTERNAL);
/* Process each contour: */
for(cnt = cnts; cnt; cnt=cnt->h_next)
{
CvBlob NewBlob;
/* Image moments: */
double M00,X,Y,XX,YY;
CvMoments m;
CvRect r = ((CvContour*)cnt)->rect;
CvMat mat;
if(r.height < S.height*m_HMin || r.width < S.width*m_WMin) continue;
cvMoments( cvGetSubRect(pFGMask,&mat,r), &m, 0 );
M00 = cvGetSpatialMoment( &m, 0, 0 );
if(M00 <= 0 ) continue;
X = cvGetSpatialMoment( &m, 1, 0 )/M00;
Y = cvGetSpatialMoment( &m, 0, 1 )/M00;
XX = (cvGetSpatialMoment( &m, 2, 0 )/M00) - X*X;
YY = (cvGetSpatialMoment( &m, 0, 2 )/M00) - Y*Y;
NewBlob = cvBlob(r.x+(float)X,r.y+(float)Y,(float)(4*sqrt(XX)),(float)(4*sqrt(YY)));
Blobs.AddBlob(&NewBlob);
} /* Next contour. */
cvReleaseImage(&pIB);
} /* One contour - one blob. */
{ /* Delete small and intersected blobs: */
int i;
for(i=Blobs.GetBlobNum(); i>0; i--)
{
CvBlob* pB = Blobs.GetBlob(i-1);
if(pB->h < S.height*m_HMin || pB->w < S.width*m_WMin)
{
Blobs.DelBlob(i-1);
continue;
}
if(pOldBlobList)
{
int j;
for(j=pOldBlobList->GetBlobNum(); j>0; j--)
{
CvBlob* pBOld = pOldBlobList->GetBlob(j-1);
if((fabs(pBOld->x-pB->x) < (CV_BLOB_RX(pBOld)+CV_BLOB_RX(pB))) &&
(fabs(pBOld->y-pB->y) < (CV_BLOB_RY(pBOld)+CV_BLOB_RY(pB))))
{ /* Intersection detected, delete blob from list: */
Blobs.DelBlob(i-1);
break;
}
} /* Check next old blob. */
} /* if pOldBlobList. */
} /* Check next blob. */
} /* Delete small and intersected blobs. */
{ /* Bubble-sort blobs by size: */
int N = Blobs.GetBlobNum();
int i,j;
for(i=1; i<N; ++i)
{
for(j=i; j>0; --j)
{
CvBlob temp;
float AreaP, AreaN;
CvBlob* pP = Blobs.GetBlob(j-1);
CvBlob* pN = Blobs.GetBlob(j);
AreaP = CV_BLOB_WX(pP)*CV_BLOB_WY(pP);
AreaN = CV_BLOB_WX(pN)*CV_BLOB_WY(pN);
if(AreaN < AreaP)break;
temp = pN[0];
pN[0] = pP[0];
pP[0] = temp;
}
}
/* Copy only first 10 blobs: */
for(i=0; i<MIN(N,10); ++i)
{
m_pBlobLists[0]->AddBlob(Blobs.GetBlob(i));
}
} /* Sort blobs by size. */
cvReleaseMemStorage(&storage);
} /* Create blobs. */
{ /* Shift each track: */
int j;
for(j=0; j<m_TrackNum; ++j)
{
int i;
DefSeq* pTrack = m_TrackSeq+j;
for(i=SEQ_SIZE-1; i>0; --i)
pTrack->pBlobs[i] = pTrack->pBlobs[i-1];
pTrack->pBlobs[0] = NULL;
if(pTrack->size == SEQ_SIZE)pTrack->size--;
}
} /* Shift each track. */
/* Analyze blob list to find best blob trajectory: */
{
double BestError = -1;
int BestTrack = -1;;
CvBlobSeq* pNewBlobs = m_pBlobLists[0];
int i;
int NewTrackNum = 0;
for(i=pNewBlobs->GetBlobNum(); i>0; --i)
{
CvBlob* pBNew = pNewBlobs->GetBlob(i-1);
int j;
int AsignedTrack = 0;
for(j=0; j<m_TrackNum; ++j)
{
double dx,dy;
DefSeq* pTrack = m_TrackSeq+j;
CvBlob* pLastBlob = pTrack->size>0?pTrack->pBlobs[1]:NULL;
if(pLastBlob == NULL) continue;
dx = fabs(CV_BLOB_X(pLastBlob)-CV_BLOB_X(pBNew));
dy = fabs(CV_BLOB_Y(pLastBlob)-CV_BLOB_Y(pBNew));
if(dx > 2*CV_BLOB_WX(pLastBlob) || dy > 2*CV_BLOB_WY(pLastBlob)) continue;
AsignedTrack++;
if(pTrack->pBlobs[0]==NULL)
{ /* Fill existed track: */
pTrack->pBlobs[0] = pBNew;
pTrack->size++;
}
else if((m_TrackNum+NewTrackNum)<SEQ_NUM)
{ /* Duplicate existed track: */
m_TrackSeq[m_TrackNum+NewTrackNum] = pTrack[0];
m_TrackSeq[m_TrackNum+NewTrackNum].pBlobs[0] = pBNew;
NewTrackNum++;
}
} /* Next track. */
if(AsignedTrack==0 && (m_TrackNum+NewTrackNum)<SEQ_NUM )
{ /* Initialize new track: */
m_TrackSeq[m_TrackNum+NewTrackNum].size = 1;
m_TrackSeq[m_TrackNum+NewTrackNum].pBlobs[0] = pBNew;
NewTrackNum++;
}
} /* Next new blob. */
m_TrackNum += NewTrackNum;
/* Check each track: */
for(i=0; i<m_TrackNum; ++i)
{
int Good = 1;
DefSeq* pTrack = m_TrackSeq+i;
CvBlob* pBNew = pTrack->pBlobs[0];
if(pTrack->size != SEQ_SIZE) continue;
if(pBNew == NULL ) continue;
/* Check intersection last blob with existed: */
if(Good && pOldBlobList)
{
int k;
for(k=pOldBlobList->GetBlobNum(); k>0; --k)
{
CvBlob* pBOld = pOldBlobList->GetBlob(k-1);
if((fabs(pBOld->x-pBNew->x) < (CV_BLOB_RX(pBOld)+CV_BLOB_RX(pBNew))) &&
(fabs(pBOld->y-pBNew->y) < (CV_BLOB_RY(pBOld)+CV_BLOB_RY(pBNew))))
Good = 0;
}
} /* Check intersection last blob with existed. */
/* Check distance to image border: */
if(Good)
{ /* Check distance to image border: */
float dx = MIN(pBNew->x,S.width-pBNew->x)/CV_BLOB_RX(pBNew);
float dy = MIN(pBNew->y,S.height-pBNew->y)/CV_BLOB_RY(pBNew);
if(dx < m_MinDistToBorder || dy < m_MinDistToBorder) Good = 0;
} /* Check distance to image border. */
/* Check uniform motion: */
if(Good)
{ /* Check uniform motion: */
double Error = 0;
int N = pTrack->size;
CvBlob** pBL = pTrack->pBlobs;
float sum[2] = {0,0};
float jsum[2] = {0,0};
float a[2],b[2]; /* estimated parameters of moving x(t) = a*t+b*/
int j;
for(j=0; j<N; ++j)
{
float x = pBL[j]->x;
float y = pBL[j]->y;
sum[0] += x;
jsum[0] += j*x;
sum[1] += y;
jsum[1] += j*y;
}
a[0] = 6*((1-N)*sum[0]+2*jsum[0])/(N*(N*N-1));
b[0] = -2*((1-2*N)*sum[0]+3*jsum[0])/(N*(N+1));
a[1] = 6*((1-N)*sum[1]+2*jsum[1])/(N*(N*N-1));
b[1] = -2*((1-2*N)*sum[1]+3*jsum[1])/(N*(N+1));
for(j=0; j<N; ++j)
{
Error +=
pow(a[0]*j+b[0]-pBL[j]->x,2)+
pow(a[1]*j+b[1]-pBL[j]->y,2);
}
Error = sqrt(Error/N);
if( Error > S.width*0.01 ||
fabs(a[0])>S.width*0.1 ||
fabs(a[1])>S.height*0.1)
Good = 0;
/* New best trajectory: */
if(Good && (BestError == -1 || BestError > Error))
{ /* New best trajectory: */
BestTrack = i;
BestError = Error;
} /* New best trajectory. */
} /* Check uniform motion. */
} /* Next track. */
#if 0
{ /**/
printf("BlobDetector configurations = %d [",m_TrackNum);
int i;
for(i=0; i<SEQ_SIZE; ++i)
{
printf("%d,",m_pBlobLists[i]?m_pBlobLists[i]->GetBlobNum():0);
}
printf("]\n");
}
#endif
if(BestTrack >= 0)
{ /* Put new blob to output and delete from blob list: */
assert(m_TrackSeq[BestTrack].size == SEQ_SIZE);
assert(m_TrackSeq[BestTrack].pBlobs[0]);
pNewBlobList->AddBlob(m_TrackSeq[BestTrack].pBlobs[0]);
m_TrackSeq[BestTrack].pBlobs[0] = NULL;
m_TrackSeq[BestTrack].size--;
result = 1;
} /* Put new blob to output and mark in blob list to delete. */
} /* Analyze blod list to find best blob trajectory. */
{ /* Delete bad tracks: */
int i;
for(i=m_TrackNum-1; i>=0; --i)
{ /* Delete bad tracks: */
if(m_TrackSeq[i].pBlobs[0]) continue;
if(m_TrackNum>0)
m_TrackSeq[i] = m_TrackSeq[--m_TrackNum];
} /* Delete bad tracks: */
}
#ifdef USE_OBJECT_DETECTOR
if( m_split_detector && pNewBlobList->GetBlobNum() > 0 )
{
int num_new_blobs = pNewBlobList->GetBlobNum();
int i = 0;
if( m_roi_seq ) cvClearSeq( m_roi_seq );
m_debug_blob_seq.Clear();
for( i = 0; i < num_new_blobs; ++i )
{
CvBlob* b = pNewBlobList->GetBlob(i);
CvMat roi_stub;
CvMat* roi_mat = 0;
CvMat* scaled_roi_mat = 0;
CvDetectedBlob d_b = cvDetectedBlob( CV_BLOB_X(b), CV_BLOB_Y(b), CV_BLOB_WX(b), CV_BLOB_WY(b), 0 );
m_debug_blob_seq.AddBlob(&d_b);
float scale = m_param_roi_scale * m_min_window_size.height / CV_BLOB_WY(b);
float b_width = MAX(CV_BLOB_WX(b), m_min_window_size.width / scale)
+ (m_param_roi_scale - 1.0F) * (m_min_window_size.width / scale)
+ 2.0F * m_max_border / scale;
float b_height = CV_BLOB_WY(b) * m_param_roi_scale + 2.0F * m_max_border / scale;
CvRect roi = cvRectIntersection( cvRect( cvFloor(CV_BLOB_X(b) - 0.5F*b_width),
cvFloor(CV_BLOB_Y(b) - 0.5F*b_height),
cvCeil(b_width), cvCeil(b_height) ),
cvRect( 0, 0, pImg->width, pImg->height ) );
if( roi.width <= 0 || roi.height <= 0 )
continue;
if( m_roi_seq ) cvSeqPush( m_roi_seq, &roi );
roi_mat = cvGetSubRect( pImg, &roi_stub, roi );
scaled_roi_mat = cvCreateMat( cvCeil(scale*roi.height), cvCeil(scale*roi.width), CV_8UC3 );
cvResize( roi_mat, scaled_roi_mat );
m_detected_blob_seq.Clear();
m_split_detector->Detect( scaled_roi_mat, &m_detected_blob_seq );
cvReleaseMat( &scaled_roi_mat );
for( int k = 0; k < m_detected_blob_seq.GetBlobNum(); ++k )
{
CvDetectedBlob* b = (CvDetectedBlob*) m_detected_blob_seq.GetBlob(k);
/* scale and shift each detected blob back to the original image coordinates */
CV_BLOB_X(b) = CV_BLOB_X(b) / scale + roi.x;
CV_BLOB_Y(b) = CV_BLOB_Y(b) / scale + roi.y;
CV_BLOB_WX(b) /= scale;
CV_BLOB_WY(b) /= scale;
CvDetectedBlob d_b = cvDetectedBlob( CV_BLOB_X(b), CV_BLOB_Y(b), CV_BLOB_WX(b), CV_BLOB_WY(b), 1,
b->response );
m_debug_blob_seq.AddBlob(&d_b);
}
if( m_detected_blob_seq.GetBlobNum() > 1 )
{
/*
* Split blob.
* The original blob is replaced by the first detected blob,
* remaining detected blobs are added to the end of the sequence:
*/
CvBlob* first_b = m_detected_blob_seq.GetBlob(0);
CV_BLOB_X(b) = CV_BLOB_X(first_b); CV_BLOB_Y(b) = CV_BLOB_Y(first_b);
CV_BLOB_WX(b) = CV_BLOB_WX(first_b); CV_BLOB_WY(b) = CV_BLOB_WY(first_b);
for( int j = 1; j < m_detected_blob_seq.GetBlobNum(); ++j )
{
CvBlob* detected_b = m_detected_blob_seq.GetBlob(j);
pNewBlobList->AddBlob(detected_b);
}
}
} /* For each new blob. */
for( i = 0; i < pNewBlobList->GetBlobNum(); ++i )
{
CvBlob* b = pNewBlobList->GetBlob(i);
CvDetectedBlob d_b = cvDetectedBlob( CV_BLOB_X(b), CV_BLOB_Y(b), CV_BLOB_WX(b), CV_BLOB_WY(b), 2 );
m_debug_blob_seq.AddBlob(&d_b);
}
} // if( m_split_detector )
#endif
return result;
} /* cvDetectNewBlob */
void MultiLayerBGS::process(const cv::Mat &img_input, cv::Mat &img_output, cv::Mat &img_bgmodel)
{
if (img_input.empty())
return;
loadConfig();
CvSize img_size = cvSize(cvCeil((double)img_input.size().width), cvCeil((double)img_input.size().height));
if (firstTime)
{
if (disableDetectMode)
status = MLBGS_LEARN;
if (status == MLBGS_LEARN)
std::cout << "MultiLayerBGS in LEARN mode" << std::endl;
if (status == MLBGS_DETECT)
std::cout << "MultiLayerBGS in DETECT mode" << std::endl;
org_img = new IplImage(img_input);
fg_img = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
bg_img = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
fg_prob_img = cvCreateImage(img_size, org_img->depth, 1);
fg_mask_img = cvCreateImage(img_size, org_img->depth, 1);
fg_prob_img3 = cvCreateImage(img_size, org_img->depth, org_img->nChannels);
merged_img = cvCreateImage(cvSize(img_size.width * 2, img_size.height * 2), org_img->depth, org_img->nChannels);
BGS = new CMultiLayerBGS();
BGS->Init(img_size.width, img_size.height);
BGS->SetForegroundMaskImage(fg_mask_img);
BGS->SetForegroundProbImage(fg_prob_img);
if (bg_model_preload.empty() == false)
{
std::cout << "MultiLayerBGS loading background model: " << bg_model_preload << std::endl;
BGS->Load(bg_model_preload.c_str());
}
if (status == MLBGS_DETECT)
{
BGS->m_disableLearning = disableLearning;
if (disableLearning)
std::cout << "MultiLayerBGS disabled learning in DETECT mode" << std::endl;
else
std::cout << "MultiLayerBGS enabled learning in DETECT mode" << std::endl;
}
if (loadDefaultParams)
{
std::cout << "MultiLayerBGS loading default params" << std::endl;
max_mode_num = 5;
weight_updating_constant = 5.0;
texture_weight = 0.5;
bg_mode_percent = 0.6f;
pattern_neig_half_size = 4;
pattern_neig_gaus_sigma = 3.0f;
bg_prob_threshold = 0.2f;
bg_prob_updating_threshold = 0.2f;
robust_LBP_constant = 3;
min_noised_angle = 10.0 / 180.0 * PI; //0,01768
shadow_rate = 0.6f;
highlight_rate = 1.2f;
bilater_filter_sigma_s = 3.0f;
bilater_filter_sigma_r = 0.1f;
}
else
std::cout << "MultiLayerBGS loading config params" << std::endl;
BGS->m_nMaxLBPModeNum = max_mode_num;
BGS->m_fWeightUpdatingConstant = weight_updating_constant;
BGS->m_fTextureWeight = texture_weight;
BGS->m_fBackgroundModelPercent = bg_mode_percent;
BGS->m_nPatternDistSmoothNeigHalfSize = pattern_neig_half_size;
BGS->m_fPatternDistConvGaussianSigma = pattern_neig_gaus_sigma;
BGS->m_fPatternColorDistBgThreshold = bg_prob_threshold;
BGS->m_fPatternColorDistBgUpdatedThreshold = bg_prob_updating_threshold;
BGS->m_fRobustColorOffset = robust_LBP_constant;
BGS->m_fMinNoisedAngle = min_noised_angle;
BGS->m_fRobustShadowRate = shadow_rate;
BGS->m_fRobustHighlightRate = highlight_rate;
BGS->m_fSigmaS = bilater_filter_sigma_s;
BGS->m_fSigmaR = bilater_filter_sigma_r;
if (loadDefaultParams)
{
//frame_duration = 1.0 / 30.0;
//frame_duration = 1.0 / 25.0;
frame_duration = 1.0f / 10.0f;
}
BGS->SetFrameRate(frame_duration);
if (status == MLBGS_LEARN)
{
if (loadDefaultParams)
{
mode_learn_rate_per_second = 0.5;
weight_learn_rate_per_second = 0.5;
init_mode_weight = 0.05f;
}
else
{
mode_learn_rate_per_second = learn_mode_learn_rate_per_second;
weight_learn_rate_per_second = learn_weight_learn_rate_per_second;
init_mode_weight = learn_init_mode_weight;
}
}
if (status == MLBGS_DETECT)
{
if (loadDefaultParams)
{
mode_learn_rate_per_second = 0.01f;
weight_learn_rate_per_second = 0.01f;
init_mode_weight = 0.001f;
}
else
{
mode_learn_rate_per_second = detect_mode_learn_rate_per_second;
weight_learn_rate_per_second = detect_weight_learn_rate_per_second;
init_mode_weight = detect_init_mode_weight;
}
}
BGS->SetParameters(max_mode_num, mode_learn_rate_per_second, weight_learn_rate_per_second, init_mode_weight);
saveConfig();
delete org_img;
}
//IplImage* inputImage = new IplImage(img_input);
//IplImage* img = cvCreateImage(img_size, IPL_DEPTH_8U, 3);
//cvCopy(inputImage, img);
//delete inputImage;
if (detectAfter > 0 && detectAfter == frameNumber)
{
std::cout << "MultiLayerBGS in DETECT mode" << std::endl;
status = MLBGS_DETECT;
mode_learn_rate_per_second = 0.01f;
weight_learn_rate_per_second = 0.01f;
init_mode_weight = 0.001f;
BGS->SetParameters(max_mode_num, mode_learn_rate_per_second, weight_learn_rate_per_second, init_mode_weight);
BGS->m_disableLearning = disableLearning;
if (disableLearning)
std::cout << "MultiLayerBGS disabled learning in DETECT mode" << std::endl;
else
std::cout << "MultiLayerBGS enabled learning in DETECT mode" << std::endl;
}
IplImage* img = new IplImage(img_input);
BGS->SetRGBInputImage(img);
BGS->Process();
BGS->GetBackgroundImage(bg_img);
BGS->GetForegroundImage(fg_img);
BGS->GetForegroundProbabilityImage(fg_prob_img3);
BGS->GetForegroundMaskImage(fg_mask_img);
BGS->MergeImages(4, img, bg_img, fg_prob_img3, fg_img, merged_img);
img_merged = cv::Mat(merged_img);
img_foreground = cv::Mat(fg_mask_img);
img_background = cv::Mat(bg_img);
if (showOutput)
{
//cv::imshow("MLBGS Layers", img_merged);
// cv::imshow("MLBGS FG Mask", img_foreground);
}
img_foreground.copyTo(img_output);
img_background.copyTo(img_bgmodel);
delete img;
//cvReleaseImage(&img);
firstTime = false;
frameNumber++;
}
void cvShowVecSamples( const char* filename, int winwidth, int winheight,
double scale )
{
CvVecFile file;
short tmp;
int i;
CvMat* sample;
tmp = 0;
file.input = fopen( filename, "rb" );
if( file.input != NULL )
{
size_t elements_read1 = fread( &file.count, sizeof( file.count ), 1, file.input );
size_t elements_read2 = fread( &file.vecsize, sizeof( file.vecsize ), 1, file.input );
size_t elements_read3 = fread( &tmp, sizeof( tmp ), 1, file.input );
size_t elements_read4 = fread( &tmp, sizeof( tmp ), 1, file.input );
CV_Assert(elements_read1 == 1 && elements_read2 == 1 && elements_read3 == 1 && elements_read4 == 1);
if( file.vecsize != winwidth * winheight )
{
int guessed_w = 0;
int guessed_h = 0;
fprintf( stderr, "Warning: specified sample width=%d and height=%d "
"does not correspond to .vec file vector size=%d.\n",
winwidth, winheight, file.vecsize );
if( file.vecsize > 0 )
{
guessed_w = cvFloor( sqrt( (float) file.vecsize ) );
if( guessed_w > 0 )
{
guessed_h = file.vecsize / guessed_w;
}
}
if( guessed_w <= 0 || guessed_h <= 0 || guessed_w * guessed_h != file.vecsize)
{
fprintf( stderr, "Error: failed to guess sample width and height\n" );
fclose( file.input );
return;
}
else
{
winwidth = guessed_w;
winheight = guessed_h;
fprintf( stderr, "Guessed width=%d, guessed height=%d\n",
winwidth, winheight );
}
}
if( !feof( file.input ) && scale > 0 )
{
CvMat* scaled_sample = 0;
file.last = 0;
file.vector = (short*) cvAlloc( sizeof( *file.vector ) * file.vecsize );
sample = scaled_sample = cvCreateMat( winheight, winwidth, CV_8UC1 );
if( scale != 1.0 )
{
scaled_sample = cvCreateMat( MAX( 1, cvCeil( scale * winheight ) ),
MAX( 1, cvCeil( scale * winwidth ) ),
CV_8UC1 );
}
cvNamedWindow( "Sample", CV_WINDOW_AUTOSIZE );
for( i = 0; i < file.count; i++ )
{
icvGetHaarTraininDataFromVecCallback( sample, &file );
if( scale != 1.0 ) cvResize( sample, scaled_sample, CV_INTER_LINEAR);
cvShowImage( "Sample", scaled_sample );
if( cvWaitKey( 0 ) == 27 ) break;
}
if( scaled_sample && scaled_sample != sample ) cvReleaseMat( &scaled_sample );
cvReleaseMat( &sample );
cvFree( &file.vector );
}
fclose( file.input );
}
}
//2D tracker
int voteForSizeAndOrientation(std::vector<cv::KeyPoint>* modelKeyPoints, std::vector<cv::KeyPoint>* observedKeyPoints, std::vector< std::vector< cv::DMatch > >* matches, cv::Mat* mask, double scaleIncrement, int rotationBins)
{
CV_Assert(!modelKeyPoints->empty());
CV_Assert(!observedKeyPoints->empty());
CV_Assert(mask->depth() == CV_8U && mask->channels() == 1);
//cv::Mat_<int> indicesMat = (cv::Mat_<int>) cv::cvarrToMat(indices);
cv::Mat_<uchar> maskMat = (cv::Mat_<uchar>) *mask;
std::vector<float> logScale;
std::vector<float> rotations;
float s, maxS, minS, r;
maxS = -1.0e-10f; minS = 1.0e10f;
for (int i = 0; i < maskMat.rows; i++)
{
if ( maskMat(i, 0))
{
cv::KeyPoint observedKeyPoint = observedKeyPoints->at(i);
cv::KeyPoint modelKeyPoint = modelKeyPoints->at( matches->at(i).at(0).trainIdx);
s = log10( observedKeyPoint.size / modelKeyPoint.size );
logScale.push_back(s);
maxS = s > maxS ? s : maxS;
minS = s < minS ? s : minS;
r = observedKeyPoint.angle - modelKeyPoint.angle;
r = r < 0.0f? r + 360.0f : r;
rotations.push_back(r);
}
}
int scaleBinSize = cvCeil((maxS - minS) / log10(scaleIncrement));
if (scaleBinSize < 2) scaleBinSize = 2;
float scaleRanges[] = {minS, (float) (minS + scaleBinSize * log10(scaleIncrement))};
cv::Mat_<float> scalesMat(logScale);
cv::Mat_<float> rotationsMat(rotations);
std::vector<float> flags(logScale.size());
cv::Mat flagsMat(flags);
{ //Perform voting for both scale and orientation
int histSize[] = {scaleBinSize, rotationBins};
float rotationRanges[] = {0, 360};
int channels[] = {0, 1};
const float* ranges[] = {scaleRanges, rotationRanges};
double minVal, maxVal;
const cv::Mat_<float> arrs[] = {scalesMat, rotationsMat};
cv::MatND hist; //CV_32S
cv::calcHist(arrs, 2, channels, cv::Mat(), hist, 2, histSize, ranges, true);
cv::minMaxLoc(hist, &minVal, &maxVal);
cv::threshold(hist, hist, maxVal * 0.5, 0, cv::THRESH_TOZERO);
cv::calcBackProject(arrs, 2, channels, hist, flagsMat, ranges);
}
int idx =0;
int nonZeroCount = 0;
for (int i = 0; i < maskMat.rows; i++)
{
if (maskMat(i, 0))
{
if (flags[idx++] != 0.0f)
nonZeroCount++;
else
maskMat(i, 0) = 0;
}
}
return nonZeroCount;
}
