/* external contour area function */ CV_IMPL double cvContourArea( const void *array, CvSlice slice, int oriented ) { double area = 0; 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" ); } else { contour = cvPointSeqFromMat( CV_SEQ_KIND_CURVE, array, &contour_header, &block ); } if( cvSliceLength( slice, contour ) == contour->total ) { IPPI_CALL( icvContourArea( contour, &area )); } else { if( CV_SEQ_ELTYPE( contour ) != CV_32SC2 ) CV_Error( CV_StsUnsupportedFormat, "Only curves with integer coordinates are supported in case of contour slice" ); IPPI_CALL( icvContourSecArea( contour, slice, &area )); } return oriented ? area : fabs(area); }
/* external contour area function */ CV_IMPL double cvContourArea( const void *array, CvSlice slice, int oriented ) { double area = 0; 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" ); } else { contour = cvPointSeqFromMat( CV_SEQ_KIND_CURVE, array, &contour_header, &block ); } if( cvSliceLength( slice, contour ) == contour->total ) { cv::AutoBuffer<double> abuf; cv::Mat points = cv::cvarrToMat(contour, false, false, 0, &abuf); return cv::contourArea( points, oriented !=0 ); } if( CV_SEQ_ELTYPE( contour ) != CV_32SC2 ) CV_Error( CV_StsUnsupportedFormat, "Only curves with integer coordinates are supported in case of contour slice" ); area = icvContourSecArea( contour, slice ); return oriented ? area : fabs(area); }
float CvGBTrees::predict( const CvMat* _sample, const CvMat* _missing, CvMat* /*weak_responses*/, CvSlice slice, int k) const { float result = 0.0f; if (!weak) return 0.0f; float* sum = new float[class_count]; for (int i=0; i<class_count; ++i) sum[i] = 0.0f; int begin = slice.start_index; int end = begin + cvSliceLength( slice, weak[0] ); pCvSeq* weak_seq = weak; Tree_predictor predictor = Tree_predictor(weak_seq, class_count, params.shrinkage, _sample, _missing, sum); //#ifdef HAVE_TBB // tbb::parallel_for(cv::BlockedRange(begin, end), predictor, // tbb::auto_partitioner()); //#else cv::parallel_for(cv::BlockedRange(begin, end), predictor); //#endif for (int i=0; i<class_count; ++i) sum[i] = sum[i] /** params.shrinkage*/ + 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 = class_labels->data.i[class_label]; return float(orig_class_label); }
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 ); }
int Image::numberContours() { IplImage* src = this -> toIplImage(); IplImage* dst = this -> cloneEmpty() -> toIplImage(); CvMemStorage* storage = cvCreateMemStorage(0); CvSeq* contour = 0; cvFindContours(src, storage, &contour, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE); int numContours = cvSliceLength(CV_WHOLE_SEQ, contour); // delete contour; return numContours; }
/* 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); }