Refactor code structure for improved readability and maintainability

diagrams/architecture.puml

@@ -0,0 +1,56 @@
+@startuml architecture_timelapse
+
+' Configuration pour rendre le diagramme plus compact
+skinparam padding 1
+skinparam nodesep 5
+skinparam ranksep 1
+skinparam componentMargin 1
+skinparam packagePadding 2
+skinparam defaultTextAlignment center
+skinparam linetype ortho
+skinparam rectangle {
+   borderColor transparent
+   stereotypeBorderColor transparent
+}
+
+!$ICONURL = "https://raw.githubusercontent.com/tupadr3/plantuml-icon-font-sprites/v3.0.0/icons"
+!include $ICONURL/common.puml
+!include $ICONURL/devicons/javascript.puml
+!include $ICONURL/devicons/html5.puml
+!include $ICONURL/devicons/css3.puml
+!include $ICONURL/devicons/nodejs.puml
+!include $ICONURL/devicons/postgresql.puml
+
+package "Hôte Proxmox" {
+    package "Conteneur LXC" as lxc {
+         package "Frontend" as frontend {
+             DEV_HTML5(html, "HTML5")
+             DEV_CSS3(css, "CSS3") #line:transparent
+             DEV_JAVASCRIPT(js, "JavaScript") #line:transparent
+         }
+         
+         package "Backend" as backend {
+             DEV_NODEJS(express, "ExpressJS") #line:transparent
+             [FFmpeg] as ffmpeg #line:transparent
+             note right of ffmpeg: Image vers Vidéo
+         }
+         
+         database "Base de données" as db {
+             DEV_POSTGRESQL(pg, "PostgreSQL") #line:transparent
+             note right of pg: Timelapses & Données
+         }
+
+         frontend --> backend : HTTP/REST
+         backend --> db : Requêtes
+         backend --> ffmpeg : Traitement
+    }
+
+    storage "Réplication Ceph" as ceph {
+         [Stockage de données] as storage #line:transparent
+         note right of storage: Stockage distribué
+    }
+
+    lxc --> ceph : Stockage
+}
+
+@enduml

diagrams/backend/backend1.puml

@@ -0,0 +1,77 @@
+@startuml Modèles de données
+
+class Project {
+  +id: integer
+  +name: string
+  +description: string
+  +start_date: date
+  +status: integer
+  +getAllProjects()
+  +getProjectById(id)
+  +createProject(name, description, startDate, status)
+  +updateProject(id, updates)
+  +updateProjectStatus(id, status)
+  +deleteProject(id)
+  +findCurrentRenderingProject()
+  +findStoppingProject()
+}
+
+class Measurement {
+  +id: integer
+  +project_id: integer
+  +timestamp: datetime
+  +path: string
+  +temperature: float
+  +humidity: float
+  +order_id: integer
+  +getAllMeasurements()
+  +getMeasurementById(id)
+  +getMeasurementByProjectAndOrderId(projectId, orderId)
+  +getMeasurementsByProjectId(projectId)
+  +createMeasurement(projectId, timestamp, path, temperature, humidity, orderId)
+  +updateMeasurement(id, updates)
+  +deleteMeasurement(id)
+  +getNextOrderId(projectId)
+}
+
+class Video {
+  +id: integer
+  +project_id: integer
+  +measurement_ids: string
+  +name: string
+  +resolution: string
+  +duration: integer
+  +status: integer
+  +progress: float
+  +video_file: string
+  +started_at: datetime
+  +updated_at: datetime
+  +eta: float
+  +getAllVideos()
+  +getVideoById(id)
+  +getVideosByProjectId(projectId)
+  +createVideo(projectId, measurementIds, name, resolution, duration, status)
+  +updateVideo(id, updates)
+  +updateVideoFilePath(id, videoFile)
+  +updateVideoStatus(id, status)
+  +deleteVideo(id)
+  +getUnfinishedVideos()
+  +updateVideoProgress(id, progress, eta)
+}
+
+class Camera {
+  +id: integer
+  +interval: integer
+  +maintenance: integer
+  +active: integer
+  +getCamera()
+  +updateCamera(id, updates)
+  +deleteCamera(id)
+  +initializeCamera()
+}
+
+Project "1" -- "0..*" Measurement : possède >
+Project "1" -- "0..*" Video : possède >
+Measurement "1..*" -- "0..*" Video : utilisée dans >
+
+@enduml

diagrams/backend/backend2.puml

@@ -0,0 +1,62 @@
+@startuml Architecture MVC
+
+package "Controllers" {
+  [ProjectController]
+  [MeasurementController]
+  [VideoController]
+  [ImageController]
+  [CameraController]
+}
+
+package "Models" {
+  [Project]
+  [Measurement]
+  [Video]
+  [Camera]
+  [DatabaseManager]
+}
+
+package "Routes" {
+  [projectRoutes]
+  [measurementRoutes]
+  [videoRoutes]
+  [imageRoutes]
+  [cameraRoutes]
+  [index]
+}
+
+package "Services" {
+  [StorageService]
+  [VideoService]
+}
+
+package "Utils" {
+  [errorHandler]
+}
+
+package "Database" {
+  [connection]
+}
+
+package "Config" {
+  [config]
+}
+
+cloud "Client" {
+  [Frontend]
+}
+
+[Frontend] --> [Routes]
+[Routes] --> [Controllers]
+[Controllers] --> [Models]
+[Controllers] --> [Services]
+[Models] --> [Database]
+[Services] --> [Models]
+[Controllers] --> [Utils]
+[Models] --> [Utils]
+[Services] --> [Utils]
+[Models] --> [Config]
+[Services] --> [Config]
+[Controllers] --> [Config]
+
+@enduml

diagrams/backend/backend3.puml

@@ -0,0 +1,39 @@
+@startuml Création de vidéo
+
+actor Client
+participant "videoRoutes" as Routes
+participant "VideoController" as Controller
+participant "Video" as Model
+participant "Measurement" as MeasurementModel
+participant "VideoService" as Service
+participant "FFmpeg" as FFmpeg
+database Database
+
+Client -> Routes: POST /videos
+Routes -> Controller: createVideo(req, res)
+Controller -> Model: createVideo(project_id, measurement_ids, name, resolution, duration)
+Model -> Database: INSERT INTO videos
+Database --> Model: video data
+Model --> Controller: video object
+
+Controller -> Controller: getMeasurementPathList(measurement_ids, project_id)
+Controller -> MeasurementModel: getMeasurementByProjectAndOrderId(projectId, orderId)
+MeasurementModel -> Database: SELECT * FROM measurements
+Database --> MeasurementModel: measurement data
+MeasurementModel --> Controller: measurement object with path
+
+Controller -> Service: createVideoFromImages(project_id, pathList, duration, video_id, resWidth, resHeight)
+Service -> FFmpeg: spawn('ffmpeg', ffmpegArgs)
+Service -> Model: updateVideo(videoId, {status: rendering, progress: 0})
+Model -> Database: UPDATE videos SET status = rendering, progress = 0
+FFmpeg --> Service: stderr progress events
+Service -> Model: updateVideoProgress(videoId, progress, eta)
+Model -> Database: UPDATE videos SET progress = X, eta = Y
+FFmpeg --> Service: process complete
+Service -> Model: updateVideo(videoId, {status: completed, progress: 100})
+Model -> Database: UPDATE videos SET status = completed, progress = 100
+Service --> Controller: videoFile path
+Controller --> Routes: { message: success, id: video.id }
+Routes --> Client: 200 OK - JSON Response
+
+@enduml

diagrams/backend/backend4.puml

@@ -0,0 +1,34 @@
+@startuml Cas d'utilisation
+
+left to right direction
+actor "Utilisateur" as User
+actor "Caméra" as Camera
+
+rectangle "Timelapse Backend" {
+  usecase "Gérer les projets" as UC1
+  usecase "Configurer la caméra" as UC2
+  usecase "Capturer des images" as UC3
+  usecase "Créer des vidéos" as UC4
+  usecase "Visualiser les images" as UC5
+  usecase "Visualiser les vidéos" as UC6
+  usecase "Démarrer une capture" as UC7
+  usecase "Arrêter une capture" as UC8
+  usecase "Uploader une image et des mesures" as UC9
+  
+  UC1 ..> UC7 : <<include>>
+  UC1 ..> UC8 : <<include>>
+  UC2 ..> UC7 : <<extend>>
+  UC2 ..> UC8 : <<extend>>
+  UC3 ..> UC9 : <<include>>
+  UC4 ..> UC5 : <<include>>
+}
+
+User --> UC1
+User --> UC2
+User --> UC4
+User --> UC5
+User --> UC6
+Camera --> UC3
+Camera --> UC9
+
+@enduml

