transformation de niveau de gris d'une image

Question

Salut,
Je suis nouvelle dans ce forum et j'ai un probleme en traitement d'image.
je dois ecrire un algo en c++ pour la transformation du niveau de gris d'une image video
en utilisant la formule qui suit, je dois calculer les valeurs de a et b en utilisant la formule suivante:
g'(x,y)= a* g(x,y)3 + b*g(x,y)2 

et en tenant compte des conditions suivantes

g'(x,y)=0 für g(x,y)=0 {function minimal}
g'(x,y)=255 für g(x,y)=255 {function maximal}

SVP avez vous une idee car j'ai déjà tout essayée en vain 
je serai contente d'avoir votre aide

laura

Pistol_Pete · Answer

Salut
Avant de convertir ton image en niveau de gris, il faut que je sache si tu arrives à recupérer dans un tableau les valeurs pour tous les pixels des trois canaux R G et B (rouge vert bleu)
Une fois que tu as réussie à faire cela, tu n'as plus qu'à faire la combinaison que tu veux entre ces trois canaux, pour transformer tes 3 canaux en un seul.

Généralement, il suffit de faire: Gris[i][j]=(Red[i][j]+Green[i][j]+Blue[i][j])/3

A+

laura1978 · Answer

j'utilise en fait le minapp
mon Programme comence ainsi : je suis allemande et code est commentez en langue allemande

extern FrameGrabber *fg;
extern BYTE *puffer1;        // Originalbild
extern BYTE *puffer2;        // Neunouvelle image

const int links  = Gw_Spreizung_rand;
const int oben   = Gw_Spreizung_rand;
const int rechts = MAX_SPALTE - Gw_Spreizung_rand;
const int unten  = MAX_ZEILE - Gw_Spreizung_rand;

mais ici je dois utiliser plutôt la formule que j'ai donnée en haut une formule pour la transformation non lineaire du niveau de gris

cs_louis14 · Answer

guten tag

c'est quoi le 2 et le 3  dans la formule, des puissances , des rangs ( je pense plutôt) et la formule ne doit pas être complète, il manque une couleur.
g'(x,y)= a* g(x,y)3 + b*g(x,y)2 

va voir du côté de CXImage , il y a une macro dans les sources qui fait cette transformation couleur-> niveau de gris.

louis14

laura1978 · Answer

j'etais dans le CXImage image je n'ai pas pue trouver peux tu m'envoyer le lien?

Pistol_Pete · Answer

D'après ce que je comprend et dis moi si je me trompe, les pixels de ton anciene image sont codé sur un BYTE!
Un byte c'est 8 bits donc 256 valeurs. Il n'y a donc qu'un canal!
Si tu as une image en couleur en etrée, il faudrait mettre:

extern BYTE *pufferRED;          // Originalbild
extern BYTE *pufferGREEN;     // Originalbild
extern BYTE *pufferBLUE;        // Originalbild

extern BYTE *puffer2;        // Neunouvelle image

Pour calculer a et b, je ne comprend pas bien : normalement, il sont fixé une bonne fois pour toute non?

laura1978 · Answer

le probleme est que j'aimerai calculer le niveau de gris sur l'ensemble de l'image donc 
je fais 
extern BYTE *puffer1;        // pour l'image Initiale qui est selon  la formule g(x,y)
extern BYTE *puffer2;        // nouvelle image qui est selon la formule g'(x,y) c.a.d la dérivée de g(x,y)

donc j'ai pas besoin de RGB car je veux calculer ce qu'on appelle en allemand "Grauwert- Spreizung" je ne connais pas la signification exacte en Francais
et donc le prof demander alors de calculer ce "Grauwert- Spreizung" à l'aide de la transformation  non lineaire 
qui est alors cette Formule : g'(x,y) = a* g(x,y)3 + b*g(x,y)2 ou je dois à partir des conditions suivantes: 
    BYTE gw_max = 0;      //ici   gw_max signifit grauwert maximale
    BYTE gw_min = 255;
determiner les parametres a et b qui me permettrons de resoudre la Transformation non lineare et ensuite je pourrai alors avoir ma nouvelle Image g'(x,y)

cs_louis14 · Answer

voilà le lien vers CXImage : http://www.codeproject.com/bitmap/cximage.asp
il faut chercher dans le projet, il y une macro commande du genre RGB2GRAY.
A moins que tu dois restaurer les couleurs à partir du niveau de gris ( cf  ximadsp.cpp).

Effectivement, il manque des précisions pour ton image codée en couleurs. j'ai vu des codages où , il y avait g(x,y) pour RED, g(x+1,y) pour GREEN et g(x+2,y) pour BLUE. Est-ce ton cas?




