---

Suche die Erleuchtung, please HELP!

Eingabefelder Verschiebung XYZ sowie Drehung XYZ
Assembly Dessign -> Verschieben oder drehen -> Position

Die Werte des Move-Befehles werden im vbs (Makros) durch ein array übergeben. Welche Werte geben die Drehung XYZ an???

Rem Dim arrayOfVariantOfDouble1(11)
arrayOfVariantOfDouble1(0) = ?
arrayOfVariantOfDouble1(1) = ?
arrayOfVariantOfDouble1(2) = ?
arrayOfVariantOfDouble1(3) = ?
arrayOfVariantOfDouble1(4) = ?
arrayOfVariantOfDouble1(5) = ?
arrayOfVariantOfDouble1(6) = ?
arrayOfVariantOfDouble1(7) = ?
arrayOfVariantOfDouble1(8) = ?
arrayOfVariantOfDouble1(9) = X-Verschiebung
arrayOfVariantOfDouble1(10) = Y-Verschiebung
arrayOfVariantOfDouble1(11) = Z-Verschiebung
move1.Apply arrayOfVariantOfDouble1

Würde mich ganz doll über eine Antwort freuen!?!  )

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

(0) bis (2) geben den Vektor der x-Achse an
(3) bis (5) geben den Vektor der y-Achse an
(6) bis (8) geben den Vektor der z-Achse an
(9) bis (11) geben den Nullpunkt an

Das heißt, die

- Rotation um die x-Achse wird über die Vektoren der y- und z-Achse
- Rotation um die y-Achse wird über die Vektoren der x- und z-Achse
- Rotation um die z-Achse wird über die Vektoren der x- und y-Achse

beschrieben.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Wie gibt man einen Vektor mit 3 Zahlen an? Hätte da 2 Zahlen erwartet!

Habe ein alpha und ein beta:
alpha = Drehung um Z Achse
beta = Drehung um X Achse

Wie kann ich damit die Vektoren berechnen?
Kannst Du mir ein Beispiel machen?

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

ein Raumvektor wird immer über 3 Koordinaten beschrieben.
In der Matrix sollten zudem immer Einheitsvektoren verwendet werden, da man daraus dann sehr leicht den Winkel berechnen kann, da dann in der Matrix die Richtungskosinusse zum Referenzachsensystem stehen.
Dann ergeben sich aus

arrayOfVariantOfDouble1(0) = x1
arrayOfVariantOfDouble1(1) = x2
arrayOfVariantOfDouble1(2) = x3
arrayOfVariantOfDouble1(3) = y1
arrayOfVariantOfDouble1(4) = y2
arrayOfVariantOfDouble1(5) = y3
arrayOfVariantOfDouble1(6) = z1
arrayOfVariantOfDouble1(7) = z2
arrayOfVariantOfDouble1(8) = z3

die folgenden Winkel:

alpha_x = arccos(x1)      alpha_y = arccos(x2)          alpha_z = arccos(x3)
beta_x = arccos(y1)        beta_y = arccos(y2)          beta_z = arccos(y3)
gamma_x = arccos(z1)    gamma_y = arccos(z2)      gamma_z = arccos(z3)

Am Beispiel von zwei Koordinatensystem K und K' sieht das wie folgt aus:

alpha_x : Winkel zwischen x'-Achse und x-Achse
alpha_y : Winkel zwischen x'-Achse und y-Achse
alpha_z : Winkel zwischen x'-Achse und z-Achse

beta_x : Winkel zwischen y'-Achse und x-Achse
beta_y : Winkel zwischen y'-Achse und y-Achse
beta_z : Winkel zwischen y'-Achse und z-Achse

gamma_x : Winkel zwischen z'-Achse und x-Achse
gamma_y : Winkel zwischen z'-Achse und y-Achse
gamma_z : Winkel zwischen z'-Achse und z-Achse

Ich hoffe, das ist verständlich.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

