Version imprimable
ah donc je dois remplir la zonne manuelement
la fonction rand ne marche pas:(
Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
????
mais ici je sais pas commet determiner la dimension d l'image
La dimension, pour un bitmap 32bits, c'est assez facile: hauteur*largeur*4 octets.
Pour un bitmap 24bits, c'est un peu plus dur, mais ce doit être du genre:
((largeur*3)+3 & ~3) * hauteur.
(le calcul supplémentaire servant à arrondir la largeur aux 4 octets supérieurs).
ah
merci pour votre aide
donc je px utiliser la fonction rand(int valeur)
et je dois spécifier la dimension de bitmap en avance
n'est ce pas
Pour moi, tu calcules la taille et tu passes à une fonction comme CryptGenRandom() ou une fonction personnelle:
Note: je fais un décalage, car les bits inférieurs sont souvent moins aléatoires que les autres. Tu peux aussi passer par les conversions de double, mais c'est souvent beaucoup plus lent.Code:
2
3
4
5
6
7
8
9
10
11
12
13
14
Attention, si RAND_MAX est inférieur à 32767, tu as intéret à réduire le décalage (voire à passer par les double).
je vais essaier d'appliquer ça
j vous remercier du mon coeur:P
svp est que vous pouvez me corriger une portion de mon code?
je prend une image
je la divise en bloc de 8*8
j'ajoute une nombre(-128)
j'applique DCT sur ce derniere
Code:
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
Ne crois-tu pas que tu devrais calculer WIDTHBYTES avant l'allocation?Code:
2
3
C'es normal que tu ne remplisses pas la colonne 0 et la ligne 0 ?Code:
2
3
4
5
6
7
ça, ça ne peut marcher qu'avec le pointeur de la même taille qu'un pixel.Code:lpDestBits[yy*BmSrcInfo->bmWidthh+xx] = lpSrcBits[yy*BmSrcInfo->bmWidth+xx]
Pour un BYTE*, ça ne marcherait que sur une image 8bits.
Pour une image 32bits, le mieux est un RGBQUAD *.
Pour une image 24bits, il n'y a rien: Il va falloir compter les bytes trois par trois...
En plus, tu copies bêtements les bits de ton image source vers ton image de destination sans même passer par ta fameuse matrice 8*8, alors que je croyais que ces boucles étaient supposées remplir la matrice 8*8...
Ça ne marche pas. Il faut faire l'opération membre à membre ou utiliser des fonctions de calcul matriciel...(Windows n'en propose pas, il faudrait donc une bibliothèque ou des fonctions perso pour cela)Code:int temp=P*(-128); //M88_128
La suite est trop confuse pour moi.
Mais je me permets de te donner un conseil: Décompose un peu plus en fonction, et fait bien attention à ce que tu fais.
Ta DCT, tu dois la faire sur ta matrice 8*8. Le bitmap source doit n'etre utilisé que pour remplir la matrice, et le bitmap destination pour la vider.
Normalement, la fonction qui fait le calcul doit prendre des matrices 8*8 en entrée, sans se soucier d'où elles viennent (que ce soit d'un bitmap Windows ou de tout autre support).
Donc, tu devrais commencer par décomposer:
- Une fonction de lecture, qui lit le bitmap et remplit la matrice
- Une fonction de calcul sur la matrice
- Une fonction d'écriture vers le bitmap destination
- Et une fonction qui utilise les trois autres en boucle.
oui oui trop des erreurs:oops: :oops:
j'ai habutiée à travailler en matlab, un jeu sur des matrces
en vc++, c compliqué pour moi que je suis encore une débutante:cry:
je te remercie pour ton superb aide
pour moi je refaite encore le code
et j'espére qu'il soit prochainemet avec peu d'erreurs
merci de nouveau
bonjour
j'ai refait le code
mais je rencontre qlq pb:oops:
Code:
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
Code:
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
Code:
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
Code:
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
:oops:
Ouh, le désastre :(
Bon, je ne peux pas t'aider maintenant, car je suis au boulot et je prends du retard. Mais je vais essayer d'y jeter un oeil ce soir. Il y a une bonne partie à revoir de font en comble, et tu as énormément de code dupliqué...
PS: Tu devrais éviter d'utiliser les fonctions comme GlobalAlloc() à gogo. C'est fonctions sont quelque peux déconseillées de nos jours. Si tu tiens à utiliser les fonctions d'allocation de Windows, tu devrais utiliser HeapAlloc(GetProcessHeap()). Ainsi au moins, tu ne t'embarasserais pas de handles, ce serait déjà ça.
ok merci
je sens que je dérange par mes fauts:oops:
moi je continuer d'utiliser la fonction GlobalLock car ds ma premiére partie de mon projet ( faire par exemple la binaraisation , négation, niveau de gris......)
je l' a utilisée:?
OK, pour les GlobalXxxx c'est pas bien grave. Mais ta séparation en fonctions a aggravé la situation au lieu de l'améliorer...
ahhhhhhhhhhhh:? :?
vraiment à cet niveau je sis perturbée
Il faut des petites fonctions, dans ce genre:
(j'ai pas compilé, donc il y a surement des erreurs)
Edit : Une petite correction dans le code.Code:
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
36enum e_couleur { ROUGE, VERT, BLEU }; /* Fonction qui prend le bitmap 32 bits en entrée et remplit la matrice 8*8 ------------------------------------------------------------------------ */ BOOL Get88Matrix32( VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits int nWidth, //[in] Largeur du bitmap 32bits en pixels int x, //[in] Coordonnée X de la matrice 8*8 int y, //[in] Coordonnée Y de la matrice 8*8 BYTE pMatrice[8][8], //[out] Matrice 8*8 à lire enum e_couleur eCouleur //[in] Couleur à lire ) { if(pcBitmapBits==NULL) return FALSE; if(pMatrice==NULL) return FALSE; RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits); //Parcours de la zone 8*8 for( xx=0 ; xx<8 ; xx++) { for( yy=0 ; yy<8 ; yy++) { RGBQUAD const *pcRgb = pcRgbBits + (yy+8*y)*nWidth + (xx+8*x); switch(eCouleur) { case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed; break; case VERT: pMatrice[xx][yy] = pcRgb->rgbGreen; break; case BLEU: pMatrice[xx][yy] = pcRgb->rgbBlue; break; } } } return TRUE; }
je vais essaiyer de le compliler
merci pour ton aide;)
Si cette fonction marche, tu pourras l'appeler (ainsi que les suivantes) dans une grande boucle.
Et là encore, on peut fragmenter : Pourquoi ne pas mettre le traitement interne de la boucle (entre les deux lignes rouge sombre) dans une fonction qu'on appellerait trois fois, prenant une enum e_couleur en paramètre ?Code:
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// on suppose que les images ont des dimensions qui sont des multiples de 8 //Je rappelle que width est la largeur et height est la hauteur //nombre de matrice 8x8 dans la largeur de l'image int nb_mat8_larg = BmSrcInfo->biWidth/8; //nombre de matrice 8x8 dans la hauteur de l'image int nb_mat8_haut = BmSrcInfo->biHeight/8; i if(BmSrcInfo->biBitCount==32) // 32 bits { f for (x=0 ; x<nb_mat8_larg ; x++) { for (y=0 ; y<nb_mat8_haut ; y++) { // -/----------------\- BYTE M88[8][8]; Get88Matrix32(lpSrcBits, BmSrcInfo->biWidth, x, y, M88, ROUGE); //Traitement sur la matrice //... //Ecriture dans la destination //... // -\----------------/- //On fait la même chose pour le vert et le bleu //... //... } }
Là encore, on évite de la recopie de code...
je le complile, il me donne juste une erreur
erreur pour chaque couleurCode:
2
mais je sais pas ,si ce code ça marche ds ma application
car moi je ravaille ds la classe CImage
donc j'hérite des fonctions
et j'utilise par exemple :lpDestBits,nScanWidth,.........
je te montre un morceau de code qui fait la binaraisation de l'image:
Code:
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
Ton morceau de code, il ne fait rien d'autre que copier une image dans une autre...
Et dans mon code, il faut remplacer les points par des '->'
ah ok je vais essayer de nouveau
je te remercie vivement:?
salut
j'ai reécrit ces fontions
je sais pas cette fois si elles sont correctes:( :(
et la fonction qui calcul la DCT:Code:
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
et la fonction quantificationCode:
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
54BOOL DCTMatrix32( VOID const *pcBitmapBits, //[in] Données (pixels) du bitmap 32bits int nWidth, //[in] Largeur du bitmap 32bits en pixels int x, //[in] Coordonnée X de la matrice 8*8 int y, //[in] Coordonnée Y de la matrice 8*8 int valeur; BYTE pMatrice[8][8], //[out] Matrice 8*8 à lire enum e_couleur eCouleur //[in] Couleur à lire ) { if(pcBitmapBits==NULL) return FALSE; if(pMatrice==NULL) return FALSE; //Calcul des coefficients de a tranformes de la dct //u,v sont les indices de la nouvelle matrice a //i,j sont les indices de la matrice m RGBQUAD const *pcRgbBits = static_cast< RGBQUAD const * >(pcBitmapBits); for (int xx=0:xx<nWidth;xx++) for (int yy=0:yy<nWidth;yy++) for (int i=0:i<nWidth;i++) for (int j=0:j<nWidth;j++) { //Test permettant de determiner la valeur des variables C1 et C2 if u==0 c1=1/sqrt(2); else c1=1; if v==0 c2=1/sqrt(2); else c2=1; //j'ai cette equation n matlab, je sais pas si j'ai bien convertit en vc++ et j'ai bien respecté les boules!!! ( M=size d'image) // a(u+1,v+1)=a(u+1,v+1)+1/sqrt(2*M)*c1*c2*m(i+1,j+1)*cos(pi*u/M*(i+1/2))*cos(pi*v/M*(j+1/2)); //Parcours de la zone 8*8 RGBQUAD const *pcRgb = pcRgbBits + (2/nWidth)*((yy*nWidth + xx)*c1*c2* *cos(pi*u/nWidth*(i+1/2))*cos(pi*v/nWidth*(j+1/2))); switch(eCouleur) { case ROUGE: pMatrice[xx][yy] = pcRgb->rgbRed; break; case VERT: pMatrice[xx][yy] = pcRgb->rgbGreen; break; case BLEU: pMatrice[xx][yy] = pcRgb->rgbBlue; break; } } } return TRUE; }
et la d'ecriture destinationCode:
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
et la fontion globale:Code:
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
j ' ecrit le code juste pour le rougeCode:
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
j'ai pas encore essayer d'aplique ce que tu me conseillé de faire