create_pose T_create_pose CreatePose CreatePose create_pose (Operator)
Name
create_pose T_create_pose CreatePose CreatePose create_pose
— Erzeugen einer 3D-Lage (Pose).
Signatur
void CreatePose (const HTuple& TransX , const HTuple& TransY , const HTuple& TransZ , const HTuple& RotX , const HTuple& RotY , const HTuple& RotZ , const HTuple& OrderOfTransform , const HTuple& OrderOfRotation , const HTuple& ViewOfTransform , HTuple* Pose )
void HPose ::HPose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const HString& OrderOfTransform , const HString& OrderOfRotation , const HString& ViewOfTransform )
void HPose ::HPose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const char* OrderOfTransform , const char* OrderOfRotation , const char* ViewOfTransform )
void HPose ::HPose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const wchar_t* OrderOfTransform , const wchar_t* OrderOfRotation , const wchar_t* ViewOfTransform )
(Nur Windows)
void HPose ::CreatePose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const HString& OrderOfTransform , const HString& OrderOfRotation , const HString& ViewOfTransform )
void HPose ::CreatePose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const char* OrderOfTransform , const char* OrderOfRotation , const char* ViewOfTransform )
void HPose ::CreatePose (double TransX , double TransY , double TransZ , double RotX , double RotY , double RotZ , const wchar_t* OrderOfTransform , const wchar_t* OrderOfRotation , const wchar_t* ViewOfTransform )
(Nur Windows)
static void HOperatorSet .CreatePose (HTuple transX , HTuple transY , HTuple transZ , HTuple rotX , HTuple rotY , HTuple rotZ , HTuple orderOfTransform , HTuple orderOfRotation , HTuple viewOfTransform , out HTuple pose )
public HPose (double transX , double transY , double transZ , double rotX , double rotY , double rotZ , string orderOfTransform , string orderOfRotation , string viewOfTransform )
void HPose .CreatePose (double transX , double transY , double transZ , double rotX , double rotY , double rotZ , string orderOfTransform , string orderOfRotation , string viewOfTransform )
Beschreibung
create_pose create_pose CreatePose CreatePose CreatePose create_pose
erzeugt eine 3D-Lage Pose Pose Pose Pose pose pose
. Eine 3D-Lage
beschreibt eine starre 3D-Transformation, d.h. eine Transformation bestehend
aus einer beliebigen Translation und Rotation, mit 6 Parametern:
TransX TransX TransX TransX transX trans_x
, TransY TransY TransY TransY transY trans_y
und TransZ TransZ TransZ TransZ transZ trans_z
beschreiben die
Translation entlang der x-, y- und z-Achse, während RotX RotX RotX RotX rotX rot_x
,
RotY RotY RotY RotY rotY rot_y
und RotZ RotZ RotZ RotZ rotZ rot_z
die Rotation beschreiben.
3D-Lagen werden typischerweise für zwei Zwecke verwendet: Erstens zur
Beschreibung der Position und Orientierung eines Koordinatensystems relativ
zu einem anderen (z.B. die 3D-Lage eines Objektkoordinatensystems relativ
zum Kamerakoordinatensystem - kurz, die 3D-Lage des Objekts relativ zur
Kamera) und zweitens zur Beschreibung der Transformation von Koordinaten
zwischen Koordinatensystemen (z.B. die Transformation von Objektkoordinaten
in Kamerakoordinaten).
Darstellung der Orientierung (Rotation)
Eine 3D-Rotation um eine beliebige Achse kann mit drei Parametern in
verschiedener Weise dargestellt werden. HALCON stellt drei davon über den
Parameter OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
zur Auswahl: Falls der Wert 'gba' "gba" "gba" "gba" "gba" "gba"
übergeben wird, wird die Rotation durch die folgende Kette von Rotationen
beschrieben (siehe hom_mat3d_rotate hom_mat3d_rotate HomMat3dRotate HomMat3dRotate HomMat3dRotate hom_mat3d_rotate
für den Inhalt der
Rotationsmatrizen
):
wird in der
Fachliteratur auch Yaw-Pitch-Roll Konvention genannt.
Bitte beachten Sie, dass diese Kette auf zwei Arten „gelesen“ werden kann:
Wenn man von rechts startet, werden die Rotationen immer relativ zum globalen
(unveränderten oder „alten“) Koordinatensystem ausgeführt. D.h.,
kann wie folgt gelesen
werden: Erst wird um die z-Achse rotiert, dann um die „alte“ y-Achse und
schließlich um die „alte“ x-Achse. Falls die Kette dagegen von links nach
rechts gelesen wird, werden die Rotationen jeweils relativ zum lokalen
(„neuen“) Koordinatensystem ausgeführt. Dann liest sich
wie folgt: Erst wird um
die x-Achse rotiert, dann um die „neue“ y-Achse und schließlich um die
„neu(st)e“ z-Achse.
Von rechts nach links gelesen, entspricht
der folgenden Sequenz von
Operatoraufrufen:
hom_mat3d_identity(HomMat3DIdent) hom_mat3d_identity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) hom_mat3d_identity(HomMat3DIdent)
hom_mat3d_rotate(HomMat3DIdent, RotZ, 'z', 0, 0, 0, HomMat3DRotZ) hom_mat3d_rotate(HomMat3DIdent, RotZ, "z", 0, 0, 0, HomMat3DRotZ) HomMat3dRotate(HomMat3DIdent, RotZ, "z", 0, 0, 0, HomMat3DRotZ) HomMat3dRotate(HomMat3DIdent, RotZ, "z", 0, 0, 0, HomMat3DRotZ) HomMat3dRotate(HomMat3DIdent, RotZ, "z", 0, 0, 0, HomMat3DRotZ) hom_mat3d_rotate(HomMat3DIdent, RotZ, "z", 0, 0, 0, HomMat3DRotZ)
hom_mat3d_rotate(HomMat3DRotZ, RotY, 'y', 0, 0, 0, HomMat3DRotYZ) hom_mat3d_rotate(HomMat3DRotZ, RotY, "y", 0, 0, 0, HomMat3DRotYZ) HomMat3dRotate(HomMat3DRotZ, RotY, "y", 0, 0, 0, HomMat3DRotYZ) HomMat3dRotate(HomMat3DRotZ, RotY, "y", 0, 0, 0, HomMat3DRotYZ) HomMat3dRotate(HomMat3DRotZ, RotY, "y", 0, 0, 0, HomMat3DRotYZ) hom_mat3d_rotate(HomMat3DRotZ, RotY, "y", 0, 0, 0, HomMat3DRotYZ)
hom_mat3d_rotate(HomMat3DRotYZ, RotX, 'x', 0, 0, 0, HomMat3DXYZ) hom_mat3d_rotate(HomMat3DRotYZ, RotX, "x", 0, 0, 0, HomMat3DXYZ) HomMat3dRotate(HomMat3DRotYZ, RotX, "x", 0, 0, 0, HomMat3DXYZ) HomMat3dRotate(HomMat3DRotYZ, RotX, "x", 0, 0, 0, HomMat3DXYZ) HomMat3dRotate(HomMat3DRotYZ, RotX, "x", 0, 0, 0, HomMat3DXYZ) hom_mat3d_rotate(HomMat3DRotYZ, RotX, "x", 0, 0, 0, HomMat3DXYZ)
Dagegen entspricht die folgende Sequenz der Leserichtung von links nach
rechts:
hom_mat3d_identity(HomMat3DIdent) hom_mat3d_identity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) HomMat3dIdentity(HomMat3DIdent) hom_mat3d_identity(HomMat3DIdent)
hom_mat3d_rotate_local(HomMat3DIdent, RotX, 'x', HomMat3DRotX) hom_mat3d_rotate_local(HomMat3DIdent, RotX, "x", HomMat3DRotX) HomMat3dRotateLocal(HomMat3DIdent, RotX, "x", HomMat3DRotX) HomMat3dRotateLocal(HomMat3DIdent, RotX, "x", HomMat3DRotX) HomMat3dRotateLocal(HomMat3DIdent, RotX, "x", HomMat3DRotX) hom_mat3d_rotate_local(HomMat3DIdent, RotX, "x", HomMat3DRotX)
hom_mat3d_rotate_local(HomMat3DRotX, RotY, 'y', HomMat3DRotXY) hom_mat3d_rotate_local(HomMat3DRotX, RotY, "y", HomMat3DRotXY) HomMat3dRotateLocal(HomMat3DRotX, RotY, "y", HomMat3DRotXY) HomMat3dRotateLocal(HomMat3DRotX, RotY, "y", HomMat3DRotXY) HomMat3dRotateLocal(HomMat3DRotX, RotY, "y", HomMat3DRotXY) hom_mat3d_rotate_local(HomMat3DRotX, RotY, "y", HomMat3DRotXY)
hom_mat3d_rotate_local(HomMat3DRotXY, RotZ, 'z', HomMat3DXYZ) hom_mat3d_rotate_local(HomMat3DRotXY, RotZ, "z", HomMat3DXYZ) HomMat3dRotateLocal(HomMat3DRotXY, RotZ, "z", HomMat3DXYZ) HomMat3dRotateLocal(HomMat3DRotXY, RotZ, "z", HomMat3DXYZ) HomMat3dRotateLocal(HomMat3DRotXY, RotZ, "z", HomMat3DXYZ) hom_mat3d_rotate_local(HomMat3DRotXY, RotZ, "z", HomMat3DXYZ)
wird in der
Fachliteratur auch Roll-Pitch-Yaw Konvention genannt.
Falls in OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
der Wert 'abg' "abg" "abg" "abg" "abg" "abg" übergeben wird,
wird die Rotation durch die folgende Transformationskette dargestellt:
Falls der Wert 'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez" in OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
übergeben
wird, werden die Rotationsparameter RotX RotX RotX RotX rotX rot_x
, RotY RotY RotY RotY rotY rot_y
und
RotZ RotZ RotZ RotZ rotZ rot_z
als die x-, y- und z-Komponente des so genannten
Rodriguez-Rotationsvektors interpretiert. Die Richtung dieses Vektors
definiert die (beliebige) Rotationsachse, seine Länge den Rotationswinkel
(mathematisch positive Orientierung). HALCON verwendet eine Variation des
Rodriguez-Vektors, in der die Länge des Vektors gleich dem Tangens des halben
Winkels ist:
Bitte beachten Sie, dass diese Posen-Darstellung nicht immer eindeutig ist,
d.h. mehrere Posen-Darstellungen beschreiben dieselbe homogene
Transformationsmatrix. Beispielsweise für
mit
haben die folgenden zwei Posen die gleiche Darstellung als homogene Transformationsmatrix:
create_pose(0, 0, 0, 30, 90, 54, 'Rp+T', 'gba', 'point', Pose1) create_pose(0, 0, 0, 30, 90, 54, "Rp+T", "gba", "point", Pose1) CreatePose(0, 0, 0, 30, 90, 54, "Rp+T", "gba", "point", Pose1) CreatePose(0, 0, 0, 30, 90, 54, "Rp+T", "gba", "point", Pose1) CreatePose(0, 0, 0, 30, 90, 54, "Rp+T", "gba", "point", Pose1) create_pose(0, 0, 0, 30, 90, 54, "Rp+T", "gba", "point", Pose1)
create_pose(0, 0, 0, 17, 90, 67, 'Rp+T', 'gba', 'point', Pose2) create_pose(0, 0, 0, 17, 90, 67, "Rp+T", "gba", "point", Pose2) CreatePose(0, 0, 0, 17, 90, 67, "Rp+T", "gba", "point", Pose2) CreatePose(0, 0, 0, 17, 90, 67, "Rp+T", "gba", "point", Pose2) CreatePose(0, 0, 0, 17, 90, 67, "Rp+T", "gba", "point", Pose2) create_pose(0, 0, 0, 17, 90, 67, "Rp+T", "gba", "point", Pose2)
Alternativ können Rotationen auch durch homogene Transformationsmatrizen oder
Quaternionen (axis_angle_to_quat axis_angle_to_quat AxisAngleToQuat AxisAngleToQuat AxisAngleToQuat axis_angle_to_quat
) dargestellt werden.
Entsprechende homogene Transformationsmatrix
Mit dem Operator pose_to_hom_mat3d pose_to_hom_mat3d PoseToHomMat3d PoseToHomMat3d PoseToHomMat3d pose_to_hom_mat3d
erhält man die der 3D-Lage
entsprechende homogene Transformationsmatrix. Gemäß der Standard-Definition
ist dies die folgende Transformationsmatrix, welche in zwei separate Matrizen
aufgespaltet werden kann, eine für die Translation
(H(T)) und eine für die Rotation
(H(R)):
Koordinatentransformation
Die folgende Gleichung zeigt, wie ein Punkt mit Hilfe einer 3D-Lage (bzw.
der entsprechenden homogenen Transformationsmatrix
) von Koordinatensystem 1
(cs 1) in Koordinatensystem 2 (cs 2) transformiert werden
kann (Ein- und Ausgabepunkte als homogene Vektoren dargestellt, vgl.
affine_trans_point_3d affine_trans_point_3d AffineTransPoint3d AffineTransPoint3d AffineTransPoint3d affine_trans_point_3d
).
Beachten Sie, dass zur Transformation von cs 1 in cs 2
die homogene Transformationsmatrix verwendet wird, die die 3D-Lage von
cs 1 relativ zu cs 2 beschreibt:
Die Gleichung entspricht der folgenden Sequenz von Operatoraufrufen:
pose_to_hom_mat3d(PoseOf1In2, HomMat3DFrom1In2) pose_to_hom_mat3d(PoseOf1In2, HomMat3DFrom1In2) PoseToHomMat3d(PoseOf1In2, HomMat3DFrom1In2) PoseToHomMat3d(PoseOf1In2, HomMat3DFrom1In2) PoseToHomMat3d(PoseOf1In2, HomMat3DFrom1In2) pose_to_hom_mat3d(PoseOf1In2, HomMat3DFrom1In2)
affine_trans_point_3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z) affine_trans_point_3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z) AffineTransPoint3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z) AffineTransPoint3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z) AffineTransPoint3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z) affine_trans_point_3d(HomMat3DFrom1In2, P1X, P1Y, P1Z, P2X, P2Y, P2Z)
Nicht dem Standard entsprechende Darstellungen von 3D-Lagen
Bisher wurde die Standard-Definition von 3D-Lagen beschrieben. Um diese zu
erzeugen, übergibt man in den Parametern OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
und
ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
die (Standard-)Werte 'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
bzw. 'point' "point" "point" "point" "point" "point" . Für andere Werte werden nicht dem Standard
entsprechende Typen von 3D-Lagen erzeugt, die kurz im Folgenden beschrieben
werden. Bitte beachten Sie, dass diese Darstellungstypen nur zur
Abwärtskompatibilität unterstützt werden; wir empfehlen nachdrücklich, die
Standard-Typen zu verwenden.
Wenn 'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" in OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
übergeben wird,
entspricht die erzeugte 3D-Lage der folgenden Transformationskette, d.h. die
Reihenfolge von Translation und Rotation ist vertauscht und die Translation
ist negiert:
Wenn in 'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" in ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
übergeben
wird, bleibt die Reihenfolge der Transformationen gleich, aber die
Rotationswinkel werden negiert. Bitte beachten Sie, dass dies nicht der
Transformation eines Koordinatensystems entspricht, auch wenn der
Parameterwert dies suggeriert!
Zurückgelieferte Datenstruktur
Die erzeugte 3D-Lage wird in Pose Pose Pose Pose pose pose
zurückgeliefert, in Form eines
Tupels mit sieben Elementen. Die ersten drei Elemente enthalten die
Translationsparameter TransX TransX TransX TransX transX trans_x
, TransY TransY TransY TransY transY trans_y
und TransZ TransZ TransZ TransZ transZ trans_z
,
gefolgt von den Rotationsparametern RotX RotX RotX RotX rotX rot_x
, RotY RotY RotY RotY rotY rot_y
und
RotZ RotZ RotZ RotZ rotZ rot_z
. Das letzte Element kodiert den Darstellungstyp der 3D-Lage,
der mit den Parametern OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
, OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
und ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
gewählt wurde. Die folgende Tabelle listet die
möglichen Kombinationen. Wie schon erwähnt empfehlen wir, nur die Typen mit
OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
= 'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T" und ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
=
'point' "point" "point" "point" "point" "point" zu verwenden (Codes 0, 2 und 4).
OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
Code
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'gba' "gba" "gba" "gba" "gba" "gba"
'point' "point" "point" "point" "point" "point"
0
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'abg' "abg" "abg" "abg" "abg" "abg"
'point' "point" "point" "point" "point" "point"
2
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez"
'point' "point" "point" "point" "point" "point"
4
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'gba' "gba" "gba" "gba" "gba" "gba"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
1
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'abg' "abg" "abg" "abg" "abg" "abg"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
3
'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T"
'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
5
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'gba' "gba" "gba" "gba" "gba" "gba"
'point' "point" "point" "point" "point" "point"
8
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'abg' "abg" "abg" "abg" "abg" "abg"
'point' "point" "point" "point" "point" "point"
10
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez"
'point' "point" "point" "point" "point" "point"
12
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'gba' "gba" "gba" "gba" "gba" "gba"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
9
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'abg' "abg" "abg" "abg" "abg" "abg"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
11
'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez"
'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
13
3D-Lagen können mit convert_pose_type convert_pose_type ConvertPoseType ConvertPoseType ConvertPoseType convert_pose_type
in andere Darstellungstypen
konvertiert werden; mit get_pose_type get_pose_type GetPoseType GetPoseType GetPoseType get_pose_type
kann der Darstellungstyp einer
3D-Lage abgefragt werden.
Ausführungsinformationen
Multithreading-Typ: reentrant (läuft parallel zu nicht-exklusiven Operatoren).
Multithreading-Bereich: global (kann von jedem Thread aufgerufen werden).
Wird ohne Parallelisierung verarbeitet.
Parameter
TransX TransX TransX TransX transX trans_x
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Translation in Richtung der x-Achse (in [m]).
Defaultwert: 0.1
Wertevorschläge: -1.0, -0.75, -0.5, -0.25, -0.2, -0.1, -0.5, -0.25, -0.125, -0.01, 0.0, 0.01, 0.125, 0.25, 0.5, 0.1, 0.2, 0.25, 0.5, 0.75, 1.0
TransY TransY TransY TransY transY trans_y
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Translation in Richtung der y-Achse (in [m]).
Defaultwert: 0.1
Wertevorschläge: -1.0, -0.75, -0.5, -0.25, -0.2, -0.1, -0.5, -0.25, -0.125, -0.01, 0.0, 0.01, 0.125, 0.25, 0.5, 0.1, 0.2, 0.25, 0.5, 0.75, 1.0
TransZ TransZ TransZ TransZ transZ trans_z
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Translation in Richtung der z-Achse (in [m]).
Defaultwert: 0.1
Wertevorschläge: -1.0, -0.75, -0.5, -0.25, -0.2, -0.1, -0.5, -0.25, -0.125, -0.01, 0.0, 0.01, 0.125, 0.25, 0.5, 0.1, 0.2, 0.25, 0.5, 0.75, 1.0
RotX RotX RotX RotX rotX rot_x
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Rotation um x-Achse bzw. x-Komponente des
Rodriguez-Vektors (in [°] bzw. ohne Einheit).
Defaultwert: 90.0
Wertevorschläge: 0.0, 90.0, 180.0, 270.0
Typischer Wertebereich: 0
≤
RotX
RotX
RotX
RotX
rotX
rot_x
≤
360
RotY RotY RotY RotY rotY rot_y
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Rotation um y-Achse bzw. y-Komponente des
Rodriguez-Vektors (in [°] bzw. ohne Einheit).
Defaultwert: 90.0
Wertevorschläge: 0.0, 90.0, 180.0, 270.0
Typischer Wertebereich: 0
≤
RotY
RotY
RotY
RotY
rotY
rot_y
≤
360
RotZ RotZ RotZ RotZ rotZ rot_z
(input_control) real →
HTuple float HTuple Htuple (real) (double ) (double ) (double )
Rotation um z-Achse bzw. z-Komponente des
Rodriguez-Vektors (in [°] bzw. ohne Einheit).
Defaultwert: 90.0
Wertevorschläge: 0.0, 90.0, 180.0, 270.0
Typischer Wertebereich: 0
≤
RotZ
RotZ
RotZ
RotZ
rotZ
rot_z
≤
360
OrderOfTransform OrderOfTransform OrderOfTransform OrderOfTransform orderOfTransform order_of_transform
(input_control) string →
HTuple str HTuple Htuple (string) (string ) (HString ) (char* )
Reihenfolge von Rotation und Translation.
Defaultwert:
'Rp+T'
"Rp+T"
"Rp+T"
"Rp+T"
"Rp+T"
"Rp+T"
Wertevorschläge: 'Rp+T' "Rp+T" "Rp+T" "Rp+T" "Rp+T" "Rp+T" , 'R(p-T)' "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)" "R(p-T)"
OrderOfRotation OrderOfRotation OrderOfRotation OrderOfRotation orderOfRotation order_of_rotation
(input_control) string →
HTuple str HTuple Htuple (string) (string ) (HString ) (char* )
Bedeutung der Rotationswerte.
Defaultwert:
'gba'
"gba"
"gba"
"gba"
"gba"
"gba"
Wertevorschläge: 'gba' "gba" "gba" "gba" "gba" "gba" , 'abg' "abg" "abg" "abg" "abg" "abg" , 'rodriguez' "rodriguez" "rodriguez" "rodriguez" "rodriguez" "rodriguez"
ViewOfTransform ViewOfTransform ViewOfTransform ViewOfTransform viewOfTransform view_of_transform
(input_control) string →
HTuple str HTuple Htuple (string) (string ) (HString ) (char* )
Sichtweise der Transformation.
Defaultwert:
'point'
"point"
"point"
"point"
"point"
"point"
Wertevorschläge: 'point' "point" "point" "point" "point" "point" , 'coordinate_system' "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system" "coordinate_system"
Pose Pose Pose Pose pose pose
(output_control) pose →
HPose , HTuple Sequence[Union[int, float]] HTuple Htuple (real / integer) (double / int / long) (double / Hlong) (double / Hlong)
3D-Lage (Pose).
Parameteranzahl: 7
Beispiel (HDevelop)
* Create a pose.
create_pose (0.1, 0.2, 0.3, 40, 50, 60, 'Rp+T', 'gba', 'point', Pose)
Beispiel (HDevelop)
* Create a pose.
create_pose (0.1, 0.2, 0.3, 40, 50, 60, 'Rp+T', 'gba', 'point', Pose)
Beispiel (C++)
HTuple Pose, Pose2;
// Create a pose.
create_pose (0.1, 0.2, 0.3, 40, 50, 60, "Rp+T", "gba", "point", &Pose);
Beispiel (HDevelop)
* Create a pose.
create_pose (0.1, 0.2, 0.3, 40, 50, 60, 'Rp+T', 'gba', 'point', Pose)
Beispiel (HDevelop)
* Create a pose.
create_pose (0.1, 0.2, 0.3, 40, 50, 60, 'Rp+T', 'gba', 'point', Pose)
Ergebnis
Sind die Parameterwerte korrekt, dann liefert create_pose create_pose CreatePose CreatePose CreatePose create_pose
den Wert TRUE.
Nachfolger
pose_to_hom_mat3d pose_to_hom_mat3d PoseToHomMat3d PoseToHomMat3d PoseToHomMat3d pose_to_hom_mat3d
,
write_pose write_pose WritePose WritePose WritePose write_pose
,
camera_calibration camera_calibration CameraCalibration CameraCalibration CameraCalibration camera_calibration
,
hand_eye_calibration hand_eye_calibration HandEyeCalibration HandEyeCalibration HandEyeCalibration hand_eye_calibration
Alternativen
read_pose read_pose ReadPose ReadPose ReadPose read_pose
,
hom_mat3d_to_pose hom_mat3d_to_pose HomMat3dToPose HomMat3dToPose HomMat3dToPose hom_mat3d_to_pose
Siehe auch
hom_mat3d_rotate hom_mat3d_rotate HomMat3dRotate HomMat3dRotate HomMat3dRotate hom_mat3d_rotate
,
hom_mat3d_translate hom_mat3d_translate HomMat3dTranslate HomMat3dTranslate HomMat3dTranslate hom_mat3d_translate
,
convert_pose_type convert_pose_type ConvertPoseType ConvertPoseType ConvertPoseType convert_pose_type
,
get_pose_type get_pose_type GetPoseType GetPoseType GetPoseType get_pose_type
,
hom_mat3d_to_pose hom_mat3d_to_pose HomMat3dToPose HomMat3dToPose HomMat3dToPose hom_mat3d_to_pose
,
pose_to_hom_mat3d pose_to_hom_mat3d PoseToHomMat3d PoseToHomMat3d PoseToHomMat3d pose_to_hom_mat3d
,
write_pose write_pose WritePose WritePose WritePose write_pose
,
read_pose read_pose ReadPose ReadPose ReadPose read_pose
Modul
Foundation