/// <summary> /// Cette fonction crée une nouvelle matrice de pixel contenant une image convulutionnée selon le choix de l'utilisateur (il y a différents choix de Kernek, flou, détection de contour etc...) /// </summary> /// <returns> /// Elle retourne une matrice de pixel de l'image convolutionnée. /// </returns> public Pixel[,] Convolution() { int[,] Kernel = null; Console.WriteLine("Choississez votre type de convolution ==> \n" + " 1 : Détetection de contour°\n" + " 2 : Flou\n" + " 3 : Repoussage\n" + " 4 : Renforcement\n"); string choix = Convert.ToString(Console.ReadLine()); switch (choix) { case "1": int[,] MatricedétectionContour = { { 0, 1, 0 }, { 1, -4, 1 }, { 0, 1, 0 } }; Kernel = MatricedétectionContour; break; case "2": int[,] MatriceFlou = { { 1, 1, 1 }, { 1, 1, 1 }, { 1, 1, 1 } }; Kernel = MatriceFlou; break; case "3": int[,] MatriceRepoussage = { { -2, -1, 0 }, { -1, 1, 1 }, { 0, 1, 2 } }; Kernel = MatriceRepoussage; break; case "4": int[,] MatriceRenforcement = { { 0, 0, 0 }, { -1, 1, 0 }, { 0, 0, 0 } }; Kernel = MatriceRenforcement; break; } Pixel[,] ImageConvolue = new Pixel[image.GetLength(0), image.GetLength(1)]; //Met la 1ère colonne et la dernière colonne en blanc for (int i = 0; i < image.GetLength(0); i++) { ImageConvolue[i, 0] = new Pixel(255, 255, 255); ImageConvolue[i, (image.GetLength(1) - 1)] = new Pixel(255, 255, 255); } //Idem avec les lignes for (int j = 0; j < image.GetLength(1); j++) { ImageConvolue[0, j] = new Pixel(255, 255, 255); ImageConvolue[(image.GetLength(0) - 1), j] = new Pixel(255, 255, 255); } int moyenneR = 0; int moyenneV = 0; int moyenneB = 0; for (int i = 1; i < image.GetLength(0) - 1; i++) { for (int j = 1; j < image.GetLength(1) - 1; j++) { for (int k = -1; k < 2; k++) { for (int l = -1; l < 2; l++) { moyenneR += image[i + k, j + l].GetR * Kernel[k + 1, l + 1]; moyenneV += image[i + k, j + l].GetV * Kernel[k + 1, l + 1]; moyenneB += image[i + k, j + l].GetB * Kernel[k + 1, l + 1]; } } if (choix == "2") { moyenneR /= 9; moyenneV /= 9; moyenneB /= 9; } if (moyenneR > 255 || moyenneR < 0) { moyenneR = 0; } if (moyenneV > 255 || moyenneV < 0) { moyenneV = 0; } if (moyenneB > 255 || moyenneB < 0) { moyenneB = 0; } ImageConvolue[i, j] = new Pixel(moyenneR, moyenneV, moyenneB); moyenneR = 0; moyenneV = 0; moyenneB = 0; } } return(ImageConvolue); }
/// <summary> /// Cette fonction vient créer un histogramme d'une des couleurs primaires R, V ou B d'une image, /// l'ordonnée varie selon le nombre d'occurence d'une nuance de couleur, tandis que l'abscisse varie de 0 à 255 /// (pour toutes les nuances possibles d'une couleur codée sur 8 bits). /// </summary> /// <returns> /// Elle retourne une matrice de pixel contenant l'histogramme d'une des trois couleurs RVB. /// </returns> public Pixel[,] HistogrammeRVB() { Console.WriteLine("Choisissez l'histogramme que vous voulez. Tapez : \n 1 pour le rouge. \n 2 pour le vert. \n 3 pour le bleu. "); string choix = Convert.ToString(Console.ReadLine()); int max_r = 0; int max_v = 0; int max_b = 0; int[] TabRouge = new int[256]; int[] TabBleu = new int[256]; int[] TabVert = new int[256]; int valeurRouge = 0; int valeurVert = 0; int valeurBleu = 0; for (int i = 0; i < 256; i++) { TabRouge[i] = 0; TabVert[i] = 0; TabBleu[i] = 0; } for (int i = 0; i < image.GetLength(0); i++) { for (int j = 0; j < image.GetLength(1); j++) { valeurRouge = image[i, j].GetR; valeurVert = image[i, j].GetV; valeurBleu = image[i, j].GetB; TabRouge[valeurRouge] = TabRouge[valeurRouge] + 1; TabBleu[valeurBleu] = TabBleu[valeurBleu] + 1; TabVert[valeurVert] = TabVert[valeurVert] + 1; } } for (int i = 0; i < 256; i++) { if (TabRouge[i] > max_r) { max_r = TabRouge[i]; } if (TabBleu[i] > max_b) { max_b = TabBleu[i]; } if (TabVert[i] > max_v) { max_v = TabVert[i]; } } int max = 0; if (choix == "1") { max = max_r; } if (choix == "2") { max = max_v; } if (choix == "3") { max = max_b; } Pixel[,] Histo = new Pixel[(max / 10 + 1), 256]; //on initialise en blanc for (int i = 0; i < max / 10 + 1; i++) { for (int j = 0; j < 256; j++) { Histo[i, j] = new Pixel(255, 255, 255); } } switch (choix) { case "1": //histo rouge for (int i = 0; i < 256; i++) { int Compteur = TabRouge[i] / 10; for (int x = 0; x < Compteur; x++) { Histo[x, i] = new Pixel(255, 0, 0); } } break; case "2": //histo vert for (int i = 0; i < 256; i++) { int Compteur = TabVert[i] / 10; for (int x = 0; x < Compteur; x++) { Histo[x, i] = new Pixel(0, 255, 0); } } break; case "3": //histo bleu for (int i = 0; i < 256; i++) { //on divise par 10 pour pas avoir un histogramme trop grand int Compteur = TabBleu[i] / 10; for (int x = 0; x < Compteur; x++) { Histo[x, i] = new Pixel(0, 0, 255); } } break; } return(Histo); }
/// <summary> /// Cette fonction crée une nouvelle matrice de pixel contenant soit une fractale de Mandelbrot soit de Julia. /// </summary> /// <returns> /// Elle retourne une matrice de pixel de la fractale. /// </returns> public Pixel[,] Fractale() { Console.WriteLine("Quelle fractale voulez vous affichez? Tapez 1 pour la fractale de Mandelbrot, 2 pour celle de Julia "); string choix = Convert.ToString(Console.ReadLine()); double x_min = 0; double x_max = 0; double y_min = 0; double y_max = 0; double c_x = 0; double c_y = 0; double x_n = 0; double y_n = 0; Console.WriteLine("Saisissez la hauteur de votre fractale (entre 0 et 1000) ==>"); int hauteur = Convert.ToInt32(Console.ReadLine()); Console.WriteLine("Saisissez la largeur de votre fractale (entre 0 et 1000) ==>"); int largeur = Convert.ToInt32(Console.ReadLine()); Pixel[,] Image_fractale = new Pixel[largeur, hauteur]; int iteration_max = 50; if (choix == "1") { x_min = -2; x_max = 0.5; y_min = -1.25; y_max = 1.25; } if (choix == "2") { x_min = -1.25; x_max = 1.25; y_min = -1.25; y_max = 1.25; } for (int y = 0; y < Image_fractale.GetLength(1); y++) { for (int x = 0; x < Image_fractale.GetLength(0); x++) { if (choix == "1") { c_x = (x * (x_max - x_min) / Image_fractale.GetLength(0) + x_min); c_y = (y * (y_min - y_max) / Image_fractale.GetLength(1) + y_max); x_n = 0; y_n = 0; } if (choix == "2") { c_x = 0.285; c_y = 0.01; x_n = (x * (x_max - x_min) / Image_fractale.GetLength(1) + x_min); y_n = (y * (y_min - y_max) / Image_fractale.GetLength(0) + y_max); } int compteur = 0; while ((x_n * x_n + y_n * y_n) < 4 && compteur < iteration_max) { double temporaire_x = x_n; double temporaire_y = y_n; x_n = temporaire_x * temporaire_x - temporaire_y * temporaire_y + c_x; y_n = 2 * temporaire_x * temporaire_y + c_y; compteur = compteur + 1; } if (compteur == iteration_max) { Image_fractale[x, y] = new Pixel(0, 0, 0); } else { //amélioration trouvée sur Internet pour rendre l'image plus agréable à regarder. Image_fractale[x, y] = new Pixel((3 * compteur) % 256, (1 * compteur) % 256, (10 * compteur) % 256); } } } return(Image_fractale); }