void blur_function(const IplImage *latent_image, IplImage *blur_image, const CvMat *hom1, const CvMat *hom2) { const int T = 20; const int tau = 10; CvMat *id_mat = cvCreateMat(3, 3, CV_32FC1); cvSetIdentity(id_mat, cvRealScalar(1)); CvMat *invhom1 = cvCreateMat(3, 3, CV_32FC1); cvInvert(hom1, invhom1, CV_LU); CvMat *h1 = cvCreateMat(3, 3, CV_32FC1); CvMat *h2 = cvCreateMat(3, 3, CV_32FC1); CvSize size = cvSize(latent_image->width, latent_image->height); IplImage *temp = cvCreateImage(size, latent_image->depth, latent_image->nChannels); IplImage *blur = cvCreateImage(size, IPL_DEPTH_32F, latent_image->nChannels); cvSetZero(blur); for (int i = 1; i <= tau; ++i) { cvAddWeighted(id_mat, (double)(T-i)/T, invhom1, (double)i/T, 0, h1); cvAddWeighted(id_mat, (double)(T-i)/T, hom2, (double)i/T, 0, h2); cvWarpPerspective(latent_image, temp, h1, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); cvAdd(blur, temp, blur, NULL); cvWarpPerspective(latent_image, temp, h2, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); cvAdd(blur, temp, blur, NULL); } cvAdd(blur, latent_image, blur, NULL); cvConvertScale(blur, blur_image, 1.0/(2*tau+1), 0); cvReleaseMat(&id_mat); cvReleaseMat(&invhom1); cvReleaseMat(&h1); cvReleaseMat(&h2); cvReleaseImage(&temp); cvReleaseImage(&blur); }
//Input image, Edges, outputNameFile int homography_transformation(CvMat* src, char* out_filename, CvPoint2D32f* srcQuad){ if(src == NULL || out_filename == NULL || srcQuad == NULL) return -1; CvPoint2D32f dstQuad[4]; //Destination vertices CvMat* warp_matrix = cvCreateMat(3,3,CV_32FC1); //transformation matrix CvMat* dst = cvCloneMat(src); //clone image int p[3]={CV_IMWRITE_JPEG_QUALITY,JPEG_QUALITY,0}; //FORMAT, QUALITY dstQuad[0].x = 0; //dst Top left dstQuad[0].y = 0; dstQuad[1].x = src->cols; //dst Top right dstQuad[1].y = 0; dstQuad[2].x = 0; //dst Bottom left dstQuad[2].y = src->rows; dstQuad[3].x = src->cols; //dst Bot right dstQuad[3].y = src->rows; // get transformation matrix that you can use to calculate cvGetPerspectiveTransform(srcQuad,dstQuad, warp_matrix); // perspective transformation. Parameters: source, destination, warp_matrix, //type of interpolation: (CV_INTER_LINEAR, CV_INTER_AREA, CV_INTER_CUBIC, CV_INTER_LANCZOS4) ///Set all scalar with the same value. 0 means the black color of border cvWarpPerspective(src, dst, warp_matrix, CV_INTER_LINEAR, cvScalarAll(0)); // 1 = CV_INTER_LINEAR cvSaveImage(out_filename,dst, p); //close and destroy all stuff cvReleaseMat(&warp_matrix); cvReleaseMat(&dst); return 0; }
/** * A +-------------+ B * / \ * / \ * / \ * D +-------------------- + C */ void ofCvImage::warpPerspective( const ofPoint& A, const ofPoint& B, const ofPoint& C, const ofPoint& D ) { // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat* translate = cvCreateMat( 3,3, CV_32FC1 ); cvSetZero( translate ); cvsrc[0].x = 0; cvsrc[0].y = 0; cvsrc[1].x = width; cvsrc[1].y = 0; cvsrc[2].x = width; cvsrc[2].y = height; cvsrc[3].x = 0; cvsrc[3].y = height; cvdst[0].x = A.x; cvdst[0].y = A.y; cvdst[1].x = B.x; cvdst[1].y = B.y; cvdst[2].x = C.x; cvdst[2].y = C.y; cvdst[3].x = D.x; cvdst[3].y = D.y; cvWarpPerspectiveQMatrix( cvsrc, cvdst, translate ); // calculate homography cvWarpPerspective( cvImage, cvImageTemp, translate ); swapTemp(); cvReleaseMat( &translate ); }
static void projectImg(IplImage *src, int64_t TRANS_X, int64_t TRANS_Y, IplImage *dst, CvMat *tmatrix) { if (tmatrix->rows == 2) { //translate CvMat* result = cvCreateMat(2, 3, CV_32FC1); cvSetReal2D(result, 0, 0, cvGetReal2D(tmatrix, 0, 0)); cvSetReal2D(result, 0, 1, cvGetReal2D(tmatrix, 0, 1)); cvSetReal2D(result, 1, 0, cvGetReal2D(tmatrix, 1, 0)); cvSetReal2D(result, 1, 1, cvGetReal2D(tmatrix, 1, 1)); cvSetReal2D(result, 0, 2, cvGetReal2D(tmatrix, 0, 2) + TRANS_X); cvSetReal2D(result, 1, 2, cvGetReal2D(tmatrix, 1, 2) + TRANS_Y); cvWarpAffine(src, dst, result, CV_INTER_LINEAR, cvScalarAll(0)); cvReleaseMat(&result); } else if (tmatrix->rows == 3) { //translate matrix CvMat* offset = cvCreateMat(3, 3, CV_32FC1); cvSetReal2D(offset, 0, 0, 1); cvSetReal2D(offset, 0, 1, 0); cvSetReal2D(offset, 0, 2, TRANS_X); cvSetReal2D(offset, 1, 0, 0); cvSetReal2D(offset, 1, 1, 1); cvSetReal2D(offset, 1, 2, TRANS_Y); cvSetReal2D(offset, 2, 0, 0); cvSetReal2D(offset, 2, 1, 0); cvSetReal2D(offset, 2, 2, 1); //translate CvMat* result = cvCreateMat(3, 3, CV_32FC1); cvMatMul(offset, tmatrix, result); cvWarpPerspective(src, dst, result, CV_INTER_LINEAR, cvScalarAll(0)); cvReleaseMat(&offset); cvReleaseMat(&result); } }
//-------------------------------------------------------------------------------- void ofxCvImage::warpPerspective( const ofPoint& A, const ofPoint& B, const ofPoint& C, const ofPoint& D ) { if( !bAllocated ){ ofLog(OF_LOG_ERROR, "in warpPerspective, need to allocate image first"); return; } // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat* translate = cvCreateMat( 3,3, CV_32FC1 ); cvSetZero( translate ); cvdst[0].x = 0; cvdst[0].y = 0; cvdst[1].x = width; cvdst[1].y = 0; cvdst[2].x = width; cvdst[2].y = height; cvdst[3].x = 0; cvdst[3].y = height; cvsrc[0].x = A.x; cvsrc[0].y = A.y; cvsrc[1].x = B.x; cvsrc[1].y = B.y; cvsrc[2].x = C.x; cvsrc[2].y = C.y; cvsrc[3].x = D.x; cvsrc[3].y = D.y; cvWarpPerspectiveQMatrix( cvsrc, cvdst, translate ); // calculate homography cvWarpPerspective( cvImage, cvImageTemp, translate ); swapTemp(); flagImageChanged(); cvReleaseMat( &translate ); }
//-------------------------------------------------------------------------------- void ofxCvImage::warpIntoMe( ofxCvImage& mom, const ofPoint src[4], const ofPoint dst[4] ){ if( !bAllocated ){ ofLog(OF_LOG_ERROR, "in warpIntoMe, image not allocated"); return; } if( !mom.bAllocated ){ ofLog(OF_LOG_ERROR, "in warpIntoMe, mom not allocated"); return; } if( mom.getCvImage()->nChannels == cvImage->nChannels && mom.getCvImage()->depth == cvImage->depth ) { // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat* translate = cvCreateMat( 3, 3, CV_32FC1 ); cvSetZero( translate ); for (int i = 0; i < 4; i++ ) { cvsrc[i].x = src[i].x; cvsrc[i].y = src[i].y; cvdst[i].x = dst[i].x; cvdst[i].y = dst[i].y; } cvWarpPerspectiveQMatrix( cvsrc, cvdst, translate ); // calculate homography cvWarpPerspective( mom.getCvImage(), cvImage, translate); flagImageChanged(); cvReleaseMat( &translate ); } else { ofLog(OF_LOG_ERROR, "in warpIntoMe: mom image type has to match"); } }
//-------------------------------------------------------------------------------- void ofxCvImage::warpPerspective( const ofPoint& A, const ofPoint& B, const ofPoint& C, const ofPoint& D ) { if( !bAllocated ){ ofLogError("ofxCvImage") << "warpPerspective(): image not allocated"; return; } // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat* translate = cvCreateMat( 3,3, CV_32FC1 ); cvSetZero( translate ); cvdst[0].x = 0; cvdst[0].y = 0; cvdst[1].x = width; cvdst[1].y = 0; cvdst[2].x = width; cvdst[2].y = height; cvdst[3].x = 0; cvdst[3].y = height; cvsrc[0].x = A.x; cvsrc[0].y = A.y; cvsrc[1].x = B.x; cvsrc[1].y = B.y; cvsrc[2].x = C.x; cvsrc[2].y = C.y; cvsrc[3].x = D.x; cvsrc[3].y = D.y; cvGetPerspectiveTransform( cvsrc, cvdst, translate ); // calculate homography cvWarpPerspective( cvImage, cvImageTemp, translate ); swapTemp(); flagImageChanged(); cvReleaseMat( &translate ); }
//-------------------------------------------------------------------------------- void ofxCvImage::warpIntoMe( ofxCvImage& mom, const ofPoint src[4], const ofPoint dst[4] ){ if( !bAllocated ){ ofLogError("ofxCvImage") << "warpIntoMe(): image not allocated"; return; } if( !mom.bAllocated ){ ofLogError("ofxCvImage") << "warpIntoMe(): source image not allocated"; return; } if( mom.getCvImage()->nChannels == cvImage->nChannels && mom.getCvImage()->depth == cvImage->depth ) { // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat* translate = cvCreateMat( 3, 3, CV_32FC1 ); cvSetZero( translate ); for (int i = 0; i < 4; i++ ) { cvsrc[i].x = src[i].x; cvsrc[i].y = src[i].y; cvdst[i].x = dst[i].x; cvdst[i].y = dst[i].y; } cvGetPerspectiveTransform( cvsrc, cvdst, translate ); // calculate homography cvWarpPerspective( mom.getCvImage(), cvImage, translate); flagImageChanged(); cvReleaseMat( &translate ); } else { ofLogError("ofxCvImage") << "warpIntoMe(): image type mismatch"; } }
int main(int argc, char** argv) { IplImage* image = cvLoadImage(argv[1], CV_LOAD_IMAGE_COLOR); // cvCreateImage(cvSize(320, 240), IPL_DEPTH_8U, 3); cvNamedWindow("result", CV_WINDOW_AUTOSIZE); /* gsl_qrng* q = gsl_qrng_alloc(gsl_qrng_halton, 2); for (int i = 0; i < 64; i++) { double v[2]; gsl_qrng_get(q, v); int x = (int)(v[0] * 319), y = (int)(v[1] * 239); image->imageData[x * 3 + y * image->widthStep] = image->imageData[x * 3 + 1 + y * image->widthStep] = image->imageData[x * 3 + 2 + y * image->widthStep] = 255; } gsl_qrng_free(q); */ gsl_rng_env_setup(); const gsl_rng_type* T = gsl_rng_default; gsl_rng* r = gsl_rng_alloc(T); gsl_rng_set(r, time(NULL)); double sigma = 0.1 * ((image->width < image->height) ? image->width : image->height); CvPoint2D32f src[4], dst[4], rds[4]; src[0].x = 0; src[0].y = 0; src[1].x = image->width; src[1].y = 0; src[2].x = image->width; src[2].y = image->height; src[3].x = 0; src[3].y = image->height; dst[0].x = -image->width / 2 + gsl_ran_gaussian(r, sigma); dst[0].y = -image->height / 2 + gsl_ran_gaussian(r, sigma); dst[1].x = image->width / 2 + gsl_ran_gaussian(r, sigma); dst[1].y = -image->height / 2 + gsl_ran_gaussian(r, sigma); dst[2].x = image->width / 2 + gsl_ran_gaussian(r, sigma); dst[2].y = image->height / 2 + gsl_ran_gaussian(r, sigma); dst[3].x = -image->width / 2 + gsl_ran_gaussian(r, sigma); dst[3].y = image->height / 2 + gsl_ran_gaussian(r, sigma); double radius = gsl_ran_gaussian(r, 3.1415926 / 8.0); double minx = 0, miny = 0, maxx = 0, maxy = 0; for (int i = 0; i < 4; i++) { rds[i].x = dst[i].x * cos(radius) - dst[i].y * sin(radius); rds[i].y = dst[i].x * sin(radius) + dst[i].y * cos(radius); if (rds[i].x < minx) minx = rds[i].x; if (rds[i].y < miny) miny = rds[i].y; if (rds[i].x > maxx) maxx = rds[i].x; if (rds[i].y > maxy) maxy = rds[i].y; } for (int i = 0; i < 4; i++) { rds[i].x -= minx; rds[i].y -= miny; } gsl_rng_free(r); float _m[9]; CvMat m = cvMat(3, 3, CV_32FC1, _m); cvGetPerspectiveTransform(src, rds, &m); IplImage* transformed = cvCreateImage(cvSize(maxx - minx, maxy - miny), IPL_DEPTH_8U, 3); cvWarpPerspective(image, transformed, &m); cvShowImage("result", transformed); cvWaitKey(0); cvDestroyWindow("result"); return 0; }
void margDisplay::feedImg(ofxCvColorImage& _source) { if (image.getWidth() != _source.getWidth()) { image.clear(); image.allocate(source.getWidth(), source.getHeight()); } cvWarpPerspective(_source.getCvImage(), image.getCvImage(), translate); image.flagImageChanged(); }
void SimpleImageProjector::project(IplImage* dst, A4PreciseDetectedRecord dstRecord) { CvPoint2D32f dstCorners[4]; dstCorners[0] = cvPoint2D32f(dstRecord.UL.x, dstRecord.UL.y); dstCorners[1] = cvPoint2D32f(dstRecord.UR.x, dstRecord.UR.y); dstCorners[2] = cvPoint2D32f(dstRecord.DL.x, dstRecord.DL.y); dstCorners[3] = cvPoint2D32f(dstRecord.DR.x, dstRecord.DR.y); cvWarpPerspective(projection, dst, transformMat, CV_INTER_LINEAR); }
void ofxImageROI::projectToTarget(ofPoint *dstPoints) { CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; cvsrc[0].x = cornerPoints[0].x; cvsrc[0].y = cornerPoints[0].y; cvsrc[1].x = cornerPoints[1].x; cvsrc[1].y = cornerPoints[1].y; cvsrc[2].x = cornerPoints[2].x; cvsrc[2].y = cornerPoints[2].y; cvsrc[3].x = cornerPoints[3].x; cvsrc[3].y = cornerPoints[3].y; cvdst[0].x = dstPoints[0].x; cvdst[0].y = dstPoints[0].y; cvdst[1].x = dstPoints[1].x; cvdst[1].y = dstPoints[1].y; cvdst[2].x = dstPoints[2].x; cvdst[2].y = dstPoints[2].y; cvdst[3].x = dstPoints[3].x; cvdst[3].y = dstPoints[3].y; CvMat* src_mat = cvCreateMat(4, 2, CV_32FC1); CvMat* dst_mat = cvCreateMat(4, 2, CV_32FC1); cvSetData(src_mat, cvsrc, sizeof(CvPoint2D32f)); cvSetData(dst_mat, cvdst, sizeof(CvPoint2D32f)); CvMat * translate = cvCreateMat(3,3,CV_32FC1); // 領域確保 cvFindHomography(src_mat, dst_mat, translate); // ホモグラフィ計算 // 画像サイズが変わったとき if (this->bAllocated() == true && inputImg.bAllocated == false) { projectedImage.allocate(this->width, this->height, OF_IMAGE_COLOR); inputImg.allocate(this->width, this->height); outputImg.allocate(this->width, this->height); } inputImg.setFromPixels(this->getPixelsRef()); // 画像のロード cvWarpPerspective(inputImg.getCvImage(), outputImg.getCvImage(), translate, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(255)); // 透視投影変換 //出力結果をofImageに変換 projectedImage.setFromPixels(outputImg.getPixels(), outputImg.getWidth(), outputImg.getHeight(), OF_IMAGE_COLOR); cvReleaseMat(&translate); cvReleaseMat(&src_mat); cvReleaseMat(&dst_mat); }
void COpenCVMFCView::OnWarpPerspect() { // TODO: Add your command handler code here CvPoint2D32f srcQuad[4], dstQuad[4]; CvMat* warp_matrix = cvCreateMat(3,3,CV_32FC1); IplImage *src=0, *dst=0; src = cvCloneImage(workImg); cvFlip(src); dst = cvCloneImage(src); dst->origin = src->origin; cvZero(dst); srcQuad[0].x = 0; //src Top left srcQuad[0].y = 0; srcQuad[1].x = (float) src->width - 1; //src Top right srcQuad[1].y = 0; srcQuad[2].x = 0; //src Bottom left srcQuad[2].y = (float) src->height - 1; srcQuad[3].x = (float) src->width - 1; //src Bot right srcQuad[3].y = (float) src->height - 1; //- - - - - - - - - - - - - -// dstQuad[0].x = (float)(src->width*0.05); //dst Top left dstQuad[0].y = (float)(src->height*0.33); dstQuad[1].x = (float)(src->width*0.9); //dst Top right dstQuad[1].y = (float)(src->height*0.25); dstQuad[2].x = (float)(src->width*0.2); //dst Bottom left dstQuad[2].y = (float)(src->height*0.7); dstQuad[3].x = (float)(src->width*0.8); //dst Bot right dstQuad[3].y = (float)(src->height*0.9); cvGetPerspectiveTransform(srcQuad,dstQuad,warp_matrix); cvWarpPerspective(src,dst,warp_matrix); cvNamedWindow( "Perspective_Warp", 1 ); cvShowImage( "Perspective_Warp", dst ); m_ImageType=-3; cvWaitKey(); cvDestroyWindow( "Perspective_Warp" ); cvReleaseImage(&src); cvReleaseImage(&dst); cvReleaseMat(&warp_matrix); m_ImageType=imageType(workImg); }
//------------------------------------------------------------------------------------- void ofCvColorImage::warpIntoMe(ofCvColorImage &mom, ofPoint2f src[4], ofPoint2f dst[4]){ // compute matrix for perspectival warping (homography) CvPoint2D32f cvsrc[4]; CvPoint2D32f cvdst[4]; CvMat *translate = cvCreateMat(3,3,CV_32FC1); cvSetZero(translate); for (int i = 0; i < 4; i++){ cvsrc[i].x = src[i].x; cvsrc[i].y = src[i].y; cvdst[i].x = dst[i].x; cvdst[i].y = dst[i].y; } cvWarpPerspectiveQMatrix(cvsrc, cvdst, translate); // calculate homography cvWarpPerspective( mom.getCvImage(), cvImage, translate); cvReleaseMat(&translate); }
void perspectiveTransform() { processImage = windowImage; setVariables(); //设置四个预设的点 setPoints(); //选取图片上的点 cvDestroyWindow("monitor"); windowImage = cvCreateImage(cvSize(squareWindowSize,squareWindowSize), IPL_DEPTH_8U, 3); cvGetPerspectiveTransform(originalPoints, transPoints, transmat); //计算transmat的值 cvWarpPerspective(processImage , windowImage , transmat); //这一句利用transmat进行变换 cvNamedWindow("control"); cvMoveWindow("control", middlewindowX, middlewindowY); cvShowImage("control", windowImage); cvWaitKey(); cvDestroyWindow("control"); }
int main(int argc, const char * argv[]) { CvPoint2D32f srcQuad[4], dstQuad[4]; CvMat* warp_matrix = cvCreateMat(3, 3, CV_32FC1); IplImage *src, *dst; if (argc == 2 && ((src = cvLoadImage(argv[1], 1)) != 0)) { dst = cvCloneImage( src ); dst->origin = src->origin; cvZero( dst ); // warp matrix srcQuad[0].x = 0; srcQuad[0].y = 0; srcQuad[1].x = src->width - 1; srcQuad[1].y = 0; srcQuad[2].x = 0; srcQuad[2].y = src->height - 1; srcQuad[3].x = src->width - 1; srcQuad[3].y = src->height - 1; dstQuad[0].x = src->width * 0.005; dstQuad[0].y = src->height * 0.33; dstQuad[1].x = src->width * 0.9; dstQuad[1].y = src->height * 0.25; dstQuad[2].x = src->width * 0.2; dstQuad[2].y = src->height * 0.7; dstQuad[3].x = src->width * 0.8; dstQuad[3].y = src->height * 0.9; cvGetPerspectiveTransform( srcQuad, dstQuad, warp_matrix ); cvWarpPerspective( src, dst, warp_matrix ); cvNamedWindow( "Perspective_Transform", 1 ); cvShowImage( "Perspective_Transform" , dst ); cvWaitKey(); cvReleaseImage( &dst ); } cvReleaseMat( &warp_matrix ); return 0; }
int hamuju_birds_eye(const char * homography_file, hamuju_image_t * in_image, hamuju_image_t * out_image) { CvMat *homography; CvSize imgsize; IplImage *orig, *birdeye; if(homography_file == NULL || in_image == NULL || out_image == NULL) { fprintf(stderr, "%s: Got a null pointer!\n", __func__); return -1; } printf("Loading Homography: %s\n", homography_file); homography = (CvMat *) cvLoad(homography_file, NULL, NULL, NULL); printf("Allocating memory for temp IplImage objects\n"); imgsize = cvSize(in_image->width, in_image->height); orig = cvCreateImage(imgsize, 8, 3); birdeye = cvCreateImage(imgsize, 8, 3); // copy the image to OpenCV format printf("Copying original image to IplImage"); hamuju_image_copy_to_iplimage((hamuju_iplimage_t *)orig, in_image); // transform the image printf("Applying warp transform\n"); /** * 2D Homography matrix: * [R11, R12, T1] * [R21, R22, T2] * [P , P , 1] */ CV_MAT_ELEM(*homography,float,2,2) = 30; //zoom cvWarpPerspective(orig, birdeye, homography, CV_INTER_LINEAR | CV_WARP_FILL_OUTLIERS | CV_WARP_INVERSE_MAP, cvScalarAll(0)); // copy bird's eye view to destination image printf("Copying transformed image to hamuju_image_t\n"); hamuju_image_copy_from_iplimage(out_image, (hamuju_iplimage_t *)birdeye); // free temp memory printf("Releasing IplImage objects\n"); //cvReleaseImage(orig); //cvReleaseImage(birdeye); return 0; }
IplImage *square_puzzle(IplImage *in, const CvPoint2D32f *location) { int xsize = location[1].x - location[0].x; int ysize = xsize; CvPoint2D32f warped_coordinates[4]; warped_coordinates[0] = cvPointTo32f(cvPoint(0, 0)); warped_coordinates[1] = cvPointTo32f(cvPoint(xsize-1, 0)); warped_coordinates[2] = cvPointTo32f(cvPoint(xsize-1, ysize-1)); warped_coordinates[3] = cvPointTo32f(cvPoint(0, ysize-1)); CvMat *map_matrix = cvCreateMat(3, 3, CV_64FC1); cvGetPerspectiveTransform(location, warped_coordinates, map_matrix); IplImage *warped_image = cvCreateImage(cvSize(xsize, ysize), 8, in->nChannels); CvScalar fillval=cvScalarAll(0); cvWarpPerspective(in, warped_image, map_matrix, CV_WARP_FILL_OUTLIERS, fillval); return warped_image; }
void llcv_unwarp(dmz_context *dmz, IplImage *input, const dmz_point source_points[4], const dmz_rect to_rect, IplImage *output) { // dmz_point source_points[4], dest_points[4]; #ifdef IOS_DMZ ios_gpu_unwarp(dmz, input, source_points, output); #else dmz_trace_log("pre-warp in.width:%i in.height:%i in.widthStep:%i in.nChannels:%i", input->width, input->height, input->widthStep, input->nChannels); assert(output != null); assert(output->imageData != null); dmz_trace_log("expecting out.width:%i out.height:%i out.widthStep:%i out.nChannels:%i", output->width, output->height, output->widthStep, output->nChannels); #if ANDROID_USE_GLES_WARP if (dmz_use_gles_warp()) { llcv_gles_warp_perspective(dmz->mz, input, source_points, output); } #endif if (!dmz_use_gles_warp()) { /* if dmz_use_gles_warp() has changed from above, then we've encountered an error and are falling back to the old way.*/ // Old-fashioned openCV float matrix[16]; dmz_point dest_points[4]; dmz_rect_get_points(to_rect, dest_points); // Calculate row-major matrix llcv_calc_persp_transform(matrix, 9, true, source_points, dest_points); CvMat *cv_persp_mat = cvCreateMat(3, 3, CV_32FC1); for (int r = 0; r < 3; r++) { for (int c = 0; c < 3; c++) { CV_MAT_ELEM(*cv_persp_mat, float, r, c) = matrix[3 * r + c]; } } cvWarpPerspective(input, output, cv_persp_mat, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); cvReleaseMat(&cv_persp_mat); }
void margDisplay::feedImg(unsigned char* pixels, int _w, int _h, bool bIsColor) { if (_w != image.getWidth()) { if(image.getWidth() != 0)image.clear(); image.allocate(_w, _h); } if (source.getWidth() != _w) { if(source.getWidth() != 0) source.clear(); source.allocate(_w, _h); } if (bIsColor) { source.setFromPixels(pixels, _w, _h); } else { if (gSource.getWidth() != _w) { if(gSource.getWidth() != 0) gSource.clear(); gSource.allocate(_w, _h); } gSource.setFromPixels(pixels, _w, _h); source = gSource; } cvWarpPerspective(source.getCvImage(), image.getCvImage(), translate); image.flagImageChanged(); }
void opencv_birds_eye_remap(ProbabilisticMapParams map, const IplImage *src_image, IplImage *dst_image, double camera_height, double camera_pitch, stereo_util stereo_util_instance) { // coordinates of 4 quadrangle vertices in the source image. CvPoint2D32f src_pts[4] = { cvPoint2D32f(180, 400), cvPoint2D32f(180, 320), cvPoint2D32f(520, 320), cvPoint2D32f(520, 400) }; // coordinates of the 4 corresponding quadrangle vertices in the destination image. CvPoint2D32f dst_pts[4]; for (int i = 0; i < 4; i++) { carmen_position_t right_point; right_point.x = src_pts[i].x; right_point.y = src_pts[i].y; carmen_vector_3D_t p3D = camera_to_world(right_point, camera_height, camera_pitch, stereo_util_instance); int x_map = map_grid_x(map, p3D.x); int y_map = map_grid_y(map, p3D.y); dst_pts[i] = cvPoint2D32f(x_map, y_map); } // FIND THE HOMOGRAPHY static CvMat *homography_matrix; if (homography_matrix == NULL) homography_matrix = cvCreateMat(3, 3, CV_32F); cvGetPerspectiveTransform(dst_pts, src_pts, homography_matrix); float Z = camera_height; CV_MAT_ELEM(*homography_matrix, float, 2, 2) = Z; cvWarpPerspective(src_image, dst_image, homography_matrix, CV_INTER_LINEAR | CV_WARP_INVERSE_MAP | CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); }
IplImage* cutSign(IplImage* origImg, CvPoint* corners, int numcorners, bool drawcircles) { // convert corners to CvPoint2D32f. CvPoint2D32f cornersf[numcorners]; for (int i=0; i<numcorners; ++i) cornersf[i] = cvPointTo32f(corners[i]); if (_debug) printf("Corners: %d,%d %d,%d %d,%d %d,%d\n",corners[0].x,corners[0].y,corners[1].x,corners[1].y,corners[2].x,corners[2].y,corners[3].x,corners[3].y); // Create target-image with right size. double xDiffBottom = pointDist(corners[0], corners[1]); double yDiffLeft = pointDist(corners[0], corners[3]); IplImage* cut = cvCreateImage(cvSize(xDiffBottom,yDiffLeft), IPL_DEPTH_8U, 3); // target points for perspective correction. CvPoint2D32f cornerstarget[numcorners]; cornerstarget[0] = cvPoint2D32f(0,0); cornerstarget[1] = cvPoint2D32f(cut->width-1,0); cornerstarget[2]= cvPoint2D32f(cut->width-1,cut->height-1); cornerstarget[3] = cvPoint2D32f(0,cut->height-1); if (_debug) printf("Corners: %f,%f %f,%f %f,%f %f,%f\n",cornerstarget[0].x,cornerstarget[0].y,cornerstarget[1].x,cornerstarget[1].y,cornerstarget[2].x,cornerstarget[2].y,cornerstarget[3].x,cornerstarget[3].y); // Apply perspective correction to the image. CvMat* transmat = cvCreateMat(3, 3, CV_32FC1); // Colums, rows ? transmat = cvGetPerspectiveTransform(cornersf,cornerstarget,transmat); cvWarpPerspective(origImg,cut,transmat); cvReleaseMat(&transmat); // Draw yellow circles around the corners. if (drawcircles) for (int i=0; i<numcorners; ++i) cvCircle(origImg, corners[i],5,CV_RGB(255,255,0),2); return cut; }
//全景拼接 void SiftMatch::on_mosaicButton_clicked() { //若能成功计算出变换矩阵,即两幅图中有共同区域,才可以进行全景拼接 if(H) { //拼接图像,img1是左图,img2是右图 CalcFourCorner();//计算图2的四个角经变换后的坐标 //为拼接结果图xformed分配空间,高度为图1图2高度的较小者,根据图2右上角和右下角变换后的点的位置决定拼接图的宽度 xformed = cvCreateImage(cvSize(MIN(rightTop.x,rightBottom.x),MIN(img1->height,img2->height)),IPL_DEPTH_8U,3); //用变换矩阵H对右图img2做投影变换(变换后会有坐标右移),结果放到xformed中 cvWarpPerspective(img2,xformed,H,CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS,cvScalarAll(0)); //cvNamedWindow(IMG_MOSAIC_TEMP); //显示临时图,即只将图2变换后的图 //cvShowImage(IMG_MOSAIC_TEMP,xformed); //简易拼接法:直接将将左图img1叠加到xformed的左边 xformed_simple = cvCloneImage(xformed);//简易拼接图,可笼子xformed cvSetImageROI(xformed_simple,cvRect(0,0,img1->width,img1->height)); cvAddWeighted(img1,1,xformed_simple,0,0,xformed_simple); cvResetImageROI(xformed_simple); //cvNamedWindow(IMG_MOSAIC_SIMPLE);//创建窗口 //cvShowImage(IMG_MOSAIC_SIMPLE,xformed_simple);//显示简易拼接图 //处理后的拼接图,克隆自xformed xformed_proc = cvCloneImage(xformed); //重叠区域左边的部分完全取自图1 cvSetImageROI(img1,cvRect(0,0,MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvSetImageROI(xformed,cvRect(0,0,MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvSetImageROI(xformed_proc,cvRect(0,0,MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvAddWeighted(img1,1,xformed,0,0,xformed_proc); cvResetImageROI(img1); cvResetImageROI(xformed); cvResetImageROI(xformed_proc); //cvNamedWindow(IMG_MOSAIC_BEFORE_FUSION); //cvShowImage(IMG_MOSAIC_BEFORE_FUSION,xformed_proc);//显示融合之前的拼接图 //采用加权平均的方法融合重叠区域 int start = MIN(leftTop.x,leftBottom.x) ;//开始位置,即重叠区域的左边界 double processWidth = img1->width - start;//重叠区域的宽度 double alpha = 1;//img1中像素的权重 for(int i=0; i<xformed_proc->height; i++)//遍历行 { const uchar * pixel_img1 = ((uchar *)(img1->imageData + img1->widthStep * i));//img1中第i行数据的指针 const uchar * pixel_xformed = ((uchar *)(xformed->imageData + xformed->widthStep * i));//xformed中第i行数据的指针 uchar * pixel_xformed_proc = ((uchar *)(xformed_proc->imageData + xformed_proc->widthStep * i));//xformed_proc中第i行数据的指针 for(int j=start; j<img1->width; j++)//遍历重叠区域的列 { //如果遇到图像xformed中无像素的黑点,则完全拷贝图1中的数据 if(pixel_xformed[j*3] < 50 && pixel_xformed[j*3+1] < 50 && pixel_xformed[j*3+2] < 50 ) { alpha = 1; } else { //img1中像素的权重,与当前处理点距重叠区域左边界的距离成正比 alpha = (processWidth-(j-start)) / processWidth ; } pixel_xformed_proc[j*3] = pixel_img1[j*3] * alpha + pixel_xformed[j*3] * (1-alpha);//B通道 pixel_xformed_proc[j*3+1] = pixel_img1[j*3+1] * alpha + pixel_xformed[j*3+1] * (1-alpha);//G通道 pixel_xformed_proc[j*3+2] = pixel_img1[j*3+2] * alpha + pixel_xformed[j*3+2] * (1-alpha);//R通道 } } cvNamedWindow(IMG_MOSAIC_PROC);//创建窗口 cvShowImage(IMG_MOSAIC_PROC,xformed_proc);//显示处理后的拼接图 //*重叠区域取两幅图像的平均值,效果不好 //设置ROI,是包含重叠区域的矩形 cvSetImageROI(xformed_proc,cvRect(MIN(leftTop.x,leftBottom.x),0,img1->width-MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvSetImageROI(img1,cvRect(MIN(leftTop.x,leftBottom.x),0,img1->width-MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvSetImageROI(xformed,cvRect(MIN(leftTop.x,leftBottom.x),0,img1->width-MIN(leftTop.x,leftBottom.x),xformed_proc->height)); cvAddWeighted(img1,0.5,xformed,0.5,0,xformed_proc); cvResetImageROI(xformed_proc); cvResetImageROI(img1); cvResetImageROI(xformed); //*/ /*对拼接缝周围区域进行滤波来消除拼接缝,效果不好 //在处理前后的图上分别设置横跨拼接缝的矩形ROI cvSetImageROI(xformed_proc,cvRect(img1->width-10,0,img1->width+10,xformed->height)); cvSetImageROI(xformed,cvRect(img1->width-10,0,img1->width+10,xformed->height)); cvSmooth(xformed,xformed_proc,CV_MEDIAN,5);//对拼接缝周围区域进行中值滤波 cvResetImageROI(xformed); cvResetImageROI(xformed_proc); cvShowImage(IMG_MOSAIC_PROC,xformed_proc);//显示处理后的拼接图 */ /*想通过锐化解决变换后的图像失真的问题,对于扭曲过大的图像,效果不好 double a[]={ 0, -1, 0, -1, 5, -1, 0, -1, 0 };//拉普拉斯滤波核的数据 CvMat kernel = cvMat(3,3,CV_64FC1,a);//拉普拉斯滤波核 cvFilter2D(xformed_proc,xformed_proc,&kernel);//滤波 cvShowImage(IMG_MOSAIC_PROC,xformed_proc);//显示处理后的拼接图*/ //保存拼接图 QString name_xformed = name1;//文件名,原文件名去掉序号后加"_Mosaic" cvSaveImage(name_xformed.replace( name_xformed.lastIndexOf(".",-1)-1 , 1 , "_Mosaic").toAscii().data() , xformed_simple);//保存简易拼接图 cvSaveImage(name_xformed.insert( name_xformed.lastIndexOf(".",-1) , "_Proc").toAscii().data() , xformed_proc);//保存处理后的拼接图 ui->mosaicButton->setEnabled(false);//禁用全景拼接按钮 } }
int main( int argc, char** argv ) { IplImage* img1, * img2, * stacked; struct feature* feat1, * feat2, * feat; struct feature** nbrs; struct kd_node* kd_root; CvPoint pt1, pt2; double d0, d1; int n1, n2, k, i, m = 0; if( argc != 3 ) fatal_error( "usage: %s <img1> <img2>", argv[0] ); img1 = cvLoadImage( argv[1], 1 ); if( ! img1 ) fatal_error( "unable to load image from %s", argv[1] ); img2 = cvLoadImage( argv[2], 1 ); if( ! img2 ) fatal_error( "unable to load image from %s", argv[2] ); stacked = stack_imgs( img1, img2 ); fprintf( stderr, "Finding features in %s...\n", argv[1] ); n1 = sift_features( img1, &feat1 ); fprintf( stderr, "Finding features in %s...\n", argv[2] ); n2 = sift_features( img2, &feat2 ); kd_root = kdtree_build( feat2, n2 ); for( i = 0; i < n1; i++ ) { feat = feat1 + i; k = kdtree_bbf_knn( kd_root, feat, 2, &nbrs, KDTREE_BBF_MAX_NN_CHKS ); if( k == 2 ) { d0 = descr_dist_sq( feat, nbrs[0] ); d1 = descr_dist_sq( feat, nbrs[1] ); if( d0 < d1 * NN_SQ_DIST_RATIO_THR ) { pt1 = cvPoint( cvRound( feat->x ), cvRound( feat->y ) ); pt2 = cvPoint( cvRound( nbrs[0]->x ), cvRound( nbrs[0]->y ) ); pt2.y += img1->height; cvLine( stacked, pt1, pt2, CV_RGB(255,0,255), 1, 8, 0 ); m++; feat1[i].fwd_match = nbrs[0]; } } free( nbrs ); } fprintf( stderr, "Found %d total matches\n", m ); display_big_img( stacked, "Matches" ); cvWaitKey( 0 ); /* UNCOMMENT BELOW TO SEE HOW RANSAC FUNCTION WORKS Note that this line above: feat1[i].fwd_match = nbrs[0]; is important for the RANSAC function to work. */ // /* // { CvMat* H; IplImage* xformed; H = ransac_xform( feat1, n1, FEATURE_FWD_MATCH, lsq_homog, 4, 0.01, homog_xfer_err, 3.0, NULL, NULL ); if( H ) { xformed = cvCreateImage( cvGetSize( img2 ), IPL_DEPTH_8U, 3 ); cvWarpPerspective( img1, xformed, H, CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS, cvScalarAll( 0 ) ); cvNamedWindow( "Xformed", 1 ); cvShowImage( "Xformed", xformed ); cvWaitKey( 0 ); cvReleaseImage( &xformed ); cvReleaseMat( &H ); } // } //*/ cvReleaseImage( &stacked ); cvReleaseImage( &img1 ); cvReleaseImage( &img2 ); kdtree_release( kd_root ); free( feat1 ); free( feat2 ); return 0; }
void bird_eye() { int board_n = board_w * board_h; CvSize board_sz = cvSize(board_w, board_h); CvMat *intrinsic = (CvMat*) cvLoad("Intrinsics.xml"); CvMat *distortion = (CvMat*) cvLoad("Distortion.xml"); IplImage* image = cvLoadImage("./Resource/bird-eye.jpg", 1); IplImage* gray_image = cvCreateImage(cvGetSize(image), 8, 1); cvCvtColor(image, gray_image, CV_BGR2GRAY); IplImage* mapx = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1); IplImage* mapy = cvCreateImage(cvGetSize(image), IPL_DEPTH_32F, 1); cvInitUndistortMap( intrinsic, distortion, mapx, mapy ); IplImage* t = cvCloneImage(image); cvRemap(t, image, mapx, mapy); cvNamedWindow("Chessboard"); cvShowImage("Chessboard", image); int c = cvWaitKey(-1); CvPoint2D32f* corners = new CvPoint2D32f[board_n]; int corner_count = 0; int found = cvFindChessboardCorners( image, board_sz, corners, &corner_count, CV_CALIB_CB_ADAPTIVE_THRESH | CV_CALIB_CB_FILTER_QUADS ); if(!found){ printf("couldn't aquire chessboard!\n"); return; } cvFindCornerSubPix( gray_image, corners, corner_count, cvSize(11, 11), cvSize(-1, -1), cvTermCriteria(CV_TERMCRIT_EPS | CV_TERMCRIT_ITER, 30, 0.1) ); CvPoint2D32f objPts[4], imgPts[4]; objPts[0].x = 0; objPts[0].y = 0; objPts[1].x = board_w - 1; objPts[1].y = 0; objPts[2].x = 0; objPts[2].y = board_h - 1; objPts[3].x = board_w - 1; objPts[3].y = board_h - 1; imgPts[0] = corners[0]; imgPts[1] = corners[board_w - 1]; imgPts[2] = corners[(board_h - 1) * board_w]; imgPts[3] = corners[(board_h - 1) * board_w + board_w - 1]; cvCircle(image, cvPointFrom32f(imgPts[0]), 9, CV_RGB(0, 0, 255), 3); cvCircle(image, cvPointFrom32f(imgPts[1]), 9, CV_RGB(0, 255, 0), 3); cvCircle(image, cvPointFrom32f(imgPts[2]), 9, CV_RGB(255, 0, 0), 3); cvCircle(image, cvPointFrom32f(imgPts[3]), 9, CV_RGB(255, 255, 0), 3); cvDrawChessboardCorners( image, board_sz, corners, corner_count, found ); cvShowImage("Chessboard", image); CvMat *H = cvCreateMat(3, 3, CV_32F); cvGetPerspectiveTransform(objPts, imgPts, H); float z = 25; int key = 0; IplImage * birds_image = cvCloneImage(image); cvNamedWindow("Birds_Eye"); while(key != 27) { CV_MAT_ELEM(*H, float, 2, 2) = z; cvWarpPerspective( image, birds_image, H, CV_INTER_LINEAR| CV_WARP_INVERSE_MAP | CV_WARP_FILL_OUTLIERS ); cvShowImage("Birds_Eye", birds_image); key = cvWaitKey(); if(key == 'u') z += 0.5; if(key == 'd') z -= 0.5; } cvSave("H.xml", H); }
void margModule::update() { // -- blobFind.feedPixels(originalPix); blobFind.findContours(); blobs = blobFind.getFoundBlobs(); blobCorr.feedBlobs(blobs); blobs = blobCorr.getCorrectBlobs(); blobInterp.feedBlobs(blobs); blobs = blobInterp.getInterpolatedBlobs(); if(mode == TRAIL_MAP || mode == FINAL_IMAGE || bExhibitionMode) trailMaker.updtMap(blobs); vidPlayer.idleMovie(); if (vidPlayer.isFrameNew()) { if (mode == FINAL_IMAGE || bExhibitionMode) vidBlender.blendVideo(trailMaker.getMap(), vidPlayer.getPixels()); } // -- if (bExhibitionMode) { display.feedImg(vidBlender.getPixels(), dispWidth, dispHeight); } else { switch (mode) { case SOURCE: display.feedImg(vidCapt.getPixels(), camWidth, camHeight, false); break; case LENSCORRECTED_SOURCE: if (correctDisp.getWidth() == 0) correctDisp.allocate(camWidth, camHeight); correctDisp.setFromPixels(vidCapt.getPixels(), camWidth, camHeight); correctDisp.undistort(correctRdX, correctRdY, correctTgX, correctTgY, correctFX, correctFY, correctCX, correctCY); display.feedImg(correctDisp.getPixels(), camWidth, camHeight, false); break; case WARPED_SOURCE: if (correctDisp.getWidth() == 0) correctDisp.allocate(camWidth, camHeight); tempSource.allocate(camWidth, camHeight); tempSource.setFromPixels(vidCapt.getPixels(), camWidth, camHeight); tempSource.undistort(correctRdX, correctRdY, correctTgX, correctTgY, correctFX, correctFY, correctCX, correctCY); cvWarpPerspective(tempSource.getCvImage(), correctDisp.getCvImage(), blobCorr.getPerspMat()); tempSource.clear(); display.feedImg(correctDisp.getPixels(), camWidth, camHeight, false); break; case THRESHOLD_SOURCE: display.feedImg(blobFind.getInputImg().getPixels(), camWidth, camHeight, false); break; case TRAIL_MAP: display.feedImg(trailMaker.getMap(), dispWidth, dispHeight, false); break; case FINAL_IMAGE: display.feedImg(vidBlender.getPixels(), dispWidth, dispHeight); break; case BYPASS_VIDEO: display.feedImg(vidPlayer.getPixels(), dispWidth, dispHeight); break; default: display.feedImg(vidBlender.getPixels(), dispWidth, dispHeight); break; } } }
//추후 수정 void FkPaperKeyboard_TypeA::cornerVerification(IplImage* srcImage){ CvSize size = cvGetSize(srcImage); IplImage* eigImage = cvCreateImage(size, IPL_DEPTH_8U,1); IplImage* tempImage = cvCreateImage(size, IPL_DEPTH_8U, 1); IplImage* grayImage = cvCreateImage(size, IPL_DEPTH_8U, 1); IplImage* veriImage = cvCreateImage(size, IPL_DEPTH_8U, 1); IplImage* dstImage = cvCreateImage(size, IPL_DEPTH_8U, 1); IplImage* mask = cvCreateImage(size, IPL_DEPTH_8U, 1); IplImage* mask2 = cvCreateImage(size, IPL_DEPTH_8U, 1); CvRect rect = cvRect(10, 10, 640 - 20, 480 - 20); CvPoint2D32f srcQuad[4], dstQuad[4]; CvMat* warp_matrix = cvCreateMat(3,3, CV_32FC1); CvMat* warp_matrix_invert = cvCreateMat(3,3, CV_32FC1); CvMat* result = cvCreateMat(3, 1, CV_32FC1); CvMat* dst = cvCreateMat(3, 1,CV_32FC1); int keyButtonCornerCount = 316; cvCvtColor(srcImage, grayImage, CV_BGR2GRAY); cvSetImageROI(grayImage, rect); cvSetImageROI(mask, rect); cvSetImageROI(dstImage, rect); cvSetImageROI(mask2, rect); // 150~255사이의 값만 추출해서 마스크에 저장 cvInRangeS(grayImage, cvScalar(100, 100, 100), cvScalar(255, 255, 255), mask); cvCopy(mask, mask2); //cvShowImage("mask", mask); //cvShowImage("mask2", mask2); // 20,20? 150 미만의 값을 제외하기 위해 0인 값(mask)과 추출한 값(mask2)을 XOR 연산 한다. cvFloodFill(mask, cvPoint(10, 10), cvScalar(0, 0, 0)); cvXor(mask2, mask, dstImage); //cvShowImage("mask3", mask); //cvShowImage("mask4", mask2); //cvShowImage("dstImage", dstImage); // 최종 연산된 이미지에서 코너 추출(각 키패드의 코너) cvGoodFeaturesToTrack(dstImage, eigImage, tempImage, keyButtonCorner, &keyButtonCornerCount, 0.01, 7, NULL, 7, 0); cvFindCornerSubPix (dstImage, keyButtonCorner, keyButtonCornerCount,cvSize (3, 3), cvSize (-1, -1), cvTermCriteria (CV_TERMCRIT_ITER | CV_TERMCRIT_EPS, 20, 0.03)); cvResetImageROI(dstImage); for(int i =0 ; i < 316 ; i++){ keyButtonCorner[i].x += rect.x; keyButtonCorner[i].y += rect.y; } initKeyButtonCorner(); srcQuad[CLOCKWISE_1].x = keyButtonCorner[315].x+10; srcQuad[CLOCKWISE_1].y = keyButtonCorner[315].y-10; srcQuad[CLOCKWISE_5].x = keyButtonCorner[31].x + 10; srcQuad[CLOCKWISE_5].y = keyButtonCorner[31].y + 10; srcQuad[CLOCKWISE_7].x = keyButtonCorner[0].x - 10; srcQuad[CLOCKWISE_7].y = keyButtonCorner[0].y + 10; srcQuad[CLOCKWISE_11].x = keyButtonCorner[290].x - 10; srcQuad[CLOCKWISE_11].y = keyButtonCorner[290].y - 10; dstQuad[CLOCKWISE_1].x = 640; dstQuad[CLOCKWISE_1].y = 0; dstQuad[CLOCKWISE_5].x = 640; dstQuad[CLOCKWISE_5].y = 480; dstQuad[CLOCKWISE_7].x = 0; dstQuad[CLOCKWISE_7].y = 480; dstQuad[CLOCKWISE_11].x = 0; dstQuad[CLOCKWISE_11].y = 0; cvGetPerspectiveTransform(srcQuad, dstQuad, warp_matrix); cvWarpPerspective(dstImage, veriImage, warp_matrix); detectKeyButtonCorner(veriImage); cvInvert(warp_matrix, warp_matrix_invert); for(int i = 0 ; i < 316 ; i++){ cvmSet(dst, 0, 0, keyButtonCorner[i].x); cvmSet(dst, 1, 0, keyButtonCorner[i].y); cvmSet(dst, 2, 0, 1); cvMatMul(warp_matrix_invert, dst, result); float t = cvmGet(result, 2,0); keyButtonCorner[i].x = cvmGet(result, 0,0)/t ; keyButtonCorner[i].y = cvmGet(result, 1,0)/t ; } cvResetImageROI(srcImage); cvResetImageROI(mask); cvReleaseImage(&eigImage); cvReleaseImage(&tempImage); cvReleaseImage(&grayImage); cvReleaseImage(&veriImage); cvReleaseImage(&dstImage); cvReleaseImage(&mask); cvReleaseImage(&mask2); cvReleaseMat(&warp_matrix); cvReleaseMat(&warp_matrix_invert); cvReleaseMat(&result); cvReleaseMat(&dst); }
void FkPaperKeyboard_TypeA::setKeyButton(IplImage* srcImage){ //꼭지점 CvPoint2D32f srcQuad[4], dstQuad[4]; IplImage* perspectiveTransImage = cvCreateImage(cvSize(640,480), IPL_DEPTH_8U, 3); CvMat* warp_matrix = cvCreateMat(3,3, CV_32FC1); CvMat* warp_matrix_invert = cvCreateMat(3,3, CV_32FC1); CvMat* result = cvCreateMat(3, 1, CV_32FC1); CvMat* dst = cvCreateMat(3, 1,CV_32FC1); sortPaperKeyboardCorner(); srcQuad[CLOCKWISE_1] = keyboardCorner[1]; srcQuad[CLOCKWISE_5] = keyboardCorner[2]; srcQuad[CLOCKWISE_7] = keyboardCorner[3]; srcQuad[CLOCKWISE_11] = keyboardCorner[0]; dstQuad[CLOCKWISE_1].x = 640; dstQuad[CLOCKWISE_1].y = 0; dstQuad[CLOCKWISE_5].x = 640; dstQuad[CLOCKWISE_5].y = 480; dstQuad[CLOCKWISE_7].x = 0; dstQuad[CLOCKWISE_7].y = 480; dstQuad[CLOCKWISE_11].x = 0; dstQuad[CLOCKWISE_11].y = 0; // 원근변환 후 검사한다. cvGetPerspectiveTransform(srcQuad, dstQuad, warp_matrix); // 변환 값 계산 cvWarpPerspective(srcImage, perspectiveTransImage, warp_matrix); // 투영 변환 행렬을 구한다 cornerVerification(perspectiveTransImage); // 추출된 행렬의 유효성을 검사한다 cvInvert(warp_matrix, warp_matrix_invert); // //cvShowImage("srcImage",srcImage); //cvShowImage("perspectiveTransImage", perspectiveTransImage); for(int i = 0 ; i < 316 ; i++){ cvmSet(dst, 0, 0, keyButtonCorner[i].x); cvmSet(dst, 1, 0, keyButtonCorner[i].y); cvmSet(dst, 2, 0, 1); cvMatMul(warp_matrix_invert, dst, result); float t = cvmGet(result, 2,0); keyButtonCorner[i].x = cvmGet(result, 0,0)/t; keyButtonCorner[i].y = cvmGet(result, 1,0)/t; } setKeyButtonArea(keyButtonCorner, 0, 16); setKeyButtonArea(keyButtonCorner, 64, 14); setKeyButtonArea(keyButtonCorner, 120, 14); setKeyButtonArea(keyButtonCorner, 176, 13); setKeyButtonArea(keyButtonCorner, 228, 12); setKeyButtonArea(keyButtonCorner, 276, 7); setDirectionKeyButtonArea(keyButtonCorner, 306, 2, 77); setDirectionKeyButtonArea(keyButtonCorner, 304, 4, 76); setDirectionKeyButtonArea(keyButtonCorner, 308, 3, 78); cvReleaseImage(&perspectiveTransImage); cvReleaseMat(&warp_matrix); cvReleaseMat(&warp_matrix_invert); cvReleaseMat(&result); cvReleaseMat(&dst); }
void the_project::project_getting() { cout << "Ready to go?\n"; cin.get(); get_in = cvCreateImage(image_size, IPL_DEPTH_8U, 3); if(v_c_flag==0){ // get a image of path ///* IplImage *new_one; cout << "调整照相机位置并获取图像,Sapce to continue:\n"; cvNamedWindow("Adjust"); while(1){ if(cvWaitKey(10)==' '){ cvCopyImage(new_one,get_in); cvDestroyWindow("Adjust"); cvReleaseCapture(&for_cam); break; } new_one = cvQueryFrame(for_cam); cvShowImage("Adjust",new_one); } cvSaveImage("image_origin.jpg",get_in); //*/ } else if(v_c_flag==1){ //for_test get_in = cvQueryFrame(for_video); } cvNamedWindow("win1"); cvShowImage("win1",get_in); // transform get_change = cvCreateImage(image_size, IPL_DEPTH_8U, 3); transmat = cvCreateMat(3, 3, CV_32FC1); vector<CvPoint2D32f> points; void * p_pointer = reinterpret_cast<void *>(&points); cout << "choose four points for transform.\n"; cvSetMouseCallback("win1", mouse,p_pointer); cvWaitKey(); cvDestroyWindow("win1"); for(int i=0;i<4;i++) originpoints[i] = points[i]; cvGetPerspectiveTransform(originpoints, newpoints, transmat); cvWarpPerspective(get_in, get_change, transmat); cvNamedWindow("win1"); cvShowImage("win1",get_in); cvNamedWindow("win2"); cvShowImage("win2",get_change); cvSaveImage("image_square.jpg",get_change); get_unchange = cvCreateImage(image_size, IPL_DEPTH_8U, 3); get_looking = cvCreateImage(image_size, IPL_DEPTH_8U, 3); cvCopyImage(get_change,get_unchange); cout << "Press any key to continue...\n"; cvWaitKey(); }
void deblur_image(int image_num, int n, IplImage *result, IplImage *result_luck) { cvSetZero(result); cvSetZero(result_luck); IplImage *trans[MAX_IMAGE];//转换后的结果? IplImage *trans_luck[MAX_IMAGE]; IplImage *blur[MAX_IMAGE]; for (int i = 0; i < image_num; ++i) { trans[i] = cvCreateImage(image_size, IPL_DEPTH_8U, 3); cvWarpPerspective(images[i], trans[i], hom[i][n], CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); //对图像进行透视变换得到trans后的图像 trans_luck[i] = cvCreateImage(image_size, IPL_DEPTH_32F, 4); cvWarpPerspective(images_luck[i], trans_luck[i], hom[i][n], CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS, cvScalarAll(0)); //images_luck 是每一帧各个点的luckiness指数 blur[i] = cvCreateImage(image_size, IPL_DEPTH_8U, 3); blur_function(trans[i], blur[i], hom[n-1][n], hom[n][n+1]); } for (int i = 0; i < image_num; ++i) { char wname[16]; sprintf(wname, "Homography%d", i); cvNamedWindow(wname, CV_WINDOW_AUTOSIZE); cvMoveWindow(wname, i*50, i*50); cvShowImage(wname, trans[i]); sprintf(wname, "Blurred%d", i); cvNamedWindow(wname, CV_WINDOW_AUTOSIZE); cvMoveWindow(wname, i*50+100, i*50); cvShowImage(wname, blur[i]); } cvWaitKey(0); cvDestroyAllWindows(); int grid_r = (image_size.height-PATCH_SIZE/2-1) / (PATCH_SIZE/2); int grid_c = (image_size.width-PATCH_SIZE/2-1) / (PATCH_SIZE/2); if (grid_r > 0 && grid_c > 0) { CvMat *patch = cvCreateMat(grid_r, grid_c, CV_64FC4); for (int i = 0; i < grid_r; ++i) { int y = (i+1)*(PATCH_SIZE/2); int t1 = clock(); for (int j = 0; j < grid_c; ++j) { CvScalar res; int x = (j+1)*(PATCH_SIZE/2); if (deblur_patch(blur, trans_luck, image_num, n, x, y, &res) != 0) { printf("deblur_patch: %d:%d,%d failed.\n", n, x, y); res.val[0] = n; res.val[1] = x; res.val[2] = y; res.val[3] = 0; //copy_pixel(result, x, y, images[n], x, y); } /* res.val[0] = 2; res.val[1] = x; res.val[2] = y; res.val[3] = 100000;*/ res.val[3] = exp(-res.val[3]/(2*SIGMA_W*SIGMA_W)); CV_MAT_ELEM(*patch, CvScalar, i, j) = res; } int t2 = clock(); printf("y:%d/%d %d ms\n", y, image_size.height, (t2-t1)*1000/CLOCKS_PER_SEC); } cvNamedWindow("origin", CV_WINDOW_AUTOSIZE); cvShowImage("origin", images[n]); cvNamedWindow("result", CV_WINDOW_AUTOSIZE); // 中心部分 for (int i = 1; i < grid_r; ++i) { int miny = i*(PATCH_SIZE/2); for (int j = 1; j < grid_c; ++j) { CvScalar pres1 = CV_MAT_ELEM(*patch, CvScalar, i-1, j-1); CvScalar pres2 = CV_MAT_ELEM(*patch, CvScalar, i-1, j); CvScalar pres3 = CV_MAT_ELEM(*patch, CvScalar, i, j-1); CvScalar pres4 = CV_MAT_ELEM(*patch, CvScalar, i, j); int minx = j*(PATCH_SIZE/2); for (int y = 0; y < PATCH_SIZE/2; ++y) for (int x = 0; x < PATCH_SIZE/2; ++x) { CvScalar v[4]; v[0] = cvGet2D(trans[(int)pres1.val[0]], (int)pres1.val[2]+y, (int)pres1.val[1]+x); v[1] = cvGet2D(trans[(int)pres2.val[0]], (int)pres2.val[2]+y, (int)pres2.val[1]+x-PATCH_SIZE/2); v[2] = cvGet2D(trans[(int)pres3.val[0]], (int)pres3.val[2]+y-PATCH_SIZE/2, (int)pres3.val[1]+x); v[3] = cvGet2D(trans[(int)pres4.val[0]], (int)pres4.val[2]+y-PATCH_SIZE/2, (int)pres4.val[1]+x-PATCH_SIZE/2); double w[4] = {pres1.val[3], pres2.val[3], pres3.val[3], pres4.val[3]}; CvScalar pv = weighted_average(v, w, 4); cvSet2D(result, y+miny, x+minx, pv); /* printf("p %d %d\n", y+miny, x+minx); for (int a = 0; a < 4; ++a) { printf("v%d: %f %f %f w %g\n", a, v[a].val[0], v[a].val[1], v[a].val[2], w[a]); } printf("pv: %f %f %f\n", pv.val[0], pv.val[1], pv.val[2]); */ } } cvShowImage("result", result); cvWaitKey(20); } // 四周特殊情况 for (int y = 0; y < PATCH_SIZE/2; ++y) for (int x = 0; x < PATCH_SIZE/2; ++x) { CvScalar pres = CV_MAT_ELEM(*patch, CvScalar, 0, 0); CvScalar pv = cvGet2D(trans[(int)pres.val[0]], (int)pres.val[2]+y-PATCH_SIZE/2, (int)pres.val[1]+x-PATCH_SIZE/2); cvSet2D(result, y, x, pv); pres = CV_MAT_ELEM(*patch, CvScalar, 0, grid_c-1); pv = cvGet2D(trans[(int)pres.val[0]], (int)pres.val[2]+y-PATCH_SIZE/2, (int)pres.val[1]+x); cvSet2D(result, y, grid_c*(PATCH_SIZE/2)+x, pv); pres = CV_MAT_ELEM(*patch, CvScalar, grid_r-1, 0); pv = cvGet2D(trans[(int)pres.val[0]], (int)pres.val[2]+y, (int)pres.val[1]+x-PATCH_SIZE/2); cvSet2D(result, grid_r*(PATCH_SIZE/2)+y, x, pv); pres = CV_MAT_ELEM(*patch, CvScalar, grid_r-1, grid_c-1); pv = cvGet2D(trans[(int)pres.val[0]], (int)pres.val[2]+y, (int)pres.val[1]+x); cvSet2D(result, grid_r*(PATCH_SIZE/2)+y, grid_c*(PATCH_SIZE/2)+x, pv); } for (int j = 1; j < grid_c; ++j) { CvScalar pres1 = CV_MAT_ELEM(*patch, CvScalar, 0, j-1); CvScalar pres2 = CV_MAT_ELEM(*patch, CvScalar, 0, j); CvScalar pres3 = CV_MAT_ELEM(*patch, CvScalar, grid_r-1, j-1); CvScalar pres4 = CV_MAT_ELEM(*patch, CvScalar, grid_r-1, j); int minx = j*(PATCH_SIZE/2); for (int y = 0; y < PATCH_SIZE/2; ++y) for (int x = 0; x < PATCH_SIZE/2; ++x) { CvScalar v[2]; v[0] = cvGet2D(trans[(int)pres1.val[0]], (int)pres1.val[2]+y-PATCH_SIZE/2, (int)pres1.val[1]+x); v[1] = cvGet2D(trans[(int)pres2.val[0]], (int)pres2.val[2]+y-PATCH_SIZE/2, (int)pres2.val[1]+x-PATCH_SIZE/2); double w[2] = {pres1.val[3], pres2.val[3]}; CvScalar pv = weighted_average(v, w, 2); cvSet2D(result, y, minx+x, pv); v[0] = cvGet2D(trans[(int)pres3.val[0]], (int)pres3.val[2]+y, (int)pres3.val[1]+x); v[1] = cvGet2D(trans[(int)pres4.val[0]], (int)pres4.val[2]+y, (int)pres4.val[1]+x-PATCH_SIZE/2); w[0] = pres3.val[3]; w[0] = pres4.val[3]; pv = weighted_average(v, w, 2); cvSet2D(result, grid_r*(PATCH_SIZE/2)+y, minx+x, pv); } } for (int i = 1; i < grid_r; ++i) { CvScalar pres1 = CV_MAT_ELEM(*patch, CvScalar, i-1, 0); CvScalar pres2 = CV_MAT_ELEM(*patch, CvScalar, i, 0); CvScalar pres3 = CV_MAT_ELEM(*patch, CvScalar, i-1, grid_c-1); CvScalar pres4 = CV_MAT_ELEM(*patch, CvScalar, i, grid_c-1); int miny = i*(PATCH_SIZE/2); for (int y = 0; y < PATCH_SIZE/2; ++y) for (int x = 0; x < PATCH_SIZE/2; ++x) { CvScalar v[2]; v[0] = cvGet2D(trans[(int)pres1.val[0]], (int)pres1.val[2]+y, (int)pres1.val[1]+x-PATCH_SIZE/2); v[1] = cvGet2D(trans[(int)pres2.val[0]], (int)pres2.val[2]+y-PATCH_SIZE/2, (int)pres2.val[1]+x-PATCH_SIZE/2); double w[2] = {pres1.val[3], pres2.val[3]}; CvScalar pv = weighted_average(v, w, 2); cvSet2D(result, miny+y, x, pv); v[0] = cvGet2D(trans[(int)pres3.val[0]], (int)pres3.val[2]+y, (int)pres3.val[1]+x); v[1] = cvGet2D(trans[(int)pres4.val[0]], (int)pres4.val[2]+y-PATCH_SIZE/2, (int)pres4.val[1]+x); w[0] = pres3.val[3]; w[0] = pres4.val[3]; pv = weighted_average(v, w, 2); cvSet2D(result, miny+y, grid_c*(PATCH_SIZE/2)+x, pv); } } cvShowImage("result", result); /* IplImage *res_diff = cvCreateImage(image_size, IPL_DEPTH_8U, 3); cvAbsDiff(result, images[n], res_diff); cvNamedWindow("diff", CV_WINDOW_AUTOSIZE); cvShowImage("diff", res_diff);*/ char name[16]; sprintf(name, "result%d.png", n); cvSaveImage(name, result, NULL); sprintf(name, "origin%d.png", n); cvSaveImage(name, images[n], NULL); cvReleaseMat(&patch); } for (int i = 0; i < image_num; ++i) { cvReleaseImage(&trans[i]); cvReleaseImage(&trans_luck[i]); cvReleaseImage(&blur[i]); } }