TD5P2

////////////////////////////////////////////////////////////////////////////////
/// VOTRE ENTÊTE ICI
////////////////////////////////////////////////////////////////////////////////


#pragma region "Inclusions" //{

#include <ciso646>
#include <cstddef>
#include <cstdint>

#include <fstream>
#include <string>

#include <iostream>

#include "CodeFourni.hpp"

#include "CodeDemande.hpp"


using namespace std;

#pragma endregion //}




#pragma region "Globaux" //{

#pragma region "Fonctions" //{

EnteteDib lireEnteteFichier ( fstream& fichier )
{
    EnteteBmp enteteBmp;
    enteteBmp = construireBmpVide();
    EnteteDib enteteDib;
    enteteDib = construireDibVide();

    fichier.seekg(0, ios::beg);

    fichier.read((char*)&enteteBmp, sizeof(enteteBmp));

    fichier.read((char*)&enteteDib, sizeof(enteteDib));


    return enteteDib;
}


void lireDonneesImage ( fstream& fichier, Image& image )
{
    ///pas necessair, image est pas vide
//  EnteteDib enteteDib = lireEnteteFichier(fichier);
//  enteteDib.hauteurImage = image.hauteur;
//enteteDib.largeurImage = image.largeur;
    Pixel pixel;
    fichier.seekg(2, ios::beg);

    for (int i = 0; i < image.hauteur; i++) {
        for (int j = 0; j < image.largeur; j++) {
            fichier.read((char*)&pixel, sizeof(pixel));
        }
        int tailleP = calculerTaillePadding(image);
        fichier.seekg(tailleP, ios::cur);
    }






    // TODO: Se positionner au début du tableau de pixels dans le fichier.
    // TODO: Pour chaque ligne de l'image, lire la ligne et sauter le padding.
}


void ecrireDonneesImage ( fstream& fichier, const Image& image )
{

    fichier.seekg(2, ios::beg);
    // TODO: Se positionner au début du tableau de pixels dans le fichier (après
    //       les entêtes).

    for (int i = image.hauteur; i > 0; i--) {
        for (int j = 0; j < image.largeur; j++) {
            fichier.write((char*)&image.pixels[i-1][j], sizeof(image.pixels[i - 1][j]));
        }
        for (int j = 0; j < calculerTaillePadding(image); j++) {
            ///fichier.write((char*)&//, sizeof(//);
        }
    }

    // TODO: Pour chaque ligne de l'image, écrire la ligne puis écrire des bytes
    //       à zéro pour le padding.
}


void ecrireImage ( const string& nomFichier, const Image& image, bool& ok ) ///GOOD
{
    // TODO: Ouvrir un fichier en écriture binaire.
    fstream sortie;
    sortie.open(nomFichier, ios::binary);




    // Si l'ouverture n'a pas échouée :
    if (sortie.fail == false) {

        // TODO: Construire les entêtes à partir de l'image.
        EnteteBmp enteteBmp = construireEnteteBmp(image);
        EnteteDib enteteDib = construireEnteteDib(image);
        // TODO: Écrire les entêtes dans le fichier.
        sortie.write((char*)&enteteBmp, sizeof(enteteBmp));
        sortie.write((char*)&enteteDib, sizeof(enteteDib));
        // TODO: Écrire les données (pixels) de l'image dans le fichier.
        ecrireDonneesImage(sortie, image);
    }

}


Image allouerImage ( unsigned largeur, unsigned hauteur )
{
    ///
    Image image;
    if (largeur != 0 && hauteur != 0) {

        image.hauteur = hauteur;
        image.largeur = largeur;

        Pixel** pixel2D;
        pixel2D = new Pixel*[hauteur];

        for (int i = 0; i < hauteur; i++) {
            pixel2D[i] = new Pixel[largeur];
        }
        image.pixels = pixel2D;
        return image;
    }
    else {
        return image;
    }
    // Si la largeur ET la hauteur ne sont pas nulles :
        // TODO: Affecter les dimensions à l'image.

        // TODO: Allouer un tableau dynamique de pixels pour l'image.
        //       On veut Image::hauteur de lignes qui ont chacune
        //       Image::largeur de pixels.
}


void desallouerImage ( Image& image )
{
    if (image.pixels != 0) {
        for (int i = 0; i < image.hauteur; i++) {

            delete[] image.pixels[i];


        }
        delete[] image.pixels;
        image.pixels = 0;
    }
    // Si le tableau dynamique de l'image n'est pas nul :
        // TODO: Désallouer le tableau 2D.
}


Image copierImage ( const Image& image )
{
    // TODO: Allouer une image de la même taille que celle donnée.
    Image imageRetour;
    imageRetour = allouerImage(image.largeur, image.hauteur);


    for (int i = 0; i < image.hauteur; i++) {
        for (int j = 0; j < image.largeur; j++) {
            imageRetour.pixels[i][j] = image.pixels[i][j];
        }
    }
    // TODO: Copier tous les pixels.
}


Image lireImage ( const string& nomFichier, bool& ok )
{
    // TODO: Ouvrir le fichier en lecture binaire.
    fstream inBin(nomFichier,  ios::binary);

    if (inBin.fail() == false) {
        EnteteDib enteteDib = lireEnteteFichier(inBin);
        allouerImage(enteteDib.largeurImage, enteteDib.hauteurImage);

    }
    else {
        cout << "Erreur d'ouverture" << endl;
    }
    // Si l'ouverture n'a pas échouée :
        // TODO: Lire l'entête DIB.

        // TODO: Allouer une image selon le contenu du DIB.

        // TODO: Lire les pixels du fichier.
}


Image extraireRectangle ( const Image& image, const Rectangle& zone )
{
    // Si la zone demandée est valide :
        // TODO: Allouer une image de la taille de la zone à extraire.

        // TODO: Copier les pixels de la zone.
}

#pragma endregion //}

#pragma endregion //}