Mesh PaterneQuad::remplissageCoin(const int& indicePointCoin, Vector2D& point1Batiment, Vector2D& pointCentre, Vector2D& point3Batiment)
{
    /*
    point1  X----X  point2
            |    |
            |    |
    point0  X----X  point3
    */

    Quadrangle centreTmp = *this;

    // Taille aléatoire
    float aleatoire = (rand()%100) / 100.0;
    centreTmp.shrink( _par->minLargeurBatiment + aleatoire*(coeffShrinkMax()-_par->minLargeurBatiment-_par->largeurRuelle) );
    //

    pointCentre = centreTmp[indicePointCoin];

    Vector2D shrink = pointCentre - get(indicePointCoin);
    Vector2D pIpIm1 = get((indicePointCoin-1)%4) - get(indicePointCoin);
    Vector2D pIpIp1 = get((indicePointCoin+1)%4) - get(indicePointCoin);

    pIpIm1.normalise(); pIpIp1.normalise();

    // disposition des points en losange

    float dpIpIm1 = shrink.scalareProduct(pIpIm1);
    dpIpIm1 = shrink.getNorm()*shrink.getNorm() / (dpIpIm1*2);

    if(dpIpIm1 >= (get((indicePointCoin-1)%4) - get(indicePointCoin)).getNorm()/2)
        dpIpIm1 = (get((indicePointCoin-1)%4) - get(indicePointCoin)).getNorm()/2 - _par->largeurRuelle/2;

    float dpIpIp1 = shrink.scalareProduct(pIpIp1);
    dpIpIp1 = shrink.getNorm()*shrink.getNorm() / (dpIpIp1*2);

    if(dpIpIp1 >= (get((indicePointCoin+1)%4) - get(indicePointCoin)).getNorm()/2)
        dpIpIp1 = (get((indicePointCoin+1)%4) - get(indicePointCoin)).getNorm()/2 - _par->largeurRuelle/2;

    point1Batiment = get(indicePointCoin) + pIpIp1*dpIpIp1;
    point3Batiment = get(indicePointCoin) + pIpIm1*dpIpIm1;
    Batiment b = Batiment(Vector3D(get(indicePointCoin).x, get(indicePointCoin).y, 0),
                          Vector3D(point1Batiment.x, point1Batiment.y, 0),
                          Vector3D(pointCentre.x, pointCentre.y, 0),
                          Vector3D(point3Batiment.x, point3Batiment.y, 0),
                          _par);
    return b.generate();

}
void PaterneQuad::faireTrotoir(Mesh& m){

    Quadrangle centre = *this, notreQuadrangle = *this;
    centre.shrink(_par->largeurTrotoir);

    for(int i=0; i<4; i++){
        m.addTriangle( Vector3D(notreQuadrangle[i].x, notreQuadrangle[i].y, 0),
                       Vector3D(notreQuadrangle[(i-1)%4].x, notreQuadrangle[(i-1)%4].y, 0),
                Vector3D(centre[i].x, centre[i].y, 0) );

        m.addTriangle( Vector3D(centre[i].x, centre[i].y, 0),
                       Vector3D(notreQuadrangle[(i-1)%4].x, notreQuadrangle[(i-1)%4].y, 0),
                Vector3D(centre[(i-1)%4].x, centre[(i-1)%4].y, 0) );
    }

    this->shrink(_par->largeurTrotoir);
}
Mesh PaterneQuad::paternTroisBatiment(){

    Mesh retour;

    Quadrangle centre = *this, notreQuadrangle = *this;


    /************ Batiment Principal ********************/

    Vector2D p0p3 = notreQuadrangle[3] - notreQuadrangle[0];
    Vector2D p1p2 = notreQuadrangle[2] - notreQuadrangle[1];

    Vector2D p2p1 = notreQuadrangle[1] - notreQuadrangle[2];
    Vector2D p2p3 = notreQuadrangle[3] - notreQuadrangle[2];

    Vector2D p3p2 = notreQuadrangle[2] - notreQuadrangle[3];
    Vector2D p3p0 = notreQuadrangle[0] - notreQuadrangle[3];

    p0p3.normalise(); p1p2.normalise();
    p2p1.normalise(); p2p3.normalise();
    p3p2.normalise(); p3p0.normalise();

    // Taille aléatoire
    float aleatoire = (rand()%100) / 100.0;
    centre.shrink( (1-aleatoire)*_par->minLargeurBatiment + aleatoire*(coeffShrinkMax()-_par->largeurRuelle) );
    //

    float dp0p3 = (centre[0]-notreQuadrangle[0]).scalareProduct(p0p3);
    dp0p3 = (centre[0]-notreQuadrangle[0]).getNorm()*(centre[0]-notreQuadrangle[0]).getNorm() / (dp0p3*2);

    if(dp0p3 >= (notreQuadrangle[3]-notreQuadrangle[0]).getNorm()/2)
        dp0p3 = (notreQuadrangle[3]-notreQuadrangle[0]).getNorm()/2 - _par->largeurRuelle/2;

    float dp1p2 = (centre[1]-notreQuadrangle[1]).scalareProduct(p1p2);
    dp1p2 = (centre[1]-notreQuadrangle[1]).getNorm()*(centre[1]-notreQuadrangle[1]).getNorm() / (dp1p2*2);

    if(dp1p2 >= (notreQuadrangle[2]-notreQuadrangle[1]).getNorm()/2)
        dp1p2 = (notreQuadrangle[2]-notreQuadrangle[1]).getNorm()/2 - _par->largeurRuelle/2;

    Vector2D p3B1 = notreQuadrangle[1] + p1p2*dp1p2;
    Vector2D p4B1 = notreQuadrangle[0] + p0p3*dp0p3;
    Batiment b = Batiment(
                Vector3D(notreQuadrangle[0].x, notreQuadrangle[0].y, 0),
                Vector3D(notreQuadrangle[1].x, notreQuadrangle[1].y, 0),
                Vector3D(p3B1.x, p3B1.y, 0),
                Vector3D(p4B1.x, p4B1.y, 0),
                _par);
    retour.merge( b.generate() );


    //////////////////////////////////////

    Quadrangle batiments[2];

    retour.merge(remplissageCoin(2, batiments[0][1], batiments[0][2], batiments[0][3]));
    retour.merge(remplissageCoin(3, batiments[1][1], batiments[1][2], batiments[1][3]));

    retour.merge(remplissageBord(p3B1, centre[1], batiments[0][2], batiments[0][3] ));
    retour.merge(remplissageBord(batiments[0][1], batiments[0][2], batiments[1][2], batiments[1][3] ));
    retour.merge(remplissageBord(batiments[1][1], batiments[1][2], centre[0], p4B1 ));

    return retour;
}
Mesh PaterneQuad::paternDeuxBatimentDiagonale(){

    Mesh retour;

    Quadrangle centre = *this, notreQuadrangle = *this;

    // Taille aléatoire
    float aleatoire = (rand()%100) / 100.0;
    float coeffShrink = (1-aleatoire)*_par->minLargeurBatiment + aleatoire*(coeffShrinkMax()/2-_par->largeurRuelle);
    //

    centre.shrink( coeffShrink );

    Vector2D p1p0 = notreQuadrangle[0] - notreQuadrangle[1];
    Vector2D p3p2 = notreQuadrangle[2] - notreQuadrangle[3];

    p1p0.normalise();
    p3p2.normalise();

    float dp1p0 = (centre[1]-notreQuadrangle[1]).scalareProduct(p1p0);
    float dp3p2 = (centre[3]-notreQuadrangle[3]).scalareProduct(p3p2);



    Vector2D p2p1 = notreQuadrangle[1] - notreQuadrangle[2];
    p2p1.normalise();

    Vector2D p2B1 = notreQuadrangle[1] + p1p0*dp1p0;
    Vector2D centre2Bis = centre[2] + (p2p1*(_par->largeurRuelle/2));

    Batiment b = Batiment(
                Vector3D(notreQuadrangle[0].x + (-p1p0.x*(_par->largeurRuelle/2)) , notreQuadrangle[0].y + (-p1p0.y*(_par->largeurRuelle/2)), 0),
            Vector3D(p2B1.x, p2B1.y, 0),
            Vector3D(p2B1.x+((centre2Bis-p2B1).normalised()*coeffShrink).x, p2B1.y+((centre2Bis-p2B1).normalised()*coeffShrink).y, 0),
            Vector3D(centre[0].x + (-p1p0.x*(_par->largeurRuelle/2)), centre[0].y + (-p1p0.y*(_par->largeurRuelle/2)), 0),
            _par);
    retour.merge( b.generate() );


    b = Batiment(Vector3D(notreQuadrangle[1].x, notreQuadrangle[1].y, 0),
            Vector3D(notreQuadrangle[2].x + (p2p1.x*(_par->largeurRuelle/2)), notreQuadrangle[2].y + (p2p1.y*(_par->largeurRuelle/2)), 0),
            Vector3D(centre2Bis.x, centre2Bis.y, 0),
            Vector3D(p2B1.x, p2B1.y, 0),
            _par);
    retour.merge( b.generate() );


    Vector2D p0p3 = notreQuadrangle[3] - notreQuadrangle[0];
    p0p3.normalise();

    Vector2D p2B3 = notreQuadrangle[3] + p3p2*dp3p2;
    Vector2D centre0Bis = centre[0] + (p0p3*(_par->largeurRuelle/2));

    b = Batiment(Vector3D(notreQuadrangle[2].x + (-p3p2.x*(_par->largeurRuelle/2)), notreQuadrangle[2].y + (-p3p2.y*(_par->largeurRuelle/2)), 0),
            Vector3D(p2B3.x, p2B3.y, 0),
            Vector3D(p2B3.x+((centre0Bis-p2B3).normalised()*coeffShrink).x, p2B3.y+((centre0Bis-p2B3).normalised()*coeffShrink).y, 0),
            Vector3D(centre[2].x + (-p3p2.x*(_par->largeurRuelle/2)), centre[2].y + (-p3p2.y*(_par->largeurRuelle/2)), 0),
            _par);
    retour.merge( b.generate() );

    b = Batiment(Vector3D(notreQuadrangle[3].x, notreQuadrangle[3].y, 0),
            Vector3D(notreQuadrangle[0].x + (p0p3*(_par->largeurRuelle/2)).x, notreQuadrangle[0].y + (p0p3*(_par->largeurRuelle/2)).y, 0),
            Vector3D(centre0Bis.x, centre0Bis.y, 0),
            Vector3D(p2B3.x, p2B3.y, 0),
            _par);
    retour.merge( b.generate() );

    return retour;

}