Histoire de scanner

Le Fablab possède un scanner 3dsystems Sense3D.

Le logiciel fourni possède une interface simple, la procédure est en théorie tout aussi aisée : il suffit de choisir le type d'élément que l'on souhaite numériser puis de balayer tous les angles de vue pour obtenir un scan le plus complet possible. On peut observer en temps réel le modèle 3d se constituer.

En pratique cela s'avère plus compliqué :

• la reconstruction en temps réel consomme beaucoup de ressources machine et il peut arriver qu'au bout de quelques minutes de scan des saccades nous fassent perdre le fil
• en cas de mouvement trop rapide on risque de perdre le focus, et devoir tout recommencer.

Dans le cas de la réussite du process, on obtient un modèle 3D avec sa texture couleur. Certains outils de retouche permettent de boucher les trous, supprimer certains les éléments et fermer le modèle. Le modèle ainsi obtenu peut être exporté au format obj.

L'avantage de ce logiciel et de ce type de scan 3d est l'obtention d'un modèle 3d rapidement. L'inconvénient se situe au niveau du process qui est difficile à réaliser correctement. Il est très rare d'obtenir un modèle complet du premier coup, plusieurs essais sont à prévoir. La grande sollicitation des ressources matérielles est un point de difficulté.

Pour pallier à la difficulté de manipulation, une approche via un flux de travail tel qu'utilisé en photogrammétrie pourrait être une bonne alternative : enregistrer dans un premier temps la séquence sous forme de film et lancer une reconstruction 3D a posteriori. Cela permettrait de réaliser les calculs sur une autre machine plus puissante que celle utilisée pour le scan et ainsi résoudre une partie des problèmes vus auparavant.

Le logiciel Sense3D étant impossible de réaliser ce type d'opération, nous devons trouver une alternative compatible avec notre matériel.

En y regardant de plus près, on s'aperçoit que notre scanner est basé sur un module Intel Realsense SR300 qui embarque une caméra couleur (RGB) ainsi qu'une caméra de profondeur https://www.intelrealsense.com/coded-light

Intel distribue un kit de développement logiciel sous licence libre Apache : https://www.intelrealsense.com/sdk-2/ permettant de développer des applications dans différents langages.

Pour la distribution GNU/Linux Ubuntu, Intel propose même un dépôt permettant d'installer facilement la librairie librealsense2 ainsi que certains utilitaires. Parmi ces outils on trouve realsense-viewer qui propose une interface graphique très simple. On peut y afficher les flux des camera couleur et profondeur sous forme 2D ou 3D, faire des réglages de qualité et exporter une vue en 3d en nuage de points au format ply ou enregistrer les flux vidéo sous forme de fichier .bag.

L'outil en ligne de commande rs-convert nous permettra d'exploiter le fichier bag pour convertir chaque image en un nuage de points au format ply, néanmoins nous n'obtenons pas un scan 3d de l'objet.

Les fichiers bag peuvent également être exploités par les distributions ROS (Robot Operating System), collection de librairies et d'outils pour la programmation de robots mais nous nous intéresserons à ces outils ne semblent pas être faciles d'accès, nous nous y pencheront au siècle prochain…

Parmi les autres outils proposés, on peut noter rs-measure avec lequel il est facile de prendre des mesures en 3D :

ou encore rs-distance qui nous affiche en temps réel la distance entre la caméra et l'objet situé en face.

On peut comprendre que ces outils couplés à la reconnaissance d'image puissent être utiles pour la robotique…

La bonne nouvelle c'est qu'il existe des librairies sous licence libre pour exploiter notre matériel, mais nous n'avons toujours pas de logiciel pour réaliser notre scan.

Et c'est au hasard d'une lecture sur le forum dédié à Realsense, continuant de chercher comment exploiter notre scanner 3D avec du logiciel libre, nous sommes redirigés vers Open3D

Open3d est une librairie sous licence MIT qui permet le développement d'applications pour exploiter des données 3D.

À première vue on peut utiliser notre camera à travers différentes librairies Python dont pyrealsense2, version python de librealsense2.

Installation Open3D : Open3D peut être compilé depuis les sources mais il existe une manière plus rapide avec le gestionnaire de paquets python 'pip' Pour notre test nous utilisons un environnement de travail Python 3.7.7

pip3 install open3D

Installation des dépendances : Nous aurons besoin également des paquets opencv-python, joblib, matplotlib, pyrealsense2 qui seront installés de la même manière :

pip3 install pyrealsense2 joblib matplotlib opencv-python

Enfin il nous faut également les paquet suivant disponible dans votre distribution :

apt-get install python-tk

Pour faire au plus simple nous allons nous appuyer sur les fichiers exemples fournis dans les sources d'open3D, nous clonons donc l'archive :

```git clone https://github.com/intel-isl/Open3D```

