def switch_to_graph(self, qtt_nodes=10, qtt_edges=10, edge_type=0, edge_weight=0):
del self.graph
del self.graph_screen
self.graph_screen = GraphScreen(self.screen, self, self.clock)
self.graph = Graph(self.graph_screen)
# edge type = 0 (undirected) and 1 (directed)
self.graph.set_edge_type(edge_type)
self.graph.set_edge_weight(edge_weight)
# disable algorithms that needs edges weight
if edge_weight == 0:
self.graph_screen.disable_edge_weight()
self.graph_screen.set_graph(self.graph)
self.graph_screen.set_generate_graph(
self.graph.automatic_generation_graph)
self.graph_screen.set_show_edge_dir(edge_type)
self.graph_screen.set_search_algorithm(
breadth_search, depth_first_search)
self.graph_screen.set_dijkstra_algorithm(dijkstra_algorithm)
self.graph_screen.set_topological(topological_order)
self.graph_screen.start(qtt_nodes, qtt_edges)
self.keys_listener_selected = self.graph_screen.keys_listener
self.draw_screen_selected = self.graph_screen.draw
class Screen(object):
def __init__(self):
self.screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT))
self.font = None
self.clock = pygame.time.Clock()
self.menu = None
self.graph_screen = None
self.keys_listener_selected = None
self.draw_screen_selected = None
self.graph = None
def start(self):
pygame.display.set_caption("Graph")
pygame.init()
self.font = pygame.font.Font(
'modules/fonts/roboto/Roboto-Black.ttf', 15)
# init programm with menu screen
self.switch_to_menu()
# self.switch_to_graph()
def switch_to_menu(self):
del self.menu
self.menu = Menu(self.screen, self, self.clock)
self.keys_listener_selected = self.menu.keys_listener
self.draw_screen_selected = self.menu.draw
def switch_to_graph(self, qtt_nodes=10, qtt_edges=10, edge_type=0, edge_weight=0):
del self.graph
del self.graph_screen
self.graph_screen = GraphScreen(self.screen, self, self.clock)
self.graph = Graph(self.graph_screen)
# edge type = 0 (undirected) and 1 (directed)
self.graph.set_edge_type(edge_type)
self.graph.set_edge_weight(edge_weight)
# disable algorithms that needs edges weight
if edge_weight == 0:
self.graph_screen.disable_edge_weight()
self.graph_screen.set_graph(self.graph)
self.graph_screen.set_generate_graph(
self.graph.automatic_generation_graph)
self.graph_screen.set_show_edge_dir(edge_type)
self.graph_screen.set_search_algorithm(
breadth_search, depth_first_search)
self.graph_screen.set_dijkstra_algorithm(dijkstra_algorithm)
self.graph_screen.set_topological(topological_order)
self.graph_screen.start(qtt_nodes, qtt_edges)
self.keys_listener_selected = self.graph_screen.keys_listener
self.draw_screen_selected = self.graph_screen.draw
def refresh(self):
while 1:
self.keys_listener_selected()
self.draw_screen_selected()
def simulationTempsCalcul(tailleX, tailleY, decoupageN, decoupageP):
"""
Simule une zone de tailleX * tailleY
Et regardes le temps de génération de cette simulation
en fonction de n et de p
"""
tempsDepartSimul = perf_counter()
f = open(
str((tailleX, tailleY, decoupageN.start, decoupageN.stop,
decoupageN.step, decoupageP.start, decoupageP.stop,
decoupageP.step)) + '.csv', "a")
for n in decoupageN:
n = int(n)
for p in decoupageP:
p = int(p)
t0, t1, t2, t3, t4 = Graph(tailleX, tailleY, n, p).temps
f.write(
str(p) + ";" + str(n) + ";" + str(t0).replace(".", ",") + ";" +
str(t1).replace(".", ",") + ";" + str(t2).replace(".", ",") +
";" + str(t3).replace(".", ",") + ";" +
str(t4).replace(".", ",") + "\n")
# Affichage de la progression en pourcentage
print(str((n * 100) // decoupageN.stop) + "%")
f.close()
return perf_counter() - tempsDepartSimul
def simulationClusters(tailleX, tailleY, decoupageN, decoupageP):
"""
Simule une zone de tailleX * tailleY
Et regardes l'état des clusters et de la qualité de connection
en fonction de n et de p
"""
t0sim = perf_counter()
for n in decoupageN:
print(n)
for portee in decoupageP:
clusters = Clusters(Graph(tailleX, tailleY, n, portee))
data = [qualiteConnection(clusters)]
tailleClusterPrecedent = 0
i = 0
for cluster in clusters.clusters:
tailleCluster = len(cluster)
if tailleCluster == tailleClusterPrecedent:
data[i][1] += 1
else:
data.append([tailleCluster, 1])
i += 1
tailleClusterPrecedent = tailleCluster
fichier = open("./simulations/clusters/" +
str((tailleX, tailleY, n, portee)) + '.txt', "a")
fichier.write(str(data) + '\n')
fichier.close()
return perf_counter() - t0sim
def switch_to_graph(self, qtt_nodes=10, qtt_edges=10):
del self.graph
del self.graph_screen
self.graph_screen = GraphScreen(self.screen, self, self.clock)
self.graph = Graph(self.graph_screen)
self.graph_screen.set_generate_graph(
self.graph.automatic_generation_graph)
self.graph_screen.set_search_algorithm(self.graph.breadth_search,
self.graph.depth_first_search)
self.graph_screen.start(qtt_nodes, qtt_edges)
self.keys_listener_selected = self.graph_screen.keys_listener
self.draw_screen_selected = self.graph_screen.draw
def simulationComplexiteClusters(tailleX, tailleY, decoupageN, decoupageP):
"""
Simule une zone de tailleX * tailleY
Et regardes la complexité de l'algorithme de séparation des clusters
en fonction de n et de p
"""
t0sim = perf_counter()
for n in decoupageN:
print(n)
for portee in decoupageP:
clusters = Clusters(Graph(tailleX, tailleY, n, portee))
fichier = open("./simulations/clustersComplex/" +
str((tailleX, tailleY, n, portee)) +
'.txt', "a")
fichier.write(str(clusters.compteur) + '\n')
fichier.close()
return perf_counter() - t0sim
def test():
g = Graph(filename="github_edges.txt")
g.plot_degree_dist()
print("Number of triangles: " + str(g.count_triangles_number()))
from modules.logg import Logg
from modules.extapi import ExtApi
from flask_cors import CORS
# tmpl_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'dist')
# static_folder = "dist"
# app = Flask(__name__,static_folder=static_folder, template_folder=tmpl_dir)
app = Flask(__name__)
CORS(app)
app.debug = False
db = None
graph = Graph.instance()
logg = Logg.instance()
extapi = ExtApi.instance()
@app.route("/")
def hello():
return "Hello World!"
@app.route("/test")
def test():
data = db.get_sensors()
return json.dumps(data)
cluster afin de pouvoir afficher le contour
dans afficherPlotAvecClusters
"""
coordBloc = [(gsm['x'], gsm['y']) for gsm in self.graph.coord
if gsm['indice'] in bloc]
enveloppe = fonctionConvexHull(coordBloc, qhull_options="QJ Pp")
return array(coordBloc,
dtype=[('x', 'int'), ('y', 'int')]), enveloppe
if __name__ == "__main__":
# Setup (non-profilé)
from modules.graph import Graph
g = Graph(1000, 1000, 20000, 25, True)
# Profiling
import cProfile
import pstats
# Start Profiler
pr = cProfile.Profile()
pr.enable()
# Benchmark clusterisation
for i in range(10):
c = Clusters(g, True)
# Stop profiler and print stats
pr.disable()
# import sys
# sys.path.append('../CourseWork/')
from modules.graph import Graph
if __name__ == "__main__":
words = [[(0, 0), (4, 3)], [(5, 8), (5, 9), (4, 11)], \
[(2, 13), (-7, 21), (-12, 16), (-12, 15), (-2, 12), (6, 11), (10, 13), (9, 21), (-1, 22), (-6, 13)], \
[(-1, 4), (3, -2), (8, -4), (16, -6), (27, 2)], [(28, 15), (31, 19), (34, 24), (27, 31)]]
g1 = Graph(words)
g1.draw()
g1.save('test_graph')
# print(g1[(0, 1)])
if message.destinataire == ancienGsm.imei:
# Envoyer l'accusé de Réception
anciens.remove(message)
if message.hash in messagesEnCours.keys():
messagesEnCours.pop(message.hash)
messagesRecus.append((message, tick - message.tick))
ancienGsm.messages = anciens
if __name__ == '__main__':
# Setup (non-profilé) :
# Test rhizome taille réelle
# g = Graph(1000, 1000, 20000, 25, True)
# Test rhizome rapide
g = Graph(20, 20, 40, 4, True)
c = Clusters(g, True)
l = [GSM(k) for k in range(g.n)]
l2 = deepcopy(l)
# Profiling
import cProfile
import pstats
# Start Profiler
pr = cProfile.Profile()
pr.enable()
# Simulation
t = rhizome(g, l, 0.0001, 100)