Agrégation informatique externe 2020, épreuve 3, option ingénierie informatiqueSujet et rapport du jury

AGRÉGATION
CONCOURS EXTERNE

Option : SCIENCES INDUSTRIELLES DE L'INGÉNIEUR ET INGÉNIERIE INFORMATIQUE

CONCEPTION PRÉLIMINAIRE D'UN SYSTÈME, D'UN PROCÉDÉ OU D'UNE ORGANISATION

• -d'un dossier sujet de la page 1 à la page 21 ;
• -d'un dossier technique (DT) de la page 22 à la page 42 ;
• -d'un dossier réponse (DR) de la page 43 à la page 48.

INFORMATION AUX CANDIDATS

Ces codes doivent être reportés sur chacune des copies que vous remettrez.

FRIPON, réseau de surveillance du ciel français pour pister les météorites

Présentation

Le principe

Figure 1. Carte européenne partielle des sites du réseau FRIPON

Figure 2. Exemple d'image prise par une caméra avec objectif fisheye

Figure 3. Photo d'une caméra implantée à l'Observatoire de Paris

Architecture de l'ensemble du système

Figure 4. Vue d'ensemble du système FRIPON

• -une caméra est connectée à un switch (commutateur réseau) ;
• -I'unité informatique locale (PC embarqué compact de type Intel NUC) héberge le logiciel Freeture ;
• -ce logiciel récupère les images de la caméra, puis les traite ;
• -lors de la détection d'un événement, les données sont sauvegardées localement et un mail est envoyé aux serveurs du réseau pour validation ;
• -si plusieurs stations géographiquement proches détectent des événements au cours de la même période, un opérateur peut démarrer une procédure logicielle pour récupérer l'ensemble des images sauvegardées par les stations concernées.

• -la première porte sur le logiciel Freeture qui détecte et alerte le site principal lors de la détection d'un événement ;
• -la deuxième porte sur l'interconnexion de tous les sites locaux au site principal de Marseille ;
• -la dernière porte sur le traitement réalisé sur toutes les images d'un événement afin de calculer la trajectoire d'une météorite et en déduire son point de chute potentiel.

Partie 1. Étude du logiciel Freeture

Sous-partie 1.1. Architecture multi-tâches

• -la caméra est configurée pour transmettre 30 images par seconde ;
• -la détection pour filtrer les faux positifs nécessite en moyenne 20 ms mais peut quelques fois dépasser 1 s ;
• -l'envoi d'un email pour prévenir d'une détection requiert en moyenne 500 ms.

• -« tAcqThread » exécute l'acquisition des images et les stocke dans le buffer ;
• -« tDetThread » exécute la détection des événements sur les images lues depuis le buffer et réalise l'envoi d'emails ;
• -« tStackThread » exécute la sauvegarde sur le disque de toutes images présentes dans le buffer après détection d'un événement en vue d'une analyse détaillée par les chercheurs.

• -la classe « tCamera » gère les accès à la caméra, notamment la récupération des images, cette classe n'est pas « thread-safe » ;
• -la classe « tCircularBuffer » implémente le stockage buffer circulaire des images en attente de traitement, cette classe n'est pas « thread-safe » ;
• -la classe « tCfgParam » stocke tous les paramètres d'exécution de l'application (calibrations et options de fonctionnement) sous forme de fichiers textes ;
• -la classe « tMail » gère l'envoi d'un email, cette classe n'est pas « thread-safe » ;
• -la classe « tThreadGeneric » mutualise les méthodes basiques de création, de démarrage, d'arrêt et de destruction d'un thread.

Sous-partie 1.2. Conception d'une synchronisation

• -le thread d'acquisition récupère les images de la caméra et les stocke dans le buffer ;
• -le thread de détection récupère les images du buffer pour les analyser.

• -un sémaphore VIDE ;
• -un sémaphore PLEIN ;
• -un mutex d'accès au buffer ACCES.

