# -*- coding: utf-8 -*-
"""
Created on Fri Jan 23 13:08:19 2015

@author: Mélaine and Arthur
"""
#programme annexe pour copier une liste
def copie(a):
    b= []
    for i in a:
        b.append(i)
    return b

salle = [[]]
def carte(L,l,p): #on definit la salle, longueur/largeur, position de la porte
    salle[0] = [L,l,p]
    return salle

def obstacle(p,T): #on définit l'obstacle par son coin de plus petite coordonnées+ sa longueur et sa largeur
    salle.append([p,T])
    return salle
"""NB: on pourrait changer et mettre des polygones pour les obstacles, mais ce serait plus
compliquer à definir, il faudrait les 4 points. Si on change, bcp de fonction seront à changer
a voir"""

#salle1 = carte(25,30,[14,0])
#obstacle([10,4],[10,4])
#obstacle([15,12],[4,8])
#obstacle([4,18],[3,9])


def quad_salle(salle,t): #qd teste: quad_salle(salle[0],t) on veut juste les dim
    longueur= salle[0]
    largeur = salle[1]
    if longueur % t == 0: #t = taille de chaque case
        i = longueur // t
    else:
        i = longueur//t +1
    if largeur % t == 0:
        j = largeur // t
    else:
        j = largeur//t +1
    quad = [i,j,t]
    return quad

def placement_dans_quadrillage_pour_les_obstacles(obstacle,quad):
    longueur= obstacle[1][0]
    largeur = obstacle[1][1]
    abscisse= obstacle[0][0]
    ordonnee= obstacle[0][1]
    t =  quad[2]
    i1= abscisse//t
    i2= (abscisse+longueur)//t
    j1= ordonnee//t
    j2= (ordonnee+largeur)//t
    obstacle.append([[i1,i2],[j1,j2]])
    return obstacle

def quadrillage_salle_obstacle(salle):
     case = quad_salle(salle[0],5) #on choisit de quadriller avec des cases des 5 m
     for i in range (1,len(salle)):
         obstacle=placement_dans_quadrillage_pour_les_obstacles(salle[i],case)
         salle[i]= obstacle
     return salle

#quadrillage_salle_obstacle(salle1)

from PIL import Image, ImageDraw
def dessin(salle):
    dessin_salle = Image.new("RGB",((salle[0][0]+1)*100,(salle[0][1]+1)*100), "white")
    draw = ImageDraw.Draw(dessin_salle)
    draw.line((0*100,0*100,0*100,salle[0][1]*100),fill=128)
    draw.line((0*100,0*100,salle[0][0]*100,0*100),fill=128)
    draw.line((0*100,salle[0][1]*100,salle[0][0]*100,salle[0][1]*100),fill=128)
    draw.line((salle[0][0]*100,0*100,salle[0][0]*100,salle[0][1]*100),fill=128)
    draw.rectangle(((salle[0][2][0]-0.5)*100,0*100,(salle[0][2][0]+0.5)*100,0.5*100), fill = 255) #on modélise la porte par un rectangle pour qu'elle apparaisse bien
    for i in range (1,len(salle)):
        draw.rectangle(((salle[i][0][0]*100,salle[i][0][1]*100),(salle[i][0][0]*100+salle[i][1][0]*100,salle[i][0][1]*100+salle[i][1][1]*100)),fill=(254,34,191))
    dessin_salle.save("dessin_salle.png", "PNG")
    Im = Image.open("dessin_salle.png")
    #Im.show()

#dessin(salle1)


"""fin de la représentation de la salle, on passe aux individus s'y trouvant"""
"""on commence par regarder comment va se déplacer un individu dans la salle"""
"""on va défnir les individus par des listes avec les caractéristiques qui les définissent, nom, coordonnées, vitesse etc ex [O, [10,12]..."""
#on modifie le prgm car on a pas encore def chaque perso avec son nom et tout, et on considere pour l'instant chaque individu avec ses coordonnées
def dessin_perso(Population):
    dessin_salle = Image.open("dessin_salle.png")
    draw = ImageDraw.Draw(dessin_salle)
    for i in range (len(Population)):
        draw.ellipse((Population[i][0][0]*100-0.5*100,Population[i][0][1]*100-0.5*100,Population[i][0][0]*100+0.5*100,Population[i][0][1]*100+0.5*100), fill=(30,224,62))
    dessin_salle.save("dessin_salle.png", "PNG")
    Im = Image.open("dessin_salle.png")
    #Im.show()

#dessin(salle1)


import random

