标签: quaternions

（也许这对数学堆栈交换更好？）

我有一个由骨头组成的链条。每块骨头都有一个尖端和尾巴。下面的代码计算它的尖端的位置，给定一个旋转，并适当地设置链位置中的下一个链接：

    // Quaternion is a hand-rolled class that works correctly (as far as I can tell.)
    Quaternion quat = new Quaternion(getRotationAngleDegrees(), getRotation());

    // figure out where the tip will be after applying the rotation
    Vector3f rotatedTip = quat.applyRotationTo(tip);

    // set the next bone's tail to be at this one's tip
    updateNextPosFrom(rotatedTip);

如果旋转应该围绕对象坐标系的原点发生，则此方法有效。但是，如果我希望围绕对象中的其他任意点进行旋转呢？我不知道如何翻译四元数。最好的方法是什么？

（我正在使用 JOGL/OpenGL。）

我不再使用欧拉角，而是使用四元数来表示和处理 3D 立方体的旋转。虽然它可以解决万向节锁定问题，但我仍然遇到这个问题。

我的代码是：

// p is the point to be rotated
// angles is a Vector3D representing the rotation angles

var xaxis = new Vector3D(1, 0, 0);
var yaxis = new Vector3D(0, 1, 0);
var zaxis = new Vector3D(0, 0, 1);

p = rotate(p, xaxis, angles.x);
p = rotate(p, yaxis, angles.y);
p = rotate(p, zaxis, angles.z);

这些rotate函数来自http://en.wikipedia.org/wiki/Quaternions_and_spatial_rotation#Pseudo-code_for_rotating_using_a_quaternion_in_3D_space（翻译成JavaScript）。

我想这个问题是由于我仍然使用轴的顺序（x y z），这是万向节锁的主要问题。

如何以解决万向节锁定的方式实现四元数旋转？

提前致谢。

我已经使用了两个例子(也来自这个网站),但结果与Unity说的结果不一样.

Quaternion.Euler和.eulerAngles是Unity函数.FromQ不执行奇点检查,FromQ2确实如此.

结果:

eulers = (100,55,-11):
Quaternion.Euler(eulers) == (0.6, 0.4, -0.4, 0.5)
ToQ(eulers)); == (0.5, -0.4, 0.2, 0.7) // 0.5, -0.4 right but in wrong order

FromQ(ToQ(eulers)) == (55.0, 100.0, -11.0)
FromQ2(ToQ(eulers)) == (-55.5, -6.3, 71.0) // something right

Quaternion.Euler(eulers).eulerAngles == (80.0, 235.0, 169.0)
FromQ2(Quaternion.Euler(eulers)) == (65.8, 1.9, 99.8)
ToQ(eulers).eulerAngles == (70.0, 286.9, 341.4)
FromQ(Quaternion.Euler(eulers)) == (-65.8, 76.0, 4.6)

It must be:
FromQ() = FromQ2() = .eulerAngles,
ToQ() = Quaternion.Euler()

代码在这里:http://pastebin.ru/eAlTHdYf

任何人都可以更正此代码？我需要的代码将返回与Unity函数返回的值相同的值.

UPDATE

这是固定代码:http://pastebin.com/riRLRvch …

正如标题所说,我有一个问题,即转换Quaternion为a Matrix4f.Eigen有Quaternion.toRotationMatrix()给我一个方法Matrix3f.现在我需要一个Matrix4f(因为我们的程序只是设计Matrix4f),有没有一种简单的方法来实现这一目标？

我试图在c#scripting上为塔防风格游戏遵循一些unity3d exmaples.我需要一个炮塔来"瞄准"另一个游戏对象.我找到的例子似乎没有说明不是0,0,0的原点.意思是,当炮塔位于不同的位置时,它的目标是基于起点,而不是其当前位置.

它现在的表现如何:http: //screencast.com/t/Vx35LJXRKNUm

在我正在使用的脚本中,如何提供有关炮塔当前位置的Quaternion.LookRotation信息,以便将其包含在计算中？脚本,函数CalculateAimPosition,第59行:

using UnityEngine;
using System.Collections;

