Skip to content

Description de l'implémentation du simulateur "View hive generator"

L'application "View hive simulator" est un simulateur visuel illustrant les allées et venues des abeilles dans une ruche. Elle permet aux utilisateurs d'observer les abeilles quittant la ruche et de consulter les données sur le nombre d'abeilles entrées et sorties. Les utilisateurs peuvent ajuster plusieurs paramètres pour personnaliser l'expérience de simulation, tels que la taille des abeilles, leur vitesse et la fréquence d'apparition des abeilles.

But

cette application est conçue pour tester une reconnaissance d'abeilles d'un algorithme de détection d'objets en temps réel (YOLOv8). Elle simule différents scénarios d'apparition et de mouvement des abeilles, permettant ainsi de vérifier et d'améliorer les algorithmes de détection d'objets en temps réel.

Interface utilisateur

Voici l'application "view hive generator" :

View hive simulator
Figure 88 — View hive simulator

Éléments de la fenêtre principale

La fenêtre principale de l'application est structurée en plusieurs sections :

  1. Vue de Dessus de la Ruche

    Affiche les abeilles entrant et sortant de la ruche.

  2. Panneau de Contrôle

    Permets aux utilisateurs de régler différents paramètres de la simulation.

  3. Panneau de Commande

    Permets aux utilisateurs de démarrer, arrêter et reprendre une simulation.

  4. Enregistrement

    Permets aux utilisateurs d'enregistrer une simulation au format MP4.

Contrôles et paramètres

  1. Nombre d'abeilles à l'intérieur

    Description: Détermine le nombre d'abeilles visibles dans la section "Intérieur de la ruche".

    Type: Numérique (entier)

  2. Nombre d'abeilles à l'extérieur

    Description: Détermine le nombre d'abeilles visibles dans la section "Extérieur de la ruche".

    Type: Numérique (entier)

  3. Durée

    Description: Affiche le temps écoulé depuis le début de la simulation.

    Type: Horloge (HH:MM:SS)

  4. Taille des abeilles

    Description: Ajuste la taille des abeilles affichées.

    Type: Slider (échelle de 1 à 10)

  5. Vitesse des abeilles

    Description: Ajuste la vitesse à laquelle les abeilles se déplacent.

    Type: Slider (échelle de 1 à 10)

  6. Chance d'apparition d'abeille

    Description: Détermine la probabilité d'apparition des abeilles toutes les secondes.

    Type: Slider (échelle de 0% à 100%)

  7. Changer l'image de fond

    Description: Permets de changer l'image de fond de la simulation.

    Type: Bouton

  8. Boutons de contrôle de la simulation

    • Démarrer (Play)

      • Description : Lance la simulation.
      • Type: Bouton

    • Arrêter (Stop)

      • Description : Arrête la simulation.
      • Type : Bouton
    • Relancer (Restart)
      • Description: Relance une simulation.
      • Type: Bouton

  9. Enregistrement

    • Démarrer
      • Description: Permets de lancer un enregistrement de la simulation
      • Type: Bouton
    • Arrêter
      • Description: Permets de stopper l'enregistrement de la simulation.
      • Type: Bouton

Fonctionnalités et code

Déplacement des abeilles

Cette méthode permet de déplacer chaque abeille dans la simulation. Chaque abeille se déplace verticalement dans une direction déterminée par sa position initiale (à l'intérieur ou à l'extérieur de la ruche). Le mouvement vertical est aléatoire, mais restreint dans une certaine plage.

/// <summary>
/// Déplace les abeilles dans une certaine plage
/// </summary>
public void MoveBee()
{
    foreach (Bee bee in bees)
    {
        if (bee.IsInside)
        {
            // Si l'abeille est à l'intérieur, elle se déplace vers le haut
            bee.ChangeCoordonner(0, -rdm.Next(MIN_RANGE_PIXEL_MOVE_BEE, MAX_RANGE_PIXEL_MOVE_BEE));
        }
        else
        {
            // Si l'abeille est à l'extérieur, elle se déplace vers le bas
            bee.ChangeCoordonner(0, rdm.Next(MIN_RANGE_PIXEL_MOVE_BEE, MAX_RANGE_PIXEL_MOVE_BEE));
        }
    }
}

