Pair et impair

salut

en faite je voulez savoir est ce que quelque peux m'aider à résoudre mon problème. je vais m'expliquer:
apres avoir allouer une zonne mémoire dans la ram (GlobalAlloc) je voudrais transferer les pixel d'une image dans cette zone.mais le problème ce pose maintenent: car je voulais charger les pixel a indice pair (ie: 0 2 4 6 8 10 ) et les nommé S0 et les pixel a indices impair nommés D0, la premiere aide est d'ecrire:
for(int i=0;i<wd;i++){
for(int j=0;j<ht;j++)
{
verefier la parite de i

si i est pair

ecrire S0 ds la valeur dans la ram
sinon ecrire D0 ds la ram
}

et mon probleme j'arrive a ecrire un programme qui fait verifier la parité de i, est ce quelque un peut m'aider.

merci d'avance

Bonjour,

je ne suis pas sûr d'avoir bien cerné le problème, mais si ton problème est de savoir si un nombre est pair, le test suivant fais l'affaire:

Code:

---

1 2 3 4 5 6 7 8 9

// soit un int i if (i%2==0) { std::cout << "i est pair: i = " << i << std::endl; } else { std::cout << "i est impair: i = " << i << std::endl; }

---

hope it helps.

Il utilise l'opérateur modulo '%' ( reste de la division entière par )
pour connaître la parité de i.

j'ai déja utiliuser cette méthodes mais le programme est tres lent.

une fois j'ai trouvé sur un forum c++, un forumer a donner une instruction qui permet de charger les pixels pair puis les pixel impair.mais j'ai pas encore réussi a l'avoir.

NB
a savoir moi je veux réaliser une décimation, ie: déviser la résolution de l'image par deux.(prendre un pixel sur deux)

A ce moment là, le plus efficace serait quelque chose du style:

Code:

---

1 2 3 4 5 6

int len = (int) (wd*ht/2); alloc(manouvelleimage); //allocation de na nouvelle image avec 'len' pixels for(int i=0; i<len; i++) { manouvelleimage[i] = monancienneimage[i*2]; //inutile de chercher à optimiser en se servant de décalages, le compilateur s'en charge trés bien }

---

Pour vérifier qu'un entier est pair, je pense qu'un et binaire est beaucoup plus économique qu'un modulo.

Code:

---

1 2 3 4 5 6 7 8

if( !(i & 1) ) { // entier pair } else { // entier impair }

---

Je pense que le compilo est suffisamment intelligent pour transformer un modulo 2 en ce qu'il y a de plus rapide.

Soit je ne comprends pas ce que cherche a faire le PO, soit avant d'optimiser certains calculs, il serait bon d'optimiser l'algorithme :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

for(int i=0;i<wd;i++) { for(int j=0;j<ht;j++) { verefier la parite de i   si i est pair { ecrire S0 ds la valeur dans la ram sinon ecrire D0 ds la ram } } }

---

Cet algorithme est mauvais : Il verifie la parité de i pour chaque itération de j ce qui fait (ht-1)*(wd) opérations inutiles.

Deja une amélioration simple serait ceci :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

for(int i=0;i<wd;i++) { verefier la parite de i si i est pair { for(int j=0;j<ht;j++) { ecrire S0 ds la valeur dans la ram } } sinon { for(int j=0;j<ht;j++) { ecrire D0 ds la ram } } }

---

Mais une solution encore meilleure serait :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

int i; for(i = 0;i<wd-2;i++) { for(int j=0;j<ht;j++) { ecrire S0 ds la valeur dans la ram } i++; for(int j=0;j<ht;j++) { ecrire D0 ds la ram } } Si wd est impair alors { for(int j=0;j<ht;j++) { ecrire S0 ds la valeur dans la ram } }

---

Ce dernier algorithme prend en compte le fait qu'on part d'une colonne paire (0) et qu'ensuite on a toujours une alternance paire/impaire (logique :roll: )
Attention au wd-2 dans le for pour eviter de sortir du tableau ainsi qu'au traitrement effectué a la sortie qui tient compte du fait que wd peut etre impair et donc qu'il reste une colonne paire non traitée.

Citation:

---

Envoyé par Ksempac

Cet algorithme est mauvais : Il verifie la parité de i pour chaque itération de j ce qui fait (ht-1)*(wd) opérations inutiles.

.

---

en faite je voulais faire cette décimation suivant les i (suivant les x).

Citation:

---

Envoyé par madjidri

en faite je voulais faire cette décimation suivant les i (suivant les x).

---

Si je comprends bien tu veux juste garder les pixels avec x pair(ou impair) ?
En quoi ca justifie que tu te fixes un x (premiere boucle) puis que tu parcours tous les y (seconde boucle) et verifie a chaque fois que x est pair alors qu'il n'a pas bougé (tant que t'es dans ta seconde boucle, i bouge pas) ?

Moi je te propose de fixer x, de verifier sa parité, puis en fonction de ca de choisir une des 2 boucles. (premiere algo).
Ou bien comme de toute facon tu sais que tu pars d'un x pair (0), et qu'ensuite on enchaine pair/impair/pair/impair... tu peux parcourir tes colonnes 2 a 2 pour carrement supprimer le test de parité. (second algo)

Citation:

---

Envoyé par Ksempac

Si je comprends bien tu veux juste garder les pixels avec x pair(ou impair) ?
En quoi ca justifie que tu te fixes un x (premiere boucle) puis que tu parcours tous les y (seconde boucle) et verifie a chaque fois que x est pair alors qu'il n'a pas bougé (tant que t'es dans ta seconde boucle, i bouge pas) ?

Moi je te propose de fixer x, de verifier sa parité, puis en fonction de ca de choisir une des 2 boucles. (premiere algo).
Ou bien comme de toute facon tu sais que tu pars d'un x pair (0), et qu'ensuite on enchaine pair/impair/pair/impair... tu peux parcourir tes colonnes 2 a 2 pour carrement supprimer le test de parité. (second algo)

---

oui ta raison mon ami, mais lors de l'ecriture de message j'ai fais une grande erreur, voici ce que j'ai fait dans mon programme et il fonctionne sans pb:

for(int j=0;j<hth;j++){
for(int i=0;i<wdh;i++)
{
faire le calcul
}
}

merci beaucoup pour ton aide

Pas efficace.

Avec ton code tu te retrouves effectivement obligé de tester la parité de i dans la seconde boucle. Donc tu fais un test pour chaque couple (i,j) soit ht*wd tests. Ca marche sans probleme, mais c'est pas efficace : Si tu avais pris i comme premiere boucle, tu n'aurais que ht tests a faire (et meme 0 fois en parcourant les colonnes 2 a 2).

Tu te plains toi meme que ton code est trop lent :

Citation:

---

j'ai déja utiliuser cette méthodes mais le programme est tres lent.

---

Si ton programme est rempli d'algo pas optimum comme celui-ci c'est sur que tu augmentes la charge. Donc il serait peut etre bon de reprendre cela, en commencant par ces 2 boucles ;)