public class TurretBehavior : MonoBehaviour {

public GameObject projectile;
public GameObject muzzleEffect;

public float reloadTime = 1f;
public float turnSpeed = 5f;
public float firePauseTime = .25f;

public Transform target;
public Transform[] muzzlePositions;
public Transform turretBall;

private float nextFireTime;
private float nextMoveTime;
private Quaternion desiredRotation;
private Vector3 aimPoint;

// Update is called once per frame
void Update () 
{
    if (target) 
    {
        if (Time.time >= nextMoveTime) 
        {
            CalculateAimPosition(target.position);
            transform.rotation …

我刚刚开始学习 Three.js，在编写一个函数时遇到了一些麻烦，该函数以对象位置（Vector3）和以毫秒为单位的时间作为参数，并逐渐旋转相机以面对它。本质上是内置 LookAt 方法的 lerp 版本。

首先，我尝试使用 tweenjs 来获得平滑的旋转过渡。对于开始和结束参数，我创建了一个虚拟对象，并将其位置、旋转和四元数设置为与相机相同，然后我使用其上的 LookAt 函数面向对象，并将其四元数存储在新变量“targetQuaternion”。然后我使用这个变量作为TWEEN.Tween方法中的目标参数来更新camera.quaternion。我之前曾尝试过使用四元数来避免健身房锁定，然后尝试旋转，但没有一个能正常工作。

function rotateCameraToObject(object3D, time) {

var cameraPosition = camera.position.clone();               // camera original position
var cameraRotation = camera.rotation.clone();               // camera original rotation
var cameraQuaternion = camera.quaternion.clone();           // camera original quaternion

var dummyObject = new THREE.Object3D();                     // dummy object


// set dummyObject's position, rotation and quaternion the same as the camera
dummyObject.position.set(cameraPosition.x, cameraPosition.y, cameraPosition.z);
dummyObject.rotation.set(cameraRotation.x, cameraRotation.y, cameraRotation.z);
dummyObject.quaternion.set(cameraQuaternion.x, cameraQuaternion.y, cameraQuaternion.z);


// lookAt object3D
dummyObject.lookAt(object3D);

// store its quaternion in a variable
var …

我正在使用 SteamVR 并想根据控制器升高的高度旋转相机，我编写了将控制器的高度发送到我的相机脚本上的方法的脚本。

当我执行以下操作时，轮换有效：

transform.Rotate(0, 0, 30); // 30 is just to test, we will use the controller height later

但我想慢慢地做这个轮换，这不能立即发生。

我也尝试过使用 Quaternion.Lerp，但它似乎不起作用。

Quaternion.Lerp(this.transform.rotation, new Quaternion(this.transform.rotation.eulerAngles.x, this.transform.rotation.eulerAngles.y, zPosition, 0), Time.deltaTime * 5);

有什么建议？

我在两个物体上使用两个相同类型的 IMU（BHI160，即方向是相对于北方并与北方对齐，IMU 的局部 y 轴指向北方）在两个物体上，比如说笔，增加了难度如果我将两个物体平行放置，两个 IMU 的 z 轴都指向上方，但是一个 IMU 相对于另一个 IMU 围绕 z 轴旋转了 180°。

现在，如果我在这里正确理解数学，四元数数据I从IMU接收相对于正北方向半角旋转，以便q * north_dir * q_inv = IMU_y_axis（与north_dir和IMU_y_axis是用于起见在全局空间3D矢量，或纯的四元数这个计算）。

由于 IMU 的旋转，我假设当两支笔都指向同一方向时，我应该能够计算第二支笔的方向为q_2 = q_rot_z * q_1，其中q_rot_z等于围绕 z 轴旋转 90° - 遵循直觉如果我将两支笔都指向北方，我将通过计算获得笔 2 的 y 轴（即笔 1 的 y 轴绕 z 轴旋转 180°）的全局方向q_rot_z * north_dir * q_rot_z_inv

因此，如果我想知道笔尖的相对旋转（比如说，我需要从第一支笔的笔尖到第二支笔的笔尖的旋转），我需要计算q_r = q_2 * q_rot_z_inv * q_1_inv以便从笔尖获得，这是否正确1 到小费 2 通过计算q_r * q_1？或者在这种情况下围绕 z 轴的“先前”旋转是否无关紧要，我只需要q_r …

我正在绘制两个线框球体，我想跟随玩家周围。然而，当玩家移动时，两个小玩意儿会跟随移动，而当我旋转时，只有其中一个小玩意儿会旋转。

损坏的 gizmo 代码如下所示，它的偏移量应该为 45：

void OnDrawGizmosSelected() {
  Gizmos.color = new Color(1, 0, 0);

  Gizmos.matrix = Matrix4x4.TRS(transform.position, Quaternion.Euler(transform.rotation.x, transform.rotation.y + 45, transform.rotation.z), Vector3.one);
  Gizmos.DrawWireSphere(Vector3.zero, 5f);
}

作为参考，这里是带有两个小玩意的整个块：

void OnDrawGizmosSelected() {
  Gizmos.color = new Color(1, 0, 0);
  // This one works
  Gizmos.matrix = Matrix4x4.TRS(transform.position, transform.rotation, Vector3.one);
  Gizmos.DrawWireSphere(Vector3.zero, 5f);

  // This one does not work
  Gizmos.matrix = Matrix4x4.TRS(transform.position, Quaternion.Euler(transform.rotation.x, transform.rotation.y + 45, transform.rotation.z), Vector3.one);
  Gizmos.DrawWireSphere(Vector3.zero, 5f);
}

默认不旋转（我希望它在旋转时保持不变）

绕 Y 轴旋转

我在 3D 空间中有一条任意线和垂直向量，所以两者都可以形成一个平面。参见插图。

任务是沿着这条线放置现有的平面，这样平面的脸就会被看到（渲染），见第二个插图。

需要有关如何操作的指南。提前致谢。