public void MyImageNoirEtBlanc()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultat = new Projet_Vincent_Poupet.MyImage("coco.bmp");
imagetest.PassageNoiretBlanc();
for (int i = 0; i < imageresultat.Hauteur; i++)
{
for (int j = 0; j < imageresultat.Largeur; j++)
{
imageresultat.MatriceDePixels[i, j].PassageNoirEtBlanc();
}
}
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, imageresultat.MatriceDePixels[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, imageresultat.MatriceDePixels[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, imageresultat.MatriceDePixels[i, j].vert);
}
}
}
public void AgrandirImageHauteur()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("test.bmp");
Projet_Vincent_Poupet.Pixel[,] matriceimageresultat = new Projet_Vincent_Poupet.Pixel[2 * imagetest.Hauteur, imagetest.Largeur];
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
int k = 0;
while (k < 2)
{
matriceimageresultat[i * 2 + k, j] = imagetest.MatriceDePixels[i, j];
k++;
}
}
}
imagetest.AgrandirImageHauteur(2);
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, matriceimageresultat[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, matriceimageresultat[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, matriceimageresultat[i, j].vert);
}
}
}
public void Rotation()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.Pixel[,] matricetournée = new Projet_Vincent_Poupet.Pixel[imagetest.Largeur, imagetest.Hauteur];
for (int j = 0; j < imagetest.Largeur; j++)
{
for (int i = 0; i < imagetest.Hauteur; i++)
{
matricetournée[j, imagetest.Hauteur - i - 1] = imagetest.MatriceDePixels[i, j];
}
}
imagetest.RotationSensTrigo();
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, matricetournée[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, matricetournée[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, matricetournée[i, j].vert);
}
}
}
/// <summary>
/// Bouton qui permet de générer une fractale
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_Fractale(object sender, RoutedEventArgs e)
{
CreeImageBlanche("Fractale.bmp", 240, 270);
Projet_Vincent_Poupet.MyImage Fractale = new Projet_Vincent_Poupet.MyImage("Fractale.bmp");
Fractale.AgrandirImageLargeur(10);
Fractale.AgrandirImageHauteur(10);
Fractale.Fractale(40);
Fractale.EnregistrerImage(this.CheminEnregistrement);
}
public void FiltreFlouPlus()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultat = new Projet_Vincent_Poupet.MyImage("coco.bmp");
int[,] matrice = new int[, ] {
{ 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1 }, { 1, 1, 1, 1, 1 }
};
int m = 0;
int n = 0;
for (int i = 2; i < imageresultat.Hauteur - 2; i++)
{
for (int j = 2; j < imageresultat.Largeur - 2; j++)
{
int totalrouge = 0;
int totalbleu = 0;
int totalvert = 0;
for (int k = i - 2; k <= i + 2; k++)
{
for (int l = j - 2; l <= j + 2; l++)
{
totalrouge = totalrouge + imageresultat.MatriceDePixels[k, l].rouge * matrice[m, n];
totalbleu = totalbleu + imageresultat.MatriceDePixels[k, l].bleu * matrice[m, n];
totalvert = totalvert + imageresultat.MatriceDePixels[k, l].vert * matrice[m, n];
n++;
}
m++;
n = 0;
}
m = 0;
imageresultat.MatriceDePixels[i, j].rouge = totalrouge / 25;
imageresultat.MatriceDePixels[i, j].bleu = totalbleu / 25;
imageresultat.MatriceDePixels[i, j].vert = totalvert / 25;
}
}
imagetest.FiltreFlouPlus();
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, imageresultat.MatriceDePixels[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, imageresultat.MatriceDePixels[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, imageresultat.MatriceDePixels[i, j].vert);
}
}
}
/// <summary>
/// Bouton qui permet d'appliquer une détection de contours
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_DectectionContours(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagedectioncontour = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagedectioncontour.FiltreDetectionContours();
imagedectioncontour.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'appliquer un effet miroir en fonction d'un axe horizontal
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_EffetMiroirHorizontal(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagemiroirhorizontal = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagemiroirhorizontal.EffetMiroirParRapportAHorizontale();
imagemiroirhorizontal.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'effectuer une rotation dans le sens trigo de 90°
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_Rotation(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagerotation = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagerotation.RotationSensTrigo();
imagerotation.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'appliquer un effet de repoussage
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_Repoussage(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagerepoussage = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagerepoussage.FiltreRepoussage();
imagerepoussage.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'appliquer en effet de renforcement des bords
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_RenforcementDesBords(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagerenforcementdesbords = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagerenforcementdesbords.FiltreRenforcementDesBords();
imagerenforcementdesbords.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet de décoder une image et voir si une image est cachée dans une autre
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_DécoderImageDansUneAutre(object sender, RoutedEventArgs e)
{
string nomfichierprincipale = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imageprincipale = new Projet_Vincent_Poupet.MyImage(nomfichierprincipale);
imageprincipale.DécoderImageDansUneAutre();
imageprincipale.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
//ON MET DES TRY/CATCH POUR EVITER QUE L'ON AIT DES ERREURS DE BUILT A CAUSE DE LA TAILLE DU MOT "nomfichier" QUI SERA NUL SI L'ON CLIQUE SUR "ANNULER"
/// <summary>
/// Bouton qui permet de faire passer l'image en niveau de gris en fonction de la valeur renvoyée par le slider associé
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_PassageNiveauGris(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;;
try
{
Projet_Vincent_Poupet.MyImage imagegrise = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagegrise.PassageGris();
imagegrise.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet de faire passer l'image en noir et blanc en fonction de la valeur renvoyée par le slider associé
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_PassageNoirEtBlanc(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagenoireetblanc = new Projet_Vincent_Poupet.MyImage(nomfichier);
imagenoireetblanc.PassageNoiretBlanc();
imagenoireetblanc.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'agrandir l'image en largeur en fonction de la valeur renvoyée par le slider associé
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AgrandirLargeur(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imageagrandie = new Projet_Vincent_Poupet.MyImage(nomfichier);
imageagrandie.AgrandirImageLargeur(Convert.ToInt32(SliderAgrandirLargeur.Value));
imageagrandie.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet d'agrandir l'image en hauteur en fonction de la valeur renvoyée par le slider associé
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void AgrandirHauteur(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imageagrandie = new Projet_Vincent_Poupet.MyImage(nomfichier);
imageagrandie.AgrandirImageHauteur(Convert.ToInt32(SliderAgrandirHauteur.Value)); //On agrandit l'image en fonction du coefficient donné par le slider
imageagrandie.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
public void DecoderImageDansUneAutre()
{
Projet_Vincent_Poupet.MyImage imagetestprincipale = new Projet_Vincent_Poupet.MyImage("lac_en_montagne.bmp");
Projet_Vincent_Poupet.MyImage imagetestacacher = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultatprincipale = new Projet_Vincent_Poupet.MyImage("lac_en_montagne.bmp");
Projet_Vincent_Poupet.MyImage imageresultatacacher = new Projet_Vincent_Poupet.MyImage("coco.bmp");
int[] tabrougeresultatacacher = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int[] tabbleuresultatacacher = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int[] tabvertresultatacacher = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int k = 0;
for (int i = 0; i < imageresultatprincipale.Hauteur; i++)
{
for (int j = 0; j < imageresultatprincipale.Largeur; j++)
{
tabrougeresultatacacher[k] = imageresultatprincipale.MatriceDePixels[i, j].rouge & 15;
tabrougeresultatacacher[k] = tabrougeresultatacacher[k] << 4;
tabbleuresultatacacher[k] = imageresultatprincipale.MatriceDePixels[i, j].bleu & 15;
tabbleuresultatacacher[k] = tabbleuresultatacacher[k] << 4;
tabvertresultatacacher[k] = imageresultatprincipale.MatriceDePixels[i, j].vert & 15;
tabvertresultatacacher[k] = tabvertresultatacacher[k] << 4;
tabrougeresultatacacher[k] = tabrougeresultatacacher[k] & 255;
tabbleuresultatacacher[k] = tabbleuresultatacacher[k] & 255;
tabvertresultatacacher[k] = tabvertresultatacacher[k] & 255;
k++;
}
}
imagetestprincipale.DécoderImageDansUneAutre();
k = 0;
for (int i = 0; i < imageresultatprincipale.Hauteur; i++)
{
for (int j = 0; j < imageresultatprincipale.Largeur; j++)
{
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].rouge, tabrougeresultatacacher[k]);
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].bleu, tabbleuresultatacacher[k]);
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].vert, tabvertresultatacacher[k]);
k++;
}
}
}
/// <summary>
/// Bouton qui permet de rétrecir la largeur en fonction de la valeur renvoyée par le slider associé
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void RetrecirLargeur(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imageretrecie = new Projet_Vincent_Poupet.MyImage(nomfichier);
imageretrecie.RetrecirImageLargeur(Convert.ToInt32(SliderRetrecirLargeur.Value));
imageretrecie.CorrectionTaillefichierdivisibilitépar4(); //NE PAS OUBLIER CETTE FONCTION
imageretrecie.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet de générer l'histogramme de couleur d'une image
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_Histogramme(object sender, RoutedEventArgs e)
{
string nomfichier = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imagepourhisto = new Projet_Vincent_Poupet.MyImage(nomfichier);
CreeImageBlanche("Histogramme.bmp", imagepourhisto.Largeur, imagepourhisto.Hauteur);
Projet_Vincent_Poupet.MyImage Histogramme = new Projet_Vincent_Poupet.MyImage("Histogramme.bmp");
Histogramme.Histogramme(imagepourhisto);
Histogramme.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
/// <summary>
/// Bouton qui permet de cacher une image dans une autre
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void Button_CoderImageDansUneAutre(object sender, RoutedEventArgs e)
{
string nomfichierprincipale = ParcourirFichierEtRecupererNomImage();
string nomfichieracacher = this.CheminOrigine;
try
{
Projet_Vincent_Poupet.MyImage imageprincipale = new Projet_Vincent_Poupet.MyImage(nomfichierprincipale);
Projet_Vincent_Poupet.MyImage imageacacher = new Projet_Vincent_Poupet.MyImage(nomfichieracacher);
imageprincipale.CoderImageDansUneAutre(imageacacher);
imageprincipale.EnregistrerImage(this.CheminEnregistrement);
}
catch (Exception)
{
}
}
public void EffetMiroirParRapportAHorizontale()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultat = new Projet_Vincent_Poupet.MyImage("coco.bmp");
int milieu;
if (imageresultat.Hauteur % 2 == 0)
{
milieu = imageresultat.Hauteur / 2;
}
else
{
milieu = (imageresultat.Hauteur - 1) / 2;
}
for (int i = 0; i < imageresultat.Largeur; i++)
{
for (int j = 0; j < milieu; j++)
{
Projet_Vincent_Poupet.Pixel Clone = new Projet_Vincent_Poupet.Pixel(imageresultat.MatriceDePixels[j, i].rouge, imageresultat.MatriceDePixels[j, i].vert, imageresultat.MatriceDePixels[j, i].bleu);
imageresultat.MatriceDePixels[j, i] = imageresultat.MatriceDePixels[imageresultat.Hauteur - j - 1, i];
imageresultat.MatriceDePixels[imageresultat.Hauteur - j - 1, i] = Clone;
}
}
imagetest.EffetMiroirParRapportAHorizontale();
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, imageresultat.MatriceDePixels[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, imageresultat.MatriceDePixels[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, imageresultat.MatriceDePixels[i, j].vert);
}
}
}
public void FiltreRenforcementDesBords()
{
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultat = new Projet_Vincent_Poupet.MyImage("coco.bmp");
int[,] matrice = new int[, ] {
{ 0, 0, 0 }, { -1, 1, 0 }, { 0, 0, 0 }
};
int m = 0;
int n = 0;
int[] tableaurouge = new int[imageresultat.Largeur * imageresultat.Hauteur];
int[] tableaubleu = new int[imageresultat.Largeur * imageresultat.Hauteur];
int[] tableauvert = new int[imageresultat.Largeur * imageresultat.Hauteur];
for (int i = 0; i < imageresultat.Hauteur; i++)
{
tableaurouge[i] = 0;
tableaubleu[i] = 0;
tableauvert[i] = 0;
}
int g = 0;
for (int i = 1; i < imageresultat.Hauteur - 1; i++)
{
for (int j = 1; j < imageresultat.Largeur - 1; j++)
{
int totalrouge = 0;
int totalbleu = 0;
int totalvert = 0;
for (int k = i - 1; k <= i + 1; k++)
{
for (int l = j - 1; l <= j + 1; l++)
{
totalrouge = totalrouge + imageresultat.MatriceDePixels[k, l].rouge * matrice[m, n];
totalbleu = totalbleu + imageresultat.MatriceDePixels[k, l].bleu * matrice[m, n];
totalvert = totalvert + imageresultat.MatriceDePixels[k, l].vert * matrice[m, n];
n++;
}
m++;
n = 0;
}
m = 0;
if (totalrouge > 255)
{
totalrouge = 255;
}
if (totalbleu > 255)
{
totalbleu = 255;
}
if (totalvert > 255)
{
totalvert = 255;
}
if (totalrouge < 0)
{
totalrouge = 0;
}
if (totalbleu < 0)
{
totalbleu = 0;
}
if (totalvert < 0)
{
totalvert = 0;
}
tableaurouge[g] = totalrouge;
tableaubleu[g] = totalbleu;
tableauvert[g] = totalvert;
g++;
}
}
g = 0;
for (int i = 0; i < imageresultat.Hauteur; i++)
{
for (int j = 0; j < imageresultat.Largeur; j++)
{
if (i == 0 || i == imageresultat.Hauteur - 1 || j == 0 || j == imageresultat.Largeur - 1)
{
imageresultat.MatriceDePixels[i, j].rouge = 0;
imageresultat.MatriceDePixels[i, j].bleu = 0;
imageresultat.MatriceDePixels[i, j].vert = 0;
}
else
{
imageresultat.MatriceDePixels[i, j].rouge = tableaurouge[g];
imageresultat.MatriceDePixels[i, j].bleu = tableaubleu[g];
imageresultat.MatriceDePixels[i, j].vert = tableauvert[g];
g++;
}
}
}
imagetest.FiltreRenforcementDesBords();
for (int i = 0; i < imagetest.Hauteur; i++)
{
for (int j = 0; j < imagetest.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, imageresultat.MatriceDePixels[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, imageresultat.MatriceDePixels[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, imageresultat.MatriceDePixels[i, j].vert);
}
}
}
public void CoderImageDansUneAutre()
{
Projet_Vincent_Poupet.MyImage imagetestprincipale = new Projet_Vincent_Poupet.MyImage("lac_en_montagne.bmp");
Projet_Vincent_Poupet.MyImage imagetestacacher = new Projet_Vincent_Poupet.MyImage("coco.bmp");
Projet_Vincent_Poupet.MyImage imageresultatprincipale = new Projet_Vincent_Poupet.MyImage("lac_en_montagne.bmp");
Projet_Vincent_Poupet.MyImage imageresultatacacher = new Projet_Vincent_Poupet.MyImage("coco.bmp");
int[] tabrougeimageprincipale = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int[] tabbleuimageprincipale = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int[] tabvertimageprincipale = new int[imageresultatprincipale.Hauteur * imageresultatprincipale.Largeur];
int[] tabrougeimagecachée = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int[] tabbleuimagecachée = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int[] tabvertimagecachée = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int[] tabrougeresultat = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int[] tabbleuresultat = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int[] tabvertresultat = new int[imageresultatacacher.Hauteur * imageresultatacacher.Largeur];
int k = 0;
for (int i = 0; i < imageresultatacacher.Hauteur; i++)
{
for (int j = 0; j < imageresultatacacher.Largeur; j++)
{
tabrougeimageprincipale[k] = imageresultatprincipale.MatriceDePixels[i, j].rouge & 240;
tabbleuimageprincipale[k] = imageresultatprincipale.MatriceDePixels[i, j].bleu & 240;
tabvertimageprincipale[k] = imageresultatprincipale.MatriceDePixels[i, j].vert & 240;
tabrougeimagecachée[k] = imageresultatacacher.MatriceDePixels[i, j].rouge & 240;
tabrougeimagecachée[k] = tabrougeimagecachée[k] >> 4;
tabbleuimagecachée[k] = imageresultatacacher.MatriceDePixels[i, j].bleu & 240;
tabbleuimagecachée[k] = tabbleuimagecachée[k] >> 4;
tabvertimagecachée[k] = imageresultatacacher.MatriceDePixels[i, j].vert & 240;
tabvertimagecachée[k] = tabvertimagecachée[k] >> 4;
tabrougeresultat[k] = tabrougeimageprincipale[k] | tabrougeimagecachée[k];
tabbleuresultat[k] = tabbleuimageprincipale[k] | tabbleuimagecachée[k];
tabvertresultat[k] = tabvertimageprincipale[k] | tabvertimagecachée[k];
k++;
}
}
imagetestprincipale.CoderImageDansUneAutre(imagetestacacher);
k = 0;
for (int i = 0; i < imageresultatacacher.Hauteur; i++)
{
for (int j = 0; j < imageresultatacacher.Largeur; j++)
{
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].rouge, tabrougeresultat[k]);
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].bleu, tabbleuresultat[k]);
Assert.AreEqual(imagetestprincipale.MatriceDePixels[i, j].vert, tabvertresultat[k]);
k++;
}
}
}
public void Histogramme()
{
Projet_Vincent_Poupet.MyImage imagepourhisto = new Projet_Vincent_Poupet.MyImage("coco.bmp");
CreeImageBlanche("histogramme.bmp", imagepourhisto.Largeur, imagepourhisto.Hauteur);
CreeImageBlanche("histogramme2.bmp", imagepourhisto.Largeur, imagepourhisto.Hauteur);
Projet_Vincent_Poupet.MyImage imageresultat = new Projet_Vincent_Poupet.MyImage("histogramme.bmp");
Projet_Vincent_Poupet.MyImage imagetest = new Projet_Vincent_Poupet.MyImage("histogramme2.bmp");
for (int i = 0; i < imagepourhisto.Largeur; i++)
{
int sommevert = 0;
int sommerouge = 0;
int sommebleu = 0;
for (int j = 0; j < imagepourhisto.Hauteur; j++)
{
sommebleu = sommebleu + imagepourhisto.MatriceDePixels[j, i].bleu;
sommevert = sommevert + imagepourhisto.MatriceDePixels[j, i].vert;
sommerouge = sommerouge + imagepourhisto.MatriceDePixels[j, i].rouge;
}
int nbbleu = (sommebleu / 255) / 3;
int nbvert = (sommevert / 255) / 3;
int nbrouge = (sommerouge / 255) / 3;
for (int k = 0; k < imagepourhisto.Hauteur; k++)
{
if (nbbleu > 0)
{
imageresultat.MatriceDePixels[k, i] = new Projet_Vincent_Poupet.Pixel(0, 0, 255);
nbbleu--;
}
else
{
if (nbrouge > 0)
{
imageresultat.MatriceDePixels[k, i] = new Projet_Vincent_Poupet.Pixel(255, 0, 0);
nbrouge--;
}
else
{
if (nbvert > 0)
{
imageresultat.MatriceDePixels[k, i] = new Projet_Vincent_Poupet.Pixel(0, 255, 0);
nbvert--;
}
}
}
}
}
imagetest.Histogramme(imagepourhisto);
for (int i = 0; i < imageresultat.Hauteur; i++)
{
for (int j = 0; j < imageresultat.Largeur; j++)
{
Assert.AreEqual(imagetest.MatriceDePixels[i, j].rouge, imageresultat.MatriceDePixels[i, j].rouge);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].bleu, imageresultat.MatriceDePixels[i, j].bleu);
Assert.AreEqual(imagetest.MatriceDePixels[i, j].vert, imageresultat.MatriceDePixels[i, j].vert);
}
}
}
