Wie bekommt man alle 24 Rotationen eines 3-dimensionalen Arrays?

Question

Ich habe ein 3-dimensionales Array. Betrachten Sie es als einen Ziegelstein. Es gibt 24 mögliche Drehungen dieses Ziegels (die seine Kanten parallel zu den Koordinatenachsen halten). Wie generiere ich alle entsprechenden 3-dimensionalen Arrays?

Answer 1

Sie können Rotationsmatrizen verwenden. Drehen eines 3D-Arrays um die X-Achse bedeutet, dass das Element an Position (i,j,k) auf Position (i,-k,j) abgebildet wird. Natürlich, wenn Ihr Array 0-indiziert ist, müssen Sie wahrscheinlich -k durch size-1-k oder etwas ähnliches ersetzen.

In ähnlicher Weise wird die Drehung um die y-Achse (i,j,k) zu (k,j,-i). Diese zwei Rotationen können als Matrizen dargestellt werden. Für die X-Achsen-Rotation:

|i'| |1 0 0| |i| 
|j'| = |0 0 -1|*|j| 
|k'| |0 1 0| |k| 

Und für die y-Achsen-Rotation:

|i'| |0 0 1| |i| 
|j'| = |0 1 0|*|j| 
|k'| |-1 0 0| |k| 

Jede allgemeine Drehung kann als eine Folge von diesen beiden Rotationen beschrieben. Wenn Sie nacheinander zwei Rotationen anwenden, multiplizieren Sie einfach die 3x3-Matrizen. Also, wenn Sie alle möglichen Produkte von ihnen finden, würden Sie 24 Matrizen (einschließlich der Identität) erhalten, jeder entspricht einer gültigen Rotation Ihres Arrays. Es ist ein wenig schwierig, alle möglichen Multiplikationen zu finden, weil sie nicht pendeln.

Ich denke, man kann nur Brute-Force alle Produkte der Form (A^p)*(B^q)*(A^r)*(B^s), wobei A und B sind die beiden Matrizen vor und p,q,r,s ihre Kräfte sind, und der Bereich von 0 bis 3 (Potenzieren A oder B bis 4 werden sie nehmen zurück zur Identitätsmatrix).

Auf diese Weise können Sie alle 24 gültigen Rotationsmatrizen generieren und das 3D-Array mit jedem von ihnen drehen. Achten Sie dabei darauf, die negativen Indizes so zu verschieben, dass Sie nicht außerhalb der Grenzen zugreifen.

Answer 2

Ein Würfel (ein halbes Würfelpaar) ist praktisch, um die 24 verschiedenen Orientierungen zu beobachten und kann Operationssequenzen vorschlagen, um diese zu erzeugen. Sie werden sehen, dass eine beliebige der sechs Flächen die oberste sein kann und die darunter liegenden Seiten in vier verschiedene Himmelsrichtungen gedreht werden können. Lassen Sie uns zwei Operationen bedeuten: von Ihnen „ drehen“ und „Rolle“, wo wiederum die Düse um die z-Achse von einem Kardinal auf die nächste dreht und Rolle die 90 dreht sterben ° weg, so das Auswärts-Gesicht wird zur Unterseite und das Nah-Gesicht zur Oberseite. Diese Operationen können unter Verwendung von Rotationsmatrizen ausgedrückt werden, wie in der Antwort von Felipe Lopes erwähnt, oder können als einfache Funktionen ausgedrückt werden, die, wenn sie gegeben sind (x, y, z), zurückkehren (-y, x, z) oder (x, z, - y) jeweils.

Wenn Sie den Würfel mit 1 auf der nahen Seite, 2 auf der rechten und 3 auf der oberen Seite platzieren, werden Sie feststellen, dass die folgende Schrittfolge die zwölf verschiedenen Orientierungen mit 1, 2 oder 3 Punkten erzeugt oben: RTTTRTTTRTTT. Dann legt die Sequenz RTR 6, 4, 5 offen, wo ursprünglich 1, 2, 3 waren, und eine Wiederholung der Sequenz RTTTRTTTRTTT erzeugt die zwölf Orientierungen mit 4, 5 oder 6 Punkten oben. Die genannte Sequenz ist in den folgenden Python-Code eingebettet.

def roll(v): return (v[0],v[2],-v[1]) 
def turn(v): return (-v[1],v[0],v[2]) 
def sequence (v): 
    for cycle in range(2): 
     for step in range(3): # Yield RTTT 3 times 
      v = roll(v) 
      yield(v)   # Yield R 
      for i in range(3): # Yield TTT 
       v = turn(v) 
       yield(v) 
     v = roll(turn(roll(v))) # Do RTR 

p = sequence((1, 1, 1)) 
q = sequence((-1,-1, 1)) 
for i in sorted(zip(p,q)): 
    print i 

Die Begründung für eine sortierte Liste von transformierten Punktpaare Ausdrucken ist zweifach: (i) eine beliebige Flächenorientierung durch die Positionen von zwei seiner Ecken festgelegt werden können; (ii) es ist dann einfach, die Eindeutigkeit jedes Paares zu prüfen, z. B. durch Rohrleitungsausgabe an uniq.

Hier ist, wie die sortierte Ausgabe beginnt:

((-1, -1, -1), (-1, 1, 1)) 
((-1, -1, -1), (1, -1, 1)) 
((-1, -1, -1), (1, 1, -1)) 
((-1, -1, 1), (-1, 1, -1)) 
((-1, -1, 1), (1, -1, -1)) 
((-1, -1, 1), (1, 1, 1)) 
((-1, 1, -1), (-1, -1, 1)) 
((-1, 1, -1), (1, -1, -1)) 
((-1, 1, -1), (1, 1, 1))