Template d'un constructeur d'une classe et pointeur

Version imprimable

Bonjour,

J'ai défini ma classe vertex de cette manière (je reprends uniquement le constructeur, le reste étant hors sujet) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 class vertex { public: /* [Constructeur] @param dim la dimension du point coordinates les coordonnées du point */ template<size_t dim> vertex(double coordinates[dim]) { this->dim = dim; this->coordinates = new double[dim]; for(int i = 0; i < dim; ++i) this->coordinates[i] = coordinates[i]; } private: size_t dim; double * coordinates; }
Je souhaiterais ensuite pouvoir écrire :
Code:

1 2 vertex *v = new vertex<3>(coordinates);
Malheureusement, cette ligne ne compile pas. Le compilateur et l'IntelliSense de Visual Studio me disent qu'aucun constructeur par défaut n'existe pour la classe vertex. J'en déduis que l'expression ci-dessus est invalide.

J'ai dû mal à voir où se situe l'erreur, pour autant que le constructeur soit lui-même valide.

En vous remerciant d'avance,

Nicolas.

09/11/2012, 11h39
Bousk

Bonjour,

syntaxe originale, mais on dirait qu'elle n'est pas possible !

Tel quel, ton appel construit une classe template, hors c'est juste ton constructeur qui est template. (ce qui donne déjà des noeuds au cerveau amha).
Le plus simple serait alors de mettre un constructeur par défaut, et de créer une autre méthode template (init, create, ...).
09/11/2012, 13h10
ternel
Ou alors, procéder comme avec le singleton: un "constructeur statique"
Code:

1 2 3 4 5 6 7 class vertex: private: vertex(double coordinates[], int size); public: template<int n> static vertex make(double coordinates[]); };
Mais comme toujours, le tableau est rarement un bon choix. Je préfère de loin la paire d'itérateur.

Ou, dans ce cas précis, templater la classe elle-même, quitte à créer une classe de base non template

Salut,

La question à se poser est sans doute :

Citation:

Est-ce que tu peux (comprend: est-il sensé de)mettre dans une seule et même collection, des vertex qui ont un nombre de coordonnées différents :question:

En toute honnêteté, je répondrais que, de toute évidence, le nombre de coordonnées que les vertex manipulent va dépendre du référentiel utilisé par le contexte global de ton application:

Soit tu travailles en "deux dimensions", et tous tes vertex seront composés de deux coordonnées, soit tu travailles en "trois dimensions", et tous tes vertex seront composés... de trois coordonnées.

A priori, il n'y a pas plus de sens à placer un vertex composé de trois coordonnées dans un contexte "deux dimensions" qu'à placer un vertex composé de deux coordonnées dans un contexte... 3D :aie:!

Ce n'est donc pas ton constructeur qui doit être template, mais carrément toute la classe ;)

Après, il y a plusieurs possibilités pour y arriver, l'une d'elles étant simplement de passer un paramètre de type entier pour indiquer le nombre de dimensions, par exemple sous une forme proche de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 template <int d> class vertex { public: enum{dimension = d;} vertex():coordinates(new double[dimension]){} ~vertex(){delete coordinates;} /* ne pas oublier le constructeur par copie et l'opérateur d'affectation * que je passe ici ;) */ double get(int num)const {return coordinates[num];} void set(int num, double value){coordinates[num] = value;} private: double * coordinates; };

Bonjour, et merci pour vos réponses. :)

En réalité, nous travaillons sur un programme de triangulation. Les coordonnées des points sont en trois dimensions puisque les triangles sont affichés en 3D via OpenGL. Cependant, la triangulation s'effectue dans le plan et ne requiert donc que les coordonnées (x,y); c'est pour cela que nous avons codé une série de fonctions template qui calculent la norme d'un vecteur, la distance entre deux vecteurs, etc. selon un certain nombre de coordonnées.

Nous avons volontairement décidé d'écarter l'utilisation d'une classe template pour nous éviter d'avoir à nous soucier de la dimension complète d'un point. Ce que l'on veut, c'est pouvoir considérer un point 3D comme un point 2D en laissant "tomber" la dernière coordonnée qui correspond à la hauteur du point.

