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; }