diagrams/backend/backend5.puml

@@ -0,0 +1,41 @@
+@startuml Déploiement
+
+node "Client Device" {
+  [Web Browser] as Browser
+}
+
+node "Docker Environment" {
+  node "timelapse-api" {
+    [Express Server] as Server
+    [Node.js Runtime] as Node
+    [FFmpeg] as FFmpeg
+  }
+  
+  database "timelapse-db" {
+    [PostgreSQL] as DB
+  }
+  
+  folder "Volumes" {
+    folder "storage/" {
+      [Project Images]
+      [Generated Videos]
+    }
+  }
+}
+
+node "Camera Device" {
+  [Camera Software] as CamSoftware
+  [Sensors] as Sensors
+}
+
+Browser --> Server: HTTP/REST
+CamSoftware --> Server: HTTP/REST
+Server --> DB: SQL Queries
+Server --> FFmpeg: Process Spawn
+FFmpeg --> [Project Images]: Read
+FFmpeg --> [Generated Videos]: Write
+Server --> [Project Images]: Read/Write
+Server --> [Generated Videos]: Read
+Sensors --> CamSoftware: Temperature/\nHumidity Data
+
+@enduml

diagrams/frontend/frontend1.puml

@@ -0,0 +1,42 @@
+@startuml
+
+class Project {
+  id: number
+  name: string
+  description: string
+  status: number
+  start_date: date
+}
+
+class Measurement {
+  id: number
+  project_id: number
+  order_id: number
+  timestamp: string
+  temperature: number
+  humidity: number
+}
+
+class Video {
+  id: number
+  project_id: number
+  name: string
+  measurement_ids: string
+  resolution: string
+  duration: number
+  status: number
+}
+
+class CameraController {
+  active_project_id: number
+  start_timelapse(id, frequency, nbimages): void
+  stopCamera(id): void
+  manualUpload(imageFile, projectId, timestamp, temperature, humidity): void
+}
+
+Project "1" *-- "n" Measurement : contient
+Project "1" *-- "n" Video : contient 
+Measurement "n" o-- "n" Video : utilisées dans
+CameraController -- Video : génère
+
+@enduml

diagrams/frontend/frontend2.puml

@@ -0,0 +1,19 @@
+@startuml
+
+start
+:Créer un projet;
+:Configurer la caméra;
+:Prises d'images automatiques;
+
+fork
+  :Upload manuel d'images;
+fork again
+  :Arrêt de la caméra;
+end fork
+
+:Sélection des images;
+:Générer une vidéo;
+:Visualiser les données;
+stop
+
+@enduml

diagrams/frontend/frontend3.puml

@@ -0,0 +1,20 @@
+@startuml
+
+actor Browser
+participant Frontend
+participant API
+participant Camera
+
+Browser -> Frontend : 1. Create project
+Frontend -> API : 2. POST /projects
+Browser -> Frontend : 3. Configure camera
+Frontend -> API : 4. POST /procedure/start
+API -> Camera : 4. Start capturing
+Camera --> API : 5. Capture images
+Browser -> Frontend : 6. Create video request
+Frontend -> API : 7. POST /videos
+Browser -> Frontend : 8. Render video
+Frontend -> API : 9. POST /videos/render/{id}
+Frontend --> Browser : 10. Display video & metrics
+
+@enduml

diagrams/frontend/frontend4.puml

@@ -0,0 +1,28 @@
+@startuml
+
+left to right direction
+actor "Utilisateur" as user
+
+rectangle "Système Timelapse" {
+  usecase "Gérer les projets" as UC1
+  usecase "Configurer la caméra" as UC2
+  usecase "Créer des vidéos" as UC3
+  usecase "Visualiser les données" as UC4
+  usecase "Uploader manuellement" as UC5
+  usecase "Afficher métriques" as UC6
+
+  UC1 --> UC2
+  UC2 --> UC3
+  UC1 --> UC4
+  UC2 --> UC5
+  UC3 --> UC6
+}
+
+user --> UC1
+user --> UC2
+user --> UC3
+user --> UC4
+user --> UC5
+user --> UC6
+
+@enduml

diagrams/frontend/frontend5.puml

@@ -0,0 +1,29 @@
+@startuml
+
+node "Client Browser" {
+  [HTML/CSS/JS]
+  [JQuery]
+  [Chart.js]
+}
+
+node "Backend API" {
+  [RESTful Services]
+  [Image Processing]
+  [Video Generation]
+}
+
+database "Filesystem Storage" {
+  [Images]
+  [Videos]
+}
+
+node "Camera Controller" {
+  [Capture Configuration]
+  [Sensors (temp/humid)]
+}
+
+[HTML/CSS/JS] -- [RESTful Services] : HTTP
+[RESTful Services] -- [Filesystem Storage]
+[RESTful Services] -- [Camera Controller]
+
+@enduml

diagrams/global.puml

