CV_IMPL void cvFilter2D( const CvArr* _src, CvArr* _dst, const CvMat* _kernel, CvPoint anchor ) { // below that approximate size OpenCV is faster const int ipp_lower_limit = 20; static CvFuncTable filter_tab; static int inittab = 0; CvFilterState *state = 0; float* kernel_data = 0; int local_alloc = 1; CvMat* temp = 0; CV_FUNCNAME( "cvFilter2D" ); __BEGIN__; CvFilterFunc func = 0; int coi1 = 0, coi2 = 0; CvMat srcstub, *src = (CvMat*)_src; CvMat dststub, *dst = (CvMat*)_dst; CvSize size; int type, depth; int src_step, dst_step; CvMat kernel_hdr; const CvMat* kernel = _kernel; if( !inittab ) { icvInitFilterTab( &filter_tab ); inittab = 1; } CV_CALL( src = cvGetMat( src, &srcstub, &coi1 )); CV_CALL( dst = cvGetMat( dst, &dststub, &coi2 )); if( coi1 != 0 || coi2 != 0 ) CV_ERROR( CV_BadCOI, "" ); type = CV_MAT_TYPE( src->type ); if( !CV_ARE_SIZES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedSizes, "" ); if( !CV_ARE_TYPES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedFormats, "" ); if( !CV_IS_MAT(kernel) || (CV_MAT_TYPE(kernel->type) != CV_32F && CV_MAT_TYPE(kernel->type) != CV_64F )) CV_ERROR( CV_StsBadArg, "kernel must be single-channel floating-point matrix" ); if( anchor.x == -1 && anchor.y == -1 ) anchor = cvPoint(kernel->cols/2,kernel->rows/2); if( (unsigned)anchor.x >= (unsigned)kernel->cols || (unsigned)anchor.y >= (unsigned)kernel->rows ) CV_ERROR( CV_StsOutOfRange, "anchor point is out of kernel" ); if( CV_MAT_TYPE(kernel->type) != CV_32FC1 || !CV_IS_MAT_CONT(kernel->type) || icvFilter_8u_C1R_p ) { int sz = kernel->rows*kernel->cols*sizeof(kernel_data[0]); if( sz < CV_MAX_LOCAL_SIZE ) kernel_data = (float*)cvStackAlloc( sz ); else { CV_CALL( kernel_data = (float*)cvAlloc( sz )); local_alloc = 0; } kernel_hdr = cvMat( kernel->rows, kernel->cols, CV_32F, kernel_data ); if( CV_MAT_TYPE(kernel->type) == CV_32FC1 ) cvCopy( kernel, &kernel_hdr ); else cvConvertScale( kernel, &kernel_hdr, 1, 0 ); kernel = &kernel_hdr; } size = cvGetMatSize( src ); depth = CV_MAT_DEPTH(type); src_step = src->step; dst_step = dst->step ? dst->step : CV_STUB_STEP; if( icvFilter_8u_C1R_p && (src->rows >= ipp_lower_limit || src->cols >= ipp_lower_limit) ) { CvFilterIPPFunc ipp_func = type == CV_8UC1 ? (CvFilterIPPFunc)icvFilter_8u_C1R_p : type == CV_8UC3 ? (CvFilterIPPFunc)icvFilter_8u_C3R_p : type == CV_8UC4 ? (CvFilterIPPFunc)icvFilter_8u_C4R_p : type == CV_16SC1 ? (CvFilterIPPFunc)icvFilter_16s_C1R_p : type == CV_16SC3 ? (CvFilterIPPFunc)icvFilter_16s_C3R_p : type == CV_16SC4 ? (CvFilterIPPFunc)icvFilter_16s_C4R_p : type == CV_32FC1 ? (CvFilterIPPFunc)icvFilter_32f_C1R_p : type == CV_32FC3 ? (CvFilterIPPFunc)icvFilter_32f_C3R_p : type == CV_32FC4 ? (CvFilterIPPFunc)icvFilter_32f_C4R_p : 0; if( ipp_func ) { CvSize el_size = { kernel->cols, kernel->rows }; CvPoint el_anchor = { el_size.width - anchor.x - 1, el_size.height - anchor.y - 1 }; int stripe_size = 1 << 16; // the optimal value may depend on CPU cache, // overhead of current IPP code etc. const uchar* shifted_ptr; int i, j, y, dy = 0; int temp_step; // mirror the kernel around the center for( i = 0; i < (el_size.height+1)/2; i++ ) { float* top_row = kernel->data.fl + el_size.width*i; float* bottom_row = kernel->data.fl + el_size.width*(el_size.height - i - 1); for( j = 0; j < (el_size.width+1)/2; j++ ) { float a = top_row[j], b = top_row[el_size.width - j - 1]; float c = bottom_row[j], d = bottom_row[el_size.width - j - 1]; top_row[j] = d; top_row[el_size.width - j - 1] = c; bottom_row[j] = b; bottom_row[el_size.width - j - 1] = a; } } CV_CALL( temp = icvIPPFilterInit( src, stripe_size, el_size )); shifted_ptr = temp->data.ptr + anchor.y*temp->step + anchor.x*CV_ELEM_SIZE(type); temp_step = temp->step ? temp->step : CV_STUB_STEP; for( y = 0; y < src->rows; y += dy ) { dy = icvIPPFilterNextStripe( src, temp, y, el_size, anchor ); IPPI_CALL( ipp_func( shifted_ptr, temp_step, dst->data.ptr + y*dst_step, dst_step, cvSize(src->cols, dy), kernel->data.fl, el_size, el_anchor )); } EXIT; } } CV_CALL( state = icvFilterInitAlloc( src->cols, cv32f, CV_MAT_CN(type), cvSize(kernel->cols, kernel->rows), anchor, kernel->data.ptr, ICV_GENERIC_KERNEL )); if( CV_MAT_CN(type) == 2 ) CV_ERROR( CV_BadNumChannels, "Unsupported number of channels" ); func = (CvFilterFunc)(filter_tab.fn_2d[depth]); if( !func ) CV_ERROR( CV_StsUnsupportedFormat, "" ); if( size.height == 1 ) src_step = dst_step = CV_STUB_STEP; IPPI_CALL( func( src->data.ptr, src_step, dst->data.ptr, dst_step, &size, state, 0 )); __END__; cvReleaseMat( &temp ); icvFilterFree( &state ); if( !local_alloc ) cvFree( (void**)&kernel_data ); }
CV_IMPL void cvMatchTemplate( const CvArr* _img, const CvArr* _templ, CvArr* _result, int method ) { CvMat* sum = 0; CvMat* sqsum = 0; CV_FUNCNAME( "cvMatchTemplate" ); __BEGIN__; int coi1 = 0, coi2 = 0; int depth, cn; int i, j, k; CvMat stub, *img = (CvMat*)_img; CvMat tstub, *templ = (CvMat*)_templ; CvMat rstub, *result = (CvMat*)_result; CvScalar templ_mean = cvScalarAll(0); double templ_norm = 0, templ_sum2 = 0; int idx = 0, idx2 = 0; double *p0, *p1, *p2, *p3; double *q0, *q1, *q2, *q3; double inv_area; int sum_step, sqsum_step; int num_type = method == CV_TM_CCORR || method == CV_TM_CCORR_NORMED ? 0 : method == CV_TM_CCOEFF || method == CV_TM_CCOEFF_NORMED ? 1 : 2; int is_normed = method == CV_TM_CCORR_NORMED || method == CV_TM_SQDIFF_NORMED || method == CV_TM_CCOEFF_NORMED; CV_CALL( img = cvGetMat( img, &stub, &coi1 )); CV_CALL( templ = cvGetMat( templ, &tstub, &coi2 )); CV_CALL( result = cvGetMat( result, &rstub )); if( CV_MAT_DEPTH( img->type ) != CV_8U && CV_MAT_DEPTH( img->type ) != CV_32F ) CV_ERROR( CV_StsUnsupportedFormat, "The function supports only 8u and 32f data types" ); if( !CV_ARE_TYPES_EQ( img, templ )) CV_ERROR( CV_StsUnmatchedSizes, "image and template should have the same type" ); if( CV_MAT_TYPE( result->type ) != CV_32FC1 ) CV_ERROR( CV_StsUnsupportedFormat, "output image should have 32f type" ); if( img->rows < templ->rows || img->cols < templ->cols ) { CvMat* t; CV_SWAP( img, templ, t ); } if( result->rows != img->rows - templ->rows + 1 || result->cols != img->cols - templ->cols + 1 ) CV_ERROR( CV_StsUnmatchedSizes, "output image should be (W - w + 1)x(H - h + 1)" ); if( method < CV_TM_SQDIFF || method > CV_TM_CCOEFF_NORMED ) CV_ERROR( CV_StsBadArg, "unknown comparison method" ); depth = CV_MAT_DEPTH(img->type); cn = CV_MAT_CN(img->type); if( is_normed && cn == 1 && templ->rows > 8 && templ->cols > 8 && img->rows > templ->cols && img->cols > templ->cols ) { CvTemplMatchIPPFunc ipp_func = depth == CV_8U ? (method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_8u32f_C1R_p : method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_8u32f_C1R_p : (CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_8u32f_C1R_p) : (method == CV_TM_SQDIFF_NORMED ? (CvTemplMatchIPPFunc)icvSqrDistanceValid_Norm_32f_C1R_p : method == CV_TM_CCORR_NORMED ? (CvTemplMatchIPPFunc)icvCrossCorrValid_Norm_32f_C1R_p : (CvTemplMatchIPPFunc)icvCrossCorrValid_NormLevel_32f_C1R_p); if( ipp_func ) { CvSize img_size = cvGetMatSize(img), templ_size = cvGetMatSize(templ); IPPI_CALL( ipp_func( img->data.ptr, img->step ? img->step : CV_STUB_STEP, img_size, templ->data.ptr, templ->step ? templ->step : CV_STUB_STEP, templ_size, result->data.ptr, result->step ? result->step : CV_STUB_STEP )); for( i = 0; i < result->rows; i++ ) { float* rrow = (float*)(result->data.ptr + i*result->step); for( j = 0; j < result->cols; j++ ) { if( fabs(rrow[j]) > 1. ) rrow[j] = rrow[j] < 0 ? -1.f : 1.f; } } EXIT; } } CV_CALL( icvCrossCorr( img, templ, result )); if( method == CV_TM_CCORR ) EXIT; inv_area = 1./((double)templ->rows * templ->cols); CV_CALL( sum = cvCreateMat( img->rows + 1, img->cols + 1, CV_MAKETYPE( CV_64F, cn ))); if( method == CV_TM_CCOEFF ) { CV_CALL( cvIntegral( img, sum, 0, 0 )); CV_CALL( templ_mean = cvAvg( templ )); q0 = q1 = q2 = q3 = 0; } else { CvScalar _templ_sdv = cvScalarAll(0); CV_CALL( sqsum = cvCreateMat( img->rows + 1, img->cols + 1, CV_MAKETYPE( CV_64F, cn ))); CV_CALL( cvIntegral( img, sum, sqsum, 0 )); CV_CALL( cvAvgSdv( templ, &templ_mean, &_templ_sdv )); templ_norm = CV_SQR(_templ_sdv.val[0]) + CV_SQR(_templ_sdv.val[1]) + CV_SQR(_templ_sdv.val[2]) + CV_SQR(_templ_sdv.val[3]); if( templ_norm < DBL_EPSILON && method == CV_TM_CCOEFF_NORMED ) { cvSet( result, cvScalarAll(1.) ); EXIT; } templ_sum2 = templ_norm + CV_SQR(templ_mean.val[0]) + CV_SQR(templ_mean.val[1]) + CV_SQR(templ_mean.val[2]) + CV_SQR(templ_mean.val[3]); if( num_type != 1 ) { templ_mean = cvScalarAll(0); templ_norm = templ_sum2; } templ_sum2 /= inv_area; templ_norm = sqrt(templ_norm); templ_norm /= sqrt(inv_area); // care of accuracy here q0 = (double*)sqsum->data.ptr; q1 = q0 + templ->cols*cn; q2 = (double*)(sqsum->data.ptr + templ->rows*sqsum->step); q3 = q2 + templ->cols*cn; } p0 = (double*)sum->data.ptr; p1 = p0 + templ->cols*cn; p2 = (double*)(sum->data.ptr + templ->rows*sum->step); p3 = p2 + templ->cols*cn; sum_step = sum ? sum->step / sizeof(double) : 0; sqsum_step = sqsum ? sqsum->step / sizeof(double) : 0; for( i = 0; i < result->rows; i++ ) { float* rrow = (float*)(result->data.ptr + i*result->step); idx = i * sum_step; idx2 = i * sqsum_step; for( j = 0; j < result->cols; j++, idx += cn, idx2 += cn ) { double num = rrow[j], t; double wnd_mean2 = 0, wnd_sum2 = 0; if( num_type == 1 ) { for( k = 0; k < cn; k++ ) { t = p0[idx+k] - p1[idx+k] - p2[idx+k] + p3[idx+k]; wnd_mean2 += CV_SQR(t); num -= t*templ_mean.val[k]; } wnd_mean2 *= inv_area; } if( is_normed || num_type == 2 ) { for( k = 0; k < cn; k++ ) { t = q0[idx2+k] - q1[idx2+k] - q2[idx2+k] + q3[idx2+k]; wnd_sum2 += t; } if( num_type == 2 ) num = wnd_sum2 - 2*num + templ_sum2; } if( is_normed ) { t = sqrt(MAX(wnd_sum2 - wnd_mean2,0))*templ_norm; if( t > DBL_EPSILON ) { num /= t; if( fabs(num) > 1. ) num = num > 0 ? 1 : -1; } else num = method != CV_TM_SQDIFF_NORMED || num < DBL_EPSILON ? 0 : 1; } rrow[j] = (float)num; } } __END__; cvReleaseMat( &sum ); cvReleaseMat( &sqsum ); }
/* Wrapper function for distance transform group */ CV_IMPL void cvDistTransform( const void* srcarr, void* dstarr, int distType, int maskSize, const float *mask, void* labelsarr ) { CvMat* temp = 0; CvMat* src_copy = 0; CvMemStorage* st = 0; CV_FUNCNAME( "cvDistTransform" ); __BEGIN__; float _mask[5] = {0}; int _imask[3]; CvMat srcstub, *src = (CvMat*)srcarr; CvMat dststub, *dst = (CvMat*)dstarr; CvMat lstub, *labels = (CvMat*)labelsarr; CvSize size; CvIPPDistTransFunc ipp_func = 0; CvIPPDistTransFunc2 ipp_inp_func = 0; CV_CALL( src = cvGetMat( src, &srcstub )); CV_CALL( dst = cvGetMat( dst, &dststub )); if( !CV_IS_MASK_ARR( src ) || CV_MAT_TYPE( dst->type ) != CV_32FC1 && (CV_MAT_TYPE(dst->type) != CV_8UC1 || distType != CV_DIST_L1 || labels) ) CV_ERROR( CV_StsUnsupportedFormat, "source image must be 8uC1 and the distance map must be 32fC1 " "(or 8uC1 in case of simple L1 distance transform)" ); if( !CV_ARE_SIZES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedSizes, "the source and the destination images must be of the same size" ); if( maskSize != CV_DIST_MASK_3 && maskSize != CV_DIST_MASK_5 && maskSize != CV_DIST_MASK_PRECISE ) CV_ERROR( CV_StsBadSize, "Mask size should be 3 or 5 or 0 (presize)" ); if( distType == CV_DIST_C || distType == CV_DIST_L1 ) maskSize = !labels ? CV_DIST_MASK_3 : CV_DIST_MASK_5; else if( distType == CV_DIST_L2 && labels ) maskSize = CV_DIST_MASK_5; if( maskSize == CV_DIST_MASK_PRECISE ) { CV_CALL( icvTrueDistTrans( src, dst )); EXIT; } if( labels ) { CV_CALL( labels = cvGetMat( labels, &lstub )); if( CV_MAT_TYPE( labels->type ) != CV_32SC1 ) CV_ERROR( CV_StsUnsupportedFormat, "the output array of labels must be 32sC1" ); if( !CV_ARE_SIZES_EQ( labels, dst )) CV_ERROR( CV_StsUnmatchedSizes, "the array of labels has a different size" ); if( maskSize == CV_DIST_MASK_3 ) CV_ERROR( CV_StsNotImplemented, "3x3 mask can not be used for \"labeled\" distance transform. Use 5x5 mask" ); } if( distType == CV_DIST_C || distType == CV_DIST_L1 || distType == CV_DIST_L2 ) { icvGetDistanceTransformMask( (distType == CV_DIST_C ? 0 : distType == CV_DIST_L1 ? 1 : 2) + maskSize*10, _mask ); } else if( distType == CV_DIST_USER ) { if( !mask ) CV_ERROR( CV_StsNullPtr, "" ); memcpy( _mask, mask, (maskSize/2 + 1)*sizeof(float)); } if( !labels ) { if( CV_MAT_TYPE(dst->type) == CV_32FC1 ) ipp_func = (CvIPPDistTransFunc)(maskSize == CV_DIST_MASK_3 ? icvDistanceTransform_3x3_8u32f_C1R_p : icvDistanceTransform_5x5_8u32f_C1R_p); else if( src->data.ptr != dst->data.ptr ) ipp_func = (CvIPPDistTransFunc)icvDistanceTransform_3x3_8u_C1R_p; else ipp_inp_func = icvDistanceTransform_3x3_8u_C1IR_p; } size = cvGetMatSize(src); if( (ipp_func || ipp_inp_func) && src->cols >= 4 && src->rows >= 2 ) { _imask[0] = cvRound(_mask[0]); _imask[1] = cvRound(_mask[1]); _imask[2] = cvRound(_mask[2]); if( ipp_func ) { IPPI_CALL( ipp_func( src->data.ptr, src->step, dst->data.fl, dst->step, size, CV_MAT_TYPE(dst->type) == CV_8UC1 ? (void*)_imask : (void*)_mask )); } else { IPPI_CALL( ipp_inp_func( src->data.ptr, src->step, size, _imask )); } } else if( CV_MAT_TYPE(dst->type) == CV_8UC1 ) { CV_CALL( icvDistanceATS_L1_8u( src, dst )); } else { int border = maskSize == CV_DIST_MASK_3 ? 1 : 2; CV_CALL( temp = cvCreateMat( size.height + border*2, size.width + border*2, CV_32SC1 )); if( !labels ) { CvDistTransFunc func = maskSize == CV_DIST_MASK_3 ? icvDistanceTransform_3x3_C1R : icvDistanceTransform_5x5_C1R; func( src->data.ptr, src->step, temp->data.i, temp->step, dst->data.fl, dst->step, size, _mask ); } else { CvSeq *contours = 0; CvPoint top_left = {0,0}, bottom_right = {size.width-1,size.height-1}; int label; CV_CALL( st = cvCreateMemStorage() ); CV_CALL( src_copy = cvCreateMat( size.height, size.width, src->type )); cvCmpS( src, 0, src_copy, CV_CMP_EQ ); cvFindContours( src_copy, st, &contours, sizeof(CvContour), CV_RETR_CCOMP, CV_CHAIN_APPROX_SIMPLE ); cvZero( labels ); for( label = 1; contours != 0; contours = contours->h_next, label++ ) { CvScalar area_color = cvScalarAll(label); cvDrawContours( labels, contours, area_color, area_color, -255, -1, 8 ); } cvCopy( src, src_copy ); cvRectangle( src_copy, top_left, bottom_right, cvScalarAll(255), 1, 8 ); icvDistanceTransformEx_5x5_C1R( src_copy->data.ptr, src_copy->step, temp->data.i, temp->step, dst->data.fl, dst->step, labels->data.i, labels->step, size, _mask ); } } __END__; cvReleaseMat( &temp ); cvReleaseMat( &src_copy ); cvReleaseMemStorage( &st ); }