diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 0000000000000000000000000000000000000000..3e99ede35449c19657050b5668845a4690f035b3
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,7 @@
+{
+ "python.testing.pytestArgs": [
+ "."
+ ],
+ "python.testing.unittestEnabled": false,
+ "python.testing.pytestEnabled": true
+}
\ No newline at end of file
diff --git a/Code_objets/__pycache__/Display.cpython-310.pyc b/Code_objets/__pycache__/Display.cpython-310.pyc
index b2170e9591314447e8a13d70e170b9cae774f34b..ce8f04f19664a039fe127ec94b25b6607f4ace33 100644
Binary files a/Code_objets/__pycache__/Display.cpython-310.pyc and b/Code_objets/__pycache__/Display.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/ImageProcessing.cpython-310.pyc b/Code_objets/__pycache__/ImageProcessing.cpython-310.pyc
index 08735fde6bd45504c90013cab1f8dcb071789803..c99760e2bcecd0066e7f4f9d7b9ae4529e83bce2 100644
Binary files a/Code_objets/__pycache__/ImageProcessing.cpython-310.pyc and b/Code_objets/__pycache__/ImageProcessing.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/Main.cpython-310.pyc b/Code_objets/__pycache__/Main.cpython-310.pyc
index 68af849b8fc70a0c48ed4b41d9d702408da65197..a0b1bc93be8307a1b2f8d23e2810a75c30885253 100644
Binary files a/Code_objets/__pycache__/Main.cpython-310.pyc and b/Code_objets/__pycache__/Main.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/Menu.cpython-310.pyc b/Code_objets/__pycache__/Menu.cpython-310.pyc
index d58ad8dfad2736a4aa7de1d20331852235f347a7..ce9d7b57e75225fab452216fc37fa6b650f79b01 100644
Binary files a/Code_objets/__pycache__/Menu.cpython-310.pyc and b/Code_objets/__pycache__/Menu.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/Parameters.cpython-310.pyc b/Code_objets/__pycache__/Parameters.cpython-310.pyc
index a1fef98059f7080b27dd78b68da050f302d94867..b0b5de2665bbbec468cb0efca8cf3ece29f80928 100644
Binary files a/Code_objets/__pycache__/Parameters.cpython-310.pyc and b/Code_objets/__pycache__/Parameters.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/Point.cpython-310.pyc b/Code_objets/__pycache__/Point.cpython-310.pyc
index 9439b4b96538d8fb0358552264e1412cc94e2503..8bddbd546715215a73f05cd2f67bd9f319f53228 100644
Binary files a/Code_objets/__pycache__/Point.cpython-310.pyc and b/Code_objets/__pycache__/Point.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/Trajectory.cpython-310.pyc b/Code_objets/__pycache__/Trajectory.cpython-310.pyc
index 074bc8f3824d01f6628aa6e2931e66119f1012d4..6e420dad93b877411490387262f423ac887e6b80 100644
Binary files a/Code_objets/__pycache__/Trajectory.cpython-310.pyc and b/Code_objets/__pycache__/Trajectory.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/UI.cpython-310.pyc b/Code_objets/__pycache__/UI.cpython-310.pyc
index d24001918bbdac43b390957180891882d316a121..d26ef227592781f64a23482cc23af63b687e5f37 100644
Binary files a/Code_objets/__pycache__/UI.cpython-310.pyc and b/Code_objets/__pycache__/UI.cpython-310.pyc differ
diff --git a/Code_objets/__pycache__/VideoManager.cpython-310.pyc b/Code_objets/__pycache__/VideoManager.cpython-310.pyc
index 96cd74133fa8fe645feb42105a8e077505bfff2f..5d76ee88c89b7894e9d867b2fa10899bd4c1b2e7 100644
Binary files a/Code_objets/__pycache__/VideoManager.cpython-310.pyc and b/Code_objets/__pycache__/VideoManager.cpython-310.pyc differ
diff --git a/Objet/__pycache__/Main.cpython-311.pyc b/Objet/__pycache__/Main.cpython-311.pyc
index 6c36253f77e5d7c3c77b1afea31dfd4593f3c8ea..9650b6d6c710b4caf08a34c7840b5ab85e5d5f0e 100644
Binary files a/Objet/__pycache__/Main.cpython-311.pyc and b/Objet/__pycache__/Main.cpython-311.pyc differ
diff --git a/Objet/__pycache__/display.cpython-311.pyc b/Objet/__pycache__/display.cpython-311.pyc
index 696fe0c14ae595903f24b7cb38ee0af0fa6dd156..7e6753e1edd62c86d99ae01c911a78f5c095fb43 100644
Binary files a/Objet/__pycache__/display.cpython-311.pyc and b/Objet/__pycache__/display.cpython-311.pyc differ
diff --git a/Objet/__pycache__/gestion_clavier.cpython-311.pyc b/Objet/__pycache__/gestion_clavier.cpython-311.pyc
index 590ba738b72bff5a20dfc6be07e690c9bd60c3d6..279d5910c609a4f128b26975390f670ec592c273 100644
Binary files a/Objet/__pycache__/gestion_clavier.cpython-311.pyc and b/Objet/__pycache__/gestion_clavier.cpython-311.pyc differ
diff --git a/Objet/__pycache__/main.cpython-310.pyc b/Objet/__pycache__/main.cpython-310.pyc
index 5cc024724307d9d45be4574c2b3f472aaa136ee6..d0b4158647e682823c630cad49ac967424325081 100644
Binary files a/Objet/__pycache__/main.cpython-310.pyc and b/Objet/__pycache__/main.cpython-310.pyc differ
diff --git a/Objet/__pycache__/menu.cpython-310.pyc b/Objet/__pycache__/menu.cpython-310.pyc
index 995153ef28663e9975adb7abe4c3546fa8d2f720..83015087dea9d2d6546eccdd7ddb7b9648a3198e 100644
Binary files a/Objet/__pycache__/menu.cpython-310.pyc and b/Objet/__pycache__/menu.cpython-310.pyc differ
diff --git a/Objet/__pycache__/menu.cpython-311.pyc b/Objet/__pycache__/menu.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1dd123c2ab29bb7189def5dfb08111f7f71deb3c
Binary files /dev/null and b/Objet/__pycache__/menu.cpython-311.pyc differ
diff --git a/Objet/__pycache__/parameters.cpython-311.pyc b/Objet/__pycache__/parameters.cpython-311.pyc
index 8f49743d82bc9d6ff302d10b690c7442891f5810..89ec17d9176eee6fa9295a78af3d991641e27c0b 100644
Binary files a/Objet/__pycache__/parameters.cpython-311.pyc and b/Objet/__pycache__/parameters.cpython-311.pyc differ
diff --git a/Objet/__pycache__/trajectory.cpython-310.pyc b/Objet/__pycache__/trajectory.cpython-310.pyc
index 35ca0cd65d6446c011005698b7cdd58aba4f8d3a..4f22c7283a097c3f0f0c0ab9fec80bb9bac23711 100644
Binary files a/Objet/__pycache__/trajectory.cpython-310.pyc and b/Objet/__pycache__/trajectory.cpython-310.pyc differ
diff --git a/Objet/__pycache__/trajectory.cpython-311.pyc b/Objet/__pycache__/trajectory.cpython-311.pyc
index dae8102cea7d3b9d680bb05a54abb5395c77fd60..8fc4ff91f7e611711af5beaacce3da6e0d51c389 100644
Binary files a/Objet/__pycache__/trajectory.cpython-311.pyc and b/Objet/__pycache__/trajectory.cpython-311.pyc differ
diff --git a/Objet/__pycache__/ui.cpython-310.pyc b/Objet/__pycache__/ui.cpython-310.pyc
index 403d169a1c35e1a378410a8362e2153cfbedd86a..64e48af625d2e8ce57e84cb50d9d8a511d05fcf1 100644
Binary files a/Objet/__pycache__/ui.cpython-310.pyc and b/Objet/__pycache__/ui.cpython-310.pyc differ
diff --git a/Objet/__pycache__/ui.cpython-311.pyc b/Objet/__pycache__/ui.cpython-311.pyc
index 917d891e9647dcbe9f5873614db6496327244255..d44d5867c48f7b92671def24eacf9b6e41e1e523 100644
Binary files a/Objet/__pycache__/ui.cpython-311.pyc and b/Objet/__pycache__/ui.cpython-311.pyc differ
diff --git a/Objet/__pycache__/video_manager.cpython-311.pyc b/Objet/__pycache__/video_manager.cpython-311.pyc
index d585046aec8b7ecf4085b94f5440c4c0a638c932..5515052c6d606809864a20f978a948770d110a55 100644
Binary files a/Objet/__pycache__/video_manager.cpython-311.pyc and b/Objet/__pycache__/video_manager.cpython-311.pyc differ
diff --git a/Objet/display.py b/Objet/display.py
index f733da11f820b58551cdceb8ee738cc39a8c445e..734479a713556417b263f6f96305940074c22cdb 100644
--- a/Objet/display.py
+++ b/Objet/display.py
@@ -32,18 +32,23 @@ class Display():
def unprocessed_frame_copy(self):
return self.unprocessed_frame.copy()
- def draw_all_points(self):
+ def draw_all_points(self, brightness = 1):
+ background = self.frame.copy()
for point in self.param.interesting_points:
if point.name != "curs" and point.name != "bar_point_left" and point.name != "bar_point_right":
self.draw_point(point)
+ self.frame = cv2.addWeighted(background, 1 - brightness, self.frame, brightness, 0)
+
+
def draw_point(self, point):
cv2.circle(self.frame, point.pos_int(), 3, point.color, 3)
- def draw_shape(self, param_list = ["net", "ant", "wind", "height", "bar"]):
+ def draw_shape(self, brightness = 1, param_list = ["net", "ant", "wind", "height", "bar"]):
def get_point(name):
return self.param.get_point(name)
-
+
+ background = self.frame.copy()
for shape in param_list:
if shape == "net":
self.draw_line(get_point("ant_bl"), get_point("ant_br"), (255, 255, 0))
@@ -61,8 +66,7 @@ class Display():
self.draw_line(get_point("bar_point_left"), get_point("bar_point"), (0, 0, 0), 5)
self.draw_line(get_point("bar_point_right"), get_point("bar_point"), (100, 100, 100), 5)
-
-
+ self.frame = cv2.addWeighted(background, 1 - brightness, self.frame, brightness, 0)
'''cv2.line(display.frame, (0, int(info[5])), (s_w, int(info[5])), (255, 255, 255), 2)
cv2.putText(display.frame, "Hauteur de mire : " + str(round(hau_mire, 1)),(0, 20), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 0, 0), 2)
@@ -88,7 +92,11 @@ class Display():
self.draw_line(point3, point4, color)
self.draw_line(point4, point1, color)
-
+ def display(self, brightness):
+ self.draw_shape(brightness)
+ self.draw_all_points(brightness)
+ self.draw_traj()
+ cv2.imshow('main', self.frame)
if __name__ == "__main__":
diff --git a/Objet/gestion_clavier.py b/Objet/gestion_clavier.py
index c2d0df567f4a09d6bd350687ceb91d4aa0c6b828..5de197301b1184147a28c265814e97c9811662f0 100644
--- a/Objet/gestion_clavier.py
+++ b/Objet/gestion_clavier.py
@@ -1,6 +1,6 @@
import subprocess
-def update(key, vid_mana, session, ui, prev_mode, mode):
+def update(key, vid_mana, session, ui, param, prev_mode, mode):
if key == ord('q'):
return "over", "over"
if key == ord('s'):
@@ -23,7 +23,11 @@ def update(key, vid_mana, session, ui, prev_mode, mode):
mode = prev_mode
if key == 13:
- ui.linked = not ui.linked
+ ui.change_setting_mode()
+
+ if key == 27:
+ param.change_window_mode()
+
return prev_mode, mode
diff --git a/Objet/main.py b/Objet/main.py
index 8d3ca4b55d890a0912efd986317edd8e516e72f4..c740e869ff59a0d63db0166d078e291663f2d16a 100644
--- a/Objet/main.py
+++ b/Objet/main.py
@@ -1,3 +1,4 @@
+ready = False
import time
import cv2
import numpy as np
@@ -34,11 +35,14 @@ class Main:
self.mode = "video"
self.prev_mode = "video"
+
def run(self):
+ global ready
+ ready = True
while self.mode != "over":
self.display.load_frame(self.vid_mana.frame)
key = cv2.waitKey(1) & 0xFF
- self.prev_mode, self.mode = gc.update(key, self.vid_mana, self.session, self.ui, self.prev_mode, self.mode)
+ self.prev_mode, self.mode = gc.update(key, self.vid_mana, self.session, self.ui, self.param, self.prev_mode, self.mode)
self.ui.move_parameters()
if self.mode == "video":
@@ -47,29 +51,25 @@ class Main:
break
all_ball = self.im_proc.get_all_ball(self.vid_mana.frame)
self.traj.update(all_ball)
-
if self.traj.is_over:
self.session.load_traj(self.traj)
self.traj = Trajectory(self.param)
self.display.load_traj(self.traj)
self.session.next_video()
-
- self.display.draw_shape()
- self.display.draw_traj()
-
- if self.mode == "parameters":
+ elif self.mode == "parameters":
darken_factor = 0.5
self.display.frame = (self.display.frame * darken_factor).astype(np.uint8)
- if self.ui.is_mouse_moving():
- self.display.draw_all_points()
-
- cv2.imshow('main', self.display.frame)
- self.session.load(self.display.frame)
+
+ self.display.display(self.ui.brightness)
+ #self.session.load(self.display.frame)
#cv2.imshow('main', im_proc.processed_frame_difference)
cv2.destroyAllWindows()
if __name__ == "__main__":
- main = Main("vid4.mp4", "video")
- main.run()
\ No newline at end of file
+ main = Main("vid3.mp4", "video")
+ main.run()
+
+def is_ready():
+ return ready
\ No newline at end of file
diff --git a/Objet/parameters.py b/Objet/parameters.py
index 5d0c43bdcb61d8a77aa8c7b0e5eedfb13da2acdc..3d7fe79f5ea77557574d6c9a9c4f05f02715142e 100644
--- a/Objet/parameters.py
+++ b/Objet/parameters.py
@@ -13,14 +13,15 @@ class Parameters:
screen = screeninfo.get_monitors()[0]
self.width = screen.width
self.height = screen.height
+ self.mode = "full"
# Liste des points intéressants
self.interesting_points = [
Point_param("ant_tl", self.width / 5, 2 * self.height / 5, (0, 0, 255)),
Point_param("wind_l_tl", self.width * 3 / 10, 2 * self.height / 5, (0, 255, 0)),
Point_param("wind_l_br", self.width * 4 / 10, self.height * 12 / 25, (0, 255, 0)),
- Point_param("wind_r_tl", self.width * 7 / 10, 2 * self.height / 5, (0, 255, 0)),
- Point_param("wind_r_br", self.width * 6 / 10, self.height * 12 / 25, (0, 255, 0)),
+ Point_param("wind_r_tl", self.width * 6 / 10, 2 * self.height / 5, (0, 255, 0)),
+ Point_param("wind_r_br", self.width * 7 / 10, self.height * 12 / 25, (0, 255, 0)),
Point_param("set_height", self.width/2, self.height / 4,(255, 255, 255)),
Point_param("set_margin_over", self.width/2, self.height * 3 / 16, (200, 200, 200)),
Point_param("set_margin_under", self.width/2, self.height * 5 / 16, (200, 200, 200))
@@ -39,6 +40,13 @@ class Parameters:
self.ant_height = self.get_point("net").y - self.get_point("ant_tl").y
+ def change_window_mode(self):
+ if self.mode == "full":
+ cv2.setWindowProperty('main', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_NORMAL)
+ self.mode = "normal"
+ else:
+ cv2.setWindowProperty('main', cv2.WND_PROP_FULLSCREEN, cv2.WINDOW_FULLSCREEN)
+ self.mode = "full"
def get_point(self, name):
for point in self.interesting_points:
diff --git a/Objet/ui.py b/Objet/ui.py
index 9b67f420d80bca2147b23193592a39804308a2b4..f79a3ae531720c067f1bac5c2643335c7a0c7c14 100644
--- a/Objet/ui.py
+++ b/Objet/ui.py
@@ -30,10 +30,15 @@ class UI:
self.param.interesting_points.append(self.bar_point)
self.touch_bar = False
self.last_mouse_move = time.time()
+ self.flag_mouse_moving = False
+ self.flag_mouse_freeze = False
+ self.phase = 'imm'
+ self.brightness = 0
+ self.time_phase = 0
self.point_pp = copy.copy(self.point_defaut)
- self.linked = False
+ self.setting_locked = False
def update_bar(self):
@@ -42,7 +47,10 @@ class UI:
def move_parameters(self):
cv2.setMouseCallback('main', self.mouse_event)
+ self.update_phase()
self.update_bar()
+ if self.setting_locked:
+ self.update_linked()
if self.dragging and self.point_near:
self.actu_para()
else :
@@ -52,9 +60,54 @@ class UI:
self.point_sel.y = self.point_pp.y
def is_mouse_moving(self):
- return time.time() - self.last_mouse_move < 0.5 or self.point_near
-
+ return time.time() - self.last_mouse_move < 0.6 or self.point_near
+
+ def update_phase(self):
+ if self.phase == 'imm':
+ if time.time() - self.last_mouse_move <= 0.1:
+ self.phase = 'up'
+ self.time_phase = time.time()
+ self.brightness = 0
+ elif self.phase == 'up':
+ if time.time() - self.time_phase <= 0.2:
+ self.brightness = (time.time() - self.time_phase)*5
+ else:
+ self.phase = 'mov'
+ self.brightness = 1
+ self.time_phase = time.time()
+ elif self.phase == 'mov':
+ if self.point_near:
+ self.last_mouse_move = time.time()
+ if time.time() - self.last_mouse_move >= 1:
+ self.phase = 'down'
+ self.time_phase = time.time()
+ self.brightness = 1
+ elif self.phase == 'down':
+ if time.time() - self.last_mouse_move <= 0.1:
+ self.phase = 'mov'
+ self.time_phase = time.time()
+ self.brightness = 1 - (time.time() - self.time_phase)*5
+ if time.time() - self.time_phase >= 0.2:
+ self.phase = 'imm'
+ self.brightness = 0
+
+ def get_brightness(self):
+ if not self.flag_mouse_moving:
+ self.mouse_begin_move = self.last_mouse_move
+ self.flag_mouse_moving = True
+ if 0 <= time.time() - self.mouse_begin_move <= 0.2:
+ return (time.time() - self.mouse_begin_move)*5
+ elif time.time() - self.last_mouse_move <= 0.4:
+ return 1
+ elif 0.6 >= time.time() - self.last_mouse_move >= 0.4 and not self.point_near:
+ return (0.6 - (time.time() - self.last_mouse_move))*5
+ self.flag_mouse_moving = False
+ if self.point_near:
+ self.flag_mouse_moving = False
+ return 1
+
+
def set_bar(self, x):
self.vid_mana.current_frame = int((x - self.bar_left) * self.vid_mana.total_frames / (self.bar_right - self.bar_left))
self.vid_mana.start_time = time.time() - self.vid_mana.current_frame / self.vid_mana.fps
@@ -88,24 +141,24 @@ class UI:
self.point_pp = copy.copy(self.point_defaut)
def change_setting_mode(self):
- if not self.linked:
+ if not self.setting_locked:
self.update_user_info()
- self.linked = not self.linked
+ self.setting_locked = not self.setting_locked
def update_user_info(self):
def get_point(name):
return self.param.get_point(name)
- self.set_heigth = (get_point("net").y - get_point("set_height").y) / (get_point("ant_bl").y - get_point("ant_tl").y)
- self.set_margin_over = (get_point("set_height").y - get_point("set_margin_over").y) / (get_point("ant_bl").y - get_point("ant_tl").y)
- self.set_margin_under = (get_point("set_margin_under").y - get_point("set_height").y) / (get_point("ant_bl").y - get_point("ant_tl").y)
+ self.set_height = (get_point("net").y - get_point("set_height").y) / (get_point("net").y - get_point("ant_tl").y)
+ self.set_margin_over = (get_point("net").y - get_point("set_margin_over").y) / (get_point("net").y - get_point("ant_tl").y)
+ self.set_margin_under = (get_point("net").y - get_point("set_margin_under").y) / (get_point("net").y - get_point("ant_tl").y)
self.wind_l_l = (get_point("wind_l_tl").x - get_point("ant_tl").x) / (get_point("ant_tr").x - get_point("ant_tl").x)
self.wind_l_r = (get_point("wind_l_tr").x - get_point("ant_tl").x) / (get_point("ant_tr").x - get_point("ant_tl").x)
- self.wind_l_t = (get_point("net").y - get_point("wind_l_tl").y) / (get_point("ant_bl").y - get_point("ant_tl").y)
- self.wind_l_b = (get_point("net").y - get_point("wind_l_bl").y) / (get_point("ant_bl").y - get_point("ant_tl").y)
+ self.wind_l_t = (get_point("net").y - get_point("wind_l_tl").y) / (get_point("net").y - get_point("ant_tl").y)
+ self.wind_l_b = (get_point("net").y - get_point("wind_l_bl").y) / (get_point("net").y - get_point("ant_tl").y)
self.wind_r_l = (get_point("ant_tr").x - get_point("wind_r_tl").x) / (get_point("ant_tr").x - get_point("ant_tl").x)
self.wind_r_r = (get_point("ant_tr").x - get_point("wind_r_tr").x) / (get_point("ant_tr").x - get_point("ant_tl").x)
- self.wind_r_t = (get_point("net").y - get_point("wind_r_tr").y) / (get_point("ant_br").y - get_point("ant_tr").y)
- self.wind_r_b = (get_point("net").y - get_point("wind_r_br").y) / (get_point("ant_br").y - get_point("ant_tr").y)
+ self.wind_r_t = (get_point("net").y - get_point("wind_r_tr").y) / (get_point("net").y - get_point("ant_tr").y)
+ self.wind_r_b = (get_point("net").y - get_point("wind_r_br").y) / (get_point("net").y - get_point("ant_tr").y)
def actu_para(self):
def get_point(name):
@@ -169,9 +222,10 @@ class UI:
if is_under("curs", name):
put_over("curs", name)
+
point = self.point_pp
name = point.name
- if not self.linked:
+ if not self.setting_locked:
if name == "net":
update_ref("ant_tl")
update_ref("ant_bl")
@@ -183,13 +237,13 @@ class UI:
valid_to_right("ant_br")
update_ref_x("ant_tl")
update_x()
- update_center_x("net", "ant_bl", "ant_br")
+ update_center("net", "ant_bl", "ant_br")
if name == "ant_br":
valid_to_left("ant_bl")
update_ref_x("ant_tr")
update_x()
- update_center_x("net", "ant_bl", "ant_br")
+ update_center("net", "ant_bl", "ant_br")
if name == "ant_tl":
valid_to_down("ant_bl")
@@ -302,11 +356,64 @@ class UI:
if name == "ant_tl":
valid_to_down("ant_bl")
valid_to_right("ant_tr")
- update_ref_x_list(["ant_bl"])
- update_ref_x("ant_br")
- update_ref_y_list("ant_tr")
update()
- update_center_x(["net", "ant_bl", "ant_br"])
+ get_point("ant_bl").x = get_point("ant_tl").x
+ get_point("ant_tr").y = get_point("ant_tl").y
+ if name == "ant_tr":
+ valid_to_down("ant_br")
+ valid_to_left("ant_tl")
+ update()
+ get_point("ant_br").x = get_point("ant_tr").x
+ get_point("ant_tl").y = get_point("ant_tr").y
+ if name == "ant_bl":
+ valid_to_up("ant_tl")
+ valid_to_right("ant_br")
+ update()
+ get_point("ant_tl").x = get_point("ant_bl").x
+ get_point("ant_br").y = get_point("ant_bl").y
+ if name == "ant_br":
+ valid_to_up("ant_tr")
+ valid_to_left("ant_bl")
+ update()
+ get_point("ant_tr").x = get_point("ant_br").x
+ get_point("ant_bl").y = get_point("ant_br").y
+
+ def update_linked(self):
+ def get_point(name):
+ return self.param.get_point(name)
+ def update_center(name1, name2, name3):
+ get_point(name1).x = self.param.get_center_x(name2, name3)
+ get_point(name1).y = self.param.get_center_y(name2, name3)
+
+ net = get_point("net")
+ ant_height = net.y - get_point("ant_tl").y
+ ant_witdh = get_point("ant_tr").x - get_point("ant_tl").x
+
+ get_point("set_height").y = net.y - self.set_height * ant_height
+ get_point("set_margin_over").y = net.y - self.set_margin_over * ant_height
+ get_point("set_margin_under").y = net.y - self.set_margin_under * ant_height
+ get_point("wind_l_tl").y = net.y - self.wind_l_t * ant_height
+ get_point("wind_l_bl").y = net.y - self.wind_l_b * ant_height
+ get_point("wind_l_tr").y = net.y - self.wind_l_t * ant_height
+ get_point("wind_l_br").y = net.y - self.wind_l_b * ant_height
+
+ get_point("wind_r_tl").y = net.y - self.wind_r_t * ant_height
+ get_point("wind_r_bl").y = net.y - self.wind_r_b * ant_height
+ get_point("wind_r_tr").y = net.y - self.wind_r_t * ant_height
+ get_point("wind_r_br").y = net.y - self.wind_r_b * ant_height
+
+ get_point("wind_l_tl").x = get_point("ant_tl").x + self.wind_l_l * ant_witdh
+ get_point("wind_l_bl").x = get_point("ant_tl").x + self.wind_l_l * ant_witdh
+ get_point("wind_l_tr").x = get_point("ant_tl").x + self.wind_l_r * ant_witdh
+ get_point("wind_l_br").x = get_point("ant_tl").x + self.wind_l_r * ant_witdh
+ get_point("wind_r_tl").x = get_point("ant_tr").x - self.wind_r_l * ant_witdh
+ get_point("wind_r_bl").x = get_point("ant_tr").x - self.wind_r_l * ant_witdh
+ get_point("wind_r_tr").x = get_point("ant_tr").x - self.wind_r_r * ant_witdh
+ get_point("wind_r_br").x = get_point("ant_tr").x - self.wind_r_r * ant_witdh
+
+ update_center("wind_l_m", "wind_l_tl", "wind_l_br")
+ update_center("wind_r_m", "wind_r_tl", "wind_r_br")
+ update_center("net", "ant_bl", "ant_br")
if __name__ == "__main__":
diff --git a/Objet/video_manager.py b/Objet/video_manager.py
index 5941a34ad034ee5e6faa1b2d1b5e0431968e467f..91aec94570df2d213b8ad77c800b97828187d379 100644
--- a/Objet/video_manager.py
+++ b/Objet/video_manager.py
@@ -19,10 +19,19 @@ class VideoManager:
self.video_type = video_type
if self.video_type == "video":
self.cap = cv2.VideoCapture(self.video_file)
- elif self.video_type == "camera":
- self.cam_index = self.select_camera()
- self.cam_index = 0
- self.cap = cv2.VideoCapture(self.cam_index)
+ elif self.video_type == "direct":
+ max_cameras=10
+ backend=cv2.CAP_DSHOW
+ available_cameras = []
+ for i in range(max_cameras):
+ cap = cv2.VideoCapture(i, backend)
+ if cap.isOpened():
+ ret, frame = cap.read()
+ if ret:
+ available_cameras.append(i)
+ cap.release()
+ print(available_cameras)
+ self.cap = cv2.VideoCapture(0)
self.fps = int(self.cap.get(cv2.CAP_PROP_FPS))
self.total_frames = int(self.cap.get(cv2.CAP_PROP_FRAME_COUNT))
self.over = False
@@ -68,20 +77,24 @@ class VideoManager:
def update_frame(self):
- frame_time = time.time() - self.current_time
- self.current_time = time.time()
- self.time = self.current_time - self.start_time
- self.current_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
- frame_targeted = int(self.time * self.fps)
- jump_frame = frame_targeted - self.current_frame
-
- for _ in range(jump_frame):
- ret, self.frame = self.cap.read()
- if not ret:
- self.over = True
- break
- self.frame = cv2.resize(self.frame, (self.parameters.width, self.parameters.height))
- self.current_frame += 1
+ if self.video_type == "video":
+ self.current_time = time.time()
+ self.time = self.current_time - self.start_time
+ self.current_frame = int(self.cap.get(cv2.CAP_PROP_POS_FRAMES))
+ frame_targeted = int(self.time * self.fps)
+ jump_frame = frame_targeted - self.current_frame
+
+ for _ in range(jump_frame):
+ ret, self.frame = self.cap.read()
+ if not ret:
+ self.over = True
+ break
+ self.frame = cv2.resize(self.frame, (self.parameters.width, self.parameters.height))
+ self.current_frame += 1
+
+ elif self.video_type == "direct":
+ self.update_frame_easy()
+ self.current_frame += 1
def update_frame_easy(self):
_, self.frame = self.cap.read()
diff --git "a/__pycache__/chercher_cam\303\251ra.cpython-311.pyc" "b/__pycache__/chercher_cam\303\251ra.cpython-311.pyc"
new file mode 100644
index 0000000000000000000000000000000000000000..8ffd2f7914e490cd758c2c24ba0cdcea184b31bd
Binary files /dev/null and "b/__pycache__/chercher_cam\303\251ra.cpython-311.pyc" differ
diff --git a/__pycache__/test_chargement.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_chargement.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..bed2af3036449cfaded3317402fe03f409368ef1
Binary files /dev/null and b/__pycache__/test_chargement.cpython-310-pytest-8.3.5.pyc differ
diff --git a/__pycache__/test_chargementlogo.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_chargementlogo.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..d86cdf7ed8ae115c53013759543d938d3abcd92e
Binary files /dev/null and b/__pycache__/test_chargementlogo.cpython-310-pytest-8.3.5.pyc differ
diff --git a/__pycache__/test_chercherdossier.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_chercherdossier.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..25417afddbde93e39f88d3e1f99cdcb58df095c4
Binary files /dev/null and b/__pycache__/test_chercherdossier.cpython-310-pytest-8.3.5.pyc differ
diff --git a/__pycache__/test_multithrading_logo.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_multithrading_logo.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..5c0355b28dae0907d99d34d4ef2e093187125f88
Binary files /dev/null and b/__pycache__/test_multithrading_logo.cpython-310-pytest-8.3.5.pyc differ
diff --git a/__pycache__/test_nouveautestthreding.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_nouveautestthreding.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b7db4f230e6cee64220aa083eded1e5add967254
Binary files /dev/null and b/__pycache__/test_nouveautestthreding.cpython-310-pytest-8.3.5.pyc differ
diff --git a/__pycache__/test_recup_info.cpython-310-pytest-8.3.5.pyc b/__pycache__/test_recup_info.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b4fa344dffe4931e1f8c95f4a81c7dc0ed4dd8bb
Binary files /dev/null and b/__pycache__/test_recup_info.cpython-310-pytest-8.3.5.pyc differ
diff --git a/chargement.py b/chargement.py
new file mode 100644
index 0000000000000000000000000000000000000000..36a2f01e5c3f76a1fe0116ee5f5ac5cc9966c04a
--- /dev/null
+++ b/chargement.py
@@ -0,0 +1,51 @@
+import inspect
+import time
+
+def count_function_lines(func):
+ """Counts the number of lines in a function."""
+ source_lines = inspect.getsourcelines(func)[0]
+ return len(source_lines)
+
+def progress_percentage(func, lines_done):
+ """Calculates the percentage of lines completed in a function."""
+ total_lines = count_function_lines(func)
+ if total_lines == 0:
+ return 0
+ return (lines_done / total_lines) * 100
+def current_line():
+ """Returns the current line number being executed in a function."""
+ return inspect.currentframe().f_back.f_lineno
+def fonction_longue():
+# Simulate a long function
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+ time.sleep(2)
+
+if __name__ == '__main__':
+ while progress_percentage(fonction_longue, current_line) < 100:
+ print(f"Line {current_line}: {progress_percentage(fonction_longue, current_line):.2f}%")
+ time.sleep(0.5)
+
+
diff --git "a/chercher_cam\303\251ra.py" "b/chercher_cam\303\251ra.py"
new file mode 100644
index 0000000000000000000000000000000000000000..0dbb4d793b333212f10a9662f3f281a07cbe3718
--- /dev/null
+++ "b/chercher_cam\303\251ra.py"
@@ -0,0 +1,98 @@
+import cv2
+import tkinter as tk
+from tkinter import ttk
+from PIL import Image, ImageTk
+import threading
+
+class CameraSelector:
+ def __init__(self, root):
+ self.root = root
+ self.root.title("Sélection de caméra")
+ self.cameras = []
+ self.current_camera = None
+ self.video_source = None
+
+ # Détection des caméras disponibles
+ self.detect_cameras()
+
+ # Interface graphique
+ self.create_widgets()
+
+ def detect_cameras(self):
+ """Détecte toutes les caméras disponibles jusqu'à l'index 10"""
+ self.cameras = []
+ for i in range(10): # Vous pouvez augmenter ce nombre si nécessaire
+ cap = cv2.VideoCapture(i)
+ if cap.isOpened():
+ self.cameras.append(i)
+ cap.release()
+
+ def create_widgets(self):
+ """Crée l'interface utilisateur"""
+ # Cadre principal
+ main_frame = ttk.Frame(self.root, padding=10)
+ main_frame.pack()
+
+ # Sélection de caméra
+ ttk.Label(main_frame, text="Caméras détectées:").pack()
+ self.camera_var = tk.StringVar()
+ self.cam_selector = ttk.Combobox(main_frame, textvariable=self.camera_var)
+ self.cam_selector['values'] = [f"Caméra {i}" for i in self.cameras]
+ self.cam_selector.pack(pady=5)
+
+ # Bouton de confirmation
+ ttk.Button(main_frame, text="Ouvrir", command=self.start_camera).pack(pady=5)
+
+ # Zone d'affichage vidéo
+ self.video_label = ttk.Label(main_frame)
+ self.video_label.pack()
+
+ def start_camera(self):
+ """Démarre le flux vidéo de la caméra sélectionnée"""
+ if self.current_camera is not None:
+ self.stop_camera()
+
+ selected = self.cam_selector.current()
+ if selected == -1:
+ return
+
+ self.video_source = self.cameras[selected]
+ self.current_camera = cv2.VideoCapture(self.video_source)
+
+ # Démarrer l'affichage vidéo dans un thread séparé
+ self.thread = threading.Thread(target=self.show_video)
+ self.thread.daemon = True
+ self.thread.start()
+
+ def show_video(self):
+ """Affiche le flux vidéo dans le label"""
+ while self.current_camera.isOpened():
+ ret, frame = self.current_camera.read()
+ if ret:
+ # Conversion de l'image pour Tkinter
+ frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+ img = Image.fromarray(frame)
+ imgtk = ImageTk.PhotoImage(image=img)
+
+ # Mise à jour de l'interface
+ self.video_label.configure(image=imgtk)
+ self.video_label.image = imgtk
+ else:
+ break
+
+ def stop_camera(self):
+ """Arrête le flux vidéo"""
+ if self.current_camera is not None:
+ self.current_camera.release()
+ self.video_label.configure(image='')
+ self.video_label.image = None
+
+ def on_close(self):
+ self.stop_camera()
+ self.root.destroy()
+
+if __name__ == "__main__":
+ root = tk.Tk()
+ app = CameraSelector(root)
+ root.protocol("WM_DELETE_WINDOW", app.on_close)
+ root.mainloop()
\ No newline at end of file
diff --git a/gopro.py b/gopro.py
new file mode 100644
index 0000000000000000000000000000000000000000..eb8ad913f02f7c90c5fea6757e7c3452ce143e67
--- /dev/null
+++ b/gopro.py
@@ -0,0 +1,61 @@
+import cv2
+import numpy as np
+import goprocam
+from goprocam import GoProCamera, constants
+#modif
+def list_cameras():
+ """ Liste les caméras disponibles et retourne leurs indices. """
+ index = 0
+ available_cameras = []
+ while True:
+ cap = cv2.VideoCapture(index)
+ if not cap.read()[0]:
+ break
+ else:
+ available_cameras.append(index)
+ cap.release()
+ index += 1
+ return available_cameras
+
+def select_camera():
+ cameras = list_cameras()
+ if not cameras:
+ print("Aucune caméra détectée.")
+ return None
+ print("Caméras disponibles :", cameras)
+ selected = int(input("Sélectionnez l'indice de votre GoPro : "))
+ return selected if selected in cameras else None
+
+def record_video(camera_index):
+ cap = cv2.VideoCapture(camera_index)
+ if not cap.isOpened():
+ print("Impossible d'accéder à la caméra.")
+ return
+
+ fourcc = cv2.VideoWriter_fourcc(*'XVID')
+ out = cv2.VideoWriter('gopro_output.avi', fourcc, 30.0, (640, 480))
+
+ while True:
+ ret, frame = cap.read()
+ if not ret:
+ break
+ cv2.imshow('GoPro Video', frame)
+ out.write(frame)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'):
+ break
+
+ cap.release()
+ out.release()
+ cv2.destroyAllWindows()
+
+if __name__ == "__main__":
+ print("Connexion à la GoPro...")
+ gopro = GoProCamera.GoPro()
+ gopro.webcamFOV("medium")
+ gopro.startWebcam()
+ cam_index = select_camera()
+ if cam_index is not None:
+ record_video(cam_index)
+ else:
+ print("Sélection invalide.")
\ No newline at end of file
diff --git a/gopro_output.avi b/gopro_output.avi
new file mode 100644
index 0000000000000000000000000000000000000000..e4232cb70f1a5a007ac0f85097045558eed32a3e
Binary files /dev/null and b/gopro_output.avi differ
diff --git a/multithreading.py b/multithreading.py
new file mode 100644
index 0000000000000000000000000000000000000000..5d2d61e3ca7f74ba0ac19c355be5cb3fbcdc78db
--- /dev/null
+++ b/multithreading.py
@@ -0,0 +1,39 @@
+import time
+import threading
+
+# Fonction qui effectue une partie du travail
+def tache_lourde(part_debut, part_fin, resultat, index):
+ somme = 0
+ for i in range(part_debut, part_fin):
+ somme += 1
+ resultat[index] = somme # Stocker le résultat pour éviter la concurrence
+
+# Paramètres
+N = 10**7 # Taille du travail total
+THREADS = 4 # Nombre de threads à utiliser
+
+# Exécution sans multithreading
+start = time.time()
+somme_total = sum(range(N)) # Exécution en une seule fois
+end = time.time()
+print(f"Temps sans multithreading: {end - start:.2f} secondes")
+
+# Exécution avec multithreading
+start = time.time()
+threads = []
+resultats = [0] * THREADS # Stocker les résultats des threads
+portion = N // THREADS # Taille de la charge par thread
+
+for i in range(THREADS):
+ debut = i * portion
+ fin = N if i == THREADS - 1 else (i + 1) * portion
+ thread = threading.Thread(target=tache_lourde, args=(debut, fin, resultats, i))
+ threads.append(thread)
+ thread.start()
+
+for thread in threads:
+ thread.join() # Attendre la fin de tous les threads
+
+somme_total_thread = sum(resultats) # Fusionner les résultats
+end = time.time()
+print(f"Temps avec multithreading: {end - start:.2f} secondes")
diff --git a/output_image.png b/output_image.png
new file mode 100644
index 0000000000000000000000000000000000000000..1dbdc6e565ee67601207b8f27bc8203717c1c713
Binary files /dev/null and b/output_image.png differ
diff --git a/success_probability_vs_E.png b/success_probability_vs_E.png
new file mode 100644
index 0000000000000000000000000000000000000000..79bd413b21f4d89c0ceaab57923b5ac49b0d7101
Binary files /dev/null and b/success_probability_vs_E.png differ
diff --git a/test_chargement.py b/test_chargement.py
index a7ed873ba88da90e8dc3376948511c0402c98810..3283d09869ec1fb332801927d1c906aa4f18eb7f 100644
--- a/test_chargement.py
+++ b/test_chargement.py
@@ -1,9 +1,11 @@
import time
+import threading
+import os
+import sys
from tkinter import Tk, Label
from PIL import Image, ImageTk # Installer Pillow si nécessaire : pip install pillow
-# Lancer ton programme principal ici
-
+# --- Création du Splash Screen ---
splash = Tk()
splash.overrideredirect(True) # Enlever la barre de titre
@@ -22,30 +24,30 @@ splash.geometry(f"{img_width}x{img_height}+{x_pos}+{y_pos}")
# Afficher l'image
label = Label(splash, image=photo)
label.pack()
+splash.update() # Mise à jour de l'affichage
-# Garder le splash pendant le chargement
-splash.update()
-
-# Pour éviter que le programme ne se ferme instantanément
-
-
-
-import os
-import sys
+# --- Fonction pour charger le menu principal ---
+def charger_menu():
+ global splash
+ base_dir = os.path.dirname(os.path.abspath(__file__))
+ dossier_path = os.path.join(base_dir, 'Objet')
+ sys.path.append(dossier_path)
+ import menu # Importer ici pour éviter les blocages
+ temps = time.time()
+
+ a = menu.App() # Chargement du menu
+ splash.destroy() # Fermer le splash après le chargement
-# Fermer le splash et ouvrir le menu principal
-base_dir = os.path.dirname(os.path.abspath(__file__))
+ tmp = time.time()
+ print(f"Temps d'exécution : {-(temps - tmp):.6f} secondes")
-dossier_path = os.path.join(base_dir,'Objet')
-sys.path.append(dossier_path)
+ a.mainloop() # Lancer l'application principale
+
-import menu
-temps = time.time()
-a = menu.App()
-splash.destroy()
-tmp = time.time()
-a.mainloop()
+# --- Lancer le chargement en arrière-plan ---
+thread = threading.Thread(target=charger_menu)
+thread.start()
-tot = temps - tmp
-print(f"Temps d'exécution : {-tot:.6f} secondes")
\ No newline at end of file
+# --- Affichage du splash screen pendant le chargement ---
+splash.mainloop()
diff --git a/test_chargementlogo.py b/test_chargementlogo.py
new file mode 100644
index 0000000000000000000000000000000000000000..bc9a592a3b3956eb5d85184d356286f3cf7ca3b3
--- /dev/null
+++ b/test_chargementlogo.py
@@ -0,0 +1,54 @@
+import time
+from PIL import Image, ImageEnhance, ImageTk
+import tkinter as tk
+
+def adjust_transparency(image_path, charge_percentage):
+ # Open the image
+ image = Image.open(image_path).convert("RGBA")
+ # Split the image into channels
+ r, g, b, alpha = image.split()
+ # Adjust the alpha channel based on charge percentage
+ alpha = alpha.point(lambda p: p * (charge_percentage / 100))
+ # Merge channels back
+ return Image.merge("RGBA", (r, g, b, alpha))
+
+def fake_charging(image_path):
+ # Create a Tkinter window
+ root = tk.Tk()
+ root.title("Charging...")
+
+ # Load the initial image
+ charge_percentage = 0
+ image = adjust_transparency(image_path, charge_percentage)
+ tk_image = ImageTk.PhotoImage(image)
+
+ # Create a label to display the image
+ label = tk.Label(root, image=tk_image)
+ label.pack()
+
+ def update_image():
+ nonlocal charge_percentage, tk_image
+ if charge_percentage < 100:
+ # Increment charge percentage smoothly
+ charge_percentage += 1
+ # Adjust transparency and update the image
+ image = adjust_transparency(image_path, charge_percentage)
+ tk_image = ImageTk.PhotoImage(image)
+ label.config(image=tk_image)
+ label.image = tk_image
+ root.title(f"Charging... {charge_percentage}%")
+ root.after(50, update_image) # Update every 50ms for smoother transition
+ else:
+ root.title("Charging complete!")
+
+ # Start updating the image
+ update_image()
+ root.mainloop()
+
+def main():
+ # Use the specified image
+ image_path = "LogoSymbole_canard.png"
+ fake_charging(image_path)
+
+if __name__ == "__main__":
+ main()
diff --git a/test_cherchercamera.py b/test_cherchercamera.py
new file mode 100644
index 0000000000000000000000000000000000000000..6ae040fe2299985c25b17371d3d3d938bb1950b5
--- /dev/null
+++ b/test_cherchercamera.py
@@ -0,0 +1,32 @@
+import chercher_caméra as cc
+import cv2
+import tkinter as tk
+
+def select_camera_lanceemnt():
+ camera_index = cc.select_camera()
+ if camera_index is not None:
+ cap = cv2.VideoCapture(camera_index)
+ if not cap.isOpened():
+ print("Erreur : Impossible d'ouvrir la caméra.")
+ return
+
+ while True:
+ ret, frame = cap.read()
+ if not ret:
+ print("Erreur : Impossible de lire le flux vidéo.")
+ break
+
+ cv2.imshow("Flux vidéo", frame)
+
+ if cv2.waitKey(1) & 0xFF == ord('q'): # Appuyez sur 'q' pour quitter
+ break
+
+ cap.release()
+ cv2.destroyAllWindows()
+ if camera_index is not None:
+ print(f"Caméra sélectionnée : {camera_index}")
+ else:
+ print("Aucune caméra sélectionnée.")
+
+if __name__ == "__main__":
+ select_camera_lanceemnt()
\ No newline at end of file
diff --git a/test_chercherdossier.py b/test_chercherdossier.py
index b38b9876adbd58be61ca6ca1d6d20b0e8377cddb..4b59e22711c326131b318c0f21a1f25c1bf584a0 100644
--- a/test_chercherdossier.py
+++ b/test_chercherdossier.py
@@ -1,11 +1,39 @@
import os
import sys
+import time
+import threading
+import os
+import sys
+from tkinter import Tk, Label
+from PIL import Image, ImageTk # Installer Pillow si nécessaire : pip install pillow
+
+# --- Création du Splash Screen ---
+splash = Tk()
+splash.overrideredirect(True) # Enlever la barre de titre
+
+# Charger l'image
+image = Image.open("LogoSymbole_canard.png")
+photo = ImageTk.PhotoImage(image)
+
+# Définir la taille et centrer
+screen_width = splash.winfo_screenwidth()
+screen_height = splash.winfo_screenheight()
+img_width, img_height = image.size
+x_pos = (screen_width - img_width) // 2
+y_pos = (screen_height - img_height) // 2
+splash.geometry(f"{img_width}x{img_height}+{x_pos}+{y_pos}")
+
+# Afficher l'image
+label = Label(splash, image=photo)
+label.pack()
+splash.update() # Mise à jour de l'affichage
base_dir = os.path.dirname(os.path.abspath(__file__))
-dossier_path = os.path.join(base_dir,'Code_objets')
+dossier_path = os.path.join(base_dir,'Objet')
sys.path.append(dossier_path)
-import Menu
-a = Menu.App()
+import menu
+a = menu.App()
+splash.destroy()
a.mainloop()
diff --git a/test_multithrading_logo.py b/test_multithrading_logo.py
index f027b1417b66c1fb30e73dc3d471326e3914c591..6d58413ba07346e1310d55f1fb762aaff96aa435 100644
--- a/test_multithrading_logo.py
+++ b/test_multithrading_logo.py
@@ -3,20 +3,17 @@ from PIL import Image, ImageTk
import threading
import time
-
-
-# Fonction pour afficher le splash screen
def show_splash():
- global splash # Garder une référence à la fenêtre
+ global splash, photo
splash = tk.Tk()
- splash.overrideredirect(True) # Enlever la barre de titre
+ splash.overrideredirect(True)
# Charger l'image
- image = Image.open("LogoSymbole_canard.png") # Remplace par ton logo
+ image = Image.open("LogoSymbole_canard.png")
photo = ImageTk.PhotoImage(image)
- # Définir la taille et centrer
+ # Centrer la fenêtre
screen_width = splash.winfo_screenwidth()
screen_height = splash.winfo_screenheight()
img_width, img_height = image.size
@@ -24,40 +21,41 @@ def show_splash():
y_pos = (screen_height - img_height) // 2
splash.geometry(f"{img_width}x{img_height}+{x_pos}+{y_pos}")
- # Afficher l'image
label = tk.Label(splash, image=photo)
+ label.image = photo # Évite la suppression de l'image par le garbage collector
label.pack()
- splash.update()
- splash.mainloop() # Garde la fenêtre active jusqu'à ce qu'on la ferme
+ # Lancer le thread du programme principal
+ global main_thread
+ main_thread = threading.Thread(target=load_main_program, daemon=True)
+ main_thread.start()
-# Fonction pour charger le programme principal
-def load_main_program():
- time.sleep(3) # Simule un chargement
+ # Vérifier périodiquement si le programme principal est chargé
+ splash.after(100, check_thread)
- # Fermer l'écran de chargement
- splash.destroy()
+ splash.mainloop()
+def load_main_program():
+ """Charge le programme principal (menu.App), sans interaction directe avec Tkinter."""
import os
- import sys
+ import sys
+
base_dir = os.path.dirname(os.path.abspath(__file__))
-
- dossier_path = os.path.join(base_dir,'Code_objets')
+ dossier_path = os.path.join(base_dir, 'Objet')
sys.path.append(dossier_path)
+ import menu
- import Menu
-
-
-
- # Lancer le programme principal ici
- a = Menu.App()
- a.mainloop()
+ global app
+ app = menu.App() # Instanciation de l'application
-# Démarrer le splash screen dans un thread
-splash_thread = threading.Thread(target=show_splash)
-splash_thread.start()
+def check_thread():
+ """Vérifie si le thread principal a fini de charger le programme."""
+ if not main_thread.is_alive():
+ splash.destroy() # Fermer le splash
+ app.mainloop() # Lancer l'application principale dans le thread principal
+ else:
+ splash.after(100, check_thread) # Vérifier à nouveau après 100 ms
-# Charger le programme principal dans un autre thread
-main_thread = threading.Thread(target=load_main_program)
-main_thread.start()
+# Démarrer le splash screen dans le thread principal
+show_splash()
diff --git a/test_nouveautestthreding.py b/test_nouveautestthreding.py
new file mode 100644
index 0000000000000000000000000000000000000000..dc2cc407c0e22b60121b8405bcafb907d53131e7
--- /dev/null
+++ b/test_nouveautestthreding.py
@@ -0,0 +1,53 @@
+import threading
+import time
+
+# Function to perform a computational task
+def compute_task(start, end):
+ total = 0
+ for i in range(start, end):
+ total += i ** 2
+ return total
+
+# Wrapper function for threading
+def thread_wrapper(start, end, results, index):
+ results[index] = compute_task(start, end)
+
+# Single-threaded execution
+def single_threaded():
+ start_time = time.time()
+ compute_task(0, 100_000_000)
+ end_time = time.time()
+ return end_time - start_time
+
+# Multi-threaded execution
+def multi_threaded():
+ start_time = time.time()
+<<<<<<< HEAD
+ num_threads = 2
+ step = 10_000_000 // num_threads
+=======
+ num_threads = 8
+ step = 100_000_000 // num_threads
+>>>>>>> 73f7a464704d2fa11671ba78a16771abe843918a
+ threads = []
+ results = [0] * num_threads
+
+ for i in range(num_threads):
+ t = threading.Thread(target=thread_wrapper, args=(i * step, (i + 1) * step, results, i))
+ threads.append(t)
+ t.start()
+
+ for t in threads:
+ t.join()
+
+ end_time = time.time()
+ return end_time - start_time
+
+# Main function to compare performance
+if __name__ == "__main__":
+ single_thread_time = single_threaded()
+ multi_thread_time = multi_threaded()
+
+ print(f"Single-threaded execution time: {single_thread_time:.4f} seconds")
+ print(f"Multi-threaded execution time: {multi_thread_time:.4f} seconds")
+ print("Multi-threading is faster!" if multi_thread_time < single_thread_time else "Single-threading is faster!")
\ No newline at end of file
diff --git a/test_recup_info.py b/test_recup_info.py
new file mode 100644
index 0000000000000000000000000000000000000000..339bbe015c3bd6a11e56da19eff6c821c1b8bb0e
--- /dev/null
+++ b/test_recup_info.py
@@ -0,0 +1,3 @@
+import multiprocessing
+print(f"CÅ“urs physiques : {multiprocessing.cpu_count() // 2}")
+print(f"CÅ“urs logiques : {multiprocessing.cpu_count()}")
diff --git a/vid3.mp4 b/vid3.mp4
new file mode 100644
index 0000000000000000000000000000000000000000..fdc50934648d989c26de3a8c4ac298b49ac8c3c4
Binary files /dev/null and b/vid3.mp4 differ
diff --git a/volley_mire_detection/scripts/__pycache__/test_model.cpython-310-pytest-8.3.5.pyc b/volley_mire_detection/scripts/__pycache__/test_model.cpython-310-pytest-8.3.5.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..cc5e0a6d21db85a3c4a6ef9154bc067e9bda0a95
Binary files /dev/null and b/volley_mire_detection/scripts/__pycache__/test_model.cpython-310-pytest-8.3.5.pyc differ