def ajout_aleatoire_individus(salle,Pop,nombre_individu):
    L = salle[0][0]
    l=salle[0][1]
    for i in range (nombre_individu):
        a = random.randint(1,L-1)
        o = random.randint(1,l-1)
        while [[a,o]] in Pop:
            a = random.randint(1,L-1)
            o = random.randint(1,l-1)
        Pop.append([[a,o]])
    personnes_a_supp = [] #individus qui sont sur un obstacle
    for i in range (len(Pop)):
        for j in range (1, len(salle)):
            if (salle[j][0][0]-1) <= Pop[i][0][0] <= (salle[j][0][0] + salle[j][1][0]+1) and salle[j][0][1]-1 <= Pop[i][0][1] <= salle[j][0][1] + salle[j][1][1]+1:
                personnes_a_supp.append(Pop[i])
    if personnes_a_supp == []:
        return Pop
    else:
        for e in range (len(personnes_a_supp)):
            Pop.remove(personnes_a_supp[e])
        nombre_individus_a_replacer = nombre_individu - (len(Pop))
        ajout_aleatoire_individus(salle,Pop,nombre_individus_a_replacer)

def repartition_aleatoire_individus(salle,nombre_individu,Pop):
    L = salle[0][0]
    l=salle[0][1]
    T = len(Pop)
    for i in range (nombre_individu):
        a = random.randint(1,L-1)
        o = random.randint(1,l-1)
        while [[a,o]] in Pop:
            a = random.randint(1,L-1)
            o = random.randint(1,l-1)
        Pop.append([[a,o]])
    personnes_a_supp = [] #individus qui sont sur un obstacle
    for i in range (len(Pop)):
        for j in range (1, len(salle)):
            if (salle[j][0][0]-1) <= Pop[i][0][0] <= (salle[j][0][0] + salle[j][1][0]+1) and salle[j][0][1]-1 <= Pop[i][0][1] <= salle[j][0][1] + salle[j][1][1]+1:
                personnes_a_supp.append(Pop[i])
    print "personnes_a_supp=",personnes_a_supp
    if personnes_a_supp == []:
       print "end"
       #print Pop
       print type(Pop)
       return Pop
    else:
        for e in range (len(personnes_a_supp)):
            Pop.remove(personnes_a_supp[e])
        nombre_individus_a_replacer = nombre_individu - ((len(Pop)-T))
        print "nombre_individus_a_replacer=", nombre_individus_a_replacer
        #print Pop
        Pop=repartition_aleatoire_individus(salle,nombre_individus_a_replacer,Pop)
        return Pop

"""A chaque individu on n'attribuera pas de numéros, on dira simplement que
l'individu se trouvant à la position 0 sera le perso 0, etc, quand un individu
passe la porte, faut donc pas le supp, sinon ca dérèglera tout, faudra lui
attribuer des caractéristiques spéciale"""

"""on considère que la vitesse initiale est nulle, et que l'accélération aussi"""

"""pour la vitesse max, on considère que les jeunes peuvent courir à 7 m/s soit
25km/h, et les plus âgés à 1.5 m/s, soit 5,4 km/h
de plus tous peuvent atteindre leur vitesse max avec en 3 seconces, on en déduit l'
accélération"""

"""Les fonctions qui déterminent les vitesses, accélérations, placement dans
quadrillage doivent toujours etre executées dans le meme ordre,
sinon la liste ne sera plus dans le meme ordre et ce sera le bordel!!"""

def vitesse_et_acceleration_max(p):
    v = (random.randint(15,70))/10. #le point c'est pour travailler avec des décimaux
    a = (random.randint(5,20))/10.
    p.append(v)
    p.append(a)
    return p

"""on peut maintenant definr les caractéristiques de la population à l'instant
t=0, vitesse nulle, acceleration aussi.."""

def vitesse_initiale_et_acceleration_initiale_de_la_pop(pop): #pas vraiment initial en fait, plutot pour ajouter la "case" vitesse et acceleration au perso
    for i in range (len(pop)):
        vitesse_et_acceleration_max(pop[i])
        pop[i].append([0,0])
        pop[i].append([0,0])
        pop[i].append([])#on en profite pour rajouter aussi les cases qui correspondent au champ de vision: persos et obstacles presents
        pop[i].append([])
    return pop


#repartition_aleatoire_invdividus(salle1,10)
#vitesse_initiale_et_acceleration_initiale_de_la_pop(Pop)



def placement_dans_quadrillage_d_un_individu(p,quad):
    t =  quad[2]
    i1= p[0][0]//t
    i2= p[0][1]//t
    p.append([i1,i2])
    return p