louis14

Pistol_Pete · Answer

Non Louis, elle a utilisé des notations mathématiques.
g(x,y) représente le niveau de gris du pixel x,y. 

Cette notation est utilisée quant tu as un tableau 1D
UCHAR *tab=new UCHAR[Largeur*Hauteur*4];

et la pour balayer ton tab, effectivement tu as:
for(i=0;i<Largeur*Hauteur*4;i+=4)
{
    Blue=tab[i]; 
    Green=tab[i+1];
    Red=tab[i+2];
}

laura1978 · Answer

le mien je n'ai pas besoin de tenir compte des informations sur des couleurs.
je dois tout simplement resourdre la formule g'(x,y) = a* g(x,y)3 + b*g(x,y)2 donc je cherche un pseudocode pour le resourdre en determinant a et b et tenant compte des Frontieres g'(x,y)=0 pour g(x,y)=0 {ici minimum de la function}et g'(x,y)=255 pour g(x,y)= 255{ici maximum de la function}

donc en fait j'ai une image Video g(x,y) et j'aimerai avoir une nouvelle image g'(x,y) en tenamt compte de cette Transformation non lineare g'(x,y) = a* g(x,y)3 + b*g(x,y)2 c'est tout je n'ai pas besoin d'infos sur le RGB

Pistol_Pete · Answer

OK je comprend mieux.
Donc en fait ton probleme c'est de déterminer a et b?
Mais a et b doivent etre constant pour tous les pixels de l'image?
La seul solution que je vois est de fixé soit a soit b:
Avec les conditions
g'(x,y)= 0 für g(x,y)=0 {function minimal}
 g'(x,y)=255 für g(x,y)=255 {function maximal} 

on obtient  3*a + 2*b  =1
Tu fixes a et tu calcules b.
une fois que tu as a et b tu peux calculer g'(x,y)  grace à ta formule

laura1978 · Answer

oui tu compris mon problème est de trouver a et b 
j'ai essayée coe tu dis j'ai utilisée les 
g'(x,y)=0 für g(x,y)=0 {function minimal}
g'(x,y)=255 für g(x,y)=255 {function maximal}
mais je ne me suis pas en sortie car je ne suis pas la meilleur en Math c'est pour celà que je croyais trouvée ici qlq qui pourra m'aider à trouver a et b en Particulier un pseudocode pourque je puisse directement le programmer en c++

Pistol_Pete · Answer

Ben faudrai faire quelque chose comme ca
int x,y;
double a,b,Coef;

a=10;                    //tu fixes a
b=(1-3*a)/2            //et tu calcules b
Coef=3*a+2*b;
//pour tous les pixels de ton image
for(x=0; x<Largeur ; x++)
  for(y=0; y<Hauteur; y++)
    g'[x][y] = Coef* g[x][y];

laura1978 · Answer

STP j''avais mal donnée la function car j'ai à faire ici au puissance donc j'ai normalement 
g'(x,y) = a* g(x,y)3 +
b*g(x,y)2

c'est pour celà q je ne comprenais pas très bien ton pseudocode.
peux tu m'aider?

Pistol_Pete · Answer

Et bien ca ne change pas grand chose: avec la condition g'(x,y)=255 für g(x,y)=255 tu as: 255 = a* 2553 + b*255²1 = a * 255 ² + b* 255 donc b=(1-255² * a)/255 a=10; //tu fixes a b=(1-255² * a) / 255; //et tu calcules b //pour tous les pixels de ton image for(x=0; x2

laura1978 · Answer

ok merci j'ai programmer cela avec visual c++ mais il y'a un problème comment calculer le g'(x,y) elle ne reconnaît pas la derivée de g'

Pistol_Pete · Answer