arrayOfVariantOfDouble1(0) = COS(Y)*SIN(P)*COS(R)+SIN(Y)*SIN(R)
arrayOfVariantOfDouble1(1) = SIN(Y)*SIN(P)*COS(R)-COS(Y)*SIN(R)
arrayOfVariantOfDouble1(2) = COS(P)*COS(R)
arrayOfVariantOfDouble1(3) = SIN(Y)*COS(R)-COS(Y)*SIN(P)*SIN(R)
arrayOfVariantOfDouble1(4) = -COS(Y)*COS(R)-SIN(Y)*SIN(P)*SIN(R)
arrayOfVariantOfDouble1(5) = -COS(P)*SIN(R)
arrayOfVariantOfDouble1(6) = COS(Y) *COS(P)
arrayOfVariantOfDouble1(7) = SIN(Y)*COS(P)
arrayOfVariantOfDouble1(8) = -SIN(P)

-> Ich glaub ich habs!?! :o) Keine Ahnung wieso ich nicht auf Vektoren gekommen bin!?!

Ein ganz dolles Dankeschööön an Stefan für die prompte Hilfe!!?!

Gruss
David von Gunten

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

jetzt weiß ich nicht, was Du meinst.

Was sind Y, P und R?

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

http://www.resourcecode.de/view.php?id=760

Gruss
David von Gunten

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

da ist leider ein kleiner Fehler drin. Diese Berechnung basiert auf einem linkshändigen Achsensystem. CATIA rechnet aber mit rechtshändigen Achsensystemen. Du mußt das also noch umrechnen.

Aber Du schaffst das schon.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Sali Steffen,
es richtets sich alles schön aus... mur wie Du sagst, etwas stimmt noch nicht 100%.
Kann ich die Vektoren *-1 rechnen? *lol*

Für einen Tip währe ich dankbar!

Grüsse aus Zürich

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Ach Mensch, meine Bauteile verquetsch und zerreisst es... *grmbl*

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

alle Vektoren mal -1 nehmen, würde bedeuten, das es gespiegelt wird. Es ist aber nur eine Achse invertiert.