def placement_dans_quadrillage_de_la_pop(pop):
    case = quad_salle(salle[0],5)
    for i in range (len(pop)):
        individu =  placement_dans_quadrillage_d_un_individu(pop[i],case)
        pop[i] = individu
    return pop

#placement_dans_quadrillage_de_la_pop(Pop)
#dessin_perso(Pop)

""" Il faut maintenant attribuer à chaque perso toute ses caractéristiques,
 ce qui engendrera des modifications dans les fonctions précédentes, on écrits
puis on les mettra avant les fonctions de dessins : FAIT"""

"""je vais mettre un # devant toute les fonctions et toutes les copier ici pour
mettre en évidence l'ordre"""

salle1 = carte(25,30,[14,0])
obstacle([10,4],[10,4])
obstacle([15,12],[4,8])
obstacle([4,18],[3,9])
quadrillage_salle_obstacle(salle1)
dessin(salle1)
#Pop= [[[10,26]],[[5,15]]]
#repartition_aleatoire_invdividus(salle1,5)
#vitesse_initiale_et_acceleration_initiale_de_la_pop(Pop)
#placement_dans_quadrillage_de_la_pop(Pop)
Pop=[[[10, 26], 5.7, 1.6, [0, 0], [0, 0], [2, 5], [[[5, 15], 3.2, 1.2, [0, 0], [0, 0], [1, 3], [], [[[10, 4], [10, 4], [[2, 4], [0, 1]]], [[15, 12], [4, 8], [[3, 3], [2, 4]]]]]], [[[15, 12], [4, 8], [[3, 3], [2, 4]]], [[4, 18], [3, 9], [[0, 1], [3, 5]]]]], [[5, 15], 3.2, 1.2, [0, 0], [0, 0], [1, 3], [], [[[10, 4], [10, 4], [[2, 4], [0, 1]]], [[15, 12], [4, 8], [[3, 3], [2, 4]]]]]]
#juste au dessus c'est la pop une fois les fonctions sur les champs de visions effectuées!
dessin_perso(Pop)

"""je viens de remarquer un bug, parfois, en testant avec 10 individu, il
m'arrive d'en obtenir 11,8,9... Resolu en modifiant la fonction répartition
aléatoire"""

"""on va maintenant s'attaquer au champ de vision qui va déterminer les
déplacements"""

"""on commence avec les obstacles pour simuler avec un seul individu"""
""" je sais pas si le quadrillage va vraiment nous servir.."""
"""on peut considérer que le champ de vision ne varie pas avec la vitesse,
car la variation de vitesse reste assez faible, si l'on compare avec une
voiture par exemple"""
"""on choisit comme champ de vision un triangle isocele, d'angle 100° (bien
que le champ de vision soit en situation normale plus important, on considèrera
qu'avec le stress ca donne ca. en plus, sinon ca fait rapidement des aires énormes)
et de hauteur 15m on a changé, c'est un cercle maintenant!"""
""" ces données que nous définissons et que l'utilisateur du prgm ne peut apriori
pas modifier sont les hypothèses que nous fixons pour nos expériences"""

"""le centre de l'individu correspond au sommet triangle isocèle ainsi défini,
la hauteur de ce triangle sera confondue avec le vecteur vitesse"""

"""voir annexe papier sur le champ de vision"""
""" on va definir une matrice de rotation qui permet de découper le cercle en
petites droites, on découpe en dix, soit 11 points, H, 5 à droite, 5 a gauche,
chaque partie a un angle de 10° soit 0,174 rad"""

from math import sqrt
from math import cos, sin, tan

