4

我有一系列要旋转的顶点(粉红色),以便顶点图案的一个边缘与三角形的边缘(白色)匹配。

为此,我首先创建两个向量来表示边缘:floretAB 和 triangleAB(绿色)。然后我找到两者的叉积以获得一个轴,我可以围绕该轴旋转顶点(红色)。

然后我得到两个向量之间的角度,并使用它和旋转轴来创建一个四元数。最后,我围绕四元数旋转所有顶点。

在此处输入图像描述

旋转前

_

在此处输入图像描述

应该产生什么旋转

_

但是,尽管顶点正确地围绕四元数旋转,但角度并不正确,如下所示:

在此处输入图像描述

这是我用来获取两个向量之间角度的代码。我不明白我做错了什么:

double[] cross = new double[3];
crossProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ, cross);
double dot = dotProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ);
double crossMag = Math.sqrt(cross[0]*cross[0] + cross[1]*cross[1] + cross[2]*cross[2]);
double angle = Math.atan2(crossMag, dot);

public static double dotProduct(double vector1X,double vector1Y,double vector1Z,double vector2X,double vector2Y,double vector2Z){

    return vector1X*vector2X + vector1Y*vector2Y + vector1Z*vector2Z;

}

public static void crossProduct(double vector1X,double vector1Y,double vector1Z,double vector2X,double vector2Y,double vector2Z, double[] outputArray){

    outputArray[0] = vector1Y*vector2Z - vector1Z*vector2Y;     
    outputArray[1] = vector1Z*vector2X - vector1X*vector2Z;
    outputArray[2] = vector1X*vector2Y - vector1Y*vector2X;

}

对此的任何帮助将不胜感激,因为它确实困扰着我。

谢谢,詹姆斯

编辑:这是其余的代码:

        // get floret p1,p2 vector
    // get triangle p1,p2 vector
    Vector3D floretAB = new Vector3D(florets3D[0], florets3D[7]);
    // get triangle p1,p2 vector
    Vector3D triangleAB = new Vector3D(triangle[0], triangle[1]);

    // get rotation axis (cross) and angle (dot)

    /*
    double[] cross = new double[3];
    crossProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ, cross);
    double dotMag = floretAB.getMagnitude() * triangleAB.getMagnitude();
    double dot = dotProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ) / dotMag;
    double angle = Math.acos(dot);
    */

    double[] cross = new double[3];
    crossProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ, cross);
    double dot = dotProduct(floretAB.mX, floretAB.mY, floretAB.mZ, triangleAB.mX, triangleAB.mY, triangleAB.mZ);
    double crossMag = Math.sqrt(cross[0]*cross[0] + cross[1]*cross[1] + cross[2]*cross[2]);
    double angle = Math.atan2(crossMag, dot);

    // rotate floret so p1,p2 vector matches with triangle p1,p2 vector     
    double[] newVerts = new double[3];
    Quaternion quat = new Quaternion(cross[0], cross[1], cross[2], angle);
    for(int i = 0;i<numfloretVerts;i++){
        Vertex3D vert = florets3D[i];
        quat.RotateVector(vert.getmX(), vert.getmY(), vert.getmZ(), newVerts);
        vert.setmX(newVerts[0]);
        vert.setmY(newVerts[1]);
        vert.setmZ(newVerts[2]);
    }

_

public class Vector3D {

public double mX;
public double mY;
public double mZ;

public Vertex3D point;

/**
 * Constructs a vector from two points. The new vector is normalised
 * 
 * @param point1
 * @param point2
 */
public Vector3D(Vertex3D point1, Vertex3D point2){
    mX = point2.getmX() - point1.getmX();
    mY = point2.getmY() - point1.getmY();
    mZ = point2.getmZ() - point1.getmZ();
    normalise();
    point = point1;
}

/**
 * Normalises the vector
 */
public void normalise(){
    double magnitude = Math.sqrt(mX*mX + mY*mY + mZ*mZ);
    if(magnitude!=0){
        mX /= magnitude;
        mY /= magnitude;
        mZ /= magnitude;
    }
}

/**
 * 
 * @return the magnitude of the vector
 */
public double getMagnitude(){
    return Math.sqrt(mX*mX + mY*mY + mZ*mZ);
}

}

_