Toi tu connais g(x,y) tu connais a (parceque tu l'as imposé), tu connais b (par calcul) donc tu peux calculer g'(x,y).

Je suppose que cette fonction  a* g[x][y]3 + b*g[x][y]²  doit approximer la dérivé d'une fonction.

laura1978 · Answer

c'est vrai Merci pour l'aide

laura1978 · Answer

Voici comment est mon code maintenant

void gwspreizung(BYTE *puffer,int iRandlinks, int iRandrechts, int iRandoben, int iRandunten)

{
    BYTE gw_max = 0;
    BYTE gw_min = 255;
    BYTE gw_act;
    float a, b;

     a=10; 
     b=(1-(255*255 * a))/255;    

    int i, x, y;
    int iZeilenPos;

    // Zeilenindex, für die Berechnung innerhalb der Schleifen durch Addition
    iZeilenPos = iRandoben * MAX_SPALTE;                                
    for (y = iRandoben; y < (MAX_ZEILE - iRandunten); y++)
    {
        for (x = iRandlinks; x < (MAX_SPALTE - iRandrechts); x++)
        {
            gw_act = puffer[iZeilenPos + x];
            if (gw_act > gw_max)
                gw_max = gw_act;    // Maximaler Grauwert
            if (gw_act < gw_min)
                gw_min = gw_act;    // Minimaler Grauwert
        }
        iZeilenPos += MAX_SPALTE;    // nächste Zeile
    }
    // Tranformation der Bildpunkte 
    
    iZeilenPos = iRandoben * MAX_SPALTE;

    for (y = iRandoben; y < (MAX_ZEILE - iRandunten); y++)
    {
        for (x = iRandlinks; x < (MAX_SPALTE-iRandrechts); x++)

        {
            puffer[i]  = (Byte) a * gw_min * gw_min * gw_min + b (byte)* gw_min * gw_min;
        }

        iZeilenPos += MAX_SPALTE;    // nächste Zeile
    }
}

Pistol_Pete · Answer

J'ai du mal à suivre mais déjà dans cette ligne:

puffer[i]  = (Byte) a * gw_min * gw_min * gw_min + b (byte)* gw_min * gw_min;

le i tu ne l'as pas initialisés et tu ne l'incremente pas!

Pistol_Pete · Answer

et de plus gw_min étant une constante, a aussi, b aussi, ton image sera unie!!! 
(Byte) a * gw_min * gw_min * gw_min + b (byte)* gw_min * gw_min;

C'est surement pas se que tu veux

laura1978 · Answer

en tout cas tu as raison car ce que j'ai fait il y'avait encore de fautes et surtout je vois une image toute noire
donc je suis encore de voire ou j'ai mal fais 
je ne suis pas une douee du c++

Pistol_Pete · Answer

Moi je le voyais plus comme ca:

void gwspreizung(BYTE *puffer,int iRandlinks, int iRandrechts, int iRandoben, int iRandunten)

{
    BYTE gw_max = 0;
    BYTE gw_min = 255;
    BYTE gw_act;
    float a, b;
    int Hauteur,Largeur;
    Largeur=iRandrechts-iRandlinks;
    Hauteur=iRandunten-iRandoben;

     a=10;
     b=(1-(255*255 * a))/255;   

    int x, y;

                               
    for (y = iRandoben; y < iRandunten+Hauteur; y++)
        for (x = iRandlinks; x < iRandrechts+Largeur; x++)
        {
            gw_act = puffer[x+y*LargeurMaxImage];
            puffer[x+y*LargeurMaxImage]=gw_act*gw_act*gw_act*a+b*gw_act*gw_act;
        }
}

laura1978 · Answer

Merci j'essaye pour voire ce que ca donne

laura1978 · Answer

j'ai fait comme si-dessus,

void gwspreizung(BYTE *puffer,int iRandlinks, int iRandrechts, int iRandoben, int iRandunten)

{

    BYTE gw_max =  0;
    BYTE gw_min = 255;
    BYTE gw_act;
    float a, b;
    int Hauteur,Largeur;

    Largeur=iRandrechts-iRandlinks;

    Hauteur=iRandunten-iRandoben;

     a=200;

     b=(1-(255*255 * a))/255;   

    int x, y;

                               
    for (y = iRandoben; y < iRandunten+Hauteur; y++)

        for (x = iRandlinks; x < iRandrechts+Largeur; x++)
        {
            gw_act = puffer[x+y*MAX_ZEILE];

            puffer[x+y*MAX_ZEILE]= (unsigned char)gw_act*gw_act*gw_act*a + (unsigned char)b*gw_act*gw_act;
        }
}

mais j'ai un Problème au niveau de la conversion puisque puffer[x+y*MAX_ZEILE] ( celui- ci sera en BYTE ) = (donc ici j'ai mis) (float)gw_act*gw_act*gw_act*a + (float)b*gw_act*gw_act;
cela me donne un Warning du genre  => warning C4244: '=' : conversion from 'float' to 'unsigned char', possible loss of data

Pistol_Pete · Answer

Met :
 puffer[x+y*MAX_ZEILE]= (unsigned char)(gw_act*gw_act*gw_act*a + b*gw_act*gw_act);
et tu n'auras plus ce warning. Mais c'est pas bien méchant ce warning. 

Ca te donne le résultat voulu?

laura1978 · Answer

j'ai tester il n'ya plus de warning, mais dommage l'image ne change pas elle reste la meme.
je ne sais ce qui ne va pas la maintenant ou bien c'est  le calcul avec la hauteur et la Largeur ?

Transformation de niveau de gris d'une image

26 réponses

Votre réponse

Discussions similaires