@@ -1,4 +1,4 @@
-@startuml Architecture Globale
+@startuml global
 
 ' Définition des composants
 node "Interfaces utilisateur" {

diagrams/global_interspec.puml

@@ -0,0 +1,100 @@
+@startuml
+left to right direction
+
+skinparam component {
+    BackgroundColor<<Informatique>> #FFE4B5
+    BackgroundColor<<Électronique>> #98FB98
+    BackgroundColor<<Matériaux>> #87CEEB
+    BorderColor #333
+}
+
+package "Infrastructure Globale" {
+    component "Caméra Raspberry Pi" <<Électronique>> as pi {
+        component "Module Caméra" as cam
+        component "Scripts Capture" as scripts
+    }
+
+    component "Serveur Central" <<Informatique>> as server {
+        component "Backend (Node.js/Express)" as backend
+        component "FFMPEG Processing" as ffmpeg
+        component "Base de Données" as db
+    }
+
+    component "Interface Web" <<Informatique>> as web {
+        component "Frontend (HTML/CSS/JS)" as front
+        component "Nginx Reverse Proxy" as nginx
+    }
+
+    component "Application Android" <<Informatique>> as android {
+        component "Kotlin API" as kotlin
+        component "Glide Image Processing" as glide
+    }
+
+    component "Système Énergétique" <<Électronique>> as energy {
+        component "Microcontrôleur STM32" as stm
+        component "Batterie LiPo" as battery
+        component "Panneau Solaire" as solar
+    }
+
+    component "Boîtier Mécanique" <<Matériaux>> as box {
+        component "Structure Étanche" as structure
+        component "Système Fixation" as mount
+    }
+
+    component "Infrastructure Virtualisée" <<Informatique>> as infra {
+        component "Proxmox VE" as proxmox
+        component "VM Ubuntu" as vm
+        component "Docker Containers" as docker
+    }
+}
+
+pi --> server : "Transfert images\n(HTTP/MQTT)"
+server --> web : "API REST"
+server --> android : "API REST"
+energy --> pi : "Alimentation\n(Power Management)"
+energy --> stm : "Contrôle énergie"
+box --> pi : "Protection physique"
+box --> energy : "Intégration"
+infra --> server : "Hébergement"
+infra --> web : "Hébergement"
+cam --> scripts : "Capture RAW"
+scripts --> backend : "Envoi images"
+backend --> ffmpeg : "Conversion vidéo"
+ffmpeg --> db : "Stockage"
+stm --> battery : "Monitoring"
+solar --> battery : "Recharge"
+front --> nginx : "Requêtes"
+nginx --> backend : "Proxy"
+vm --> docker : "Orchestration"
+structure --> mount : "Assemblage"
+
+note top of pi
+ **Technologies Électronique**
+ - Altium Designer
+ - STM32 CubeIDE
+ - Protocoles I2C/SPI
+end note
+
+note right of server
+ **Stack Logicielle**
+ - Node.js + Express
+ - PostgreSQL
+ - FFMPEG
+ - CI/CD Gitea
+end note
+
+note left of energy
+ **Gestion Énergie**
+ - PCB Custom
+ - Capteurs température/hygro
+ - Algorithme économie d'énergie
+end note
+
+note bottom of box
+ **Caractéristiques Mécaniques**
+ - PLA résistant aux UV
+- Indice IP67
+- Dissipation thermique
+end note
+
+@enduml

diagrams/global_interspec_lite.puml

@@ -0,0 +1,87 @@
+@startuml
+left to right direction
+
+skinparam component {
+    BackgroundColor<<Logiciel>> #FFE4B5
+    BackgroundColor<<Matériel>> #98FB98
+    BackgroundColor<<Infrastructure>> #87CEEB
+    BorderColor #333
+}
+
+package "Matériel" <<Matériel>> {
+    component "RPi 4B + Cam" as pi {
+        [Module Caméra] --> [Scripts Python]
+    }
+    
+    component "Système d'énergie" as energy {
+        [STM32] --> [Batterie LiPo]
+        [Panneau Solaire] --> [Gestion d'énergie]
+    }
+    
+    component "Boîtier Mécanique" as box {
+        [PLA IP67] --> [Système de Montage]
+    }
+}
+
+package "Logiciel" <<Logiciel>> {
+    component "Backend" as backend {
+        [Node.js] --> [FFMPEG]
+        [Express] --> [PostgreSQL]
+    }
+    
+    component "Frontend" as web {
+        [React] --> [Nginx]
+    }
+    
+    component "Application Mobile" as mobile {
+        [Kotlin] --> [Android API]
+    }
+}
+
+package "Infrastructure" <<Infrastructure>> {
+    component "Proxmox" as proxmox {
+        [VM Ubuntu] --> [Docker]
+    }
+}
+
+pi --> backend : "HTTP/MQTT\n(images)"
+energy --> pi : "Alimentation"
+box --> pi : "Protection physique"
+backend --> web : "API REST"
+backend --> mobile : "API REST"
+proxmox --> backend : "Hébergement"
+proxmox --> web : "Proxy inverse"
+
+note right of pi
+<b>Technologie Matérielle:</b>
+• Altium Designer
+• STM32 CubeIDE
+• I2C/SPI
+• RDM6/CES
+end note
+
+note bottom of backend
+<b>Stack Logicielle:</b>
+• Node.js/Express
+• FFMPEG
+• Auth JWT
+• CI/CD Gitea
+end note
+
+note left of proxmox
+<b>Infrastructure:</b>
+• Docker Swarm
+• Let's Encrypt
+• VPN/Wireguard
+• Sauvegardes Automatisées
+end note
+
+note top of box
+<b>Mécanique:</b>
+• Solidworks
+• BambuLab X1
+• Analyse Thermique
+• Classification IP67
+end note
+
+@enduml

diagrams/raspi/01_architecture_generale.puml

@@ -0,0 +1,52 @@
+@startuml Architecture Générale du Système Timelapse
+
+!define ICONURL https://raw.githubusercontent.com/tupadr3/plantuml-icon-font-sprites/v2.4.0
+!include ICONURL/common.puml
+!include ICONURL/devicons/python.puml
+!include ICONURL/font-awesome-5/raspberry_pi.puml
+!include ICONURL/font-awesome-5/cloud.puml
+!include ICONURL/font-awesome-5/camera.puml
+!include ICONURL/font-awesome-5/database.puml
+
+skinparam {
+  BackgroundColor white
+  ArrowColor #666666
+  BorderColor #666666
+  FontName "Arial"
+}
+
+rectangle "Système Raspberry Pi" as raspi {
+  DEV_PYTHON(pyonline, "timelapse_online.py") #lightblue
+  DEV_PYTHON(pyoffline, "timelapse_offline.py") #lightgreen
+  rectangle "timelapse/" {
+    DEV_PYTHON(config, "config.py") #lightyellow
+    DEV_PYTHON(apiclient, "api_client.py") #pink
+    DEV_PYTHON(capture, "capture.py") #lightcyan
+    DEV_PYTHON(sensors, "sensors.py") #lightyellow
+  }
+  FA5_DATABASE(localdb, "CONFIG/config.json") #lightgrey
+  FA5_CAMERA(camera, "Caméra") #white
+}
+
+cloud "Serveur Distant" {
+  rectangle "API REST" as api #pink
+  database "Base de données" as db #lightgrey
+}
+
+pyonline --> config : utilise
+pyoffline --> config : utilise
+pyonline --> apiclient : utilise
+pyonline --> capture : utilise
+pyoffline --> capture : utilise
+capture --> config : lit/écrit
+capture --> sensors : utilise
+apiclient --> api : communique
+config --> localdb : lit/écrit
+sensors --> camera : contrôle
+
+note bottom of pyonline : "Mode connecté"
+note bottom of pyoffline : "Mode hors ligne"
+note right of api : "Authentification\net gestion des données"
+note bottom of camera : "Capture des images"
+
+@enduml

diagrams/raspi/02_flux_capture.puml

@@ -0,0 +1,77 @@
+@startuml Flux du Processus de Capture d'Images
+
+skinparam {
+  BackgroundColor white
+  ArrowColor #666666
+  BorderColor #666666
+  FontName "Arial"
+}
+
+start
+if (Connexion internet disponible?) then (oui)
+  :Mode connecté (timelapse_online.py);
+  :Récupération du statut depuis l'API;
+  if (Serveur accessible?) then (oui)
+    :Mise à jour de la configuration locale;
+    if (Mode maintenance?) then (oui)
+      :Arrêt du processus;
+      stop
+    else (non)
+      if (Demande d'arrêt?) then (oui)
+        :Confirmation de l'arrêt au serveur;
+        :Réinitialisation de la configuration;
+        stop
+      else (non)
+        if (Configuration active?) then (oui)
+          :Capture d'image;
+          :Lecture des données environnementales;
+          :Envoi au serveur;
+          if (Envoi réussi?) then (oui)
+            :Décrémenter le nombre d'images restantes;
+          else (non)
+            :Sauvegarder en mode hors-ligne;
+          endif
+          if (Toutes images capturées?) then (oui)
+            :Notification au serveur;
+            :Désactivation de la configuration;
+            stop
+          else (non)
+            :Attente du prochain cycle;
+          endif
+        else (non)
+          :Mode IDLE, aucune action;
+          stop
+        endif
+      endif
+    endif
+  else (non)
+    :Fonctionnement en mode dégradé;
+  endif
+else (non)
+  :Mode hors ligne (timelapse_offline.py);
+  if (Configuration active?) then (oui)
+    if (Images restantes > 0?) then (oui)
+      :Capture d'image;
+      :Lecture des données environnementales;
+      :Sauvegarde en local;
+      :Décrémenter le nombre d'images restantes;
+      if (Toutes images capturées?) then (oui)
+        :Désactivation de la configuration;
+        stop
+      else (non)
+        :Envoi de l'intervalle au microcontrôleur;
+        :Attente du prochain cycle;
+      endif
+    else (non)
+      :Désactivation de la configuration;
+      stop
+    endif
+  else (non)
+    :Aucune configuration active;
+    stop
+  endif
+endif
+
+stop
+
+@enduml

diagrams/raspi/03_structure_classes.puml

@@ -0,0 +1,91 @@
+@startuml Structure des Classes et Composants
+
+skinparam {
+  BackgroundColor white
+  ClassBackgroundColor lightcyan
+  ClassBorderColor gray
+  ClassFontName Arial
+  ClassFontSize 12
+}
+
+class Config {
+  + BASE_DIR : string
+  + CONFIG_DIR : string
+  + PROJECT_DIR : string
+  + LOG_FILE : string
+  + CONFIG_FILE : string
+  + API_BASE_URL : string
+  + API_ENDPOINTS : dict
+  + DEFAULT_CONFIG : dict
+  --
+  + ensure_directories()
+  + setup_logging()
+  + load_config()
+  + save_config()
+  + update_config(new_config)
+  + get(key, default)
+  + set(key, value)
+  + delete_config_file()
+  + decrement_remaining_images()
+}
+
+class APIClient {
+  - base_url : string
+  - headers : dict
+  --
+  + get_camera_status()
+  + upload_measurement(image_path, timestamp, temperature, humidity)
+  + confirm_stop()
+  + update_camera_config(status)
+  + check_connection()
+}
+
+class TimelapseCaptureManager {
+  - offline_dir : string
+  --
+  + single_capture(online)
+  + run_capture_sequence(online)
+  + sync_offline_captures()
+  + count_offline_captures()
+  - _move_to_offline(image_path, json_path)
+  - _cleanup_local_capture(image_path, json_path)
+}
+
+class "timelapse_online.py" as TimelapseOnline {
+  + main()
+}
+
+class "timelapse_offline.py" as TimelapseOffline {
+  + main()
+}
+
+package "sensors" {
+  class EnvironmentalSensor {
+    + read_data()
+  }
+  
+  class Camera {
+    + capture_image()
+  }
+  
+  class MicroController {
+    + send_interval(interval)
+  }
+}
+
+Config "1" <-- "1" TimelapseOnline : utilise
+Config "1" <-- "1" TimelapseOffline : utilise
+Config "1" <-- "1" TimelapseCaptureManager : utilise
+APIClient "1" <-- "1" TimelapseOnline : utilise
+TimelapseCaptureManager "1" <-- "1" TimelapseOnline : utilise
+TimelapseCaptureManager "1" <-- "1" TimelapseOffline : utilise
+TimelapseCaptureManager "1" --> "1" EnvironmentalSensor : utilise
+TimelapseCaptureManager "1" --> "1" Camera : utilise
+APIClient "1" --> "1" Config : utilise
+TimelapseOffline ..> MicroController : utilise
+
+note bottom of Config : "Gestion de la configuration\nlocale et persistance"
+note bottom of APIClient : "Communication avec\nle serveur distant"
+note bottom of TimelapseCaptureManager : "Orchestration du processus\nde capture d'images"
+
+@enduml

diagrams/raspi/04_sequence_synchronisation.puml

@@ -0,0 +1,78 @@
+@startuml Séquence de Synchronisation des Données
+
+skinparam {
+  BackgroundColor white
+  SequenceGroupBorderColor gray
+  SequenceGroupBodyBackgroundColor whitesmoke
+  ParticipantBackgroundColor lightblue
+  ParticipantBorderColor gray
+  LifeLineBorderColor gray
+  ArrowColor #666666
+}
+
+actor "Système" as System
+participant "sync_offline_data.py" as Sync
+participant "APIClient" as API
+participant "TimelapseCaptureManager" as Manager
+participant "Config" as Config
+database "Stockage local" as Storage
+database "Serveur API" as Server
+
+System -> Sync : Exécution du script
+activate Sync
+
+Sync -> API : check_connection()
+activate API
+API --> Sync : Connexion disponible
+deactivate API
+
+Sync -> Manager : count_offline_captures()
+activate Manager
+Manager -> Storage : Listing des dossiers offline
+Storage --> Manager : Liste des captures
+Manager --> Sync : Nombre de captures hors ligne
+deactivate Manager
+
+alt Captures hors ligne disponibles
+    Sync -> Manager : sync_offline_captures()
+    activate Manager
+    
+    loop Pour chaque capture hors ligne
+        Manager -> Storage : Lire données JSON
+        activate Storage
+        Storage --> Manager : Données (timestamp, température, etc.)
+        deactivate Storage
+        
+        Manager -> Storage : Lire image
+        activate Storage
+        Storage --> Manager : Fichier image
+        deactivate Storage
+        
+        Manager -> API : upload_measurement()
+        activate API
+        API -> Server : POST /camera/upload
+        
+        alt Upload réussi
+            Server --> API : Confirmation (ID image)
+            API --> Manager : Succès
+            Manager -> Storage : Suppression des fichiers locaux
+            Manager -> Config : Mise à jour du statut
+        else Échec de l'upload
+            Server --> API : Erreur
+            API --> Manager : Échec
+            note right: Conservation des fichiers locaux\npour tentative ultérieure
+        end
+        
+        deactivate API
+    end
+    
+    Manager --> Sync : Nombre de captures synchronisées
+    deactivate Manager
+else Aucune capture à synchroniser
+    Sync -> Sync : Fin sans action
+end
+
+Sync --> System : Rapport de synchronisation
+deactivate Sync
+
+@enduml

diagrams/raspi/05_deploiement_infrastructure.puml

@@ -0,0 +1,69 @@
+@startuml infra_raspi
+
+skinparam {
+  BackgroundColor white
+  NodeBackgroundColor lightyellow
+  NodeBorderColor gray
+  AgentBackgroundColor lightcyan
+  AgentBorderColor gray
+  ArrowColor #666666
+  ComponentBackgroundColor lightblue
+  ComponentBorderColor gray
+}
+
+artifact "Raspbian OS" as linux
+
+node "Raspberry Pi" as raspi {
+  agent "Service Systemd" as service
+  artifact "timelapse.service" as timelapseService
+  artifact "script.sh" as script
+  
+  service --> timelapseService : gère
+  service --> script : exécute
+  
+  component "Scripts Python" as scripts {
+    artifact "timelapse_online.py" as pyOnline
+    artifact "timelapse_offline.py" as pyOffline
+    artifact "sync_offline_data.py" as pySync
+  }
+  
+  component "Modules Timelapse" as modules {
+    artifact "config.py" as config
+    artifact "api_client.py" as apiClient
+    artifact "capture.py" as capture
+    artifact "sensors.py" as sensors
+  }
+  
+  artifact "Caméra Pi" as cam
+  artifact "Microcontrôleur" as micro
+}
+
+cloud "Internet" as internet {
+  node "Serveur API" as api_server {
+    database "Base de données" as db
+    folder "Stockage d'images" as images
+  }
+}
+
+linux --> service : exécute
+service --> script : lance
+script --> scripts : appelle selon\nétat connexion
+scripts --> modules : utilisent
+modules --> cam : contrôle
+modules --> micro : communique
+modules --> internet : envoie données
+internet --> modules : récupère configuration
+
+note right of service : "Démarrage au boot\net exécution périodique"
+note right of scripts : "Sélection auto du mode\nselon connectivité"
+note bottom of cam : "Capture des images\ndu timelapse"
+note bottom of micro : "Gestion de l'intervalle\nde capture"
+
+legend right
+  <b>Infrastructure de Déploiement Timelapse</b>
+  Ce diagramme représente l'infrastructure complète
+  du système timelapse, depuis le service systemd
+  jusqu'à la communication avec le serveur distant.
+endlegend
+
+@enduml

diapo_master.tex

@@ -17,6 +17,7 @@
 \usepackage{xcolor}
 \usepackage{listings}
 \usepackage{fancyvrb}
+\usepackage[french]{babel}
 
 % Define the dot-based progress bar
 \usepackage{tikz}
@@ -43,148 +44,35 @@
 
 % Introduction
 \section{Introduction}
-\begin{frame}{Contexte et Objectifs}
-   \begin{itemize}
-      \item Présentation du projet : Caméra Timelapse
-      \item Contexte d'utilisation et motivation
-      \item Objectifs principaux du projet
-   \end{itemize}
-\end{frame}
-
-\section{Exemple UML}
-\begin{frame}{Exemple UML}
-   \begin{center}
-      \includegraphics[width=0.9\textwidth]{diagrams/global.png}
-   \end{center}
-\end{frame}
+\input{diapos/contexte-objectifs.tex}
 
 % Cahier des charges
 \section{Cahier des charges}
-\begin{frame}{Spécifications et Contraintes}
-   \begin{itemize}
-      \item Fonctionnalités attendues
-      \item Contraintes techniques (matériel, logiciel)
-      \item Livrables
-   \end{itemize}
-\end{frame}
+\input{diapos/cahier-charges.tex}
 
 % Partie mécanique
 \section{Partie mécanique}
-\begin{frame}{Partie mécanique}
-   \begin{itemize}
-      \item Présentation de la structure mécanique
-      \item Choix des matériaux et conception
-      \item Schémas ou photos du montage
-   \end{itemize}
-\end{frame}
+\input{diapos/meca.tex}
 
 % Partie électronique
 \section{Partie électronique}
-\begin{frame}{Partie électronique}
-   \begin{itemize}
-      \item Architecture électronique
-      \item Composants utilisés (capteurs, microcontrôleurs, etc.)
-      \item Schémas électroniques
-   \end{itemize}
-\end{frame}
+\input{diapos/elec.tex}
 
-% Partie serveur, front et application mobile
-\section{Serveur, Front et Application mobile}
-\begin{frame}{Serveur, Front et Application mobile}
-   \begin{itemize}
-      \item Présentation de l'architecture logicielle
-      \item Fonctionnalités principales du serveur
-      \item Aperçu du front web et de l'application mobile
-      \item Technologies utilisées
-   \end{itemize}
-\end{frame}
+% Partie informatique (serveur, front et application mobile)
+\section{Partie informatique}
+\input{diapos/info.tex}
 
-% Partie front end
-\subsection{Front end}
-\begin{frame}{Front end}
-   \textbf{Choix des technologies :}
-   \begin{itemize}
-      \item HTML, CSS, Javascript
-      \item ChartJS pour la visualisation de données
-      \item Ajax pour la communication asynchrone
-   \end{itemize}
-   \vspace{0.5em}
-   \textbf{Efforts notables :}
-   \begin{itemize}
-      \item Carousel 3D animé, modulable selon le nombre de projets
-      \item Responsive : adaptation à la taille de la fenêtre
-      \item Menu déroulant pour cacher les images en excès
-      \item Affichage d'images compressées pour optimiser la génération
-      \item Style universel pour le confort utilisateur
-   \end{itemize}
-\end{frame}
-
-\begin{frame}{Front end : Architecture}
-   \textbf{Organisation du code~:}
-   \begin{itemize}
-      \item \textbf{HTML}~: \texttt{index.html}, \texttt{pages/projet\_detail.html}
-      \item \textbf{CSS}~: \texttt{css/base/style.css}, \texttt{css/components/style\_menu.css}, \texttt{css/pages/style\_projet.css}, images dans \texttt{css/image/}
-      \item \textbf{JS}~: \texttt{js/core/} (logique principale), \texttt{js/libs/} (librairies tierces), \texttt{js/pages/} (scripts spécifiques aux pages)
-   \end{itemize}
-   \vspace{0.5em}
-   \textbf{Outils et automatisation~:}
-   \begin{itemize}
-      \item Déploiement automatisé avec \texttt{.gitea/workflows/deploy.yml}
-      \item Conteneurisation possible via \texttt{docker-compose.yml}
-      \item Fichier \texttt{deploy.sh} pour le déploiement manuel
-   \end{itemize}
-\end{frame}
-
-\begin{frame}{Automatisation du déploiement : deploy.sh}
-   \textbf{Script de déploiement automatique~:}
-   \begin{itemize}
-      \item Un script bash (\texttt{deploy.sh}) a été développé par Ethan pour automatiser le déploiement du front-end.
-      \item Il permet de mettre à jour rapidement la version en ligne lors du développement continu.
-      \item Ce script facilite l'intégration des modifications et réduit les risques d'erreur humaine lors des mises à jour.
-      \item Il s'intègre dans la chaîne de développement pour accélérer les cycles de test et de validation.
-   \end{itemize}
-\end{frame}
-
-\begin{frame}{Front end (suite)}
-   \textbf{Difficultés rencontrées :}
-   \begin{itemize}
-      \item Interface optimale entre le front end, le serveur et l'application mobile
-      \item Évolution constante des routes et de la logique serveur
-      \item Adaptation aux changements du modèle de données
-   \end{itemize}
-   \vspace{0.5em}
-   \textbf{Apprentissages :}
-   \begin{itemize}
-      \item Génération de 3D en HTML et CSS
-      \item Manipulation d'images et de vidéos
-   \end{itemize}
-\end{frame}
+% Partie multimédia
+\section{Traitement multimédia}
+\input{diapos/multi.tex}
 
 % Démonstration
 \section{Démonstration}
-\begin{frame}{Démonstration}
-   \begin{itemize}
-      \item Vidéo ou démonstration en direct du projet
-      \item Points forts à montrer
-   \end{itemize}
-\end{frame}
+\input{diapos/demo.tex}
 
 % Conclusion
 \section{Conclusion}
-\begin{frame}{Bilan et perspectives}
-   \begin{block}{Résumé}
-      \begin{itemize}
-         \item Synthèse des apports du projet
-         \item Retour d'expérience
-      \end{itemize}
-   \end{block}
-   \begin{alertblock}{Perspectives}
-      \begin{itemize}
-         \item Améliorations possibles
-         \item Suites envisagées
-      \end{itemize}
-   \end{alertblock}
-\end{frame}
+\input{diapos/conclusion.tex}
 
 % Remerciements
 \begin{frame}{Remerciements}

diapos/cahier-charges.tex

@@ -0,0 +1,112 @@
+\begin{frame}{Spécifications et Cahier des Charges}
+   \begin{itemize}
+      \item Fonctionnalités attendues du système complet
+      \item Contraintes techniques à respecter
+      \item Livrables du projet
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Fonctionnalités principales}
+   \begin{itemize}
+      \item \textbf{Acquisition d'images}
+         \begin{itemize}
+            \item Capture programmable à intervalles réguliers
+            \item Résolution suffisante pour générer des vidéos HD
+            \item Stabilité et qualité d'image optimales
+         \end{itemize}
+      \item \textbf{Gestion des données}
+         \begin{itemize}
+            \item Stockage local des images sur la Raspberry Pi
+            \item Transmission des images vers un serveur distant
+            \item Optimisation de la consommation d'énergie et de bande passante
+         \end{itemize}
+      \item \textbf{Interfaces utilisateur}
+         \begin{itemize}
+            \item Interface web et application mobile pour configuration
+            \item Visualisation des images et vidéos générées
+            \item Informations en temps réel sur l'état de la caméra
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Contraintes du projet}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Contraintes techniques}
+         \begin{itemize}
+            \item Autonomie énergétique (batterie + panneau solaire)
+            \item Résistance aux intempéries (boîtier IP65)
+            \item Connectivité réseau fiable
+            \item Capacité de stockage suffisante
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Contraintes organisationnelles}
+         \begin{itemize}
+            \item Budget limité
+            \item Délais de développement contraints
+            \item Coordination entre équipes multidisciplinaires
+            \item Disponibilité des ressources matérielles
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Architecture globale du système}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/global/global.png}
+   \end{center}
+   \vspace{0.5em}
+   \begin{itemize}
+      \item Approche modulaire facilitant le développement parallèle
+      \item Communication entre modules via interfaces standardisées
+      \item Séparation des responsabilités : acquisition, traitement, interface
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Livrables}
+   \begin{itemize}
+      \item \textbf{Prototype de caméra timelapse fonctionnel} comprenant:
+      \begin{itemize}
+         \item Système électronique complet
+         \item Boîtier résistant aux intempéries
+         \item Logiciel embarqué sur Raspberry Pi
+      \end{itemize}
+      \item \textbf{Logiciels et interfaces}
+      \begin{itemize}
+         \item Serveur de traitement et stockage
+         \item Interface web
+         \item Application mobile Android
+      \end{itemize}
+      \item \textbf{Documentation}
+      \begin{itemize}
+         \item Plans et schémas techniques
+         \item Rapport de projet détaillé
+         \item Plan Qualité Projet (PQP)
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Indicateurs de performance}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Indicateurs de gestion}
+         \begin{itemize}
+            \item Tâches complétées par semaine
+            \item Pourcentage d'avancement vs plan
+            \item Respect des délais prévus
+            \item Nouvelles compétences acquises
+         \end{itemize}
+      \end{column}
+      
+      \begin{column}{0.5\textwidth}
+         \textbf{Indicateurs techniques}
+         \begin{itemize}
+            \item Autonomie énergétique du système
+            \item Fiabilité des transmissions de données
+            \item Qualité des vidéos générées
+            \item Score de satisfaction utilisateur
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}

