Discussion :

[electroremy]

Bonjour à tous,

Je continue à developer un logiciel de CAO / FAO commencé en 2011
Il est codé avec VB.NET, avec quelques parties en C#

Pour l'affichage en 3D et aussi en 2D, j'utilise Open GL avec la DLL OpenTK version 1.0.278.44921

Je me dis que ça doit être obsolète...

Surtout que j'utilise une méthode assez ancienne (qui devait correspondre au début d'Open GL), à savoir qu'à chaque affichage j'envoie toutes les données

Code VB.NET :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
                    GL.Begin(BeginMode.Triangles)
                    For j = 0 To STL_ListeT.Count - 1
                        STL_ListeT_Current = STL_ListeT.Item(j)
                        STL_ListeColor3_Current = STL_ListeColor3.Item(j)
                        n = STL_ListeT_Current.Count \ 12
                        For i = 0 To n - 1
                            GL.Color3(STL_ListeColor3_Current.Item(i))
                            k = 12 * i
                            GL.Normal3(STL_ListeT_Current.Item(k), STL_ListeT_Current.Item(k + 1), STL_ListeT_Current.Item(k + 2))
                            GL.Vertex3(STL_ListeT_Current.Item(k + 3) + dtx3D, STL_ListeT_Current(k + 4) + dty3D, STL_ListeT_Current.Item(k + 5) + dtz3D)
                            GL.Vertex3(STL_ListeT_Current.Item(k + 6) + dtx3D, STL_ListeT_Current.Item(k + 7) + dty3D, STL_ListeT_Current.Item(k + 8) + dtz3D)
                            GL.Vertex3(STL_ListeT_Current.Item(k + 9) + dtx3D, STL_ListeT_Current.Item(k + 10) + dty3D, STL_ListeT_Current.Item(k + 11) + dtz3D)
                        Next
                    Next
                    GL.End()

Curieusement ça reste assez rapide, ça ne commence à perdre en fluidité que lorsque la pièce compte plus de 200.000 triangles et ça devient pénible voir inutilisable au delà de 1.000.000 de triangles

Une fois l'objet affiché, avec la souris :
- je ne fait que bouger le point de vue (ou l'éclairage)
- parfois je modifie, j'ajoute ou je retire juste quelques éléments

Il serait plus pertinent, lors des mouvements de pièces à la souris au lieu de tout renvoyer à chaque fois, de pouvoir réutiliser les données dans la carte graphique et de changer seulement la position de la caméra et de l'éclairage.

Ca serait bien, si c'est possible, de pouvoir modifier, supprimer ou ajouter des elements en laissant des autres dans la carte graphique. Mais si j'arrive déjà à ne pas renvoyer toutes les données à chaque affichage ça sera très bien.

J'utilise les objets suivants avec Open GL :
- Lines
- LineStrip
- LineLoop
- Quads
- QuadStrip
- Triangles
- TriangleStrip
- TriangleFan

Si besoin je peux me passer des Quads, des TriangleStrip et TriangleFan pour n'utiliser que des triangles.
En revanche, j'ai besoin d'afficher des lignes, ça serait une grosse galère de créer des cylindres de petit diamètre à la place.

J'utilise aussi la transparence, ce façon modérée mais nécessaire (une surface plane au dessus de la pièce, pour visualiser un plan de coupe ou un niveau)

J'ai des fenêtres comportant plusieurs zones OpenGL que mon programme affiche en même temps (typiquement : vue en 3D, vue de dessus en 2D, et vue en coupe en 2D), ça aussi c'est nécessaire

EDIT : j'ai aussi besoin de pouvoir afficher les triangles 'à l'envers', avec une couleur dédiée, dans un mode d'affichage de mon programme (pour vérifier la présence de surfaces orientées dans le mauvais sens)

Enfin, si on pouvait afficher quelques textes de façon simple ça serait super mais c'est un détail.

Ne m'étant pas intéressé au sujet depuis des années, je ne sais pas trop ce qu'il en est...
Vous me conseillez quoi ?
Je ne cherche pas la toute dernière version ; simplement une méthode plus optimale, on va dire un compromis moins obsolète
Comme dit au début, c'est un logiciel fait en .NET, le logiciel doit tourner sous Windows 7 et suivants.
Un compatibilité avec Windows XP serait un plus mais je peux m'en passer (NB : il y a souvent des ordinateurs anciens associés aux machines d'usinage, car la mécanique n'évolue pas aussi vite que l'informatique)

A bientôt

[Kannagi]

