Discussion :

[salem4]

salut tout le monde,
J'ai besoin d'aide sur la croissance de région, en fait j'ai une image bitmap et je veut éliminer son arrière plan, j'ai essayer la détection de contour mais sans résultat.
Si posssible je veut une source.
Merci d'avance.

[matazz]

je te conseille d'aller voir plutot du côté du forum Algorithme...

[Ti-R]

en fait j'ai une image bitmap et je veut éliminer son arrière plan

:

[salem4]

ok

[salem4]

Ti-R: je veut ouvrir une image médicale et plus précisément échographique (en niveau de gris (24 bit)), le but est de nettoyer cette image afin d'éliminer le fond noir.
voila.

[matazz]

sinon, tu peut définir une plage de couleur sombre à éliminer et tu les mets transparantes dans une couche alpha...

[mat.M]

Ti-R: je veut ouvrir une image médicale et plus précisément échographique (en niveau de gris (24 bit)), le but est de nettoyer cette image afin d'éliminer le fond noir.
voila.

C'est plus du ressort du forum Algorithmes comme précédemment suggéré

Qu'appelles-tu bruit ??
Il faut faire du traitement numérique, un filtrage avec peut-être des transformations de Fourier
Il ya sans doute des classes toutes faites pour ça.
Voir sur sourceforge.net , il ya sûrement du code source pour ça
Sinon ta boite peut peut-être payer pour une licence de Leadtools si c'est un projet à maintenir sous délais

sinon, tu peut définir une plage de couleur sombre à éliminer et tu les mets transparantes dans une couche alpha...

A ma connaissance en niveaux de gris il n'ya pas de couches alpha ( seulement en couleur avec A,R,V,B )

En plus le GDI ne supporte pas le traitement de la couche alpha , il faut le faire par soi-même

[Ti-R]

Ti-R: je veut ouvrir une image médicale et plus précisément échographique (en niveau de gris (24 bit)), le but est de nettoyer cette image afin d'éliminer le fond noir.
voila.

Quelle information tu veux précisément dans l'image?
C'est pour faire de la reconstruction 3D derrière ?
Comment veux tu que l'image soit ensuite ?
Tu veux de la transparence à la place du "noir" ?

[salem4]

en fait ce sont des simples images bitmaps codés en 24 bit (niveau de gris)
si tu veut je peut te les envoyer par mail
Ce que je veut c'est de rendre le fond noir de 'limage transparent.

[Ti-R]

Tu souhaites garder l'information sur 24 bits ?!
ou tu penses dupliquer le contenu pour un affichage 8bits ?

[salem4]

Je souhaite garder les informations sur 24 bits

[Ti-R]

Voila ce que je te propose
24bits -> échantillonne 8bits et place l'alpha dans l'image -> l'affiche

1er passe: Il faut que tu parcours ton image 24bit et que tu sauvegardes le min et le max des pixels dans l'image.

Tu calculs scale=max-min;

2eme passe: pour chacun pixel, tu fais v=((current_pixel-min)/scale)*255
et tu sauvegardes les résultats dans ton image RGBA qui va te servir pour l'affichage.
Donc tu auras R=v, G=v, B=v, soit A=255-v, soit A=v

Il ne te reste plus qu'afficher ton image RGBA qui sera grise mais avec un canal alpha, du noir au blanc représentant sa transparence.

Ps : scale permet de maximiser le signal et donc son affichage à l’écran, une autre solution est d’échantillonner une partie et de se balader via un index dans tout le signal.

[salem4]

est ce que tu peut m'exliquer d'avantages stp : parceque là je suis entrain de nages dans une grande et profonde mer.

2/C'est quoi l'alpha :
1/ comment échantillonner l'image en 8bits et comment placer l'alpha dans l'image :

[Ti-R]

D'ailleurs je me suis trompé si dessus

Ce n'est pas R=v, G=v, B=v, soit A=255-v, soit A=v
Mais R=1, G=1, B=1, en principe c'est A=255-v (le blanc défini la transparence à ta radio donc il faut l'inverser pour afficher le signal enregistré)


Si on place R=v, G=v, B=v l'image aura une couleur vraiment atténuée, car l'alpha aura l'effet de double rôle.