diapos/conclusion.tex

@@ -0,0 +1,223 @@
+\begin{frame}{Bilan et perspectives}
+   \begin{block}{Résumé}
+      \begin{itemize}
+         \item Synthèse des apports du projet
+         \item Retour d'expérience
+      \end{itemize}
+   \end{block}
+   \begin{alertblock}{Perspectives}
+      \begin{itemize}
+         \item Améliorations possibles
+         \item Suites envisagées
+      \end{itemize}
+   \end{alertblock}
+\end{frame}
+
+\begin{frame}{Bilan du projet}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Objectifs atteints :}
+         \begin{itemize}
+            \item Système fonctionnel et autonome
+            \item Interface utilisateur intuitive
+            \item Qualité d'image satisfaisante
+            \item Communication fiable entre composants
+            \item Solution complète de bout en bout
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Retour d'expérience :}
+         \begin{itemize}
+            \item Travail en équipe pluridisciplinaire
+            \item Gestion des contraintes techniques
+            \item Adaptation aux imprévus
+            \item Intégration de multiples technologies
+            \item Respect des délais et du budget
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Difficultés rencontrées et solutions}
+   \begin{itemize}
+      \item \textbf{Autonomie énergétique}
+         \begin{itemize}
+            \item Difficulté : Consommation élevée du Raspberry Pi
+            \item Solution : Mode veille optimisé et panneau solaire dimensionné
+         \end{itemize}
+      \item \textbf{Transmission des données}
+         \begin{itemize}
+            \item Difficulté : Connexion instable en zone reculée
+            \item Solution : File d'attente et compression intelligente
+         \end{itemize}
+      \item \textbf{Intégration des composants}
+         \begin{itemize}
+            \item Difficulté : Espace limité et contraintes thermiques
+            \item Solution : Conception 3D optimisée et refroidissement passif
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Perspectives d'évolution}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Améliorations techniques :}
+         \begin{itemize}
+            \item Réduction de la consommation énergétique
+            \item Augmentation de la résolution (8K)
+            \item Intégration de l'IA pour traitement avancé
+            \item Optimisation pour conditions extrêmes
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Nouvelles fonctionnalités :}
+         \begin{itemize}
+            \item Détection automatique d'événements
+            \item Contrôle par commande vocale
+            \item Intégration avec drones pour vues dynamiques
+            \item Analyses prédictives des phénomènes observés
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Applications futures}
+   \begin{itemize}
+      \item \textbf{Domaine scientifique}
+         \begin{itemize}
+            \item Surveillance environnementale
+            \item Étude des écosystèmes
+            \item Documentation des changements climatiques
+         \end{itemize}
+      \item \textbf{Domaine industriel}
+         \begin{itemize}
+            \item Suivi de chantiers complexes
+            \item Contrôle de processus industriels
+            \item Documentation pour assurances et contentieux
+         \end{itemize}
+      \item \textbf{Domaine artistique et médiatique}
+         \begin{itemize}
+            \item Productions audiovisuelles professionnelles
+            \item Installations artistiques interactives
+            \item Documentation d'événements culturels
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Mot de la fin}
+   \begin{center}
+      \Large\textbf{Merci pour votre attention !}
+      
+      \vspace{1cm}
+      
+      \normalsize
+      Des questions ?
+   \end{center}
+\end{frame}
+
+\begin{frame}{Conclusion}
+   \begin{itemize}
+      \item Réalisation d'un système complet de caméra timelapse autonome
+      \item Approche multi-disciplinaire : mécanique, électronique et informatique
+      \item Méthodologie agile et développement en cycle en V avec itérations
+      \item Tous les objectifs initiaux atteints avec succès
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Récapitulatif du projet}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Réalisations techniques :}
+         \begin{itemize}
+            \item Boîtier robuste et résistant aux intempéries
+            \item Système électronique autonome
+            \item Infrastructure serveur complète
+            \item Interfaces web et mobile fonctionnelles
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Résultats obtenus :}
+         \begin{itemize}
+            \item Prototype fonctionnel
+            \item Interface utilisateur intuitive
+            \item Qualité des timelapses générés
+            \item Fiabilité du système complet
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Gestion des risques}
+   \begin{center}
+      \begin{tabular}{|p{4cm}|p{3.5cm}|p{3.5cm}|}
+      \hline
+      \textbf{Risques identifiés} & \textbf{Impact potentiel} & \textbf{Solutions mises en œuvre} \\
+      \hline
+      Intégration mécatronique & Délais, coûts & Communication renforcée \\
+      \hline
+      Dysfonctionnement serveur & Pertes de données & Système robuste, sauvegarde \\
+      \hline
+      Manque de ressources & Délais & Ressources personnelles \\
+      \hline
+      \end{tabular}
+   \end{center}
+   \vspace{0.5em}
+   \begin{itemize}
+      \item Analyse précoce des risques
+      \item Actions préventives efficaces
+      \item Réactivité face aux problèmes rencontrés
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Compétences développées}
+   \begin{itemize}
+      \item \textbf{Compétences techniques :}
+      \begin{itemize}
+         \item Conception mécanique et fabrication additive
+         \item Conception électronique et intégration
+         \item Développement logiciel full-stack (serveur, web, mobile)
+         \item Administration système et DevOps
+      \end{itemize}
+      \item \textbf{Compétences transversales :}
+      \begin{itemize}
+         \item Gestion de projet agile
+         \item Communication interdisciplinaire
+         \item Résolution de problèmes complexes
+         \item Documentation technique
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Perspectives d'amélioration}
+   \begin{itemize}
+      \item \textbf{Améliorations techniques possibles :}
+      \begin{itemize}
+         \item Optimisation de l'autonomie énergétique
+         \item Ajout de capteurs environnementaux supplémentaires
+         \item Amélioration des algorithmes de traitement d'images
+         \item Interface de configuration plus complète
+      \end{itemize}
+      \item \textbf{Évolutions potentielles :}
+      \begin{itemize}
+         \item Support pour plusieurs caméras synchronisées
+         \item Intégration d'intelligence artificielle pour analyse
+         \item Version commercialisable avec documentation utilisateur
+         \item Extension à d'autres usages (surveillance, etc.)
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Remerciements et questions}
+   \begin{center}
+      \large\textbf{Merci pour votre attention}
+      \vspace{1.5em}
+      
+      \normalsize
+      Projet réalisé par\\
+      THIEFFRY Raphaël, HUA Olivier, RIBETTE Baptiste,\\
+      PUYAUBREAU Ethan et RUSSAC Antonin
+      \vspace{1.5em}
+      
+      \large\textbf{Questions ?}
+   \end{center}
+\end{frame}