Voici le code complet de la classe vertex réadaptée avec l'idée de Bousk.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 class vertex { public: /* [Constructeur] Il se contente d'attribuer le pointeur nul au pointeur des coordonnées. */ vertex() : dim(0), coordinates(nullptr) { } /* [Destructeur] */ ~vertex(void) { /* libère la mémoire allouée au tableau des coordonnées du point */ if(coordinates != nullptr) delete coordinates; } /* Initialise l'objet vertex. @param: coordinates les coordonnées du point */ template<size_t dim> void init(double coordinates[dim]) { if(dim < 1) throw exception("vertex::init<size_t dim> : le paramètre dimensionnel est invalide."); if(this->coordinates != nullptr) delete coordinates; this->dim = dim; this->coordinates = new double[dim]; for(size_t i = 0; i < dim; ++i) this->coordinates[i] = coordinates[i]; } /* Retourne les coordonnées du point dans un tableau pré-alloué. @param: coordinates les coordonnées du point */ template<size_t dim> void get_coordinates(double coordinates[dim]) const { if(this->coordinates == nullptr) throw exception("vertex::get_coordinates<size_t dim> : l'objet n'a pas été initialisé (vertex::init<size_t dim>)."); if(dim > this->dim || dim < 0) throw exception("vertex::get_coordinates<size_t dim> : le paramètre dimensionnel est invalide."); for(size_t i = 0; i < dim; ++i) coordinates[i] = this->coordinates[i]; } /* Modifie les coordonnées du point. @param: new_coordinates les nouvelles coordonnées du point */ template<size_t dim> void set_coordinates(double new_coordinates[dim]) { if(this->coordinates == nullptr) throw exception("vertex::set_coordinates<size_t dim> : l'objet n'a pas été initialisé (vertex::init<size_t dim>)."); if(dim > this->dim || dim < 0) throw exception("vertex::set_coordinates<size_t dim> : le paramètre dimensionnel est invalide."); for(size_t i = 0; i < dim; ++i) this->coordinates[i] = coordinates[i]; } private: size_t dim; double * coordinates; };
J'imagine que les utilisations de la classe exception et du keyword nullptr sont également discutables. :p

Citation:

Mais comme toujours, le tableau est rarement un bon choix. Je préfère de loin la paire d'itérateur.

Pouvez-vous m'en dire davantage ? :D

Bien à vous,

Nicolas.

09/11/2012, 14h01
ternel

Le gros problème d'un tableau, c'est qu'on ignore sa taille.

C'est mal adapté à cette situation, mais en gros, ma proposition était de reprendre l'interface générale de la STL.
Avec une paire d'itérateurs, directement tirés de <iterator>, vous aurez une indépendance vis à vis du conteneur utilisé par l'appeleur de votre constructeur.

En gros ca permet d'avoir un appel en vertex v(truc.begin(), truc.end());.

Cela dit, pour votre problème, il suffirait d'avoir des points 3D, et de ne lire que les deux premières dimensions…
09/11/2012, 14h08
Bousk

Je ne vois aucun avantage à ce choix par rapport à une simple structure Point avec 3 membres x,y,z, quitte à ne pas utiliser z dans certains algorithmes qui traitent le point en 2D. :calim2:
09/11/2012, 14h10
ternel

tout à fait. mais sans contexte, ca pouvait passer
09/11/2012, 14h15
Nadd

En fait, j'avais en tête de créer quelque chose de générique qui puisse fonctionner aussi bien en dimension deux qu'en dimension N > 2, même si le cas N > 3 n'est absolument pas pertinent pour le problème qui nous intéresse.

Puisque l'algorithme de triangulation ne requiert que les deux premières coordonnées, je voulais épargner au programme de devoir récupérer une coordonnée qui ne nous intéresse pas. Le programme doit tourner très rapidement sur un nombre très grand de points. Je me doute que l'opération d'affectation d'une valeur à une entrée d'un tableau ne coûte rien du tout, mais cela me semblait tout de même être un effort inutile dont nous pourrions nous passer.

Après, nous pourrions effectivement nous contenter d'une simple structure avec trois fonctions accesseurs de type get_x(), get_y() et get_z().

Cela dit, ça ne change rien au fait qu'il nous faut des fonctions qui calculent la distance entre deux points ou la norme d'un vecteur en dimension 2 et en dimension 3. L'utilisation de templates dans ce cas là permettrait de n'avoir qu'une seule fonction norm qui fonctionne en 2D ou en 3D plutôt que deux fonctions séparées.

Citation:

Envoyé par Nadd

Bonjour, et merci pour vos réponses. :)

En réalité, nous travaillons sur un programme de triangulation. Les coordonnées des points sont en trois dimensions puisque les triangles sont affichés en 3D via OpenGL. Cependant, la triangulation s'effectue dans le plan et ne requiert donc que les coordonnées (x,y); c'est pour cela que nous avons codé une série de fonctions template qui calculent la norme d'un vecteur, la distance entre deux vecteurs, etc. selon un certain nombre de coordonnées.

Nous avons volontairement décidé d'écarter l'utilisation d'une classe template pour nous éviter d'avoir à nous soucier de la dimension complète d'un point. Ce que l'on veut, c'est pouvoir considérer un point 3D comme un point 2D en laissant "tomber" la dernière coordonnée qui correspond à la hauteur du point.

Cela n'a pas de sens...