• -P() permet de verrouiller un mutex: si le mutex est déjà verrouillé par un autre thread, l'appelant est suspendu par le noyau jusqu'au déverrouillage de ce mutex. Sinon, le mutex est verrouillé pour l'appelant au retour de la fonction ;
• -P() appliqué sur un sémaphore suspend l'appelant si son compteur interne vaut zéro, sinon le compteur interne est simplement décrémenté de 1. La suspension pour l'appelant prend fin lorsqu'un autre thread incrémente ce sémaphore ;
• -V() appliqué sur un mutex le déverrouille et réveille un autre thread en attente de cet objet. Dans tous les cas, aucune suspension possible pour le thread appelant ;
• -V() appliqué sur un sémaphore incrémente son compteur interne. Dans tous les cas, aucune suspension possible pour le thread appelant.

Sous-partie 1.3. Implémentation de la solution

Sous-partie 1.4 Conclusion

Partie 2. Étude du réseau d'un système d'acquisition

• -la caméra communique par IP avec le PC embarqué pour transférer les images ;
• -le PC embarqué reçoit toutes les images, les traite et sélectionne uniquement les observations ayant un intérêt (observation d'un bolide lumineux, voir partie précédente avec Freeture) en sauvegardant les images correspondantes sur son disque ;
• -le logiciel de traitement prévient le site de Marseille par envoi d'emails ;
• -si un événement a été repéré par plusieurs stations, un opérateur peut télécharger les images précédemment sauvegardées sur le disque local vers les serveurs centraux de Fripon.

• 1.l'administration du système est réalisée intégralement à distance dans le but de changer sa configuration réseau, de mettre à jour les logiciels et les systèmes d'exploitation. Les ingénieurs en charge de la maintenance générale du réseau Fripon se connectent à distance sur le PC embarqué afin d'accéder aux autres composants ;
• 2.étant donné le grand nombre de systèmes d'acquisition connectés à l'infrastructure, les échanges avec le réseau central Fripon sont limités. Les échanges volumineux de données entre la caméra et le PC embarqué ne transitent pas via le réseau central ;
• 3.le système d'acquisition n'utilise le réseau local de l'hébergeur (généralement une université, un institut partenaire) que pour les communications vers le réseau central Fripon. L'accès direct à d'autres adresses/réseaux est interdit ;
• 4.les échanges entre la caméra et le PC embarqué ne transitent pas par le réseau local de l'hébergeur. Autrement dit, le domaine de collision entre la caméra et le PC est différent de celui du réseau d'accueil ;
• 5.le système d'acquisition n'est pas accessible depuis le réseau local de l'hébergeur. Un utilisateur connecté au réseau local de l'hébergeur ne peut communiquer ni avec la caméra ni avec le PC embarqué.

Sous-partie 2.1. Configuration des VLAN et des ports Ethernet

• -le VLAN « vision » véhicule les images issues de la caméra ;
• -le VLAN « hébergeur » relie le système d'aquisition au réseau local de l'hébergeur.

• -8 ports LAN, 1 port WAN (Wide Area Network) et 1 port d'administration interne ;
• -support des VLAN avec affectation possible d'un port dans plusieurs VLAN ;
• -possibilité de taguer l'entête des paquets Ethernet (IEEE 802.1Q).

• -la configuration « tagged » indique que l'identificateur du VLAN est ajouté dans l'entête de chaque paquet transitant via ce port. La configuration « untagged » ne transmet pas l'identificateur du VLAN dans ces paquets (utilisation de l'entête Ethernet classique) ;
• -les configurations des ports reliant deux équipements doivent être cohérentes : un appareil « untagged » ne peut être relié qu'à un port configuré « untagged » du switch (et inversement) ;
• -un port « tagged » peut être affecté à plusieurs VLAN. Un port « untagged » ne peut être affecté qu'à un seul VLAN.

Sous-partie 2.2. Liaison sécurisée VPN côté client

• -un réseau privé virtuel (VPN) permet le transfert bidirectionnel de paquets IP. L'établissement des connexions est également bidirectionnel. Un VPN fait le lien entre différentes stations en encapsulant leurs échanges dans une connexion sécurisée. Un VPN peut re-router automatiquement tout le trafic entre les différents sites ;
• -un proxy sécurisé (Proxy SSL) centralise les connections entre différentes applications clients et serveurs. Il fonctionne uniquement pour certains protocoles (par exemple HTTP) et sa mise en place nécessite des clients compatibles. Seules les connexions entre ce client et le serveur transiteront par le proxy.

Sous-partie 2.3. Logiciel client VPN

