Algoritmo di vista esplosa per CAD

Question

Sto realizzando un programma per visualizzare modelli CAD 3D e vorrei creare viste esplose automatizzate. Tutti gli assiemi che verranno visualizzati sono assi-simmetrici. Alcuni potrebbero non esserlo, ma la maggioranza lo è. Mi piacerebbe capire un algoritmo per spostare automaticamente le parti in un assieme in una posizione di vista esplosa. Ecco un esempio di quello che voglio raggiungere attraverso un algoritmo (meno le etichette, ovviamente):

L'unico valore che devo lavorare con il centro del rettangolo di selezione di ogni parte. Se sono necessarie più informazioni di quelle, posso calcolare più informazioni, ma sembra che dovrebbe essere sufficiente. L'approccio approssimativo che ho in mente è quello di calcolare un vettore dall'origine dell'assieme al centro di ciascuna parte lungo l'asse assi-simmetrico, quindi calcolare un vettore radiale al centro della parte rispetto all'asse centrale. Da lì, avrei bisogno di calcolare alcuni calcoli che sarebbero in grado di scalare la posizione di ciascuna parte lungo una combinazione di questi due vettori. Questa è la parte in cui non sono abbastanza sicuro su quale direzione andare con questo. L'immagine che ho incluso mostra la funzionalità esatta che mi piacerebbe, ma voglio essere in grado di scalare la posizione di qualsiasi valore float per espandere o contrarre la vista esplosa, con 1.0 che è il modello assemblato originale. Qualche idea?

Answer 1

La tua domanda è abbastanza ampia e quindi la mia spiegazione è diventata in qualche modo lunga. Proporrò due varianti di un algoritmo di esplosione per il trattamento sia assiale che radiale.

Per illustrare loro con un esempio userò i seguenti numeri (quadri delimitatori lungo l'asse solo, solo cinque parti):

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

Mentre parti P1-P4 esattamente toccarsi, P4 e P5 effettivamente si sovrappongono.

Il primo è un algoritmo che sostanzialmente ridimensiona le distanze di un fattore, come proposto. Ne risentirà se la dimensione dei pezzi è molto diversa in un assieme ma anche per le parti che si sovrappongono (ad esempio nell'esempio lungo l'asse l'estensione dell'ingranaggio circolare è molto più piccola del portainserti).

Lascia che il fattore di scala sia f, quindi il centro di ogni riquadro di delimitazione viene ridimensionato da f, ma l'estensione non lo è. Parti allora sarebbero

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 distanza tra le parti P1' a P4 è quindi dato dalla

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) 

Come previsto la differenza è zero per f=0 ma per qualsiasi Esploso la distanza dipende fortemente dalle dimensioni delle parti separate. Non penso che questo sembrerà troppo bello se la variazione delle dimensioni è maggiore.

Inoltre per parti sovrapposte

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

ancora sovrappongono per ragionevoli f.

Un'altra possibilità sarebbe quella di definire non un fattore di scala per l'asse ma una distanza parziale costante d.Poi riquadri di delimitazione vengono allineate come la seguente:

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

noti che nell'ultima riga abbiamo aggiunto 24-8=6, cioè la sovrapposizione al fine di differenziare le due parti.

Mentre questo algoritmo gestisce i casi sopra menzionati in un modo (a mio parere) migliore, dobbiamo aggiungere un'attenzione speciale alle parti che coprono più parti e che non devono essere incluse nel raggruppamento (ad es. Gestire la parte superiore nel caso) .

Una possibilità sarebbe quella di raggruppare le parti in gruppi in un primo passaggio e quindi applicare l'algoritmo al riquadro di delimitazione di questi gruppi. Successivamente, può essere applicato nuovamente alle parti di ciascun gruppo, omettendo le parti che coprono più di un sottogruppo. Nel vostro caso sarebbe (nota raggruppamento annidata è possibile):

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

Si potrebbe vedere che ho introdotto due diversi tipi di gruppi: componenti/gruppi in parentesi quadre sono gestite dall'algoritmo, cioè una spaziatura è aggiunto tra ogni parte/sottogruppo all'interno di tale gruppo, mentre i gruppi all'interno di parentesi tonde non sono esplosi.

Fino ad ora non abbiamo gestito l'esplosione radiale perché si disaccoppia bene dal trattamento dell'asse. Ma anche in questo caso entrambi gli approcci possono essere utilizzati anche per l'esplosione radiale. Ma ancora una volta secondo me il secondo algoritmo produce risultati più piacevoli. Per esempio. i gruppi possono essere eseguite come segue per trattamento radiale:

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

In questo caso si potrebbe aggiungere un elemento supplementare r a tutti i centri radiali nel secondo gruppo e 2*r a tutti nel terzo gruppo.

Si noti che l'algoritmo di ridimensionamento semplice viene eseguito senza una guida utente speciale (una volta assegnato il fattore di scala) mentre il secondo utilizza informazioni aggiuntive (il raggruppamento).

Spero che questa spiegazione piuttosto lunga ti dia alcune idee su come procedere ulteriormente. Se le mie spiegazioni non sono chiare a un certo punto o se hai ulteriori domande non esitare a commentare.