def champ_de_vision(perso,salle): #on obtient les points caractéristiques à savoir I,J,H
    if perso[3]==[0,0]:
        vecteur_directeur_du_champ_de_vision = [(salle1[0][2][0]-perso[0][0])/sqrt((salle1[0][2][0]-perso[0][0])**2+(salle1[0][2][1]-perso[0][1])**2),(salle1[0][2][1]-perso[0][1])/sqrt((salle1[0][2][0]-perso[0][0])**2+(salle1[0][2][1]-perso[0][1])**2)]
        #print "vecteur directeur",vecteur_directeur_du_champ_de_vision
    else:
        vecteur_directeur_du_champ_de_vision = perso[3]
    Kh = 15/sqrt(vecteur_directeur_du_champ_de_vision[0]**2 + vecteur_directeur_du_champ_de_vision[1]**2)
    H = [perso[0][0]+Kh*vecteur_directeur_du_champ_de_vision[0],perso[0][1]+Kh*vecteur_directeur_du_champ_de_vision[1]]
    #a = 17.8763 # tan(50°)*15
    #Ki = a/(sqrt(vecteur_directeur_du_champ_de_vision[0]**2+vecteur_directeur_du_champ_de_vision[1]**2))
    #Kj = - Ki
    #I = [H[0]+Ki*(-vecteur_directeur_du_champ_de_vision[1]), H[1] + Ki*vecteur_directeur_du_champ_de_vision[0]]
    #J = [H[0]+Kj*(-vecteur_directeur_du_champ_de_vision[1]), H[1] + Kj*vecteur_directeur_du_champ_de_vision[0]]
    #print I,J,perso,vecteur_directeur_du_champ_de_vision
    #print H
    dessin_salle = Image.open("dessin_salle.png")
    draw = ImageDraw.Draw(dessin_salle)
    #draw.ellipse((H[0]*100-0.5*100,H[1]*100-0.5*100,H[0]*100+0.5*100,H[1]*100+0.5*100), fill=(30,55,62))
    #draw.ellipse((perso[0][0]*100-15*100,perso[0][1]*100-15*100,perso[0][0]*100+15*100,perso[0][1]*100+15*100),fill=(25,125,86))
    #draw.polygon([(I[0]*100,I[1]*100),(J[0]*100,J[1]*100),(perso[0][0]*100,perso[0][1]*100)], fill=(10, 234, 15))
    teta = 1.745
    points_caracteristiques = []
    point_depart = [perso[0][0] + cos(-teta/2)*(H[0]-perso[0][0]) - sin(-teta/2)*(H[1]-perso[0][1]), perso[0][1] + sin(-teta/2)*(H[0] - perso[0][0]) + cos(-teta/2)*(H[1]-perso[0][1])]
    #print point_depart
    points_caracteristiques.append(point_depart)
    for i in range (1,11):
        A = [perso[0][0] + cos(i*teta/10)*(point_depart[0]-perso[0][0]) - sin(i*teta/10)*(point_depart[1]-perso[0][1]) , perso[0][1] + sin(i*teta/10)*(point_depart[0]-perso[0][0]) + cos(i*teta/10)*(point_depart[1]-perso[0][1])]
        points_caracteristiques.append(A)
    #for i in range (len(points_caracteristiques)):
        #draw.ellipse((points_caracteristiques[i][0]*100-0.5*100,points_caracteristiques[i][1]*100-0.5*100,points_caracteristiques[i][0]*100+0.5*100,points_caracteristiques[i][1]*100+0.5*100), fill=(14,200,182))
    dessin_salle.save("dessin_salle.png", "PNG")
    Im = Image.open("dessin_salle.png")
    #Im.show()
    return points_caracteristiques

"""X' = P + R(X-P) """
#champ_de_vision(Pop[0],salle1)
#champ_de_vision(Pop[1],salle1)
#champ_de_vision(Pop[2],salle1)
#champ_de_vision(Pop[3],salle1)
#champ_de_vision(Pop[4],salle1)


""" on pourra avoir des pb, si python considere les coordonnées comme des entiers"""

def test_appartenance_champ_de_vision(point_test,perso,salle):
    points = champ_de_vision(perso,salle)
    test = True
    i=0
    #print points,perso
    while test==True and i<10:
        if ((points[i+1][0]-points[i][0])*(point_test[1]-points[i][1]) - (points[i+1][1]-points[i][1])*(point_test[0]-points[i][0]))*((points[i+1][0]-points[i][0])*(perso[0][1]-points[i][1]) - (points[i+1][1]-points[i][1])*(perso[0][0]-points[i][0])) > 0:
            test = True
        else:
            test = False
        i = i+1
    if test == True:
        if (((points[0][0]-perso[0][0])*(point_test[1]-perso[0][1]) - (points[0][1]-perso[0][1])*(point_test[0]-perso[0][0]))*((points[0][0]-perso[0][0])*(points[10][1]-perso[0][1]) - (points[0][1]-perso[0][1])*(points[10][0]-perso[0][0])) > 0) and (((points[10][0]-perso[0][0])*(point_test[1]-perso[0][1]) - (points[10][1]-perso[0][1])*(point_test[0]-perso[0][0]))*((points[10][0]-perso[0][0])*(points[0][1]-perso[0][1]) - (points[10][1]-perso[0][1])*(points[0][0]-perso[0][0])) > 0) :
            test = True
            #print "in"
        else:
                test = False
             #   print "out"
    else:
        #print "out"
        return test
    return test

#test_appartenance_champ_de_vision([12,18],Pop[0],salle1)