• 1.le client VPN sur le PC embarqué ouvre une connexion (tunnel) vers le serveur VPN dont l'adresse IP est 1.2.3.4 (adresse « anonyme » du système Fripon réel) ;
• 2.cette connexion nécessite la négociation de protocoles de chiffrement et de sécurisation gérés au niveau de la couche « application » ;

• 3.le client VPN crée une interface réseau virtuelle « tun0 » dont il relaie tout le trafic pour l'encapsuler dans le tunnel sécurisé ;
• 4.le client DHCP du système d'exploitation s'exécute pour cette interface réseau virtuelle et obtient, par l'intermédiaire du tunnel, l'adresse IP locale 10.8.0.218 et la passerelle 10.8.0.217 ;
• 5.le client VPN ajoute des routes afin d'orienter le trafic par l'interface réseau sécurisée.

Sous-partie 2.4. Vérification des exigences

Partie 3. Détermination de la trajectoire d'un météore

Sous-partie 3.1. Présentation

• -la première phase consiste en l'entrée dans l'atmosphère à haute vitesse, le météore est visible dans le ciel (phase de combustion) dès que son altitude est inférieure à 80 km. Au cours de cette phase relativement courte (quelques secondes), le rayon de courbure dû à l'attraction terrestre est très grand et la vitesse du bolide est très élevée. La trajectoire du météore est approximée par une droite prolongeant la trajectoire d'orbite. Le météore devient lumineux (il est alors nommé fireball) dès que l'atmosphère a suffisamment chauffé sa surface (forces de frottement) et « s'éteint » lorsqu'il a suffisamment décéléré ;
• -la deuxième phase consiste en la trajectoire lors de la phase de « dark flight », le météore a suffisamment décéléré pour être assimilé à un corps en chute libre dans l'atmosphère avec une vitesse initiale. Cette phase peut durer plusieurs minutes et ne permet pas d'observation optique directe car l'objet est alors assimilable à un corps noir de petite taille. L'objet touchant le sol s'appelle une météorite.

Figure 5. Illustration des différentes phases de la chute

Sous-partie 3.2. Méthode de calcul de la trajectoire en phase de « combustion »

Figure 6. Lignes de vue de deux stations (Dax et Hendaye) pour un unique météore.

Figure 7. Autre point de vue montrant les lignes se croisant dans une zone spatiale.

Sous-partie 3.3. Coordonnées des caméras

Figure 8. Définition du repère géographique (source Wikipédia - Creative Commons)

Figure 9. Définition du repère WGS84 (Source NIMA report 8350.2 avec modifications)

Figure 10. Définition du repère sphérique (Source NIMA report 8350.2 avec modifications)

• - ρ = r/a
• - tan(u) = (1 − f) ⋅ tan(φ)
• - ρ ⋅ cos(φ^′) = cos(u) + h/a ⋅ cos(φ)
• - ρ ⋅ sin(φ^′) = (1 − f) ⋅ sin(u) + h/a ⋅ sin(φ)
• - λ^′ = λ

• - ρ : distance au centre de la Terre normalisée par le rayon de la Terre à l'équateur (sans unité) ;
• -r : distance au centre de la Terre (sphérique) en mètre ;
• -u: angle de correction entre les coordonnées géographiques (GPS) et géocentriques (sphériques) ;
• - φ^′ : latitude géocentrique (sphérique) en degré ;
• - λ^′ : longitude géocentrique (sphérique) en degré ;
• - φ : latitude géographique (GPS) en degré ;
• - λ : longitude géographique (GPS) en degré ;
• -h : altitude géographique (GPS) par rapport à l'ellipsoïde de référence (WGS84) en mètre ;
• -a : rayon de la Terre à l'équateur (WGS84) en mètre ;
• -f : aplatissement de l'ellipsoïde terrestre (sans dimension).

Sous-partie 3.4. Détermination du vecteur directeur de la ligne de vue

Figure 11. Schéma montrant le trajet d'un rayon avec un objectif optique fisheye

• -x0, y0 : centre de l'image obtenue ;
• -V, S, D, P et Q: coefficients du polynôme d'ordre 9 limité aux coefficients impairs tel que P(x) = V ⋅ x + S ⋅ x^3 + D ⋅ x^5 + P ⋅ x^7 + Q ⋅ x^9;
• - θ_x, θ_y, θ_z : angles de positionnement du repère de la caméra par rapport au repère géocentrique sphérique lié à la terre selon chaque axe ;
• -ani, phi : coefficients de correction du décalage entre la focale de la lentille et le centre de l'image.

