void CHandDrawEffect::EffectImage(IplImage* back, IplImage* frame, IplImage* alpha, IplImage* mask, IplImage* res) { if(drawMode & 0x01) { //基本エフェクト Posterize(0xD0, frame, imageA); // DrawHatching(frame, imageA); cvAnd(imageA, mask, imageB); //エフェクト処理後のCG部分のくりぬき //囲み cvNot(mask, imageA); cvDilate(imageA, imageD, 0, 1); cvDilate(mask, imageE, 0, 3); cvXor(imageE, imageD, mask); //アルファマスク更新 cvNot(mask, imageA); cvConvertScale(imageA, imageA, 0.5); cvOr(alpha, imageA, alpha); //色付きの囲み cvNot(mask, imageA); cvAnd(imageA, imageC, imageA); cvOr(imageA, imageB, imageB); //走査線 cvAnd(imageB, scanningLine, imageB); //アルファブレンド AlphaBlend(back, imageB, alpha, res); if(0) { //drawMode & 0x02) { // DrawEdge(frame, imageB, res, 2); cvNot(mask, frame); cvDilate(frame, imageA, 0, 1); cvDilate(mask, imageB, 0, 3); cvXor(imageA, imageB, mask); cvAnd(mask, res, res); //色付きの線 cvNot(mask, imageA); cvAnd(imageA, scanningLine, imageA); cvAnd(imageA, imageC, imageA); cvOr(res, imageA, res); } } else if(drawMode & 0x02) { // DrawEdge(frame, imageB, res, 2); } }
void THISCLASS::OnReloadConfiguration() { // Mask mode wxString mode = GetConfigurationString(wxT("Mode"), wxT("black-black")); if (mode == wxT("white-white")) { mMode = cMode_WhiteWhite; } else if (mode == wxT("white-black")) { mMode = cMode_WhiteBlack; cvNot(mMaskImage, mMaskImage); } else if (mode == wxT("black-white")) { mMode = cMode_BlackWhite; cvNot(mMaskImage, mMaskImage); } else { mMode = cMode_BlackBlack; } }
int main() { IplImage* image = 0; IplImage* reverse = 0; CvCapture* video = cvCaptureFromCAM(-1); cvNamedWindow("Original Video",0); cvNamedWindow("Reverse Video",0); while(1) { cvGrabFrame(video); image = cvRetrieveFrame(video); cvShowImage("Original Video",image); reverse = cvCreateImage(cvGetSize(image),image->depth,image->nChannels); cvNot(image,reverse); if(cvWaitKey(10) >=0) break; reverse->origin=image->origin; cvShowImage("Reverse Video",reverse); } cvReleaseImage(&reverse); cvReleaseCapture(&video); cvDestroyWindow("Reverse Video"); cvDestroyWindow("Original Video"); return 0; }
int main(int argc,char *argv[]) { IplImage* loadedImg; // where we'll store the current frame IplImage* invFrame; if(argc < 2) { printf("usage: %s image1 [image2] [image3] ...\n", argv[0]); return 0; } for(int i = 1; i < argc; i++) { loadedImg = cvLoadImage(argv[i]); // load image // check for errors: if(!loadedImg) continue; cvNot(loadedImg, loadedImg); //some funcions can do in-place modification char buffer[100]; sprintf(buffer, "modified-%s", argv[i]); //new filename cvSaveImage(buffer, loadedImg); //save the modified image cvReleaseImage(&loadedImg); //release it now that we're done } return 0; }
/* chain function * this function does the actual processing */ static GstFlowReturn gst_edgedetect_chain (GstPad * pad, GstBuffer * buf) { Gstedgedetect *filter; filter = GST_EDGEDETECT (GST_OBJECT_PARENT (pad)); filter->cvImage->imageData = (char *) GST_BUFFER_DATA (buf); cvCvtColor (filter->cvImage, filter->cvGray, CV_RGB2GRAY); cvSmooth (filter->cvGray, filter->cvEdge, CV_BLUR, 3, 3, 0, 0); cvNot (filter->cvGray, filter->cvEdge); cvCanny (filter->cvGray, filter->cvEdge, filter->threshold1, filter->threshold2, filter->aperture); cvZero (filter->cvCEdge); if (filter->mask) { cvCopy (filter->cvImage, filter->cvCEdge, filter->cvEdge); } else { cvCvtColor (filter->cvEdge, filter->cvCEdge, CV_GRAY2RGB); } gst_buffer_set_data (buf, filter->cvCEdge->imageData, filter->cvCEdge->imageSize); return gst_pad_push (filter->srcpad, buf); }
void thresholdCalculator::calculateAverages(ofxCvGrayscaleAdvanced & smallCurrentImg, ofxCvGrayscaleAdvanced & maskImg, ofRectangle & targetRect) { roi.x = targetRect.x / divisor; roi.y = targetRect.y / divisor; maskImg.setROI(roi); smallCurrentImg.setROI(roi); CvScalar tempPupilAvg = cvAvg(smallCurrentImg.getCvImage(), maskImg.getCvImage()); cvNot(maskImg.getCvImage(), notDiffImg.getCvImage()); pupilAvg = tempPupilAvg.val[0]; // get average of pupil black iteratively(get average twice) to remove the influence of glint cvThreshold(smallCurrentImg.getCvImage(), farFromAvg, pupilAvg + 30, 255, CV_THRESH_BINARY); // 30 is the distance from average. cvSub(maskImg.getCvImage(), farFromAvg, newMask); // make a mask to get rid of those far points. CvScalar newPupilAvg = cvAvg(smallCurrentImg.getCvImage(), newMask); // get new average value. // get average, min and max value of white area of an eye. CvScalar tempWhiteAvg = cvAvg(smallCurrentImg.getCvImage(), notDiffImg.getCvImage()); for (int i = 0; i < 6; i++) notDiffImg.erode(); // this might be very useful to reduce the influence of small noise & glint cvMinMaxLoc(smallCurrentImg.getCvImage(), &whiteMin, &whiteMax, &whiteLocMin, &whiteLocMax, notDiffImg.getCvImage()); maskImg.resetROI(); smallCurrentImg.resetROI(); pupilAvg = newPupilAvg.val[0]; // value is in the first element of CvScalar whiteAvg = tempWhiteAvg.val[0]; }
int main(int args,char *argv[]){ // 视频结构 CvCapture *capture = NULL; // 获得摄像头数据 // CV_CAP_ANY 自动 capture = cvCreateCameraCapture(CV_CAP_ANY); if (!capture) { exit(0); } cvNamedWindow("camera",CV_WINDOW_AUTOSIZE); // 图片结构 IplImage *image = NULL; while(image = cvQueryFrame(capture)){ // 反色处理 cvNot(image,image); // 现实图像 cvShowImage("camera",image); // 监听键盘输入,如果有输入则跳出while if( cvWaitKey(2) >= 0 ) break; } // 释放视频 cvReleaseCapture(&capture); return 0; }
/* chain function * this function does the actual processing */ static GstFlowReturn gst_edge_detect_chain (GstPad * pad, GstBuffer * buf) { GstEdgeDetect *filter; GstBuffer *outbuf; filter = GST_EDGE_DETECT (GST_OBJECT_PARENT (pad)); filter->cvImage->imageData = (char *) GST_BUFFER_DATA (buf); cvCvtColor (filter->cvImage, filter->cvGray, CV_RGB2GRAY); cvSmooth (filter->cvGray, filter->cvEdge, CV_BLUR, 3, 3, 0, 0); cvNot (filter->cvGray, filter->cvEdge); cvCanny (filter->cvGray, filter->cvEdge, filter->threshold1, filter->threshold2, filter->aperture); cvZero (filter->cvCEdge); if (filter->mask) { cvCopy (filter->cvImage, filter->cvCEdge, filter->cvEdge); } else { cvCvtColor (filter->cvEdge, filter->cvCEdge, CV_GRAY2RGB); } outbuf = gst_buffer_new_and_alloc (filter->cvCEdge->imageSize); gst_buffer_copy_metadata (outbuf, buf, GST_BUFFER_COPY_ALL); memcpy (GST_BUFFER_DATA (outbuf), filter->cvCEdge->imageData, GST_BUFFER_SIZE (outbuf)); gst_buffer_unref (buf); return gst_pad_push (filter->srcpad, outbuf); }
/** * Обновление выводимой информации. */ void EdgeDetector::update() { if (camera == NULL) return; cvWaitKey(33); cameraFrame = cvQueryFrame(camera); cvReleaseImage(&resultFrame); if (isGrayScaleEffect) { IplImage* tempFrame = cvCloneImage(cameraFrame); resultFrame = cvCreateImage(imageSize, cameraFrame->depth, CV_LOAD_IMAGE_GRAYSCALE); cvCvtColor(tempFrame, resultFrame, CV_BGR2GRAY); cvReleaseImage(&tempFrame); } else resultFrame = cvCloneImage(cameraFrame); if (!isOriginalEffect) { if (isStrokeEffect) { IplImage* tempFrame = cvCloneImage(resultFrame); tempFrame = edgeDetectOperator->applyOperator(tempFrame); cvSub(resultFrame, tempFrame, resultFrame); cvReleaseImage(&tempFrame); } else resultFrame = edgeDetectOperator->applyOperator(resultFrame); } if (isInverseEffect) { IplImage* tempFrame = cvCloneImage(resultFrame); cvNot(tempFrame, resultFrame); cvReleaseImage(&tempFrame); } cvShowImage(getWindowName(), resultFrame); }
void draw(int dummy) { //delaunay cvClearMemStorage(storage); subdiv=cvCreateSubdivDelaunay2D(rect,trianglestore); blur(origV, out); SWAP(in,out); thresh(in, out); findContours(out, storage, &contours); cvMerge(origH, origS, out, NULL, temp); cvCvtColor( temp, temp, CV_HSV2RGB ); every_contour(contours, temp); drawContour(temp, contours); SWAP(in,out); draw_subdiv(temp,subdiv, cvScalar(255,255,255,255)); if(k==0) { cvNot(in,out); //k=1; } else{} cvClearMemStorage(trianglestore); //findcorners(origH,out); //needs 32bit float image cvShowImage(OUT, temp); }
// Generates and returns the histogram of a GRAYSCALE image. IplImage* DrawHistogram(IplImage* img) { CvSize imgSize = cvGetSize(img); int area = imgSize.width*imgSize.height; // Holds the actual histogram image IplImage* ret = cvCreateImage(cvSize(257, 100), 8, 1); cvZero(ret); int freq[256] = {0}; int max=0; // Loop through each pixel of the image for(int x=0;x<imgSize.width;x++) { for(int y=0;y<imgSize.height;y++) { // Increment the frequency int curr = (int)cvGetReal2D(img, y, x); freq[curr]++; if(freq[curr]>max) max = freq[curr]; } } // Finally, draw the actual histogram for(int k=0;k<256;k++) { int value = ((float)(100*freq[k])/(float)max); cvLine(ret, cvPoint(k, 100), cvPoint(k, 100-value), cvScalar(255,255,255)); } cvNot(ret, ret); return ret; }
//形态学非约束击中-击不中变换 针对二值和灰度图像 void lhMorpHMTU(const IplImage* src, IplImage* dst, IplConvKernel* sefg, IplConvKernel* sebg =NULL) { assert(src != NULL && dst != NULL && src != dst && sefg!= NULL && sefg!=sebg); if (sebg == NULL) { sebg = lhStructuringElementNot(sefg); } IplImage* temp = cvCreateImage(cvGetSize(src), 8, 1); IplImage* mask = cvCreateImage(cvGetSize(src), 8, 1); cvZero(mask); //P106 (5.4) cvErode( src, temp, sefg); cvDilate(src, dst, sebg); cvCmp(temp, dst, mask, CV_CMP_GT); cvSub(temp, dst, dst, mask); cvNot(mask, mask); cvSet(dst, cvScalar(0), mask); //cvCopy(dst, mask); //cvSet(dst, cvScalar(255), mask); cvReleaseImage(&mask); cvReleaseImage(&temp); cvReleaseStructuringElement(&sebg); }
//形态学二值击中-击不中变换 void lhMorpHMTB(const IplImage* src, IplImage* dst, IplConvKernel* sefg, IplConvKernel* sebg =NULL) { assert(src != NULL && dst != NULL && src != dst && sefg!= NULL && sefg!=sebg); if (sebg == NULL) { sebg = lhStructuringElementNot(sefg); } IplImage* temp1 = cvCreateImage(cvGetSize(src), 8, 1); IplImage* temp2 = cvCreateImage(cvGetSize(src), 8, 1); //P104 (5.2) cvErode( src, temp1, sefg); cvNot(src, temp2); cvErode( temp2, temp2, sebg); cvAnd(temp1, temp2, dst); cvReleaseImage(&temp1); cvReleaseImage(&temp2); cvReleaseStructuringElement(&sebg); }
void COpenCVMFCView::OnImageInvert() { // TODO: Add your command handler code here cvNot(workImg,workImg); Invalidate(); }
//-------------------------------------------------------------------------------- void ofxCvImage::invert(){ if( !bAllocated ){ ofLog(OF_LOG_ERROR, "in invert, need to allocate image first"); return; } cvNot(cvImage, cvImage); flagImageChanged(); }
//-------------------------------------------------------------------------------- void ofxCvImage::invert(){ if( !bAllocated ){ ofLogError("ofxCvImage") << "invert(): image not allocated"; return; } cvNot(cvImage, cvImage); flagImageChanged(); }
static COMMAND_FUNC( do_ocv_not ) { OpenCV_Image *src, *dst; dst = PICK_OCVI("destination image"); src = PICK_OCVI("source image"); if( dst == NO_OPENCV_IMAGE || src == NO_OPENCV_IMAGE ) return; cvNot( src->ocv_image, dst->ocv_image ); }
bool optimizeDepthMap() { cvErode(uImage,uImage,0,2); //Smoothen the User Map as well cvDilate(uImage,uImage,0,2); CvScalar depthMean=cvAvg(dImage,uImage); //Get teh Average Depth Value of the User Pixels cvNot(uImage,uImage); //Invert the user pixels to paint the rest of the image with average user depth //viewImage(dImage); cvSet(dImage,depthMean,uImage); IplImage* tempImage=cvCreateImage(dSize,IPL_DEPTH_8U,1); cvConvertScale(dImage,tempImage,1.0/256); cvSmooth(tempImage,tempImage,CV_GAUSSIAN,7);//Perform Gaussian Smoothing, depth map is optimized. cvConvert(tempImage,dImage); cvScale(dImage,dImage,256); cvSet(dImage,cvScalar(0),uImage); //viewImage(dImage); //cvSmooth(dImage,dImage,CV_GAUSSIAN,gaussian_m,gaussian_n,gaussian_e);//Perform Gaussian Smoothing, depth map is optimized. cvNot(uImage,uImage); cvReleaseImage(&tempImage); return true; }
// The smooth filter really needs the blur size as a param void InvertFilter::kernel() { // derived class responsible for allocating storage for filtered image if( !destination ) { destination = cvCreateImage(cvSize(source->width,source->height), source->depth, source->nChannels); destination->origin = source->origin; // same vertical flip as source } cvNot(source, destination); }
unique_ptr<Mat[]> CaliHelper::GetCalibrationImages(int numImag) { char key = 'c'; int capturedImages = 0; //LightCrafter lcr; //Mat whiteImage(684,608, CV_8UC1, Scalar(255)); //lcr.ProjectImage(whiteImage); namedWindow( "Camera", CV_WINDOW_NORMAL ); PGCam pgcam; pgcam.Init(CAMERA_WIDTH,CAMERA_HEIGHT,CAMERA_OFFSET_X,CAMERA_OFFSET_Y); unique_ptr<Mat[]> caliImages(new Mat[numImag*2]); while(key!='q') { vector<IplImage*> image = pgcam.grabFrame(); char key = cvWaitKey(1); if(key == 'c') { if(capturedImages/2 == numImag) break; Mat(image[0]).copyTo(caliImages[capturedImages]); capturedImages+=1; Mat(image[1]).copyTo(caliImages[capturedImages]); capturedImages+=1; IplImage* view2=cvCloneImage(&(IplImage)Mat(image[0])); cvNot(view2,view2); imshow( "Camera", Mat(view2) ); cvReleaseImage(&view2); } else { cv::Mat im1, im2; cv::resize(Mat(image[0]), im1, cv::Size(800,400)); cv::resize(Mat(image[1]), im2, cv::Size(800,400)); //imshow( "Camera", image[0] ); imshow("left", im1); imshow("right", im2); cvReleaseImage(&image[0]); cvReleaseImage(&image[1]); } } cvDestroyWindow("Camera"); return caliImages; }
// define a trackbar callback void on_trackbar(int h) { cvSmooth( gray, edge, CV_BLUR, 3, 3, 0, 0 ); cvNot( gray, edge ); // Run the edge detector on grayscale cvCanny(gray, edge, (float)edge_thresh, (float)edge_thresh*3, 3); cvZero( cedge ); // copy edge points cvCopy( image, cedge, edge ); cvShowImage(wndname, cedge); }
/* We take ownership of mask here */ static void gst_motiondetect_load_mask (StbtMotionDetect * filter, char* mask) { char *oldMaskFilename = NULL; IplImage *oldMaskImage = NULL, *newMaskImage = NULL; if (mask) { newMaskImage = cvLoadImage (mask, CV_LOAD_IMAGE_GRAYSCALE); if (!newMaskImage) { /* Unfortunately OpenCV doesn't seem to provide any way of finding out why the image load failed, so we can't be more specific than FAILED: */ GST_ELEMENT_WARNING (filter, RESOURCE, FAILED, ("OpenCV failed to load mask image"), ("While attempting to load mask '%s'", mask)); GST_WARNING ("Couldn't load mask image: %s. error: %s", mask, g_strerror (errno)); g_free (mask); mask = NULL; } gst_motiondetect_check_mask_compability(filter); } GST_OBJECT_LOCK(filter); oldMaskFilename = filter->mask; filter->mask = mask; oldMaskImage = filter->cvMaskImage; filter->cvMaskImage = newMaskImage; if (filter->cvInvertedMaskImage) { cvReleaseImage (&filter->cvInvertedMaskImage); filter->cvInvertedMaskImage = NULL; } if (filter->cvMaskImage) { filter->cvInvertedMaskImage = cvCloneImage (filter->cvMaskImage); cvNot(filter->cvMaskImage, filter->cvInvertedMaskImage); } GST_OBJECT_UNLOCK(filter); cvReleaseImage (&oldMaskImage); g_free(oldMaskFilename); }
// i can pass image as constante, to make sure that no change int negative(IplImage* image) { IplImage *dest = cvCloneImage(image); cvNamedWindow("Original:", 1); cvShowImage("Original:", image); cvNot(image, dest); //Create a negative image from source image cvNamedWindow("Negative:", 1); cvShowImage("Negative:", dest); cvWaitKey(0); cvDestroyWindow("Original:"); cvReleaseImage(&image); cvDestroyWindow("Negative:"); cvReleaseImage(&dest); return 0; }
int main(){ //initialize IplImage *image, *reverse; //load camera image CvCapture *video = cvCaptureFromCAM(-1); //create window cvNamedWindow("Original Video",0); cvNamedWindow("Reverse Video",0); //show camera image while(1){ cvGrabFrame(video); image = cvRetrieveFrame(video); cvShowImage("Original Video", image); reverse = cvCreateImage(cvGetSize(image), image->depth, image->nChannels); //reverse cvNot(image, reverse); //wait key input if(cvWaitKey(10)>=0) break; reverse->origin = image->origin; cvShowImage("Reverse Video", reverse); } //release memory cvReleaseImage(&reverse); cvReleaseCapture(&video); cvDestroyWindow("Original Video"); cvDestroyWindow("Reverse Video"); return 0; }
IplImage* crearMascaraBinarizada(IplImage* img_effect){ IplImage *img_gray = cvCreateImage(cvSize(img_effect->width,img_effect->height),img_effect->depth,1); IplImage *img_binaria = cvCreateImage(cvSize(img_effect->width,img_effect->height),img_effect->depth,img_effect->nChannels); //cvShowImage("binarizacion",img_effect); //Convertir img_effect a gris cvCvtColor(img_effect,img_gray,CV_BGR2GRAY); //Binarizacion cvThreshold(img_gray,img_gray,230,255,CV_THRESH_BINARY); //cvShowImage("binarizacion",img_gray); //EL negativo cvNot(img_gray,img_gray); //cvShowImage("negativo",img_gray); //Dos veces cerradura (dos dilataciones +dos erosiones) //se realiza dos dilataciones cvDilate(img_gray,img_gray,NULL,2); //se realiza dos erosiones cvErode(img_gray,img_gray,NULL,2); //cvShowImage("cerradura",img_gray); //Una vez apertura(erosion+dilatacion) cvErode(img_gray,img_gray,NULL,1); cvDilate(img_gray,img_gray,NULL,1); //cvShowImage("apertura",img_gray); cvErode(img_gray,img_gray,NULL,2); //cvShowImage("erosion",img_gray); //Convertir la imagen binarizada en 3 canales cvCvtColor(img_gray,img_binaria,CV_GRAY2BGR); return img_binaria; }
/* chain function * this function does the actual processing */ static GstFlowReturn gst_edge_detect_chain (GstPad * pad, GstObject * parent, GstBuffer * buf) { GstEdgeDetect *filter; GstBuffer *outbuf; GstMapInfo in_info; GstMapInfo out_info; filter = GST_EDGE_DETECT (parent); buf = gst_buffer_make_writable (buf); gst_buffer_map (buf, &in_info, GST_MAP_WRITE); filter->cvImage->imageData = (char *) in_info.data; cvCvtColor (filter->cvImage, filter->cvGray, CV_RGB2GRAY); cvSmooth (filter->cvGray, filter->cvEdge, CV_BLUR, 3, 3, 0, 0); cvNot (filter->cvGray, filter->cvEdge); cvCanny (filter->cvGray, filter->cvEdge, filter->threshold1, filter->threshold2, filter->aperture); cvZero (filter->cvCEdge); if (filter->mask) { cvCopy (filter->cvImage, filter->cvCEdge, filter->cvEdge); } else { cvCvtColor (filter->cvEdge, filter->cvCEdge, CV_GRAY2RGB); } outbuf = gst_buffer_new_and_alloc (filter->cvCEdge->imageSize); gst_buffer_copy_into (outbuf, buf, GST_BUFFER_COPY_METADATA, 0, -1); gst_buffer_map (outbuf, &out_info, GST_MAP_WRITE); memcpy (out_info.data, filter->cvCEdge->imageData, gst_buffer_get_size (outbuf)); gst_buffer_unmap (buf, &in_info); gst_buffer_unmap (outbuf, &out_info); gst_buffer_unref (buf); return gst_pad_push (filter->srcpad, outbuf); }
void calc_and_publish_BWMask(const ros::Time time_stamp, const std::string frame_id) { robmod->updateRobotLinks(time_stamp); #ifdef USE_GLUT_RENDERING glutPostRedisplay(); glutMainLoopEvent(); #else displayFunc(); #endif // USE_GLUT_RENDERING cvCvtColor(ipl_maskBGRA, ipl_maskBW, CV_BGRA2GRAY); cvFlip(ipl_maskBW); if (inverted) cvNot(ipl_maskBW,ipl_maskBW); if(publish_mask){ sensor_msgs::ImagePtr img_msg = sensor_msgs::CvBridge::cvToImgMsg(ipl_maskBW); img_msg->header.frame_id = frame_id; img_msg->header.stamp = time_stamp; mask_publisher.publish(img_msg); } }
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; }
//Funcion recibe el frame y la imagen del efecto que le deseo añadir para su fusion. // Tambien se recibe el escalamiento para que se encuentre redimensionada el efecto sobre el frame-video, y ademàs los desplazamientos de la imagen efecto void fusionImagenes(IplImage* frame, IplImage* img_effect,CvRect* r, double escalamiento, double despX,double despY){ IplImage *cloneFrame,*imgObj,*imgObj2,*mascara,*mascara2,*resize_imgEffect,*resize_mascara; //Creo mi mascara IplImage* mascara_imgEffect = crearMascaraBinarizada(img_effect); //cvShowImage("MI MASCARA",mascara_imgEffect); //Se clona la Imagen que captura la camara cloneFrame = cvCloneImage(frame); //Incializo imagenes base de mi imagen efectos imgObj = cvCreateImage(cvSize(frame->width,frame->height),frame->depth,frame->nChannels);//imagen para pegar el img_effect imgObj2 = cvCreateImage(cvSize(frame->width,frame->height),frame->depth,frame->nChannels);//img_effect pero trasladada //Pinto mi imagen base de color blanco cvSet(imgObj, cvScalar(255,255,255,0),NULL); cvSet(imgObj2, cvScalar(255,255,255,0),NULL); //Incializo imagenes base de mi macara mascara = cvCreateImage(cvSize(frame->width,frame->height),frame->depth,frame->nChannels);//imagen para pegar la Mascara mascara2 = cvCreateImage(cvSize(frame->width,frame->height),frame->depth,frame->nChannels);//mascara pero trasladada //Pinto mi imagen base de color negro cvSet(mascara, cvScalar(0,0,0,0),NULL); cvSet(mascara2, cvScalar(0,0,0,0),NULL); //Se define el nuevo tamaño int nuevoWidth = (int)(escalamiento*img_effect->width*r->width);//tamaño horizontal nuevo para el img_effect, tiene que ser proporcional al de r, por eso lo multiplico int nuevoHeight = (int)(escalamiento*img_effect->height*r->height);//tamaño vertical nuevo para el img_effect.. //printf("\neffect(%d,%d)-> %d,%d",img_effect->width,img_effect->height,r->width,r->height); if(nuevoWidth > frame->width) nuevoWidth = frame->width; // valida que el nuevo tamaño horizontal del objeto no sobrepase el del frame if(nuevoHeight > frame->height) nuevoHeight = frame->height; // valida que el nuevo tamaño vertical del objeto no sobrepase el del frame //Se redimensiona la imagen effecto con los nuevos valores para el width-heigth resize_imgEffect = cvCreateImage(cvSize(nuevoWidth,nuevoHeight),img_effect->depth,img_effect->nChannels);//Imagen con el nuevo tamaño cvResize(img_effect,resize_imgEffect,1); resize_mascara = cvCreateImage(cvSize(nuevoWidth,nuevoHeight),mascara_imgEffect->depth,mascara_imgEffect->nChannels);//Mascara con el nuevo tamaño cvResize(mascara_imgEffect,resize_mascara,1);//crea la mascara con el nuevo tamaño cvShowImage("imgObj-antes",resize_imgEffect);cvShowImage("mascara-antes",resize_mascara); //ROI de la imagen effecto cvSetImageROI(imgObj, cvRect(0,0,resize_imgEffect->width,resize_imgEffect->height));//crea un roi en el origen con el tamaño de la imagen efecto cvCopy(resize_imgEffect,imgObj);//copia el objeto cvResetImageROI(imgObj);//quita el roi cvShowImage("copy",imgObj); //ROI de la mascara cvSetImageROI(mascara, cvRect(0,0,resize_mascara->width,resize_mascara->height)); cvCopy(resize_mascara,mascara); cvResetImageROI(mascara); cvShowImage("MASK-ROI",mascara); //Se define los deplazamientos int dx = r->x+despX;//La posicion x del rectangulo que detecta la cara+desplazamiento basado en el ancho del rectangulo int dy = r->y+despY; //printf("\ndespx= %d , despy= %d ----- %d,%d",dx,dy,despX,despY); //cvShowImage("imgObj-antes",imgObj);cvShowImage("mascara-antes",mascara); //Matriz de transformacion, solo tomamos en cuenta dx,dy para la traslacion CvMat *M = cvCreateMat( 2, 3, CV_32FC1); cvmSet(M,0,0,1); // asignamos valor 1 al elemento (0,0) cvmSet(M,0,1,0); // asignamos valor 0 al elemento (0,1) cvmSet(M,1,0,0); // asignamos valor 0 al elemento (1,0) cvmSet(M,1,1,1); // asignamos valor 1 al elemento (1,1) cvmSet(M,0,2,dx); // el cuarto número indica los píxeles que se recorren en el eje x cvmSet(M,1,2,dy); cvWarpAffine (imgObj, imgObj2, M, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(255));// aplicamos la transformación para obtener la imagen trasladada cvWarpAffine (mascara,mascara2, M, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS,cvScalarAll(0));//lo mismo pero para la mascara //cvShowImage("imgObj-despues",imgObj2);cvShowImage("mascara-despues",mascara2); cvShowImage("imgObj-despues",imgObj2);cvShowImage("mascara-despues",mascara2); cvAnd(imgObj2,mascara2,imgObj2,0);//Se recorta el objeto usando la mascara cvShowImage("AND imgObj2-mascara2",imgObj2); cvNot(mascara2,mascara2); //Se crea la mascara inversa cvShowImage("NOT mascara2",mascara2); cvShowImage("CLoNE FRAME",cloneFrame); cvAnd(cloneFrame,mascara2,cloneFrame,0); //Se usa la macara inversa para quitar la parte en donde ira el objeto cvShowImage("AND cloneFrame-mascara2",cloneFrame); cvOr(cloneFrame,imgObj2,frame,0); // Se unen las dos imagenes con OR //Libero memoria de cada una de las imagenes /* cvReleaseImage(&cloneFrame); cvReleaseImage(&imgObj); cvReleaseImage(&imgObj2); cvReleaseImage(&mascara_imgEffect); cvReleaseImage(&mascara); cvReleaseImage(&mascara2); cvReleaseImage(&resize_imgEffect); cvReleaseImage(&resize_mascara); */ }
//static method for handling mouse events void Image_OP::my_Mouse_Handler(int events, int x, int y, int flags, void* param) { IplImage *img_orig; // Operations are done on a cloned image // so original settings can be restored // if operations need to be repeated IplImage *img_clone; img_orig = (IplImage*) param; int x_ROI =0, y_ROI =0 , wi_ROI =0, he_ROI =0; switch(events) {//begin switch // event, when user presses left button case CV_EVENT_LBUTTONDOWN: { // saves mouse coordinates (x,y) in static (CvPoint) variable // (by typecasting with cvPoint) my_point = cvPoint(x, y); } break; // user moves the mouse case CV_EVENT_MOUSEMOVE: { // user moves mouse and presses left button if (flags == CV_EVENT_FLAG_LBUTTON ) { // makes a copy of original image // over which the mouse moves img_clone = cvCloneImage(img_orig); // draws green (see CV_RGB(0-255,0-255,0-255) rectangle // using point coordinates from // CV_EVENT_LBUTTONDOWN as origin (= upper left corner) // and coordinates of this event as bottom right corner cvRectangle(img_clone,my_point,cvPoint(x , y ), CV_RGB(0,255, 0),1, 8, 0); // shows image with rectangle drawn on it cvShowImage("choose area", img_clone); } } break; // user releases left button case CV_EVENT_LBUTTONUP: { img_clone = cvCloneImage(img_orig); // checks position of starting point // stored in CV_EVENT_LBUTTONWDOWN) // in relation to end point, in order // to avoid negative values if(my_point.x > x) { x_ROI = x; wi_ROI = my_point.x -x; } else { x_ROI = my_point.x; wi_ROI = x - my_point.x ; } if(my_point.y > y) { y_ROI = y; he_ROI = my_point.y -y; } else { y_ROI = my_point.y; he_ROI = y - my_point.y ; } //stores coordinates of Region of Interest // in static variable my_ROI.x = x_ROI; my_ROI.y = y_ROI; my_ROI.width = wi_ROI; my_ROI.height = he_ROI; // set region of interest; for cvNot operation below cvSetImageROI(img_clone,cvRect(x_ROI, y_ROI,wi_ROI, he_ROI)); // inverts color information of image (bitwise inversion of array) // makes selected area clearly visible cvNot(img_clone, img_clone); // resets region of interest cvResetImageROI(img_clone); cvShowImage("choose area", img_clone); } break; }//end switch }//end mousehandler