(il est aussi possible de télécharger l'archive sous forme de fichier zip : https://github.com/intel-isl/Open3D/archive/master.zip à décompresser)

On se rend dans le répertoire examples/Python/ReconstructionSystem/sensors et on lance la commande : ```python realsense_recorder.py –record_imgs```

Cette commande a pour fonction de décomposer à la volée la séquence vidéo filmée sous forme de couples d'images. À l'écran s'affiche une fenêtre coupée en deux parties :

• à gauche ce que voit la caméra couleur, la zone grise correspondant à ce qui est hors de la profondeur de champs
• à droite que que voit la caméra de profondeur

Les images ainsi captures sont enregistrées dans le répertoire examples/Python/ReconstructionSystem/dataset/realsense/ avec :

• dans le sous-répertoire color : des photos couleurs au format jpeg
• dans le sous-répertoire depth : des images de profondeur auformat png, converties en niveaux de gris par opencv

Si la commande retourne l'erreur RuntimeError: Couldn't resolve requests c'est que la configuration de la camera n'est pas bonne, regardons de plus près le fichier realsense_recorder.py

On constate lignes 122 et 123 que les résolution des cameras couleur et profondeur ne sont pas correctes on remplace donc :

config.enable_stream(rs.stream.depth, 1280, 720, rs.format.z16, 30)

par

config.enable_stream(rs.stream.depth, 640, 480, rs.format.z16, 30)

et

config.enable_stream(rs.stream.color, 640, 480, rs.format.bgr8, 30)

par

config.enable_stream(rs.stream.color, 960, 540, rs.format.bgr8, 30)

On relance la commande, une fenêtre nous affiche les deux cameras couleur et profondeur.

On peut alors réaliser notre scan3D en faisant le balayage de l'objet. Une fois terminé on appui sur la touche Echap pour terminer.

Remarques :

• Notre camera de profondeur a une résolution maximale de 640x480px à 30img/s
• Notre camera de RVB a une résolution maximale de 1920x1080px à 30img/s
• Si nous utilisons la résolution maximale pour la couleur, la fenêtre d'affichage n'étant pas redimensionnée à l'écran, nous ne pouvons afficher la partie profondeur.

on retourne dans le répertoire examples/Python/ReconstructionSystem

on lance la commande python run_system.py config/realsense.json –make –register –refine –integrate

Cette commande a pour fonction de regrouper l'ensemble des vues par lot de 100 pour réaliser des fragments en 3D, puis ces fragments sont réassemblés pour constituer le modèle 3D dans son ensemble.

Après quelques minutes de calcul (15 à 30 minutes pour nos différents tests), dépendant du processeur, nous obtenons ainsi dans le répertoire examples/Python/ReconstructionSystem/dataset/realsense/scene un fichier integrated.ply correspondant à notre reconstruction.

Nous avons réalisé un premier test en extérieur, à l'ombre en prenant comme objet un vinaigrier ce qui nous permet d'avoir

• une texture exploitable
• un volume global géométriquement simple
• des détails plus complexes avec les anses et le robinet

Un premier scan a été réalisés avec Sense3D, il aura fallu 5 essais pour obtenir un modèle complet. Plusieurs essais ont été réalisés avec Open3D en faisant varier la résolution de la caméra couleur. Pour ces deux méthodes le même type de balayage a été utilisé mais il est évident qu'ils ne peuvent pas être réellement identiques. Enfin nous avons réalisé un modèle par photogrammétrie à partir de 36 photos de l'objet depuis plusieurs angles de vue, le modèle a été recomposé en 1 heure avec le logiciel libre Meshroom et nous servira de modèle de référence.

avec Sense3D : le modèle 3D obtenu est correct dans son ensemble, la texture est nette, au niveau des éléments les plus fins : les anses sont correctes mais le robinet n'est pas vraiment réussi.

avec open3D : le modèle 3D obtenu est correct dans son ensemble mais nécessitera un nettoyage pour enlever les artefacts générés. On remarque également des défauts sur les éléments les plus fins comme les anses, mais le robinet est plutôt bien dessiné. La texture obtenue est bien moins détaillée qu'avec le logiciel Sense3d.

avec Meshroom : le modèle est très fidèe à tout point de vue.

Pour les deux modèles obtenus, les structures du maillage sont régulières et assez similaires l'une de l'autre, le maillage obtenu avec Open3D est beaucoup plus dense et le nombre de faces nous le confirme :

• avec Sense3D : ~ 75 000 faces

• avec Open3D : ~ 1 000 000 faces

• avec Meshroom : ~ 430 000 faces

Le scan 3D réalisé avec notre scanner nous a permis d'obtenir un modèle de qualité moyenne mais avec une résultat rapide. La difficulté réside dans la manipulation du scanner et le fait d'être relié à l'ordinateur par un câble relativement court puisqu'il mesure moins de deux mètres. La possibilité d'utiliser une chaîne de logiciels libres nous permet d'envisager d'utiliser le matériel sur d'autres systèmes d'exploitation et d'une manière différente même si les résultats obtenus lors de notre essai ne sont pas meilleurs.

La photogrammétrie reste la méthode la plus facile à mettre en œuvre mais la plus lente en terme de calcul de rendu. Elle reste la méthode qui obtient également le meilleur résultat.

Il nous faudrait faire un test comparatif avec un protocole de scan dans lequel le scanner est fixé sur trépied et l'objet sur plateau rotatif. Ainsi le protocole sera réellement identique pour nos deux essais logiciels permettant une meileure comparaison. Aussi, la possibilité d'utiliser Open3D sur un Raspberry Pi 4 muni d'USB3 et fonctionnant sur batterie nous permettrait d'avoir une solution plus portable.

Enfin, nous n'avons pas exploré tous les réglages offerts par Open3D, il y a certainement des possibilités d'amélioration, notamment sur le traitement de la texture car en testant des résolutions supérieures nous n'avons pas pour autant obtenu de meilleurs résultats.