Discussion :

[cestquoica]

Bonjour tout le monde.

Je tente en vain et depuis quelques jours maintenant de manipuler un fichier ply en C++.

Je m'explique, j'essaie de faire 2 choses :
- parcourir le fichier avec une bibliothèque adaptée, en l'occurrence RPly (qui avait l'air d'être documentée mais pas tant que ça finalement), pour récupérer les valeurs RVB des points d'un nuage.
-parcourir le fichier ply comme on le ferait avec un fichier txt, et en fonction de la couleur récupérée à l'étape précédente, copier cette ligne du fichier ply dans un nouveau fichier ply que je crée (j'ai tenté de la lecture-écriture avec fstream et getline).

Pour ce qui est de l'étape 1, j'ouvre d'abord le fichier .ply avec ply_open, je lis le header avec ply_read_header. Puis j'essaie de récupérer les composantes RVB d'une première ligne, avec la fonction ply_get_argument_value, mais impossible de la faire marcher...
Est-ce que quelqu'un connaissant RPly pourrait me dire s'il s'agit de bien de cette fonction à utiliser (auquel cas je ne l'utilise pas comme il faut) ? Connaissez-vous une autre bibliothèque plus simple d'utilisation et bien documentée ?

Pour ce qui est de l'étape 2, est-il possible d'essayer de lire le fichier .ply comme on le fait avec des fichiers .txt (fstream...) ? Si non, est-il nécessaire de transformer le .ply en .txt ?

[Matt_Houston]

Je n'ai jamais utilisé RPly en production mais je me suis renseigné il y a quelque temps en vue du choix d'un format d'échange de données 3D pour une application au boulot.

As-tu lu et bien appréhendé l'exemple sur la page officielle : http://w3.impa.br/~diego/software/rply/ ? Il est assez parlant : entre l'ouverture du fichier via ply_open et sa validation via ply_read_header, et la lecture effective de son contenu via ply_read, il convient d'enregistrer des callbacks que la bibliothèque va invoquer aux moments opportuns via ply_set_read_cb. Je cite la documentation :

RPly uses callbacks to pass data to an application.

Rien de sorcier, c'est la manière de procéder de libpng et d'autres..

As-tu correctement implémenté chacune de ces étapes ?


En ce qui concerne la seconde partie du problème : puisque tu lis le fichier d'entrée avec RPly, ne pas l'utiliser également pour écrire le fichier de sortie aurait peu de sens..

[cestquoica]

D'accord pour l'écriture.
J'ai bien utilisé ply_open et ply_read_header et ça a l'air de marcher.

J'ai bien étudié la doc sur la page officielle, effectivement, mais j'ai du mal avec la notion de callback.

De plus, si je comprends bien, appeler la fonction ply_read ne retourne pas les valeurs RVB que je recherche. Dans le code de la librairie, je trouve des fonctions qui ont plus de sens (pour moi) mais qui prennent en entrée des éléments que j'appréhende mal : des elements, arguments notamment. A quoi correspondent-ils ? J'ai tenté plusieurs appels dans mon code, en passant en paramètre par exemple "vertex" pour indiquer que je voulais travailler sur tous les vertex, mais les types de ces variables ne correspondent pas...

Voilà en gros ce que j'ai essayé :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
 
// Opens ply file
p_ply myply=ply_open(mply.toUtf8().constData(),NULL, 0, NULL);
 
// Reads header
int res=ply_read_header(myply);
 
// Returns number of vertices
long nbVertices=ply_set_read_cb(myply, "vertex", "x", vertex_cb, NULL, 0);
printf("Number of vertices : %ld\n", nbVertices);
 
// Gets value of r
int res=ply_get_element_info("vertex", "r",nbVertices);
 
// Closes ply file
ply_close(myply);

[Bousk]

Ca a pourtant pas l'air compliqué, et l'exemple du site est très suffisant.
Tu enregistres tes callbacks, puis tu fais le ply_read, elles seront appelées selon ce qui est actuellement lue.
ply_read n'a jamais été faîte pour retourner du RGB . ply_read exécute la lecture du fichier et t'informe de ce qu'il lit à chaque fois, si nécessaire, via les callbacks que tu lui as renseigné.

In our example, we start with a call to ply_open to open a file for reading. Then we get RPly to parse it's header, with a call to ply_read_header. After the header is parsed, RPly knows which element types and properties are available. We then set callbacks for each of the vertex element properties and the face property (using ply_set_read_cb). Finally, we invoke the main RPly reading function, ply_read. This function reads all data in the file, passing the data to the appropriate callbacks. After all reading is done, we call ply_close to release any resources used by RPly.

Renseignes-toi peut-être sur le format lui-même aussi, les couleurs semblent être dans le header http://paulbourke.net/dataformats/ply/

[Matt_Houston]

En effet, ce n'est pas correct. Tenter des choses au petit bonheur en espérant obtenir le résultat souhaité ne fonctionnera pas (en tout cas en C et C++). Il faut que tu comprennes tout ce que tu écris, ne saute pas les étapes.


Qu'est-ce qu'un/une callback ? Lorsque l'on ne sait pas : Wikipédia ! On trouve sur la Wikipédia anglaise : https://en.wikipedia.org/wiki/Callba...r_programming) , d'où on peut accéder à la version française : https://fr.wikipedia.org/wiki/Fonction_de_rappel . On y trouve immédiatement, suivi de quelques exemples :

[...]une [callback] est une fonction qui est passée en argument à une autre fonction.

Ok, soit.. ça veut dire qu'on peut faire effectuer à une fonction des traitements aussi divers que l'ensemble des sous-fonctions qu'on peut lui transmettre en tant qu'arguments.


Revenons à l'exemple RPly. Il y a un truc qui doit faire tilt : il n'y a pas de boucle dans main. Comment lire un fichier arbitraire sans boucler ? Ne cherche pas, c'est impossible : on ne connaît pas le contenu d'un fichier tant qu'on ne l'a pas récupéré. Or on peut lire au sein de l'explication :

[...] Finally, we invoke the main RPly reading function, ply_read. This function reads all data in the file, passing the data to the appropriate callbacks.

This function reads all data in the file... La boucle que nous cherchions est donc dans ply_read ! Autrement dit : ply_read ne retourne pas tant que RPly n'a pas intégralement parcouru le fichier. Mais quid de ces callbacks mentionnés ensuite ? On peut lire aussi :

Independent callbacks can be associated with each property of each element. For scalar properties, the callback is invoked once for each instance. For list properties, the callback is invoked first with the number of entries in the instance, and then once for each of the data entries. [...]

Que peut-on en déduire ?

Que pour chaque type d'élément qui nous intéresse au sein du fichier PLY, la bibliothèque attend de notre part une fonction qui porte une signature bien précise, au sein de laquelle nous pouvons récupérer les données lues et qui sera appelée pendant la lecture du fichier. Cette opération de lecture démarrera à l'appel de ply_read.


Relis bien l'exemple, ligne par ligne, ainsi que l'explication associée. Si le rôle d'un appel n'est pas clair, le manuel de référence qui décrit chaque fonction de l'interface en détail est inclus en fin de page.