create_poseT_create_poseCreatePoseCreatePosecreate_pose (Operator)

Name

create_poseT_create_poseCreatePoseCreatePosecreate_pose — Erzeugen einer 3D-Lage (Pose).

Signatur

create_pose( : : TransX, TransY, TransZ, RotX, RotY, RotZ, OrderOfTransform, OrderOfRotation, ViewOfTransform : Pose)

Herror T_create_pose(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 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)

def create_pose(trans_x: float, trans_y: float, trans_z: float, rot_x: float, rot_y: float, rot_z: float, order_of_transform: str, order_of_rotation: str, view_of_transform: str) -> Sequence[Union[int, float]]

Beschreibung

create_posecreate_poseCreatePoseCreatePoseCreatePosecreate_pose erzeugt eine 3D-Lage PosePosePosePoseposepose. Eine 3D-Lage beschreibt eine starre 3D-Transformation, d.h. eine Transformation bestehend aus einer beliebigen Translation und Rotation, mit 6 Parametern: TransXTransXTransXTransXtransXtrans_x, TransYTransYTransYTransYtransYtrans_y und TransZTransZTransZTransZtransZtrans_z beschreiben die Translation entlang der x-, y- und z-Achse, während RotXRotXRotXRotXrotXrot_x, RotYRotYRotYRotYrotYrot_y und RotZRotZRotZRotZrotZrot_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 OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_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_rotatehom_mat3d_rotateHomMat3dRotateHomMat3dRotateHomMat3dRotatehom_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 OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_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 OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_of_rotation übergeben wird, werden die Rotationsparameter RotXRotXRotXRotXrotXrot_x, RotYRotYRotYRotYrotYrot_y und RotZRotZRotZRotZrotZrot_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_quataxis_angle_to_quatAxisAngleToQuatAxisAngleToQuatAxisAngleToQuataxis_angle_to_quat) dargestellt werden.

Entsprechende homogene Transformationsmatrix

Mit dem Operator pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3dpose_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 (cs1) in Koordinatensystem 2 (cs2) transformiert werden kann (Ein- und Ausgabepunkte als homogene Vektoren dargestellt, vgl. affine_trans_point_3daffine_trans_point_3dAffineTransPoint3dAffineTransPoint3dAffineTransPoint3daffine_trans_point_3d). Beachten Sie, dass zur Transformation von cs1 in cs2 die homogene Transformationsmatrix verwendet wird, die die 3D-Lage von cs1 relativ zu cs2 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 OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_of_transform und ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_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 OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_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 ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_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 PosePosePosePoseposepose zurückgeliefert, in Form eines Tupels mit sieben Elementen. Die ersten drei Elemente enthalten die Translationsparameter TransXTransXTransXTransXtransXtrans_x, TransYTransYTransYTransYtransYtrans_y und TransZTransZTransZTransZtransZtrans_z, gefolgt von den Rotationsparametern RotXRotXRotXRotXrotXrot_x, RotYRotYRotYRotYrotYrot_y und RotZRotZRotZRotZrotZrot_z. Das letzte Element kodiert den Darstellungstyp der 3D-Lage, der mit den Parametern OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_of_transform, OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_of_rotation und ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_of_transform gewählt wurde. Die folgende Tabelle listet die möglichen Kombinationen. Wie schon erwähnt empfehlen wir, nur die Typen mit OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_of_transform = 'Rp+T'"Rp+T""Rp+T""Rp+T""Rp+T""Rp+T" und ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_of_transform = 'point'"point""point""point""point""point" zu verwenden (Codes 0, 2 und 4).

OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_of_transform OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_of_rotation ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_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_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseTypeconvert_pose_type in andere Darstellungstypen konvertiert werden; mit get_pose_typeget_pose_typeGetPoseTypeGetPoseTypeGetPoseTypeget_pose_type kann der Darstellungstyp einer 3D-Lage abgefragt werden.

Ausführungsinformationen

Parameter

TransXTransXTransXTransXtransXtrans_x (input_control)  real HTuplefloatHTupleHtuple (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

TransYTransYTransYTransYtransYtrans_y (input_control)  real HTuplefloatHTupleHtuple (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

TransZTransZTransZTransZtransZtrans_z (input_control)  real HTuplefloatHTupleHtuple (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

RotXRotXRotXRotXrotXrot_x (input_control)  real HTuplefloatHTupleHtuple (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

RotYRotYRotYRotYrotYrot_y (input_control)  real HTuplefloatHTupleHtuple (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

RotZRotZRotZRotZrotZrot_z (input_control)  real HTuplefloatHTupleHtuple (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

OrderOfTransformOrderOfTransformOrderOfTransformOrderOfTransformorderOfTransformorder_of_transform (input_control)  string HTuplestrHTupleHtuple (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)"

OrderOfRotationOrderOfRotationOrderOfRotationOrderOfRotationorderOfRotationorder_of_rotation (input_control)  string HTuplestrHTupleHtuple (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"

ViewOfTransformViewOfTransformViewOfTransformViewOfTransformviewOfTransformview_of_transform (input_control)  string HTuplestrHTupleHtuple (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"

PosePosePosePoseposepose (output_control)  pose HPose, HTupleSequence[Union[int, float]]HTupleHtuple (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_posecreate_poseCreatePoseCreatePoseCreatePosecreate_pose den Wert TRUE.

Nachfolger

pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3dpose_to_hom_mat3d, write_posewrite_poseWritePoseWritePoseWritePosewrite_pose, camera_calibrationcamera_calibrationCameraCalibrationCameraCalibrationCameraCalibrationcamera_calibration, hand_eye_calibrationhand_eye_calibrationHandEyeCalibrationHandEyeCalibrationHandEyeCalibrationhand_eye_calibration

Alternativen

read_poseread_poseReadPoseReadPoseReadPoseread_pose, hom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPoseHomMat3dToPosehom_mat3d_to_pose

Siehe auch

hom_mat3d_rotatehom_mat3d_rotateHomMat3dRotateHomMat3dRotateHomMat3dRotatehom_mat3d_rotate, hom_mat3d_translatehom_mat3d_translateHomMat3dTranslateHomMat3dTranslateHomMat3dTranslatehom_mat3d_translate, convert_pose_typeconvert_pose_typeConvertPoseTypeConvertPoseTypeConvertPoseTypeconvert_pose_type, get_pose_typeget_pose_typeGetPoseTypeGetPoseTypeGetPoseTypeget_pose_type, hom_mat3d_to_posehom_mat3d_to_poseHomMat3dToPoseHomMat3dToPoseHomMat3dToPosehom_mat3d_to_pose, pose_to_hom_mat3dpose_to_hom_mat3dPoseToHomMat3dPoseToHomMat3dPoseToHomMat3dpose_to_hom_mat3d, write_posewrite_poseWritePoseWritePoseWritePosewrite_pose, read_poseread_poseReadPoseReadPoseReadPoseread_pose

Modul

Foundation