src/Controller/MeteoController.php line 586

Open in your IDE?
  1. <?php
  3. namespace App\Controller;
  5. use App\Service\MeteoFranceService;
  6. use App\DTO\StationMeteoDTO;
  7. use App\Form\StationMeteoType; 
  8. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  9. use Symfony\Component\HttpFoundation\JsonResponse;
  10. use Symfony\Component\HttpFoundation\Response;
  11. use Symfony\Component\Routing\Annotation\Route;
  12. use Doctrine\ORM\EntityManagerInterface;
  13. use Symfony\Component\HttpFoundation\Request;
  14. use App\Entity\Pluviometrie;
  15. use App\Entity\StationsMeteo;
  17. set_time_limit(36000);
  19. class MeteoController extends AbstractController {
  21. //    private HttpClientInterface $client;
  22. //    private CacheInterface $cache;
  23. //    private string $apiKey;
  24. //    private string $tokenUrl;
  25. //    private string $apiUrl;
  26.     
  27.     public function __construct(private MeteoFranceService $meteoService, StationMeteoType $stationMeteoType){//, HttpClientInterface $client, CacheInterface $cache, string $apiKey, string $meteoFranceTokenUrl, string $meteoFranceApiUrl) {
  28.         $this->stationMeteoType = $stationMeteoType;
  29.     }
  31.     #[Route(path: '/meteo/stations/tous', name: 'meteo_stations_tous')]
  32.     public function getAllStationsData(EntityManagerInterface $em, \App\Repository\PluvioDatabaseRepository $pluvioRepo,
  33.             Request $req): Response {
  34.         // Liste des départements (exemple de 5 départements, tu peux en ajouter plus)
  35.         $departements = ['974','976','984', '985','986','987','988'];
  36.             //'17','18','19','20','21','22','23','24','25','26','27','28','29','30','31','32',
  37.             //'33','34','35','36','37','38','39','40','41','42','43','44','45','46','47','48','49','50','51','52','53','54','55','56','57',
  38.             //'58','59','60','61','62','63','64','65','66','67','68','69','70','71','72','73','74','75','76','77','78','79','80','81','82',
  39.             //'83','84','85','86','87','88','89','90','91','92','93','94','95','971','972','973',
  40.          //,   ,
  41.             //'11','12','13','14','15','16',
  42.            // '01','02']; '05','06','07','08','09','10'// Remplace par la liste complète des départements
  43.         
  44.         //[
  45.             //'75','92', '69','91','13','31','44',           
  46.             //'33'//,'35','51','06','67','38','73','63','76',
  47.              //    '26','53','45','59','16','84','79','2A','37','64','34','85','49','74','29','56','95','14','25','10',
  48.              //    '86','42','77','87','54','71','39','50','60','17','22','72','41','83','90','28','52','12','05','89',
  49.              //    '18','01','04','19','40','48','47','88','57','03','30','27','46','08','58','65','15','81','36','2B',
  50.              // '66','62','82','43','61','02','24','55','11','32','07','70','09','23'
  51.             //'78'//'93'//,'93',,  '21'// 
  52.           //  ];
  53.         
  54.         
  56.         $stationsData = [];
  57.         $commandeArray = []; // Initialisation pour éviter l'erreur Undefined variable
  58.         $columnDataArray = []; // Initialisation pour stocker les données des colonnes
  59.         // Boucle pour récupérer les données pour chaque département
  60. //        foreach ($departements as $departement) {
  61. //            try {
  62. //                $stations = $this->meteoService->getStationsByDepartment($departement);
  63. //
  64. //                // Ajouter le numéro du département à chaque station
  65. //                foreach ($stations as &$station) {
  66. //                    $station['departement'] = $departement;
  67. //                }
  68. //
  69. //                $stationsData[$departement] = $stations;
  70. //            } catch (\Exception $e) {
  71. //                $stationsData[$departement] = ['error' => $e->getMessage()];
  72. //            }
  73. //            
  74. //                // Pause pour respecter la limite de 50 requêtes par minute
  75. //               usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes
  76. //            
  77. //        }
  78. //
  79. //        dump($stationsData);
  80. //
  81. //        foreach ($stationsData as $listeStationsDdepartement) {
  82.             
  83.             //$listeStationsDdepartement = $em->getRepository(StationsMeteo::class)->findAll();
  84.             $listeStationsDdepartement = $em->getRepository(StationsMeteo::class)
  85.     ->createQueryBuilder('s')
  86.     ->where('s.departement > :min')
  87.     ->andWhere('s.departement < :max')
  88.     ->setParameter('min', 39)
  89.     ->setParameter('max', 41)
  90.     ->getQuery()
  91.     ->getResult();
  93.             // Pour chaque station, on réalise une commande
  94.             foreach ($listeStationsDdepartement as $station) {
  95.                 dump($station);
  96.             //    if ($station['typePoste'] < 2) {
  97.                     $stationId = $station->getIdStation();
  98.                      dump($stationId);
  99.                     $AnneesEtudiees = [];
  100.                     foreach (range(2020, 2024) as $annee) {
  101.                         $AnneesEtudiees[$annee] = [
  102.                             'dateDeb' => "{$annee}-01-01T00%3A00%3A00Z",
  103.                             'dateFin' => "{$annee}-12-31T00%3A00%3A00Z",
  104.                         ];
  105.                     }
  107.                     foreach ($AnneesEtudiees as $annee => $AnneeEtudiee) {
  109.                         //check si déjà commandé ?
  110.                         $dejaCommandee = null;
  111.                         $stationEntity = $em->getRepository(StationsMeteo::class)->findOneBy(['IdStation' => $stationId]);
  112.                         if ($stationEntity) {
  113.                             $dejaCommandee = $em->getRepository(Pluviometrie::class)->findOneBy([
  114.                                 'idStation' => $stationEntity,
  115.                                 'annee' => $annee
  116.                             ]);
  117.                         }
  118.                         if (!$dejaCommandee) {
  119.                             $commande = $this->meteoService->getStationData($stationId, $AnneeEtudiee);
  120.                             $commandeArray[$stationId][$annee] = $commande;
  121.                             // Pause pour respecter la limite de 50 requêtes par minute
  122.                             usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes
  123.                         }
  124.                     }
  127.                     //$nomDesStations[] = $station['nom'];
  129.                     $stationDB = $em->getRepository(StationsMeteo::class)->findOneBy(['IdStation' => $stationId]);
  131.                     if (!$stationDB) {
  132.                         // Si la station n'existe pas, alors crée-la
  133.                         //saisie dans la bdd
  134.                         $stationDB = new \App\Entity\StationsMeteo();
  135.                         $stationDB->setNomStation($station['nom']);
  136.                         $stationDB->setTypeStation($station['typePoste']);
  137.                         $stationDB->setDepartement($station['departement']);
  138.                         $stationDB->setIdStation($station['id']);
  139.                         dump($stationDB);
  140.                         $em->persist($stationDB);
  141.                         $em->flush();
  142.                     }
  143.             //    }
  144.             }
  145.        // }
  146.         dump($commandeArray);
  147.         $erreur500 = null;
  148.         $extractedData = null;
  150.         // Récupération des fichiers à partir des commandes
  151.         foreach ($commandeArray as $stationId => $anneesData) {
  152.             dump($anneesData);
  153.             $erreur = null;
  154.             
  156.             foreach ($anneesData as $AnneeEtudiee => $commandeAnnee) {
  157.                 $commandeId = $commandeAnnee['elaboreProduitAvecDemandeResponse']['return'];
  158.                 dump($commandeId);
  160.                 $csvString = $this->meteoService->getFichier($commandeId);
  161.                 // Pause pour respecter la limite de 50 requêtes par minute
  162.                 usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes  
  163.                 
  164.                 if ($csvString == 'Erreur 500'){
  165.                     $erreur500[$commandeId] = $stationId;                    
  166.                     $erreur = 1;
  167.                 } else {
  168.                                    // Diviser la chaîne en lignes
  169.                     $lines = explode("\n", $csvString);
  171.                     // Tableau pour stocker les données extraites
  172.                     $extractedData = [];
  174.                     foreach ($lines as $index => $line) {
  175.                         // Ignorer la première ligne (en-tête)
  176.                         if ($index === 0) {
  177.                             continue;
  178.                         }
  180.                         // Diviser chaque ligne en colonnes par le séparateur ;
  181.                         $columns = explode(";", $line);
  183.                         // Vérifier qu'il y a suffisamment de colonnes
  184.                         if (count($columns) > 2) {
  185.                             // Extraire ce qui se situe entre le 3ème et 4ème point-virgule
  186.                             $data = $columns[2]; // Récupère la valeur de l'élément à l'index 2 (entre 3ème et 4ème point-virgule)
  187.                             // Remplacer les virgules par des points
  188.                             $data = str_replace(",", ".", $data);
  190.                             $extractedData[] = $data;
  191.                         }
  192.                     }
  195.                     // Création de l'entité Pluviometrie
  196.                     $entity = new \App\Entity\Pluviometrie();
  197.                     $entity->setRainData($extractedData);
  198.                     dump($stationId);
  199.                     // Vérifie si tu récupères bien l'entité StationsMeteo avant de l'assigner
  200.                     $station = $em->getRepository(StationsMeteo::class)->findOneBy(['IdStation' => $stationId]);
  202.                     if ($station) {
  203.                         $entity->setIdStation($station); // Assigner l'entité StationMeteo
  204.                     } else {
  205.                         // Gérer le cas où la station n'existe pas
  206.                         throw new \Exception("Station not found");
  207.                     }
  209.                     // Lier l'année à Pluviometrie
  210.                     $entity->setAnnee($AnneeEtudiee);
  212.                     // Persister l'entité
  213.                     $em->persist($entity);
  214.                     
  215.                 }
  216.             }
  217.             
  218.             if (!$erreur){
  219.                 $em->flush();
  220.             }
  221.             
  222.         }
  224. // Flush une seule fois après avoir traité toutes les données
  225.         
  226. $query = $em->createQueryBuilder()
  227.     ->select('s.id')  // On récupère uniquement l'ID de la station météo
  228.     ->from(\App\Entity\Pluviometrie::class, 'p')
  229.     ->join('p.idStation', 's')  // Jointure avec StationsMeteo
  230.     ->getQuery();
  232. $idStations = $query->getResult();
  233.     dump($idStations); //die();
  234.     
  235.     // Extraction des ID des stations météorologiques
  236.     $idStation = [];
  237.     foreach ($idStations as $idStation) {
  238.         
  239.             $idStationArray[] = $idStation['id'];
  240.         
  241.     }
  242. dump($idStationArray);
  243.     // Supprimer les doublons d'ID
  244.     $listeUniqueIdStation = array_unique($idStationArray);
  245. dump($listeUniqueIdStation); 
  246.     // Récupérer toutes les stations correspondantes
  247.     $stationDBAll = $em->getRepository(\App\Entity\StationsMeteo::class)
  248.                        ->findBy(['id' => $listeUniqueIdStation], ['departement' => 'ASC']);
  249. dump($stationDBAll); //die();
  250.     return $this->render('meteoFrance.html.twig', ['stationDBAll' => $stationDBAll]);
  251.     }
  253.     #[Route(path: '/meteo/listeStation', name: 'listeStation')]
  254.     public function listeStation(EntityManagerInterface $em, \App\Repository\PluvioDatabaseRepository $pluvioRepo,
  255.             Request $req): Response {
  256. $stationDBAll = $em->getRepository(StationsMeteo::class)->findAll();
  257. return $this->render('meteoFrance.html.twig', ['stationDBAll' => $stationDBAll]);
  258.     }
  259.     
  260.     
  261.     #[Route(path: '/meteo/station/{stationId}', name: 'meteo_station_data')]
  262.     public function getStationData(string $stationId): JsonResponse {
  263.         try {
  264.             // Récupérer les données pour la station spécifiée et la période
  265.             $data = $this->meteoService->getStationData($stationId);
  266.             return new JsonResponse($data); // Retourner les données au format JSON
  267.         } catch (\Exception $e) {
  268.             return new JsonResponse(['error' => $e->getMessage()]);
  269.         }
  270.     }
  272.     #[Route(path: '/meteo/commande/{commandeId}', name: 'meteo_commande')]
  273.     public function getFichier(string $commandeId): Response {
  275.         // Récupérer les données pour la station spécifiée et la période
  276.         $data = $this->meteoService->getFichier($commandeId);
  277.         return new Response(
  278.                 $data,
  279.                 Response::HTTP_OK,
  280.                 ['Content-Type' => 'text/plain']
  281.         );
  282.     }
  283.     
  284.     
  285.     #[Route(path: '/meteo/stations/{departmentId}/precipitation', name: 'meteo_stations', methods: ['GET'])]
  286.     public function getStations(string $departmentId) {
  287.         // Récupérer les données pour le département spécifié
  288.         $data = $this->meteoService->getStationsByDepartment($departmentId);
  289.         dump($data);
  290.         // Retourner les données sous forme de réponse JSON
  291.         return new JsonResponse($data);
  292.     }
  294.     #[Route(path: '/meteo/commande/tous', name: 'commande_tous')]
  295.     public function getCommandeData(): JsonResponse {
  296.         // Liste des départements (exemple de 5 départements, tu peux en ajouter plus)
  297.         $departements = ['01', '02']; // Remplace par la liste complète des départements
  299.         $stationsData = [];
  301.         // Boucle pour récupérer les données pour chaque département
  302.         foreach ($departements as $departement) {
  303.             //           try {
  304.             dump($departement);
  305.             $stationsData[$departement] = $this->meteoService->getStationsByDepartment($departement);
  306.             //           } catch (\Exception $e) {
  307.             //               $stationsData[$departement] = ['error' => $e->getMessage()];
  308.             //           }
  309.         }
  311.         dump($stationsData);
  313.         // Pour chaque station, on réalise une commande
  314.         //$commandeArray = $this->meteoService->getStationData($stationId);
  315.         // Pour chaque commande, on obtient un fichier
  316.         //$fichier = $this->meteoService->getFichier($commandeId);
  318.         return $this->render('meteoFrance.html.twig');
  319.     }
  320.     
  321. //    #[Route(path: '/meteo/testToken', name: 'testToken')]
  322. //    public function gettestToken(string $tokenUrl): Response {
  323. //
  324. //        // Récupérer les données pour la station spécifiée et la période
  325. //        $tokenUrl = $this->meteoService->getrefreshToken();
  326. //        return new Response(
  327. //                $tokenUrl,
  328. //                Response::HTTP_OK,
  329. //                ['Content-Type' => 'text/plain']
  330. //        );
  331. //    }
  332.     
  333. #[Route(path: '/meteo/listeDesStations', name: 'listeDesStations')]
  334. public function listeDesStations(EntityManagerInterface $em, \App\Repository\PluvioDatabaseRepository $pluvioRepo, Request $req): Response 
  335. {
  336.     // Récupération de toutes les données de pluviométrie
  337.     //$pluviometrieAll = $em->getRepository(\App\Entity\Pluviometrie::class)->findAll();
  338.     
  339. $query = $em->createQueryBuilder()
  340.     ->select('s.id')  // On récupère uniquement l'ID de la station météo
  341.     ->from(\App\Entity\Pluviometrie::class, 'p')
  342.     ->join('p.idStation', 's')  // Jointure avec StationsMeteo
  343.     ->getQuery();
  345. $idStations = $query->getResult();
  346.     dump($idStations); //die();
  347.     
  348.     // Extraction des ID des stations météorologiques
  349.     $idStation = [];
  350.     foreach ($idStations as $idStation) {
  351.         
  352.             $idStationArray[] = $idStation['id'];
  353.         
  354.     }
  355. dump($idStationArray);
  356.     // Supprimer les doublons d'ID
  357.     $listeUniqueIdStation = array_unique($idStationArray);
  358. dump($listeUniqueIdStation); 
  359.     // Récupérer toutes les stations correspondantes
  360.     $stationDBAll = $em->getRepository(\App\Entity\StationsMeteo::class)
  361.                        ->findBy(['id' => $listeUniqueIdStation], ['departement' => 'ASC']);
  362. dump($stationDBAll); //die();
  363.     return $this->render('meteoFrance.html.twig', ['stationDBAll' => $stationDBAll]);
  364. }
  366.     #[Route(path: '/chart', name: 'chart')]
  367.     public function index(Request $request): Response
  368.     {    
  369.         // Créer une instance du DTO pour passer au formulaire
  370.         $stationMeteoDTO = new StationMeteoDTO();
  371.         
  372.         // Créer le formulaire avec l'objet DTO
  373.         $form = $this->createForm(StationMeteoType::class, $stationMeteoDTO);
  375.         // Gérer la soumission du formulaire
  376.         $form->handleRequest($request);
  378.         if ($form->isSubmitted() && $form->isValid()) {
  379.             // Récupérer les données du formulaire
  380.             $data = $form->getData();
  381.             dump($data);
  382.             // Tu as directement accès à l'objet StationMeteoDTO ici
  383.             $apikey = $data->getApikey();  // Accès via la méthode getter
  384.             $stationAPI = $data->getStationAPI();  // Accès via la méthode getter
  387.             // Appeler le service pour obtenir les données météo
  388.           //  try {
  391.                // $result = $this->météoService->getStationDataHoraire($data['stationId'], $AnneeEtudiee, $data['apiKey']);
  399.         $stationsData = [];
  400.         $commandeArray = []; // Initialisation pour éviter l'erreur Undefined variable
  401.         $columnDataArray = []; // Initialisation pour stocker les données des colonnes  
  403.                     $AnneesEtudiees = [];
  404.                     foreach (range(2018, 2024) as $annee) {
  405.                         $AnneesEtudiees[$annee] = [
  406.                             'dateDeb' => "{$annee}-01-01T00%3A00%3A00Z",
  407.                             'dateFin' => "{$annee}-12-31T00%3A00%3A00Z",
  408.                         ];
  409.                     }
  411.                     foreach ($AnneesEtudiees as $annee => $AnneeEtudiee) {
  412.                             $commande = $this->meteoService->getStationDataHoraire($stationAPI, $AnneeEtudiee, $apikey);
  413.                             $commandeArray[$stationAPI][$annee] = $commande;
  414.                             // Pause pour respecter la limite de 50 requêtes par minute
  415.                             usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes
  416.                         }
  417.         dump($commandeArray);
  418.         $erreur500 = null;
  419.         $extractedData = [];
  421.         // Récupération des fichiers à partir des commandes
  422.         foreach ($commandeArray as $stationAPI => $anneesData) {
  423.             dump($anneesData);
  424.             $erreur = null;
  427.             foreach ($anneesData as $AnneeEtudiee => $commandeAnnee) {
  428.                 $commandeId = $commandeAnnee['elaboreProduitAvecDemandeResponse']['return'];
  429. //                dump($commandeId);
  431.                 $csvString = $this->meteoService->getFichier($commandeId, $apikey);
  432.                // dump($csvString);
  433.                 // Pause pour respecter la limite de 50 requêtes par minute
  434.                 usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes  
  436.                 if ($csvString == 'Erreur 500'){
  437.                     $erreur500[$commandeId] = $stationId;                    
  438.                     $erreur = 1;
  439.                 } else {
  440.                                    // Diviser la chaîne en lignes
  441.                     $lines = explode("\n", $csvString);
  443.                     // Tableau pour stocker les données extraites
  444.                     $data = [];
  447.                     foreach ($lines as $index => $line) {
  448.                         // Ignorer la première ligne (en-tête)
  449.                         if ($index === 0) {
  450.                             continue;
  451.                         }
  453.                         // Diviser chaque ligne en colonnes par le séparateur ;
  454.                         $columns = explode(";", $line);
  456.                         // Vérifier qu'il y a suffisamment de colonnes
  457.                         if (count($columns) > 2) {
  458.                             // Extraire ce qui se situe entre le 3ème et 4ème point-virgule
  459.                             $data['date'] = str_replace(",", ".", $columns[1]);
  460.                             $data['temperature'] = str_replace(",", ".", $columns[10]);
  461.                             $data['vitesse'] = str_replace(",", ".", $columns[48]);
  462.                             $data['direction'] = str_replace(",", ".", $columns[50]);
  465.                             $extractedData[] = $data;
  466.                             $extractedDataParAn[$AnneeEtudiee][] = $data;
  467.                         }
  468.                     }                    
  469.                 }
  470.             }                     
  471.         }
  472. //        dump($extractedDataParAn);
  476.         $directions = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE',
  477.             'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
  479.         $classesVitesse = [
  480.             '<1' => [0, 1],
  481.             '1–5' => [1, 5],
  482.             '5–10' => [5, 10],
  483.             '10–15' => [10, 15],
  484.             '>15' => [15, INF],
  485.         ];
  487.         $roseDesVents = [];
  488.         foreach ($directions as $dir) {
  489.             foreach ($classesVitesse as $classe => $_) {
  490.                 $roseDesVents[$dir][$classe] = 0;
  491.             }
  492.             $roseDesVents[$dir]['Total'] = 0;
  493.         }
  495.         function getWindDirection16($deg) {
  496.             $dirs = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE',
  497.                 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
  498.             $index = (int) round($deg / 22.5) % 16;
  499.             return $dirs[$index];
  500.         }
  502.         function getVitesseClasse($vitesse, $classesVitesse) {
  503.             foreach ($classesVitesse as $label => [$min, $max]) {
  504.                 if ($vitesse >= $min && $vitesse < $max) {
  505.                     return $label;
  506.                 }
  507.             }
  508.             return '>10'; // fallback
  509.         }
  511.         $totalObservations = 0;
  513.         foreach ($extractedData as $data) {
  514.             $direction = floatval($data['direction']);
  515.             $vitesse = floatval($data['vitesse']);
  517.             if ($vitesse < 0 || $direction < 0 || $direction > 360)
  518.                 continue;
  520.             $dirName = getWindDirection16($direction);
  521.             $classeVitesse = getVitesseClasse($vitesse, $classesVitesse);
  523.             $roseDesVents[$dirName][$classeVitesse]++;
  524.             $roseDesVents[$dirName]['Total']++;
  525.             $totalObservations++;
  526.         }
  528.         // Convertir en % de fréquence
  529.         foreach ($roseDesVents as $dir => $classes) {
  530.             foreach ($classesVitesse as $classe => $_) {
  531.                 $count = $roseDesVents[$dir][$classe];
  532.                 $roseDesVents[$dir][$classe] = round(($count / $totalObservations) * 100, 2);
  533.             }
  534.             // Total (par direction, toutes vitesses confondues)
  535.             $countTotal = $roseDesVents[$dir]['Total'];
  536.             $roseDesVents[$dir]['Total'] = round(($countTotal / $totalObservations) * 100, 2);
  537.         }
  539.         $stationKey = $this->getKeyById($stationAPI);
  541.         $summerData = [];
  542.                 $winterData = [];
  544.                 foreach ($extractedData as $data) {
  545.                     // Récupérer l'année, le mois et le jour de la date
  546.                     $date = $data['date'];  // Assurez-vous que la date est au format AAAAMMJJHH
  547.                     $year = substr($date, 0, 4); // AAAA
  548.                     $month = substr($date, 4, 2); // MM
  549.                     $day = substr($date, 6, 2);   // JJ
  550.                     // Vérifier si la date correspond à l'été (juin, juillet, août)
  551.                     if (in_array($month, ['06', '07', '08'])) {
  552.                         $summerData[] = $data;
  553.                     }
  554.                     // Vérifier si la date correspond à l'hiver (décembre, janvier, février)
  555.                     elseif (in_array($month, ['12', '01', '02'])) {
  556.                         $winterData[] = $data;
  557.                     }
  558.                 }
  560. // Traiter les données d'été et d'hiver de la même manière que pour les données globales
  561.                 $summerRoseDesVents = $this->processWindData($summerData, $classesVitesse);
  562.                 $winterRoseDesVents = $this->processWindData($winterData, $classesVitesse);
  564. //                dump($summerRoseDesVents);
  565. //                dump($roseDesVents);
  568. // Passer les données au template
  569.         return $this->render('chart.html.twig', [
  570.                             'roseDesVents' => $roseDesVents,
  571.                             'summerRoseDesVents' => $summerRoseDesVents,
  572.                             'winterRoseDesVents' => $winterRoseDesVents,
  573.                             'directions' => $directions,
  574.                             'stationKey' => $stationKey,
  575.             'form' => $form->createView(),
  576.         ]);
  578. //            } catch (\Exception $e) {
  579. //                // Gérer les erreurs
  580. //                $this->addFlash('error', 'Erreur : ' . $e->getMessage());
  581. //            }
  582.         }
  584.         // Rendre la vue du formulaire
  585.         return $this->render('formulaireWindrose.html.twig', [
  586.             'form' => $form->createView(),
  587.         ]);
  588.         
  589.         
  590.     }
  593.     // Méthode pour obtenir la clé en fonction de l'ID
  594.     public function getKeyById($id)
  595.     {
  596.         // Récupérer le tableau des stations et IDs à partir de StationMeteoType
  597.         $choices = $this->stationMeteoType->getStationAPIChoices();
  599.         // Rechercher la clé correspondant à l'ID
  600.         $key = array_search($id, $choices);
  602.         // Si l'ID est trouvé, retourne la clé, sinon retourne null
  603.         return $key !== false ? $key : null;
  604.     }
  605.     
  606.     
  607.     private function processWindData(array $data, array $classesVitesse)
  608. {
  609.     $roseDesVents = [];
  610.     foreach ($data as $dataPoint) {
  611.         $direction = floatval($dataPoint['direction']);
  612.         $vitesse = floatval($dataPoint['vitesse']);
  613.     
  614.         if ($vitesse < 0 || $direction < 0 || $direction > 360) {
  615.             continue;
  616. }
  618.         $dirName = getWindDirection16($direction);
  619.         $classeVitesse = getVitesseClasse($vitesse, $classesVitesse);
  621.         if (!isset($roseDesVents[$dirName])) {
  622.             $roseDesVents[$dirName] = [];
  623.         }
  624.         if (!isset($roseDesVents[$dirName][$classeVitesse])) {
  625.             $roseDesVents[$dirName][$classeVitesse] = 0;
  626.         }
  628.         $roseDesVents[$dirName][$classeVitesse]++;
  629.     }
  631.     // Convertir en % de fréquence
  632.     $totalObservations = array_sum(array_map(function ($direction) {
  633.         return array_sum($direction);
  634.     }, $roseDesVents));
  635.     //dump($roseDesVents);
  637. // S'assurer que chaque direction contient toutes les classes avec une valeur par défaut
  638. foreach ($roseDesVents as $dir => &$classes) {
  639.     foreach ($classesVitesse as $classe => $_) {
  640.         if (!isset($classes[$classe])) {
  641.             $classes[$classe] = 0;
  642.         }
  643.     }
  644. }
  645. // Important : libérer la référence
  646. unset($classes);
  648. // Ensuite, tu peux faire le calcul des pourcentages
  649. foreach ($roseDesVents as $dir => $classes) {
  650.     foreach ($classesVitesse as $classe => $_) {
  651.         $count = $roseDesVents[$dir][$classe];
  652.         $roseDesVents[$dir][$classe] = round(($count / $totalObservations) * 100, 2);
  653.     }
  654.     // Pareil pour Total (si tu veux l’inclure dans le tableau final)
  655.     $roseDesVents[$dir]['Total'] = round((array_sum($roseDesVents[$dir]) / 100), 2);
  656. }
  658.     return $roseDesVents;
  659. }
  660.     
  661.     
  662.     
  663. }