Tu peux, très facilement, envisager d'avoir une conversion de point 3D en point2D si tu n'as pas besoin d'une des coordonnées, mais le principe est strictement le même que lorsque tu travailles en système métrique et que tu veux avoir des informations en pouces, pieds, et miles : tu change de référentiel, et tu dois donc convertir tes valeurs;)

La conversion peut, effectivement, se "contenter" d'ignorer la composante "Y", ou de la considérer comme ayant une valeur nulle, mais elle doit se faire ;)

Avec la classe template sous la forme que j'ai présentée, tu pourrais avoir deux fonctions proches de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 vertex<2> to2D(vertex<3> const & origin) { vertex<2> ret; ret.set(0,origin.get(0)); ret.set(1,origin.get(2)); return ret; } vertex<3> to3D(vertex<2> const & origin) { vertex<3> ret; ret.set(0,origin.get(0)); ret.set(2,origin.get(1)); ret.set(1,origin.get(0.0)); return ret; }
Quand tu dois trianguler, tu convertis de la sorte tous tes plans et toutes tes droites, puis tu les manipule en "deux dimensions", pour terminer en convertissant le résultat en 3D en vue de l'affichage ;)

Ou bien, tu te bases sur le fait que, quoi qu'il arrive, tu travailles toujours avec des points "3D", mais que, quoi qu'il arrive, le résultat d'une triangulation aura toujours une valeur arbitraire pour la coordonnée Y, qui peut etre, au choix nulle ou équivalente à la moyenne de la coordonnée des coordonnées Y des points de référence(ou toute autre valeur valide mais arbitraire de ton choix).

Dans ce cas, la classe vertex pourrait d'ailleurs ne plus être template ;)
Mais, quoi qu'il en soit, il n'y a strictement aucun sens à vouloir faire tenir des points 2D et des points 3D dans une seule et même collection ;)

09/11/2012, 14h24
Nadd

Citation:

La conversion peut, effectivement, se "contenter" d'ignorer la composante "Y", ou de la considérer comme ayant une valeur nulle, mais elle doit se faire.

Imaginons que j'ai un point en 3D : vertex<3> *v. Si je le convertis en 2D pour effectuer la triangulation puis que je le reconvertis en 3D, je ne risque pas de perdre une composante ?

Sinon, j'ai saisi l'incohérence d'avoir des points 2D et 3D dans une même collection. :?
09/11/2012, 14h33
koala01

Citation:

Envoyé par Nadd

Imaginons que j'ai un point en 3D : vertex<3> *v. Si je le convertis en 2D pour effectuer la triangulation puis que je le reconvertis en 3D, je ne risque pas de perdre une composante ?

De toutes façons, a priori, ta triangulation ne donnera aucune information de hauteur...

Tu "perds" donc d'office cette information au sujet de l'objet triangulé ;)

C'est la raison pour laquelle je te donne différentes pistes à suivre afin d'arriver à déterminer une valeur "cohérente" pour cette composante ;)

Tu pourrais tout aussi parfaitement, si tu sais que les objets triangulés sont d'office au sol, envisager de chercher la hauteur du point connu le plus proche du résultat de ta triangulation, mais bon, cela ne marchera pas avec des avions, par exemple ;)

Citation:

Sinon, j'ai saisi l'incohérence d'avoir des points 2D et 3D dans une même collection. :?

Là, tu me rassures ;)
09/11/2012, 14h36
Nadd
En réalité, le programme reçoit un nuage de points en 3D à partir d'un fichier de données. C'est la première étape du programme que de charger ces données et de créer des objets vertex. La triangulation s'effectue ensuite dans le plan et les triangles sont ensuite affichés en 3D grâce à OpenGL. L'objectif est donc de trianguler une surface dans l'espace. La hauteur des points est inutile pour la triangulation mais elle sert pour le rendu final. Il faut donc pouvoir conserver les données de hauteur.

EDIT: L'intérêt majeur dans notre construction était de pouvoir appliquer la triangulation aussi bien sur des objets vertex 2D que 3D. Nous pourrions considérer une classe vertex<size_t dim> template comme proposé et rendre notre fonction de triangulation également template en se limitant au cas où dim = 2 et dim = 3. Par exemple :
Code:

1 2 3 4 5 6 template<size_t dim> class vertex { ... } template<size_t dim> void triangulation(vector<vertex<dim>*> vertices, ...);
Notre collection ne contiendrait alors que des points de même dimension et la fonction de triangulation pourrait admettre des points 2D ou 3D, selon que l'utilisateur décide de trianguler uniquement dans le plan ou bien avec un rendu dans l'espace. Puisque la fonction de triangulation n'a besoin que des coordonnées 2D, il faudrait éventuellement conserver les méthodes et fonctions templates afin de pouvoir (par exemple) calculer la norme 2D d'un vecteur 3D. Ce que je voulais surtout éviter c'était de me retrouver avec des fonctions doubles du genre : norm2D, norm3D, dist2D, dist3D, dot2D, dot3D, etc.
09/11/2012, 16h38
ternel

