void asef_locate_eyes(AsefEyeLocator *asef){ asef->face_image.cols = asef->face_rect.width; asef->face_image.rows = asef->face_rect.height; asef->face_image.type = CV_8UC1; asef->face_image.step = asef->face_rect.width; cvGetSubRect(asef->input_image, &asef->face_image, asef->face_rect); double xscale = ((double)asef->scaled_face_image_8uc1->cols)/((double)asef->face_image.cols); double yscale = ((double)asef->scaled_face_image_8uc1->rows)/((double)asef->face_image.rows); cvResize(&asef->face_image, asef->scaled_face_image_8uc1, CV_INTER_LINEAR); cvLUT(asef->scaled_face_image_8uc1, asef->scaled_face_image_32fc1, asef->lut); cvDFT(asef->scaled_face_image_32fc1, asef->scaled_face_image_32fc1, CV_DXT_FORWARD, 0); cvMulSpectrums(asef->scaled_face_image_32fc1, asef->lfilter_dft, asef->lcorr, CV_DXT_MUL_CONJ); cvMulSpectrums(asef->scaled_face_image_32fc1, asef->rfilter_dft, asef->rcorr, CV_DXT_MUL_CONJ); cvDFT(asef->lcorr, asef->lcorr, CV_DXT_INV_SCALE, 0); cvDFT(asef->rcorr, asef->rcorr, CV_DXT_INV_SCALE, 0); cvMinMaxLoc(asef->lroi, NULL, NULL, NULL, &asef->left_eye, NULL); cvMinMaxLoc(asef->rroi, NULL, NULL, NULL, &asef->right_eye, NULL); asef->left_eye.x = (asef->lrect.x + asef->left_eye.x)/xscale + asef->face_rect.x; asef->left_eye.y = (asef->lrect.y + asef->left_eye.y)/yscale + asef->face_rect.y; asef->right_eye.x = (asef->rrect.x + asef->right_eye.x)/xscale + asef->face_rect.x; asef->right_eye.y = (asef->rrect.y + asef->right_eye.y)/yscale + asef->face_rect.y; }
void asef_initialze(AsefEyeLocator *asef, const char *file_name){ load_asef_filters(file_name, &asef->n_rows, &asef->n_cols, &asef->lrect, &asef->rrect, &asef->lfilter, &asef->rfilter); asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->image = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->image_tile = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1); asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1); asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1); cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0); cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0); cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect); cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect); asef->lut = cvCreateMat(256, 1, CV_32FC1); for (int i = 0; i<256; i++){ cvmSet(asef->lut, i, 0, 1.0 + i); } cvLog(asef->lut, asef->lut); }
void asef_locate_eyes(AsefEyeLocator *asef, IplImage *image, CvRect face_rect, CvPoint *leye, CvPoint *reye){ asef->face_img.cols = face_rect.width; asef->face_img.rows = face_rect.height; asef->face_img.type = CV_8UC1; asef->face_img.step = face_rect.width; cvGetSubRect(image, &asef->face_img, face_rect); double xscale = ((double)asef->image_tile->cols)/((double)asef->face_img.cols); double yscale = ((double)asef->image_tile->rows)/((double)asef->face_img.rows); cvResize(&asef->face_img, asef->image_tile, CV_INTER_LINEAR); cvLUT(asef->image_tile, asef->image, asef->lut); cvDFT(asef->image, asef->image, CV_DXT_FORWARD, 0); cvMulSpectrums(asef->image, asef->lfilter_dft, asef->lcorr, CV_DXT_MUL_CONJ); cvMulSpectrums(asef->image, asef->rfilter_dft, asef->rcorr, CV_DXT_MUL_CONJ); cvDFT(asef->lcorr, asef->lcorr, CV_DXT_INV_SCALE, 0); cvDFT(asef->rcorr, asef->rcorr, CV_DXT_INV_SCALE, 0); cvMinMaxLoc(asef->lroi, NULL, NULL, NULL, leye, NULL); cvMinMaxLoc(asef->rroi, NULL, NULL, NULL, reye, NULL); leye->x = (asef->lrect.x + leye->x)/xscale + face_rect.x; leye->y = (asef->lrect.y + leye->y)/yscale + face_rect.y; reye->x = (asef->rrect.x + reye->x)/xscale + face_rect.x; reye->y = (asef->rrect.y + reye->y)/yscale + face_rect.y; }
int main(int argc, char** argv) { int M1 = 2; int M2 = 2; int N1 = 2; int N2 = 2; // initialize A and B // CvMat* A = cvCreateMat(M1, N1, CV_32F); CvMat* B = cvCreateMat(M2, N2, A->type); // it is also possible to have only abs(M2-M1)+1×abs(N2-N1)+1 // part of the full convolution result CvMat* conv = cvCreateMat(A->rows + B->rows - 1, A->cols + B->cols - 1, A->type); int dft_M = cvGetOptimalDFTSize(A->rows + B->rows - 1); int dft_N = cvGetOptimalDFTSize(A->cols + B->cols - 1); CvMat* dft_A = cvCreateMat(dft_M, dft_N, A->type); CvMat* dft_B = cvCreateMat(dft_M, dft_N, B->type); CvMat tmp; // copy A to dft_A and pad dft_A with zeros // cvGetSubRect(dft_A, &tmp, cvRect(0, 0, A->cols, A->rows)); cvCopy(A, &tmp); cvGetSubRect(dft_A, &tmp, cvRect(A->cols, 0, dft_A->cols - A->cols, A->rows)); cvZero(&tmp); // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below // cvDFT(dft_A, dft_A, CV_DXT_FORWARD, A->rows); // repeat the same with the second array // cvGetSubRect(dft_B, &tmp, cvRect(0, 0, B->cols, B->rows)); cvCopy(B, &tmp); cvGetSubRect(dft_B, &tmp, cvRect(B->cols, 0, dft_B->cols - B->cols, B->rows)); cvZero(&tmp); // no need to pad bottom part of dft_B with zeros because of // use nonzero_rows parameter in cvDFT() call below // cvDFT(dft_B, dft_B, CV_DXT_FORWARD, B->rows); // or CV_DXT_MUL_CONJ to get correlation rather than convolution // cvMulSpectrums(dft_A, dft_B, dft_A, 0); // calculate only the top part // cvDFT(dft_A, dft_A, CV_DXT_INV_SCALE, conv->rows); cvGetSubRect(dft_A, &tmp, cvRect(0, 0, conv->cols, conv->rows)); cvCopy(&tmp, conv); return 0; }
void ASEF_Algorithm::detecteyes(Mat face_image) { if (isInitialized == false) this->initialize(); double xscale = ((double) scaled_face_image_8uc1->cols) / ((double) face_image.cols); double yscale = ((double) scaled_face_image_8uc1->rows) / ((double) face_image.rows); CvMat temp = face_image; cvResize(&temp, scaled_face_image_8uc1, CV_INTER_LINEAR); cvLUT(scaled_face_image_8uc1, scaled_face_image_32fc1, lut); cvDFT(scaled_face_image_32fc1, scaled_face_image_32fc1, CV_DXT_FORWARD, 0); cvMulSpectrums(scaled_face_image_32fc1, lfilter_dft, lcorr, CV_DXT_MUL_CONJ); cvMulSpectrums(scaled_face_image_32fc1, rfilter_dft, rcorr, CV_DXT_MUL_CONJ); cvDFT(lcorr, lcorr, CV_DXT_INV_SCALE, 0); cvDFT(rcorr, rcorr, CV_DXT_INV_SCALE, 0); minMaxLoc(Mat(lroi), &MinValuel, NULL, NULL, &left_eye); minMaxLoc(Mat(rroi), &MinValuer, NULL, NULL, &right_eye); left_eye.x = (lrect.x + left_eye.x) / xscale; left_eye.y = (lrect.y + left_eye.y) / yscale; right_eye.x = (rrect.x + right_eye.x) / xscale; right_eye.y = (rrect.y + right_eye.y) / yscale; }
int asef_initialze(AsefEyeLocator *asef, const char *asef_file_name, const char *fd_file_name){ if ( !asef || !asef_file_name || !fd_file_name || strlen(asef_file_name)==0 || strlen(fd_file_name)==0) return -1; // For face detection: asef->face_detection_buffer = cvCreateMemStorage(0); asef->face_detection_classifier = fd_load_detector( fd_file_name ); if ( !asef->face_detection_classifier ) return -1; // For asef eye locator: if ( load_asef_filters(asef_file_name, &asef->n_rows, &asef->n_cols, &asef->lrect, &asef->rrect, &asef->lfilter, &asef->rfilter) ) return -1; asef->lfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->rfilter_dft = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->scaled_face_image_32fc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->scaled_face_image_8uc1 = cvCreateMat(asef->n_rows, asef->n_cols, CV_8UC1); asef->lcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->rcorr = cvCreateMat(asef->n_rows, asef->n_cols, CV_32FC1); asef->lroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1); asef->rroi = cvCreateMatHeader(asef->n_rows, asef->n_cols, CV_32FC1); asef->lut = cvCreateMat(256, 1, CV_32FC1); if ( !(asef->lfilter_dft && asef->rfilter_dft && asef->scaled_face_image_32fc1 && asef->scaled_face_image_8uc1 && asef->lcorr && asef->rcorr && asef->lroi && asef->rroi && asef->lut) ){ return -1; } cvDFT(asef->lfilter, asef->lfilter_dft, CV_DXT_FORWARD, 0); cvDFT(asef->rfilter, asef->rfilter_dft, CV_DXT_FORWARD, 0); cvGetSubRect(asef->lcorr, asef->lroi, asef->lrect); cvGetSubRect(asef->rcorr, asef->rroi, asef->rrect); for (int i = 0; i<256; i++){ cvmSet(asef->lut, i, 0, 1.0 + i); } cvLog(asef->lut, asef->lut); return 0; }
void BModel::wiener_filter_chanel(IplImage *channel, IplImage *kernel, const double sigma) { IplImage *fKernel = cvCreateImage(cvGetSize(kernel), IPL_DEPTH_64F, 2); IplImage *fChannel = cvCreateImage(cvGetSize(channel), IPL_DEPTH_64F, 2); IplImage *answ = cvCreateImage(cvGetSize(channel), IPL_DEPTH_64F, 2); IplImage *reFKernel = cvCreateImage(cvGetSize(kernel), IPL_DEPTH_64F, 1); IplImage *imFKernel = cvCreateImage(cvGetSize(kernel), IPL_DEPTH_64F, 1); IplImage *reFChannel = cvCreateImage(cvGetSize(kernel), IPL_DEPTH_64F, 1); IplImage *imFChannel = cvCreateImage(cvGetSize(kernel), IPL_DEPTH_64F, 1); IplImage *reAnsw = cvCreateImage(cvGetSize(channel), IPL_DEPTH_64F, 1); IplImage *imAnsw = cvCreateImage(cvGetSize(channel), IPL_DEPTH_64F, 1); cvDFT(kernel, fKernel, CV_DXT_FORWARD, channel->height); cvDFT(channel, fChannel, CV_DXT_FORWARD, channel->height); cvMulSpectrums(fChannel, fKernel, answ, CV_DXT_MUL_CONJ); cvSplit(answ, reAnsw, imAnsw, 0, 0 ); cvSplit(fKernel, reFKernel, imFKernel, 0, 0 ); cvPow(reFKernel, reFKernel, 2); cvPow(imFKernel, imFKernel, 2); cvAdd(reFKernel, imFKernel, reFKernel, 0); cvAddS(reFKernel, cvScalarAll(sigma), reFKernel, 0); cvDiv(reAnsw, reFKernel, reAnsw, 1); cvDiv(imAnsw, reFKernel, imAnsw, 1); cvMerge(reAnsw, imAnsw, NULL, NULL, answ); cvDFT(answ, answ, CV_DXT_INV_SCALE, channel->height); cvCopy(answ, channel); cvReleaseImage(&fKernel); cvReleaseImage(&fChannel); cvReleaseImage(&answ); cvReleaseImage(&reFKernel); cvReleaseImage(&imFKernel); cvReleaseImage(&reFChannel); cvReleaseImage(&imFChannel); cvReleaseImage(&reAnsw); cvReleaseImage(&imAnsw); }
int ASEF_Algorithm::initialize() { if (load_asef_filters(haar_cascade_path, &n_rows, &n_cols, &lrect, &rrect, &lfilter, &rfilter)) return -1; lfilter_dft = cvCreateMat(n_rows, n_cols, CV_32FC1); rfilter_dft = cvCreateMat(n_rows, n_cols, CV_32FC1); scaled_face_image_32fc1 = cvCreateMat(n_rows, n_cols, CV_32FC1); scaled_face_image_8uc1 = cvCreateMat(n_rows, n_cols, CV_8UC1); lcorr = cvCreateMat(n_rows, n_cols, CV_32FC1); rcorr = cvCreateMat(n_rows, n_cols, CV_32FC1); lroi = cvCreateMatHeader(n_rows, n_cols, CV_32FC1); rroi = cvCreateMatHeader(n_rows, n_cols, CV_32FC1); lut = cvCreateMat(256, 1, CV_32FC1); point = cvCreateMat(1, 2, CV_32FC1); if (!(lfilter_dft && rfilter_dft && scaled_face_image_32fc1 && scaled_face_image_8uc1 && lcorr && rcorr && lroi && rroi && lut)) { return -1; } cvDFT(lfilter, lfilter_dft, CV_DXT_FORWARD, 0); cvDFT(rfilter, rfilter_dft, CV_DXT_FORWARD, 0); cvGetSubRect(lcorr, lroi, lrect); cvGetSubRect(rcorr, rroi, rrect); for (int i = 0; i < 256; i++) { cvmSet(lut, i, 0, 1.0 + i); } cvLog(lut, lut); isInitialized = true; return 0; }
////////////////////////perform fourier transform////////////////////////////////////////////////// //fft2 // code comes from http://www.opencv.org.cn/ void CLightSet::fft2(IplImage *src,CvMat *dst) { IplImage * realInput; IplImage * imaginaryInput; IplImage * complexInput; int dft_M, dft_N; CvMat* dft_A, tmp; IplImage * image_Re; IplImage * image_Im; realInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 1); imaginaryInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 1); complexInput = cvCreateImage( cvGetSize(src), IPL_DEPTH_32F, 2); cvScale(src, realInput, 1.0, 0.0); cvZero(imaginaryInput); cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); // dft_M = cvGetOptimalDFTSize( src->height - 1 ); // dft_N = cvGetOptimalDFTSize( src->width - 1 ); dft_M =src->height; dft_N =src->width ; dft_A = cvCreateMat( dft_M, dft_N, CV_32FC2 ); image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_32F, 1); image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_32F, 1); // copy A to dft_A and pad dft_A with zeros cvGetSubRect( dft_A, &tmp, cvRect(0,0, src->width, src->height)); cvCopy( complexInput, &tmp, NULL ); if( dft_A->cols > src->width ) { cvGetSubRect( dft_A, &tmp, cvRect(src->width,0, dft_A->cols - src->width, src->height)); cvZero( &tmp ); } // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height ); cvCopy(dft_A,dst); cvReleaseImage(&realInput); cvReleaseImage(&imaginaryInput); cvReleaseImage(&complexInput); cvReleaseImage(&image_Re); cvReleaseImage(&image_Im); }
void cvShowInvDFT1(IplImage* im, CvMat* dft_A, int dft_M, int dft_N,char* src) { IplImage* realInput; IplImage* imaginaryInput; IplImage* complexInput; IplImage * image_Re; IplImage * image_Im; double m, M; char str[80]; realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2); image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); //cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, complexInput->height ); cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, dft_M); strcpy(str,"DFT INVERSE - "); strcat(str,src); cvNamedWindow(str, 0); // Split Fourier in real and imaginary parts cvSplit( dft_A, image_Re, image_Im, 0, 0 ); // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cvPow( image_Re, image_Re, 2.0); cvPow( image_Im, image_Im, 2.0); cvAdd( image_Re, image_Im, image_Re, NULL); cvPow( image_Re, image_Re, 0.5 ); // Compute log(1 + Mag) cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag cvLog( image_Re, image_Re ); // log(1 + Mag) cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m)); //cvCvtColor(image_Re, image_Re, CV_GRAY2RGBA); cvShowImage(str, image_Re); }
IplImage *fftImageInv(IplImage *img) { IplImage *ret; CvMat *ft; CvMat tmp; ft = cvCreateMat(img->height, img->width, CV_64FC2); origin_center(img); // copy A to dft_A and pad dft_A with zeros cvGetSubRect(ft, &tmp, cvRect(0, 0, img->width, img->height)); // tmp points to sub of dft_A cvCopy(img, &tmp, NULL); // Copy complex image into sub of dft_A cvDFT(ft, ft, (CV_DXT_SCALE | CV_DXT_INVERSE), img->height); ret = cvMatToImage(ft); cvReleaseMat(&ft); printf("INVFFT Return image is: Depth=%d channels=%d\n", ret->depth, ret->nChannels); return ret; }
IplImage* fftImage(IplImage *img) { IplImage *realpart, *imgpart, *complexpart, *ret; CvMat *ft; int sizeM, sizeN; CvMat tmp; realpart = cvCreateImage(cvGetSize(img), IPL_DEPTH_64F, 1); imgpart = cvCreateImage(cvGetSize(img), IPL_DEPTH_64F, 1); complexpart = cvCreateImage(cvGetSize(img), IPL_DEPTH_64F, 2); cvScale(img, realpart, 1.0, 0.0); // copy grey input image to realpart cvZero(imgpart); // Set imaginary part to 0 cvMerge(realpart, imgpart, NULL, NULL, complexpart); // real+imag to complex /* Messy bit - fft needs sizes to be a power of 2, so the images have to be // embedded into a background of 0 pixels. */ sizeM = cvGetOptimalDFTSize(img->height - 1); sizeN = cvGetOptimalDFTSize(img->width - 1); printf("Size of image to be transformed is %dx%d\n", sizeM, sizeN); ft = cvCreateMat(sizeM, sizeN, CV_64FC2); origin_center(complexpart); // copy A to dft_A and pad dft_A with zeros cvGetSubRect(ft, &tmp, cvRect(0, 0, img->width, img->height)); // tmp points to sub of dft_A cvCopy(complexpart, &tmp, NULL); // Copy complex image into sub of dft_A cvGetSubRect(ft, &tmp, cvRect(img->width, 0, ft->cols - img->width, img->height)); // Get sub of dft_A on right side if ((ft->cols - img->width) > 0) cvZero(&tmp); // Set right margin to zero cvDFT(ft, ft, CV_DXT_FORWARD, complexpart->height); ret = cvMatToImage(ft); cvReleaseMat(&ft); cvReleaseImage(&realpart); cvReleaseImage(&imgpart); cvReleaseImage(&complexpart); return ret; }
CvMat* cvShowDFT1(IplImage* im, int dft_M, int dft_N,char* src) { IplImage* realInput; IplImage* imaginaryInput; IplImage* complexInput; CvMat* dft_A, tmp; IplImage* image_Re; IplImage* image_Im; char str[80]; double m, M; realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2); cvScale(im, realInput, 1.0, 0.0); cvZero(imaginaryInput); cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 ); image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); // copy A to dft_A and pad dft_A with zeros cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height)); cvCopy( complexInput, &tmp, NULL ); if( dft_A->cols > im->width ) { cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height)); cvZero( &tmp ); } // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height ); strcpy(str,"DFT -"); strcat(str,src); cvNamedWindow(str, 0); // Split Fourier in real and imaginary parts cvSplit( dft_A, image_Re, image_Im, 0, 0 ); // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cvPow( image_Re, image_Re, 2.0); cvPow( image_Im, image_Im, 2.0); cvAdd( image_Re, image_Im, image_Re, NULL); cvPow( image_Re, image_Re, 0.5 ); // Compute log(1 + Mag) cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag cvLog( image_Re, image_Re ); // log(1 + Mag) cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m)); cvShowImage(str, image_Re); return(dft_A); }
int main(int argc, char ** argv) { const char* filename = argc >=2 ? argv[1] : "lena.jpg"; IplImage * im; IplImage * realInput; IplImage * imaginaryInput; IplImage * complexInput; int dft_M, dft_N; CvMat* dft_A, tmp; IplImage * image_Re; IplImage * image_Im; double m, M; im = cvLoadImage( filename, CV_LOAD_IMAGE_GRAYSCALE ); if( !im ) return -1; realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2); cvScale(im, realInput, 1.0, 0.0); cvZero(imaginaryInput); cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); dft_M = cvGetOptimalDFTSize( im->height - 1 ); dft_N = cvGetOptimalDFTSize( im->width - 1 ); dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 ); image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); // copy A to dft_A and pad dft_A with zeros cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height)); cvCopy( complexInput, &tmp, NULL ); if( dft_A->cols > im->width ) { cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height)); cvZero( &tmp ); } // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height ); cvNamedWindow("win", 0); cvNamedWindow("magnitude", 0); cvShowImage("win", im); // Split Fourier in real and imaginary parts cvSplit( dft_A, image_Re, image_Im, 0, 0 ); // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cvPow( image_Re, image_Re, 2.0); cvPow( image_Im, image_Im, 2.0); cvAdd( image_Re, image_Im, image_Re, NULL); cvPow( image_Re, image_Re, 0.5 ); // Compute log(1 + Mag) cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag cvLog( image_Re, image_Re ); // log(1 + Mag) // Rearrange the quadrants of Fourier image so that the origin is at // the image center cvShiftDFT( image_Re, image_Re ); cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m)); cvShowImage("magnitude", image_Re); cvWaitKey(-1); return 0; }
void CMagicCabsineUniversalProperty_feature_texture_spectral_DFT::ComputeProperty() { IplImage * im;//输入图像必须是灰度图像 IplImage * realInput; IplImage * imaginaryInput; IplImage * complexInput; int dft_M, dft_N; CvMat* dft_A, tmp; IplImage * image_Im; IplImage * image_Re; double m, M; //灰度图转化 IplImage *srcimg_cvt = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,3);//源图像格式化图像 im = cvCreateImage(cvGetSize(srcImage),IPL_DEPTH_8U,1); cvConvertScale(srcImage,srcimg_cvt);//源图像格式化 转换成 IPL_DEPTH_32F 3通道 cvCvtColor(srcImage,im,CV_BGR2GRAY);//源图像转换成灰度图 cvReleaseImage(&srcimg_cvt); realInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 1);//灰度图像 imaginaryInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 1);//灰度图像 complexInput = cvCreateImage( cvGetSize(srcImage), IPL_DEPTH_64F, 2); cvScale(im, realInput, 1.0, 0.0);//从8u转换成32f 提高精度 cvZero(imaginaryInput); //将单通道图像合并成多通道图像(将realInput和imageinaryImput合并到双通道图像complexInput) cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); /*dft_M = cvGetOptimalDFTSize( im->height - 1 ); dft_N = cvGetOptimalDFTSize( im->width - 1 );*/ dft_M = im->height; dft_N = im->width; dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 ); image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);//DFT最佳尺寸的图像 image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); // copy A to dft_A and pad dft_A with zeros cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height)); cvCopy( complexInput, &tmp, NULL ); if( dft_A->cols > im->width ) { cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height)); cvZero( &tmp ); } // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height ); // Split Fourier in real and imaginary parts cvSplit( dft_A, image_Re, image_Im, 0, 0 ); // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cvPow( image_Re, image_Re, 2.0); cvPow( image_Im, image_Im, 2.0); cvAdd( image_Re, image_Im, image_Re, NULL); cvPow( image_Re, image_Re, 0.5 ); // Compute log(1 + Mag) cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag cvLog( image_Re, image_Re ); // log(1 + Mag) // Rearrange the quadrants of Fourier image so that the origin is at // the image center cvShiftDFT( image_Re, image_Re ); cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m)); //cvShowImage("magnitude", image_Re); //正规化傅里叶变换图像使其可以被存储 image_Re_save = cvCreateImage(cvSize(dft_N,dft_M),IPL_DEPTH_64F,1);//注意本来应该在初始化中创建,但是由于大小参数无法估计故在此创建需要在析构函数中release cvNormalize(image_Re,image_Re_save,255,0,CV_MINMAX,NULL); cvReleaseImage(&im); cvReleaseImage(&realInput); cvReleaseImage(&imaginaryInput); cvReleaseImage(&complexInput); cvReleaseImage(&image_Re); cvReleaseImage(&image_Im); ////对傅里叶进行正规化使用L2(欧几里得)范式获取正规化傅里叶系数NFP,以计算3个傅里叶系数,未加绝对值 //cvNormalize(image_Re,image_Re,1,0,CV_L2,NULL); ////test //cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); ////对傅里叶NFP取绝对值 //cvAbs(image_Re,image_Re); ////test //cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL); ////计算傅里叶系数熵 //double h = FT_Entropy(image_Re, dft_N, dft_M); //double e = FT_Energy(image_Re, dft_N, dft_M); //double i = FT_Inertia(image_Re, dft_N, dft_M); ////存储特征 //featurefilename+=".txt"; // //FILE* file = fopen(featurefilename.c_str(),"w"); //fprintf_s(file,"%.6f\n",h); //fprintf_s(file,"%.6f\n",e); //fprintf_s(file,"%.6f\n",i); //fclose(file); //return 0; }
IplImage* create_fourier_image(const IplImage *im) { IplImage *realInput; IplImage *imaginaryInput; IplImage *complexInput; int dft_M, dft_N; CvMat *dft_A, tmp; IplImage *image_Re; IplImage *image_Im; realInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); imaginaryInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1); complexInput = rb_cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2); cvScale(im, realInput, 1.0, 0.0); cvZero(imaginaryInput); cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); dft_M = cvGetOptimalDFTSize( im->height - 1 ); dft_N = cvGetOptimalDFTSize( im->width - 1 ); dft_A = rb_cvCreateMat( dft_M, dft_N, CV_64FC2 ); image_Re = rb_cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); image_Im = rb_cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1); // copy A to dft_A and pad dft_A with zeros cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height)); cvCopy( complexInput, &tmp, NULL ); if( dft_A->cols > im->width ) { cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height)); cvZero( &tmp ); } // no need to pad bottom part of dft_A with zeros because of // use nonzero_rows parameter in cvDFT() call below cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height ); // Split Fourier in real and imaginary parts cvSplit( dft_A, image_Re, image_Im, 0, 0 ); // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2) cvPow( image_Re, image_Re, 2.0); cvPow( image_Im, image_Im, 2.0); cvAdd( image_Re, image_Im, image_Re, NULL); cvPow( image_Re, image_Re, 0.5 ); // Compute log(1 + Mag) cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag cvLog( image_Re, image_Re ); // log(1 + Mag) // Rearrange the quadrants of Fourier image so that the origin is at // the image center cvShiftDFT( image_Re, image_Re ); cvReleaseImage(&realInput); cvReleaseImage(&imaginaryInput); cvReleaseImage(&complexInput); cvReleaseImage(&image_Im); cvReleaseMat(&dft_A); return image_Re; }
void prefilt(const IplImage* img,IplImage* prefedImg,int pad,IplImage* filter2D) { int imagesize=img->height; int padImgSize=imagesize+2*pad; IplImage* temp1=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,3); /*put 8 bits image into 32 bits float image*/ cvConvertScale(img,temp1,1,1); int i; //use ptr to get access to data blocks/pixels,each block/pixel has three float numbers IplImage* temp2=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,3); float* ptr=NULL; cvLog(temp1,temp2); cvReleaseImage(&temp1); /*pad the image to reduce boundary artifacts*/ IplImage* temp5=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3); IplImage* pad1=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1); IplImage* pad2=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1); IplImage* pad3=cvCreateImage(cvSize(imagesize,imagesize),IPL_DEPTH_32F,1); cvSplit(temp2,pad1,pad2,pad3,NULL); IplImage* C1=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); IplImage* C2=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); IplImage* C3=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); padarraySym(pad1,C1,pad);/* pad each channel */ padarraySym(pad2,C2,pad); padarraySym(pad3,C3,pad); cvMerge(C1,C2,C3,NULL,temp5); cvReleaseImage(&pad1); cvReleaseImage(&pad2); cvReleaseImage(&pad3); cvReleaseImage(&C1); cvReleaseImage(&C2); cvReleaseImage(&C3); /* FFT */ /* split 3-channel image to single channel images */ IplImage* splitImgs[3]; IplImage* dftOutput[3]; IplImage* splitImgsC2[3]; for(i=0;i<3;i++) { splitImgs[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); splitImgsC2[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); dftOutput[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); cvSetZero(splitImgs[i]); cvSetZero(splitImgsC2[i]); cvSetZero(dftOutput[i]); } cvSplit(temp5,splitImgs[0],splitImgs[1],splitImgs[2],NULL); IplImage* mergSrc=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); cvSetZero(mergSrc); /* merge to double channel images for input of FFT */ for(i=0;i<3;i++) { cvMerge(splitImgs[i],mergSrc,NULL,NULL,splitImgsC2[i]); cvReleaseImage(&splitImgs[i]); } /* FFT */ for(i=0;i<3;i++) { cvDFT(splitImgsC2[i],dftOutput[i],CV_DXT_FORWARD); cvReleaseImage(&splitImgsC2[i]); } /* apply prefilt to three channels */ IplImage* output_temp[3]; IplImage* outputReal[3]; IplImage* outputImaginary[3]; IplImage* ifftOutput[3]; float temp=0; int j=0; float* ptr1=NULL; for(i=0;i<3;i++) { output_temp[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); cvSetZero(output_temp[i]); cvMul(filter2D,dftOutput[i],output_temp[i]); cvReleaseImage(&dftOutput[i]); outputReal[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); cvSetZero(outputReal[i]); outputImaginary[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); cvSetZero(outputImaginary[i]); ifftOutput[i]=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); cvSetZero(ifftOutput[i]); cvDFT(output_temp[i],ifftOutput[i],CV_DXT_INVERSE_SCALE); cvSplit(ifftOutput[i],outputReal[i],outputImaginary[i],NULL,NULL); cvReleaseImage(&outputImaginary[i]); cvReleaseImage(&ifftOutput[i]); } /* merge real parts to a 3-channel image */ IplImage* temp3=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3); cvMerge(outputReal[0],outputReal[1],outputReal[2],NULL,temp3); cvReleaseImage(&outputReal[0]); cvReleaseImage(&outputReal[1]); cvReleaseImage(&outputReal[2]); IplImage* prefiltOutput=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3); cvSub(temp5,temp3,prefiltOutput); cvReleaseImage(&temp3); cvReleaseImage(&temp5); /* local contrast normalization */ /* mean of values in different channels of each pixel */ IplImage* mean=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); IplImage* mean2D=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); ptr=(float*) mean->imageData; ptr1=(float*) prefiltOutput->imageData; for(i=0;i<(padImgSize)*(padImgSize)*3;i++) { if((i+1)%3==0) { temp=(*(ptr1+i)+*(ptr1+i-1)+*(ptr1+i-2))/3; *(ptr+(i+1)/3-1)=temp*temp; } } /* FFT */ IplImage* fftRes=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); cvMerge(mean,mergSrc,NULL,NULL,mean2D); cvReleaseImage(&mergSrc); cvDFT(mean2D,fftRes,CV_DXT_FORWARD); cvReleaseImage(&mean); IplImage* temp4=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); cvMul(filter2D,fftRes,temp4); /* Inverse FFT */ IplImage* ifftRes=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,2); IplImage* lccstTemp=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,1); ptr1=(float*) lccstTemp->imageData; cvFFT(temp4,ifftRes,CV_DXT_INVERSE_SCALE); /* caculate the abs of complex number matrix */ ptr=(float*)ifftRes->imageData; float realV=0; float imgV=0; for(i=0;i<(padImgSize)*(padImgSize);i++) { realV=*(ptr+2*i); imgV=*(ptr+2*i+1); *(ptr1+i)=sqrt(sqrt(realV*realV+fabs(imgV*imgV)))+0.2; } IplImage* lccst=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3); cvMerge(lccstTemp,lccstTemp,lccstTemp,NULL,lccst); IplImage* outputTemp=cvCreateImage(cvSize(padImgSize,padImgSize),IPL_DEPTH_32F,3); cvDiv(prefiltOutput,lccst,outputTemp); cvReleaseImage(&mean2D); cvReleaseImage(&fftRes); cvReleaseImage(&ifftRes); cvReleaseImage(&lccstTemp); cvReleaseImage(&lccst); cvReleaseImage(&prefiltOutput); cvReleaseImage(&temp2); cvReleaseImage(&temp4); cvReleaseImage(&output_temp[0]); cvReleaseImage(&output_temp[1]); cvReleaseImage(&output_temp[2]); IplImage* temp6 = cvGetSubImage(outputTemp,cvRect(pad,pad,imagesize,imagesize)); cvCopy(temp6,prefedImg); cvReleaseImage(&outputTemp); cvReleaseImage(&temp6); }
void ASEF::ComputeEyeLocations(IplImage *img, CvRect bb){ assert(img->nChannels==1); IplImage *roi = cvCreateImage(cvSize(this->nCols, this->nRows), img->depth, 1); cvSetImageROI(img, bb); cvResize(img, roi, CV_INTER_LINEAR); cvResetImageROI(img); IplImage *roi_64 = cvCreateImage(cvGetSize(roi), IPL_DEPTH_64F, 1); cvConvertScale(roi, roi_64, 1./255., 0.); FaceNormIllu::do_NormIlluRETINA(roi_64, this->face_real, 5.0); cvMerge(this->face_real, this->face_im, 0, 0, this->complex_data); // do DFT cvDFT(this->complex_data, this->F, CV_DXT_FORWARD, this->complex_data->height); // G left cvMulSpectrums(this->F, this->LeftEyeDetector, this->Gl, CV_DXT_ROWS); cvDFT(this->Gl, this->Gl, CV_DXT_INV_SCALE, this->Gl->height); cvSplit(this->Gl, this->gl, 0, 0, 0); // G right cvMulSpectrums(this->F, this->RightEyeDetector, this->Gr, CV_DXT_ROWS); cvDFT(this->Gr, this->Gr, CV_DXT_INV_SCALE, this->Gl->height); cvSplit(this->Gr, this->gr,0,0,0); // add both responses double minV, maxV; cvMinMaxLoc(this->gl, &minV, &maxV); cvConvertScale(this->gl, this->gl, 1./(maxV-minV), -minV/(maxV-minV)); cvMinMaxLoc(this->gr, &minV, &maxV); cvConvertScale(this->gr, this->gr, 1./(maxV-minV), -minV/(maxV-minV)); cvAdd(this->gl, this->gr, this->g); cvMul(this->g, this->LeftEyeMask, this->gl); cvMul(this->g, this->RightEyeMask, this->gr); /////////////////////////////////////////////////// // Compute Eye Locations /////////////////////////////////////////////////// float scale; cvSetImageROI(this->gl, cvRect(0,0, this->nCols>>1, this->nRows>>1)); cvMinMaxLoc(this->gl, 0,0,0, &this->pEyeL); cvResetImageROI(this->gl); scale = (float)bb.width/(float)this->nCols; this->pEyeL.x=cvRound((float)this->pEyeL.x * scale + bb.x); this->pEyeL.y=cvRound((float)this->pEyeL.y * scale + bb.y); cvSetImageROI(this->gr, cvRect(this->nCols>>1, 0, this->nCols>>1, this->nRows>>1)); cvMinMaxLoc(this->gr, 0,0,0, &this->pEyeR); cvResetImageROI(this->gr); scale = (float)bb.height/(float)this->nRows; this->pEyeR.x=cvRound((float)(this->pEyeR.x + this->nCols*0.5)* scale + bb.x); this->pEyeR.y=cvRound((float)this->pEyeR.y * scale + bb.y); cvReleaseImage(&roi); cvReleaseImage(&roi_64); }
*/ int main(int argc, char *argv[]) { DSP_cvStartDSP(); CvCapture * capture; IplImage *videoFrame, *convFrame, *convOpencvFrame, *unsignedFrame; IplImage *dataImage, *integralImage; int key; int *ptr; float *flPtr; int i,j; float tempFloat=0.0; float *floatDataPtr; float *floatOutPtr; /* Data to test cvIntegral() */ unsigned char intdata[] = { 151, 57, 116, 170, 9, 247, 208, 140, 150, 60, 88, 77, 4, 6, 162, 6, 31, 143, 178, 3, 135, 91, 54, 154, 193, 161, 20, 162, 137, 150, 128, 224, 214, 113, 9, 28, 53, 211, 98, 217, 149, 233, 231, 127, 115, 203, 177, 42, 62, 155, 3, 103, 127, 16, 135, 131, 211, 158, 9, 2, 106, 227, 249, 255 }; //16 x 4 if ( argc < 2 ) { printf( "Usage: ./remote_ti_platforms_evm3530_opencv.xv5T [option] \n"); printf("option:\ni. integral\ns. sobel\nd. dft\n"); printf("Following are the all usage:\n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T i dsp(To test integral-image algorithm using DSP. Input is from webcam). Note: You need to install VLIB to test this.\n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T i arm(To test integral-image algorithm using ARM. Input is from webcam). \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T i test(To test integral-image algorithm using test data given in APP. Input is from webcam). \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T d dsp (To test DFT algorithm using DSP) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T d arm (To test DFT algorithm using ARM) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi dsp (To test sobel algorithm for movie clip tree.avi using DSP) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi arm (To test sobel algorithm for movie clip tree.avi using ARM) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T s webcam dsp (To test sobel algorithm for image from webcam using DSP) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T s webcam arm (To test sobel algorithm for image from webcam using ARM) \n"); printf("./remote_ti_platforms_evm3530_opencv.xv5T rgb2gray (To test RGB to Gray for image from webcam.) \n"); return (-1); } if (*argv[1] == 's' && argc < 3) { printf( "Usage: ./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi \n"); printf( "Usage: ./remote_ti_platforms_evm3530_opencv.xv5T s webcam \n"); return (-1); } switch (*argv[1]) { case 'i': switch (*argv[2]) { case 'd': { //'d' dor DSP accelerated cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCaptureFromCAM(-1); if ( !capture) { printf("Error: Video capture initialization failed.\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading from webcam\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width+1, convFrame->height+1 ), IPL_DEPTH_32S, 1 ); /* Process the first frame outside the loop*/ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); DSP_cvSyncDSP(); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); /*Find integral image */ DSP_cvIntegral(convFrame,convOpencvFrame,NULL,NULL); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } DSP_cvSyncDSP(); /* Do color conversion */ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* show Image */ //Since I am using VLIB for IntegralImage, its output image width and height is same as source image. convOpencvFrame->width -= 1; convOpencvFrame->height -= 1; convOpencvFrame->widthStep -= sizeof(int) * convOpencvFrame->nChannels; cvShowImage("video", convOpencvFrame); convOpencvFrame->width += 1; convOpencvFrame->height += 1; convOpencvFrame->widthStep += sizeof(int) * convOpencvFrame->nChannels; /* Sync with DSP */ DSP_cvSyncDSP(); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); cvReleaseCapture(&capture); } break; /* End of sobel test */ case 'a': { // 'a' for ARM side cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCaptureFromCAM(-1); if ( !capture) { printf("Error: Video capture initialization failed.\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading from webcam\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width+1, convFrame->height+1 ), IPL_DEPTH_32S, 1 ); /* Process the first frame outside the loop*/ cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); /*Find integral image */ cvIntegral(convFrame,convOpencvFrame,NULL,NULL); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } /* Do color conversion */ cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* show Image */ cvShowImage("video", convOpencvFrame); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); cvReleaseCapture(&capture); } break; /* End of sobel test */ case 't': { /* This to test the consistency of algorithm */ /* Start of integral image test */ dataImage = cvCreateImageHeader(cvSize(16, 4), IPL_DEPTH_8U, 1); integralImage = cvCreateImageHeader(cvSize(17, 5), IPL_DEPTH_32S, 1); unsigned char *data = (unsigned char*)cvAlloc(16*4*sizeof(char)); unsigned int *sum = (unsigned int *)cvAlloc(17*5*sizeof(int)); memcpy(data, &intdata[0], 16*4*sizeof(char)); memset(sum, 0, 17*5*sizeof(int)); dataImage->imageData = ( char *)data; integralImage->imageData = ( char *)sum; /* DSP based integral */ DSP_cvIntegral(dataImage,integralImage,NULL,NULL); ptr = (int *)integralImage->imageData; printf(" The integral image is:\n"); for (i=0;i<4;i++){ for (j=0;j<16;j++){ printf("%d \t ", ptr[i* 16 + j]); } printf("\n"); } /* Arm based cvIntegral() */ cvIntegral(dataImage, integralImage,NULL,NULL); ptr = (int *)integralImage->imageData; printf(" The integral image is:\n"); for (i=0;i<5;i++){ for (j=0;j<17;j++){ printf("%d \t ", ptr[i* 17 + j]); } printf("\n"); } cvFree(&dataImage); cvFree(&integralImage); } break; /* End of integral image test */ default: printf("Input argument Error:\n Usage :\n./remote_ti_platforms_evm3530_opencv.xv5T i d \n./remote_ti_platforms_evm3530_opencv.xv5T i a\n ./remote_ti_platforms_evm3530_opencv.xv5T i d \n"); break; } break; /* Start RGB to Y test */ case 'r': { cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCaptureFromCAM(-1); if ( !capture) { printf("Error: Video capture initialization failed.\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading from webcam\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); unsignedFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); /* Process the first frame outside the loop*/ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } DSP_cvSyncDSP(); cvShowImage("video",convFrame); Time_delta(&sTime,&time); printf("Total execution time1 = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); } break; case 's': /* Start of sobel test */ switch (*argv[2]) { case 't': switch(*argv[3]) { case 'd': { //'d' dor DSP accelerated cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCreateFileCapture(argv[2]); if ( !capture) { printf("Error: Video not found\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading video\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width, convFrame->height ), IPL_DEPTH_16S, 1 ); DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); DSP_cvSyncDSP(); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); DSP_cvSobel(convFrame,convOpencvFrame,1,1,3); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } /* Sync with DSP*/ DSP_cvSyncDSP(); /* Start RGB To Y conversion of next frame */ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* Display Filtered Image */ cvShowImage("video", convOpencvFrame); /* Sync DSP */ DSP_cvSyncDSP(); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); } break; /* End of sobel test */ case 'a': { // 'a' for ARM side cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCreateFileCapture(argv[2]); if ( !capture) { printf("Error: Video not found\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading video\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width, convFrame->height ), IPL_DEPTH_16S, 1 ); cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); cvSobel(convFrame,convOpencvFrame,1,1,3); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } /* Start RGB To Y conversion of next frame */ cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* Display Filtered Image */ cvShowImage("video", convOpencvFrame); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); } break; /* End of sobel test */ default: printf("Input argument Error:\n Usage :\n./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi d \n./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi a\n"); } break; case 'w': switch(*argv[3]) { case 'd': { //'d' dor DSP accelerated cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCaptureFromCAM(-1); if ( !capture) { printf("Error: Video capture initialization failed.\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading from webcam\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width, convFrame->height ), IPL_DEPTH_16S, 1 ); /* Create unsigned image */ unsignedFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* Process the first frame outside the loop*/ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); DSP_cvSyncDSP(); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); DSP_cvSobel(convFrame,convOpencvFrame,1,1,3); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } /* Sync with DSP*/ DSP_cvSyncDSP(); /* Start RGB To Y conversion of next frame */ DSP_cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* Convert signed image to unsign image for better clarity */ cvConvert(convOpencvFrame,unsignedFrame); /* Display Filtered Image */ cvShowImage("video", unsignedFrame); /* Sync DSP */ DSP_cvSyncDSP(); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); } break; /* End of sobel test */ case 'a': { // 'a' for ARM side cvNamedWindow( "video", CV_WINDOW_AUTOSIZE ); capture = cvCaptureFromCAM(-1); if ( !capture) { printf("Error: Video capture initialization failed.\n"); break; } videoFrame = cvQueryFrame ( capture ); if ( !videoFrame) { printf("**Error reading from webcam\n"); break; } /* create new image for the grayscale version */ convFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* create sobel filtered image */ convOpencvFrame = cvCreateImage( cvSize( convFrame->width, convFrame->height ), IPL_DEPTH_16S, 1 ); /* Create unsigned image */ unsignedFrame = cvCreateImage( cvSize( videoFrame->width, videoFrame->height ), IPL_DEPTH_8U, 1 ); /* Process the first frame outside the loop*/ cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); while ( key != 'q') { /* Time to test and benchmark DSP based sobel filter */ Time_reset(&sTime); Time_delta(&sTime,&time); cvSobel(convFrame,convOpencvFrame,1,1,3); /* get next frame */ videoFrame = cvQueryFrame( capture); if ( !videoFrame) { printf("***The End***\n"); break; } /* Start RGB To Y conversion of next frame */ cvCvtColor(videoFrame,convFrame,CV_RGB2GRAY); /* Convert signed image to unsign image for better clarity */ cvConvert(convOpencvFrame,unsignedFrame); /* Display Filtered Image */ cvShowImage("video", unsignedFrame); Time_delta(&sTime,&time); printf("Total execution time = %dus\n",(unsigned int)time); key = cvWaitKey( 15 ); } cvDestroyWindow("video"); cvReleaseImage(&videoFrame); cvReleaseImage(&convFrame); cvReleaseImage(&convOpencvFrame); } break; /* End of sobel test */ default: printf("Input argument Error:\n Usage :\n./remote_ti_platforms_evm3530_opencv.xv5T s webcam d \n./remote_ti_platforms_evm3530_opencv.xv5T s webcam a\n"); } break; default: printf("Input argument Error:\n Usage :\n./remote_ti_platforms_evm3530_opencv.xv5T s tree.avi \n./remote_ti_platforms_evm3530_opencv.xv5T s webcam\n"); break; } break; case 'd': switch(*argv[2]) { case 'd': { //'d' dor DSP accelerated int row =63; int col =63; floatDataPtr = (float *)cvAlloc(sizeof(float)*row*col* 2); floatOutPtr = (float *)cvAlloc(sizeof(float)*row*col * 2); dataImage = cvCreateImageHeader(cvSize(col, row), IPL_DEPTH_32F, 2); dataImage->imageData = (char *)floatDataPtr; integralImage = cvCreateImageHeader(cvSize(col, row), IPL_DEPTH_32F, 2); integralImage->imageData = (char *)floatOutPtr; for (i=0; i< row * col * 2; i+=2) { tempFloat += 1.0; floatDataPtr[i] = tempFloat; floatDataPtr[i+1] = 0.0; } Time_reset(&sTime); Time_delta(&sTime,&time); DSP_cvDFT(dataImage,integralImage,CV_DXT_FORWARD,0); Time_delta(&sTime,&time); DSP_cvSyncDSP(); /* Print the output data for DFT */ flPtr = (float *)integralImage->imageData; printf(" The DFT output is:\n"); for (i=0;i<integralImage->height;i++){ key = 0; for (j=0;j<integralImage->width * 2;j+=2){ key++; printf("%f + i%f\t", flPtr[(i*integralImage->width * 2)+j], flPtr[(i*integralImage->width * 2) + j + 1]); if ((key % 5) == 0) printf("\n"); } printf("\n"); } printf("DSP_cvDFT Total execution time = %dus\n",(unsigned int)time); cvFree(&floatDataPtr); cvFree(&floatOutPtr); } break; case 'a': { int row =63; int col =63; floatDataPtr = (float *)cvAlloc(sizeof(float)*row*col*2); floatOutPtr = (float *)cvAlloc(sizeof(float)*row*col*2); dataImage = cvCreateImageHeader(cvSize(col, row), IPL_DEPTH_32F, 2); dataImage->imageData = (char *)floatDataPtr; integralImage = cvCreateImageHeader(cvSize(col, row), IPL_DEPTH_32F, 2); integralImage->imageData = (char *)floatOutPtr; for (i=0; i< row * col * 2; i+=2) { tempFloat += 1.0; floatDataPtr[i] = tempFloat; floatDataPtr[i+1] = 0.0; } Time_reset(&sTime); Time_delta(&sTime,&time); cvDFT(dataImage,integralImage,CV_DXT_FORWARD,0); Time_delta(&sTime,&time); /* Print the output data for DFT */ flPtr = (float *)integralImage->imageData; printf(" The DFT output is:\n"); for (i=0;i<integralImage->height;i++){ key = 0; for (j=0;j<integralImage->width * 2;j+=2){ key++; printf("%f + i%f\t", flPtr[(i*integralImage->width * 2)+j], flPtr[(i*integralImage->width * 2) + j + 1]); if ((key % 5) == 0) printf("\n"); } printf("\n"); } printf("cvDFT Total execution time = %dus\n",(unsigned int)time); cvFree(&floatDataPtr); cvFree(&floatOutPtr); } break; default: printf("Input argument Error:\n Usage :\n./remote_ti_platforms_evm3530_opencv.xv5T d d \n./remote_ti_platforms_evm3530_opencv.xv5T d a\n"); } // end of latest switch(*argv[3]) break; default: return -1; } DSP_cvEndDSP(); return 0;
void CLightSet::RunLightPrep(IplImage* src,IplImage* dest) { int M,N; M=0; N=0; if (src->roi) { M = src->roi->width; N = src->roi->height; } else { M = src->width; N = src->height; } CvMat *matD; // create mat for meshgrid frequency matrices matD = cvCreateMat(M,N,CV_32FC1); CDM(M,N,matD); CvMat *matH; matH = cvCreateMat(M,N,CV_32FC1); // mat for lowpass filter float D0 = 10.0; float rH,rL,c; rH = 2.0; rL = 0.5; c = 1.0; lpfilter(matD,matH,D0,rH,rL,c); IplImage *srcshift; // shift center srcshift = cvCloneImage(src); cvShiftDFT(srcshift,srcshift); IplImage *log, *temp; log = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1); temp = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1); cvCvtScale(srcshift,temp,1.0,0); cvLog(temp,log); cvCvtScale(log,log,-1.0,0); CvMat *Fourier; Fourier = cvCreateMat( M, N, CV_32FC2 ); fft2(log,Fourier); IplImage* image_im; image_im = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,1); cvSplit(Fourier,dest,image_im,0,0); cvMul(dest,matH,dest); cvMul(image_im,matH,image_im); IplImage *dst; dst = cvCreateImage(cvGetSize(src),IPL_DEPTH_32F,2); cvMerge(dest,image_im,0,0,dst); cvDFT(dst,dst,CV_DXT_INV_SCALE); cvExp(dst,dst); cvZero(dest); cvZero(image_im); cvSplit(dst,dest,image_im,0,0); //使得图像按照原来的顺序显示 cvShiftDFT(dest,dest); double max,min; // normalize cvMinMaxLoc(dest,&min,&max,NULL,NULL); cvReleaseImage(&image_im); cvReleaseImage(&srcshift); cvReleaseImage(&dst); cvReleaseImage(&log); cvReleaseImage(&temp); cvReleaseMat(&matD); cvReleaseMat(&matH); }
void icvCrossCorr( const CvArr* _img, const CvArr* _templ, CvArr* _corr, CvPoint anchor, double delta, int borderType ) { // disable OpenMP in the case of Visual Studio, // otherwise the performance drops significantly #undef USE_OPENMP #if !defined _MSC_VER || defined CV_ICC #define USE_OPENMP 1 #endif const double block_scale = 4.5; const int min_block_size = 256; cv::Ptr<CvMat> dft_img[CV_MAX_THREADS]; cv::Ptr<CvMat> dft_templ; std::vector<uchar> buf[CV_MAX_THREADS]; int k, num_threads = 0; CvMat istub, *img = (CvMat*)_img; CvMat tstub, *templ = (CvMat*)_templ; CvMat cstub, *corr = (CvMat*)_corr; CvSize dftsize, blocksize; int depth, templ_depth, corr_depth, max_depth = CV_32F, cn, templ_cn, corr_cn, buf_size = 0, tile_count_x, tile_count_y, tile_count; img = cvGetMat( img, &istub ); templ = cvGetMat( templ, &tstub ); corr = cvGetMat( corr, &cstub ); if( CV_MAT_DEPTH( img->type ) != CV_8U && CV_MAT_DEPTH( img->type ) != CV_16U && CV_MAT_DEPTH( img->type ) != CV_32F && CV_MAT_DEPTH( img->type ) != CV_64F ) CV_Error( CV_StsUnsupportedFormat, "The function supports only 8u, 16u and 32f data types" ); if( !CV_ARE_DEPTHS_EQ( img, templ ) && CV_MAT_DEPTH( templ->type ) != CV_32F ) CV_Error( CV_StsUnsupportedFormat, "Template (kernel) must be of the same depth as the input image, or be 32f" ); if( !CV_ARE_DEPTHS_EQ( img, corr ) && CV_MAT_DEPTH( corr->type ) != CV_32F && CV_MAT_DEPTH( corr->type ) != CV_64F ) CV_Error( CV_StsUnsupportedFormat, "The output image must have the same depth as the input image, or be 32f/64f" ); if( (!CV_ARE_CNS_EQ( img, corr ) || CV_MAT_CN(templ->type) > 1) && (CV_MAT_CN( corr->type ) > 1 || !CV_ARE_CNS_EQ( img, templ)) ) CV_Error( CV_StsUnsupportedFormat, "The output must have the same number of channels as the input (when the template has 1 channel), " "or the output must have 1 channel when the input and the template have the same number of channels" ); depth = CV_MAT_DEPTH(img->type); cn = CV_MAT_CN(img->type); templ_depth = CV_MAT_DEPTH(templ->type); templ_cn = CV_MAT_CN(templ->type); corr_depth = CV_MAT_DEPTH(corr->type); corr_cn = CV_MAT_CN(corr->type); CV_Assert( corr_cn == 1 || delta == 0 ); max_depth = MAX( max_depth, templ_depth ); max_depth = MAX( max_depth, depth ); max_depth = MAX( max_depth, corr_depth ); if( depth > CV_8U ) max_depth = CV_64F; /*if( img->cols < templ->cols || img->rows < templ->rows ) CV_Error( CV_StsUnmatchedSizes, "Such a combination of image and template/filter size is not supported" );*/ if( corr->rows > img->rows + templ->rows - 1 || corr->cols > img->cols + templ->cols - 1 ) CV_Error( CV_StsUnmatchedSizes, "output image should not be greater than (W + w - 1)x(H + h - 1)" ); blocksize.width = cvRound(templ->cols*block_scale); blocksize.width = MAX( blocksize.width, min_block_size - templ->cols + 1 ); blocksize.width = MIN( blocksize.width, corr->cols ); blocksize.height = cvRound(templ->rows*block_scale); blocksize.height = MAX( blocksize.height, min_block_size - templ->rows + 1 ); blocksize.height = MIN( blocksize.height, corr->rows ); dftsize.width = cvGetOptimalDFTSize(blocksize.width + templ->cols - 1); if( dftsize.width == 1 ) dftsize.width = 2; dftsize.height = cvGetOptimalDFTSize(blocksize.height + templ->rows - 1); if( dftsize.width <= 0 || dftsize.height <= 0 ) CV_Error( CV_StsOutOfRange, "the input arrays are too big" ); // recompute block size blocksize.width = dftsize.width - templ->cols + 1; blocksize.width = MIN( blocksize.width, corr->cols ); blocksize.height = dftsize.height - templ->rows + 1; blocksize.height = MIN( blocksize.height, corr->rows ); dft_templ = cvCreateMat( dftsize.height*templ_cn, dftsize.width, max_depth ); #ifdef USE_OPENMP num_threads = cvGetNumThreads(); #else num_threads = 1; #endif for( k = 0; k < num_threads; k++ ) dft_img[k] = cvCreateMat( dftsize.height, dftsize.width, max_depth ); if( templ_cn > 1 && templ_depth != max_depth ) buf_size = templ->cols*templ->rows*CV_ELEM_SIZE(templ_depth); if( cn > 1 && depth != max_depth ) buf_size = MAX( buf_size, (blocksize.width + templ->cols - 1)* (blocksize.height + templ->rows - 1)*CV_ELEM_SIZE(depth)); if( (corr_cn > 1 || cn > 1) && corr_depth != max_depth ) buf_size = MAX( buf_size, blocksize.width*blocksize.height*CV_ELEM_SIZE(corr_depth)); if( buf_size > 0 ) { for( k = 0; k < num_threads; k++ ) buf[k].resize(buf_size); } // compute DFT of each template plane for( k = 0; k < templ_cn; k++ ) { CvMat dstub, *src, *dst, temp; CvMat* planes[] = { 0, 0, 0, 0 }; int yofs = k*dftsize.height; src = templ; dst = cvGetSubRect( dft_templ, &dstub, cvRect(0,yofs,templ->cols,templ->rows)); if( templ_cn > 1 ) { planes[k] = templ_depth == max_depth ? dst : cvInitMatHeader( &temp, templ->rows, templ->cols, templ_depth, &buf[0][0] ); cvSplit( templ, planes[0], planes[1], planes[2], planes[3] ); src = planes[k]; planes[k] = 0; } if( dst != src ) cvConvert( src, dst ); if( dft_templ->cols > templ->cols ) { cvGetSubRect( dft_templ, dst, cvRect(templ->cols, yofs, dft_templ->cols - templ->cols, templ->rows) ); cvZero( dst ); } cvGetSubRect( dft_templ, dst, cvRect(0,yofs,dftsize.width,dftsize.height) ); cvDFT( dst, dst, CV_DXT_FORWARD + CV_DXT_SCALE, templ->rows ); } tile_count_x = (corr->cols + blocksize.width - 1)/blocksize.width; tile_count_y = (corr->rows + blocksize.height - 1)/blocksize.height; tile_count = tile_count_x*tile_count_y; #if defined _OPENMP && defined USE_OPENMP #pragma omp parallel for num_threads(num_threads) schedule(dynamic) #endif // calculate correlation by blocks for( k = 0; k < tile_count; k++ ) { #ifdef USE_OPENMP int thread_idx = cvGetThreadNum(); #else int thread_idx = 0; #endif int x = (k%tile_count_x)*blocksize.width; int y = (k/tile_count_x)*blocksize.height; int i, yofs; CvMat sstub, dstub, *src, *dst, temp; CvMat* planes[] = { 0, 0, 0, 0 }; CvMat* _dft_img = dft_img[thread_idx]; uchar* _buf = buf_size > 0 ? &buf[thread_idx][0] : 0; CvSize csz = { blocksize.width, blocksize.height }, isz; int x0 = x - anchor.x, y0 = y - anchor.y; int x1 = MAX( 0, x0 ), y1 = MAX( 0, y0 ), x2, y2; csz.width = MIN( csz.width, corr->cols - x ); csz.height = MIN( csz.height, corr->rows - y ); isz.width = csz.width + templ->cols - 1; isz.height = csz.height + templ->rows - 1; x2 = MIN( img->cols, x0 + isz.width ); y2 = MIN( img->rows, y0 + isz.height ); for( i = 0; i < cn; i++ ) { CvMat dstub1, *dst1; yofs = i*dftsize.height; src = cvGetSubRect( img, &sstub, cvRect(x1,y1,x2-x1,y2-y1) ); dst = cvGetSubRect( _dft_img, &dstub, cvRect(0,0,isz.width,isz.height) ); dst1 = dst; if( x2 - x1 < isz.width || y2 - y1 < isz.height ) dst1 = cvGetSubRect( _dft_img, &dstub1, cvRect( x1 - x0, y1 - y0, x2 - x1, y2 - y1 )); if( cn > 1 ) { planes[i] = dst1; if( depth != max_depth ) planes[i] = cvInitMatHeader( &temp, y2 - y1, x2 - x1, depth, _buf ); cvSplit( src, planes[0], planes[1], planes[2], planes[3] ); src = planes[i]; planes[i] = 0; } if( dst1 != src ) cvConvert( src, dst1 ); if( dst != dst1 ) cvCopyMakeBorder( dst1, dst, cvPoint(x1 - x0, y1 - y0), borderType ); if( dftsize.width > isz.width ) { cvGetSubRect( _dft_img, dst, cvRect(isz.width, 0, dftsize.width - isz.width,dftsize.height) ); cvZero( dst ); } cvDFT( _dft_img, _dft_img, CV_DXT_FORWARD, isz.height ); cvGetSubRect( dft_templ, dst, cvRect(0,(templ_cn>1?yofs:0),dftsize.width,dftsize.height) ); cvMulSpectrums( _dft_img, dst, _dft_img, CV_DXT_MUL_CONJ ); cvDFT( _dft_img, _dft_img, CV_DXT_INVERSE, csz.height ); src = cvGetSubRect( _dft_img, &sstub, cvRect(0,0,csz.width,csz.height) ); dst = cvGetSubRect( corr, &dstub, cvRect(x,y,csz.width,csz.height) ); if( corr_cn > 1 ) { planes[i] = src; if( corr_depth != max_depth ) { planes[i] = cvInitMatHeader( &temp, csz.height, csz.width, corr_depth, _buf ); cvConvertScale( src, planes[i], 1, delta ); } cvMerge( planes[0], planes[1], planes[2], planes[3], dst ); planes[i] = 0; } else { if( i == 0 ) cvConvertScale( src, dst, 1, delta ); else { if( max_depth > corr_depth ) { cvInitMatHeader( &temp, csz.height, csz.width, corr_depth, _buf ); cvConvert( src, &temp ); src = &temp; } cvAcc( src, dst ); } } } } }
void tips(IplImage *img) { FILE *tipgraph = fopen("tipgraph.dat","w"); //FILE *freq = fopen("freq.dat", "w"); int i, j, curr_pixel, step, x[640]; tipcount=0; uchar *data = (uchar*)img->imageData; step = img->widthStep; CvMat *dst = cvCreateMat(1, 640, CV_32FC1 ); CvMat *src = cvCreateMat(1, 640, CV_32FC1 ); for(i=0; i<width; i++) { x[i] = 0; for(j=0; j<height; j++) { curr_pixel = data[j*step + i]; if((curr_pixel == 255) ) { //data[x[i]*step + i] = 0; x[i] = j; } //else data[j*step + i] = 0; } cvSetReal1D(src, i, x[i]); fprintf(tipgraph, "%d\n", x[i]); //printf("hi"); } cvDFT(src, dst, CV_DXT_SCALE, 0); for(i=0; i<width; i++) { //fprintf(freq, "%f\n", abs(cvGetReal1D(dst, i))); if(i>20) cvSetReal1D(dst, i, 0); } cvDFT(dst, src, CV_DXT_INVERSE, 0); for(i=1; i<width-1; i++) { if((cvGetReal1D(src, i+1) - cvGetReal1D(src, i) <= 0 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) >= 0) //|| (cvGetReal1D(src, i+1) - cvGetReal1D(src, i) <= 0 && cvGetReal1D(src, i+1) - cvGetReal1D(src, i) >=-5 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) <= 0 && cvGetReal1D(src, i) - cvGetReal1D(src, i-1) >= -5) ) { tips_position[tipcount][0] = 0; for(j=-3; j<=3; j++) { if((i+j)<640 && (i+j)>0) { tips_position[tipcount][0] += x[i+j]; } } tips_position[tipcount][0] = (tips_position[tipcount][0])/7; if(tips_position[tipcount][0] > 40) { if((tipcount > 1) && (i-tips_position[tipcount-1][1]) < 55) { tips_position[tipcount-1][0] = (tips_position[tipcount-1][0] + tips_position[tipcount][0]) / 2; tips_position[tipcount-1][1] = (tips_position[tipcount-1][1] + i) / 2; } else { tips_position[tipcount++][1] = i; } } } fprintf(tipgraph, "%f\n", cvGetReal1D(src, i)); } //printf("%d\t",tipcount); fclose(tipgraph); correlated_tips(); //fclose(freq); }
void defense::ImgToContours(IplImage* TheInput,int PlaneNumber, int CMode){ CvMemStorage* G_storage=NULL; G_storage=cvCreateMemStorage(0); CvSeq* contour = 0; IplImage * Maska; Maska = cvCreateImage( cvGetSize(TheInput),IPL_DEPTH_8U,1); int TotalEllip=0; CvMat* TempMat; TempMat = cvCreateMat(FFTSize, 1, CV_32FC2); vector <ofVec2f> TempVec; ArrayOfContours.clear(); ContourGray.clear(); for (int k=0;k<PlaneNumber;k++){ if (CMode==0) { cvInRangeS(TheInput,cvScalarAll((k-1)*255/(float)PlaneNumber),cvScalarAll(k*255/(float)PlaneNumber),Maska); } else{ cvThreshold(TheInput, Maska, k*255/(float)PlaneNumber, 255, CV_THRESH_BINARY_INV); } cvSmooth(Maska,Maska,CV_MEDIAN,3); int NC=cvFindContours( Maska, G_storage, &contour, sizeof(CvContour), CV_RETR_EXTERNAL, CV_CHAIN_APPROX_SIMPLE); // CV_RETR_EXTERNAL, CV_CHAIN_APPROX_TC89_L1 ); for( ; contour != 0; contour = contour->h_next ) { if ((contour->total > 10 )&&(TotalEllip<MaxEllip)){ CvMat* CountArray; CvBox2D Ellipdesc; CvPoint2D32f * OtroArray; OtroArray = new CvPoint2D32f[contour->total]; for(int q=0;q<contour->total;q++){ CvPoint* p = (CvPoint*)cvGetSeqElem( contour, q ); OtroArray[q].x = (float)p->x; OtroArray[q].y=(float)p->y; } CountArray=cvCreateMatHeader(contour->total,1,CV_32FC2); cvInitMatHeader(CountArray,contour->total,1,CV_32FC2,OtroArray); cvResize(CountArray, TempMat); cvDFT(TempMat, TempMat, CV_DXT_FORWARD); int TheLimit = (int)((FFTSize/2)*Slider1/127.0) -1; for (int q =0; q < TheLimit; q++) { ((float*)(TempMat->data.ptr + TempMat->step*((FFTSize/2)-q)))[0] = 0.0; ((float*)(TempMat->data.ptr + TempMat->step*((FFTSize/2)-q)))[1] = 0.0; ((float*)(TempMat->data.ptr + TempMat->step*((FFTSize/2)+q)))[0] = 0.0; ((float*)(TempMat->data.ptr + TempMat->step*((FFTSize/2)+q)))[1] = 0.0; } cvDFT(TempMat, TempMat, CV_DXT_INV_SCALE); TempVec.clear(); for (int q=0; q < FFTSize;q++){ TempVec.push_back(ofVec2f (((const float*)(TempMat->data.ptr + TempMat->step*q))[0], ((const float*)(TempMat->data.ptr + TempMat->step*q))[1])); } ArrayOfContours.push_back(TempVec); ContourGray.push_back(k*255/(float)PlaneNumber); TotalEllip++; delete [] OtroArray; cvReleaseMat(&CountArray); } // end of if contour-> total } // end of for contours } // end for planenumber cvReleaseMat(&TempMat); cvReleaseImage(&Maska); // releasing mem storages if (contour!=NULL){cvClearSeq(contour);} //cvClearMemStorage(storage); if (G_storage!=NULL){cvReleaseMemStorage(&G_storage);} }
ReturnType FrequencyFilter::onExecute() { // 영상을 Inport로부터 취득 opros_any *pData = ImageIn.pop(); RawImage result; if(pData != NULL) { // 포트로 부터 이미지 취득 RawImage Image = ImageIn.getContent(*pData); RawImageData *RawImage = Image.getImage(); // 현재영상의 크기를 취득 m_in_width = RawImage->getWidth(); m_in_height = RawImage->getHeight(); // 받은 영상의 2의 승수임을 확인 if(!Check2Square(m_in_width) || !Check2Square(m_in_height)) { std::cout << "This image is not a multifplier of 2" << std::endl; return OPROS_BAD_INPUT_PARAMETER; } // 받은 영상의 가로 세로 사이즈가 같은지 확인 if(m_in_width != m_in_height) { std::cout << "Size(width and height) of Image is not equal" << std::endl; return OPROS_BAD_INPUT_PARAMETER; } // 원본영상의 이미지영역 확보 if(m_orig_img == NULL) { m_orig_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3); } // 바이너리 영상영역의 확보 if(m_gray_img == NULL) { m_gray_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1); } // 수행결과 영상영역의 확보 if(m_result_img == NULL) { m_result_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 1); } // 출력결과 영상영역의 확보 if(m_final_img == NULL) { m_final_img = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_8U, 3); } // Re영역 영상영역의 확보(실수) if(m_image_Re == NULL) { m_image_Re = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 1); } // Im영역 영상영역의 확보(허수) if(m_image_Im == NULL) { m_image_Im = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 1); } // 주파수 변환 영상영역의 확보. if(m_pDFT_A == NULL) { m_pDFT_A = cvCreateImage(cvSize(m_in_width, m_in_height), IPL_DEPTH_32F, 2); } // 영상에 대한 정보를 확보!memcpy memcpy(m_orig_img->imageData, RawImage->getData(), RawImage->getSize()); // 둘다 none 이 아니거나, 둘중에 하나가 none 일경우 if((m_low_Pass_Filtering != "none" || m_high_Pass_Filtering != "none") && (m_low_Pass_Filtering == "none" || m_high_Pass_Filtering == "none")) { // 입력 받은 영상을 이진화 시킴 cvCvtColor( m_orig_img, m_gray_img, CV_BGR2GRAY ); // 주파수영역으로의 작업을 위한 깊이 정보 변경 cvConvertScale(m_gray_img, m_image_Re); // 8U -> 32F // m_image_Im의 초기화 cvZero(m_image_Im); // shift center // 입력영상을 실수부로 변환한 이미지가 홀수인 화소의 부호를 변경하여 // 푸리에변환에 의한 주파수 영역의 원점을 중심으로 이동시키기 위함 ChangePosition(m_image_Re); cvMerge(m_image_Re, m_image_Im, NULL, NULL, m_pDFT_A); // m_pDFT_A에 대해 푸리에 변환을 수행 cvDFT(m_pDFT_A, m_pDFT_A, CV_DXT_FORWARD); // 이상적 저주파 통과 필터링 실행 if(m_low_Pass_Filtering == "ideal" && m_high_Pass_Filtering == "none") { IdealLowPassFiltering(m_pDFT_A, m_cutoff_Frequency); } // 버터워스 저주파 통과 필터링 실행 else if(m_low_Pass_Filtering == "butterworth" && m_high_Pass_Filtering == "none") { ButterworthLowPassFiltering(m_pDFT_A, m_cutoff_Frequency, 2); } // 가우시안 저주파 통과 필터링 실행 else if(m_low_Pass_Filtering == "gaussian" && m_high_Pass_Filtering == "none") { GaussianLowPassFiltering(m_pDFT_A, m_cutoff_Frequency); } // 이상적 고주파 통과 필터링 실행 else if(m_high_Pass_Filtering == "ideal" && m_low_Pass_Filtering == "none") { IdealHighPassFiltering(m_pDFT_A, m_cutoff_Frequency); } // 버터워스 고주파 통과 필터링 실행 else if(m_high_Pass_Filtering == "butterworth" && m_low_Pass_Filtering == "none") { ButterworthHighPassFiltering(m_pDFT_A, m_cutoff_Frequency, 2); } // 가우시안 고주파 통과 필터링 실행 else if(m_high_Pass_Filtering == "gaussian" && m_low_Pass_Filtering == "none") { GaussianHighpassFiltering(m_pDFT_A, m_cutoff_Frequency); } else { //none } // 퓨리에 역변환 실행 cvDFT(m_pDFT_A, m_pDFT_A, CV_DXT_INV_SCALE); // 다중 채널의 행렬을 단일 채널 행렬로 분할(Re, Im으로) cvSplit(m_pDFT_A, m_image_Re, m_image_Im, NULL, NULL); // 저주파일때만 실행 if((m_low_Pass_Filtering == "ideal" || m_low_Pass_Filtering == "butterworth" || m_low_Pass_Filtering == "gaussian") && m_high_Pass_Filtering == "none") { ChangePosition(m_image_Re); cvScale(m_image_Re, m_result_img, 1); } // 고주파일때만 실행 if((m_high_Pass_Filtering == "ideal" || m_high_Pass_Filtering == "butterworth" || m_high_Pass_Filtering == "gaussian") && m_low_Pass_Filtering == "none") { // 스펙트럼의 진폭을 계산 Mag=sqrt(Re^2 + Im^2) cvPow(m_image_Re, m_image_Re, 2.0); cvPow(m_image_Im, m_image_Im, 2.0); cvAdd(m_image_Re, m_image_Re, m_image_Re); cvPow(m_image_Re, m_image_Re, 0.5); // 진폭 화상의 픽셀치가 min과 max사이에 분포하로독 스케일링 double min_val, max_val; cvMinMaxLoc(m_image_Re, &min_val, &max_val, NULL, NULL); cvScale(m_image_Re, m_result_img, 255.0/max_val); } // 1채널 영상의 3채널 영상으로의 변환 cvMerge(m_result_img, m_result_img, m_result_img, NULL, m_final_img); // 아웃풋 push // RawImage의 이미지 포인터 변수 할당 RawImageData *pimage = result.getImage(); // 입력된 이미지 사이즈 및 채널수로 로 재 설정 pimage->resize(m_final_img->width, m_final_img->height, m_final_img->nChannels); // 영상의 총 크기(pixels수) 취득 int size = m_final_img->width * m_final_img->height * m_final_img->nChannels; // 영상 데이터로부터 영상값만을 할당하기 위한 변수 unsigned char *ptrdata = pimage->getData(); // 현재 프레임 영상을 사이즈 만큼 memcpy memcpy(ptrdata, m_final_img->imageData, size); // 포트아웃 opros_any mdata = result; ImageOut.push(result);//전달 delete pData; } else { // 아웃풋 push // 아웃풋 push // RawImage의 이미지 포인터 변수 할당 RawImageData *pimage = result.getImage(); // 입력된 이미지 사이즈 및 채널수로 로 재 설정 pimage->resize(m_orig_img->width, m_orig_img->height, m_orig_img->nChannels); // 영상의 총 크기(pixels수) 취득 int size = m_orig_img->width * m_orig_img->height * m_orig_img->nChannels; // 영상 데이터로부터 영상값만을 할당하기 위한 변수 unsigned char *ptrdata = pimage->getData(); // 현재 프레임 영상을 사이즈 만큼 memcpy memcpy(ptrdata, m_orig_img->imageData, size); // 포트아웃 opros_any mdata = result; ImageOut.push(result);//전달 delete pData; } } return OPROS_SUCCESS; }
static CvPoint alignImages( const CvMat* img, const CvMat* pano ) { CvSize img_size = cvGetSize(img); CvSize pano_size = cvGetSize(pano); // to handle wraparound correctly, I set the output size to be at least as // large as double the smallest dimensions #define max(a,b) ( (a) > (b) ? (a) : (b) ) #define min(a,b) ( (a) < (b) ? (a) : (b) ) CvSize dft_size = cvSize( max( 2*min(img_size.width, pano_size.width), max(img_size.width, pano_size.width) ), max( 2*min(img_size.height, pano_size.height), max(img_size.height, pano_size.height) ) ); #undef min #undef max #define DoDft(mat) \ CvMat* mat ## _float = cvCreateMat( dft_size.height, dft_size.width, CV_32FC1); \ assert( mat ## _float ); \ \ CvMat* mat ## _dft = cvCreateMat( dft_size.height, dft_size.width, CV_32FC1); \ assert( mat ## _dft ); \ \ cvSet( mat ## _float, \ cvAvg(mat, NULL), \ NULL ); \ \ CvMat mat ## _float_origsize; \ cvGetSubRect( mat ## _float, &mat ## _float_origsize, \ cvRect(0,0, mat ## _size.width, mat ## _size.height ) ); \ cvConvert( mat, &mat ## _float_origsize ); \ cvDFT(mat ## _float, mat ## _dft, CV_DXT_FORWARD, 0) DoDft(img); DoDft(pano); CvMat* correlation = cvCreateMat( dft_size.height, dft_size.width, CV_32FC1); CvMat* correlation_freqdomain = cvCreateMat( dft_size.height, dft_size.width, CV_32FC1); assert(correlation_freqdomain); cvMulSpectrums(pano_dft, img_dft, correlation_freqdomain, CV_DXT_MUL_CONJ); cvDFT(correlation_freqdomain, correlation, CV_DXT_INVERSE, 0); double minval, maxval; CvPoint minpoint, maxpoint; cvMinMaxLoc( correlation, &minval, &maxval, &minpoint, &maxpoint, NULL ); printf("right answer: (644,86)\n"); cvSaveImage( "iedges.png", img_float ,0 ); cvSaveImage( "pedges.png", pano_float,0 ); CvMat* correlation_img = cvCreateMat( dft_size.height, dft_size.width, CV_8UC1); cvConvertScale( correlation, correlation_img, 255.0/(maxval - minval), -minval*255.0/(maxval - minval) ); cvSaveImage( "corr.png", correlation_img ,0 ); cvReleaseMat( &correlation_img ); cvReleaseMat( &correlation ); cvReleaseMat( &correlation_freqdomain ); cvReleaseMat( &img_float ); cvReleaseMat( &pano_float ); cvReleaseMat( &img_dft ); cvReleaseMat( &pano_dft ); return maxpoint; }
IplImage* ComputeSaliency(IplImage* image, int thresh, int scale) { //given a one channel image unsigned int size = floor(pow(2,scale)); //the size to do teh saliency @ IplImage* bw_im = cvCreateImage(cvSize(size,size), IPL_DEPTH_8U,1); cvResize(image, bw_im); IplImage* realInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1); IplImage* imaginaryInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 1); IplImage* complexInput = cvCreateImage( cvGetSize(bw_im), IPL_DEPTH_32F, 2); cvScale(bw_im, realInput, 1.0/255.0); cvZero(imaginaryInput); cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput); CvMat* dft_A = cvCreateMat( size, size, CV_32FC2 ); // copy A to dft_A and pad dft_A with zeros CvMat tmp; cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size)); cvCopy( complexInput, &tmp ); // cvZero(&tmp); cvDFT( dft_A, dft_A, CV_DXT_FORWARD, size ); cvSplit( dft_A, realInput, imaginaryInput, NULL, NULL ); // Compute the phase angle IplImage* image_Mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1); IplImage* image_Phase = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1); //compute the phase of the spectrum cvCartToPolar(realInput, imaginaryInput, image_Mag, image_Phase, 0); IplImage* log_mag = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1); cvLog(image_Mag, log_mag); //Box filter the magnitude, then take the difference IplImage* log_mag_Filt = cvCreateImage(cvSize(size, size), IPL_DEPTH_32F, 1); CvMat* filt = cvCreateMat(3,3, CV_32FC1); cvSet(filt,cvScalarAll(1.0/9.0)); cvFilter2D(log_mag, log_mag_Filt, filt); cvReleaseMat(&filt); cvSub(log_mag, log_mag_Filt, log_mag); cvExp(log_mag, image_Mag); cvPolarToCart(image_Mag, image_Phase, realInput, imaginaryInput,0); cvExp(log_mag, image_Mag); cvMerge(realInput, imaginaryInput, NULL, NULL, dft_A); cvDFT( dft_A, dft_A, CV_DXT_INV_SCALE, size); cvAbs(dft_A, dft_A); cvMul(dft_A,dft_A, dft_A); cvGetSubRect( dft_A, &tmp, cvRect(0,0, size,size)); cvCopy( &tmp, complexInput); cvSplit(complexInput, realInput, imaginaryInput, NULL,NULL); IplImage* result_image = cvCreateImage(cvGetSize(image),IPL_DEPTH_32F, 1); double minv, maxv; CvPoint minl, maxl; cvSmooth(realInput,realInput); cvSmooth(realInput,realInput); cvMinMaxLoc(realInput,&minv,&maxv,&minl,&maxl); printf("Max value %lf, min %lf\n", maxv,minv); cvScale(realInput, realInput, 1.0/(maxv-minv), 1.0*(-minv)/(maxv-minv)); cvResize(realInput, result_image); double threshold = thresh/100.0*cvAvg(realInput).val[0]; cvThreshold(result_image, result_image, threshold, 1.0, CV_THRESH_BINARY); IplImage* final_result = cvCreateImage(cvGetSize(image),IPL_DEPTH_8U, 1); cvScale(result_image, final_result, 255.0, 0.0); cvReleaseImage(&result_image); //cvReleaseImage(&realInput); cvReleaseImage(&imaginaryInput); cvReleaseImage(&complexInput); cvReleaseMat(&dft_A); cvReleaseImage(&bw_im); cvReleaseImage(&image_Mag); cvReleaseImage(&image_Phase); cvReleaseImage(&log_mag); cvReleaseImage(&log_mag_Filt); cvReleaseImage(&bw_im); return final_result; //return bw_im; }
static IplImage* get_convolution (const IplImage *image, const IplImage *filter) { CvSize dft_size; IplImage *reversed_image, *reversed_filter; IplImage *dft_image, *dft_filter, *dft_res; IplImage *res; dft_size.height = cvGetOptimalDFTSize(image->height + filter->height - 1); dft_size.width = cvGetOptimalDFTSize(image->width + filter->width - 1); res = cvCreateImage(cvSize(image->width, image->height), IPL_DEPTH_32F, N_CHANNELS_GRAY); reversed_image = cvCreateImage(cvGetSize(image), IPL_DEPTH_8U, N_CHANNELS_GRAY); reversed_filter = cvCreateImage(cvGetSize(filter), IPL_DEPTH_8U, N_CHANNELS_GRAY); cvNot(image, reversed_image); cvNot(filter, reversed_filter); dft_image = cvCreateImage(dft_size, IPL_DEPTH_32F, N_CHANNELS_GRAY); cvSet(dft_image, cvScalar(0, 0, 0, 0), NULL); dft_filter = cvCreateImage(dft_size, IPL_DEPTH_32F, N_CHANNELS_GRAY); cvSet(dft_filter, cvScalar(0, 0, 0, 0), NULL); cvSetImageROI(dft_image, cvRect(0, 0, reversed_image->width, reversed_image->height)); cvSetImageROI(dft_filter, cvRect(0, 0, reversed_filter->width, reversed_filter->height)); double scaling_factor = 1.0/255; cvConvertScale(reversed_image, dft_image, scaling_factor, 0); cvConvertScale(reversed_filter, dft_filter, scaling_factor, 0); cvResetImageROI(dft_image); cvResetImageROI(dft_filter); cvDFT(dft_image, dft_image, CV_DXT_FORWARD, image->height); cvDFT(dft_filter, dft_filter, CV_DXT_FORWARD, filter->height); dft_res = cvCreateImage(dft_size, IPL_DEPTH_32F, N_CHANNELS_GRAY); cvMulSpectrums(dft_image, dft_filter, dft_res, 0); cvDFT(dft_res, dft_res, CV_DXT_INVERSE, res->height); cvSetImageROI(dft_res, cvRect(0, 0, res->width, res->height)); cvCopy(dft_res, res, NULL); cvResetImageROI(dft_res); cvReleaseImage(&reversed_filter); cvReleaseImage(&reversed_image); cvReleaseImage(&dft_image); cvReleaseImage(&dft_filter); cvReleaseImage(&dft_res); return res; }
IplImage *wiener_filter(IplImage* input_file, double snr, IplImage *filter_file){ int height = input_file->height; int width = input_file->width; int h, w; // convert to CvMat CvMat *input_real = cvCreateMat( height, width, CV_64FC1 ); CvMat *input_imag = cvCreateMat( height, width, CV_64FC1 ); CvMat *output_real = cvCreateMat( height, width, CV_64FC1 ); CvMat *output_imag = cvCreateMat( height, width, CV_64FC1 ); CvMat *filter_real = cvCreateMat( height, width, CV_64FC1 ); CvMat *filter_imag = cvCreateMat( height, width, CV_64FC1 ); // cvDFTを使うためのデータ変換 // cvDFTで扱うデータ形式は,double型cvMat,2channel CvMat *fft_mat = cvCreateMat( height, width, CV_64FC2 ); // input file cvConvert( input_file, input_real ); // IplImage -> input_real cvSetZero( input_imag ); // input_imag = 0 cvMerge( input_real, input_imag, NULL, NULL, fft_mat ); // ( input_real, input_imag ) -> fft_mat cvDFT( fft_mat, fft_mat, CV_DXT_FORWARD , 0);// FFT cvSplit( fft_mat, input_real, input_imag, NULL, NULL ); // fft_mat -> ( input_real, input_imag ) // filter file cvSetZero( filter_real ); // convert filter_file to filter_real for( h = 0; h < filter_file->height; ++h ){ for( w = 0; w < filter_file->width; ++w ){ int y = h - filter_file->height/2; int x = w - filter_file->width/2; y += (y<0) ? height : 0; x += (x<0) ? width : 0; CV_MAT_ELEM( *filter_real, double, y, x ) = CV_IMAGE_ELEM( filter_file, uchar, h, w ); } } cvNormalize( filter_real, filter_real, 1.0, 0.0, CV_L1, NULL ); cvSetZero( filter_imag ); // filter_imag = 0 cvMerge( filter_real, filter_imag, NULL, NULL, fft_mat ); // ( filter_real, filter_imag ) -> fft_mat cvDFT( fft_mat, fft_mat, CV_DXT_FORWARD , 0);// FFT cvSplit( fft_mat, filter_real, filter_imag, NULL, NULL ); // fft_mat -> ( filter_real, filter_imag ) // Wiener calculation for( h = 0; h < height; ++h ){ for( w = 0; w < width; ++w ){ double a = CV_MAT_ELEM( *input_real, double, h, w ); double b = CV_MAT_ELEM( *input_imag, double, h, w ); double c = CV_MAT_ELEM( *filter_real, double, h, w ); double d = CV_MAT_ELEM( *filter_imag, double, h, w ); CV_MAT_ELEM( *output_real, double, h, w ) = ( a*c + b*d ) / ( c*c + d*d + snr ); CV_MAT_ELEM( *output_imag, double, h, w ) = ( b*c - a*d ) / ( c*c + d*d + snr ); } } // IFT cvMerge( output_real, output_imag, NULL, NULL, fft_mat); cvDFT( fft_mat, fft_mat, CV_DXT_INV_SCALE, 0 ); cvSplit( fft_mat, output_real, output_imag, NULL, NULL ); // save file IplImage *output_file = cvCreateImage( cvSize( width, height), IPL_DEPTH_8U, 1 ); cvConvert( output_real, output_file); return output_file; }