Ce que je veut c'est de rendre le fond noir de 'limage transparent.

C'est l'alpha...

Une couleur qui définie la transparence nommée A comme Alpha

comment échantillonner l'image en 8bits et comment placer l'alpha dans l'image

Placer un pointer sur les données en mémoire, parcourir les données 1 premières fois pour récupérer min max (c’est juste pour pousser le contraste au maximum), calculer scale. Reparcourir l'image et pour chaque pixel 24bits (int) calculer v=((current_pixel_24bits-min)/scale)*255...

[salem4]

ok, merci pour ton aide, je vais essayer ta solution

[Ti-R]

Oh la je suis plongé dans OpenGL et je mélange tout dans ce que je te dis entre couleur float et UCHAR, il fallait bien comprendre R=255, G=255, B=255 pour R=1., G=1., B=1. encore dsl

[salem4]

en fait j'aiessayer ce que tu m'as dit, mais l'image est apparue toute noire, en conclusion je ne pourrais utiliser que la croissance de région, mais la question c'est comment le faire??????????

[Ti-R]

mais l'image est apparue toute noire

Tu as bien mis R=255, G=255, B=255 ?

Tu peux montrer un bout de code stp

[salem4]

voici la source:
pixIdx c'est le compteur des pixels,
image.PImage c'est l'image ouverte,
tempImageData c'est l'image intermédiare


pixIdx=0;

for (i=0;i<hauteur*3;i++)
{
for (j=0;j<largeur;j++)
{
tempImageData[pixIdx]=0;
pixIdx++;
}
}

pixIdx=0;
for (i=0;i<hauteur*3;i++)
{
for (j=0;j<largeur;j++)
{
if(image.PImage[pixIdx]<min)
min=image.PImage[pixIdx];
pixIdx++;
}
}
scale=max-min;

pixIdx=0;
for (i=0;i<hauteur*3;i++)
{
for (j=0;j<largeur;j++)
{
tempImageData[pixIdx]=255-(((image.PImage[pixIdx]-min)/scale)*255);
pixIdx++;
}
}

pixIdx=0;
for (i=0;i<hauteur*3;i++)
{
for (j=0;j<largeur;j++)
{
image.PImage[pixIdx]=tempImageData[pixIdx];
pixIdx++;
}
}

[Ti-R]

min est bien initialisé à 0xFFFFFFFF ?
max est calculé ou ? (il est bien initialisé à 0 ?)

pas besoin d'initialiser l'image donc toutes les données vont être écrasées

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
// (DEBUT) code inutile
for (i=0;i<hauteur*3;i++) 
{ 
for (j=0;j<largeur;j++) 
{ 
tempImageData[pixIdx]=0; 
pixIdx++; 
} 
}
// (FIN) code inutile

ton image est RGBA donc au lieu de faire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
for (i=0;i<hauteur*3;i++) 
{ 
for (j=0;j<largeur;j++) 
{
... 
}
}

met à la place

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
// Ce qui est en dessous n'est pas optimisé mais c'est toujours mieux :)
int taille = largeur * hauteur * 4;
 
for (i=0;i<taille;i++) 
{ 
... 
}

Pour ce calcul

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
for (i=0;i<hauteur*3;i++) 
{ 
for (j=0;j<largeur;j++) 
{ 
tempImageData[pixIdx]=255-(((image.PImage[pixIdx]-min)/scale)*255); 
pixIdx++; 
} 
}

Tu ne peux parcourir une image qui stocke sur 1 valeur et une image finale qui stocke le contenu sur 4 valeurs

Donc le code se rapproche + de

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
 
// Le code ci dessous n'est pas optimisé !
int taille = largeur * hauteur ; // ne pas multiplier par 4
 
for (i=0;i<taille;i++) 
{ 
// on place RGB à blanc -> 255
tempImageData[pixIdx++]=255;
tempImageData[pixIdx++]=255;
tempImageData[pixIdx++]=255;
 
// On calcul l'alpha
// (pixIdx>>2) permet de divisé par 4 par décalage. Donc 11 -> 3 décalé de 2 -> 0
tempImageData[pixIdx]=255-(((image.PImage[pixIdx>>2]-min)/scale)*255); 
++pixIdx;
}