public class Quaternion {

private static final double TOLERANCE = 0.00001f;

double w;
double x;
double y;
double z;

public Quaternion(double axisX, double axisY, double axisZ, double angleInRadians){
    setAxisAngle(axisX, axisY, axisZ, angleInRadians);      
}

public void Normalise(){

    // Don't normalize if we don't have to
    double mag2 = w * w + x * x + y * y + z * z;
    if (Math.abs(mag2) > TOLERANCE && Math.abs(mag2 - 1.0f) > TOLERANCE) {
        double mag = (double) Math.sqrt(mag2);
        w /= mag;
        x /= mag;
        y /= mag;
        z /= mag;
    }

}

public void getConjugate(double[] outputArray){

    outputArray[0] = w;
    outputArray[1] = -x;
    outputArray[2] = -y;
    outputArray[3] = -z;

}

public void Multiply(double[] aq, double[] rq, double[] outputArray){

    outputArray[0] = aq[0] * rq[0] - aq[1] * rq[1] - aq[2] * rq[2] - aq[3] * rq[3];
    outputArray[1] = aq[0] * rq[1] + aq[1] * rq[0] + aq[2] * rq[3] - aq[3] * rq[2];
    outputArray[2] = aq[0] * rq[2] + aq[2] * rq[0] + aq[3] * rq[1] - aq[1] * rq[3];
    outputArray[3] = aq[0] * rq[3] + aq[3] * rq[0] + aq[1] * rq[2] - aq[2] * rq[1];

}

private double[] vecQuat = new double[4];
private double[] resQuat = new double[4];
private double[] thisQuat = new double[4];

private double[] conj = new double[4];

/**
 * Rotates a vector (or point) around this axis-angle
 * 
 * @param vectorX the x component of the vector (or point)
 * @param vectorY the y component of the vector (or point)
 * @param vectorZ the z component of the vector (or point)
 * @param outputArray the array in which the results will be stored
 */
public void RotateVector(double vectorX, double vectorY, double vectorZ, double[] outputArray){

    vecQuat[0] = 0.0f;
    vecQuat[1] = vectorX;
    vecQuat[2] = vectorY;
    vecQuat[3] = vectorZ;

    thisQuat[0] = w;
    thisQuat[1] = x;
    thisQuat[2] = y;
    thisQuat[3] = z;

    getConjugate(conj);
    Multiply(vecQuat,conj,resQuat);
    Multiply(thisQuat,resQuat,vecQuat);

    outputArray[0] = vecQuat[1];
    outputArray[1] = vecQuat[2];
    outputArray[2] = vecQuat[3];

}

/**
 * set Quaternion by providing axis-angle form
 */
public void setAxisAngle(double axisX, double axisY, double axisZ, double angleInRadians){
    w = (double) Math.cos( angleInRadians/2);
    x = (double) (axisX * Math.sin( angleInRadians/2 ));
    y = (double) (axisY * Math.sin( angleInRadians/2 ));
    z = (double) (axisZ * Math.sin( angleInRadians/2 ));

    Normalise();
}
}
4

3 回答 3

1

我认为问题在于您以错误的方式评估角度。如果我正确理解您要达到的目标,那么您需要两条绿线之间的角度。您使用以下定义正确评估了 2 条绿线之间的点积:

(a, b) = a1*b1 + a2*b2 + a3*b3.

但是点积也可以这样计算:

(a, b) = |a|*|b|*cos(theta)

所以你可以评估 cos(theta) - 两条绿线之间的角度余弦 - 像这样:

cos(theta) = (a1*b1 + a2*b2 + a3*b3) / (|a|*|b|)

但我会使用另一种方法。我会首先对两个向量进行归一化(即将它们转换为unit-vectors)。您可以通过将每个向量的分量除以向量的长度 (sqrt(x1*x1 + y1*y1 + z1*z1)) 来做到这一点,然后您将获得以下结果:

(aa, bb) = cos(theta)

其中 aa 是归一化的 a,bb 是归一化的 b。

我希望这有帮助。

于 2012-12-17T14:56:59.950 回答
1

我认为你的数学过于复杂了。

给定两个单位向量(您确实说过它们已归一化),则叉积的大小等于sin(theta)。不需要调用点积或atan2.

在创建四元数之前,您可能还需要对叉积向量结果进行归一化 - 这取决于您的实现new Quaternion(x, y, z, theta)以及是否需要[x, y, z]对其进行归一化。

于 2012-12-17T15:39:37.880 回答
1

所述答案对于实数是正确的,但在使用浮点数计算时可能会在某些角度附近失去准确性。对于角度接近零或 PI 的 arcs(),以及接近 pi/2 和 –pi/2 的 arcsin(),可能会丢失多达一半的有效数字。假设输入向量是单位长度,一种更稳健且仅在从零到包括 PI 的整个范围内均匀地遭受一些舍入误差的方法是:

public double AngleBetween(Vector3D a, Vector3D b)
{
    return 2.0d * Math.atan((a-b).Length/(a+b).Length);
}

请注意,这给出了两个向量之间的无方向角。可以在以下位置找到关于此并归因于 Kahan 的参考:http ://www.cs.berkeley.edu/~wkahan/MathH110/Cross.pdf

于 2015-02-19T00:03:50.417 回答