Explication du fonctionnement

  1. Boucle sur toutes les abeilles :

  2. La méthode utilise une boucle foreach pour parcourir toutes les abeilles dans la liste bees.

  3. Déplacement vertical des abeilles :

  4. Si l'abeille est à l'intérieur de la ruche (bee.IsInside est true), elle se déplace vers le haut. La position Y de l'abeille est réduite d'une valeur aléatoire comprise entre MIN_RANGE_PIXEL_MOVE_BEE et MAX_RANGE_PIXEL_MOVE_BEE.

  5. Si l'abeille est à l'extérieur de la ruche (bee.IsInside est false), elle se déplace vers le bas. La position Y de l'abeille est augmentée d'une valeur aléatoire comprise entre MIN_RANGE_PIXEL_MOVE_BEE et MAX_RANGE_PIXEL_MOVE_BEE.

  6. Mouvement aléatoire :

  7. Le déplacement vertical de chaque abeille est déterminé par un nombre aléatoire généré par rdm.Next(MIN_RANGE_PIXEL_MOVE_BEE, MAX_RANGE_PIXEL_MOVE_BEE). Cela ajoute un comportement naturel et imprévisible au mouvement des abeilles.

Détection des abeilles

Cette méthode permet de détecter si les abeilles ont traversé des lignes de détection, indiquant leur entrée ou leur sortie de la ruche. Lorsqu'une abeille traverse la ligne supérieure ou inférieure, le compteur correspondant est incrémenté.

/// <summary>
/// Compte les abeilles à l'extérieur et à l'intérieur grâce à une détection
/// </summary>
/// <param name="beeList">Liste des abeilles à détecter</param>
public void DetectionBee(List<Bee> beeList)
{
    for (int i = 0; i < beeList.Count; i++)
    {
        int cordsBee = beeList[i].Coordonne.Y + (beeList[i].Img.Height / 2);

        // L'abeille touche la barre supérieure
        if (cordsBee >= lineTopDetectedBee && cordsBee <= lineTopDetectedBee + LINE_DETECTION_MARGIN)
        {
            beeList[i].TouchLineTop = true;

            // L'abeille touche la barre inférieure et la valeur n'a pas encore été ajoutée
            if (beeList[i].TouchLineBottom && beeList[i].AddNumber == false)
            {
                // L'abeille entre dans la ruche
                NumberBeeInside++;
                beeList[i].AddNumber = true;
                if (Record)
                {
                    NumberBeeInsideDuringRecord++;
                }
            }
        }
        // L'abeille touche la barre inférieure 
        if (cordsBee >= lineBottomDetectedBee && cordsBee <= lineBottomDetectedBee + LINE_DETECTION_MARGIN)
        {
            beeList[i].TouchLineBottom = true;

            // L'abeille touche la barre supérieure et la valeur n'a pas encore été ajoutée
            if (beeList[i].TouchLineTop && beeList[i].AddNumber == false)
            {
                // L'abeille sort de la ruche
                NumberBeeOutside++;
                beeList[i].AddNumber = true;
                if (Record)
                {
                    NumberBeeOutsideDuringRecord++;
                }
            }
        }
    }
}