Sous-partie 3.5. Analyse des images

• -numéro de l'enregistrement ;
• -brillance totale (luminosité totale des pixels représentant une météorite) ;
• -abscisse moyenne de la position (en pixel) ;
• -ordonnée moyenne de la position (en pixel) ;
• -heure/date de l'image.

Sous-partie 3.6. Algorithme heuristique d'optimisation de la trajectoire

Présentation de l'algorithme

Implémentation de l'optimisation par essaim particulaire

• -étape 1 : le coût de chaque particule est calculé, il mesure numériquement la qualité de la solution représentée par cette particule. Chaque particule possède sa propre meilleure valeur. Si la mesure actuelle est meilleure que les précédentes de cette particule, alors la particule mémorise cette nouvelle valeur ainsi que sa position (i.e. le vecteur de valeurs correspondantes) ;
• -étape 2 : parmi toutes les particules, la meilleure valeur globale de coût est mémorisée. Si pour toutes les valeurs de coût de l'itération actuelle une meilleure valeur est trouvée, alors celle-ci est mémorisée ainsi que sa position ;
• -étape 3 (schématisée dans la figure 13) : la nouvelle valeur de vitesse v_(id)(k + 1) de chaque dimension d de chaque particule i est calculée selon la relation ci-dessous : v_(id)(k + 1) = w ⋅ v_(id)(k) + c_1 ⋅ rand_1 ⋅ (x_(id)ˆ(k) − x_(id)(k)) + c_2 ⋅ rand_2 ⋅ (g_(id)(k) − x_(id)(k))

• ○ v_(id)(k) est la vitesse de la dimension d de la particule i ;
• ○w est un facteur « d'inertie » pondérant la vitesse actuelle de la particule. Cette valeur constante est en général fixée à 0.8 dans la littérature ;
• ○ C_1 et C_2 sont deux constantes ajustant les contributions de l'écart entre la position actuelle x_(id)(k) et la meilleure position personnelle x_(id)ˆ(k) ainsi que de l'écart entre la position actuelle x_(id)(k) et la meilleure position globale g_(id)(k). Elles sont inférieures à 1 ;
• ○rand _1 et rand _2 sont deux valeurs tirées aléatoirement entre 0 et 1 pour chaque dimension de chaque particule à chaque itération ;
• -étape 4 : la position de chaque dimension de chaque particule est mise à jour selon la vitesse selon la relation suivante : x_(id)(k + 1) = x_(id)(k) + v_(id)(k + 1).

Figure 13. Schématisation de l'évolution itérative de la position d'une particule i (en 2 dimensions)

Application de l'algorithme au cas de Fripon

• -A est un point appartenant la droite D ;
• -A' est un point appartenant à la droite D' ;
• - u→ est le vecteur directeur de la droite D ;
• - v→ est le vecteur directeur de la droite D' ;
• - ‖AA^(→−), u→, v→‖ est la norme cartésienne du produit mixte de relation (AA^(→−) ∧ u→) ⋅ v→;
• - ‖u→ ∧ v→‖ est la norme cartésienne du produit vectoriel entre u→ et v→.

Sous-partie 3.7. Validation du fonctionnement

Document technique DT1. Code de la synchronisation

mutex *detSignal_mutex;
bool *detSignal;
condition_variable *detSignal_condition;
mutex *frameBuffer_mutex;