diapos/contexte-objectifs.tex

@@ -0,0 +1,99 @@
+\begin{frame}{Contexte et Objectifs}
+   \begin{itemize}
+      \item Création d'une caméra timelapse autonome et connectée
+      \item Développement complet : matériel, logiciel et interfaces utilisateur
+      \item Utilisation d'une Raspberry Pi et d'un module caméra fournis
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Qu'est-ce qu'un Timelapse?}
+   \begin{columns}
+      \begin{column}{0.6\textwidth}
+         \begin{itemize}
+            \item Technique photographique qui compresse le temps
+            \item Capture d'images à intervalles réguliers
+            \item Assemblées en vidéo à fréquence normale (24-30 fps)
+            \item Permet d'observer des phénomènes lents (construction, floraison, etc.)
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.4\textwidth}
+         \centering
+         % Image exemple d'un timelapse
+         [Image exemple de timelapse]
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Objectifs du projet}
+   \begin{itemize}
+      \item \textbf{Objectif principal :} Infrastructure matérielle et logicielle permettant la création d'une vidéo à partir d'une série d'images capturées via une caméra sans fil
+      \item \textbf{Objectifs secondaires :}
+      \begin{itemize}
+         \item Créer un serveur de traitement et stockage
+         \item Développer une interface d'accès Web
+         \item Concevoir une application mobile
+         \item Fabriquer un boîtier résistant aux intempéries
+         \item Concevoir une carte électronique pour gérer l'énergie
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Périmètre du projet}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Informatique :}
+         \begin{itemize}
+            \item Traitement et stockage des données
+            \item Serveur, interfaces Web et Android
+            \item Publication de l'application
+         \end{itemize}
+         
+         \textbf{Électronique :}
+         \begin{itemize}
+            \item Système autonome d'alimentation
+            \item Gestion de la consommation d'énergie
+            \item Protocoles de communication
+         \end{itemize}
+      \end{column}
+      
+      \begin{column}{0.5\textwidth}
+         \textbf{Mécanique :}
+         \begin{itemize}
+            \item Boîtier étanche et robuste
+            \item Système de fixation adaptable
+            \item Facilité de montage/démontage
+         \end{itemize}
+         
+         \textbf{Hors périmètre :}
+         \begin{itemize}
+            \item Conception de la caméra
+            \item Traitement d'images avancé
+            \item Conception du matériel informatique
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Applications visées}
+   \begin{itemize}
+      \item \textbf{Projets de construction}
+      \begin{itemize}
+         \item Suivi de l'évolution des chantiers
+         \item Documentation du processus de construction
+      \end{itemize}
+      \item \textbf{Phénomènes naturels}
+      \begin{itemize}
+         \item Croissance des plantes, floraison
+         \item Événements météorologiques, lever/coucher de soleil
+      \end{itemize}
+      \item \textbf{Événements de longue durée}
+      \begin{itemize}
+         \item Expositions, événements publics
+      \end{itemize}
+      \item \textbf{Projets artistiques}
+      \begin{itemize}
+         \item Création de contenu visuel
+         \item Narration visuelle accélérée
+      \end{itemize}
+   \end{itemize}
+\end{frame}

