virtual void operator()(const cv::BlockedRange& range) const { #ifdef HAVE_TBB tbb::spin_mutex::scoped_lock lock; #endif CvSeqReader reader; int begin = range.begin(); int end = range.end(); int weak_count = end - begin; CvDTree* tree; for (int i=0; i<k; ++i) { float tmp_sum = 0.0f; if ((weak[i]) && (weak_count)) { cvStartReadSeq( weak[i], &reader ); cvSetSeqReaderPos( &reader, begin ); for (int j=0; j<weak_count; ++j) { CV_READ_SEQ_ELEM( tree, reader ); tmp_sum += shrinkage*(float)(tree->predict(sample, missing)->value); } } #ifdef HAVE_TBB lock.acquire(SumMutex); sum[i] += tmp_sum; lock.release(); #else sum[i] += tmp_sum; #endif } } // Tree_predictor::operator()
CV_IMPL double cvContourPerimeter( CvSeq *contour, CvSlice slice ) { double perimeter = 0; int i, j = 0, count; const int N = 16; float buffer[N]; CvSeqReader reader; CV_FUNCNAME("cvCalcContourPerimeter"); __BEGIN__; if( !contour ) CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR ); if( !CV_IS_SEQ_POLYLINE( contour )) CV_ERROR_FROM_STATUS( CV_BADFLAG_ERR ); if( contour->total > 1 ) { CvPoint pt1, pt2; cvStartReadSeq( contour, &reader, 0 ); cvSetSeqReaderPos( &reader, slice.startIndex ); count = icvSliceLength( slice, contour ); CV_ADJUST_EDGE_COUNT( count, contour ); /* scroll the reader by 1 point */ CV_READ_EDGE( pt1, pt2, reader ); for( i = 0; i < count; i++ ) { int dx, dy; int edge_length; CV_READ_EDGE( pt1, pt2, reader ); dx = pt2.x - pt1.x; dy = pt2.y - pt1.y; edge_length = dx * dx + dy * dy; buffer[j] = (float)edge_length; if( ++j == N || i == count - 1 ) { cvbSqrt( buffer, buffer, j ); for( ; j > 0; j-- ) perimeter += buffer[j-1]; } } } __CLEANUP__ __END__ return perimeter; }
static char* icvSeqFindNextElem( CvSeq* seq, int offset, int mask, int value, int* start_index ) { char* elem_ptr = 0; CV_FUNCNAME("icvStartScanGraph"); __BEGIN__; CvSeqReader reader; int total, elem_size, index; if( !seq || !start_index ) CV_ERROR_FROM_STATUS( CV_NULLPTR_ERR ); elem_size = seq->elem_size; total = seq->total; index = *start_index; if( (unsigned)offset > (unsigned)elem_size ) CV_ERROR_FROM_STATUS( CV_BADARG_ERR ); if( total == 0 ) EXIT; if( (unsigned)index >= (unsigned)total ) { index %= total; index += index < 0 ? total : 0; } CV_CALL( cvStartReadSeq( seq, &reader )); if( index != 0 ) { CV_CALL( cvSetSeqReaderPos( &reader, index )); } for( index = 0; index < total; index++ ) { int* flag_ptr = (int*)(reader.ptr + offset); if( (*flag_ptr & mask) == value ) break; CV_NEXT_SEQ_ELEM( elem_size, reader ); } if( index < total ) { elem_ptr = reader.ptr; *start_index = index; } __END__; return elem_ptr; }
void CvFaceElement::MergeRects(int d) { int nRects = m_seqRects->total; CvSeqReader reader, reader2; cvStartReadSeq( m_seqRects, &reader ); int i, j; for (i = 0; i < nRects; i++) { CvTrackingRect* pRect1 = (CvTrackingRect*)(reader.ptr); cvStartReadSeq( m_seqRects, &reader2 ); cvSetSeqReaderPos(&reader2, i + 1); for (j = i + 1; j < nRects; j++) { CvTrackingRect* pRect2 = (CvTrackingRect*)(reader2.ptr); if (abs(pRect1->ptCenter.y - pRect2->ptCenter.y) < d && abs(pRect1->r.height - pRect2->r.height) < d) { CvTrackingRect rNew; rNew.iColor = (pRect1->iColor + pRect2->iColor + 1) / 2; rNew.r.x = min(pRect1->r.x, pRect2->r.x); rNew.r.y = min(pRect1->r.y, pRect2->r.y); rNew.r.width = max(pRect1->r.x + pRect1->r.width, pRect2->r.x + pRect2->r.width) - rNew.r.x; rNew.r.height = min(pRect1->r.y + pRect1->r.height, pRect2->r.y + pRect2->r.height) - rNew.r.y; if (rNew.r != pRect1->r && rNew.r != pRect2->r) { rNew.ptCenter = Center(rNew.r); cvSeqPush(m_seqRects, &rNew); } } CV_NEXT_SEQ_ELEM( sizeof(CvTrackingRect), reader2 ); } CV_NEXT_SEQ_ELEM( sizeof(CvTrackingRect), reader ); } // delete equal rects for (i = 0; i < m_seqRects->total; i++) { CvTrackingRect* pRect1 = (CvTrackingRect*)cvGetSeqElem(m_seqRects, i); int j_begin = i + 1; for (j = j_begin; j < m_seqRects->total;) { CvTrackingRect* pRect2 = (CvTrackingRect*)cvGetSeqElem(m_seqRects, j); if (pRect1->r == pRect2->r) cvSeqRemove(m_seqRects, j); else j++; } } }//void CvFaceElement::MergeRects(int d)
void CvGBTrees::clear() { if( weak ) { CvSeqReader reader; CvSlice slice = CV_WHOLE_SEQ; CvDTree* tree; //data->shared = false; for (int i=0; i<class_count; ++i) { int weak_count = cvSliceLength( slice, weak[i] ); if ((weak[i]) && (weak_count)) { cvStartReadSeq( weak[i], &reader ); cvSetSeqReaderPos( &reader, slice.start_index ); for (int j=0; j<weak_count; ++j) { CV_READ_SEQ_ELEM( tree, reader ); //tree->clear(); delete tree; tree = 0; } } } for (int i=0; i<class_count; ++i) if (weak[i]) cvReleaseMemStorage( &(weak[i]->storage) ); delete[] weak; } if (data) { data->shared = false; delete data; } weak = 0; data = 0; delta = 0.0f; cvReleaseMat( &orig_response ); cvReleaseMat( &sum_response ); cvReleaseMat( &sum_response_tmp ); cvReleaseMat( &subsample_train ); cvReleaseMat( &subsample_test ); cvReleaseMat( &sample_idx ); cvReleaseMat( &missing ); cvReleaseMat( &class_labels ); }
/* calculates length of a curve (e.g. contour perimeter) */ CV_IMPL double cvArcLength( const void *array, CvSlice slice, int is_closed ) { double perimeter = 0; int i, j = 0, count; const int N = 16; float buf[N]; CvMat buffer = cvMat( 1, N, CV_32F, buf ); CvSeqReader reader; CvContour contour_header; CvSeq* contour = 0; CvSeqBlock block; if( CV_IS_SEQ( array )) { contour = (CvSeq*)array; if( !CV_IS_SEQ_POLYLINE( contour )) CV_Error( CV_StsBadArg, "Unsupported sequence type" ); if( is_closed < 0 ) is_closed = CV_IS_SEQ_CLOSED( contour ); } else { is_closed = is_closed > 0; contour = cvPointSeqFromMat( CV_SEQ_KIND_CURVE | (is_closed ? CV_SEQ_FLAG_CLOSED : 0), array, &contour_header, &block ); } if( contour->total > 1 ) { int is_float = CV_SEQ_ELTYPE( contour ) == CV_32FC2; cvStartReadSeq( contour, &reader, 0 ); cvSetSeqReaderPos( &reader, slice.start_index ); count = cvSliceLength( slice, contour ); count -= !is_closed && count == contour->total; // scroll the reader by 1 point reader.prev_elem = reader.ptr; CV_NEXT_SEQ_ELEM( sizeof(CvPoint), reader ); for( i = 0; i < count; i++ ) { float dx, dy; if( !is_float ) { CvPoint* pt = (CvPoint*)reader.ptr; CvPoint* prev_pt = (CvPoint*)reader.prev_elem; dx = (float)pt->x - (float)prev_pt->x; dy = (float)pt->y - (float)prev_pt->y; } else { CvPoint2D32f* pt = (CvPoint2D32f*)reader.ptr; CvPoint2D32f* prev_pt = (CvPoint2D32f*)reader.prev_elem; dx = pt->x - prev_pt->x; dy = pt->y - prev_pt->y; } reader.prev_elem = reader.ptr; CV_NEXT_SEQ_ELEM( contour->elem_size, reader ); // Bugfix by Axel at rubico.com 2010-03-22, affects closed slices only // wraparound not handled by CV_NEXT_SEQ_ELEM if( is_closed && i == count - 2 ) cvSetSeqReaderPos( &reader, slice.start_index ); buffer.data.fl[j] = dx * dx + dy * dy; if( ++j == N || i == count - 1 ) { buffer.cols = j; cvPow( &buffer, &buffer, 0.5 ); for( ; j > 0; j-- ) perimeter += buffer.data.fl[j-1]; } } } return perimeter; }
/* area of a contour sector */ static double icvContourSecArea( CvSeq * contour, CvSlice slice ) { CvPoint pt; /* pointer to points */ CvPoint pt_s, pt_e; /* first and last points */ CvSeqReader reader; /* points reader of contour */ int p_max = 2, p_ind; int lpt, flag, i; double a00; /* unnormalized moments m00 */ double xi, yi, xi_1, yi_1, x0, y0, dxy, sk, sk1, t; double x_s, y_s, nx, ny, dx, dy, du, dv; double eps = 1.e-5; double *p_are1, *p_are2, *p_are; double area = 0; CV_Assert( contour != NULL && CV_IS_SEQ_POINT_SET( contour )); lpt = cvSliceLength( slice, contour ); /*if( n2 >= n1 ) lpt = n2 - n1 + 1; else lpt = contour->total - n1 + n2 + 1;*/ if( contour->total <= 0 || lpt <= 2 ) return 0.; a00 = x0 = y0 = xi_1 = yi_1 = 0; sk1 = 0; flag = 0; dxy = 0; p_are1 = (double *) cvAlloc( p_max * sizeof( double )); p_are = p_are1; p_are2 = NULL; cvStartReadSeq( contour, &reader, 0 ); cvSetSeqReaderPos( &reader, slice.start_index ); CV_READ_SEQ_ELEM( pt_s, reader ); p_ind = 0; cvSetSeqReaderPos( &reader, slice.end_index ); CV_READ_SEQ_ELEM( pt_e, reader ); /* normal coefficients */ nx = pt_s.y - pt_e.y; ny = pt_e.x - pt_s.x; cvSetSeqReaderPos( &reader, slice.start_index ); while( lpt-- > 0 ) { CV_READ_SEQ_ELEM( pt, reader ); if( flag == 0 ) { xi_1 = (double) pt.x; yi_1 = (double) pt.y; x0 = xi_1; y0 = yi_1; sk1 = 0; flag = 1; } else { xi = (double) pt.x; yi = (double) pt.y; /**************** edges intersection examination **************************/ sk = nx * (xi - pt_s.x) + ny * (yi - pt_s.y); if( (fabs( sk ) < eps && lpt > 0) || sk * sk1 < -eps ) { if( fabs( sk ) < eps ) { dxy = xi_1 * yi - xi * yi_1; a00 = a00 + dxy; dxy = xi * y0 - x0 * yi; a00 = a00 + dxy; if( p_ind >= p_max ) icvMemCopy( &p_are1, &p_are2, &p_are, &p_max ); p_are[p_ind] = a00 / 2.; p_ind++; a00 = 0; sk1 = 0; x0 = xi; y0 = yi; dxy = 0; } else { /* define intersection point */ dv = yi - yi_1; du = xi - xi_1; dx = ny; dy = -nx; if( fabs( du ) > eps ) t = ((yi_1 - pt_s.y) * du + dv * (pt_s.x - xi_1)) / (du * dy - dx * dv); else t = (xi_1 - pt_s.x) / dx; if( t > eps && t < 1 - eps ) { x_s = pt_s.x + t * dx; y_s = pt_s.y + t * dy; dxy = xi_1 * y_s - x_s * yi_1; a00 += dxy; dxy = x_s * y0 - x0 * y_s; a00 += dxy; if( p_ind >= p_max ) icvMemCopy( &p_are1, &p_are2, &p_are, &p_max ); p_are[p_ind] = a00 / 2.; p_ind++; a00 = 0; sk1 = 0; x0 = x_s; y0 = y_s; dxy = x_s * yi - xi * y_s; } } } else dxy = xi_1 * yi - xi * yi_1; a00 += dxy; xi_1 = xi; yi_1 = yi; sk1 = sk; } } xi = x0; yi = y0; dxy = xi_1 * yi - xi * yi_1; a00 += dxy; if( p_ind >= p_max ) icvMemCopy( &p_are1, &p_are2, &p_are, &p_max ); p_are[p_ind] = a00 / 2.; p_ind++; // common area calculation area = 0; for( i = 0; i < p_ind; i++ ) area += fabs( p_are[i] ); if( p_are1 != NULL ) cvFree( &p_are1 ); else if( p_are2 != NULL ) cvFree( &p_are2 ); return area; }
float CvGBTrees::predict_serial( const CvMat* _sample, const CvMat* _missing, CvMat* weak_responses, CvSlice slice, int k) const { float result = 0.0f; if (!weak) return 0.0f; CvSeqReader reader; int weak_count = cvSliceLength( slice, weak[class_count-1] ); CvDTree* tree; if (weak_responses) { if (CV_MAT_TYPE(weak_responses->type) != CV_32F) return 0.0f; if ((k >= 0) && (k<class_count) && (weak_responses->rows != 1)) return 0.0f; if ((k == -1) && (weak_responses->rows != class_count)) return 0.0f; if (weak_responses->cols != weak_count) return 0.0f; } float* sum = new float[class_count]; memset(sum, 0, class_count*sizeof(float)); for (int i=0; i<class_count; ++i) { if ((weak[i]) && (weak_count)) { cvStartReadSeq( weak[i], &reader ); cvSetSeqReaderPos( &reader, slice.start_index ); for (int j=0; j<weak_count; ++j) { CV_READ_SEQ_ELEM( tree, reader ); float p = (float)(tree->predict(_sample, _missing)->value); sum[i] += params.shrinkage * p; if (weak_responses) weak_responses->data.fl[i*weak_count+j] = p; } } } for (int i=0; i<class_count; ++i) sum[i] += base_value; if (class_count == 1) { result = sum[0]; delete[] sum; return result; } if ((k>=0) && (k<class_count)) { result = sum[k]; delete[] sum; return result; } float max = sum[0]; int class_label = 0; for (int i=1; i<class_count; ++i) if (sum[i] > max) { max = sum[i]; class_label = i; } delete[] sum; /* int orig_class_label = -1; for (int i=0; i<get_len(class_labels); ++i) if (class_labels->data.i[i] == class_label+1) orig_class_label = i; */ int orig_class_label = class_labels->data.i[class_label]; return float(orig_class_label); }