Bonjour a tous !

Donc voila pour un petit projet perso j'essaye d'appliqué les calcul de matrice de convolution, j'ai trouver ce site :

https://docs.gimp.org/2.6/fr/plug-in-convmatrix.html

qui explique pas mal de chose et je pensais avoir compris mais hélas deviens clair que non.

Si quelqu'un peut regarder mon code et me dire d'où viens le problème svp.

Voici le code :

public void Contour() {
		for(int i=1; i<getWIDTH()-1; i++) {
			for(int j=1; j<getHEIGHT()-1; j++) {
				// cration de la matrice initial (etape inutile mais qui aide a visualisé)
				int[][] matrixInitial = {
						{this.image.getRGB(i-1, j-1),this.image.getRGB(i, j-1),this.image.getRGB(i+1, j-1)},
						{this.image.getRGB(i-1, j),this.image.getRGB(i, j),this.image.getRGB(i+1, j)},
						{this.image.getRGB(i-1, j+1),this.image.getRGB(i, j+1),this.image.getRGB(i+1, j+1)}
				};
				// creation de la matrice de convolution pour le contour d'objet
				int[][] matrixConvolution = {
						{0,1,0},
						{1,-4,1},
						{0,1,0}
				};
				// calcul du nouveau rgb apres convolution
				int rgbConvo = ((matrixInitial[0][0]*matrixConvolution[0][0])+(matrixInitial[1][0]*matrixConvolution[1][0])+
								(matrixInitial[2][0]*matrixConvolution[2][0])) + ((matrixInitial[0][1]*matrixConvolution[0][1])+(matrixInitial[1][1]*matrixConvolution[1][1])+
								(matrixInitial[2][1]*matrixConvolution[2][1])) + ((matrixInitial[0][2]*matrixConvolution[0][2])+(matrixInitial[1][2]*matrixConvolution[1][2])+(matrixInitial[2][2]*matrixConvolution[2][2]));
				// mise en place du nouveau rgb
				this.image.setRGB(i, j, rgbConvo);
			}
		}
	}

Et ci dessous le résultat : 

Merci d'avance a tous pour votre temps et votre aide

-
Edité par Anonyme 21 avril 2021 à 22:13:09

Bonjour,

Tu remplaces tes pixels au fur et à mesure. Essaye plutôt de les mettre dans un nouveau tableau 2D et seulement à la fin des deux boucles, tu transformes ce tableau en image.

Merci pour ta reponse alors voila ce que ca donne y a du mieux mais ca me semble faible comme résultat quand même:

code :

	public void Contour() {
		int[][] NewImage = new int[getWIDTH()][getHEIGHT()];
		for(int i=1; i<getWIDTH()-1; i++) {
			for(int j=1; j<getHEIGHT()-1; j++) {
				// cration de la matrice initial (etape inutile mais qui aide a visualisé)
				int[][] matrixInitial = {
						{this.image.getRGB(i-1, j-1),this.image.getRGB(i, j-1),this.image.getRGB(i+1, j-1)},
						{this.image.getRGB(i-1, j),this.image.getRGB(i, j),this.image.getRGB(i+1, j)},
						{this.image.getRGB(i-1, j+1),this.image.getRGB(i, j+1),this.image.getRGB(i+1, j+1)}
				};
				// creation de la matrice de convolution pour le contour d'objet
				int[][] matrixConvolution = {
						{0,1,0},
						{1,-4,1},
						{0,1,0}
				};
				// calcul du nouveau rgb apres convolution
				int rgbConvo = ((matrixInitial[0][0]*matrixConvolution[0][0])+(matrixInitial[1][0]*matrixConvolution[1][0])+(matrixInitial[2][0]*matrixConvolution[2][0])) +
								((matrixInitial[0][1]*matrixConvolution[0][1])+(matrixInitial[1][1]*matrixConvolution[1][1])+(matrixInitial[2][1]*matrixConvolution[2][1])) +
								((matrixInitial[0][2]*matrixConvolution[0][2])+(matrixInitial[1][2]*matrixConvolution[1][2])+(matrixInitial[2][2]*matrixConvolution[2][2]));
				// mise en place du nouveau rgb
				NewImage[i][j] = rgbConvo;
			}
		}
		
		for(int i=1; i<getWIDTH()-1; i++) {
			for(int j=1; j<getHEIGHT()-1; j++) {
				
				this.image.setRGB(i, j, NewImage[i-1][j-1]);
			}
		}	
		
	}