Alors effectivement, tu dois tout templater: la classe de point, la triangulation, la norme, et ainsi de suite.

Surtout que pour trianguler dans un plan, tu dois d'abord changer de repère, opération qui considère les 3 coordonnées.

Cependant, avec une bonne classe de point et de vecteur, la plupart des operations sont implémentables comme des operator libres.

Bonjour, et merci encore pour vos réponses. :)

J'ai suivi vos conseils et décidé de simplifier drastiquement la structure du programme. Puisque le problème qui nous intéresse ne fait intervenir que la 2D (pour la triangulation) et la 3D (pour le rendu), j'ai décidé de nous y tenir pour la classe vertex.

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class vertex
{
public:
	vertex(double x, double y, double z);
	~vertex(void);
	inline double x(void) const { return _x; }
	inline double y(void) const { return _y; }
	inline double z(void) const { return _z; }
	inline void get_coordinates(point<dimension::dim2> &p) const { p[0] = _x; p[1] = _y; }
	inline void get_coordinates(point<dimension::dim3> &p) const { p[0] = _x; p[1] = _y; p[2] = _z; }
	inline double &x(void) { return _x; }
	inline double &y(void) { return _y; }
	inline double &z(void) { return _z; }
	inline void set_coordinates(double x, double y, double z) { _x = x; _y = y; _z = z; }
private:
	double _x, _y, _z;
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
enum dimension : size_t
{
	dim2 = 2,
	dim3 = 3
};
 
template<dimension dim>
class point
{
public:
	point() { ... }
	point(double coordinates[dim]) { ... }
	inline void get_coordinates(double coordinates[dim]) const { ... }
	inline double const & operator[](size_t index) const { ... }
	inline double & operator[](size_t index) { ... }
private:
	double coordinates[dim];
};

Code:

1
2
3
4
5
6
7
8
9
10
11
12
template<dimension dim>
inline double norm(vertex *u)
{
	point<dim> p;
	u->get_coordinates(p);
 
	double sum = 0.;
	for(int i = 0; i < dim; ++i)
		sum += pow(p[i], 2);
 
	return sqrt(sum);
};

J'espère que l'usage du keywork inline est justifié et que la structure général est suffisamment claire. :P

Merci encore pour votre aide,

Nicolas.

Il y a quand meme une question qui me turlupine dans ta solution : quelle est la différence entre un vertex et un point, surtout s'il est 3D :question:

A priori le phénomène d'alignement aidant, il n'y a aucune différence en terme d'utilisation de la mémoire entre le fait d'avoir une structure qui manipules trois double sous la forme d'un tableau proche de
Code:

1 2 3 4 struct Point { double coordinate[3]; };
et la même structure qui les manipule sous la forme de trois variables séparées et ressemblant à quelque chose comme
Code:

1 2 3 4 5 6 struct Point { double x; double y; double z; };
si ce n'est que la première forme impose une convention supplémentaire dans le sens où tout le monde doit savoir à quel axe de coordonnée correspond chaque valeur de coordinate.

Or, c'est finalement à peu près ce à quoi correspondent tes actuelles classes Point <3> et vertex :aie:

D'après ce que tu expliquais au début, ta classe vertex était, sommes toutes, fort proche de ton actuelle classe point.

Je t'ai convaincu du fait qu'il n'avait aucun sens d'avoir des points deux dimensions et des points trois dimensions "mélangés" dans une seule et même collection, et je maintiens ce que j'ai dit hier.

Mais c'est peut etre se "faire du mal pour rien" que d'avoir deux représentations sommes toutes identiques de la même donnée, et de "s'amuser" à passer de l'une à l'autre, non :question:

Comme je l'ai dit plus tot, rien ne t'empêche d'avoir une classe Point (car il est vrai que ca semble mieux coller à l'idée que le nom vertex) qui représente manipule d'office des points 3D, mais de "laisser purement et simplement tomber" (ou du moins de ne pas la prendre en compte ou de lui donner une valeur arbitraire ) la coordonnée Y quand elle ne sert à rien.

Ceci dit:

Quand tu fournis l'implémentation d'une fonction directement dans la définition d'une classe, la fonction est implicitement déclarée inline. L'utilisation du mot clé inline est donc inutile pour les fonctions de ta classe vertex ;)(par contre, le mot clé est obligatoire pour la fonction norm ;))
Il n'est jamais bon de renvoyer une référence non constante sur un membre de classe, car cela brise purement et simplement l'encapsulation :aie: : Fournis des accesseurs constants et des mutateurs si besoin en est, mais pas une fonction non constante qui renvoie une référence non constante sur un membre ;)
En outre, on pourrait sans doute arguer du fait qu'un objet de type vertex (ou point) a sémantique de valeur, et que tout objet de ce type est donc d'office constant (si tu change une des coordonnée d'un point, tu obtiens, purement et simplement un autre point ;)) pour justifier le fait que seuls les accesseurs constants sont réellement utiles et intéressants ;)

Je persiste encore une fois et je signe le fait que, à mon sens, tu pourais très bien te contenter d'une seule et unique classe (nommons la Point, si tu veux) qui prendrait la forme de
Code:

1 2 3 4 5 6 7 8 9 10 11 12 class Point { public: Point(double x, double y, double z):x_(x),y_(y),z_(z){} double x() const{return x_;} double y() const{return y_;} double z() const{return z_;} private: double x_; double y_; double z_; };
qui serait utilisée partout en considérant que, dans certaines circonstances ( lors de la triangulation, essentiellement), il faut simplement envisager l'utilisation d'une valeur arbitraire pour la coordonnée Y.

La seule question restant à trancher étant la manière de déterminer cette valeur arbitraire, et j'ai ouvert suffisamment de voies pour te permettre de faire preuve d'imagination ;)

Ta fonction norm prendrait alors la forme de
Code:

1 2 3 4 5 6 7 double norm(const Point & origin) { double result = (origin.x()*origin.x() + origin.y()*origin.y() + origin.z()*origin.z()); return sqrt(result); }
Et, quand il s'agit de faire la triangulation, tu travailles uniquement sur les coordonnées X et Z, avant d'évaluer la valeur arbitraire pour y (au pire, en te basant sur le fait que y vaut 0.0 lors des premiers calculs) ;)

Bonjour, et merci pour votre réponse. :)

La classe point avait pour objectif de permettre la conversion de coordonnées 3D en coordonnées 2D en laissant simplement tomber la coordonnée en Z. Il s'agissait simplement de planquer un tableau de coordonnées dans un objet.

En géométrie numérique, on travaille sur des maillages. La terminologie à appliquer est celle de triangle et de vertex, d'où l'utilisation de ces noms pour les casses. Même si un vertex possède la même structure qu'un point, il ne désigne a priori pas la même chose. :aie:

Citation:

Comme je l'ai dit plus tot, rien ne t'empêche d'avoir une classe Point (car il est vrai que ca semble mieux coller à l'idée que le nom vertex) qui représente manipule d'office des points 3D, mais de "laisser purement et simplement tomber" (ou du moins de ne pas la prendre en compte ou de lui donner une valeur arbitraire ) la coordonnée Y quand elle ne sert à rien.
Code:

1 2 3 4 5 6 7 double norm(const Point & origin) { double result = (origin.x()*origin.x() + origin.y()*origin.y() + origin.z()*origin.z()); return sqrt(result); }
Lorsque le programme démarre, il charge toutes les points à partir d'un fichier de données. Ces points sont en trois dimensions et toutes leurs composantes ont de l'importance. Pour la triangulation, seules les deux premières m'intéressent : la troisième ne doit donc pas être prise en compte dans la norme, d'où l'idée d'un template. Pour être honnête, je ne saisis pas très bien votre idée. :oops: Comment la classe point pourrait-elle savoir qu'elle doit attribuer une valeur spécifique à l'une de ses composants pour "simuler" le cas 2D, à moins que l'idée n'était de faire une copie du point et d'attribuer la valeur nulle à l'une de ses composantes ?

Citation:

Ceci dit:
1. Quand tu fournis l'implémentation d'une fonction directement dans la définition d'une classe, la fonction est implicitement déclarée inline. L'utilisation du mot clé inline est donc inutile pour les fonctions de ta classe vertex (par contre, le mot clé est obligatoire pour la fonction norm )
2. Il n'est jamais bon de renvoyer une référence non constante sur un membre de classe, car cela brise purement et simplement l'encapsulation : Fournis des accesseurs constants et des mutateurs si besoin en est, mais pas une fonction non constante qui renvoie une référence non constante sur un membre

J'en prends très bonne note. Honte sur moi ! :roll:

Citation:
Envoyé par Nadd
Code:

1 2 3 4 5 6 7 double norm(const Point & origin) { double result = (origin.x()*origin.x() + origin.y()*origin.y() + origin.z()*origin.z()); return sqrt(result); }
Lorsque le programme démarre, il charge toutes les points à partir d'un fichier de données. Ces points sont en trois dimensions et toutes leurs composantes ont de l'importance. Pour la triangulation, seules les deux premières m'intéressent : la troisième ne doit donc pas être prise en compte dans la norme, d'où l'idée d'un template. Pour être honnête, je ne saisis pas très bien votre idée. :oops: Comment la classe point pourrait-elle savoir qu'elle doit attribuer une valeur spécifique à l'une de ses composants pour "simuler" le cas 2D, à moins que l'idée n'était de faire une copie du point et d'attribuer la valeur nulle à l'une de ses composantes ?
Oui, tout à fait...

