CV_IMPL void cvCornerMinEigenVal( const void* srcarr, void* eigenvarr, int block_size, int aperture_size ) { CV_FUNCNAME( "cvCornerMinEigenVal" ); __BEGIN__; CvMat stub, *src = (CvMat*)srcarr; CvMat eigstub, *eigenv = (CvMat*)eigenvarr; CV_CALL( src = cvGetMat( srcarr, &stub )); CV_CALL( eigenv = cvGetMat( eigenv, &eigstub )); if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 || CV_MAT_TYPE(eigenv->type) != CV_32FC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" ); if( !CV_ARE_SIZES_EQ( src, eigenv )) CV_ERROR( CV_StsUnmatchedSizes, "" ); CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_MINEIGENVAL )); __END__; }
CV_IMPL void cvCornerHarris( const CvArr* srcarr, CvArr* harris_responce, int block_size, int aperture_size, double k ) { CV_FUNCNAME( "cvCornerHarris" ); __BEGIN__; CvMat stub, *src = (CvMat*)srcarr; CvMat eigstub, *eigenv = (CvMat*)harris_responce; CV_CALL( src = cvGetMat( srcarr, &stub )); CV_CALL( eigenv = cvGetMat( eigenv, &eigstub )); if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 || CV_MAT_TYPE(eigenv->type) != CV_32FC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" ); if( !CV_ARE_SIZES_EQ( src, eigenv )) CV_ERROR( CV_StsUnmatchedSizes, "" ); CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_HARRIS, k )); __END__; }
/*F/////////////////////////////////////////////////////////////////////////////////////// // Name: cvCalcOpticalFlowLK // Purpose: Optical flow implementation // Context: // Parameters: // srcA, srcB - source image // velx, vely - destination image // Returns: // // Notes: //F*/ CV_IMPL void cvCalcOpticalFlowLK(const void* srcarrA, const void* srcarrB, CvSize winSize, void* velarrx, void* velarry) { CvMat stubA, *srcA = cvGetMat(srcarrA, &stubA); CvMat stubB, *srcB = cvGetMat(srcarrB, &stubB); CvMat stubx, *velx = cvGetMat(velarrx, &stubx); CvMat stuby, *vely = cvGetMat(velarry, &stuby); if (!CV_ARE_TYPES_EQ(srcA, srcB)) { CV_Error(CV_StsUnmatchedFormats, "Source images have different formats"); } if (!CV_ARE_TYPES_EQ(velx, vely)) { CV_Error(CV_StsUnmatchedFormats, "Destination images have different formats"); } if (!CV_ARE_SIZES_EQ(srcA, srcB) || !CV_ARE_SIZES_EQ(velx, vely) || !CV_ARE_SIZES_EQ(srcA, velx)) { CV_Error(CV_StsUnmatchedSizes, ""); } if (CV_MAT_TYPE(srcA->type) != CV_8UC1 || CV_MAT_TYPE(velx->type) != CV_32FC1) CV_Error(CV_StsUnsupportedFormat, "Source images must have 8uC1 type and " "destination images must have 32fC1 type"); if (srcA->step != srcB->step || velx->step != vely->step) { CV_Error(CV_BadStep, "source and destination images have different step"); } IPPI_CALL(icvCalcOpticalFlowLK_8u32fR((uchar*)srcA->data.ptr, (uchar*)srcB->data.ptr, srcA->step, cvGetMatSize(srcA), winSize, velx->data.fl, vely->data.fl, velx->step)); }
CV_IMPL void cvCornerEigenValsAndVecs( const void* srcarr, void* eigenvarr, int block_size, int aperture_size ) { CV_FUNCNAME( "cvCornerEigenValsAndVecs" ); __BEGIN__; CvMat stub, *src = (CvMat*)srcarr; CvMat eigstub, *eigenv = (CvMat*)eigenvarr; CV_CALL( src = cvGetMat( srcarr, &stub )); CV_CALL( eigenv = cvGetMat( eigenv, &eigstub )); if( CV_MAT_CN(eigenv->type)*eigenv->cols != src->cols*6 || eigenv->rows != src->rows ) CV_ERROR( CV_StsUnmatchedSizes, "Output array should be 6 times " "wider than the input array and they should have the same height"); if( CV_MAT_TYPE(src->type) != CV_8UC1 && CV_MAT_TYPE(src->type) != CV_32FC1 || CV_MAT_TYPE(eigenv->type) != CV_32FC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Input must be 8uC1 or 32fC1, output must be 32fC1" ); CV_CALL( icvCornerEigenValsVecs( src, eigenv, block_size, aperture_size, ICV_EIGENVALSVECS )); __END__; }
CV_IMPL void cvCopyMakeBorder( const CvArr* srcarr, CvArr* dstarr, CvPoint offset, int bordertype, CvScalar value ) { CvMat srcstub, *src = (CvMat*)srcarr; CvMat dststub, *dst = (CvMat*)dstarr; CvSize srcsize, dstsize; int srcstep, dststep; int pix_size, type; if( !CV_IS_MAT(src) ) src = cvGetMat( src, &srcstub ); if( !CV_IS_MAT(dst) ) dst = cvGetMat( dst, &dststub ); if( offset.x < 0 || offset.y < 0 ) CV_Error( CV_StsOutOfRange, "Offset (left/top border width) is negative" ); if( src->rows + offset.y > dst->rows || src->cols + offset.x > dst->cols ) CV_Error( CV_StsBadSize, "Source array is too big or destination array is too small" ); if( !CV_ARE_TYPES_EQ( src, dst )) CV_Error( CV_StsUnmatchedFormats, "" ); type = CV_MAT_TYPE(src->type); pix_size = CV_ELEM_SIZE(type); srcsize = cvGetMatSize(src); dstsize = cvGetMatSize(dst); srcstep = src->step; dststep = dst->step; if( srcstep == 0 ) srcstep = CV_STUB_STEP; if( dststep == 0 ) dststep = CV_STUB_STEP; bordertype &= 15; if( bordertype == IPL_BORDER_REPLICATE ) { icvCopyReplicateBorder_8u( src->data.ptr, srcstep, srcsize, dst->data.ptr, dststep, dstsize, offset.y, offset.x, pix_size ); } else if( bordertype == IPL_BORDER_REFLECT_101 ) { icvCopyReflect101Border_8u( src->data.ptr, srcstep, srcsize, dst->data.ptr, dststep, dstsize, offset.y, offset.x, pix_size ); } else if( bordertype == IPL_BORDER_CONSTANT ) { double buf[4]; cvScalarToRawData( &value, buf, src->type, 0 ); icvCopyConstBorder_8u( src->data.ptr, srcstep, srcsize, dst->data.ptr, dststep, dstsize, offset.y, offset.x, pix_size, (uchar*)buf ); } else CV_Error( CV_StsBadFlag, "Unknown/unsupported border type" ); }
CV_IMPL void cvCornerEigenValsAndVecs( const void* srcarr, void* eigenvarr, int block_size, int aperture_size ) { static CvFuncTable eig_tab; static int inittab = 0; void *buffer = 0; CV_FUNCNAME( "cvCornerEigenValsAndVecs" ); __BEGIN__; CvSize src_size; int buf_size; CvEigFunc func = 0; CvMat stub, *src = (CvMat*)srcarr; CvMat eigstub, *eigenv = (CvMat*)eigenvarr; if( !inittab ) { icvInitEigenValsVecsTable( &eig_tab ); inittab = 1; } CV_CALL( src = cvGetMat( srcarr, &stub )); CV_CALL( eigenv = cvGetMat( eigenv, &eigstub )); if( CV_ARR_CN(src->type) != 1 ) CV_ERROR(CV_StsBadArg, "Source image has more than 1 channel"); if( CV_ARR_CN(eigenv->type)*eigenv->width != src->width*6 ) CV_ERROR(CV_StsBadArg, "Eigen-vals&vecs image should be 6 times " "wider than the source image"); if( src->height != eigenv->height ) CV_ERROR( CV_StsUnmatchedSizes, "" ); if( CV_ARR_DEPTH(eigenv->type) != CV_32F ) CV_ERROR( CV_BadDepth, "Eigen-vals&vecs image does not have IPL_DEPTH_32F depth" ); func = (CvEigFunc)(eig_tab.fn_2d[CV_ARR_DEPTH(src->type)]); if( !func ) CV_ERROR( CV_StsUnsupportedFormat, "" ); src_size = icvGetMatSize( src ); IPPI_CALL( icvEigenValsVecsGetSize( src_size.width, aperture_size, block_size, &buf_size )); CV_CALL( buffer = cvAlloc( buf_size )); IPPI_CALL( func( src->data.ptr, src->step, eigenv->data.ptr, eigenv->step, src_size, aperture_size, block_size, buffer )); __END__; cvFree( &buffer ); }
CV_IMPL void cvGetRectSubPix( const void* srcarr, void* dstarr, CvPoint2D32f center ) { static CvFuncTable gr_tab[2]; static int inittab = 0; CvMat srcstub, *src = (CvMat*)srcarr; CvMat dststub, *dst = (CvMat*)dstarr; CvSize src_size, dst_size; CvGetRectSubPixFunc func; int cn, src_step, dst_step; if( !inittab ) { icvInitGetRectSubPixC1RTable( gr_tab + 0 ); icvInitGetRectSubPixC3RTable( gr_tab + 1 ); inittab = 1; } if( !CV_IS_MAT(src)) src = cvGetMat( src, &srcstub ); if( !CV_IS_MAT(dst)) dst = cvGetMat( dst, &dststub ); cn = CV_MAT_CN( src->type ); if( (cn != 1 && cn != 3) || !CV_ARE_CNS_EQ( src, dst )) CV_Error( CV_StsUnsupportedFormat, "" ); src_size = cvGetMatSize( src ); dst_size = cvGetMatSize( dst ); src_step = src->step ? src->step : CV_STUB_STEP; dst_step = dst->step ? dst->step : CV_STUB_STEP; //if( dst_size.width > src_size.width || dst_size.height > src_size.height ) // CV_ERROR( CV_StsBadSize, "destination ROI must be smaller than source ROI" ); if( CV_ARE_DEPTHS_EQ( src, dst )) { func = (CvGetRectSubPixFunc)(gr_tab[cn != 1].fn_2d[CV_MAT_DEPTH(src->type)]); } else { if( CV_MAT_DEPTH( src->type ) != CV_8U || CV_MAT_DEPTH( dst->type ) != CV_32F ) CV_Error( CV_StsUnsupportedFormat, "" ); func = (CvGetRectSubPixFunc)(gr_tab[cn != 1].fn_2d[1]); } if( !func ) CV_Error( CV_StsUnsupportedFormat, "" ); IPPI_CALL( func( src->data.ptr, src_step, src_size, dst->data.ptr, dst_step, dst_size, center )); }
void cvNeumannBoundCond(const CvArr * srcarr, CvArr * dstarr) { //CV_FUNCNAME("cvNeumannBoundCond"); //__BEGIN__; CvMat sstub, *src; CvMat dstub, *dst; CvSize size; int i, j; float * ptr_src, * ptr_dst; int iStep_src, iStep_dst; // CV_CALL( src = cvGetMat(srcarr, &sstub )); // CV_CALL( dst = cvGetMat(dstarr, &dstub )); src = cvGetMat(srcarr, &sstub ); dst = cvGetMat(dstarr, &dstub ); // if( CV_MAT_TYPE(src->type) != CV_32FC1) // CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); // if( CV_MAT_TYPE(dst->type) != CV_32FC1) // CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); // if( !CV_ARE_SIZES_EQ(src, dst)) // CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" ); size = cvGetMatSize( src ); cvCopy(src, dst); ptr_src = src->data.fl; iStep_src = src->step / sizeof(ptr_src[0]); ptr_dst = dst->data.fl; iStep_dst = dst->step / sizeof(ptr_dst[0]); ptr_dst[0] = ptr_src[2+iStep_src*2]; //dst(0,0)=src(3,3) ptr_dst[size.width-1] = ptr_src[size.width-3+iStep_src*2]; //dst(0,col-1)=src(3,col-3) ptr_dst[iStep_dst*(size.height-1)] = ptr_src[2+iStep_src*(size.height-3)]; //dst(row-1,0)=src(row-3,3) ptr_dst[size.width-1+iStep_dst*(size.height-1)] = ptr_src[size.width-3+iStep_dst*(size.height-3)]; //dst(row-1,col-1)=src(row-3,col-3) for(i = 1; i < size.width-1; i++){ ptr_dst[i] = ptr_src[i+iStep_src*2]; ptr_dst[i+iStep_dst*(size.height-1)]=ptr_src[i+iStep_src*(size.height-3)]; } for(j = 1; j < size.height-1; j++){ ptr_dst[iStep_dst*j] = ptr_src[2+iStep_src*j]; ptr_dst[size.width-1+iStep_dst*j]=ptr_src[size.width-3+iStep_src*j]; } //__END__; }
CV_IMPL void cvCornerMinEigenVal( const void* srcarr, void* eigenvarr, int block_size, int aperture_size ) { static CvFuncTable eig_tab; static int inittab = 0; void *buffer = 0; CV_FUNCNAME( "cvCornerMinEigenVal" ); __BEGIN__; CvSize src_size; int buf_size; CvEigFunc func = 0; CvMat stub, *src = (CvMat*)srcarr; CvMat eigstub, *eigenv = (CvMat*)eigenvarr; if( !inittab ) { icvInitMinEigenValTable( &eig_tab ); inittab = 1; } CV_CALL( src = cvGetMat( srcarr, &stub )); CV_CALL( eigenv = cvGetMat( eigenv, &eigstub )); if( CV_ARR_CN(src->type) != 1 || CV_ARR_CN(eigenv->type) != 1 ) CV_ERROR(CV_StsBadArg, "Source or min-eigen-val images have more than 1 channel"); if( CV_ARR_DEPTH(eigenv->type) != CV_32F ) CV_ERROR( CV_BadDepth, "min-eigen-val image does not have IPL_DEPTH_32F depth" ); if( !CV_ARE_SIZES_EQ( src, eigenv )) CV_ERROR( CV_StsUnmatchedSizes, "" ); func = (CvEigFunc)(eig_tab.fn_2d[CV_ARR_DEPTH(src->type)]); if( !func ) CV_ERROR( CV_StsUnsupportedFormat, "" ); src_size = icvGetMatSize( src ); IPPI_CALL( icvMinEigenValGetSize( src_size.width, aperture_size, block_size, &buf_size )); CV_CALL( buffer = cvAlloc( buf_size )); IPPI_CALL( func( src->data.ptr, src->step, eigenv->data.ptr, eigenv->step, src_size, aperture_size, block_size, buffer )); __END__; cvFree( &buffer ); }
CV_IMPL void cvCalS(const CvArr* srcarr, CvArr* dstarr) { CV_FUNCNAME("cvCalS"); __BEGIN__; CvMat sstub, *src; CvMat dstub, *dst; CvMat* src_dx=0, *src_dy=0; CvSize size; int i, j; int iStep; float* fPtr; CV_CALL( src = cvGetMat(srcarr, &sstub )); CV_CALL( dst = cvGetMat(dstarr, &dstub )); if( CV_MAT_TYPE(src->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( CV_MAT_TYPE(dst->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( !CV_ARE_SIZES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" ); size = cvGetMatSize( src ); src_dx = cvCreateMat(size.height, size.width, CV_32FC1 ); src_dy = cvCreateMat(size.height, size.width, CV_32FC1 ); cvSetZero(src_dx); cvSetZero(src_dy); iStep = dst->step / sizeof(fPtr[0]); fPtr = dst->data.fl; cvSobel(src, src_dx, 1, 0, 1); cvSobel(src, src_dy, 0, 1, 1); cvMul(src_dx, src_dx, src_dx, 0.25f*0.25f); //rescale gradient cvMul(src_dy, src_dy, src_dy, 0.25f*0.25f); //rescale gradient cvAdd(src_dx, src_dy, dst); for(j=0; j<size.height; j++){ for (i=0; i<size.width; i++) fPtr[i+iStep*j] = sqrt(fPtr[i+iStep*j])+SMALLNUM; } cvReleaseMat(&src_dx); cvReleaseMat(&src_dy); __END__; }
CV_IMPL void cvCurvature(const CvArr* srcarr_x, const CvArr* srcarr_y, CvArr* dstarr) { CV_FUNCNAME("cvCurvature"); __BEGIN__; CvMat sstub_x, sstub_y, *src_x, *src_y; CvMat dstub, *dst; CvSize size; CvMat *Nxx=0, *Nyy=0, *ones=0; CV_CALL( src_x = cvGetMat(srcarr_x, &sstub_x )); CV_CALL( src_y = cvGetMat(srcarr_y, &sstub_y )); CV_CALL( dst = cvGetMat(dstarr, &dstub )); if( CV_MAT_TYPE(src_x->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( CV_MAT_TYPE(src_y->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( CV_MAT_TYPE(dst->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( !CV_ARE_SIZES_EQ( src_x, src_y )) CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" ); size = cvGetMatSize( src_x ); Nxx = cvCreateMat(size.height, size.width, CV_32FC1 ); Nyy = cvCreateMat(size.height, size.width, CV_32FC1 ); ones= cvCreateMat(size.height, size.width, CV_32FC1 ); cvSetZero(Nxx); cvSetZero(Nyy); cvSet(ones, cvScalar(1.0f)); cvSobel(src_x, Nxx, 1, 0, 1); cvSobel(src_y, Nyy, 0, 1, 1); cvMul(Nxx, ones, Nxx, 0.25f); cvMul(Nyy, ones, Nyy, 0.25f); cvAdd(Nxx, Nyy, dst); cvReleaseMat(&Nxx); cvReleaseMat(&Nyy); cvReleaseMat(&ones); __END__; }
// get column of input array CV_IMPL CvMat* cvGetCol( const CvArr* arr, CvMat* submat, int col ) { CvMat* res = 0; CV_FUNCNAME( "cvGetCol" ); __BEGIN__; CvMat stub, *mat = (CvMat*)arr; if( !CV_IS_ARR( mat )) CV_CALL( mat = cvGetMat( mat, &stub )); if( !submat ) CV_ERROR( CV_StsNullPtr, "" ); if( (unsigned)col >= (unsigned)mat->width ) CV_ERROR( CV_StsOutOfRange, "" ); CV_CALL( cvInitMatHeader( submat, mat->height, 1, mat->type, mat->data.ptr + col*icvPixSize[CV_ARR_TYPE(mat->type)], mat->step )); res = submat; __END__; return res; }
CVAPI(void) cvShowImageEx(const char * id, const CvArr * arr, const int cm) { CvMat * src, src_stub; double minval, maxval, maxdiff; CvPoint minloc, maxloc; int type = cvGetElemType(arr); CvMat * disp, * src_scaled; int i, j; if (!CV_IS_MAT(arr)) src = cvGetMat(arr, &src_stub); else{ src = (CvMat*)arr; } src = cvCloneMat(src); if ( (src->rows<60) || (src->rows<60) ) { CvMat * orig = cvCloneMat(src); int scale=60./MIN(orig->rows, orig->cols); cvReleaseMat(&src); src = cvCreateMat(orig->rows*scale, orig->cols*scale, CV_MAT_TYPE(orig->type)); int m,n; if (CV_MAT_TYPE(src->type)==CV_64F){ for (m=0;m<orig->rows;m++) { for (n=0;n<orig->cols;n++) { for (i=0;i<scale;i++) { for (j=0;j<scale;j++) { CV_MAT_ELEM(*src, double, m*scale+i, n*scale+j) = CV_MAT_ELEM(*orig, double, m, n); } } } } }else if (CV_MAT_TYPE(src->type)==CV_32F){
CV_IMPL int cvSampleLine( const void* img, CvPoint pt1, CvPoint pt2, void* _buffer, int connectivity ) { int count = -1; int i, coi = 0, pix_size; CvMat stub, *mat = cvGetMat( img, &stub, &coi ); CvLineIterator iterator; uchar* buffer = (uchar*)_buffer; if( coi != 0 ) CV_Error( CV_BadCOI, "" ); if( !buffer ) CV_Error( CV_StsNullPtr, "" ); count = cvInitLineIterator( mat, pt1, pt2, &iterator, connectivity ); pix_size = CV_ELEM_SIZE(mat->type); for( i = 0; i < count; i++ ) { for( int j = 0; j < pix_size; j++ ) buffer[j] = iterator.ptr[j]; buffer += pix_size; CV_NEXT_LINE_POINT( iterator ); } return count; }
// Generate and return a boolean array from the source image. // Return 0 if a failure occurs or if the source image is undefined. JNIEXPORT jbooleanArray JNICALL Java_org_siprop_opencv_OpenCV_getSourceImage(JNIEnv* env, jobject thiz) { if (m_sourceImage == 0) { LOGE("Error source image was not set."); return 0; } CvMat stub; CvMat *mat_image = cvGetMat(m_sourceImage, &stub); int channels = CV_MAT_CN( mat_image->type ); int ipl_depth = cvCvToIplDepth(mat_image->type); WLNonFileByteStream *strm = new WLNonFileByteStream(); loadImageBytes(mat_image->data.ptr, mat_image->step, mat_image->width, mat_image->height, ipl_depth, channels, strm); int imageSize = strm->GetSize(); jbooleanArray res_array = env->NewBooleanArray(imageSize); if (res_array == 0) { LOGE("Unable to allocate a new boolean array for the source image."); return 0; } env->SetBooleanArrayRegion(res_array, 0, imageSize, (jboolean*)strm->GetByte()); strm->Close(); SAFE_DELETE(strm); return res_array; }
static CvMat* icvRetrieveMatrix( void* obj ) { CvMat* m = 0; CV_FUNCNAME( "icvRetrieveMatrix" ); __BEGIN__; if( CV_IS_MAT(obj) ) m = (CvMat*)obj; else if( CV_IS_IMAGE(obj) ) { IplImage* img = (IplImage*)obj; CvMat hdr, *src = cvGetMat( img, &hdr ); CV_CALL( m = cvCreateMat( src->rows, src->cols, src->type )); CV_CALL( cvCopy( src, m )); cvReleaseImage( &img ); } else if( obj ) { cvRelease( &obj ); CV_ERROR( CV_StsUnsupportedFormat, "The object is neither an image, nor a matrix" ); } __END__; return m; }
// get ROI (or minor) of input array CV_IMPL CvMat* cvGetSubArr( const CvArr* arr, CvMat* submat, CvRect rect ) { CvMat* res = 0; CV_FUNCNAME( "cvGetSubArr" ); __BEGIN__; CvMat stub, *mat = (CvMat*)arr; if( !CV_IS_ARR( mat )) CV_CALL( mat = cvGetMat( mat, &stub )); if( !submat ) CV_ERROR( CV_StsNullPtr, "" ); if( (rect.x|rect.y|rect.width|rect.height) < 0 ) CV_ERROR( CV_StsBadSize, "" ); if( rect.x + rect.width > mat->width || rect.y + rect.height > mat->height ) CV_ERROR( CV_StsBadSize, "" ); CV_CALL( cvInitMatHeader( submat, rect.height, rect.width, mat->type, mat->data.ptr + rect.y*mat->step + rect.x*icvPixSize[CV_ARR_TYPE(mat->type)], mat->step )); res = submat; __END__; return res; }
DOUBLEVECT HoughAccumulator::FindBest() { DOUBLEVECT v; CvMat temp; CvMat* locMat = cvGetMat(acc, &temp, NULL, 1); // int rowsize = 4 * ((acc->dims / 4) + // ((acc->dims % 4 > 0) ? 1 : 0)); double max_val; CvPoint max_loc; cvMinMaxLoc(locMat, NULL, &max_val, NULL, &max_loc, NULL); int indraw = max_loc.x + max_loc.y * locMat->step; uchar* pValue = cvPtr2D(locMat, max_loc.y, max_loc.x); if (*pValue < 10) return v; indices[0] = indraw / acc->dim[0].step; indices[acc->dims - 1] = indraw % acc->dim[acc->dims - 2].step; for (int i = 1; i < acc->dims - 1; i ++) indices[i] = (indraw % acc->dim[i - 1].step) / acc->dim[i].step; for (int j = 0; j < acc->dims; j++) { double d = indices[j] / (float)precision + paramRanges[j].min; v.push_back(d); } return v; }
void cvImageWidgetSetImage(CvImageWidget * widget, const CvArr *arr){ CvMat * mat, stub; int origin=0; //printf("cvImageWidgetSetImage\n"); if( CV_IS_IMAGE_HDR( arr )) origin = ((IplImage*)arr)->origin; mat = cvGetMat(arr, &stub); if(widget->original_image && !CV_ARE_SIZES_EQ(mat, widget->original_image)){ cvReleaseMat( &widget->original_image ); } if(!widget->original_image){ widget->original_image = cvCreateMat( mat->rows, mat->cols, CV_8UC3 ); gtk_widget_queue_resize( GTK_WIDGET( widget ) ); } cvConvertImage( mat, widget->original_image, (origin != 0 ? CV_CVTIMG_FLIP : 0) + CV_CVTIMG_SWAP_RB ); if(widget->scaled_image){ cvResize( widget->original_image, widget->scaled_image, CV_INTER_AREA ); } // window does not refresh without this gtk_widget_queue_draw( GTK_WIDGET(widget) ); }
TDV_NAMESPACE_BEGIN bool ImageReader::update() { WriteGuard<ReadWritePipe<CvMat*> > wg(m_wpipe); if ( m_cImg < m_filenames.size() ) { const std::string &filename(m_filenames[m_cImg++]); IplImage *img = cvLoadImage(filename.c_str()); if ( img != NULL ) { #if 0 CvMat *mat = cvCreateMatHeader(img->height, img->width, CV_8UC3); mat = cvGetMat(img, mat); #else CvMat *mat = cvCreateMat(img->height, img->width, CV_8UC3); cvConvertImage(img, mat, CV_CVTIMG_SWAP_RB); cvReleaseImage(&img); #endif wg.write(mat); } else { throw Exception(boost::format("can't open image: %1%") % filename); } } return wg.wasWrite(); }
// get row of input array CV_IMPL CvMat* cvGetRow( const CvArr* arr, CvMat* submat, int row ) { CvMat* res = 0; CV_FUNCNAME( "cvGetRow" ); __BEGIN__; CvMat stub, *mat = (CvMat*)arr; if( !CV_IS_ARR( mat )) CV_CALL( mat = cvGetMat( mat, &stub )); if( !submat ) CV_ERROR( CV_StsNullPtr, "" ); if( (unsigned)row >= (unsigned)mat->height ) CV_ERROR( CV_StsOutOfRange, "" ); CV_CALL( cvInitMatHeader( submat, 1, mat->width, mat->type, mat->data.ptr + row*mat->step, CV_AUTOSTEP )); res = submat; __END__; return res; }
CV_IMPL void cvImgToObs_DCT( const void* arr, float *obs, CvSize dctSize, CvSize obsSize, CvSize delta ) { CV_FUNCNAME( "cvImgToObs_DCT" ); __BEGIN__; CvMat stub, *mat = (CvMat*)arr; CV_CALL( mat = cvGetMat( arr, &stub )); switch( CV_MAT_TYPE( mat->type )) { case CV_8UC1: IPPI_CALL( icvImgToObs_DCT_8u32f_C1R( mat->data.ptr, mat->step, cvGetMatSize(mat), obs, dctSize, obsSize, delta )); break; case CV_32FC1: IPPI_CALL( icvImgToObs_DCT_32f_C1R( mat->data.fl, mat->step, cvGetMatSize(mat), obs, dctSize, obsSize, delta )); break; default: CV_ERROR( CV_StsUnsupportedFormat, "" ); } __END__; }
CvArr * cvCvtSeqToArray_Shadow( const CvSeq* seq, CvArr * elements, CvSlice slice){ CvMat stub, *mat=(CvMat *)elements; if(!CV_IS_MAT(mat)){ mat = cvGetMat(elements, &stub); } cvCvtSeqToArray( seq, mat->data.ptr, slice ); return elements; }
void printNumberByMat(IplImage* getNumberPicture, vector<ContourData> contourData){ CvMat *srcMat, matHeader; for (int i = 0; i < contourData.size(); i++) { cvSetImageROI(getNumberPicture, cvRect(contourData[i].getMinX(), contourData[i].getMinY(), contourData[i].getWidth(), contourData[i].getHeight())); srcMat = cvGetMat(getNumberPicture, &matHeader); PrintMat(srcMat, "srcMat"); } }
CV_IMPL void cvDirac(const CvArr* srcarr, CvArr* dstarr, double sigma) { CV_FUNCNAME("cvDirac"); __BEGIN__; CvMat sstub, *src; CvMat dstub, *dst; CvSize size; int i, j, iStep_src, iStep_dst; float* fPtr_src, *fPtr_dst, flag=0.0f; float temp1=0.0f, temp2=0.0f; CV_CALL( src = cvGetMat(srcarr, &sstub )); CV_CALL( dst = cvGetMat(dstarr, &dstub )); if( CV_MAT_TYPE(src->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel input images are supported" ); if( CV_MAT_TYPE(dst->type) != CV_32FC1) CV_ERROR( CV_StsUnsupportedFormat, "Only-32bit, 1-channel output images are supported" ); if( !CV_ARE_SIZES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedSizes, "The input images must have the same size" ); size = cvGetMatSize( src ); iStep_src = src->step / sizeof(fPtr_src[0]); fPtr_src = src->data.fl; iStep_dst = dst->step / sizeof(fPtr_dst[0]); fPtr_dst = dst->data.fl; for (j=0; j<size.height; j++){ for (i=0; i<size.width; i++){ temp1 = fPtr_src[i+iStep_src*j]; temp2 = (1.0f/2.0f/sigma)*(1.0f+cos(PI*temp1/sigma)); if (int(temp1*10000)<=int(sigma*10000) && int(temp1*10000)>=int(-sigma*10000)) { flag = 1.0f; } else { flag = 0.0f; } fPtr_dst[i+iStep_dst*j]=temp2*flag; } } __END__; }
int main(int argc, char * argv[]) { int i,j; const char * imglist[] = { "../data/palm.train/positive.txt", "../data/palm.train/negative.txt","" }; char filename[2][1<<13][256]; int count[2]={0,0}; char line[1024]; FILE * fp; IplImage * tmp; CvMat *** samples = new CvMat **[2]; CvMat ** samples_stub = new CvMat *[2]; // load image info for (i=0;i<2;i++){ fp = fopen(imglist[i],"r"); for (j=0;;j++){ fgets(line,1024,fp); if (line[0]=='-'){break;} // strcpy(filename[i][j],line); sscanf(line,"%s",filename[i][j]); } fclose(fp); count[i]=j-1; } // load raw image for (i=0;i<2;i++){ samples[i] = new CvMat * [count[i]]; samples_stub[i] = new CvMat[count[i]]; for (j=0;j<count[i];j++){ if (!icvFileExist(filename[i][j])){ LOGE("file %s not exist",filename[i][j]); } tmp = cvLoadImage(filename[i][j],0); samples[i][j] = cvCloneMat(cvGetMat(tmp,&samples_stub[i][j])); cvReleaseImage(&tmp); } } // fprintf(stderr, "INFO: %d positive samples!\n", i); CvStagedDetectorHOG detector; detector.cascadetrain(samples[0],count[0],samples[1],count[1]); // release raw images for (i=0;i<2;i++){ for (j=0;j<count[i];j++){ cvReleaseMat(&samples[i][j]); } delete [] samples[i]; } delete [] samples; return 0; }
/*F/////////////////////////////////////////////////////////////////////////////////////// // Name: cvCalcOpticalFlowHS // Purpose: Optical flow implementation // Context: // Parameters: // srcA, srcB - source image // velx, vely - destination image // Returns: // // Notes: //F*/ CV_IMPL void cvCalcOpticalFlowHS( const void* srcarrA, const void* srcarrB, int usePrevious, void* velarrx, void* velarry, double lambda, CvTermCriteria criteria ) { CV_FUNCNAME( "cvCalcOpticalFlowHS" ); __BEGIN__; CvMat stubA, *srcA = (CvMat*)srcarrA; CvMat stubB, *srcB = (CvMat*)srcarrB; CvMat stubx, *velx = (CvMat*)velarrx; CvMat stuby, *vely = (CvMat*)velarry; CV_CALL( srcA = cvGetMat( srcA, &stubA )); CV_CALL( srcB = cvGetMat( srcB, &stubB )); CV_CALL( velx = cvGetMat( velx, &stubx )); CV_CALL( vely = cvGetMat( vely, &stuby )); if( !CV_ARE_TYPES_EQ( srcA, srcB )) CV_ERROR( CV_StsUnmatchedFormats, "Source images have different formats" ); if( !CV_ARE_TYPES_EQ( velx, vely )) CV_ERROR( CV_StsUnmatchedFormats, "Destination images have different formats" ); if( !CV_ARE_SIZES_EQ( srcA, srcB ) || !CV_ARE_SIZES_EQ( velx, vely ) || !CV_ARE_SIZES_EQ( srcA, velx )) CV_ERROR( CV_StsUnmatchedSizes, "" ); if( CV_MAT_TYPE( srcA->type ) != CV_8UC1 || CV_MAT_TYPE( velx->type ) != CV_32FC1 ) CV_ERROR( CV_StsUnsupportedFormat, "Source images must have 8uC1 type and " "destination images must have 32fC1 type" ); if( srcA->step != srcB->step || velx->step != vely->step ) CV_ERROR( CV_BadStep, "source and destination images have different step" ); IPPI_CALL( icvCalcOpticalFlowHS_8u32fR( (uchar*)srcA->data.ptr, (uchar*)srcB->data.ptr, srcA->step, cvGetMatSize( srcA ), usePrevious, velx->data.fl, vely->data.fl, velx->step, (float)lambda, criteria )); __END__; }
/* motion templates */ CV_IMPL void cvUpdateMotionHistory( const void* silhouette, void* mhimg, double timestamp, double mhi_duration ) { CvSize size; CvMat silhstub, *silh = (CvMat*)silhouette; CvMat mhistub, *mhi = (CvMat*)mhimg; int mhi_step, silh_step; CV_FUNCNAME( "cvUpdateMHIByTime" ); __BEGIN__; CV_CALL( silh = cvGetMat( silh, &silhstub )); CV_CALL( mhi = cvGetMat( mhi, &mhistub )); if( !CV_IS_MASK_ARR( silh )) CV_ERROR( CV_StsBadMask, "" ); if( CV_MAT_CN( mhi->type ) > 1 ) CV_ERROR( CV_BadNumChannels, "" ); if( CV_MAT_DEPTH( mhi->type ) != CV_32F ) CV_ERROR( CV_BadDepth, "" ); if( !CV_ARE_SIZES_EQ( mhi, silh )) CV_ERROR( CV_StsUnmatchedSizes, "" ); size = cvGetMatSize( mhi ); mhi_step = mhi->step; silh_step = silh->step; if( CV_IS_MAT_CONT( mhi->type & silh->type )) { size.width *= size.height; mhi_step = silh_step = CV_STUB_STEP; size.height = 1; } IPPI_CALL( icvUpdateMotionHistory_8u32f_C1IR( (const uchar*)(silh->data.ptr), silh_step, mhi->data.fl, mhi_step, size, (float)timestamp, (float)mhi_duration )); __END__; }
CV_IMPL void cvPreCornerDetect( const void* srcarr, void* dstarr, int aperture_size ) { static CvFuncTable pre_tab; static int inittab = 0; CV_FUNCNAME( "cvPreCornerDetect" ); __BEGIN__; CvSize src_size; CvPreCornerFunc func = 0; CvMat srcstub, *src = (CvMat*)srcarr; CvMat dststub, *dst = (CvMat*)dstarr; if( !inittab ) { icvInitPreCornerDetectTable( &pre_tab ); inittab = 1; } CV_CALL( src = cvGetMat( srcarr, &srcstub )); CV_CALL( dst = cvGetMat( dstarr, &dststub )); if( CV_ARR_CN(src->type) != 1 || CV_ARR_CN(dst->type) != 1 ) CV_ERROR(CV_StsBadArg, "Source or min-eigen-val images have more than 1 channel"); if( CV_ARR_DEPTH(dst->type) != CV_32F ) CV_ERROR( CV_BadDepth, "min-eigen-val image does not have IPL_DEPTH_32F depth" ); if( !CV_ARE_SIZES_EQ( src, dst )) CV_ERROR( CV_StsUnmatchedSizes, "" ); func = (CvPreCornerFunc)(pre_tab.fn_2d[CV_ARR_DEPTH(src->type)]); if( !func ) CV_ERROR( CV_StsUnsupportedFormat, "" ); src_size = icvGetMatSize( src ); IPPI_CALL( func( src->data.ptr, src->step, dst->data.ptr, dst->step, src_size, aperture_size )); __END__; }
/* Calculates bounding rectagnle of a point set or retrieves already calculated */ CV_IMPL CvRect cvBoundingRect( CvArr* array, int update ) { CvRect rect = { 0, 0, 0, 0 }; CvContour contour_header; CvSeq* ptseq = 0; CvSeqBlock block; CvMat stub, *mat = 0; int calculate = update; if( CV_IS_SEQ( array )) { ptseq = (CvSeq*)array; if( !CV_IS_SEQ_POINT_SET( ptseq )) CV_Error( CV_StsBadArg, "Unsupported sequence type" ); if( ptseq->header_size < (int)sizeof(CvContour)) { update = 0; calculate = 1; } } else { mat = cvGetMat( array, &stub ); if( CV_MAT_TYPE(mat->type) == CV_32SC2 || CV_MAT_TYPE(mat->type) == CV_32FC2 ) { ptseq = cvPointSeqFromMat(CV_SEQ_KIND_GENERIC, mat, &contour_header, &block); mat = 0; } else if( CV_MAT_TYPE(mat->type) != CV_8UC1 && CV_MAT_TYPE(mat->type) != CV_8SC1 ) CV_Error( CV_StsUnsupportedFormat, "The image/matrix format is not supported by the function" ); update = 0; calculate = 1; } if( !calculate ) return ((CvContour*)ptseq)->rect; if( mat ) { rect = cv::maskBoundingRect(cv::cvarrToMat(mat)); } else if( ptseq->total ) { cv::AutoBuffer<double> abuf; rect = cv::pointSetBoundingRect(cv::cvarrToMat(ptseq, false, false, 0, &abuf)); } if( update ) ((CvContour*)ptseq)->rect = rect; return rect; }