Reconnaissance des étoiles à l'aide de la vision par ordinateur (OpenCV) : 11 étapes (avec images)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Cette instructable vous décrira comment créer un programme de vision par ordinateur pour identifier automatiquement les motifs d'étoiles dans une image. La méthode utilise la bibliothèque OpenCV (Open-Source Computer Vision) pour créer un ensemble de cascades HAAR entraînées qui peuvent être utilisées pour reconnaître des modèles d'étoiles spécifiques. Bien que ce guide soit dans le contexte de la reconnaissance de formes en étoile, le processus OpenCV que je décris peut également être appliqué à d'autres applications - il sera donc, espérons-le, utile !

Le projet est résumé dans cette vidéo:

Pourquoi ai-je écrit cette instructable ?

1. Je pense que la méthode d'identification des motifs d'étoiles que je développe a le potentiel d'être appliquée à un large éventail de projets d'astronomie amateur - qu'il s'agisse d'orientation de télescope, de classification automatique d'images ou même finalement d'un capteur d'étoiles sur un CubeSat open source ou amateur.
2. Il y a beaucoup de bons instructables OpenCV ici, mais même si j'ai trouvé que c'était un processus très difficile à apprendre au départ, j'espère donc que ce guide sera une bonne référence pour d'autres personnes cherchant à former des classificateurs HAAR pour OpenCV (pas nécessairement à voir avec l'astronomie peut-être !).
3. Je ne suis pas moi-même un programmeur de formation, donc ce projet a vraiment poussé ma compréhension. Espérons qu'en écrivant cet Instructable, d'autres fabricants plus expérimentés seront inspirés pour travailler sur ce concept et contribuer au GitHub et à cette instructable via les commentaires sur cette page.
4. L'astronomie amateur et les méthodes d'orientation sont un grand intérêt pour moi, voir mon précédent instructable comportant un Arduino Star-Finder pour les télescopes.

La photo de couverture de ce Instructable est d'une conception de concept 3U CubeSat dont j'ai participé à la conception. Je l'ai utilisé pour illustrer cette instructable car l'application originale du système de reconnaissance des étoiles par vision par ordinateur devait être pour un capteur d'orientation pour les CubeSats de fabrication amateur, à l'aide d'une caméra Raspberry Pi V2. Il existe de nombreuses autres applications potentielles de la reconnaissance des étoiles par vision par ordinateur, je crois, mais je pense que c'est la plus cool !

Un petit glossaire:

L'apprentissage de la vision par ordinateur est rendu plus lent par la quantité stupide de termes spécialisés utilisés, alors je vais en définir quelques-uns pour nous ici:

Cascade - Un classificateur formé pour identifier un objet cible spécifique.

Marqueur Fiducial - Un marqueur ajoutant un point de référence visuelle à une image.

HAAR - Les caractéristiques de type Haar sont un type de caractéristique d'image utilisé pour l'apprentissage des classificateurs.

OpenCV - Open Source Computer Vision, une bibliothèque d'outils de vision par ordinateur.

Stellarium - Logiciel d'astronomie Open Source.

Étape 1: Exigences

OpenCV est une bibliothèque basée sur Linux, donc bien qu'il soit soi-disant possible de bien l'utiliser sous Windows, vous aurez beaucoup plus de facilité à l'exécuter dans un environnement Linux (prenez cela de moi et beaucoup de jours à essayer de le faire fonctionner pleinement sur Les fenêtres!). À titre d'expérience, j'ai téléchargé et exécuté OpenCV sur mon Raspberry Pi 3B+, ce qui a été un succès, bien que la formation en classificateur soit un processus très gourmand en RAM, donc si vous souhaitez le faire à n'importe quelle vitesse, l'itinéraire recommandé est de louer un serveur virtuel Linux (ce qui peut être étonnamment peu coûteux en fait) pendant quelques jours/semaines/mois et utilisez-le comme environnement dédié dans lequel exécuter la formation sur le classificateur. Vous pourrez contrôler le serveur depuis un PC Windows à l'aide d'un client SSH tel que Putty. Une fois les cascades formées à l'aide du VPS, elles peuvent être téléchargées sur votre PC Windows et Python peut être utilisé pour exécuter le programme de reconnaissance d'images dans un environnement Windows.

Serveur virtuel Linux:

Un serveur virtuel Linux (VPS) est nécessaire pour effectuer les processus de formation en cascade HAAR. Au départ, j'ai loué un serveur avec 8 Go de RAM et Ubuntu 16.04.6 (LTS) x64, et plus tard un second pour doubler la vitesse à laquelle je pouvais former des cascades, bien que vous n'en ayez besoin que d'un minimum

Logiciel:

• Stellarium - il s'agit d'un logiciel de planétarium/astronomie virtuel, disponible gratuitement. Il sera utilisé pour rassembler des images d'étoiles simulées à utiliser dans les tests.
• Putty - Il s'agit d'un client SSH utilisé pour contrôler le VPS via la ligne de commande.
• WinSCP - il est utilisé pour effectuer le transfert de fichiers à partir du PC Windows.

Étape 2: Configuration VPS

Il existe un petit processus de configuration pour que le VPS soit opérationnel. La première fois, cela peut prendre un peu de temps pour vous, mais ce n'est pas trop compliqué si vous suivez attentivement les étapes. Ce tutoriel a été une excellente référence pour moi, je vous recommande de lire cela aussi tout en travaillant sur cette instructable. Il couvre les spécificités des commandes linux ligne par ligne, qu'il est nécessaire de suivre à la lettre.

En gros, le processus implique:

1. Création d'un serveur Linux avec la bonne version d'Ubuntu.
2. Mise à niveau et mise à jour du serveur.
3. Création d'un répertoire d'espace de travail, dans lequel OpenCV est installé.
4. Installation de certains éléments essentiels, à savoir un compilateur, diverses bibliothèques et des liaisons Python.

Après cette étape, vous êtes prêt à commencer à préparer le processus de formation.

Étape 3: Le processus

L'ensemble du processus de vision par ordinateur utilisant les cascades HAAR est assez déroutant au début, donc cette étape décrit la logique un peu plus en détail:

Processus de base

1. Un ensemble de données d'images négatives existe, composé de plusieurs milliers d'images qui ne contiennent pas l'objet d'intérêt. Cela devra être téléchargé sur le VPS.
2. Une seule image positive est créée qui contient l'objet d'intérêt. Cela devra également être téléchargé sur le VPS.
3. L'image positive unique est déformée, déformée, tournée, etc., par un ensemble de paramètres choisis et superposée sur une sélection d'images négatives. Il s'agit d'une manière artificielle de créer un grand ensemble de données positives à partir d'une seule image. (Pour d'autres applications du monde réel, telles que l'identification d'un chat, vous pouvez simplement utiliser plusieurs milliers d'images de chats, mais cette méthode n'est pas toujours appropriée si vous n'avez pas un si grand nombre d'images positives. L'approche artificielle utilisée ici sera moins efficace, mais c'est la seule option pour un cas d'utilisation comme celui-ci).
4. Un processus de formation est exécuté, qui fonctionne par étapes. Chaque étape entraînera une cascade pour identifier différentes caractéristiques de type HAAR dans les ensembles d'images. Chaque étape prend exponentiellement plus de temps à terminer et l'efficacité du classificateur augmente à chaque fois (il est également possible de sur-entraîner juste pour que vous le sachiez !).
5. Une seule cascade entraînée pourra rechercher un seul objet cible. Si vous souhaitez identifier plusieurs objets uniques, vous aurez besoin d'une cascade entraînée pour chacun. Dans ce cas, j'ai entraîné environ 50 cascades différentes pour des motifs d'étoiles uniques, afin de créer un ensemble qui pourrait couvrir l'hémisphère nord céleste.
6. Enfin, un programme de détection est utilisé qui exécute chaque cascade d'un ensemble contre une image d'entrée. La cascade recherchera son objet cible donné dans l'image d'entrée.
7. En cas de succès, l'objet cible sera identifié dans l'image d'entrée.

n.b. si elle est utilisée dans un contexte d'orientation satellite par exemple, une image serait capturée à l'aide d'une caméra embarquée. Les étoiles les plus brillantes de cette image seront identifiées et des marqueurs superposés dans ces positions. Cette image est ensuite présentée à l'ensemble des cascades entraînées, qui testeront pour voir si l'image d'entrée contient l'un des objets cibles. Si un vrai positif est détecté, alors la position angulaire d'une constellation connue est découverte par rapport aux axes du corps du satellite.

Étape 4: Négatifs et positifs

Négatifs

Un aspect vraiment clé de la formation en cascade est d'avoir un ensemble de données d'images négatives aussi grand que possible. On parle de milliers, idéalement de dizaines de milliers d'images. Peu importe ce qu'ils contiennent, le but est simplement de fournir une variété d'informations visuelles. Le dossier Classifier Training contient une variété de différents ensembles de données d'images négatives que j'ai compilés. Initialement, celles-ci étaient composées uniquement d'images de champ d'étoiles simulées glanées à partir de Stellarium, mais j'ai ensuite augmenté l'ensemble de données avec autant d'images aléatoires que j'ai pu trouver (oui, y compris mes photos de vacances…). Le plus grand ensemble de données comprend près de 9 000 images, ce qui est le plus grand que j'ai créé jusqu'à présent. En l'utilisant, cela vous évitera de compiler la vôtre.

Points positifs

L'image positive (c'est-à-dire le motif en étoile cible que la cascade sera entraînée à reconnaître) commence par une capture d'écran d'un motif en étoile dans Stellarium. Un programme python identifie ensuite les étoiles les plus brillantes de l'image et superpose des marqueurs (expliqués plus loin dans cette instructable) sur ces positions d'étoiles. Cette image est ensuite réduite à 50x50 pixels. C'est petit, mais le temps d'entraînement requis pour les cascades augmentera de façon exponentielle à mesure que cette taille augmente, et c'est donc un bon compromis entre la qualité et le temps.