diapos/demo.tex

@@ -0,0 +1,97 @@
+\begin{frame}{Démonstration}
+   \begin{center}
+      \huge\textbf{Démonstration du projet}
+      \vspace{1em}
+      
+      \large Présentation du prototype fonctionnel
+   \end{center}
+\end{frame}
+
+\begin{frame}{Prototype intégré}
+   \begin{columns}
+      \begin{column}{0.6\textwidth}
+         \textbf{Présentation du prototype :}
+         \begin{itemize}
+            \item Boîtier complet avec tous les composants intégrés
+            \item Système électronique fonctionnel
+            \item Connexion au serveur et démonstration de capture
+            \item Tests des différentes fonctionnalités
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.4\textwidth}
+         \centering
+         % Image du prototype final
+         [Photo du prototype complet]
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Interface web}
+   \begin{center}
+      % Capture d'écran de l'interface web
+      [Capture d'écran de l'interface web]
+      \vspace{0.5em}
+      \textit{Interface de gestion des projets timelapse}
+   \end{center}
+   \vspace{0.5em}
+   Démonstration des fonctionnalités :
+   \begin{itemize}
+      \item Création et configuration d'un projet
+      \item Visualisation des images capturées
+      \item Génération et visualisation d'une vidéo timelapse
+      \item Configuration des paramètres de capture
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Application Android}
+   \begin{center}
+      % Capture d'écran de l'application mobile
+      [Capture d'écran de l'application mobile]
+      \vspace{0.5em}
+      \textit{Application mobile de contrôle et visualisation}
+   \end{center}
+   \vspace{0.5em}
+   Démonstration des fonctionnalités :
+   \begin{itemize}
+      \item Connexion et authentification
+      \item Consultation des projets en cours
+      \item Configuration à distance de la caméra
+      \item Visualisation des timelapses générés
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Vidéos timelapses générées}
+   \begin{center}
+      % Exemple de timelapses générés
+      [Exemples de timelapses générés]
+      \vspace{0.5em}
+      \textit{Résultats obtenus avec le système développé}
+   \end{center}
+   \vspace{0.5em}
+   \begin{itemize}
+      \item Présentation de plusieurs exemples de timelapse
+      \item Démonstration de différents intervalles et durées
+      \item Qualité d'image et stabilité du résultat
+      \item Comparaison avant/après traitement
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Performances et résultats}
+   \begin{itemize}
+      \item \textbf{Autonomie énergétique :}
+      \begin{itemize}
+         \item Test en conditions réelles sur plusieurs jours
+         \item Données de consommation et recharge
+      \end{itemize}
+      \item \textbf{Fiabilité de la transmission :}
+      \begin{itemize}
+         \item Statistiques de transmissions réussies
+         \item Tests en conditions de connexion dégradée
+      \end{itemize}
+      \item \textbf{Qualité du traitement :}
+      \begin{itemize}
+         \item Stabilité des vidéos générées
+         \item Efficacité des algorithmes de correction
+      \end{itemize}
+   \end{itemize}
+\end{frame}

