GaussianBlur et Filter2D

Rebonjour,

voilà j'ai un code qui fonctionne et qui me permet de faire un filtrage fréquentiel

Sauf que je n'arrive pas à finir le code : je suis avec une vieille bibliothèque opencv1.1 et je dois donc composer avec une version de cvDFT qui me donne accès (je crois) uniquement à la partie réelle et imaginaire de mon image

(je me suis grandement inspiré de l'exemple fourni avec opencv)

Or une fois que j'ai fait le filtrage fréquentiel sur log(1+sqrt(Re*Re+Im*Im)) je ne pense pas qu'il soit safe d'essayer de faire du log^-1 (et si cette fonction existe d'ailleurs)

Quelqu'un peut il m'aider ?

D'avance merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
    IplImage * im;
	IplImage* Kernel1=NULL;
    IplImage * realInput;
    IplImage * imaginaryInput;
    IplImage * complexInput;
    int dft_M, dft_N;
    CvMat* dft_A, tmp;
    IplImage * image_Re;
    IplImage * image_Im;
    double m, M;
	double* G1_ptr	= NULL;
	double sigma1=0.45;
	IplImage* Result1=NULL;
 
    im = cvLoadImage("U:\\Workspace\\lena.bmp",CV_LOAD_IMAGE_GRAYSCALE);
    if( !im )
        return -1;
 
    realInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    imaginaryInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 1);
    complexInput = cvCreateImage( cvGetSize(im), IPL_DEPTH_64F, 2);
	Kernel1= cvCreateImage(cvSize(im->width,im->height), IPL_DEPTH_64F,1);
	Result1= cvCreateImage(cvSize(im->width,im->height), IPL_DEPTH_64F,1);	
 
    cvScale(im, realInput, 1.0, 0.0);
    cvZero(imaginaryInput);
    cvMerge(realInput, imaginaryInput, NULL, NULL, complexInput);
 
    dft_M = cvGetOptimalDFTSize( im->height - 1 );
    dft_N = cvGetOptimalDFTSize( im->width - 1 );
 
    dft_A = cvCreateMat( dft_M, dft_N, CV_64FC2 );
    image_Re = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
    image_Im = cvCreateImage( cvSize(dft_N, dft_M), IPL_DEPTH_64F, 1);
 
    // copy A to dft_A and pad dft_A with zeros
    cvGetSubRect( dft_A, &tmp, cvRect(0,0, im->width, im->height));
    cvCopy( complexInput, &tmp, NULL );
    if( dft_A->cols > im->width )
    {
        cvGetSubRect( dft_A, &tmp, cvRect(im->width,0, dft_A->cols - im->width, im->height));
        cvZero( &tmp );
    }
 
    // no need to pad bottom part of dft_A with zeros because of
    // use nonzero_rows parameter in cvDFT() call below
 
 
 
    cvDFT( dft_A, dft_A, CV_DXT_FORWARD, complexInput->height );
 
    cvNamedWindow("win", 0);
    cvShowImage("win", im);
 
    // Split Fourier in real and imaginary parts
    cvSplit( dft_A, image_Re, image_Im, 0, 0 );
 
    // Compute the magnitude of the spectrum Mag = sqrt(Re^2 + Im^2)
    cvPow( image_Re, image_Re, 2.0);
    cvPow( image_Im, image_Im, 2.0);
    cvAdd( image_Re, image_Im, image_Re, NULL);
    cvPow( image_Re, image_Re, 0.5 );
 
	// Compute log(1 + Mag) : passage en décibel
	cvAddS( image_Re, cvScalarAll(1.0), image_Re, NULL ); // 1 + Mag
    cvLog(image_Re,image_Re); // log(1 + Mag)
 
 
    /*// Rearrange the quadrants of Fourier image so that the origin is at
    // the image center
    cvShiftDFT( image_Re, image_Re );
    cvMinMaxLoc(image_Re, &m, &M, NULL, NULL, NULL);
    cvScale(image_Re, image_Re, 1.0/(M-m), 1.0*(-m)/(M-m));*/
 
 
 
		float X=0.0;
		float Y=0.0;
 
		for (int y = 0; y < image_Re->height; y++)
		{	
			G1_ptr	= (double *)	(Kernel1->imageData + (Kernel1->widthStep *y));
 
			for (int x = 0; x < image_Re->width; x++)
			{
				X=x-image_Re->width/2;
				Y=y-image_Re->height/2;
				(*G1_ptr) =exp(-sigma1*sigma1*(X*X+Y*Y)/2);
 
				G1_ptr++;
 
			}
		}
 
 
	cvMul(Kernel1,image_Re,Result1,1); //j'effectue mon filtrage frequentiel
 
 
 
	cvNamedWindow("magnitude", 0);
	cvShowImage("magnitude", Result1);
 
	cvWaitKey(0);

bon finalement j'ai installé une nouvelle version d'opencv.

J'essaie donc de faire fonctionner Filter2D mais sans succès : l image que j'obtiens à sa sortie est toute blanche et je n'arrive pas à comprendre pourquoi :
utilisation du CV_32F ? mon image de départ convertie est également en CV_32F et j'arrive très bien à la lire ainsi que l'image de GaussianBlur

Je créé mal mon Kernel peut être ? je ne vois pas pourquoi

D'avance merci

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
	int ksize=((2.*(1.0 + (sigma1 - 0.8) /0.3)) + 1.0)/1.;
 
	if(!(ksize%2))
	{ksize+=1.;}		
 
	Kernel1= cvCreateImage(cvSize(ksize,ksize), IPL_DEPTH_32F,1);
 
		float X=0.0;
		float Y=0.0;
 
		for (int y = 0; y < ksize; y++)
		{	
			G1_ptr	= (float *)	(Kernel1->imageData + (Kernel1->widthStep *y));
 
			for (int x = 0; x < ksize; x++)
			{
				X=x-(ksize+1)/2;
				Y=y-(1+ksize)/2;
				(*G1_ptr) =exp(-1*(X*X+Y*Y)/(2*sigma1*sigma1)); //Verifier formule
 
				G1_ptr++;
 
			}
		}
 
 
	cv::Mat Kernel_mat(Kernel1);
	cv::Mat im_mat(im32);
	cv::Mat mat_blur1(im_mat.size(),im_mat.depth());
 
	cv::namedWindow("im", 0);
    cv::imshow("im", im_mat);
 
	cv::namedWindow("Kernel", 0);
    cv::imshow("Kernel", Kernel_mat);
 
 
	cv::filter2D(im_mat,mat_blur1,-1,Kernel_mat,cv::Point(-1,-1),0,0);//cv::BORDER_CONSTANT
 
	cv::namedWindow("filter2D", 0);
    cv::imshow("filter2D", mat_blur1);
 
	cv::Mat mat_blur2(im_mat.size(),im_mat.depth());
 
	cv::GaussianBlur(im_mat,mat_blur2,cv::Size(ksize,ksize),sigma1);
 
	cv::namedWindow("GaussianBlur", 0);
    cv::imshow("GaussianBlur", mat_blur2);

bon c'était bien le CV_32F le problème

d'après la doc je pensais que la normalisation se faisait automatiquement.

En divisant mon image par 255 j'ai la bonne solution