Étape 5: Contrôle Stellarium

Le dossier Stellarium Scripts du référentiel GitHub contient trois programmes que j'ai écrits pour contrôler l'utilisation de Stellarium. Pour les utiliser, placez-les dans le dossier scripts de votre dossier d'installation de Stellarium. Pour les exécuter, vous pouvez ouvrir la fenêtre des scripts à partir du menu Stellarium, ou simplement en double-cliquant sur le programme dans le dossier des scripts, ce qui lancera Stellarium et exécutera immédiatement le programme sélectionné.

thesis_4 et thesis_5 capturent environ 2000 images chacune des hémisphères célestes nord et sud, respectivement. Ceux-ci ont été utilisés pour former des bases de données d'images négatives, pour former l'image positive contre. La distinction entre le nord et le sud était un moyen simple de s'assurer que le motif d'étoiles cible (positif) ne serait pas présent dans l'ensemble de données négatif en entraînant les motifs d'étoiles de l'hémisphère nord par rapport à l'ensemble de données d'images de l'hémisphère céleste sud et vice versa. (Si une image positive est également présente dans l'ensemble de données d'images négatives, cela affectera la qualité du classificateur).

thesis_setup est également utile - cela configure Stellarium pour qu'il soit approprié pour capturer des images - les images utilisées pour simuler une vue depuis l'espace. Il effectue automatiquement des actions telles que le masquage de menus, de quadrillages, d'étiquettes, etc., pour vous éviter d'avoir à chaque fois que vous souhaitez saisir une image.