diapos/elec.tex

@@ -0,0 +1,141 @@
+\begin{frame}{Partie électronique}
+   \begin{itemize}
+      \item Conception du système électronique autonome
+      \item Gestion intelligente de l'énergie
+      \item Intégration des composants avec la Raspberry Pi
+      \item Protocoles de communication
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Composants électroniques principaux}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Unité de traitement :}
+         \begin{itemize}
+            \item Raspberry Pi 4B avec Raspbian
+            \item Module caméra fourni par l'école
+            \item Microcontrôleur STM32 pour gestion d'énergie
+            \item Capteur hygrométrique
+         \end{itemize}
+         
+         \textbf{Connectivité :}
+         \begin{itemize}
+            \item WiFi intégré à la Raspberry Pi
+            \item Connexions filaires sécurisées
+         \end{itemize}
+      \end{column}
+      
+      \begin{column}{0.5\textwidth}
+         \textbf{Alimentation :}
+         \begin{itemize}
+            \item Batterie de 6€
+            \item Panneaux solaires
+            \item Modules d'alimentation à découpage (2)
+            \item Système de gestion d'énergie
+         \end{itemize}
+         
+         \textbf{Composants additionnels :}
+         \begin{itemize}
+            \item Transistors (2 en 1)
+            \item LED indicatrices d'état
+            \item Résistances et condensateurs
+            \item Connectique et câbles
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Architecture électronique}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/01_architecture_generale/Architecture Générale du Système Timelapse.png}
+   \end{center}
+   \vspace{0.5em}
+   \begin{itemize}
+      \item Conception modulaire avec connecteurs standards
+      \item Protection contre les surtensions et court-circuits
+      \item PCB optimisé pour minimiser les interférences
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Conception et fabrication du PCB}
+   \begin{itemize}
+      \item \textbf{Outils de conception :}
+      \begin{itemize}
+         \item Altium Designer pour conception et routage
+         \item STM32 CubeIDE et STMProgrammer pour le développement logiciel
+      \end{itemize}
+      \item \textbf{Processus de fabrication :}
+      \begin{itemize}
+         \item Utilisation d'une graveuse mécanique
+         \item PCB vierge (6€)
+         \item Assemblage manuel des composants
+         \item Tests de fonctionnement
+      \end{itemize}
+      \item \textbf{Approche itérative :}
+      \begin{itemize}
+         \item Versions successives documentées
+         \item Répertoires numérotés par version de production
+         \item Archives détachées des répertoires de travail
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Gestion de l'énergie}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Enjeux énergétiques :}
+         \begin{itemize}
+            \item Autonomie complète en extérieur
+            \item Optimisation de la consommation
+            \item Gestion des cycles charge/décharge
+            \item Adaptation aux conditions météo
+         \end{itemize}
+      \end{column}
+      
+      \begin{column}{0.5\textwidth}
+         \textbf{Solutions implémentées :}
+         \begin{itemize}
+            \item Circuit de charge intelligent
+            \item Mode économie d'énergie
+            \item Surveillance de la batterie
+            \item Protection contre décharge profonde
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Flux de traitement des données}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/02_flux_capture/Flux du Processus de Capture d'Images.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Capture et traitement d'images optimisés
+      \item Stockage temporaire sur la Raspberry Pi
+      \item Synchronisation avec le serveur distant
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Défis électroniques}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Défis rencontrés :}
+         \begin{itemize}
+            \item Intégration mécatronique
+            \item Problématiques d'autonomie énergétique
+            \item Fiabilité des connexions
+            \item Gestion de la chaleur
+         \end{itemize}
+      \end{column}
+      
+      \begin{column}{0.5\textwidth}
+         \textbf{Solutions apportées :}
+         \begin{itemize}
+            \item Communication constante avec l'équipe mécanique
+            \item Design électronique à basse consommation
+            \item Connecteurs sécurisés et isolés
+            \item Systèmes de dissipation thermique
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}

diapos/info.tex

@@ -0,0 +1,188 @@
+\begin{frame}{Architecture informatique}
+   \begin{itemize}
+      \item Développement basé sur méthodologie agile
+      \item Architecture client-serveur distribuée
+      \item Trois composants principaux : Backend, Frontend, Application mobile
+      \item Infrastructure robuste et sécurisée
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Architecture globale}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/architecture/architecture_timelapse.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Architecture modulaire avec interfaces standardisées
+      \item Communication via API REST sécurisée
+      \item Séparation claire des responsabilités
+      \item Intégration continue et déploiement automatisé
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Infrastructure et déploiement}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/backend/backend5/Déploiement.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Applications hébergées dans des conteneurs Docker
+      \item Machine virtuelle Ubuntu Server sur hyperviseur Proxmox
+      \item Trois niveaux d'abstraction facilitant maintenance et sauvegarde
+      \item Déploiement et mise à jour automatisés via CI/CD
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Structure des classes et composants}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/raspi/03_structure_classes/Structure des Classes et Composants.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Organisation objet orientée domaines
+      \item Séparation des responsabilités
+      \item Interfaces clairement définies entre composants
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Synchronisation des données}
+   \begin{center}
+      \includegraphics[width=0.75\textwidth]{out/diagrams/raspi/04_sequence_synchronisation/Séquence de Synchronisation des Données.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Processus robuste de transfert des images
+      \item Gestion des échecs de connexion
+      \item Reprise de transfert automatique
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Backend - Technologies et architecture}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Technologies utilisées :}
+         \begin{itemize}
+            \item Node.js + Express
+            \item FFMPEG pour traitement vidéo
+            \item NPM pour la gestion des dépendances
+            \item Docker pour la conteneurisation
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Architecture :}
+         \begin{itemize}
+            \item Architecture MVC
+            \item API RESTful
+            \item Traitement asynchrone
+            \item Gestion des erreurs robuste
+         \end{itemize}
+      \end{column}
+   \end{columns}
+   \begin{center}
+      \includegraphics[width=0.5\textwidth]{out/diagrams/backend/backend2/Architecture MVC.png}
+   \end{center}
+\end{frame}
+
+\begin{frame}{Backend - Modèles de données et traitement}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \begin{center}
+            \includegraphics[width=\textwidth]{out/diagrams/backend/backend1/Modèles de données.png}
+         \end{center}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \begin{center}
+            \includegraphics[width=\textwidth]{out/diagrams/backend/backend3/Création de vidéo.png}
+         \end{center}
+      \end{column}
+   \end{columns}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Modèles structurés pour stockage et traitement efficaces
+      \item Algorithme optimisé pour la création de vidéos timelapse
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Frontend Web}
+   \begin{columns}
+      \begin{column}{0.6\textwidth}
+         \textbf{Technologies et organisation :}
+         \begin{itemize}
+            \item Javascript (jQuery) + HTML + CSS
+            \item Organisation modulaire du code
+            \item Style universel pour confort utilisateur
+            \item Interface responsive et intuitive
+         \end{itemize}
+         \vspace{0.5em}
+         \textbf{Fonctionnalités principales :}
+         \begin{itemize}
+            \item Gestion des projets timelapse
+            \item Visualisation des images et vidéos
+            \item Configuration des paramètres
+            \item Carousel 3D animé et modulable
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.4\textwidth}
+         \begin{center}
+            \includegraphics[width=\textwidth]{out/diagrams/frontend/frontend3/frontend3.png}
+         \end{center}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Application Mobile Android}
+   \begin{columns}
+      \begin{column}{0.6\textwidth}
+         \textbf{Technologies :}
+         \begin{itemize}
+            \item Kotlin avec Retrofit et Glide
+            \item XML pour layouts
+            \item Android API native
+         \end{itemize}
+         \vspace{0.5em}
+         \textbf{Fonctionnalités :}
+         \begin{itemize}
+            \item Visualisation des projets et timelapses
+            \item Configuration à distance des caméras
+            \item Mode hors-ligne avec synchronisation
+            \item Notifications en temps réel
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.4\textwidth}
+         \begin{center}
+            \includegraphics[width=\textwidth]{UML Schematique android.png}
+         \end{center}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Intégration et flux de données}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/global_interspec_lite/global_interspec_lite.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Communication fluide entre tous les composants
+      \item Interfaces standardisées pour l'échange de données
+      \item Gestion des erreurs et reprise sur incident
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Sécurité et optimisation}
+   \begin{itemize}
+      \item \textbf{Sécurité :}
+      \begin{itemize}
+         \item Authentification sécurisée
+         \item Exposition sécurisée via reverse proxy
+         \item Chiffrement des communications
+         \item VPN et re-routage d'adresses IP
+      \end{itemize}
+      \item \textbf{Optimisation :}
+      \begin{itemize}
+         \item Adaptation de la qualité selon la connexion
+         \item Mise en cache des données pour fonctionnement hors-ligne
+         \item Traitement asynchrone des tâches lourdes
+         \item Compression adaptative des images et vidéos
+      \end{itemize}
+   \end{itemize}
+\end{frame}