def test_appartenance_champ_de_vision_pour_obstacle(obstacle,perso,salle):
    x=obstacle[0][0] #abscisse du point de plus petite coordonnées
    y=obstacle[0][1]
    test = False
    a = x
    b= y
    while test == False and a < x + obstacle[1][0]:
        test = test_appartenance_champ_de_vision([a,b], perso, salle)
        a = a+1
    if test == True:
        #print "in"
        return test
    else:
        a=x
        b=y
        while test == False and b < y + obstacle[1][1]:
            test = test_appartenance_champ_de_vision([a,b], perso, salle)
            b=b+1
            #print "coordonnees =", [a,b]
        if test == True:
            #print "in"
            return test
        else:
            a=x
            b=y + obstacle[1][1]
            while test == False and a < x + obstacle[1][0]:
                test = test_appartenance_champ_de_vision([a,b], perso, salle)
                a = a+1
            if test == True:
                #print "in"
                return test
            else:
                a= x + obstacle[1][0]
                b=y
                while test == False and b < y + obstacle[1][1]:
                    test = test_appartenance_champ_de_vision([a,b], perso, salle)
                    b= b+1
                #if test == True:
                    #print "in"
                #else:
                    #print "out"

#test_appartenance_champ_de_vision_pour_obstacle(salle1[2],Pop[0],salle1)


def liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(perso,salle,Pop):
    persos_appartenant_au_champ = [ ]
    obstacles_appartenant_au_champ= [ ]
    for i in range (len(Pop)):
        if test_appartenance_champ_de_vision(Pop[i][0],perso,salle) == True:
            persos_appartenant_au_champ.append(Pop[i])
    for i in range(1,len(salle)):
        if test_appartenance_champ_de_vision_pour_obstacle(salle[i],perso,salle) == True:
            obstacles_appartenant_au_champ.append(salle[i])
    if perso in persos_appartenant_au_champ:
        persos_appartenant_au_champ.remove(perso)
    print "persos dans le champ:", persos_appartenant_au_champ, "obstacles dans le champ:",obstacles_appartenant_au_champ
    perso[6] = persos_appartenant_au_champ
    perso[7] = obstacles_appartenant_au_champ
    return persos_appartenant_au_champ, obstacles_appartenant_au_champ

def rentrer_cette_liste_dans_la_pop(pop,salle):
    for i in range (len(pop)):
        L = liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(pop[i],salle)
        pop[i][6] = L[0]
        pop[i][7] = L[1]

#liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(Pop[0],salle1,Pop)[0], liste_des_persos_et_obstacles_appartenant_au_champ_de_vison(Pop[0],salle1,Pop)[1]
#liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(Pop[0],salle1,Pop)
#liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(Pop[1],salle1,Pop)

#Im = Image.open("dessin_salle.png") #on met ca là, sinon le dessin s'ouvre 50 fois
#Im.show()

""" ca y est, je crois qu'on en a fini avec le champ de vision!, on a tout"""
"""maintenant on va s'interesser à comment se dirige un perso tout seul dans
la salle, cad on sa direction, sa vitesse, son accélération"""
"""on va réfléchir à tout ca en se basant sur le bonhomme de position [3, 19]
c'est à dire Pop[3]"""
"""d'abord le cas le plus simple, si personne ne va gener à la position suivante
ou si un obstacle va gener"""

""" Pop[0][6] correspond aux persos présents dans le champ de vision du perso
Pop[0][7] correspond aux obstacles présents dans le champ de vision du perso"""



def rencontre_obstacle(perso,salle):
    if perso[7]== []:
        L = []
        return L
    else:
        obstacles_du_champ = perso[7]
        vitesse = perso[3]
        coord = perso[0]
        if vitesse == [0,0]:
            vitesse = [(salle1[0][2][0]-perso[0][0])/sqrt((salle1[0][2][0]-perso[0][0])**2+(salle1[0][2][1]-perso[0][1])**2),(salle1[0][2][1]-perso[0][1])/sqrt((salle1[0][2][0]-perso[0][0])**2+(salle1[0][2][1]-perso[0][1])**2)]
        #print "vitesse", vitesse
        L = []
        t = 0
        test = True
        for i in range (len(obstacles_du_champ)):
            while sqrt((perso[0][0]-coord[0]+vitesse[0]*t)**2 + (perso[0][1]+vitesse[1]*t-coord[1])**2) < 15 and test == True:
                A= sqrt((perso[0][0]-coord[0]+vitesse[0]*t)**2 + (perso[0][1]+vitesse[1]*t-coord[1])**2) #distance à l'obstacle
                #print "distance", A
                if (obstacles_du_champ[i][0][0] < coord[0]+vitesse[0]*t) and ((obstacles_du_champ[i][0][1] < coord[1]+vitesse[1]*t)) and ((obstacles_du_champ[i][0][0] + obstacles_du_champ[i][1][0] > coord[0]+vitesse[0]*t)) and (obstacles_du_champ[i][0][1] + obstacles_du_champ[i][1][1] > coord[1]+vitesse[1]*t):
                    #print coord[0]+vitesse[0]*t,coord[1]+vitesse[1]*t, obstacles_du_champ[i]
                    test = False
                    a = t
                    while (obstacles_du_champ[i][0][0] < coord[0]+vitesse[0]*a) and ((obstacles_du_champ[i][0][1] < coord[1]+vitesse[1]*a)) and ((obstacles_du_champ[i][0][0] + obstacles_du_champ[i][1][0] > coord[0]+vitesse[0]*a)) and (obstacles_du_champ[i][0][1] + obstacles_du_champ[i][1][1] > coord[1]+vitesse[1]*a):
                         a = a + .1
                    L.append([[coord[0]+vitesse[0]*t,coord[1]+vitesse[1]*t],[coord[0]+vitesse[0]*a,coord[1]+vitesse[1]*a],obstacles_du_champ[i],A])
                else:
                    t = t+.1
                    #print "t=",t
                    #print coord[0]+vitesse[0]*t,coord[1]+vitesse[1]*t
        min = 0
        for i in range (len(L)):
            if L[i][2]<min:
                del L[min]
                min = i
        return L