Quand tu fais ta triangulation, tu pars d'un certain nombre de points connus qui participent au relèvement, qui vont fournir chacun un azimut vers l'objet triangulé qui va représenter un "point inconnu".

Dans 99% des cas, deux points de relèvements et les deux azimuts correspondant pourraient suffire, sauf, bien sur, si l'objet triangulé se trouve dans l'alignement des deux points de relèvement.

C'est pour cela que l'on va travailler généralement avec minimum trois points de relèvements, mais chaque point de relèvement supplémentaire a une chance d'apporter une précision supérieure ;)

Quand tu vas faire ta triangulation, tu vas prendre les points de relèvement deux à deux , pour obtenir un triangle dont deux des angles sont les points de relèvement et dont le troisième est l'objet triangulé, dont tu ignores, a priori, la position.

Les cotés de ce triangles sont représentés par :

l'azimut reliant les deux points de relèvement pour le premier coté
l'azimut relevé à partir du premier point de relèvement pour le deuxième coté
l'azimut relevé à partir du deuxième point de relèvement pour le troisième coté
et ce sont ces informations qui te permettront de déterminer le point où se trouve... l'objet triangulé.

Ta fonction de triangulation va donc... renvoyer un point qui ne fait, au début du moins, pas partie de l'ensemble des points déjà connus, et sur une hauteur inconnue, et qui pourrait ressembler à quelque chose comme
Code:

1 2 3 4 5 6 7 8 9 Point triangulation(std::vector<Point> const &, std::vector<Azimuts> const &) //un azimut par point { /* calcul des position X et Z en utilisant les points 2 à 2 et les azimuts * correspondant * (règle des sinus ??? ) */ return Point(X, 0.0,Z) }
et tu vas tracer une verticale passant par le point renvoyé pour indiquer que ton objet triangulé se trouve "à une altitude inconnue" "quelque part à la verticale de ce point".

Si tu sais que ton objet triangulé est d'office "au sol", tu pourras chercher le point connu le plus proche du point calculé afin d'en récupérer l'altitude ;)

Tu pourrais, bien sur, en plus d'avoir un azimut, envisager d'avoir un angle d'élévation, vu que tu connais l'altitude de tes points de relèvements, et tu pourrais appliquer le même principe, mais sur base des élévations pour déterminer l'altitude de ton objet triangulé ;)

Mais cela implique que, pour calculer l'altitude, chaque point de relèvement doit te donner un azimut et une élévation, donc deux angles au total ;)

Et comme il n'est pas impossible que le point triangulé se trouve exactement à l'emplacement d'un de tes points de maillage, tu peux, bien entendu, avoir deux fois le même point en mémoire : une fois pour indiquer le point de maillage et une autre fois pour indiquer l'objet triangulé, ce dernier pouvant être "retiré de la liste" une fois qu'il n'a plus de raison d'être ;)

11/11/2012, 14h27
Nadd

Je pense qu'il doit y avoir un mal entendu. :mouarf: Lorsque je parle de triangulation, je fais référence à la triangulation de Delaunay, qui consiste, à partir d'un nuage de points connus dans le plan, à former des triangles de Delaunay de manière à obtenir un maillage sur lequel nous pouvons appliquer une méthode d'éléments finis. Il ne s'agit pas de la technique permettant de calculer la position d'un point à partir d'autres points. Je suis navré de n'avoir pas été clair là-dessus... :oops:

Le nuage de points est connu et il n'y aucun point mystère à calculer. L'objectif du programme est simplement de former des triangles de Delaunay avec ces points, ce qui s'effectue dans le plan, et ensuite afficher via OpenGL ces triangles dans l'espace 3D en utilisant les données de hauteur.
11/11/2012, 15h39
koala01

Ah, ok... au temps pour moi :aie:

Ceci dit, même si la triangulation ne prend pas l'altitude du point en compte, tu te retrouveras quand même au final avec un triangle donc chaque point est la copie d'un point de ton maillage d'origine, et le calcul de la normale prendra toujours la composante y en compte aussi ;)

La seule chose, c'est que la composante y des points ne sera pas prise en compte lors de la triangulation.

Mais cela n'implique absolument pas le fait... qu'elle n'existe pas ;)
11/11/2012, 17h17
Nadd

Pour être honnête, je n'avais pas envie de devoir travailler avec des copies de points pour la triangulation, mais avec les points d'origine, ce qui implique de devoir travailler avec des fonctions qui permettent de n'utiliser que les deux premières composantes puisque la troisième n'est pas nulle ni négligeable pour le rendu final. Ou alors je n'ai toujours pas compris votre idée... Il s'agit bien de les copier, d'annuler l'une des composantes et de trianguler ? :oops:
11/11/2012, 17h25
koala01
Ah, tu peux travailler sur des pointeurs / itérateurs sur la collection de ton nuage de points, ce qui évite la copie et permet en plus de garder une trace de la composante y, mais l'idée est de se dire que la composante y n'est, effectivement, pas négligeable pour le rendu final, mais n'intervient purement et simplement pas dans la triangulation.