Explication du fonctionnement

  1. Boucle sur toutes les abeilles :

  2. La méthode utilise une boucle for pour parcourir toutes les abeilles dans la liste beeList.

  3. Calcul des coordonnées de détection :

  4. cordsBee représente la position verticale actuelle de l'abeille en ajoutant la moitié de la hauteur de l'image de l'abeille à sa position Y.

  5. Détection de la ligne supérieure :

  6. Si les coordonnées de l'abeille se trouvent dans la plage de détection de la ligne supérieure (lineTopDetectedBee à lineTopDetectedBee + LINE_DETECTION_MARGIN), le drapeau TouchLineTop de l'abeille est activé.

  7. Si l'abeille a déjà touché la ligne inférieure (TouchLineBottom est true) et qu'elle n'a pas encore été comptabilisée (AddNumber est false), cela signifie que l'abeille est entrée dans la ruche. Le compteur NumberBeeInside est incrémenté, et si l'enregistrement est activé (Record est true), NumberBeeInsideDuringRecord est également incrémenté.

  8. Détection de la ligne inférieure :

  9. Si les coordonnées de l'abeille se trouvent dans la plage de détection de la ligne inférieure (lineBottomDetectedBee à lineBottomDetectedBee + LINE_DETECTION_MARGIN), le drapeau TouchLineBottom de l'abeille est activé.
  10. Si l'abeille a déjà touché la ligne supérieure (TouchLineTop est true) et qu'elle n'a pas encore été comptabilisée (AddNumber est false), cela signifie que l'abeille est sortie de la ruche. Le compteur NumberBeeOutside est incrémenté, et si l'enregistrement est activé (Record est true), NumberBeeOutsideDuringRecord est également incrémenté.

Ces fonctionnalités permettent de simuler et de suivre le mouvement des abeilles entrant et sortant d'une ruche de manière réaliste et précise.

Enregistrement de la simulation

Le bouton "Enregistrement" permet de capturer la simulation image par image jusqu'à ce que le bouton "Stop" soit pressé, ce qui arrête l'enregistrement et sauvegarde le fichier au format MP4. Il permet aussi d'enregistrer dans un fichier texte le nombre d'abeilles entrées et sorties durant le laps de temps. Pour par la suite comparer les données avec le module de surveillance externe.

```csharp ///

/// Bouton pour lancer l'enregistrement /// /// /// private void btnStartRecord_Click(object sender, EventArgs e) { if (!_isRecording) { // Arrondir les dimensions au multiple de deux le plus proche int width = ptbHiveWatch.Width - (ptbHiveWatch.Width % 2); int height = ptbHiveWatch.Height - (ptbHiveWatch.Height % 2);

         simulator.Record = true;
         // Initialiser le VideoFileWriter
         _videoWriter = new VideoFileWriter();
         _videoWriter.Open(linkRecordDownload, width, height, 25, VideoCodec.MPEG4);

         _isRecording = true;
         tmrRecording.Start();
     }
 }

 /// <summary>
 /// Bouton pour arrrêter l'enregistrement
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void btnStopRecord_Click(object sender, EventArgs e)
 {
     if (_isRecording)
     {
         // Arrêter l'enregistrement
         tmrRecording.Stop();
         _videoWriter.Close();
         _videoWriter.Dispose();
         _isRecording = false;
     }
     if (File.Exists(linkDataDownload))
     {
         File.Delete(linkDataDownload);
     }

     File.Create(linkDataDownload).Close();
     using (StreamWriter sw = File.AppendText(linkDataDownload))
     {
         sw.WriteLine("Nombre d'abeille sortie : " + simulator.NumberBeeOutsideDuringRecord);
         sw.WriteLine("Nombre d'abeille entree : " + simulator.NumberBeeInsideDuringRecord);
     }
     simulator.Record = true;

 }
 /// <summary>
 /// Timer qui addition des captures d'écran pour crée le flux vidéo
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 private void tmrRecording_Tick(object sender, EventArgs e)
 {
     if (_isRecording)
     {
         // Capture l'image actuelle du PictureBox
         _currentFrame = new Bitmap(ptbHiveWatch.Width, ptbHiveWatch.Height);
         ptbHiveWatch.DrawToBitmap(_currentFrame, new Rectangle(0, 0, ptbHiveWatch.Width, ptbHiveWatch.Height));

         // Ajouter l'image à la vidéo
         _videoWriter.WriteVideoFrame(_currentFrame);

         // Libérer la mémoire
         _currentFrame.Dispose();
     }
 }

```