def parse(self):
def parseSubLignes(lignes, index):
voisins = {}
nbrlignes = len(lignes)
for i in range(index + 1, nbrlignes):
ligne = lignes[i]
if len(ligne.split()) == 2:
(villeV, distance) = ligne.split()
voisins[villeV] = int(distance)
elif len(ligne.split()) == 3:
return voisins
return voisins
villes = []
for i in range(0, len(self.lignes)):
ligne = self.lignes[i]
if len(ligne.split()) == 3:
(nom, lat, long) = ligne.split()
ville = Ville(nom, lat, long)
voisins = parseSubLignes(self.lignes, i)
ville.voisins = voisins
villes.append(ville)
return villes
class TestVille(unittest.TestCase):
def setUp(self):
self.v = Ville(1, 2)
def tearDown(self):
self.v = None
def test_repr(self):
"""
Teste la representation textuelle d'une ville
"""
self.assertEqual('(1;2)', self.v.__repr__())
def test_distance_to(self):
"""
Teste le calcul de distance entre 2 points
"""
v2 = Ville(1, 3)
self.assertEqual(self.v.distance_to(v2), 1)
def test_eq(self):
"""
Teste l'égalité entre 2 villes
"""
v2 = Ville(1, 2)
v3 = Ville(2, 1)
self.assertEqual(self.v, v2)
self.assertNotEqual(self.v, v3)
def test_fermeture(self):
self.assertEqual(
[Ville(1, 2),
Ville(1, 3),
Ville(1, 4),
Ville(1, 5),
Ville(1, 2)],
self.c.fermeture().liste_villes)
def test_eq(self):
self.assertEqual(
self.c,
Chemin.from_array(
[Ville(1, 2),
Ville(1, 3),
Ville(1, 4),
Ville(1, 5)]))
def test_eq(self):
"""
Teste l'égalité entre 2 villes
"""
v2 = Ville(1, 2)
v3 = Ville(2, 1)
self.assertEqual(self.v, v2)
self.assertNotEqual(self.v, v3)
def callback(self):
text = self.entry.get()
self.can.delete(self.popup)
self.can.delete(self.popup2)
self.addVille(Ville(self, self.villeTemps[0], self.villeTemps[1],
text))
# Réactivation des bind
self.can.bind("<ButtonPress-1>", lambda event: self.lpress(event))
self.can.bind("<ButtonRelease-1>", lambda event: self.lrelease(event))
self.can.bind("<Button-3>", lambda event: self.rclic(event))
self.window.bind("<space>", lambda event: self.run())
def from_csv(cls, nom_fichier):
"""
Permet la creation d'un chemin a partir d'un fichier csv
contenant des coordonnées
"""
coords = []
with open(nom_fichier, 'r') as fichier:
r = reader(fichier)
for ligne in r:
coords.append(Ville(float(ligne[0]), float(ligne[1])))
c = Chemin(0)
c.liste_villes = coords
return c
def __init__(self, nombre_villes):
"""
Initialise un chemin de nombre_villes aléatoires
"""
# Si on utilise ce constructeur depuis la methode de classe fromArray
if nombre_villes == 0:
# Ne pas creer de liste de villes
pass
self.liste_villes = set()
while len(self.liste_villes) < nombre_villes:
# Ajouter une ville aléatoires au chemin
self.liste_villes.add(Ville(randint(0, 1000), randint(0, 1000)))
self.liste_villes = list(self.liste_villes)
if len(set(self.liste_villes)) != len(self.liste_villes):
raise ValueError('NON UNIQUES')
def update_bien(id):
session = Session()
bien = session.query(BienImmobilier).filter(BienImmobilier.id == id).one()
data = request.get_json(force=True)
nomm = data['nom']
descriptionn = data['description']
typeBienn = data['typeBien']
villeObj = data['ville']
nomVille = villeObj['nom']
codePos = villeObj['codePostal']
departement = villeObj['departement']
region = villeObj['region']
bien.nom = nomm
bien.description = descriptionn
bien.typeBien = typeBienn
ville = Ville(nomVille, departement, region, codePos)
bien.ville = ville
session.commit()
return bien_schema.jsonify(bien)
def defaultSetup(self):
# La geographie
self.addVille(Ville(self, 30, 30, "Source"))
self.addVille(Ville(self, 130, 360, "Ville 1"))
self.addVille(Ville(self, 400, 280, "Ville 2"))
self.addVille(Ville(self, 100, 600, "Ville 3"))
self.addVille(Ville(self, 500, 550, "Ville 4"))
self.addVille(Ville(self, 700, 750, "Objectif"))
self.addVille(Ville(self, 350, 500, "Ville 5"))
self.villes[0].setNid()
self.villes[5].setSource()
self.addRoute(Route(self, self.villes[0], self.villes[1]))
self.addRoute(Route(self, self.villes[0], self.villes[2]))
self.addRoute(Route(self, self.villes[3], self.villes[5]))
self.addRoute(Route(self, self.villes[4], self.villes[5]))
self.addRoute(Route(self, self.villes[2], self.villes[3]))
self.addRoute(Route(self, self.villes[2], self.villes[4]))
self.addRoute(Route(self, self.villes[1], self.villes[3]))
self.addRoute(Route(self, self.villes[3], self.villes[6]))
def add_bien():
session = Session()
data = request.get_json(force=True)
print(data)
nomBien = data['nom']
description = data['description']
typeBien = data['typeBien']
userObj = data['utilisateur']
nomUtilisateur = userObj['nom']
prenomUtilisateur = userObj['prenom']
dateNaissance = userObj['dateNaissance']
villeObj = data['ville']
nomVille = villeObj['nom']
codePos = villeObj['codePostal']
departement = villeObj['departement']
region = villeObj['region']
new_user = Utilisateur(nomUtilisateur, prenomUtilisateur, dateNaissance)
new_ville = Ville(nomVille, departement, region, codePos)
new_bien = BienImmobilier(nomBien, description, typeBien, new_user,
new_ville)
session.add(new_bien)
session.commit()
return jsonify(new_bien)
"""
Created on Mon May 4 20:53:51 2020
@author: Brahim DEBBAGH
"""
from GeneticAlgorithm import GA
from Circuit import Carte
from Ville import Ville
from Population import Population
if __name__ == '__main__':
carte = Carte()
ville1 = Ville(3.002556, 45.846117, 'Clermont-Ferrand')
carte.ajouterVille(ville1)
ville2 = Ville(-0.644905, 44.896839, 'Bordeaux')
carte.ajouterVille(ville2)
ville3 = Ville(-1.380989, 43.470961, 'Bayonne')
carte.ajouterVille(ville3)
ville4 = Ville(1.376579, 43.662010, 'Toulouse')
carte.ajouterVille(ville4)
ville5 = Ville(5.337151, 43.327276, 'Marseille')
carte.ajouterVille(ville5)
ville6 = Ville(7.265252, 43.745404, 'Nice')
carte.ajouterVille(ville6)
ville7 = Ville(-1.650154, 47.385427, 'Nantes')
carte.ajouterVille(ville7)
ville8 = Ville(-1.430427, 48.197310, 'Rennes')
carte.ajouterVille(ville8)
def setUp(self):
self.c = Chemin.from_array(
[Ville(1, 2), Ville(1, 3),
Ville(1, 4), Ville(1, 5)])
from Carte import Carte
from Ville import Ville
from Chemin import Chemin
from Genetique import Genetique
from random import randint
import numpy as np
import matplotlib as mpl
mpl.use('Agg')
import matplotlib.pyplot as plt
# Variables
results = []
carte = Carte()
# Creation d'une carte
ville1 = Ville(0, 0)
ville2 = Ville(100, 0)
ville3 = Ville(0, 100)
ville4 = Ville(50, 60)
ville5 = Ville(70, 75)
ville6 = Ville(25, 40)
ville7 = Ville(40, 80)
ville8 = Ville(90, 15)
ville9 = Ville(25, 80)
carte.ajoutVille(ville1)
carte.ajoutVille(ville2)
carte.ajoutVille(ville3)
carte.ajoutVille(ville4)
carte.ajoutVille(ville5)
carte.ajoutVille(ville6)
carte.ajoutVille(ville7)
from config import Session
from BienImmobilier import BienImmobilier, Piece
from Utilisateur import Utilisateur
from Ville import Ville
# 2 - generer la base de données
Base.metadata.create_all(engine)
# 3 - creer une nouvelle session
session = Session()
user1 = Utilisateur("kenna", "amine", date(1994, 6, 1))
user2 = Utilisateur("baali", "kaoutar", date(1997, 1, 11))
ville1 = Ville("Paris", "Paris", "ile de france", 75000)
ville2 = Ville("Chatenay Malabry", "Haut seine", "ile de france", 92290)
bien1 = BienImmobilier("appartement", "tres jolie", "appt", user1, ville1)
bien2 = BienImmobilier("villa", "tres belle", "vl", user2, ville2)
piece1 = Piece(20, "vaste", bien1)
session.add(user1)
session.add(user2)
session.add(ville1)
session.add(ville2)
session.add(bien1)
session.add(bien2)
from Chemin import Chemin
from Ville import Ville
from csv import reader
from math import inf
from itertools import permutations
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
coords = []
with open('coords.csv', 'r') as f:
r = reader(f)
for x in r:
coords.append(Ville(int(x[0]), int(x[1])))
carte = Chemin.from_array(coords)
chemins = []
score = inf
best = None
def toPlot(c):
x = []
y = []
for coo in c:
x.append(coo.x)
y.append(coo.y)
return x, y
# Generation de tout les chemins possibles
def test_distance_to(self):
"""
Teste le calcul de distance entre 2 points
"""
v2 = Ville(1, 3)
self.assertEqual(self.v.distance_to(v2), 1)
from Utilitaire.BaseDeDonnees import BaseDeDonnees
from Utilitaire import Global
import sys
"""Import de la base de données"""
#commande main.py duree=24*6 nomdutest=0 datededébut=0
analyseur = False
if (len(sys.argv) > 1):
Global.duree = eval(sys.argv[1])
analyseur = True
if (len(sys.argv) > 2):
Global.numtest = sys.argv[2]
if (len(sys.argv) > 3):
Global.temps = eval(sys.argv[3])
"""initialisation de la Ville dans l'objet Ville"""
ville = Ville()
numTest = Global.numtest
Global.duree += Global.temps #décalage si présence d'un offset
duree = Global.duree
def ind_eqpascher(
liste, consigne
): #pour prod MAX !! indice de l'equipement le moins cher, liste comme simulations
i = 0
while (i < len(liste) and abs(consigne[i] - liste[i][1]) < 10.**(-3)
): #indice d'un équipement pas encore au max
i += 1
if i < len(liste):
cout_min = liste[i][4]
for j in range(0, len(liste)):
def test_from_array(self):
l = [Ville(1, 2), Ville(1, 3), Ville(1, 4), Ville(1, 5)]
ch = Chemin.from_array(l)
self.assertEqual(ch.liste_villes, l)
def test_get_item(self):
self.assertEqual(self.c[0], Ville(1, 2))
def test_set_item(self):
v = Ville(12, 12)
self.c.__setitem__(0, v)
self.assertEqual(self.c[0], v)
def setUp(self):
self.v = Ville(1, 2)
def __init__(self, nombre_villes=0):
""" Créé un réseau vierge """
self.villes = [Ville(i) for i in range(nombre_villes)]
self.routes = []