Die ganze Berechnung ist mit der Matrizenberechnung eigentlich ganz einfach, auch wenn in dem verlinkten Beitrag ( http://www.resourcecode.de/view.php?id=760 bewußt darauf verzichtet wurde.

Ich beginne hier an der Stelle der Drehmatrizen der einzelnen Achsen (Das kann man ja noch nachvollziehen über simple Trigonometrie). Dabei verwende ich die Bezeichner aus o.g. Beitrag.

Drehung um die z-Achse (Winkel Y):

        vf          vr          vu
_______________________
x |  cos(Y)    sin(Y)      0
y |  -sin(Y)    cos(Y)    0
z |      0          0          1

Drehung um die y-Achse (Winkel P):

        vf          vr          vu
_______________________
x |  cos(P)      0        -sin(P)
y |    0            1          0
z |  sin(P)        0        cos(P)

Drehung um die x-Achse (Winkel R):

        vf          vr          vu
_______________________
x |    1          0            0
y |    0        cos(R)  sin(R)
z |    0        -sin(R)  cos(R)

Damit sind die 3 Drehungen definiert. Eine Kombination von Transformationen ist nichts weiter als die Multiplikation der einzelnen Transformationsmatrizen.
Matrizen werden multipliziert, indem jeweils ein Zeilenvektor mit einem Spaltenvektor multipliziert wird. Kombiniert man jetzt die Drehung von Y und P ergibt sich folgende Matrix:

            vf                    vr                    vu
________________________________________
x |  cos(Y)*cos(P)      sin(Y)        -cos(Y)*sin(P)
y |  -sin(Y)*cos(P)      cos(Y)        sin(Y)*sin(P)
z |  sin(P)                      0            cos(P)

Jetzt dazu noch die Drehung R ergibt:

                  vf                                    vr                                                        vu
___________________________________________________________________________________
x |    cos(Y)*cos(P)      sin(Y)*cos(R)+cos(Y)*sin(P)*sin(R)        sin(Y)*sin(R)-cos(Y)*sin(P)*cos(R)
y |    -sin(Y)*cos(P)      cos(Y)*cos(R)-sin(Y)*sin(P)*sin(R)          cos(Y)*sin(R)+sin(Y)*sin(P)*cos(R)
z |    sin(P)                  -cos(P)*sin(R)                                      cos(P)*cos(R)

Umgekehrt kann man, wenn die Matrize schon mit Zahlen gefüllt ist, die Winkel berechnen.

P = arcsin(vf.z)
Y = arccos(vf.x / cos(P))
R = arccos(vu.z / cos(P))

So das soll es erstmal gewesen sein. Ich hoffe, das ganze ist verständlich für Dich.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Ich habe noch was vergessen. Das Ganze in CATIA-Sprache sieht dan so aus:

arrayOfVariantOfDouble1(0) = cos(Y)*cos(P)
arrayOfVariantOfDouble1(1) = sin(Y)*cos(R)+cos(Y)*sin(P)*sin(R)
arrayOfVariantOfDouble1(2) = sin(Y)*sin(R)-cos(Y)*sin(P)*cos(R)
arrayOfVariantOfDouble1(3) = -sin(Y)*cos(P)
arrayOfVariantOfDouble1(4) = cos(Y)*cos(R)-sin(Y)*sin(P)*sin(R)
arrayOfVariantOfDouble1(5) = cos(Y)*sin(R)+sin(Y)*sin(P)*cos(R)
arrayOfVariantOfDouble1(6) = sin(P)
arrayOfVariantOfDouble1(7) = -cos(P)*sin(R)
arrayOfVariantOfDouble1(8) = cos(P)*cos(R)

wobei P, Y und R im Bogenmaß anzugegeben sind also P=Winkel*PI/180.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Sali Steffen,
solange ich in den Ebenen bleibe (Winkel 90°/ 180°/ etc.) funktioniert alles , sobald ich aber einen Winkel wie 45° eingebe funktioniert es nicht.
Habe 2 Winkel
alpha: um Z-Achse im Uhrzeigersinn -> Yaw
beta: um Y-Achse im Gegenuhrzeigersinn -> Pitch
Roll setze ich auf 0
wd ist der Abstand vom Fokuspunkt, welcher durch fpx, fpy und fpz bestimmt wird.

Meine Tabelle:
wd alpha beta fpx fpy fpz 
253  0  0  0  0  0
253  90  0  0  0  0
253 180  0  0  0  0
253 270  0  0  0  0
253  0  90  0  0  0
253  0 -90  0  0  0
253 -45  45  0  0  0
253  45  45  0  0  0
253 135  45  0  0  0
253 225  45  0  0  0
253  0 -45  0  0  0
253  90 -45  0  0  0
253 180 -45  0  0  0
253 270 -45  0  0  0

Y = alpha * PI / 180
P = beta * PI / 180
R = 0

Rem -> R EbeneYZ um X
arrayOfVariantOfDouble1(0) = cos(Y)*cos(P*-1)
arrayOfVariantOfDouble1(1) = sin(Y)*cos(R)+cos(Y)*sin(P*-1)*sin(R)
arrayOfVariantOfDouble1(2) = sin(Y)*sin(R)-cos(Y)*sin(P*-1)*cos(R)

Rem -> P EbeneXZ um Y
arrayOfVariantOfDouble1(3) = -sin(Y)*cos(P*-1)
arrayOfVariantOfDouble1(4) = cos(Y)*cos(R)-sin(Y)*sin(P*-1)*sin(R)
arrayOfVariantOfDouble1(5) = cos(Y)*sin(R)+sin(Y)*sin(P*-1)*cos(R)

Rem -> Y EbeneXY um Z
arrayOfVariantOfDouble1(6) = sin(P*-1)
arrayOfVariantOfDouble1(7) = -cos(P*-1)*sin(R)
arrayOfVariantOfDouble1(8) = cos(P*-1)*cos(R)

XYZ wird durch einen Fokuspunkt, dessen Abstand wd und der Winkel alpha und beta berechnet:

arrayOfVariantOfDouble1(9) = fpx+cos(Y)*cos(P)*wd
arrayOfVariantOfDouble1(10) = fpy+sin(Y)*cos(P)*wd
arrayOfVariantOfDouble1(11) = fpz+sin(P)*wd

-> siehe http://www.ferrovac.com/wizard/index.htm  (shockwave wird benötigt)

Wieso haben die Franzosen die Drehrichtungen im Uhrzeigersinn, ist doch verkehrt!

Freundliche Grüsse
David von Gunten

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Rechen P*-1 weil die Winkel Angabe alpha welche ich verwende um die Z-Achse im Uhrzeigersinn gedreht wird. Die anderen Achsen im Gegenuhrzeigersinn!?!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Soory, das stimmt überhaupt nicht!!! Hab die *-1 rausgenommen, aber es klappt noch immer nicht!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Es stimmen alle Verschiebungen bezw. Drehungen, ausser die, welche in der ZX-Ebene, also um die Achse Y gedreht werden, diese sind verkehrt!?!

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Hallo vogy,

da ich bei meiner Rechnung keinen Fehler entdecken kann, sollten wir das Thema privat weiter diskutieren.
Ich schicke Dir über PM meine eMail-Adresse.

Gruß
Steffen

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP

---

Die Lösung:

Y = alpha*PI/180
P = beta*PI/180
R = 0

arrayOfVariantOfDouble1(0) = 1
arrayOfVariantOfDouble1(1) = 0
arrayOfVariantOfDouble1(2) = 0
arrayOfVariantOfDouble1(3) = 0
arrayOfVariantOfDouble1(4) = 1
arrayOfVariantOfDouble1(5) = 0
arrayOfVariantOfDouble1(6) = 0
arrayOfVariantOfDouble1(7) = 0
arrayOfVariantOfDouble1(8) = 1
arrayOfVariantOfDouble1(9) = wd
arrayOfVariantOfDouble1(10) = 0
arrayOfVariantOfDouble1(11) = 0
move1.Apply arrayOfVariantOfDouble1

arrayOfVariantOfDouble2(0) = cos(Y)*cos(P)
arrayOfVariantOfDouble2(1) = sin(Y)*cos(P)
arrayOfVariantOfDouble2(2) = sin(P)
arrayOfVariantOfDouble2(3) = -sin(Y)
arrayOfVariantOfDouble2(4) = cos(Y)
arrayOfVariantOfDouble2(5) = 0
arrayOfVariantOfDouble2(6) = -cos(Y)*sin(P)
arrayOfVariantOfDouble2(7) = -sin(Y)*sin(P)
arrayOfVariantOfDouble2(8) = cos(P)
arrayOfVariantOfDouble2(9) = 0
arrayOfVariantOfDouble2(10) = 0
arrayOfVariantOfDouble2(11) = 0
move2.Apply arrayOfVariantOfDouble2

arrayOfVariantOfDouble3(0) = 1
arrayOfVariantOfDouble3(1) = 0
arrayOfVariantOfDouble3(2) = 0
arrayOfVariantOfDouble3(3) = 0
arrayOfVariantOfDouble3(4) = 1
arrayOfVariantOfDouble3(5) = 0
arrayOfVariantOfDouble3(6) = 0
arrayOfVariantOfDouble3(7) = 0
arrayOfVariantOfDouble3(8) = 1
arrayOfVariantOfDouble3(9) = fpx
arrayOfVariantOfDouble3(10) = fpy
arrayOfVariantOfDouble3(11) = fpz
move3.Apply arrayOfVariantOfDouble3

Hallo Steffen,
in Deiner Lösung waren die Minuszeichen nicht korrekt gesetzt! Wir haben nun jede einzelne Drehung in jeweils einem Befehl umgesetzt, danach die Drehung um Z und Y zusammen genommen...

Freundliche Grüsse
Andreas Vaterlaus & David von Gunten

Eine Antwort auf diesen Beitrag verfassen (mit Zitat/Zitat des Beitrags) IP