diapos/meca.tex

@@ -0,0 +1,111 @@
+\begin{frame}{Partie mécanique}
+   \begin{itemize}
+      \item Conception d'un boîtier robuste et adapté
+      \item Choix des matériaux pour environnement extérieur
+      \item Système de fixation modulaire et ajustable
+      \item Protection des composants électroniques
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Conception mécanique}
+   \begin{columns}
+      \begin{column}{0.6\textwidth}
+         \textbf{Caractéristiques principales :}
+         \begin{itemize}
+            \item Boîtier étanche IP65 (résistant aux intempéries)
+            \item Support orientable pour cadrage optimal
+            \item Fixation universelle (trépied, rail, mur)
+            \item Accès facile aux composants pour maintenance
+            \item Ventilation passive pour éviter la surchauffe
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.4\textwidth}
+         \centering
+         % Image du prototype électromécanique
+         [Image du prototype boîtier]
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Méthodologie de conception}
+   \begin{itemize}
+      \item \textbf{Approche par cycle en V avec itérations}
+      \begin{itemize}
+         \item Phase d'analyse des besoins
+         \item Spécifications techniques détaillées
+         \item Conception générale et détaillée
+         \item Prototypages successifs et tests
+      \end{itemize}
+      \item \textbf{Intégration avec la partie électronique}
+      \begin{itemize}
+         \item Communication constante entre équipes mécanique et électronique
+         \item Conception adaptée aux contraintes d'assemblage
+         \item Marges de sécurité pour ajustements finaux
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Processus de fabrication}
+   \begin{itemize}
+      \item \textbf{Prototypage :}
+         \begin{itemize}
+            \item Conception 3D sur Solidworks
+            \item Impression 3D avec Bambu Lab X1S (PLA)
+            \item Tests d'étanchéité et de résistance
+            \item Organisation de répertoires "RELEASE" pour archiver chaque prototype
+         \end{itemize}
+      \item \textbf{Optimisations :}
+         \begin{itemize}
+            \item Réduction du poids tout en maintenant la solidité
+            \item Amélioration de la ventilation interne
+            \item Simplification du montage/démontage
+            \item Passages de câbles optimisés
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Choix des matériaux}
+   \begin{itemize}
+      \item \textbf{Matériau principal : PLA}
+      \begin{itemize}
+         \item Facilité d'impression et précision dimensionnelle
+         \item Coût raisonnable (20€/kg)
+         \item Rigidité adaptée aux contraintes mécaniques
+      \end{itemize}
+      \item \textbf{Analyse et sélection}
+      \begin{itemize}
+         \item Utilisation du logiciel CES pour le choix du matériau
+         \item Calculs de contraintes avec RDM6
+         \item Compromis entre légèreté, résistance et coût
+      \end{itemize}
+      \item \textbf{Éléments complémentaires}
+      \begin{itemize}
+         \item Visserie standard pour faciliter maintenance
+         \item Joints d'étanchéité sur mesure
+         \item Supports anti-vibration pour la caméra
+      \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Défis mécaniques rencontrés}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Défis}
+         \begin{itemize}
+            \item Intégration mécatronique complexe
+            \item Étanchéité vs ventilation
+            \item Poids vs rigidité
+            \item Tolérance dimensionnelle de l'impression 3D
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Solutions}
+         \begin{itemize}
+            \item Communication renforcée entre équipes
+            \item Systèmes d'aération avec filtres
+            \item Nervures de renfort dans la conception
+            \item Tests et itérations multiples
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}

diapos/multi.tex

@@ -0,0 +1,130 @@
+\begin{frame}{Traitement multimédia}
+   \begin{itemize}
+      \item Acquisition et traitement des images
+      \item Génération automatisée des timelapses
+      \item Optimisation des processus de traitement
+      \item Compatibilité avec différents formats et résolutions
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Acquisition d'images}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Paramètres de capture :}
+         \begin{itemize}
+            \item Résolution : jusqu'à HD (1920×1080)
+            \item Format : JPEG optimisé
+            \item Intervalles configurables via l'interface
+            \item Exposition automatique adaptative
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Optimisations :}
+         \begin{itemize}
+            \item Adaptation auto selon les conditions
+            \item Balance des blancs automatique
+            \item Compression intelligente
+            \item Stockage efficient des métadonnées
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Processus de capture et traitement}
+   \begin{center}
+      \includegraphics[width=0.8\textwidth]{out/diagrams/backend/backend3/Création de vidéo.png}
+   \end{center}
+   \vspace{0.3em}
+   \begin{itemize}
+      \item Acquisition planifiée des images
+      \item Prétraitement sur la Raspberry Pi
+      \item Transmission sécurisée vers le serveur
+      \item Assemblage en vidéo via FFMPEG
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Traitement des images}
+   \begin{itemize}
+      \item \textbf{Pré-traitement sur la Raspberry Pi :}
+         \begin{itemize}
+            \item Validation de la qualité de l'image
+            \item Compression adaptative selon la connexion
+            \item Stockage temporaire sécurisé
+            \item Préparation pour transmission
+         \end{itemize}
+      \item \textbf{Traitement sur le serveur :}
+         \begin{itemize}
+            \item Normalisation des images
+            \item Correction de luminosité entre les prises
+            \item Algorithme anti-scintillement (deflicker)
+            \item Détection et élimination des images défectueuses
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Génération de timelapses}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Pipeline de traitement :}
+         \begin{enumerate}
+            \item Importation et vérification des images
+            \item Traitement par lot avec FFMPEG
+            \item Ajout d'effets et transitions
+            \item Encodage optimisé (H.264/H.265)
+            \item Génération de vignettes pour les interfaces
+         \end{enumerate}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Options de personnalisation :}
+         \begin{itemize}
+            \item Vitesse de lecture ajustable
+            \item Résolution de sortie configurable
+            \item Options de qualité/compression
+            \item Possibilité d'ajouter des titres
+            \item Formats de sortie multiples
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}
+
+\begin{frame}{Optimisations du traitement}
+   \begin{itemize}
+      \item \textbf{Performance serveur :}
+         \begin{itemize}
+            \item Traitement asynchrone des requêtes
+            \item File d'attente pour les tâches intensives
+            \item Parallélisation des opérations quand possible
+            \item Cache intelligent des ressources
+         \end{itemize}
+      \item \textbf{Optimisation bande passante :}
+         \begin{itemize}
+            \item Compression adaptative selon la qualité du réseau
+            \item Transfert par lots d'images
+            \item Reprise automatique des transferts interrompus
+            \item Priorisation des données essentielles
+         \end{itemize}
+   \end{itemize}
+\end{frame}
+
+\begin{frame}{Défis et solutions techniques}
+   \begin{columns}
+      \begin{column}{0.5\textwidth}
+         \textbf{Défis :}
+         \begin{itemize}
+            \item Variations de luminosité entre prises
+            \item Connexion réseau intermittente
+            \item Ressources limitées sur la Raspberry Pi
+            \item Conservation de la qualité d'image
+         \end{itemize}
+      \end{column}
+      \begin{column}{0.5\textwidth}
+         \textbf{Solutions :}
+         \begin{itemize}
+            \item Algorithmes de normalisation
+            \item Système de mise en cache et synchronisation
+            \item Optimisation du code pour faible consommation
+            \item Paramètres de compression intelligents
+         \end{itemize}
+      \end{column}
+   \end{columns}
+\end{frame}