Il "suffit" donc que ta fonction de triangulation travaille avec les valeurs de x() et de z(), sans s'intéresser à celle de y(), et c'est tout ;)

Comme j'essayais de le dire la tout de suite, ce n'est pas parce que la composante y de ton point n'est pas utilisée qu'elle n'existe pas, bien au contraire... Il suffit "simplement" que tu décides de ne pas l'utiliser dans ton algorithme de triangulation ;)
[EDIT]
Maintenant, cela peut peut etre impliquer le fait d'avoir une fonction "bis" de calcul de la normale qui pourrait etre proche de
Code:

1 2 3 4 5 6 7 double normForTriangulation(vertex *u) (const Point & origin) { double result = (origin.x()*origin.x() + origin.z()*origin.z()); return sqrt(result); }
si la prise en compte de la composante y occasionne des erreurs de calcul ;)
11/11/2012, 17h42
Nadd

Citation:

Il "suffit" donc que ta fonction de triangulation travaille avec les valeurs de x() et de z(), sans s'intéresser à celle de y(), et c'est tout.

Effectivement, mais je trouvais plus esthétique d'effectuer les calculs sur des tableaux de coordonnées 2D avec des boucles plutôt que des appels des fonctions x() et y().

Citation:

Maintenant, cela peut peut etre impliquer le fait d'avoir une fonction "bis" de calcul de la normale qui pourrait etre proche de [...] si la prise en compte de la composante y occasionne des erreurs de calcul.

En fait, il y a tout un tas d'autres fonctions qui nécessitent la même flexibilité que la fonction qui calcule la norme d'un vecteur : il y a aussi le produit scalaire de deux vecteurs, le produit vectoriel de deux vecteurs, la distance entre deux vecteurs, etc. Fonctions qui doivent fonctionner aussi bien en 2D qu'en 3D. L'avantage des templates, c'était justement d'avoir à éviter de dédoubler toutes ces fonctions qui font la même chose à une composante près.

A ce moment là, il devient peut etre intéressant de se rappeler ce que disait

Citation:

Envoyé par David Wheeler

all problems in computer science can be solved by another level of indirection .

;)

Ce n'est plus "point" qui se templatise, mais un foncteur qui sera spécialisé pour la récupération des valeurs, sous une forme proche de (on peut reprendre l'idée de ton énumération ;))

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
template<int maxDim>
struct getter;
template <>
struct getter<3>
{
    enum {max=3};
    double get(Point const & p, int index) const
    {
         switch(index)
         {
             case 0 :
                 result = p.x();
                 break;
             case 1 :
                 result = p.y();
                 break;
             case 2 :
                 result = p.z();
                 break;
         }
    }
};template <>
struct getter<2>
{
    double get(Point const & p, int index) const
    {
         double result;
         switch(index)
         {
             case 0 :
                 result = p.x();
                 break;
             case 1 :
                 result = p.z();
                 break;
         }
    }
};

Et tu templatise, effectivement, les foncteurs qui t'intéressent, par exemple sous une forme proche de

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
template <int dim>
struct normalizer
{
    enum {dimCount = dim};
    double operator()(Point const & p)
    {
         double result = 0.0;
         for(int i = 0; i< dimCount; ++i)
         {
             double temp = getter<dimCount>().get(p,i);
             temp *=temp;
             resut += temp;
         }
         return sqrt(result);
    }
};

De cette manière, tu dégage ta classe Point d'une responsabilité qu'il ne doit pas avoir (le fait de savoir si tu travailles dans une contexte 2D ou 3D) et tous les foncteurs susceptibles d'être adaptés en fonction du contexte pourront l'être ;)

J'adopte... à moitié ! :D

L'idée du foncteur est très intéressante ! Ayant implémenté le foncteur getter, j'ai tout de même préféré conserver l'aspect fonction template pour le calcule de la norme, de la distance, etc.
Code:

1 2 3 4 5 6 7 8 template<dimension dim> inline double norm(point *u) { double sum = 0.; for(int i = 0; i < dim; ++i) sum += pow(getter<dim>().get(u, i), 2); return sqrt(sum); };
Dans votre proposition, quel est le rôle joué par l'énumération ?

Le fait de dissocier le soucis de d'avoir si l'on travaille en 2D ou en 3D de la classe point me semble effectivement cohérent. ;)

Ceci dit, je me pose une dernière question : pourquoi ne pas intégrer à la classe point une fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 double get(size_t index) const { double result = 0.; switch(index) { case 0: result = x(); break; case 1: result = y(); break; case 2: result = z(); break; } return result; }
Puisque dans ma triangulation, seules les coordonnées x() et y() m'intéressent, il suffirait d'écrire :
Code:

1 2 3 4 5 for(size_t i = 0; i < 2; ++i) { double c = v->get(i); // DO SOMETHING }
Bien entendu, la technique du foncteur reste plus flexible puisqu'elle permet de cibler les coordonnées d'intérêt avec plus de robustesse.

Merci beaucoup pour l'aide que vous m'avez apportée. :D

Citation:
Envoyé par Nadd
J'adopte... à moitié ! :D

L'idée du foncteur est très intéressante ! Ayant implémenté le foncteur getter, j'ai tout de même préféré conserver l'aspect fonction template pour le calcule de la norme, de la distance, etc.
Code:

1 2 3 4 5 6 7 8 template<dimension dim> inline double norm(point *u) { double sum = 0.; for(int i = 0; i < dim; ++i) sum += pow(getter<dim>().get(u, i), 2); return sqrt(sum); };
Dans votre proposition, quel est le rôle joué par l'énumération ?
C'est surtout une habitude qui permet, en cas de besoin, de disposer d'une constante de compilation qui représente la valeur de l'entier fournis en paramètre template ;)

Dans le cas présent, elle permet "juste" d'avoir un nom clairement défini dans la boucle ;)
Citation:
Ceci dit, je me pose une dernière question : pourquoi ne pas intégrer à la classe point une fonction :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 double get(size_t index) const { double result = 0.; switch(index) { case 0: result = x(); break; case 1: result = y(); break; case 2: result = z(); break; } return result; }
Parce que, la classe Point n'étant pas template, tu ne pourrais pas utiliser une boucle pour récupérer les coordonnées, or, j'ai cru comprendre que le fait d'avoir la composante y pourrait poser problème pour la triangulation ;)
Citation:
Puisque dans ma triangulation, seules les coordonnées x() et y() m'intéressent, il suffirait d'écrire :
Code:

1 2 3 4 5 for(size_t i = 0; i < 2; ++i) { double c = v->get(i); // DO SOMETHING }
Ce sont les coordonnées x() et z() qui t'intéressent pour la triangulation, y() étant l'axe "vertical", non :question:

Cela impliquerait que tu devrait utiliser get(0) pour avoir x() et get(2) pour avoir z(), et c'est, justement, pour cela que je conseille une spécialisation de foncteur qui permet de n'avoir que x() et z() en get(0) et get(1) ;)

Citation:

Bien entendu, la technique du foncteur reste plus flexible puisqu'elle permet de cibler les coordonnées d'intérêt avec plus de robustesse.

Tout à fait...

Avec l'énorme avantage que si, un jour, il faut envisager "une autre solution", il te suffira de créer la spécialisation qui convient ;)

Tu veilles donc à rester en mesure de respecter le fameux "OCP" (open close principle) qui est, faut il le rappeler, l'un des cinq principes vantés par les méthodes SOLID et autre agile ;)

12/11/2012, 08h22
Nadd

Citation:

Ce sont les coordonnées x() et z() qui t'intéressent pour la triangulation, y() étant l'axe "vertical", non ?

Le format adopté par le fichier d'entrée est le format : X Y Z, où (X,Y) représentent les coordonnées dans le plan et Z l'élévation du point. Ce n'est pas standard, mais c'est la convention qui nous a été imposée. :roll:

EDIT: Après réflexion, et puisque le programme le permet, nous avons décidé d'adopter la convention universelle. Après tout, cela n'implique que la modification de deux lignes de code (l'une pour le getter et l'autre pour la récupération des données).

Encore une fois, merci beaucoup pour votre aide. ;)

Bien à vous,

Nicolas.
12/11/2012, 12h43
koala01

Citation:

Envoyé par Nadd

Le format adopté par le fichier d'entrée est le format : X Y Z, où (X,Y) représentent les coordonnées dans le plan et Z l'élévation du point. Ce n'est pas standard, mais c'est la convention qui nous a été imposée. :roll:

Ils sont malins, eux !!!

Mais bon, parfois, on a des gens qui refusent la facilité :P

Citation:

EDIT: Après réflexion, et puisque le programme le permet, nous avons décidé d'adopter la convention universelle. Après tout, cela n'implique que la modification de deux lignes de code (l'une pour le getter et l'autre pour la récupération des données).

Cela me semble beaucoup plus sage, d'autant plus que, autrement, il me semble que tu aurais du chipoter pour passer les coordonnées dans le bon ordre à openGL, non :question:
12/11/2012, 15h32
Nadd

Citation:

Cela me semble beaucoup plus sage, d'autant plus que, autrement, il me semble que tu aurais du chipoter pour passer les coordonnées dans le bon ordre à openGL, non ?

Tout à fait ! :)