src/Controller/MeteoController.php line 369

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.                     }
  106.                     
  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'];
  128.                     
  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.     /**
  367.      * @Route("/chart", name="chart")
  368.      */
  369.     public function index(Request $request): Response
  370.     {    
  371.         // Créer une instance du DTO pour passer au formulaire
  372.         $stationMeteoDTO = new StationMeteoDTO();
  373.         
  374.         // Créer le formulaire avec l'objet DTO
  375.         $form = $this->createForm(StationMeteoType::class, $stationMeteoDTO);
  377.         // Gérer la soumission du formulaire
  378.         $form->handleRequest($request);
  380.         if ($form->isSubmitted() && $form->isValid()) {
  381.             // Récupérer les données du formulaire
  382.             $data = $form->getData();
  383.             dump($data);
  384.             // Tu as directement accès à l'objet StationMeteoDTO ici
  385.             $apikey = $data->getApikey();  // Accès via la méthode getter
  386.             $stationAPI = $data->getStationAPI();  // Accès via la méthode getter
  387.            
  389.             // Appeler le service pour obtenir les données météo
  390.           //  try {
  391.                 
  392.                 
  393.                // $result = $this->météoService->getStationDataHoraire($data['stationId'], $AnneeEtudiee, $data['apiKey']);
  394.                
  395.     
  396.         
  397.         
  398.         
  399.         
  400.         
  401.         $stationsData = [];
  402.         $commandeArray = []; // Initialisation pour éviter l'erreur Undefined variable
  403.         $columnDataArray = []; // Initialisation pour stocker les données des colonnes  
  405.                     $AnneesEtudiees = [];
  406.                     foreach (range(2018, 2024) as $annee) {
  407.                         $AnneesEtudiees[$annee] = [
  408.                             'dateDeb' => "{$annee}-01-01T00%3A00%3A00Z",
  409.                             'dateFin' => "{$annee}-12-31T00%3A00%3A00Z",
  410.                         ];
  411.                     }
  412.                     
  413.                     foreach ($AnneesEtudiees as $annee => $AnneeEtudiee) {
  414.                             $commande = $this->meteoService->getStationDataHoraire($stationAPI, $AnneeEtudiee, $apikey);
  415.                             $commandeArray[$stationAPI][$annee] = $commande;
  416.                             // Pause pour respecter la limite de 50 requêtes par minute
  417.                             usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes
  418.                         }
  419.         dump($commandeArray);
  420.         $erreur500 = null;
  421.         $extractedData = [];
  423.         // Récupération des fichiers à partir des commandes
  424.         foreach ($commandeArray as $stationAPI => $anneesData) {
  425.             dump($anneesData);
  426.             $erreur = null;
  427.             
  429.             foreach ($anneesData as $AnneeEtudiee => $commandeAnnee) {
  430.                 $commandeId = $commandeAnnee['elaboreProduitAvecDemandeResponse']['return'];
  431. //                dump($commandeId);
  433.                 $csvString = $this->meteoService->getFichier($commandeId, $apikey);
  434.                // dump($csvString);
  435.                 // Pause pour respecter la limite de 50 requêtes par minute
  436.                 usleep(1300000); // 1,2 secondes = 1 200 000 microsecondes  
  437.                 
  438.                 if ($csvString == 'Erreur 500'){
  439.                     $erreur500[$commandeId] = $stationId;                    
  440.                     $erreur = 1;
  441.                 } else {
  442.                                    // Diviser la chaîne en lignes
  443.                     $lines = explode("\n", $csvString);
  445.                     // Tableau pour stocker les données extraites
  446.                     $data = [];
  447.                     
  449.                     foreach ($lines as $index => $line) {
  450.                         // Ignorer la première ligne (en-tête)
  451.                         if ($index === 0) {
  452.                             continue;
  453.                         }
  455.                         // Diviser chaque ligne en colonnes par le séparateur ;
  456.                         $columns = explode(";", $line);
  458.                         // Vérifier qu'il y a suffisamment de colonnes
  459.                         if (count($columns) > 2) {
  460.                             // Extraire ce qui se situe entre le 3ème et 4ème point-virgule
  461.                             $data['date'] = str_replace(",", ".", $columns[1]);
  462.                             $data['temperature'] = str_replace(",", ".", $columns[10]);
  463.                             $data['vitesse'] = str_replace(",", ".", $columns[48]);
  464.                             $data['direction'] = str_replace(",", ".", $columns[50]);
  465.                             
  467.                             $extractedData[] = $data;
  468.                             $extractedDataParAn[$AnneeEtudiee][] = $data;
  469.                         }
  470.                     }                    
  471.                 }
  472.             }                     
  473.         }
  474. //        dump($extractedDataParAn);
  475.         
  476.         
  478.         $directions = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE',
  479.             'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
  481.         $classesVitesse = [
  482.             '<1' => [0, 1],
  483.             '1–5' => [1, 5],
  484.             '5–10' => [5, 10],
  485.             '10–15' => [10, 15],
  486.             '>15' => [15, INF],
  487.         ];
  489.         $roseDesVents = [];
  490.         foreach ($directions as $dir) {
  491.             foreach ($classesVitesse as $classe => $_) {
  492.                 $roseDesVents[$dir][$classe] = 0;
  493.             }
  494.             $roseDesVents[$dir]['Total'] = 0;
  495.         }
  497.         function getWindDirection16($deg) {
  498.             $dirs = ['N', 'NNE', 'NE', 'ENE', 'E', 'ESE', 'SE', 'SSE',
  499.                 'S', 'SSW', 'SW', 'WSW', 'W', 'WNW', 'NW', 'NNW'];
  500.             $index = (int) round($deg / 22.5) % 16;
  501.             return $dirs[$index];
  502.         }
  504.         function getVitesseClasse($vitesse, $classesVitesse) {
  505.             foreach ($classesVitesse as $label => [$min, $max]) {
  506.                 if ($vitesse >= $min && $vitesse < $max) {
  507.                     return $label;
  508.                 }
  509.             }
  510.             return '>10'; // fallback
  511.         }
  513.         $totalObservations = 0;
  515.         foreach ($extractedData as $data) {
  516.             $direction = floatval($data['direction']);
  517.             $vitesse = floatval($data['vitesse']);
  519.             if ($vitesse < 0 || $direction < 0 || $direction > 360)
  520.                 continue;
  522.             $dirName = getWindDirection16($direction);
  523.             $classeVitesse = getVitesseClasse($vitesse, $classesVitesse);
  525.             $roseDesVents[$dirName][$classeVitesse]++;
  526.             $roseDesVents[$dirName]['Total']++;
  527.             $totalObservations++;
  528.         }
  530.         // Convertir en % de fréquence
  531.         foreach ($roseDesVents as $dir => $classes) {
  532.             foreach ($classesVitesse as $classe => $_) {
  533.                 $count = $roseDesVents[$dir][$classe];
  534.                 $roseDesVents[$dir][$classe] = round(($count / $totalObservations) * 100, 2);
  535.             }
  536.             // Total (par direction, toutes vitesses confondues)
  537.             $countTotal = $roseDesVents[$dir]['Total'];
  538.             $roseDesVents[$dir]['Total'] = round(($countTotal / $totalObservations) * 100, 2);
  539.         }
  540.         
  541.         $stationKey = $this->getKeyById($stationAPI);
  542.         
  543.         $summerData = [];
  544.                 $winterData = [];
  546.                 foreach ($extractedData as $data) {
  547.                     // Récupérer l'année, le mois et le jour de la date
  548.                     $date = $data['date'];  // Assurez-vous que la date est au format AAAAMMJJHH
  549.                     $year = substr($date, 0, 4); // AAAA
  550.                     $month = substr($date, 4, 2); // MM
  551.                     $day = substr($date, 6, 2);   // JJ
  552.                     // Vérifier si la date correspond à l'été (juin, juillet, août)
  553.                     if (in_array($month, ['06', '07', '08'])) {
  554.                         $summerData[] = $data;
  555.                     }
  556.                     // Vérifier si la date correspond à l'hiver (décembre, janvier, février)
  557.                     elseif (in_array($month, ['12', '01', '02'])) {
  558.                         $winterData[] = $data;
  559.                     }
  560.                 }
  562. // Traiter les données d'été et d'hiver de la même manière que pour les données globales
  563.                 $summerRoseDesVents = $this->processWindData($summerData, $classesVitesse);
  564.                 $winterRoseDesVents = $this->processWindData($winterData, $classesVitesse);
  565.                 
  566. //                dump($summerRoseDesVents);
  567. //                dump($roseDesVents);
  568.                 
  570. // Passer les données au template
  571.         return $this->render('chart.html.twig', [
  572.                             'roseDesVents' => $roseDesVents,
  573.                             'summerRoseDesVents' => $summerRoseDesVents,
  574.                             'winterRoseDesVents' => $winterRoseDesVents,
  575.                             'directions' => $directions,
  576.                             'stationKey' => $stationKey,
  577.             'form' => $form->createView(),
  578.         ]);
  579.         
  580. //            } catch (\Exception $e) {
  581. //                // Gérer les erreurs
  582. //                $this->addFlash('error', 'Erreur : ' . $e->getMessage());
  583. //            }
  584.         }
  586.         // Rendre la vue du formulaire
  587.         return $this->render('formulaireWindrose.html.twig', [
  588.             'form' => $form->createView(),
  589.         ]);
  590.         
  591.         
  592.     }
  595.     // Méthode pour obtenir la clé en fonction de l'ID
  596.     public function getKeyById($id)
  597.     {
  598.         // Récupérer le tableau des stations et IDs à partir de StationMeteoType
  599.         $choices = $this->stationMeteoType->getStationAPIChoices();
  601.         // Rechercher la clé correspondant à l'ID
  602.         $key = array_search($id, $choices);
  604.         // Si l'ID est trouvé, retourne la clé, sinon retourne null
  605.         return $key !== false ? $key : null;
  606.     }
  607.     
  608.     
  609.     private function processWindData(array $data, array $classesVitesse)
  610. {
  611.     $roseDesVents = [];
  612.     foreach ($data as $dataPoint) {
  613.         $direction = floatval($dataPoint['direction']);
  614.         $vitesse = floatval($dataPoint['vitesse']);
  615.     
  616.         if ($vitesse < 0 || $direction < 0 || $direction > 360) {
  617.             continue;
  618. }
  620.         $dirName = getWindDirection16($direction);
  621.         $classeVitesse = getVitesseClasse($vitesse, $classesVitesse);
  623.         if (!isset($roseDesVents[$dirName])) {
  624.             $roseDesVents[$dirName] = [];
  625.         }
  626.         if (!isset($roseDesVents[$dirName][$classeVitesse])) {
  627.             $roseDesVents[$dirName][$classeVitesse] = 0;
  628.         }
  630.         $roseDesVents[$dirName][$classeVitesse]++;
  631.     }
  633.     // Convertir en % de fréquence
  634.     $totalObservations = array_sum(array_map(function ($direction) {
  635.         return array_sum($direction);
  636.     }, $roseDesVents));
  637.     //dump($roseDesVents);
  639. // S'assurer que chaque direction contient toutes les classes avec une valeur par défaut
  640. foreach ($roseDesVents as $dir => &$classes) {
  641.     foreach ($classesVitesse as $classe => $_) {
  642.         if (!isset($classes[$classe])) {
  643.             $classes[$classe] = 0;
  644.         }
  645.     }
  646. }
  647. // Important : libérer la référence
  648. unset($classes);
  650. // Ensuite, tu peux faire le calcul des pourcentages
  651. foreach ($roseDesVents as $dir => $classes) {
  652.     foreach ($classesVitesse as $classe => $_) {
  653.         $count = $roseDesVents[$dir][$classe];
  654.         $roseDesVents[$dir][$classe] = round(($count / $totalObservations) * 100, 2);
  655.     }
  656.     // Pareil pour Total (si tu veux l’inclure dans le tableau final)
  657.     $roseDesVents[$dir]['Total'] = round((array_sum($roseDesVents[$dir]) / 100), 2);
  658. }
  660.     return $roseDesVents;
  661. }
  662.     
  663.     
  664.     
  665. }