QU'est ce que vous en pensez ?

PS: voici l'image d'origine :

-
Edité par Anonyme 22 avril 2021 à 2:13:00

Je vois deux problèmes.

1) Tu calcules ton produit sur les valeurs RGB. Ca ne fonctionnera pas car lors du produit, les résultats d'une couleur peuvent déborder sur les bits d'une autre couleur. Je pense qu'il faut faire un produit pour chaque couleur. Sinon, tu peux transformer ton image en niveaux de gris avant de faire la convolution.

2) Ton filtre me semble incomplet. Le résultat de la convolution pour un pixel et une couleur doit donner une valeur entre 0 et 255. Or, ton produit donne une valeur entre -1020 et +1020. A vue de nez, Je dirais qu'il faut prendre la valeur absolue du résultat divisée par 4.

Enfin, tu devrais découper ton code en fonctions pour le rendre plus lisible et facile à corriger. Exemple :

int pixelConvolution(image, filter, x, y, channel)

Salut brubru ! merci pour ton suivi du sujet !

Pour le premier point voila ce que j'ai fais :

public void Contour() {
		int[][] NewImage = new int[getWIDTH()][getHEIGHT()];
		for(int i=1; i<getWIDTH()-1; i++) {
			for(int j=1; j<getHEIGHT()-1; j++) {
				// creation de la matrice de convolution pour le contour d'objet
				int[][] matrixConvolution = {
						{0,1,0},
						{1,-4,1},
						{0,1,0}
				};
				// calcul du nouveau rgb apres convolution
				int rgbConvo = ((this.image.getRGB(i-1, j-1)*matrixConvolution[0][0])+(this.image.getRGB(i, j-1)*matrixConvolution[1][0])+(this.image.getRGB(i+1, j-1)*matrixConvolution[2][0])) +
								((this.image.getRGB(i-1, j)*matrixConvolution[0][1])+(this.image.getRGB(i, j)*matrixConvolution[1][1])+(this.image.getRGB(i+1, j)*matrixConvolution[2][1])) +
								((this.image.getRGB(i-1, j+1)*matrixConvolution[0][2])+(this.image.getRGB(i, j+1)*matrixConvolution[1][2])+(this.image.getRGB(i+1, j+1)*matrixConvolution[2][2]));
				// mise en place du nouveau rgb
				NewImage[i][j] = rgbConvo;
			}
		}
		
		for(int i=1; i<getWIDTH()-1; i++) {
			for(int j=1; j<getHEIGHT()-1; j++) {
				this.image.setRGB(i, j, NewImage[i-1][j-1]);
			}
		}	
	}

et voila le resultat :

je trouve ca beaucoup, et j'ai juste appliqué un filtre noir et blanc sur l'image avant de faire la convolution.

Pour le deuxième point, et ben au vu du résultat je me demande si il y a un problème ... et juste pour te corriger sur un point mon filtre ne donne pas une valeur entre 0 et 255 il donne un rgb donc une valeur de ce genre la -16777216 (c'est le code rgb du noir)

Voila t'en pense quoi du coup ?

Ps: maintenant j'essaye de relier les points blanc pour rendre l'image plus net

Et merci encore

Un rgb, c'est un entier constitué de 4 groupes de 8 bits. Un pour l'alpha (optionnel), un pour le rouge, un pour le vert, un pour le bleu.

Donc chaque composante a une valeur comprise entre 0 et 255. Si tu multiplies/ajoutes des rgb, tes couleurs vont "déborder" sur les bits des autres couleurs.

Exemple : 255 (bleu) + 1 (bleu presque noir) = 256 (vert presque noir)

Oki donc pour ne pas deborder je remis un petit coup de fonction black and white ca permet de tout normaliser normalement:

	public void BlackAndWhite2() {
		// transform l'image en noir et blanc
		for(int i=0; i<getWIDTH(); i++) {
			for(int j=0; j< getHEIGHT(); j++) {
				
				int col = new Color(this.image.getRGB(i, j)).getRed() + new Color(this.image.getRGB(i, j)).getGreen() + new Color(this.image.getRGB(i, j)).getBlue();
				col /= 3;
				if(col < 127) {
					this.image.setRGB(i, j, new Color(0,0,0).getRGB());
				}else {
					this.image.setRGB(i, j, new Color(255,255,255).getRGB());
				}
			}
		}
	}