""" Ainsi, L contient le point de rencontre avec l'obstacle, les donnees sur l'obstacle en question, le point de "sortie" de l'obstacle
"""

#rencontre_obstacle(Pop[0],salle1)


def decision_par_rapport_a_obstacle(perso,salle): #modification de l'acceleration modifie UNIQUEMENT l'orientation du vecteur vitesse et non ca norme
    L = rencontre_obstacle(perso,salle)
    vitesse = perso[3]
    if L == []: #pas d'obstacle en vue
        print "on ne modifie rien"
        acceleration = [0,0] #pas d'acceleration due à une rotation
    else:
        obstacle = L[0][2]
        distance = L[0][3]
        Pr = L[0][0] #point de rencontre entre la trajectoire du perso et l'obstacle
        Ps = L[0][1]
        print "Pr=",Pr, "Ps=", Ps, "obstacle=", obstacle
        Aire_obstacle = obstacle[1][0]*obstacle[1][1]
        if (round(Pr[0])==obstacle[0][0]) and (round(Ps[0])==obstacle[0][0]+ obstacle[1][0]):
            A = obstacle[1][0]*(obstacle[0][1]+obstacle[1][1]-Pr[1]) + .5*(Ps[1]-Pr[1])*obstacle[1][0]
        elif (round(Ps[0])==obstacle[0][0]) and (round(Pr[0])==obstacle[0][0]+ obstacle[1][0]):
           A = Aire_obstacle - obstacle[1][0]*(obstacle[0][1]+obstacle[1][1]-Pr[1]) + .5*(Ps[1]-Pr[1])*obstacle[1][0]
        elif (round(Pr[1])==obstacle[0][1]) and (round(Ps[1])==obstacle[0][1]+obstacle[1][1]):
            A = obstacle[1][1]*(Pr[0]-obstacle[0][0]) + 0.5*(Ps[0]-Pr[0])*obstacle[0][1]
        elif (round(Ps[1])==obstacle[0][1]) and (round(Pr[1])==obstacle[0][1]+obstacle[1][1]):
            A = Aire_obstacle - (obstacle[1][1]*(Pr[0]-obstacle[0][0]) + 0.5*(Ps[0]-Pr[0])*obstacle[0][1])
        elif (round(Pr[1])==obstacle[0][1] or round(Pr[1])==obstacle[0][1]+obstacle[1][1]) and (round(Ps[1])==obstacle[0][1] or round(Ps[1])==obstacle[0][1]+obstacle[1][1]):
            A = obstacle[1][1]*(Pr[0]) + .5*(Ps[0]-Pr[0])*obstacle[1][1]
        elif (round(Pr[0]) == obstacle[0][0]) and (round(Ps[1]) == obstacle[0][1]):
            A= Aire_obstacle-(.5*(Pr[1]-obstacle[0][1])*(Ps[0]-obstacle[0][0]))
        elif (round(Ps[0]) == obstacle[0][0]) and (round(Pr[1]) == obstacle[0][1]):
            A= .5*(Ps[1]-obstacle[0][1])*(Pr[0]-obstacle[0][0])
        elif (round(Pr[0]) == (obstacle[0][0])) and (round(Ps[1]) == (obstacle[0][1]+obstacle[1][1])):
            A= .5*(obstacle[0][1]+obstacle[1][1]-Pr[1])*(Ps[0]-obstacle[0][0])
        elif (round(Ps[0]) == (obstacle[0][0])) and (round(Pr[1]) == (obstacle[0][1]+obstacle[1][1])):
            A= Aire_obstacle-(.5*abs(obstacle[0][1]+obstacle[1][1]-Ps[1])*abs(Pr[0]-obstacle[0][0]))
        elif (round(Pr[0]) == (obstacle[0][0]+obstacle[1][0])) and (round(Ps[1]) == (obstacle[0][1]+obstacle[1][1])):
            A= Aire_obstacle-(.5*(obstacle[0][1]+obstacle[1][1]-Ps[1])*(obstacle[0][0]+obstacle[1][0]-Pr[0]))
        elif (round(Ps[0]) == (obstacle[0][0]+obstacle[1][0])) and (round(Pr[1]) == (obstacle[0][1]+obstacle[1][1])):
            A= .5*(obstacle[0][1]+obstacle[1][1]-Pr[1])*(obstacle[0][0]+obstacle[1][0]-Ps[0])
        elif (round(Pr[0]) == (obstacle[0][0]+obstacle[1][0])) and (round(Ps[1]) == (obstacle[0][1])):
            A= .5*(Pr[1]-obstacle[0][1])*(obstacle[0][0]+obstacle[1][0]-Ps[0])
        elif (round(Ps[0]) == (obstacle[0][0]+obstacle[1][0])) and (round(Pr[1]) == (obstacle[0][1])):
            A= Aire_obstacle-(.5*abs(Ps[1]-obstacle[0][1])*(obstacle[0][0]+obstacle[1][0]-Pr[0]))
        print "Aire=",A, "Aire Obstacle", Aire_obstacle
        if A < Aire_obstacle*.5:
            print "droite"
            decision = True #on va bien à droite
        else:
            print "gauche"
            decision = False #on va à gauche
        if distance > 10: #l'obstacle est à plus de 10m on doit tourner un peu, de 15°, (15 * pi) / 180 = 0.2617993877991494
            print "on tourne de 10°"
            if decision == True:
                vitesse = [cos(0.17453292519943295)*(vitesse[0])- sin(0.17453292519943295)*(vitesse[1]) ,sin(0.17453292519943295)*(vitesse[0]) + cos(0.17453292519943295)*(vitesse[1])]
                persotest = copie(perso)
                persotest[3] = vitesse
                if (rencontre_obstacle(persotest,salle)) != (rencontre_obstacle(perso,salle)) :
                    while (rencontre_obstacle(persotest,salle)) != (rencontre_obstacle(perso,salle)) :
                        persotest[3]= [cos(-0.08726646259971647)*(vitesse[0])- sin(-0.08726646259971647)*(vitesse[1]) ,sin(-0.08726646259971647)*(vitesse[0]) + cos(-0.08726646259971647)*(vitesse[1])]
                    vitesse = [cos(0.08726646259971647)*(vitesse[0])- sin(0.08726646259971647)*(vitesse[1]) ,sin(0.08726646259971647)*(vitesse[0]) + cos(0.08726646259971647)*(vitesse[1])]
            else:
                vitesse= [cos(-0.17453292519943295)*(vitesse[0])- sin(-0.17453292519943295)*(vitesse[1]) ,sin(-0.17453292519943295)*(vitesse[0]) + cos(-0.17453292519943295)*(vitesse[1])]
                persotest = copie(perso)
                persotest[3] = vitesse
                if (rencontre_obstacle(persotest,salle)) != (rencontre_obstacle(perso,salle)) :
                    while (rencontre_obstacle(persotest,salle)) != (rencontre_obstacle(perso,salle)) :
                        persotest[3]= [cos(-0.08726646259971647)*(vitesse[0])- sin(-0.08726646259971647)*(vitesse[1]) ,sin(-0.08726646259971647)*(vitesse[0]) + cos(-0.08726646259971647)*(vitesse[1])]
                    vitesse = [cos(0.08726646259971647)*(vitesse[0])- sin(0.08726646259971647)*(vitesse[1]) ,sin(0.08726646259971647)*(vitesse[0]) + cos(0.08726646259971647)*(vitesse[1])]

        elif distance >5: #l'obstacle est entre 5 et 10m, on doit tourner un peu plus de 15°  15*pi/180 = 0.2617993877991494
            print "on tourne de 15°"
            if decision == True:
                vitesse = [cos(0.2617993877991494)*(vitesse[0])- sin(0.2617993877991494)*(vitesse[1]) ,sin(0.2617993877991494)*(vitesse[0]) + cos(0.2617993877991494)*(vitesse[1])]
            else:
                vitesse= [cos(-0.2617993877991494)*(vitesse[0])- sin(-0.2617993877991494)*(vitesse[1]) ,sin(-0.2617993877991494)*(vitesse[0]) + cos(-0.2617993877991494)*(vitesse[1])]
        else: #on doit tourner plus! de 20° 20*pi/180 =0.3490658503988659
            print "on tourne de 20°"
            if decision == True:
                vitesse= [cos(0.3490658503988659)*(vitesse[0])- sin(0.3490658503988659)*(vitesse[1]) ,sin(0.3490658503988659)*(vitesse[0]) + cos(0.3490658503988659)*(vitesse[1])]
            else:
                vitesse= [cos(-0.3490658503988659)*(vitesse[0])- sin(-0.3490658503988659)*(vitesse[1]) ,sin(-0.3490658503988659)*(vitesse[0]) + cos(-0.3490658503988659)*(vitesse[1])]
        acceleration = [0,0]
        acceleration[0]= vitesse[0] - perso[3][0]
        acceleration[1]= vitesse[1] - perso[3][1]
        print "acceleration=", acceleration
        print "distance=", distance
        dessin_salle = Image.open("dessin_salle.png")
        draw = ImageDraw.Draw(dessin_salle)
        #draw.ellipse(((vitesse[0]+perso[0][0])*100-0.5*100,(vitesse[1]+perso[0][1])*100-0.5*100,(vitesse[0]+perso[0][0])*100+0.5*100,(vitesse[1]+perso[0][1])*100+0.5*100), fill=(145,200,182))
        dessin_salle.save("dessin_salle.png", "PNG")
        Im = Image.open("dessin_salle.png")
        Im.show()
        print "modification de l'orientation de la vitesse dans le cas ou il n'y a pas de persos=", vitesse
    print "acceleration=", acceleration
    return acceleration

