Algorithme de vue éclatée pour CAO

Question

Je suis en train de créer un programme pour visualiser des modèles CAO 3D et je voudrais intégrer des vues éclatées automatisées. Tous les assemblages qui seront vus sont axi-symétriques. Certains ne peuvent pas être, mais la majorité le sont. Je voudrais comprendre un algorithme pour déplacer automatiquement des pièces dans un ensemble dans une position de vue éclatée. Voici un exemple de ce que je veux réaliser grâce à un algorithme (moins les étiquettes bien sûr):

La seule valeur que je dois travailler avec le centre de la zone de délimitation de chaque partie. Si plus d'informations que cela est nécessaire, je peux calculer plus d'informations, mais il semble que cela devrait suffire. L'approche approximative que j'ai en tête est de calculer un vecteur de l'origine de l'assemblage au centre de chaque partie le long de l'axe axi-symétrique, puis de calculer un vecteur radial au centre de la pièce par rapport à l'axe central. À partir de là, je devrais trouver un calcul qui permettrait d'ajuster la position de chaque partie le long d'une combinaison de ces deux vecteurs. C'est la partie où je ne suis pas sûr de la direction à suivre. L'image que j'ai incluse montre la fonctionnalité exacte que je voudrais, mais je veux être en mesure de mettre à l'échelle la position par n'importe quelle valeur flottante pour agrandir ou contracter la vue éclatée, avec 1.0 étant le modèle assemblé original. Des idées?

Answer 1

Votre question est assez large et donc mon explication est devenue assez longue. Je vais proposer deux variantes d'un algorithme d'explosion pour le traitement axial et radial.

Pour les illustrer par un exemple que je vais utiliser les numéros suivants (boîtes englobantes le long de l'axe seulement, seulement cinq parties):

P1: [ 0,10] (battery) 
P2: [10,14] (motor) 
P3: [14,16] (cog) 
P4: [16,24] (bit holder) 
P5: [18,26] (gear casing) 

Alors que les pièces P1-P4 toucher exactement les uns des autres, et P4P5 en fait se chevauchent.

Le premier est un algorithme qui met fondamentalement à l'échelle les distances d'un facteur, tel que vous l'avez proposé. Il souffrira si la taille des pièces est très différente dans un assemblage mais aussi pour des pièces qui se chevauchent (par exemple dans votre exemple le long de l'axe, l'extension du cercle cog est beaucoup plus petite que le porte-embout). Laissez le facteur d'échelle être f, puis le centre de chaque zone de délimitation est mis à l'échelle par f, mais l'extension ne l'est pas. Pièces seraient alors

P1: 5 + [-5,5] => P1': 5*f + [-5,5] 
P2: 12 + [-2,2] => P2': 12*f + [-2,2] 
P3: 15 + [-1,1] => P3': 15*f + [-1,1] 
P4: 20 + [-4,4] => P4': 20*f + [-4,4] 
P5: 22 + [-4,4] => P5': 22*f + [-4,4] 

La distance entre les parties P1'-P4 est alors donné par

P2' - P1' : (12*f-2) - (5*f+5) = 7*(f-1) 
P3' - P2' : (15*f-1) - (12*f+2) = 3*(f-1) 
P4' - P3' : (20*f-4) - (15*f+1) = 5*(f-5) 

Comme prévu, la différence est nulle pour f=0 mais pour une vue éclatée, voir la distance dépend fortement des tailles des parties séparées. Je ne pense pas que cela sera trop beau si la variation de taille est plus grande.

En outre, pour les parties qui se chevauchent

P5' - P4' : (22*f-4) - (20*f+4) = 2*f-8 

qu'ils se chevauchent encore f raisonnable.

Une autre possibilité consisterait à définir non pas un facteur d'échelle pour l'axe, mais une distance partielle constante d.Ensuite, boîtes englobantes seraient alignées comme les suivantes:

P1': [ 0,10] 
P2': [10,14]+d 
P3': [14,16]+2*d 
P4': [16,24]+3*d 
P5': [18,26]+4*d+6 

Notez que dans la dernière ligne, nous avons ajouté 24-8=6, à savoir le chevauchement afin de différencier les deux parties. Bien que cet algorithme traite les cas mentionnés ci-dessus d'une manière (à mon avis) meilleure, nous devons apporter un soin particulier aux parties qui couvrent plusieurs autres parties et ne doivent pas être incluses dans le groupe (par exemple poignée dans votre cas) .

Une possibilité consisterait à regrouper les parties en groupes dans une première étape, puis à appliquer l'algorithme à la zone de délimitation de ces groupes. Ensuite, il peut être appliqué aux parties de chaque groupe, en omettant les parties qui couvrent plus d'un sous-groupe. Dans votre cas, il serait (note regroupement imbriqué est possible):

[ 
    ([battery,(switch,circuit switch),motor],handle top), 
    motor cog, 
    tri-cog, 
    red-cog, 
    circle-cog, 
    bit-holder, 
    (gear casing,spring,lock knob) 
] 

Vous pouvez voir que je vous ai présenté deux différents types de groupes: parties/groupes dans des crochets sont traités par l'algorithme, à savoir un espacement est ajouté entre chaque partie/sous-groupe à l'intérieur d'un tel groupe, tandis que les groupes à l'intérieur des accolades rondes ne sont pas explosés. Jusqu'à présent, nous n'avons pas traité l'explosion radiale car elle se décolle bien du traitement de l'axe. Mais encore une fois les mêmes approches peuvent être utilisées pour l'explosion radiale. Mais encore une fois, à mon avis, le second algorithme donne des résultats plus agréables. Par exemple. les groupes peuvent se faire comme suit pour le traitement radial:

[ 
    (battery,switch,<many parts>,gear casing), 
    (switch,spring), 
    (handle top, lock knob) 
] 

Dans ce cas, nous ajouter un composant supplémentaire r à tous les centres radiaux dans le deuxième groupe et 2*r à tous dans le troisième groupe.

Notez que l'algorithme de mise à l'échelle simple fonctionne sans guide d'utilisateur spécial (une fois que le facteur d'échelle est donné) tandis que le second utilise des informations supplémentaires (le regroupement). J'espère que cette explication plutôt longue vous donnera quelques idées sur la façon de procéder. Si mes explications ne sont pas claires à un moment ou si vous avez d'autres questions, n'hésitez pas à commenter.