Étape 6: L'homme-fusée

Les premières cascades que j'ai entraînées étaient incapables d'identifier correctement les motifs d'étoiles. Ils étaient très peu fiables et étaient très sujets aux faux positifs. Mon hypothèse était qu'effectivement, les images de champ d'étoiles de Stellarium (essentiellement juste des points blancs sur fond noir) ne contenaient tout simplement pas suffisamment d'informations visuelles pour contenir suffisamment de caractéristiques de type HAAR pour un entraînement réussi des classificateurs. Je pense qu'il était tard dans la nuit, mais j'ai décidé d'essayer l'idée d'écrire un programme pour placer automatiquement une petite image miniature sur l'emplacement de chaque étoile brillante dans une image de champ d'étoiles.

Elton

C'était un test idiot, mais en ajoutant une petite image du visage d'Elton John à chaque emplacement d'étoile brillante, en entraînant le classificateur par rapport à cette image positive, puis en exécutant les cascades par rapport à l'image d'origine, il était beaucoup plus efficace de trouver correctement le bon modèle. Je savais que j'étais sur quelque chose !

Étape 7: Marqueurs de référence

Bien que les "Eltons" aient prouvé la théorie, j'avais besoin d'un marqueur ayant une symétrie de rotation complète, de sorte que le motif en étoile apparaisse le même quelle que soit l'orientation dans laquelle il était présenté. J'ai testé une gamme de types de marqueurs et j'ai constaté que le type en bas à droite était le plus efficace, avec les anneaux noirs et blancs contrastés. Le programme python présenté dans le dossier positif du dépôt GitHub montre comment les étoiles les plus brillantes d'une image donnée sont identifiées, et ces marqueurs se superposent automatiquement dans ces positions. Nous avons maintenant créé une représentation des modèles d'étoiles clés contre lesquels on peut s'entraîner.

