public CPixels[,] Rotation90SensAntiTrigoPxl()
{
// On ne s'occupe pas de savoir si l'image est rectangle ou carré,
// Si l'algo traite les rectangles il traitera les carrés.
CPixels[,] matriceRGB_Returned = new CPixels[m_matriceRGB.GetLength(1), m_matriceRGB.GetLength(0)];
int indexI;
int indexJ = 0;
//AffichageMatriceRGB();
for (int i = 0; i < m_matriceRGB.GetLength(0); i++)
{
indexI = 0;
for (int j = m_matriceRGB.GetLength(1) - 1; j >= 0; j--)
{
//Console.WriteLine("Valeur matriceRGB en (" + i + "," + j + ") : " + m_matriceRGB[i,j].DisplayPixelStr());
matriceRGB_Returned[indexI, indexJ] = m_matriceRGB[i, j];
//Console.WriteLine("Valeur nouvelle Matrice en (" + indexI + "," + indexJ + ") : " + resultRotateMatrixRGB[indexI, indexJ].DisplayPixelStr());
indexI++;
}
indexJ++;
}
// A partir de la, on a notre nouvelle matrice résultant de m_matriceRGB,
return(matriceRGB_Returned);
}
public byte[] RemplissageHEADERNouvelleImageBmp()
{
CPixels[,] matricePxl = new CPixels[m_hauteurFichierInt, m_largeurFichierInt];
// Le HEADER des bmp fait 54 octets (entre l'index 0 et l'index 53), il faut donc le construire "à la main" à l'aide des variables crées ci-dessus et de ce lien : http://www.commentcamarche.net/contents/1200-bmp-format-bmp
// Initialisation du tableau d'octet
byte[] tableauImageAAfficherByte = new byte[(matricePxl.GetLength(0) * matricePxl.GetLength(1) * 3) + m_tailleOffSetInt];
// Remplissage du tableau d'octet pour les 54 premiers octets composants le HEADER
tableauImageAAfficherByte[0] = 66; //par définition d'un fichier bmp
tableauImageAAfficherByte[1] = 77; //par définition d'un fichier bmp
for (int i = 2; i < 6; i++)
{
tableauImageAAfficherByte[i] = m_tailleFicherByte[i - 2];
}
for (int i = 6; i < 10; i++)
{
tableauImageAAfficherByte[i] = 0; // par définition champs réservé voir site internet
}
for (int i = 10; i < 14; i++)
{
tableauImageAAfficherByte[i] = m_tailleOffSetByte[i - 10];
}
byte[] tailleEnteteByte = { 40, 0, 0, 0 }; // fixé pour les fichiers traités
for (int i = 14; i < 18; i++)
{
tableauImageAAfficherByte[i] = tailleEnteteByte[i - 14];
}
for (int i = 18; i < 22; i++)
{
tableauImageAAfficherByte[i] = m_largeurImageByte[i - 18];
}
for (int i = 22; i < 26; i++)
{
tableauImageAAfficherByte[i] = m_hauteurImageByte[i - 22];
}
tableauImageAAfficherByte[26] = 1; // par définition pour les fichiers bmp
tableauImageAAfficherByte[27] = 0; // par définition pour les fichiers bmp
tableauImageAAfficherByte[28] = m_nombreOctetParCouleurByte; // pour les fichiers que l'on traite c'est toujours 24 bits
tableauImageAAfficherByte[29] = 0; // car l'octet 28 et 29 définissent le nombre de couleur par octet, or cette info est codée en 2 bits
for (int i = 30; i < 34; i++)
{
tableauImageAAfficherByte[i] = 0; // octets pour la compression, ici elle est nulle
}
for (int i = 34; i < 38; i++)
{
tableauImageAAfficherByte[i] = m_tailleImageByte[i - 34];
}
for (int i = 38; i < m_tailleOffSetInt; i++)
{
tableauImageAAfficherByte[i] = 0; // défini à 0 cf le lien internet
}
//for(int i =0; i < tableauImageAAfficherByte.Length; i++)
//{
// Console.WriteLine("¨Pour i = " + i + " l'octet est égale à :" + tableauImageAAfficherByte[i]);
//}
return(tableauImageAAfficherByte);
}
public void ChangementValeurMatriceRGB()
{
for (int i = 0; i < m_hauteurFichierInt; i++)
{
for (int j = 0; j < m_largeurFichierInt; j++)
{
m_matriceRGB[i, j] = new CPixels(11, 22, 33);
}
}
}
public void RemplissageMatriceRGB() // on donne une valeur à chacun de nos pixels
{
// On intègre les octets de m_fileByte dans une matriceRGB de dimension m_hauteurInt et m_largeurInt
int indexFichierInt = 54;
for (int i = 0; i < m_hauteurFichierInt; i++)
{
for (int j = 0; j < m_largeurFichierInt; j++)
{
m_matriceRGB[i, j] = new CPixels(m_fileByte[indexFichierInt], m_fileByte[indexFichierInt + 1], m_fileByte[indexFichierInt + 2]);
indexFichierInt += 3;
}
}
}
public static CPixels[,] tourner180Pxl(CPixels[,] matrice)
{
CPixels memoire = new CPixels();
for (int i = 0; i < (matrice.GetLength(0) / 2); i++)
{
for (int j = 0; j < matrice.GetLength(1); j++)
{
memoire = matrice[i, j];
matrice[i, j] = matrice[(matrice.GetLength(0) - 1 - i), j];
matrice[(matrice.GetLength(0) - 1 - i), j] = memoire;
}
}
return(matrice);
}
public void InitialisationMatriceRGB() // on donne une valeur à chacun de nos pixels
{
// On intègre les octets de m_fileByte dans une matriceRGB de dimension m_hauteurInt et m_largeurInt
int indexFichierInt = m_tailleOffSetInt;
// On lit le file à l'nevers car c'est une convention du BMP, on remet juste l'image a l'endroit
// En d'autres termes, la première ligne dans le fichier correspond à la dernière dans l'image
for (int i = 0; i < m_hauteurFichierInt; i++)
{
for (int j = 0; j < m_largeurFichierInt; j++)
{
m_matriceRGB[i, j] = new CPixels(m_fileByte[indexFichierInt + 2], m_fileByte[indexFichierInt + 1], m_fileByte[indexFichierInt]);
indexFichierInt += 3;
}
}
}
public static CPixels[,] MatriceImage2couleurs()
{
CPixels[,] matriceImage = new CPixels[6, 8];
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 8; j++)
{
matriceImage[i, j] = new CPixels(255, 0, 0);
}
}
for (int i = 3; i < 6; i++)
{
for (int j = 0; j < 8; j++)
{
matriceImage[i, j] = new CPixels(0, 0, 0);
}
}
return(matriceImage);
}
public CPixels[,] FiltreEstampage_Pxl()
{
CPixels[,] matriceRGB_Returned = new CPixels[m_matriceRGB.GetLength(0), m_matriceRGB.GetLength(1)];
// On s'appuie sur le site : http://tavmjong.free.fr/INKSCAPE/MANUAL/html_fr/Filters-Pixel.html
// La matrice permettant de faire l'estampage est [{-2,0,0};{0,1,0};{0,0,2}]
// Pour ce filtre, il suffit à partir du pixel initial situé en [i,j] de prendre,
// Le pixel en [i-1,j-1] et en [i+1,j+1]
// Donc en [0,0] et en [Get(0),Get(1)] ce calcul sera impossible et égal à 0
try
{
int resultatPixelRougeInt = Int32.MinValue;
int pixelRougeEnHautGaucheInt = Int32.MinValue; // car va contenir une valeur négative
int resultatPixelVertInt = Int32.MinValue;
int pixelVertEnHautGaucheInt = Int32.MinValue; // car va contenir une valeur négative
int resultatPixelBleuInt = Int32.MinValue;
int pixelBleuEnHautGaucheInt = Int32.MinValue; // car va contenir une valeur négative
for (int i = 0; i < matriceRGB_Returned.GetLength(0); i++)
{
for (int j = 0; j < matriceRGB_Returned.GetLength(1); j++)
{
//Pour les frontières on les initialise à 0
if (i == 0)
{
matriceRGB_Returned[i, j] = new CPixels();
//Console.WriteLine("Je passe i=0 en [" + i + "," + j + "]");
}
else if (j == 0)
{
matriceRGB_Returned[i, j] = new CPixels();
//Console.WriteLine("Je passe j = 0 en [" + i + "," + j + "]");
}
else if (i == matriceRGB_Returned.GetLength(0) - 1)
{
matriceRGB_Returned[i, j] = new CPixels();
//Console.WriteLine("Je passe i = Get(0) en [" + i + "," + j + "]");
}
else if (j == matriceRGB_Returned.GetLength(1) - 1)
{
matriceRGB_Returned[i, j] = new CPixels();
//Console.WriteLine("Je passe j = Get(1) en [" + i + "," + j + "]");
}
else
{
//Pour le pixel Bleu
pixelBleuEnHautGaucheInt = m_matriceRGB[i - 1, j - 1].PixelBleuByte * (-2);
resultatPixelBleuInt = (pixelBleuEnHautGaucheInt + m_matriceRGB[i, j].PixelBleuByte + m_matriceRGB[i + 1, j + 1].PixelBleuByte * 2) / 3; //stockage dans le pixel initial
//Pour le pixel Vert
pixelVertEnHautGaucheInt = m_matriceRGB[i - 1, j - 1].PixelVertByte * (-2);
resultatPixelVertInt = (pixelVertEnHautGaucheInt + m_matriceRGB[i, j].PixelVertByte + m_matriceRGB[i + 1, j + 1].PixelVertByte * 2) / 3; //stockage dans le pixel initial
//Pour le pixel Rouge
pixelRougeEnHautGaucheInt = m_matriceRGB[i - 1, j - 1].PixelRougeByte * (-2);
resultatPixelRougeInt = (pixelRougeEnHautGaucheInt + m_matriceRGB[i, j].PixelRougeByte + m_matriceRGB[i + 1, j + 1].PixelRougeByte * 2) / 3; //stockage dans le pixel initial
// Construction de la nouvelle matrice en lui applicant le nouveau pixel
//Console.WriteLine("Pixel bleu : " + resultatPixelBleuInt);
//Console.WriteLine("Pixel vert : " + resultatPixelVertInt);
//Console.WriteLine("Pixel rouge : " + resultatPixelRougeInt);
if (resultatPixelBleuInt < 0)
{
resultatPixelBleuInt = -1 * resultatPixelBleuInt;
}
if (resultatPixelVertInt < 0)
{
resultatPixelVertInt = -1 * resultatPixelVertInt;
}
if (resultatPixelRougeInt < 0)
{
resultatPixelRougeInt = -1 * resultatPixelRougeInt;
}
//Console.WriteLine("Pixel bleu : " + resultatPixelBleuInt);
//Console.WriteLine("Pixel vert : " + resultatPixelVertInt);
//Console.WriteLine("Pixel rouge : " + resultatPixelRougeInt);
matriceRGB_Returned[i, j] = new CPixels(Convertir_Int_To_Byte(resultatPixelBleuInt), Convertir_Int_To_Byte(resultatPixelVertInt), Convertir_Int_To_Byte(resultatPixelRougeInt));
}
//Console.ReadKey();
}
}
}
catch (Exception e)
{
Console.WriteLine("ERREUR dans méthode FiltreEstampage_Pxl()");
Console.WriteLine(e.Message);
}
return(matriceRGB_Returned);
}
/// <summary>
/// Cette fonction permet de renforcer les bords d'une image
/// </summary>
/// <returns></returns>
public CPixels[,] RenforcementDesBords_Pxl()
{
CPixels[,] matriceRGB_Returned = new CPixels[m_matriceRGB.GetLength(0), m_matriceRGB.GetLength(1)];
try
{
// On s'appuie sur le site : https://docs.gimp.org/fr/plug-in-convmatrix.html
// La matrice permettant de faire le renforcement des bords est [{0,0,0};{-1,1,0};{0,0,0}]
// Donc il suffit simplement de multiplier le pixel a gauche du pixel initial par -1 et par 1 le pixel initial,
// Il y aura donc un problème de frontière que sur la premiere colonne !!!!
// Dans un premier temps, on s'occupe de toute la matrice sauf la première colonne
int resultatPixelRougeInt = Int32.MinValue;
int pixelRougeAGaucheInt = Int32.MinValue;
int resultatPixelVertInt = Int32.MinValue;
int pixelVertAGaucheInt = Int32.MinValue;
int resultatPixelBleuInt = Int32.MinValue;
int pixelBleuAGaucheInt = Int32.MinValue;
for (int i = 0; i < m_matriceRGB.GetLength(0); i++)
{
for (int j = 1; j < m_matriceRGB.GetLength(1); j++)
{
//Pour le pixel Bleu
pixelBleuAGaucheInt = m_matriceRGB[i, j - 1].PixelBleuByte * (-1); // on multiplie par -1 d'après la matrice de convolution
resultatPixelBleuInt = pixelBleuAGaucheInt + m_matriceRGB[i, j].PixelBleuByte; // ici on a donc appliqué la matrice de convolution pour le renforcement des bords
//Pour le pixel Vert
pixelVertAGaucheInt = m_matriceRGB[i, j - 1].PixelVertByte * (-1); // on multiplie par -1 d'après la matrice de convolution
resultatPixelVertInt = pixelVertAGaucheInt + m_matriceRGB[i, j].PixelVertByte; // ici on a donc appliqué la matrice de convolution pour le renforcement des bords
//Pour le pixel Rouge
pixelRougeAGaucheInt = m_matriceRGB[i, j - 1].PixelRougeByte * (-1); // on multiplie par -1 d'après la matrice de convolution
resultatPixelRougeInt = pixelRougeAGaucheInt + m_matriceRGB[i, j].PixelRougeByte; // ici on a donc appliqué la matrice de convolution pour le renforcement des bords
// Construction de la nouvelle matrice en lui applicant le nouveau pixel
//Console.WriteLine("Pixel bleu : " + resultatPixelBleuInt);
//Console.WriteLine("Pixel vert : " + resultatPixelVertInt);
//Console.WriteLine("Pixel rouge : " + resultatPixelRougeInt);
if (resultatPixelBleuInt <= 0)
{
resultatPixelBleuInt = -1 * resultatPixelBleuInt;
}
if (resultatPixelVertInt <= 0)
{
resultatPixelVertInt = -1 * resultatPixelVertInt;
}
if (resultatPixelRougeInt <= 0)
{
resultatPixelRougeInt = -1 * resultatPixelRougeInt;
}
//Console.WriteLine("Pixel bleu : " + resultatPixelBleuInt);
//Console.WriteLine("Pixel vert : " + resultatPixelVertInt);
//Console.WriteLine("Pixel rouge : " + resultatPixelRougeInt);
matriceRGB_Returned[i, j] = new CPixels(Convertir_Int_To_Byte(resultatPixelBleuInt), Convertir_Int_To_Byte(resultatPixelVertInt), Convertir_Int_To_Byte(resultatPixelRougeInt));
//Console.ReadKey();
}
}
for (int i = 0; i < m_matriceRGB.GetLength(0); i++)
{
for (int j = 0; j < 1; j++)
{
matriceRGB_Returned[i, j] = new CPixels(); // on initialise à 0
}
}
}
catch (Exception e)
{
Console.WriteLine("ERREUR DANS RenforcementDesBordsPxl() ");
Console.WriteLine(e.Message);
}
return(matriceRGB_Returned);
}
public static CPixels[,] RemplissageMatriceInitial_M()
{
CPixels[,] m_matriceInitialPrenom = new CPixels[240, 240]; // TAILLE Image a choisir, attention largeur doit etre un multiple de 4
//On parcourt la matrice colonne par colonne
//On forme un premier rectangle
for (int j = 0; j < (m_matriceInitialPrenom.GetLength(1) / 5); j++)
{
for (int i = 0; i < m_matriceInitialPrenom.GetLength(0); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 255, 0);
}
}
// On forme la première diagonale descendante de la lettre M
int decalageInt = 0;
for (int j = (m_matriceInitialPrenom.GetLength(1) / 5); j < (m_matriceInitialPrenom.GetLength(1) / 2); j++)
{
for (int i = 0; i <= decalageInt; i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 0, 0);
}
decalageInt++;
for (int i = decalageInt; i < (decalageInt + (m_matriceInitialPrenom.GetLength(1) / 4)); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 255, 0);
}
for (int i = (decalageInt + (m_matriceInitialPrenom.GetLength(1) / 4)); i < m_matriceInitialPrenom.GetLength(0); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 0, 0);
}
// ICI on parcouru toute une colonne de la matrice
}
//ICI on va s'attaquer maintenant à la diagonale montante de la lettre M
#region 1er jet
for (int j = (m_matriceInitialPrenom.GetLength(1) / 2); j < (m_matriceInitialPrenom.GetLength(1) - (m_matriceInitialPrenom.GetLength(1) / 5)); j++)
{
if (decalageInt != 0)
{
decalageInt--;
}
for (int i = 0; i < decalageInt; i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 0, 0);
}
for (int i = decalageInt; i < (decalageInt + (m_matriceInitialPrenom.GetLength(1) / 4)); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 255, 0);
}
for (int i = (decalageInt + (m_matriceInitialPrenom.GetLength(1) / 4)); i < m_matriceInitialPrenom.GetLength(0); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 0, 0);
}
#endregion
//ICI on a parcouru toute une colonne de la matrice
}
//ICI on a fini la diagonale montante, on s'attaque au dernier rectangle de la lettre M
for (int j = (m_matriceInitialPrenom.GetLength(1) - (m_matriceInitialPrenom.GetLength(1) / 5)); j < m_matriceInitialPrenom.GetLength(1); j++)
{
for (int i = 0; i < m_matriceInitialPrenom.GetLength(0); i++)
{
m_matriceInitialPrenom[i, j] = new CPixels(0, 255, 0);
}
} // On a terminé de parcourir toute notre matrice (image)
CPixels memoire = new CPixels();
for (int i = 0; i < m_matriceInitialPrenom.GetLength(0); i++)
{
for (int j = 0; j < m_matriceInitialPrenom.GetLength(1); j++)
{
memoire = m_matriceInitialPrenom[i, j];
m_matriceInitialPrenom[i, j] = m_matriceInitialPrenom[(m_matriceInitialPrenom.GetLength(0) - 1 - i), j];
m_matriceInitialPrenom[(m_matriceInitialPrenom.GetLength(0) - 1 - i), j] = memoire;
}
}
//AfficherMatricePxl(m_matriceInitialPrenom);
m_matriceInitialPrenom = tourner180Pxl(m_matriceInitialPrenom); // lecture en little endian, besoin de renverser la matrice pour que la lecture se fasse dans le bon sens
//Console.WriteLine();
//AfficherMatricePxl(m_matriceInitialPrenom);
return(m_matriceInitialPrenom);
}