void AcqThread::run()
{
    tFrame* newFrame;
    while (!stop)
    {
        if (camera.getNextFrame(newFrame))
        {
            unique_lock verrouCB(*frameBuffer_mutex);
            cirBuf->push(newFrame);
            verrouCB.unlock();

        unique_lock verrouSig(*detSignal_mutex);
        *detSignal = true;
        detSignal_condition->notify_one();
        verrouSig.unlock();
    \}
\}

Code partiel du fil d'exécution du thread de détection

void DetThread::run()
{
    bool eventToComplete = false;
    while(!stop)
    {
        unique_lock verrouSig(*detSignal_mutex);
        while (!*detSignal)
        {
            detSignal_condition->wait(verrouSig);
        }
        *detSignal = false;
        verrouSig.unlock();

        unique_lock verrouCB(*frameBuffer_mutex);
        tFrame* frame = cirBuf->back();
        verrouCB.unlock();
        chrono::high_resolution_clock::time_point tref;
        //pDetMthd est un pointeur donnant accès à
        //la fonction de détection.
        //Elle renvoie true si il y a détection d'un météore, false sinon.
        if(pDetMthd->runDetection(lastFrame) && !eventToComplete)
        {
            eventToComplete = true;
            NbDetection++;
            tref = chrono::high_resolution_clock::now();
        }
        if (eventToComplete)
        {
            auto diff = chrono::high_resolution_clock::now() - tref;
            auto diff_ms = chrono::duration_cast<chrono::microseconds>(diff);
            if (diff_ms > param.diff)
            {
                eventToComplete = false;
                // la suite du code est dédiée à la sauvegarde des images de
                // l'événement.
            }
        }
    }
}

Document technique DT2. Classe std::condition_variable

Description générale de la classe std::condition_variable

• 1.acquire a std::mutex
• 2.perform the modification while the lock is held
• 3.execute notify_one on the std::condition_variable (the lock does not need to be held for notification)

• 1.acquire a std::unique_lock, on the same mutex as used to protect the shared variable
• 2.execute wait(). The wait operations atomically release the mutex and suspend the execution of the thread.
• 3.When the condition variable is notified, a timeout expires, or a spurious wakeup occurs, the thread is awakened, and the mutex is atomically reacquired. The thread should then check the condition and resume waiting if the wake up was spurious.

Description de la méthode std::condition_variable::notify_one

Description de la méthode std::condition_variable::wait

void wait( std::unique_lock& lock );

Document technique DT3. Classe std::unique_lock

Description générale de la classe std::condition_variable

Documentation constructeur std::unique_lock::unique_lock

explicit unique_lock( mutex_type& m );

Documentation méthode std::unique_lock::unlock

void unlock();

Document technique DT4. « spurious wakeup »

bool something_happened;
mutex m;
condition_variable c;
void thread1() {
    unique_lock<mutex> lock(m);
    while(!something_happened) {

void thread2() {
    // do lots of work
    unique_lock<mutex> lock(m);
    something_happened = true;
    c.notify_one()
}

        c.wait(m);
    }
}

if (!something_happened)
    c.wait(m);

Document technique DT5. Configuration réseau l'établissement du VPN

eth0 Link encap:Ethernet HWaddr b8:ae:ed:73:b8:c9
inet addr:192.168.1.13 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::baae:edff:fe73:b8c9/64 Scope:Link
eth0.2 Link encap:Ethernet HWaddr b8:ae:ed:73:b8:c9
inet addr:10.254.99.99 Bcast:10.254.99.103 Mask:255.255.255.248
inet6 addr: fe80::baae:edff:fe73:b8c9/64 Scope:Link
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host

Kernel IP routing table
Destination Gateway Genmask Iface
0.0.0.0 192.168.1.1 0.0.0.0 eth0
10.254.99.96 0.0.0.0 255.255.255.248 eth0.2
192.168.1.0 0.0.0.0 255.255.255.0 eth0

Document technique DT6. Configuration réseau l'établissement du VPN

eth0 Link encap:Ethernet HWaddr b8:ae:ed:73:b8:c9
inet addr:192.168.1.13 Bcast:192.168.1.255 Mask:255.255.255.0
inet6 addr: fe80::baae:edff:fe73:b8c9/64 Scope:Link
eth0.2 Link encap:Ethernet HWaddr b8:ae:ed:73:b8:c9
inet addr:10.254.99.99 Bcast:10.254.99.103 Mask:255.255.255.248
inet6 addr: fe80::baae:edff:fe73:b8c9/64 Scope:Link
lo Link encap:Local Loopback
inet addr:127.0.0.1 Mask:255.0.0.0
inet6 addr: ::1/128 Scope:Host
tun0 Link encap:UNSPEC
inet addr:10.8.0.218 P-t-P:10.8.0.217 Mask:255.255.255.255

Kernel IP routing table
Destination Gateway Genmask Iface
0.0.0.0 192.168.1.1 0.0.0.0 eth0
10.8.0.0 10.8.0.217 255.255.0.0 tun0
10.8.0.217 0.0.0.0 255.255.255.255 tun0
10.254.99.96 0.0.0.0 255.255.255.248 eth0.2
192.168.1.0 0.0.0.0 255.255.255.0 eth0
212.211.132.250 10.8.0.217 255.255.255.255 tun0
217.196.149.233 10.8.0.217 255.255.255.255 tun0

Document technique DT7. Code du client VPN

int main(int argc, char **argv)
{
    int do_load_balance;
    const uint8_t hex_test[] = { 0, 1, 2, 3 };
    struct sa_block oursa[1];
    struct sa_block *s = oursa;
    test_pack_unpack();
#if defined(__CYGWIN__)
    gcry_control(GCRYCTL_SET_THREAD_CBS, &gcry_threads_pthread);
#endif
    gcry_check_version("1.1.90");
    gcry_control(GCRYCTL_INIT_SECMEM, 16384, 0);
    group_init();
    memset(s, 0, sizeof(*s));
    s->ipsec.encap_mode = IPSEC_ENCAP_TUNNEL;
    s->ike.timeout = 1000; /* 1 second */
    do_config(argc, argv);
    DEBUG(1, printf("\nvpnc version " VERSION "\n"));
    hex_dump("hex_test", hex_test, sizeof(hex_test), NULL);
    DEBUGTOP(2, printf("S1 init_sockaddr\n"));
    init_sockaddr(&s->dst, config[CONFIG_IPSEC_GATEWAY]);
    init_sockaddr(&s->opt_src_ip, config[CONFIG_LOCAL_ADDR]);
    DEBUGTOP(2, printf("S2 make_socket\n"));
    s->ike.src_port = atoi(config[CONFIG_LOCAL_PORT]);
    s->ike.dst_port = ISAKMP_PORT;
    s->ike_fd = make_socket(s, s->ike.src_port, s->ike.dst_port);
    DEBUGTOP(2, printf("S3 setup_tunnel\n"));
    setup_tunnel(s);
    do_load_balance = 0;
    do {
        DEBUGTOP(2, printf("S4 do_phase1_am\n"));
        do_phase1_am(config[CONFIG_IPSEC_ID],
            config[CONFIG_IPSEC_SECRET], s);
        DEBUGTOP(2, printf("S5 do_phase2_xauth\n"));
        /* FIXME: Create and use a generic function in supp.[hc] */
        if (s->ike.auth_algo >= IKE_AUTH_HybridInitRSA)
            do_load_balance = do_phase2_xauth(s);
        DEBUGTOP(2, printf("S6 do_phase2_config\n"));
        if ((opt_vendor == VENDOR_CISCO) && (do_load_balance == 0))
            do_load_balance = do_phase2_config(s);

    } while (do_load_balance);
    DEBUGTOP(2, printf("S7 setup_link (phase 2 + main_loop)\n"));
    DEBUGTOP(2, printf("S7.0 run interface setup script\n"));
    config_tunnel(s);
    do_phase2_qm(s);
    DEBUGTOP(2, printf("S7.9 main loop (receive and transmit ipsec
packets)\n"));
    vpnc_doit(s);
    /* Tear down phase 2 and 1 tunnels */
    send_delete_ipsec(s);
    send_delete_isakmp(s);
    /* Cleanup routing */
    DEBUGTOP(2, printf("S8 close_tunnel\n"));
    close_tunnel(s);
    s_atexit_sa = NULL;
    /* Free resources */
    DEBUGTOP(2, printf("S9 cleanup\n"));
    cleanup(s);
    return 0;
}

classe tPoint

• -attributs
  • ○ x, y et z : coordonnées du point selon l'axe (O, x→), (O, y→) et (O, z→).
• -méthodes
  • ○toutes les méthodes préfixées par get permettent de récupérer la coordonnée correspondante de l'axe correspondant ;
  • ○toutes les méthodes préfixées par set permettent de fixer la coordonnée correspondante de l'axe correspondant.

classe tVecteur

• -attributs
  • ○vx, vy et vz : coordonnées du vecteur selon l'axe (O, x→ ), (O, y→ ) et (O, z→ ).
• -méthodes
  • ○toutes les méthodes préfixées par get permettent de récupérer la coordonnée de l'axe correspondant ;
  • ○toutes les méthodes préfixées par set permettent de fixer la coordonnée de l'axe correspondant ;
  • ○double produitScalaire(tVecteur v) : calcul le produit scalaire entre le vecteur courant (this) le vecteur passé en paramètre ;
  • ○double produitVectoriel(tVecteur v) : calcule le produit vectoriel entre le vecteur courant (this) et le vecteur passé en paramètre ;
  • ○double norme() : renvoie la norme euclidienne du vecteur ;
  • ○double produitMixte(tVecteur v1, tVecteur v2) : renvoie la valeur du produit mixte entre le vecteur courant (this - représenté ici v3) et les vecteurs v1 et v2 passés en paramètres tel que le produit mixte est égale à (v3^(→−) ∧ v1^(→−)) ⋅ v2^(→−).

classe tDroite

• -attributs
  • ○voir question Q.3.9 sur la justification des liens.
• -méthodes
  • ○tPoint getPoint() : récupère une copie du point caractéristique de la droite ;
  • ○tVecteur getVecteur() : récupère une copie du vecteur caractéristique de la droite ;
  • ○double calculDistance(tDroite* d) : calcule la distance entre la droite courante et la droite d en paramètre (code à fournir depuis la question Q.3.13).

classe tParticule

• -attributs
  • ○vitX, vitY,..., vitVy, vitVz: permettent de stocker les vitesses des attributs x,y,...,vy,vz ;
  • ○bestLocalValue : meilleure valeur calculée par la particule ;
  • ○bestLocalPos : meilleure droite trouvée par la particule ;
  • ○tabDroites : objet de type vector (de la standard library) permettant de stocker les adresses de toutes les lignes de vue (donc des droites) des caméras ;
  • ○bestGlobalPos : meilleure droite trouvée par l'ensemble des particules ;
  • ○bestGlobalValue : meilleure valeur calculée par l'ensemble des particules ;
  • ○w, c1, c2 : paramètres fixés de l'algorithme.
• -méthodes
  • ○updateFitness() : méthode de calcul de la nouvelle valeur de fitness (coût).
  • ○updatePosition() : méthode de calcul de la nouvelle position.

Document technique DT9. Documentation de la classe std:fstream et des classes hérités

std::fstream Input/output file stream class

Class diagram:

Input/output stream class to operate on files.
File streams are associated with files either on construction, or by calling member open.

Public member functions

(constructor) Construct object and optionally open file (public member function)
open Open file (public member function )
is_open Check if a file is open (public member function)
close Close file (public member function)

Public member functions inherited from istream

operator>> Extract formatted input (public member function)
ignore Extract and discard characters (public member function)

Public member functions inherited from ios

eof Check whether eofbit is set (public member function)

• (1)
  fstream();

  explicit fstream (const char* filename,
  

• (2)
  ```
  ios_base::openmode mode=ios_base::in|ios_base::out);
  explicit fstream (const string& filename,
  ios_base::openmode mode=ios_base::in|ios_base::out);

• (1)default constructor
  Constructs an fstream object that is not associated with any file.

filename A string representing the name of the file to be opened.
Specifics about its format and validity depend on the library implementation and
running environment.
mode Flags describing the requested input/output mode for the file.
This is an object of the bitmask member type openmode that consists of a
combination of the following member constants:

in input File open for reading: the internal stream buffer supports input operations.
out output File open for writing: the internal stream buffer supports output operations.
binary binary Operations are performed in binary mode rather than text.
ate at end The output position starts at the end of the file.
and All output operations happen at the end of the file, appending to its existing
    contents.
trunc truncate Any contents that existed in the file before it is open are discarded.

public member function std::istream::operator>>

istream& operator>> (bool& val);
istream& operator>> (short& val);
istream& operator>> (unsigned short& val);
istream& operator>> (int& val);
istream& operator>> (unsigned int& val);
istream& operator>> (long& val);

istream& ignore (streamsize n = 1, int delim = EOF);

public member function std::ios::eof

bool eof() const;

constant EOF

Document technique DT10. Documentation de la classe std:vector et des classes héritées

class template std::vector

template < class T, class Alloc = allocator<T> > class vector;

explicit vector ();
explicit vector (const allocator_type& alloc =
        allocator_type());
explicit vector (size_type n);

vector (size_type n, const value_type& val,
    const allocator_type& alloc =
        allocator_type());

~vector();

size_type size() const noexcept;

reference operator[] (size_type n);
const_reference operator[] (size_type n) const;

void push_back (const value_type& val);
void push_back (value_type&& val);

Document technique DT11. Pseudo-code de l'optimisation par essaim particulaire

Tant que le maximum d'itérations ou un certain critère n'est pas atteint

Tous les documents réponses sont à rendre, même non complétés.

Document réponse DR1. (question Q1.5)

Document réponse DR2. (question Q1.6)

Compléter les pointillés.

Document réponse DR3. (question Q2.1)

Document réponse DR4. (question Q2.2)

Document réponse DR5. (question Q3.4)

• -longitude : longitude géographique d'un point (en degré) ;
• -latitude : latitude géographique d'un point (en degré) ;
• -h : altitude géographique d'un point (en mètre) ;
• -coordCart : pointeur de type double vers le premier élément d'un tableau de trois éléments représentant les coordonnées cartésiennes du point (en mètre).

void calculCoordonnees(double longitude, double latitude,
double h, double* coordCart)
{
    // en utilisant le système géodésique WGS84
    double a=6378137; //en mètre
    double f=1/298.257222;
    // autres déclarations à suivre
    // la constante M_PI est disponible

Document réponse DR6. (question Q3.6)

• -x, y: coordonnées de la météorite dans l'image ;
• -para_astro : tableau de constantes de calibrations (paramètres astronomiques) ;
• -output : coordonnées du vecteur directeur de la ligne de vue.

void pix_to_earth_vector(double x, double y,
            double * para_astro, double * output)
{
    pix_to_cam_vector(output, x, y, para_astro[0], para_astro[1],
        para_astro[2], para_astro[3], para_astro[4],
        para_astro[5], para_astro[6], para_astro[10],
        para_astro[11]);
    rot_x(output, para_astro[7]);
    rot_y(output, para_astro[8]);
    rot_z(output, para_astro[9]);
}

• -coord : coordonnées du vecteur directeur de la ligne de vue ;
• -x, y: coordonnées de la météorite dans l'image ;
• -x0, y0 : centre de l'image ;
• -V, S, D, P et Q: coefficient du polynôme d'ordre 9 ;
• -ani, phi : coefficients de correction liés à l'objectif.

void pix_to_cam_vector(double * coord, double x, double y,
        double x0, double y0,
        double V, double S, double D, double P,
        double Q, double ani, double phi )
{
    x = x-x0;
    y = y-y0;
    double R = sqrt(x*x+y*y);
    double A; //angle azimutal (angle entre le vecteur et l'axe x)
    double e; //angle zénithal (angle entre le vecteur et l'axe z)
    if( R==0. ) { A = 0.; } else { A = atan2(y,x); }
    R = R*(1.+ ani*sin(A+phi))/1000.;
    e = R* (V + R*R* (S + R* R* (D + R*R* (P + Q*R*R))));
    coord[0] = -cos(A)*sin(e);
    coord[1] = sin(A)*sin(e);
    coord[2] = cos(e);
}

Document réponse DR7. (questions 3.9 et 3.10)

• -la variable chemins ;
• -une variable de type vector<double*> coordsCartStations : vecteur contenant des pointeurs de type double représentant des tableaux de 3 coordonnées. Chaque élément correspond aux coordonnées cartésiennes d'une station ;
• -une variable de type vector<double*> paramsStations : chaque élément du vecteur est un tableau de type double* donnant les douze paramètres astronomiques d'une station.

vector<tDroite*> calculerLignesDeVue(
        const vector<string>& chemins,
        const vector<double*>& coordsCartStations),
        const vector<double*>& paramsStations)
{
    vector<tDroite*> lignesDeVue;
    // pour toutes les lignes de tous les fichiers
    fstream fichier
        // lecture des valeurs sur la ligne
        int index;
        float brillance, posX, posY;

    // vecteur directeur pour cet enregistrement
    double vecteurDirecteur[3];
    pix_to_earth_vector(posX, posY, paramStations[i],
            vecteurDirecteur);
        // création des objets tPoint, tVecteur et tDroite
        tPoint* point = new tPoint(coordsCartStations[i][0],
                coordsCartStations[i][1],
                coordsCartStations[i][2]);
        tVecteur* vec
        tDroite* droite
        // ajout de la droite à la liste des résultats