#decision_par_rapport_a_obstacle(Pop[1],salle1)

def determination_acceleration_initiale_par_rapport_aux_obstacles(perso,salle):
    vitesse = [((salle[0][2][0]-perso[0][0])/sqrt((salle[0][2][0]-perso[0][0])**2+(salle[0][2][1]-perso[0][1])**2)),((salle[0][2][1]-perso[0][1])/sqrt((salle[0][2][0]-perso[0][0])**2+(salle[0][2][1]-perso[0][1])**2))]
    perso[3] = vitesse
    acceleration = decision_par_rapport_a_obstacle(perso,salle)
    vitesse = [vitesse[0]+acceleration[0]*1,vitesse[1]+acceleration[1]*1] #*1 car on considère que le pas de temps est 1
    acceleration = [vitesse[0]*perso[2],vitesse[1]*perso[2]] #acceleration max
    perso[3]=[0,0]
    perso[4] = acceleration
    #print perso
    return perso


"""
dessin(salle1)
#Poptest=[[[10,26]]]
#vitesse_initiale_et_acceleration_initiale_de_la_pop(Poptest)
#placement_dans_quadrillage_de_la_pop(Poptest)
#liste_des_persos_et_obstacles_appartenant_au_champ_de_vison(Poptest[0],salle1,Poptest)
#on trouve Poptest= [[[10, 26], 2.1, 0.5, [0, 0], [0, 0], [2, 5], [], [[[15, 12], [4, 8], [[3, 3], [2, 4]]], [[4, 18], [3, 9], [[0, 1], [3, 5]]]]]]
Poptest= [[[10, 26], 2.1, 0.5, [0, 0], [0, 0], [2, 5], [], [[[15, 12], [4, 8], [[3, 3], [2, 4]]], [[4, 18], [3, 9], [[0, 1], [3, 5]]]]]]
dessin_perso(Poptest)
Im = Image.open("dessin_salle.png")
Im.show()
determination_acceleration_initiale_par_rapport_aux_obstacles(Poptest[0],salle1)
def testmouv(perso,salle):
    print perso
    for i in range (6):
        perso[0][0] = perso[0][0]+perso[3][0]*3
        perso[0][1] = perso[0][1]+perso[3][1]*3
        perso[3][0] = perso[3][0]+perso[4][0]*3
        perso[3][1] = perso[3][1]+perso[4][1]*3
        acceleration = decision_par_rapport_a_obstacle(perso,salle)
        perso[4] = acceleration
        liste_des_persos_et_obstacles_appartenant_au_champ_de_vision(Poptest[0],salle1,Poptest)
        dessin_perso(Poptest)
        print perso
        Im = Image.open("dessin_salle.png")
        Im.show()

testmouv(Poptest[0],salle1)"""