essai_optimisation

#include <stdlib.h>/* Chargement des bibliothèque */
#include <stdio.h>
#include <math.h>
#include "libimage.h"
#include "libimage.c"

#define NOM_IMAGE "dendrites.ppm" /* les paramètres de l'image*/
#define LARGEUR 150               /* on peut modifier la largeur en modifiant le chiffre*/
#define HAUTEUR 150               /* on peut modifier la hauteur en modifiant le chiffre*/
#define GRAINE 100                /* on peut modifier le pas de nombre aléatoire en modifiant le nombre de graines*/

/*Fonctions usuelles aux programmes données dans le sujet */

/* Le générateur de nombres pseudo-aléatoires */
static unsigned long suivant = 1;

#define ALEA_MAX 32767

int alea(void)
{
    suivant = suivant * 1103515245 + 12345;
    return ((unsigned)(suivant / 65536) % 32768);
}

void init_alea(unsigned int graine)
{
    suivant = graine;
}

typedef struct /* stockage des coordonnées d'un point généré */
{
    int x;
    int y;
} point;

int lance_de(int n) /* simulation du lancement d'un dé à n faces */
{
    int diviseur = ALEA_MAX / n;
    int res;
    do
    {
        res = alea() / diviseur;
    } while (res > n - 1);
    return res + 1;
}

point point_au_hasard() // A ETE MODIFIE, juste caster la structure de sortie
{
    return (point) { lance_de(LARGEUR) - 1, lance_de(HAUTEUR) - 1 }
}

point torique(point Ivrogne) // A ETE MODIFIE: J'ai utilise les ternaires, plus pratiques
{

    Ivrogne.x = (Ivrogne.x > LARGEUR - 1) ? Ivrogne.x - LARGEUR : Ivrogne.x < 0 ?  Ivrogne.x + LARGEUR : Ivrogne.x;
    Ivrogne.y = (Ivrogne.y > HAUTEUR - 1) ? Ivrogne.y - HAUTEUR : Ivrogne.y < 0 ?  Ivrogne.y + HAUTEUR : Ivrogne.y;
    return Ivrogne;
}

int point_noir(image im, point Ivrogne) // A ETE MODIFIE
{
    point p0 = (point){Ivrogne.x, Ivrogne.y};
    point p1 = (point){p0.x - 1, p0.y - 1};
    p1 = torique(p1);
    point p2 = (point){p0.x, p0.y - 1};
    p2 = torique(p2);

    point p3 = (point){p0.x + 1, p0.y - 1};
    p3 = torique(p3);

    point p4 = (point){p0.x - 1, p0.y};
    p4 = torique(p4);

    point p5 = (point){p0.x + 1, p0.y};
    p5 = torique(p5);

    point p6 = (point){p0.x - 1, p0.y + 1};
    p6 = torique(p6);

    point p7 = (point){p0.x, p0.y + 1};
    p7 = torique(p7);

    point p8 = (point){p0.x + 1, p0.y + 1};
    p8 = torique(p8);

    int accept = 0;

    /*Test cases environnantes et ériture le cas échéant*/
    couleur c[9] = { lire_couleur(im, p0.x, p0.y), lire_couleur(im, p1.x, p1.y), lire_couleur(im, p2.x, p2.y),
                     lire_couleur(im, p3.x, p3.y), lire_couleur(im, p4.x, p4.y), lire_couleur(im, p5.x, p5.y),
                     lire_couleur(im, p6.x, p6.y), lire_couleur(im, p7.x, p7.y), lire_couleur(im, p8.x, p8.y)
    };

    (c[0].bleu + c[0].rouge + c[0].vert) == (255 * 3) ?  accept++ : NULL;
    (c[1].bleu + c[1].rouge + c[1].vert) == (255 * 3) ?  accept++ : NULL;
    (c[2].bleu + c[2].rouge + c[2].vert) == (255 * 3) ?  accept++ : NULL;
    (c[3].bleu + c[3].rouge + c[3].vert) == (255 * 3) ?  accept++ : NULL;
    (c[4].bleu + c[4].rouge + c[4].vert) == (255 * 3) ?  accept++ : NULL;
    (c[5].bleu + c[5].rouge + c[5].vert) == (255 * 3) ?  accept++ : NULL;
    (c[6].bleu + c[6].rouge + c[6].vert) == (255 * 3) ?  accept++ : NULL;
    (c[7].bleu + c[7].rouge + c[7].vert) == (255 * 3) ?  accept++ : NULL;
    (c[8].bleu + c[8].rouge + c[8].vert) == (255 * 3) ?  accept++ : NULL;

    return accept;
}

int main()
{
    int compteur_dendrites = 0; /*Declaration des variables*/
    int Surface, i, j;
    int accept = 0;

    init_alea(GRAINE); /*initialisation alea*/

    image im = nouvelle_image(LARGEUR, HAUTEUR);

    point Point_centre = (point){floor(LARGEUR / 2), floor(HAUTEUR / 2) }; //ANCIEN A ETE MODIFIE

    point Ivrogne;

    Surface = HAUTEUR * LARGEUR;

    couleur blanc = (couleur){255, 255, 255};//ANCIEN A ETE MODIFIE

    couleur noir = (couleur){0, 0, 0};

    /*démarrage du programme*/
    for (i = 0; i < LARGEUR; i++) /*création du fond en blanc*/
    {
        for (j = 0; j < HAUTEUR; j++)
        {
            change_couleur(im, i, j, blanc);
        }
    }
    change_couleur(im, Point_centre.x, Point_centre.y, noir); /*Coloration en noir du germe en centre de page*/
    while (compteur_dendrites < Surface / 5)                  /*on peut faire varier le % de surface en  modifiant le diviseur*/
    {
        while (accept < 9) /*règle limitante: le point n'est pas proche d'un point noir*/
        {
            Ivrogne = point_au_hasard(); /*caractéristiques des ivrognes*/
            Ivrogne = torique(Ivrogne);
            accept = point_noir(im, Ivrogne);
        }
        while (accept == 9) //ANCIEN A ETE MODIFIE (voir ci-dessous)
        {
            switch (lance_de(8)) /* règle d'ecriture des coordonnées pour chaque nouvelle case générée*/
            {
            case 1:
                Ivrogne = (point) { Ivrogne.x - 1, Ivrogne.y - 1 };
                break;
            case 2:
                Ivrogne = (point){Ivrogne.x, Ivrogne.y - 1};
                break;
            case 3:
                Ivrogne = (point){Ivrogne.x + 1, Ivrogne.y - 1};
                break;
            case 4:
                Ivrogne = (point){Ivrogne.x - 1, Ivrogne.y};
                break;
            case 5:
                Ivrogne = (point){Ivrogne.x + 1, Ivrogne.y};
                break;
            case 6:
                Ivrogne = (point){Ivrogne.x - 1, Ivrogne.y + 1};
                break;
            case 7:
                Ivrogne = (point){Ivrogne.x , Ivrogne.y + 1};
                break;
            case 8:
                Ivrogne = (point){Ivrogne.x + 1, Ivrogne.y + 1};
                break;
            default:
                printf("Erreur fonction (lance_de())");
                break;
            }
            Ivrogne = torique(Ivrogne);
            accept = point_noir(im, Ivrogne);
        }
        change_couleur(im, Ivrogne.x, Ivrogne.y, noir);
        compteur_dendrites++;
        printf("Compteur creation pixel noir: %d \n", compteur_dendrites);
    }
    ecrire_image(im, NOM_IMAGE); /* nommer l'image générée*/
    detruire_image(im);          /*écraser l'image existante si non renommée*/
    return (0);
}