Je te conseille d'utiliser au moins OpenGL 3 , vu que oui ta méthode est obsolète et super lente.
(Et OpenGL 3 est le bon compromis, vu que de nos jours ,c'est plus Vulkan qui devrait être conseillé et OpenGL 4 est obsolète et complexe ).

[electroremy]

Je te conseille d'utiliser au moins OpenGL 3 , vu que oui ta méthode est obsolète et super lente.
(Et OpenGL 3 est le bon compromis, vu que de nos jours ,c'est plus Vulkan qui devrait être conseillé et OpenGL 4 est obsolète et complexe ).

Merci pour ta réponse

J'ai quelques questions :
- est-ce que toutes les fonctions que j'utilisent ont un équivalent sous OpenGL3 (je pense aux objets qui ne sont pas des triangles, et à la 2D ; mon usage d'OpenGL est assez différent des besoins liés à l'animation ou aux jeux vidéo) ?
- dois-je mettre à jour ma DLL OpenTK et/ou utiliser autre chose pour travailler avec OpenGL3 sous .NET ?
- est-ce possible, pour faciliter la "migration" et la mise au point, d'utiliser dans le même projet OpenGL3 tout en conservant l'ancien code OpenGL1 (quitte à faire deux fenêtres séparées) ?

A bientôt

[Kannagi]

- est-ce que toutes les fonctions que j'utilisent ont un équivalent sous OpenGL3 (je pense aux objets qui ne sont pas des triangles, et à la 2D ; mon usage d'OpenGL est assez différent des besoins liés à l'animation ou aux jeux vidéo) ?

Je n'ai pas trop compris parce que faire des objet ou de la 2D , ça se fait dans du JV , mais bon OpenGL3 possède plus de chose que OpenGL1 , et sans vouloir d’offenser , le jeux vidéo ou l'animation utilisera des fonctions avancé ,comparé à toi qui semble vraiment faire une utilisation très basique de la lib.

- dois-je mettre à jour ma DLL OpenTK et/ou utiliser autre chose pour travailler avec OpenGL3 sous .NET ?

Jamais utilisé OpenTK/.Net, mais normalement pas besoin de changer.

Merci pour ta réponse
- est-ce possible, pour faciliter la "migration" et la mise au point, d'utiliser dans le même projet OpenGL3 tout en conservant l'ancien code OpenGL1 (quitte à faire deux fenêtres séparées) ?

Les deux codes peuvent fonctionner ensemble (conseiller de faire de façon séparé ) ,c'est sur OpenGL ES où les fonction OpenGL1 n'existe plus.

ah bien sur GLU ne doit plus être utilisé.
(et on peut s'en passer sur OpenGL 1 aussi même pour de la 3D)

[electroremy]

et sans vouloir d’offenser , le jeux vidéo ou l'animation utilisera des fonctions avancé ,comparé à toi qui semble vraiment faire une utilisation très basique de la lib.

Oui tout à fait tu as raison :-)

Le besoin est plus simple... et il est même parfois antagoniste.
Dans un jeu ou une animation, on souhaite avoir la plus belle image le plus efficacement possible, y compris en "trichant" mais en faisant en sorte que les défauts ne soient pas remarqués par l'œil du joueur ou du spectateur.

En revanche, en CAO / FAO on veut quelque chose de fidèle, pas au sens esthétique mais géométrique ; et s'il y a des défauts (typiquement des triangles mal raccordés, par exemple dans une pièce 3D qui n'est pas "étanche" alors qu'elle le devrait) on veut qu'ils soient bien visibles, pour vérifier si une pièce est bien ou mal modélisée.

Voici quelques copies d'écran, ce sera plus parlant.

Les pièces sont usinées ou imprimées dans la même matière, donc la vraie pièce a une couleur uniforme ; mais dans mon programme je "colorise" certaines parties de la pièce pour bien les différencier et identifier plus facilement les difficultés d'usinage et/ou les erreurs de modélisation. Certaines formes "auxiliaires" sont dessinées en plus comme des parcours d'outils, des axes de perçage, des hauteurs... le but étant de vérifier que certaines choses "invisibles" sur la pièce finale sont bien présentes et au bon endroit.

Voici la fenêtre de visu avec une vue 2D correspondant à une image BMP lue et convertie en vectoriel, avant et après lissage :





Voici la fenêtre de visu avec une vue 2D à gauche et une vue 3D à droite, on voit la pièce "en fausse couleurs" avec les perçages dessinés sous forme de cercle en 2D, et les axes de perçage sur la vue 3D. On navigue dans chaque vue de façon indépendante.



Voici la fenêtre de visu avec uniquement la vue 3D



Voici la fenêtre de visu avec une vue 2D à gauche et une vue 3D à droite pour la saisie de la position des brides, qui se fait à la souris uniquement sur la vue 2D. On peut naviguer dans la vue 2D et 3D indépendament. Quand une bride est déplacée sur la vue 2D, on la voit bouger en même temps sur la vue 3D. Les hachures sur la vue 2D correspondent à la direction du sens du fil du bois. On utilise un peu de transparence avec des rectangles au dessus des brides qui représente une hauteur de fixation



Voici la fenêtre de visu avec une vue 2D à gauche et une vue 3D à droite pour la visualisation des phases d'usinage. Le jaune (en 2D, et en transparence sur la vue 3D) représente la surface à usiner, les traits en vert sur la vue 2D représentent les parcours d'outils ; la zone noire est la zone effectivement usinée.



Voici la fenêtre de visu avec deux vue 2D à gauche (vue de dessus et vue en coupe) et une vue 3D à droite pour la visualisation de la simulation d'usinage. Les 3 vues permettent de bien visualiser un parcours de la fraise (polyline fermée). On navigue dans la vue 3D de façon indépendante, mais les deux vues 2D sont liées car elles partagent l'axe X (si je bouge une des vues 2D, le mouvement de l'axe X est fait dans l'autre vue)



Voici la fenêtre de visu avec uniquement la vue 3D d'une pièce en "vraie 3D" (et pas seulement en 2.5D) :



Voici la fenêtre de visu avec uniquement la vue 3D d'une pièce en "vraie 3D" en mode "debug", c'est à dire avec la face externe de chaque triangle en vert et la face interne en rouge (j'ai zoomé pour "rentrer" dans une pièce et voir l'intérieur) :



Pour résumer c'est moche mais "parlant" du point de vue mécanique.

Aurais-tu un tutoriel particulier à me recommander sur Open GL3 (en français ou en anglais) ?

[Kannagi]

Jolie projet en tout cas

sur DVP , il y'a un tutoriel là dessus :
https://opengl.developpez.com/tutori...engl-tutorial/

[Bousk]

s'il y a des défauts (typiquement des triangles mal raccordés, par exemple dans une pièce 3D qui n'est pas "étanche" alors qu'elle le devrait) on veut qu'ils soient bien visibles, pour vérifier si une pièce est bien ou mal modélisée.

Tu sais, dans un jeu, si un model a un problème, on va pas les corriger avec un algo mais le renvoyer à l'artiste.

[Mat.M]

Vous me conseillez quoi ?

Comme Kannagi je n'arrive pas trop bien à saisir le problème.
Si le projet consiste à afficher des lignes, des listes de triangles bref des objets 3d éclairés et affichés en 3d avec les transformations classiques bref ce que fait Open GL pas besoin je pense d'avoir recours à des API plus perfectionnées.
Le plus important c'est que le projet soit vraiment fonctionnel c'est pas comme pour un projet de jeu où contrairement à un outil de CAO, dans un jeu le rendu final à l'écran ça compte beaucoup.
Par contre ça semble être un beau projet

[electroremy]

Merci pour vos réponses

Dans un premier temps je vais essayer de faire de l'OpenGL 3 avec ma lib OpenTK actuelle ; la lib est plus récente que la date de sortie d'OpenGL3, et je retrouve dans l'objet GL d'OpenTK les fonctions liées aux shaders donc à priori c'est bon.

En effet, j'en avais un peu bavé pour intégrer OpenTK et avoir une fenêtre avec plusieurs zones d'affichage OpenGL indépendantes, tout en gérant la souris et le clavier de façon cohérente, et sans avoir des affichages redondants à cause d'évènements multiples
Du coup si j'y parvient de cette façon je n'aurais pas à remettre en cause mon IHM ça sera plus simple.

Sinon, je passerais à une version plus récente d'OpenTK, il devrait y avoir un nombre de changements limité.

Il faudra y passer un certain temps car il y a une rupture entre OpenGL1 et OpenGL3.
Je commencerais par la visu 3D "vraie 3D", c'est là où j'ai le plus de triangles et en même temps où le code est le plus simple (juste une liste de triangles, pas d'édition)
Ca permettra d'évaluer le gain en vitesse

Mon projet est une sorte de petit Open Scad maison, avec des fonctions un peu particulières correspondant exactement à ce que j'ai besoin de faire.
A l'origine il servait à faire de l'usinage 2.5D à partir d'une image quelquonque.
Puis je l'ai amélioré avec une partie génération vectorielle directe en plus de l'image.
Lorsque j'ai acquis une imprimante 3D, j'ai ajouté un export en STL pour imprimer en 3D ces pièces 2.5D, puis, créé un petit module de fonctions à part pour faire mes pièces en "vraie 3D".

Dernièrement, je me suis amusé à faire des lithophanies.
Le principe d'une lithophanie c'est de fabriquer une pièce fine avec une épaisseur variable en fonction du niveau de gris d'une image, pour obtenir des logos ou des photos "lumineuses"
Je peux visualiser le résultat en 3D normale ou avec les couleurs d'origine.
Ca génère un grand nombre de triangle... d'où me besoin de faire quelque chose de plus rapide que OpenGL1

Voici quelques copies d'écran et photo :

L'image de départ, mon image de profil (en basse résolution, exprès pour bien voir les triangles) :



Le résultat après traitement :



La pièce avec l'image en "haute résolution" :





Une photo de l'impression 3D en ABS blanc :



Voilà ce que ça donne avec un éclairage arrière, par transparence :





On voit que c'est mieux avec la gravure côté visible et l'éclairage côté lisse, donc j'aurais du imprimer la pièce à l'endroit et pas en miroir.

On peut aussi faire une lithophanie cylindrique, voici une petite lampe de chevet imprimée en 3D selon ce principe, les filetages et taraudages ont été imprimés en 3D, les seules pièces mécaniques non imprimées en 3D sont 3 vis M6 pour fixer le support des rubans à led dans le socle :







A bientôt