Étape 8: Utiliser les Cascades

Quand on a entraîné un ensemble de cascades, il faut savoir les utiliser pour identifier un objet dans une image !

Regardez le dossier Star Identification du GitHub, où vous trouverez le programme cascade_test19.py. Ce programme au nom accrocheur prend un ensemble de cascades à partir d'un dossier donné, et les exécute toutes sur une image d'entrée, et rapporte les détections effectuées. La fonction 'detectMultiScale' est au cœur de cela, et elle prend une variété d'arguments qui définissent le processus de détection. Les modifier est essentiel pour les performances du classificateur en cascade, et une discussion plus approfondie à ce sujet peut être trouvée à l'étape suivante, où nous examinons comment éliminer les faux positifs.

Cela pourrait être appliqué dans un système d'orientation satellite en corrélant la valeur du pixel au centre de la boîte englobante à la coordonnée céleste Ra/Dec du motif d'étoile identifié, puis en corrélant cela au déplacement angulaire du centre de l'image (caméra axe). À partir de là, en utilisant une compréhension de la distorsion de l'objectif (approchée d'une projection gnomonique), l'angle du satellite peut être trouvé à partir de seulement deux identifications positives.

Étape 9: Comment rester positif face aux faux positifs

Ces deux images montrent les résultats du test de la cascade sur une image identique, mais avec des paramètres différents. Clairement, la première image contient la vraie identification, mais aussi un nombre énorme de faux positifs, alors que la deuxième image ne contient que la bonne identification.

Le programme cascade_test19.py dans le dossier Star Identification du référentiel GitHub utilise deux méthodes pour trier les résultats. Premièrement, la fonction detectMultiScale définit une taille minimale et maximale de résultat qui peut être trouvée, ce qui est raisonnable, comme la taille approximative du motif d'étoile cible dans la fenêtre (pour l'objectif et le grossissement donnés - mes images Stellarium simulées utilisent les propriétés de la caméra Raspberry Pi V2) est connue. Deuxièmement, le code sélectionnera le résultat avec la plus grande boîte englobante (dans les limites précédentes). Lors des tests, cela s'est avéré être le vrai positif. Troisièmement, le programme définit un « levelWeights » minimum (en fait une « valeur de confiance ») qui est nécessaire pour traiter cet ID comme un vrai positif. Par cette méthode, les cascades étaient efficaces pour trouver le bon résultat.

En plus des images du champ d'étoiles, j'ai également testé cela par rapport à des photos de mon bureau par exemple, des cascades d'entraînement pour identifier mon cahier, ma tasse, etc., pour m'entraîner à éliminer les faux positifs. Les méthodes ci-dessus ont bien fonctionné dans toutes les circonstances, ce qui était encourageant.

Étape 10: Discussion

Zones d'amélioration

Cela a été un projet complexe pour moi, et a vraiment poussé ma compréhension du sujet. Il a fallu au total plusieurs mois de travail presque à temps plein pour amener le projet à ce point où je peux le partager avec vous, mais il reste encore beaucoup de travail à faire pour améliorer les performances de la méthode. En l'état, il peut bien fonctionner dans certaines contraintes. J'ai travaillé pour identifier les domaines nécessitant des travaux supplémentaires, et j'espère pouvoir passer du temps à les traiter dans les mois à venir. Elles sont:

Angle - Il s'agit d'un domaine complexe, l'idée que les résultats des classificateurs doivent être invariants en rotation, c'est-à-dire qu'il doit identifier de manière fiable le motif en étoile cible quel que soit l'angle sous lequel il est présenté l'image contenant le motif en étoile cible. Une cascade entraînée à l'aide d'une image d'entrée à une seule orientation ne sera pas en mesure d'identifier cette image à des orientations aléatoires. Par conséquent, la variance de l'angle d'image positif doit être introduite dans le processus d'entraînement pour entraîner des cascades pouvant accepter une plage d'angles d'entrée. Le paramètre « maxzangle » dans les commandes d'entraînement en cascade prend un argument en radians, qui contrôle une limite de l'angle selon lequel l'image positive d'entrée sera superposée sur les images négatives fournies, de sorte que l'ensemble d'images positives résultant contiendra une gamme d'orientations de l'image positive. Cependant, à mesure que ce maxzangle augmente, le taux d'acceptation (au sens large, la qualité) de la cascade diminuera fortement. Je pense que la solution consiste à former des cascades à l'aide d'une base de données d'images négatives nettement plus importante que celle que j'utilisais pour garantir qu'un classificateur en cascade de bonne qualité puisse être créé, même en incorporant une large diffusion d'orientation.

Une autre solution potentielle serait de former un certain nombre de cascades pour une cible spécifique, chaque cascade régissant une certaine partie d'une rotation complète de 360 degrés. De cette façon, la qualité de chaque cascade peut être maintenue à un niveau élevé, mais d'un autre côté, cela entraînera beaucoup plus de cascades et, par conséquent, le processus d'identification sera plus lent.

Le paramètre 'levelWeight', qui est une valeur fournie par la fonction 'detectMultiScale', est analogue à une valeur de confiance dans la détection qui a été effectuée. En étudiant cela, le graphique ci-dessus a été créé, qui montre comment la confiance de l'identification positive diminue fortement à mesure que l'orientation de l'image augmente dans les deux sens, confirmant l'idée qu'il s'agit d'un point faible.

Placement des pixels - Un point beaucoup plus simple, mais également problématique, est celui du placement des pixels, illustré par les deux images suivantes, montrant une vue agrandie d'une image d'étoile, de sorte que les pixels individuels de deux étoiles puissent être clairement vus. Le processus d'érosion utilisé dans le programme pour effacer toutes les étoiles de l'image, à l'exception des plus brillantes, conservera la première étoile et rejettera la seconde, bien qu'elles soient de luminosité égale. La raison en est que la première étoile est centrée sur un pixel, alors que la seconde ne l'est pas en tant que telle. La fonction d'érosion supprime les anneaux concentriques de pixels autour du pixel central d'un groupe, et ainsi la première étoile verra le pixel central survivre à la fonction d'érosion, mais la deuxième étoile sera complètement supprimée de l'image. Par conséquent, les marqueurs de référence ne seront placés que sur la première étoile, et non sur la seconde. Cela entraînera des incohérences concernant les étoiles brillantes dans un champ d'étoiles donné qui recevront des marqueurs (et seront donc comparées aux classificateurs entraînés) - il est donc possible qu'une observation positive correcte ne soit pas possible.

Étape 11: dernier mot

Merci d'avoir lu mon instructable, j'espère que vous avez trouvé ce projet intrigant. Cela a été un processus très intéressant de travailler dessus, cela fait plus d'un an que j'ai commencé à travailler sur le concept, et je suis encouragé par les résultats à ce stade. D'après la littérature que j'ai lue, c'est un concept assez original, et avec plus de développement peut certainement être appliqué dans une gamme d'applications pour l'astronomie amateur ou plus.

Ce projet a été une courbe d'apprentissage abrupte pour moi, et j'espère donc que certains lecteurs ayant plus d'expérience en programmation pourront être inspirés pour contribuer à la poursuite du projet via la page GitHub, et nous pourrons continuer à développer cet outil open source. J'ai hâte de lire vos commentaires, mais s'il vous plaît ne posez pas trop de questions difficiles!

Finaliste du défi spatial