void ImageProcessorCV::CalculateGradientImageHSV(CByteImage *pInputImage, CByteImage *pOutputImage) { if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height || pInputImage->type != CByteImage::eRGB24 || pOutputImage->type != CByteImage::eGrayScale) return; IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage); IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage); // Determine Gradient Image by Irina Wchter // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1); IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1); cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL); // calculate gradients on S-channel //cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3); cvSobel(singleChannel1, diff, 1, 0, 3); cvConvertScaleAbs(diff, abs); cvSobel(singleChannel1, diff, 0, 1, 3); cvConvertScaleAbs(diff, pIplOutputImage); cvAdd(abs, pIplOutputImage, pIplOutputImage, 0); // threshold S-channel for creating a maskfor gradients of H-channel cvThreshold(singleChannel1, singleChannel1, 60, 255, CV_THRESH_BINARY); cvDilate(singleChannel1, singleChannel1); // calculate gradients on H-channel //cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3); cvSobel(singleChannel0, diff, 1, 0, 3); cvConvertScaleAbs(diff, abs); cvSobel(singleChannel0, diff, 0, 1, 3); cvConvertScaleAbs(diff, singleChannel0); cvAdd(abs, singleChannel0, singleChannel0, 0); // filter gradients of H-channel with mask cvAnd(singleChannel0, singleChannel1, singleChannel0); // combine to gradient images cvMax(pIplOutputImage, singleChannel0, pIplOutputImage); // free memory cvReleaseImage(&singleChannel0); cvReleaseImage(&singleChannel1); cvReleaseImage(&singleChannel2); cvReleaseImage(&diff); cvReleaseImage(&abs); cvReleaseImageHeader(&pIplInputImage); cvReleaseImageHeader(&pIplOutputImage); }
void onTrackbar(int) { if(!(aSize & 1)) aSize++; if(isColor) { dst = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 3); //create BGR layer and splitt IplImage *B = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); IplImage *G = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); IplImage *R = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); IplImage *B16s = cvCreateImage(cvGetSize(img), IPL_DEPTH_16S, 1); IplImage *G16s = cvCreateImage(cvGetSize(img), IPL_DEPTH_16S, 1); IplImage *R16s = cvCreateImage(cvGetSize(img), IPL_DEPTH_16S, 1); cvSplit(img, B, G, R, 0); //sobel cvSobel(B, B16s, isY, 1 - isY, aSize); cvSobel(G, G16s, isY, 1 - isY, aSize); cvSobel(R, R16s, isY, 1 - isY, aSize); cvConvertScaleAbs(B16s, B, 1, 0); cvConvertScaleAbs(G16s, G, 1, 0); cvConvertScaleAbs(R16s, R, 1, 0); cvMerge(B, G, R, 0, dst); cvReleaseImage(&B); cvReleaseImage(&G); cvReleaseImage(&R); cvReleaseImage(&B16s); cvReleaseImage(&G16s); cvReleaseImage(&R16s); }//end if else { dst = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); IplImage *gray = cvCreateImage(cvGetSize(img), img->depth, 1); IplImage *img16s = cvCreateImage(cvGetSize(img), IPL_DEPTH_16S, 1); cvCvtColor(img, gray, CV_BGR2GRAY); //sobel cvSobel(gray, img16s, isY, 1 - isY, aSize); cvConvertScaleAbs(img16s, dst, 1, 0); cvReleaseImage(&gray); cvReleaseImage(&img16s); }//end else cvShowImage(windowName, dst); }
void myShowSignedImage(char *window, IplImage *img){ IplImage *temp=NULL; temp = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1 ); cvConvertScaleAbs(img, temp, 1, 0); cvShowImage(window, temp); cvReleaseImage(&temp); }
int main (int argc, char **argv){ IplImage *src_img, *dst_img, *tmp_img; // 画像の読み込み(グレースケールで読み込み) if (argc != 2 || (src_img = cvLoadImage (argv[1], CV_LOAD_IMAGE_GRAYSCALE)) == 0){ fprintf(stderr,"Usage: $ %s img_file\n",argv[0]); return -1; } tmp_img = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_16S, 1); dst_img = cvCreateImage(cvGetSize(src_img), IPL_DEPTH_8U, 1); // Sobelフィルタによる微分画像の作成 cvSobel(src_img, tmp_img, 1, 0, 3); cvConvertScaleAbs(tmp_img, dst_img,1,0); // 画像の表示 cvNamedWindow(SRC, CV_WINDOW_AUTOSIZE); cvShowImage(SRC, src_img); cvNamedWindow(DST, CV_WINDOW_AUTOSIZE); cvShowImage(DST, dst_img); // ユーザ入力待ち cvWaitKey(0); // 後始末 cvDestroyWindow(SRC); cvDestroyWindow(DST); cvReleaseImage(&src_img); cvReleaseImage(&dst_img); cvReleaseImage(&tmp_img); return 0; }
int main (int argc, char **argv) { CvCapture *capture = 0; IplImage *frame = 0; double w = 320, h = 240; int c; // (1)コマンド引数によって指定された番号のカメラに対するキャプチャ構造体を作成する if (argc == 1 || (argc == 2 && strlen (argv[1]) == 1 && isdigit (argv[1][0]))) capture = cvCreateCameraCapture (argc == 2 ? argv[1][0] - '0' : 0); /* この設定は,利用するカメラに依存する */ // (2)キャプチャサイズを設定する. //cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_WIDTH, w); //cvSetCaptureProperty (capture, CV_CAP_PROP_FRAME_HEIGHT, h); cvNamedWindow ("Capture", CV_WINDOW_AUTOSIZE); // (3)カメラから画像をキャプチャする { IplImage *src_img_gray, *tmp_img_gray, *dst_img_gray; // (a) 画像処用の画像データを確保 frame = cvQueryFrame (capture); frame = cvQueryFrame (capture); frame = cvQueryFrame (capture); tmp_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_16S, 1); src_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 1); dst_img_gray = cvCreateImage(cvGetSize(frame), IPL_DEPTH_8U, 1); while (1) { frame = cvQueryFrame (capture); // (b)グレイ画像を作成 cvCvtColor(frame, src_img_gray, CV_BGR2GRAY); // (c)Edge処理 if ( 0 ) { cvCanny (src_img_gray, dst_img_gray, 50.0, 200.0, 3); }else{ cvLaplace (src_img_gray, tmp_img_gray, 5); cvConvertScaleAbs(tmp_img_gray, dst_img_gray, 1, 0); } // (d)結果を表示する cvShowImage ("Capture", dst_img_gray); c = cvWaitKey (10); if (c == '\x1b') break; } } cvReleaseCapture (&capture); cvDestroyWindow ("Capture"); return 0; }
// ÀÆÕÀ˹±ä»» int main( int argc, char** argv ) { IplImage* laplace = 0; IplImage* colorlaplace = 0; IplImage* planes[3] = { 0, 0, 0 }; CvCapture* capture = 0; if( argc == 1 || (argc == 2 && strlen(argv[1]) == 1 && isdigit(argv[1][0]))) capture = cvCaptureFromCAM( argc == 2 ? argv[1][0] - '0' : 0 ); else if( argc == 2 ) capture = cvCaptureFromAVI( argv[1] ); if( !capture ) { fprintf(stderr,"Could not initialize capturing...\n"); return -1; } cvNamedWindow( "Laplacian", 0 ); for(;;) { IplImage* frame = 0; int i; frame = cvQueryFrame( capture ); if( !frame ) break; if( !laplace ) { for( i = 0; i < 3; i++ ) planes[i] = cvCreateImage( cvSize(frame->width,frame->height), 8, 1 ); laplace = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_16S, 1 ); colorlaplace = cvCreateImage( cvSize(frame->width,frame->height), 8, 3 ); } cvCvtPixToPlane( frame, planes[0], planes[1], planes[2], 0 ); for( i = 0; i < 3; i++ ) { cvLaplace( planes[i], laplace, 3 ); cvConvertScaleAbs( laplace, planes[i], 1, 0 ); } cvCvtPlaneToPix( planes[0], planes[1], planes[2], 0, colorlaplace ); colorlaplace->origin = frame->origin; cvShowImage("Laplacian", colorlaplace ); if( cvWaitKey(10) >= 0 ) break; } cvReleaseCapture( &capture ); cvDestroyWindow("Laplacian"); return 0; }
void COpenCVMFCView::OnLaplace() { // TODO: Add your command handler code here IplImage* pImage; IplImage* pImgLaplace = NULL; IplImage* pImgPlanes[3] = {0,0,0}; int i; pImage = workImg; pImgLaplace = cvCreateImage(cvGetSize(pImage), IPL_DEPTH_16S,1); if (workImg->nChannels == 1) { cvLaplace(pImage,pImgLaplace,3); cvConvertScaleAbs(pImgLaplace,pImage, 1, 0 ); } else { for (i = 0; i < 3; i++) { pImgPlanes[i] = cvCreateImage(cvGetSize(pImage), IPL_DEPTH_8U,1); } cvCvtPixToPlane(pImage,pImgPlanes[0], pImgPlanes[1],pImgPlanes[2],0); for (i = 0; i < 3; i++) { cvLaplace(pImgPlanes[i],pImgLaplace,3); cvConvertScaleAbs(pImgLaplace,pImgPlanes[i], 1, 0 ); } cvCvtPlaneToPix(pImgPlanes[0],pImgPlanes[1], pImgPlanes[2],0,pImage); for (i = 0; i < 3; i++) { cvReleaseImage(&pImgPlanes[i]); } } cvReleaseImage(&pImgLaplace); Invalidate(); }
void COpenCVMFCView::OnSobel() { // TODO: Add your command handler code here IplImage* pImage; IplImage* pImgSobel = NULL; IplImage* pImgPlanes[3] = {0,0,0}; int i; pImage = workImg; pImgSobel = cvCreateImage(cvGetSize(pImage), IPL_DEPTH_16S,1); // Create Working Image if (workImg->nChannels == 1) { // Handle Single Channel cvSobel(pImage,pImgSobel,1,1,3); cvConvertScaleAbs(pImgSobel,pImage, 1, 0 ); } else { // Handle Triad Ones for (i = 0; i < 3; i++) { pImgPlanes[i] = cvCreateImage(cvGetSize(pImage), IPL_DEPTH_8U,1); // Create Sub Image } cvCvtPixToPlane(pImage,pImgPlanes[0], pImgPlanes[1],pImgPlanes[2],0); // Get Sub for (i = 0; i < 3; i++) { // Handle Sub Independently cvSobel(pImgPlanes[i],pImgSobel,1,1,3); cvConvertScaleAbs(pImgSobel,pImgPlanes[i], 1, 0 ); } cvCvtPlaneToPix(pImgPlanes[0],pImgPlanes[1], pImgPlanes[2],0,pImage); // Form Color Image From Sub Images for (i = 0; i < 3; i++) { cvReleaseImage(&pImgPlanes[i]); // Release Sub Image } } cvReleaseImage(&pImgSobel); // Release Working Image Invalidate(); }
void detectPupils(IplImage *img) { //cvShowImage("Eyes before", img); //setting up the grayscale image IplImage* gray = cvCreateImage( cvGetSize(img), 8, 1 ); IplImage* copy = cvCreateImage( cvGetSize(img), 8, 3 ); //IplImage* src = cvCreateImage(cvGetSize(img), 8, 1); //set up circle storage CvMemStorage* storage = cvCreateMemStorage(0); //prepair the grayscale image cvCvtColor( img, gray, CV_RGB2GRAY ); //cvCopy(img, copy); /*try close elipse start*/ ///cvThreshold(gray, gray, 30, 255, CV_THRESH_BINARY_INV); cvShowImage("Eyes before", gray); //IplConvKernel elipse = *cvCreateStructuringElementEx(3, 3, 0, 0, CV_SHAPE_ELLIPSE, 0); //cvMorphologyEx(gray, gray, copy, &elipse, CV_MOP_CLOSE, 2); /*try close elipse end */ //cvThreshold(gray, gray, 42, 255, CV_THRESH_BINARY_INV); //cvAdaptiveThreshold(gray, gray, 255); cvConvertScaleAbs(gray, gray, 4, -3); cvSmooth( gray, gray, CV_GAUSSIAN, 9, 9); // smooth it, otherwise a lot of false circles may be detected //cvCanny(gray, gray, 0, canny2, canny3); //cvThreshold(gray, gray, 200, 255, CV_THRESH_BINARY); //apply Hough CvSeq* circles = cvHoughCircles( gray, storage, CV_HOUGH_GRADIENT, dp, 10, param1, param2, 0, gray->height/3); //loop through circles for(int i = 0; i < circles->total; i++) { float* circle = (float*)cvGetSeqElem( circles, i ); cvCircle( img, cvPoint(cvRound(circle[0]),cvRound(circle[1])), cvRound(circle[2]), CV_RGB(0,255,0), 1, 8, 0 ); } cvShowImage("Eyes", gray); //std::cerr << "Circles: " << circles->total << std::endl; }
bool motion_free_frame(IplImage* current_frame, IplImage* previous_frame) { // TO-DO: Determine the percentage of the frames which have changed (by more than VARIATION_ALLOWED_IN_PIXEL_VALUES) // and return whether that percentage is less than ALLOWED_MOTION_FOR_MOTION_FREE_IMAGE. //return true; // Just to allow the system to compile while the code is missing. if(previous_frame == NULL) return true; IplImage *current_frame_grayscale = cvCreateImage( cvGetSize(current_frame) , IPL_DEPTH_8U , 1); IplImage *previous_frame_grayscale = cvCreateImage( cvGetSize(previous_frame) , IPL_DEPTH_8U , 1); cvCvtColor(current_frame, current_frame_grayscale, CV_BGR2GRAY); cvCvtColor(previous_frame, previous_frame_grayscale, CV_BGR2GRAY); IplImage *image = cvCreateImage( cvGetSize(current_frame_grayscale) ,IPL_DEPTH_8U , 1); IplImage *sub_image = cvCreateImage( cvGetSize(current_frame_grayscale) ,IPL_DEPTH_16S , 1); cvSub(current_frame_grayscale, previous_frame_grayscale, sub_image); cvConvertScaleAbs(sub_image, image); int width_step = image->widthStep; int pixel_step = image->widthStep/image->width; int count = 0; for(int row = 0; row<image->height;++row) { for(int col = 0; col < image->width;++col) { unsigned char* curr_point = GETPIXELPTRMACRO( image, col, row, width_step, pixel_step ); if( (*curr_point) > VARIATION_ALLOWED_IN_PIXEL_VALUES) { count ++ ; } } } float res = ((float)count * 100)/(image->height * image->width); if(res < ALLOWED_MOTION_FOR_MOTION_FREE_IMAGE) return true; else return false; }
inline void convert_scale_abs_( const ipl_image_wrapper& src , ipl_image_wrapper& dst , const double& scale = 1.0 , const double& shift = 0.0 ) { cvConvertScaleAbs( src.get() , dst.get() , scale , shift ); }
void compute_vertical_edge_image(IplImage* input_image, IplImage* output_image) { // TO-DO: Compute the partial first derivative edge image in order to locate the vertical edges in the passed image, // and then determine the non-maxima suppressed version of these edges (along each row as the rows can be treated // independently as we are only considering vertical edges). Output the non-maxima suppressed edge image. // Note: You may need to smooth the image first. IplImage * tmp = cvCreateImage( cvGetSize(input_image) , IPL_DEPTH_8U , 1); IplImage * first_derivative_img = cvCreateImage( cvGetSize(input_image) , IPL_DEPTH_16S , 1 ); IplImage * non_maxima_suppressed_img = cvCloneImage(tmp); cvZero(non_maxima_suppressed_img); cvCvtColor(input_image, tmp, CV_BGR2GRAY); cvSmooth(tmp, tmp,CV_GAUSSIAN, 3, 3); cvSobel(tmp, first_derivative_img, 1, 0, 3); cvConvertScaleAbs(first_derivative_img, tmp); cvThreshold(tmp, tmp, 220, 0, CV_THRESH_TOZERO); // non-maximum suppression int width_step = tmp->widthStep; int pixel_step = tmp->widthStep/tmp->width; for(int row = 0; row<tmp->height;++row) { for(int col = 1; col < tmp->width-1;++col) { unsigned char* curr_point = GETPIXELPTRMACRO(tmp, col, row, width_step, pixel_step); unsigned char* pre_point = GETPIXELPTRMACRO(tmp, col-1, row, width_step, pixel_step); unsigned char* post_point = GETPIXELPTRMACRO(tmp, col+1, row, width_step, pixel_step); unsigned char* non_maxima_suppressed_img_point = GETPIXELPTRMACRO(non_maxima_suppressed_img, col, row, width_step, pixel_step); if( (*curr_point) <= (*pre_point) || (*curr_point) < (*post_point) ) { (*non_maxima_suppressed_img_point) = 0; } else { (*non_maxima_suppressed_img_point) = *(curr_point); } } } cvThreshold(non_maxima_suppressed_img, non_maxima_suppressed_img, 200, 255, CV_THRESH_BINARY); cvCvtColor(non_maxima_suppressed_img, output_image, CV_GRAY2BGR); }
void ImageProcessorCV::Laplacian5x5(CByteImage *pInputImage, CByteImage *pOutputImage) { if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height || pInputImage->type != pOutputImage->type || pInputImage->type != CByteImage::eGrayScale) return; IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage); IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage); IplImage *pIplTempImage = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1); cvLaplace(pIplInputImage, pIplTempImage, 5); cvConvertScaleAbs(pIplTempImage, pIplOutputImage); cvReleaseImage(&pIplTempImage); cvReleaseImageHeader(&pIplInputImage); cvReleaseImageHeader(&pIplOutputImage); }
/* *The sobel filter is an approximation to a derivative, it can apply first or second order in both coordinates in an image *First, the sobel operator applies a gaussian filter, in order to smooth the image *Then it calculates the derivative, and umbralizes the image *@param input, the input image, could be grayscale or RGB *@param output, the output image must have at least 16 bit pixel representation, to avoid overflow *@param xOrder, the derivative order for the X axis *@param yOrder, the derivative order for the Y axis *@param apertureSize, size of the filter window, if the size is 3, the scharr filter is used, less sensitive to noise */ ImageImPro* OpenImProLib_OpenCvImpl::filterSobel(ImageImPro* ptrInput, int xOrder, int yOrder, int apertureSize){ IplImage* ptrCvInput = ptrInput->getOpenCvImage(); //buffer for sobel result needing more bits per pixel for the result, then, rescaling is necesary to get it back to 8 bits per pixel IplImage* ptrCvTemp = cvCreateImage(cvGetSize(ptrCvInput),IPL_DEPTH_32F,1); IplImage* ptrCvOutput = cvCreateImage(cvGetSize(ptrCvInput), IPL_DEPTH_8U, 1); if(ptrInput->getChannels() != 1){ IplImage* ptrCvInputGray = cvCreateImage(cvSize(ptrCvInput->width,ptrCvInput->height),IPL_DEPTH_8U,1); cvCvtColor(ptrCvInput,ptrCvInputGray, CV_RGB2GRAY); cvSobel(ptrCvInputGray,ptrCvTemp, xOrder, yOrder, apertureSize); cvReleaseImage(&ptrCvInputGray); } else{ cvSobel(ptrCvInput,ptrCvTemp, xOrder, yOrder, apertureSize); } cvConvertScaleAbs(ptrCvTemp, ptrCvOutput, 1, 0); ImageImPro* ptrOutput = new ImageImPro_OpenCvImpl(ptrCvOutput); cvReleaseImage(&ptrCvOutput); cvReleaseImage(&ptrCvInput); cvReleaseImage(&ptrCvTemp); return ptrOutput; }
int main( int argc, char** argv ) { if(argc != 2) { printf("Usage: ./image <image name>\n"); return 0; } // Show original image IplImage* img = cvLoadImage( argv[1], 0 ); cvNamedWindow( "Input", CV_WINDOW_AUTOSIZE ); cvShowImage( "Input", img ); printf("Input depth: %x\n", img->depth); // 8U // Run Sobel edge detection IplImage *res = cvCreateImage( cvGetSize(img), IPL_DEPTH_8U, 1 ); #ifdef USE_OPENCV // OpenCV implementation // Convert images to 16SC1 IplImage *out = cvCreateImage( cvGetSize(img), IPL_DEPTH_16S, 1 ); cvSobel( img, out, 1, 0 ); cvConvertScaleAbs(out, res); // need 8U again cvReleaseImage( &out ); #else // Own implementation of Sobel kernel int H = img->height, W = img->width, WS = img->widthStep; uint8_t *srcdata = (uint8_t *) img->imageData; uint8_t *dstdata = (uint8_t *) res->imageData; #define ind(i,j) ((i)*WS+(j)) // work on bulk of image for(int i = 1; i+1 < H; i++) { for(int j = 1; j+1 < W; j++) { // dx kernel // -1 0 1 // -2 0 2 // -1 0 1 int16_t value = - srcdata[ind(i-1,j-1)] + srcdata[ind(i-1,j+1)] - srcdata[ind(i,j-1)] * 2 + srcdata[ind(i,j+1)] * 2 - srcdata[ind(i+1,j-1)] + srcdata[ind(i+1,j+1)]; if(value < 0) value = 0; if(value > 255) value = 255; dstdata[ind(i,j)] = value; } } // work on left and right edges (not accurate) for(int i = 0; i < H; i++) { dstdata[ind(i,0)] = 0; dstdata[ind(i,W-1)] = 0; } // work on top and bottom edges (not accurate) for(int j = 0; j < W; j++) { dstdata[ind(0,j)] = 0; dstdata[ind(H-1,j)] = 0; } // debugging for(int j = 0; j < 10; j++) printf("%d ", dstdata[ind(1, j)]); printf("\n"); #undef ind #endif // Display cvNamedWindow( "Output", CV_WINDOW_AUTOSIZE ); cvShowImage( "Output", res ); // Cleanup cvWaitKey(0); cvReleaseImage( &img ); cvReleaseImage( &res ); cvDestroyWindow( "Input" ); cvDestroyWindow( "Output" ); return 0; }
/** * @brief Return an Image (gandalf image class) with a specific Type * @param Type The Type of gabor kernel, e.g. REAL, IMAG, MAG, PHASE * @return Pointer to image structure, or NULL on failure */ IplImage* CvGabor::get_image(int Type) { if(IsKernelCreate() == false) { perror("Error: the Gabor kernel has not been created in get_image()!\n"); return NULL; } else { IplImage* pImage; IplImage *newimage; newimage = cvCreateImage(cvSize(Width,Width), IPL_DEPTH_8U, 1 ); //printf("Width is %d.\n",(int)Width); //printf("Sigma is %f.\n", Sigma); //printf("F is %f.\n", F); //printf("Phi is %f.\n", Phi); //pImage = gan_image_alloc_gl_d(Width, Width); pImage = cvCreateImage( cvSize(Width,Width), IPL_DEPTH_32F, 1 ); CvMat* kernel = cvCreateMat(Width, Width, CV_32FC1); double ve; // CvScalar S; CvSize size = cvGetSize( kernel ); int rows = size.height; int cols = size.width; switch(Type) { case 1: //Real cvCopy( (CvMat*)Real, (CvMat*)kernel, NULL ); //pImage = cvGetImage( (CvMat*)kernel, pImageGL ); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { ve = cvGetReal2D((CvMat*)kernel, i, j); cvSetReal2D( (IplImage*)pImage, j, i, ve ); } } break; case 2: //Imag cvCopy( (CvMat*)Imag, (CvMat*)kernel, NULL ); //pImage = cvGetImage( (CvMat*)kernel, pImageGL ); for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { ve = cvGetReal2D((CvMat*)kernel, i, j); cvSetReal2D( (IplImage*)pImage, j, i, ve ); } } break; case 3: //Magnitude ///@todo printf("[CvGabor::get_image] Error: No magnitude available.\n"); break; case 4: //Phase ///@todo printf("[CvGabor::get_image] Error: No phase available.\n"); break; } cvNormalize((IplImage*)pImage, (IplImage*)pImage, 0, 255, CV_MINMAX, NULL ); cvConvertScaleAbs( (IplImage*)pImage, (IplImage*)newimage, 1, 0 ); cvReleaseMat(&kernel); cvReleaseImage(&pImage); return newimage; } }
int main(void) { IplImage *src=NULL; if (0){ src = cvCreateImageHeader(cvSize(4,4),IPL_DEPTH_8U,1); char rawdata[4][4] = { {0, 0, 1, 1}, {0, 0, 1, 1}, {0, 2, 2, 2}, {2, 2, 3, 3}}; src->imageData = (char*)(&rawdata); }else{ src = cvLoadImage("test.png",0); } CvGLCM* glcm; // glcm = cvCreateGLCM(src, 1, NULL, 4, CV_GLCM_OPTIMIZATION_LUT); glcm = cvCreateGLCM(src, 1, NULL, 4, CV_GLCM_OPTIMIZATION_NONE); cvCreateGLCMDescriptors(glcm, CV_GLCMDESC_OPTIMIZATION_ALLOWDOUBLENEST); //#define CV_GLCMDESC_ENTROPY 0 //#define CV_GLCMDESC_ENERGY 1 //#define CV_GLCMDESC_HOMOGENITY 2 //#define CV_GLCMDESC_CONTRAST 3 //#define CV_GLCMDESC_CLUSTERTENDENCY 4 //#define CV_GLCMDESC_CLUSTERSHADE 5 //#define CV_GLCMDESC_CORRELATION 6 //#define CV_GLCMDESC_CORRELATIONINFO1 7 //#define CV_GLCMDESC_CORRELATIONINFO2 8 //#define CV_GLCMDESC_MAXIMUMPROBABILITY 9 for (int step=0; step<4; step++){ for (int i=0; i<10; i++){ printf("%.3f,", cvGetGLCMDescriptor(glcm, step, i)); } printf("\n"); } IplImage *d0org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1); cvResize(cvCreateGLCMImage(glcm,0),d0org,CV_INTER_NN); IplImage *d0 = cvCreateImage(cvGetSize(d0org),IPL_DEPTH_8U,1); cvConvertScaleAbs(d0org,d0,255,0); cvNormalize(d0,d0,0,255,CV_MINMAX); cvSaveImage("d0.png",d0); IplImage *d1org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1); cvResize(cvCreateGLCMImage(glcm,1),d1org,CV_INTER_NN); IplImage *d1 = cvCreateImage(cvGetSize(d1org),IPL_DEPTH_8U,1); cvConvertScaleAbs(d1org,d1,255,0); cvNormalize(d1,d1,0,255,CV_MINMAX); cvSaveImage("d1.png",d1); IplImage *d2org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1); cvResize(cvCreateGLCMImage(glcm,2),d2org,CV_INTER_NN); IplImage *d2 = cvCreateImage(cvGetSize(d2org),IPL_DEPTH_8U,1); cvConvertScaleAbs(d2org,d2,255,0); cvNormalize(d2,d2,0,255,CV_MINMAX); cvSaveImage("d2.png",d2); IplImage *d3org = cvCreateImage(cvSize(256,256),IPL_DEPTH_32F,1); cvResize(cvCreateGLCMImage(glcm,3),d3org,CV_INTER_NN); IplImage *d3 = cvCreateImage(cvGetSize(d3org),IPL_DEPTH_8U,1); cvConvertScaleAbs(d3org,d3,255,0); cvNormalize(d3,d3,0,255,CV_MINMAX); cvSaveImage("d3.png",d3); cvNamedWindow("D0",1); cvNamedWindow("D1",1); cvNamedWindow("D2",1); cvNamedWindow("D3",1); cvShowImage("D0",d0); cvShowImage("D1",d1); cvShowImage("D2",d2); cvShowImage("D3",d3); cvWaitKey(0); cvReleaseGLCM(glcm,CV_GLCM_ALL); return 0; }
int main( int argc, char** argv ) { IplImage *current_frame=NULL; IplImage *running_average_background=NULL; IplImage *static_background_image=NULL; IplImage *static_moving_mask_image=NULL; IplImage *running_average_background_image=NULL; IplImage *running_average_moving_mask_image=NULL; IplImage *running_gaussian_average_background_average=NULL; IplImage *running_gaussian_average_background_sd=NULL; IplImage *running_gaussian_average_sd_image=NULL; IplImage *running_gaussian_average_background_image=NULL; IplImage *running_gaussian_average_moving_mask_image=NULL; IplImage *change_and_remain_changed_background_image=NULL; IplImage *subtracted_image=NULL; IplImage *moving_mask_image=NULL; int user_clicked_key=0; int show_ch = 'm'; bool paused = false; // Load the video (AVI) file CvCapture *capture = cvCaptureFromAVI( " " ); //Add here the inputh video path // Ensure AVI opened properly if( !capture ) return 1; // Get Frames Per Second in order to playback the video at the correct speed int fps = ( int )cvGetCaptureProperty( capture, CV_CAP_PROP_FPS ); // Explain the User Interface printf( "Hot keys: \n" "\tESC - quit the program\n" "\tSPACE - pause/resume the video\n"); // Create display windows for images cvNamedWindow( "Input video", 0 ); cvNamedWindow( "Static Background", 0 ); cvNamedWindow( "Running Average Background", 0 ); cvNamedWindow( "Running Gaussian Average Background", 0 ); cvNamedWindow( "Running Gaussian Average Stan. Dev.", 0 ); cvNamedWindow( "Moving Points - Static", 0 ); cvNamedWindow( "Moving Points - Running Average", 0 ); cvNamedWindow( "Moving Points - Running Gaussian Average", 0 ); // Setup mouse callback on the original image so that the user can see image values as they move the // cursor over the image. cvSetMouseCallback( "Input video", on_mouse_show_values, 0 ); window_name_for_on_mouse_show_values="Input video"; while( user_clicked_key != ESC ) { // Get current video frame current_frame = cvQueryFrame( capture ); if( !current_frame ) // No new frame available break; image_for_on_mouse_show_values = current_frame; // Assign image for mouse callback cvShowImage( "Input video", current_frame ); if (static_background_image == NULL) { // The first time around the loop create the images for processing // General purpose images subtracted_image = cvCloneImage( current_frame ); // Static backgound images static_background_image = cvCloneImage( current_frame ); static_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 ); cvShowImage( "Static Background", static_background_image ); // Running average images running_average_background = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 ); //cvZero(running_average_background); cvConvert(current_frame, running_average_background); running_average_background_image = cvCloneImage( current_frame ); running_average_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 ); // Running Gaussian average images running_gaussian_average_background_image = cvCloneImage( current_frame ); running_gaussian_average_sd_image = cvCloneImage( current_frame ); running_gaussian_average_moving_mask_image = cvCreateImage( cvGetSize(current_frame), 8, 3 ); running_gaussian_average_background_average = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 ); cvConvert(current_frame, running_gaussian_average_background_average); running_gaussian_average_background_sd = cvCreateImage( cvGetSize(current_frame), IPL_DEPTH_32F, 3 ); cvZero(running_gaussian_average_background_sd); } // Static Background Processing cvAbsDiff( current_frame, static_background_image, subtracted_image ); cvThreshold( subtracted_image, static_moving_mask_image, 30, 255, CV_THRESH_BINARY ); cvShowImage( "Moving Points - Static", static_moving_mask_image ); // Running Average Background Processing cvRunningAvg( current_frame, running_average_background, 0.01 /*, moving_mask_image*/ ); cvConvert( running_average_background, running_average_background_image ); cvAbsDiff( current_frame, running_average_background_image, subtracted_image ); cvThreshold( subtracted_image, running_average_moving_mask_image, 30, 255, CV_THRESH_BINARY ); cvShowImage( "Running Average Background", running_average_background_image ); cvShowImage( "Moving Points - Running Average", running_average_moving_mask_image ); // Running Gaussian Average Background Processing update_running_gaussian_averages( current_frame, running_gaussian_average_background_average, running_gaussian_average_background_sd ); cvConvertScaleAbs( running_gaussian_average_background_average, running_gaussian_average_background_image, 1.0, 0 ); cvShowImage( "Running Gaussian Average Background", running_gaussian_average_background_image ); cvConvertScaleAbs( running_gaussian_average_background_sd, running_gaussian_average_sd_image, 10.0, 0 ); cvShowImage( "Running Gaussian Average Stan. Dev.", running_gaussian_average_sd_image ); determine_moving_points_using_running_gaussian_averages( current_frame, running_gaussian_average_background_average, running_gaussian_average_background_sd, running_gaussian_average_moving_mask_image ); cvShowImage( "Moving Points - Running Gaussian Average", running_gaussian_average_moving_mask_image ); // Deal with user input, and wait for the delay between frames do { if( user_clicked_key == ' ' ) { paused = !paused; } if (paused) user_clicked_key = cvWaitKey(0); else user_clicked_key = cvWaitKey( 1000 / fps ); } while (( user_clicked_key != ESC ) && ( user_clicked_key != -1 )); } /* free memory */ cvReleaseCapture( &capture ); cvDestroyWindow( "Input video" ); cvDestroyWindow( "Static Background" ); cvDestroyWindow( "Running Average Background" ); cvDestroyWindow( "Running Gaussian Average Background" ); cvDestroyWindow( "Running Gaussian Average Stan. Dev." ); cvDestroyWindow( "Moving Points - Static" ); cvDestroyWindow( "Moving Points - Running Average" ); cvDestroyWindow( "Moving Points - Running Gaussian Average" ); return 0; }
/** * main */ int main(int argc, const char **argv) { // *** MODIFICATION: OpenCV modifications. // Load previous image. IplImage* prevImage = cvLoadImage("motion1.jpg", CV_LOAD_IMAGE_COLOR); // Create two arrays with the same number of channels than the original one. avg1 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3); avg2 = cvCreateMat(prevImage->height,prevImage->width,CV_32FC3); // Create image of 32 bits. IplImage* image32 = cvCreateImage(cvSize(prevImage->width,prevImage->height), 32,3); // Convert image to 32 bits. cvConvertScale(prevImage,image32,1/255,0); // Set data from previous image into arrays. cvSetData(avg1,image32->imageData,image32->widthStep); cvSetData(avg2,image32->imageData,image32->widthStep); // *** MODIFICATION end // Our main data storage vessel.. RASPISTILL_STATE state; MMAL_STATUS_T status = MMAL_SUCCESS; MMAL_PORT_T *camera_preview_port = NULL; MMAL_PORT_T *camera_video_port = NULL; MMAL_PORT_T *camera_still_port = NULL; MMAL_PORT_T *preview_input_port = NULL; MMAL_PORT_T *encoder_input_port = NULL; MMAL_PORT_T *encoder_output_port = NULL; bcm_host_init(); // Register our application with the logging system vcos_log_register("fast", VCOS_LOG_CATEGORY); signal(SIGINT, signal_handler); default_status(&state); if (state.verbose) { fprintf(stderr, "\n%s Camera App %s\n\n", basename(argv[0]), VERSION_STRING); } // OK, we have a nice set of parameters. Now set up our components // We have three components. Camera, Preview and encoder. // Camera and encoder are different in stills/video, but preview // is the same so handed off to a separate module if ((status = create_camera_component(&state)) != MMAL_SUCCESS) { vcos_log_error("%s: Failed to create camera component", __func__); } else if ((status = raspipreview_create(&state.preview_parameters)) != MMAL_SUCCESS) { vcos_log_error("%s: Failed to create preview component", __func__); destroy_camera_component(&state); } else if ((status = create_encoder_component(&state)) != MMAL_SUCCESS) { vcos_log_error("%s: Failed to create encode component", __func__); raspipreview_destroy(&state.preview_parameters); destroy_camera_component(&state); } else { PORT_USERDATA callback_data; if (state.verbose) fprintf(stderr, "Starting component connection stage\n"); camera_preview_port = state.camera_component->output[MMAL_CAMERA_PREVIEW_PORT]; camera_video_port = state.camera_component->output[MMAL_CAMERA_VIDEO_PORT]; camera_still_port = state.camera_component->output[MMAL_CAMERA_CAPTURE_PORT]; preview_input_port = state.preview_parameters.preview_component->input[0]; encoder_input_port = state.encoder_component->input[0]; encoder_output_port = state.encoder_component->output[0]; if (state.preview_parameters.wantPreview ) { if (state.verbose) { fprintf(stderr, "Connecting camera preview port to preview input port\n"); fprintf(stderr, "Starting video preview\n"); } // *** USER: remove preview // Connect camera to preview //status = connect_ports(camera_preview_port, preview_input_port, &state.preview_connection); } else { status = MMAL_SUCCESS; } if (status == MMAL_SUCCESS) { VCOS_STATUS_T vcos_status; if (state.verbose) fprintf(stderr, "Connecting camera stills port to encoder input port\n"); // Now connect the camera to the encoder status = connect_ports(camera_still_port, encoder_input_port, &state.encoder_connection); if (status != MMAL_SUCCESS) { vcos_log_error("%s: Failed to connect camera video port to encoder input", __func__); goto error; } // Set up our userdata - this is passed though to the callback where we need the information. // Null until we open our filename callback_data.file_handle = NULL; callback_data.pstate = &state; vcos_status = vcos_semaphore_create(&callback_data.complete_semaphore, "RaspiStill-sem", 0); vcos_assert(vcos_status == VCOS_SUCCESS); if (status != MMAL_SUCCESS) { vcos_log_error("Failed to setup encoder output"); goto error; } FILE *output_file = NULL; int frame = 1; // Enable the encoder output port encoder_output_port->userdata = (struct MMAL_PORT_USERDATA_T *)&callback_data; if (state.verbose) fprintf(stderr, "Enabling encoder output port\n"); // Enable the encoder output port and tell it its callback function status = mmal_port_enable(encoder_output_port, encoder_buffer_callback); // Create an empty matrix with the size of the buffer. CvMat* buf = cvCreateMat(1,60000,CV_8UC1); // Keep buffer that gets frames from queue. MMAL_BUFFER_HEADER_T *buffer; // Image to be displayed. IplImage* image; // Keep number of buffers and index for the loop. int num, q; while(1) { // Send all the buffers to the encoder output port num = mmal_queue_length(state.encoder_pool->queue); for (q=0;q<num;q++) { buffer = mmal_queue_get(state.encoder_pool->queue); if (!buffer) vcos_log_error("Unable to get a required buffer %d from pool queue", q); if (mmal_port_send_buffer(encoder_output_port, buffer)!= MMAL_SUCCESS) vcos_log_error("Unable to send a buffer to encoder output port (%d)", q); } // for if (mmal_port_parameter_set_boolean(camera_still_port, MMAL_PARAMETER_CAPTURE, 1) != MMAL_SUCCESS) vcos_log_error("%s: Failed to start capture", __func__); else { // Wait for capture to complete // For some reason using vcos_semaphore_wait_timeout sometimes returns immediately with bad parameter error // even though it appears to be all correct, so reverting to untimed one until figure out why its erratic vcos_semaphore_wait(&callback_data.complete_semaphore); if (state.verbose) fprintf(stderr, "Finished capture %d\n", frame); } // else // Copy buffer from camera to matrix. buf->data.ptr = buffer->data; // This workaround is needed for the code to work // *** TODO: investigate why. printf("Until here works\n"); // Decode the image and display it. image = cvDecodeImage(buf, CV_LOAD_IMAGE_COLOR); // Destinations CvMat* res1 = cvCreateMat(image->height,image->width,CV_8UC3); CvMat* res2 = cvCreateMat(image->height,image->width,CV_8UC3); // Update running averages and then scale, calculate absolute values // and convert the result 8-bit. // *** USER:change the value of the weight. cvRunningAvg(image,avg2,0.0001, NULL); cvConvertScaleAbs(avg2, res2, 1,0); cvRunningAvg(image,avg1,0.1, NULL); cvConvertScaleAbs(avg1, res1, 1,0); // Show images cvShowImage("img",image); cvShowImage("avg1",res1); cvShowImage("avg2",res2); cvWaitKey(20); // Update previous image. cvSaveImage("motion1.jpg", image, 0); } // end while vcos_semaphore_delete(&callback_data.complete_semaphore); } else { mmal_status_to_int(status); vcos_log_error("%s: Failed to connect camera to preview", __func__); } error: mmal_status_to_int(status); if (state.verbose) fprintf(stderr, "Closing down\n"); // Disable all our ports that are not handled by connections check_disable_port(camera_video_port); check_disable_port(encoder_output_port); if (state.preview_parameters.wantPreview ) mmal_connection_destroy(state.preview_connection); mmal_connection_destroy(state.encoder_connection); /* Disable components */ if (state.encoder_component) mmal_component_disable(state.encoder_component); if (state.preview_parameters.preview_component) mmal_component_disable(state.preview_parameters.preview_component); if (state.camera_component) mmal_component_disable(state.camera_component); destroy_encoder_component(&state); raspipreview_destroy(&state.preview_parameters); destroy_camera_component(&state); if (state.verbose) fprintf(stderr, "Close down completed, all components disconnected, disabled and destroyed\n\n"); } if (status != MMAL_SUCCESS) raspicamcontrol_check_configuration(128); return 0; }
void ImageProcessorCV::CalculateGradientImage(CByteImage *pInputImage, CByteImage *pOutputImage) { if (pInputImage->width != pOutputImage->width || pInputImage->height != pOutputImage->height || pOutputImage->type != CByteImage::eGrayScale) return; IplImage *pIplInputImage = IplImageAdaptor::Adapt(pInputImage); IplImage *pIplOutputImage = IplImageAdaptor::Adapt(pOutputImage); if (pInputImage->type == CByteImage::eGrayScale) { IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1); IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1); cvSmooth(pIplInputImage, abs, CV_GAUSSIAN, 3, 3); cvSobel(abs, diff, 1, 0, 3); cvConvertScaleAbs(diff, pIplOutputImage); cvSobel(abs, diff, 0, 1, 3); cvConvertScaleAbs(diff, abs); cvAdd(abs, pIplOutputImage, pIplOutputImage, 0); cvReleaseImage(&diff); cvReleaseImage(&abs); } else if (pInputImage->type == CByteImage::eRGB24) { // Determine Gradient Image by Irina Wchter // instead of normal norm sqrt(x*x +y*y) use |x|+|y| because it is much faster IplImage *singleChannel0 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *singleChannel1 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *singleChannel2 = cvCreateImage(cvSize(pInputImage->width,pInputImage->height), IPL_DEPTH_8U, 1); IplImage *diff = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_16S, 1); IplImage *abs = cvCreateImage(cvSize(pInputImage->width, pInputImage->height), IPL_DEPTH_8U, 1); cvCvtPixToPlane(pIplInputImage, singleChannel0, singleChannel1, singleChannel2, NULL); cvSmooth(singleChannel0, singleChannel0, CV_GAUSSIAN, 3, 3); cvSobel(singleChannel0, diff, 1, 0, 3); cvConvertScaleAbs(diff, abs); cvSobel(singleChannel0, diff, 0, 1, 3); cvConvertScaleAbs(diff, singleChannel0); cvAdd(abs, singleChannel0, pIplOutputImage, 0); cvSmooth(singleChannel1, singleChannel1, CV_GAUSSIAN, 3, 3); cvSobel(singleChannel1, diff, 1, 0, 3); cvConvertScaleAbs(diff, abs); cvSobel(singleChannel1, diff, 0, 1, 3); cvConvertScaleAbs(diff, singleChannel1); cvAdd(abs, singleChannel1, singleChannel1, 0); cvMax(pIplOutputImage, singleChannel1, pIplOutputImage); cvSmooth(singleChannel2, singleChannel2, CV_GAUSSIAN, 3, 3); cvSobel(singleChannel2, diff, 1, 0, 3); cvConvertScaleAbs(diff, abs); cvSobel(singleChannel2, diff, 0, 1, 3); cvConvertScaleAbs(diff, singleChannel2); cvAdd(abs, singleChannel2, singleChannel2, 0); cvMax(pIplOutputImage, singleChannel2, pIplOutputImage); cvReleaseImage(&singleChannel0); cvReleaseImage(&singleChannel1); cvReleaseImage(&singleChannel2); cvReleaseImage(&diff); cvReleaseImage(&abs); } cvReleaseImageHeader(&pIplInputImage); cvReleaseImageHeader(&pIplOutputImage); }
int main(int argc, char *argv[]) { IplImage* img = 0; int height,width,step,channels; unsigned char *data; // load an image img= cvLoadImage("kantai.png"); if(!img){ printf("Could not load image file: %s\n",argv[1]); exit(0); } // get the image data height = img->height; width = img->width; step = img->widthStep; channels = img->nChannels; data = (uchar *)img->imageData; printf("Processing a %dx%d image with %d channels\n",height,width,channels); printf("step = %d\n", step); IplImage* imgGrayscale = cvCreateImage(cvGetSize(img), IPL_DEPTH_8U, 1); // 8-bit grayscale is enough. // convert to grayscale. cvCvtColor(img, imgGrayscale, CV_BGR2GRAY); // Create an image for the outputs IplImage* imgSobelX = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 ); // to prevent overflow. IplImage* imgSobelY = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 ); IplImage* imgSobelAdded = cvCreateImage( cvGetSize(img), IPL_DEPTH_32F, 1 ); IplImage* imgSobel = cvCreateImage( cvGetSize(img), IPL_DEPTH_8U, 1 ); // final image is enough to be an 8-bit plane. // Sobel cvSobel(imgGrayscale, imgSobelX, 1, 0, 3); cvSobel(imgGrayscale, imgSobelY, 0, 1, 3); cvAdd(imgSobelX, imgSobelY, imgSobelAdded); cvConvertScaleAbs(imgSobelAdded, imgSobel); //scaled to 8-bit level; important for visibility. //----------------------- OULINE EXTRACTION ------------------------------- // Normal diff IplImage* imgNormDiff = cvCreateImage(cvGetSize(img), 8, 1); cvCopy(imgGrayscale,imgNormDiff); norm_diff(imgNormDiff); // Roberts IplImage* imgRoberts = cvCreateImage(cvGetSize(img), 8, 1); cvCopy(imgGrayscale,imgRoberts); roberts(imgRoberts); // Sobel IplImage* imgSobel2 = cvCreateImage(cvGetSize(img), 8, 1); cvCopy(imgGrayscale,imgSobel2); sobel(imgSobel2); // Laplacian IplImage* imgLap = cvCreateImage(cvGetSize(img), 8, 1); cvCopy(imgGrayscale,imgLap); laplacian(imgLap); //--------------------------- ENHANCEMENT -------------------------------- // Laplacian IplImage* imgLap2 = cvCreateImage(cvGetSize(img), 8, 3); IplImage* imgRed = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgGreen = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgBlue = cvCreateImage(cvGetSize(img), 8, 1); cvSplit(img, imgRed, imgGreen, imgBlue, NULL); laplacian2(imgBlue); laplacian2(imgGreen); laplacian2(imgRed); cvMerge(imgRed,imgGreen,imgBlue, NULL, imgLap2); // Variant IplImage* imgVariant = cvCreateImage(cvGetSize(img), 8, 3); IplImage* imgRed2 = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgGreen2 = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgBlue2 = cvCreateImage(cvGetSize(img), 8, 1); cvSplit(img, imgRed2, imgGreen2, imgBlue2, NULL); variant(imgBlue2); variant(imgGreen2); variant(imgRed2); cvMerge(imgRed2,imgGreen2,imgBlue2, NULL, imgVariant); // Sobel IplImage* imgSobel3 = cvCreateImage(cvGetSize(img), 8, 3); IplImage* imgRed3 = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgGreen3 = cvCreateImage(cvGetSize(img), 8, 1); IplImage* imgBlue3 = cvCreateImage(cvGetSize(img), 8, 1); cvSplit(img, imgRed3, imgGreen3, imgBlue3, NULL); sobel2(imgBlue3); sobel2(imgGreen3); sobel2(imgRed3); cvMerge(imgRed3,imgGreen3,imgBlue3, NULL, imgSobel3); // create a window cvNamedWindow("Original", CV_WINDOW_KEEPRATIO); cvNamedWindow("Normal different line", CV_WINDOW_KEEPRATIO); cvNamedWindow("Roberts line", CV_WINDOW_FREERATIO); cvNamedWindow("Sobel line", CV_WINDOW_FREERATIO); cvNamedWindow("Laplacian line", CV_WINDOW_KEEPRATIO); cvNamedWindow("Laplacian Color", CV_WINDOW_KEEPRATIO); cvNamedWindow("Variant", CV_WINDOW_KEEPRATIO); cvNamedWindow("Sobel", CV_WINDOW_KEEPRATIO); /*cvNamedWindow( "Sobel-x" ); cvNamedWindow( "Sobel-y" ); cvNamedWindow( "Sobel-Added" ); cvNamedWindow( "Sobel-Added (scaled)" );*/ // show the image cvShowImage("Original", img); cvShowImage("Normal different line", imgNormDiff); cvShowImage("Roberts line",imgRoberts); cvShowImage("Sobel line", imgSobel2); cvShowImage("Laplacian line", imgLap); cvShowImage("Laplacian Color", imgLap2); cvShowImage("Variant", imgVariant); cvShowImage("Sobel", imgSobel3); /*cvShowImage("Sobel-x", imgSobelX); cvShowImage("Sobel-y", imgSobelY); cvShowImage("Sobel-Added", imgSobelAdded); cvShowImage("Sobel-Added (scaled)", imgSobel);*/ // wait for a key cvWaitKey(0); // release the image cvReleaseImage(&img); cvReleaseImage(&imgGrayscale); cvReleaseImage(&imgNormDiff); cvReleaseImage(&imgRoberts); cvReleaseImage(&imgSobel2); cvReleaseImage(&imgLap); cvReleaseImage(&imgLap2); cvReleaseImage(&imgVariant); cvReleaseImage(&imgSobel3); cvReleaseImage(&imgSobelX); cvReleaseImage(&imgSobelY); cvReleaseImage(&imgSobelAdded); cvReleaseImage(&imgSobel); return 0; }