标签: angle

我打算制作一个游戏,你可以从上面看到一个角色.但问题是如何让角色始终看着鼠标呢？我如何计算角度,以便我可以向鼠标射击(我正在寻找的位置).我想你必须玩三角学和类似的东西来获得角度,但我真的不知道如何.

我擅长数学,所以如果你们给我一些帮助,我可能会弄清楚.

对不起我最后的英语不好,我是瑞典人:)

谢谢,亚历山大

给定同一圆的两个圆弧段:A = [a1,a2],B = [b1,b2],其中:

• a1,a2,b1,b2的值在-inf和+ inf之间
• a1 <= a2; b1 <= b2
• A2-A1 <= 360; B2-B1 <= 360

如何确定这两个圆弧段是否重叠？(即如果它们相交或触摸至少一个点)

例子:

A=[  -45°,    45°]; B=[   10°,   20°] ==> overlap
A=[  -45°,    45°]; B=[   90°,  180°] ==> no overlap
A=[  -45°,    45°]; B=[  180°,  360°] ==> overlap
A=[ -405°,  -315°]; B=[  180°,  360°] ==> overlap
A=[-3600°, -3601°]; B=[ 3601°, 3602°] ==> overlap (touching counts as overlap)
A=[ 3600°,  3601°]; B=[-3601°,-3602°] ==> overlap (touching counts as overlap)
A=[    -1°,    1°]; B=[ 3602°, …

如何找到原点为0,1的点与另一点（如下图中的）之间的角度（0 到 360 度，顺时针旋转） ？这是我需要的一个有点粗略的说明：0.3,-0.170,0

左边的圆圈纯粹是为了显示我希望角度旋转的方向，以及它们从哪里开始/结束。右图给出了我将提供给代码的输入示例（即0.3,-0.17）。绿线是结果角度。

如何在 C++ 或 JavaScript 中找到如上所述的两点之间的角度？

我正在尝试计算两个角度间隔之间的交点，如下图所示。不幸的是，-pi 处的分支使代码比我希望的要丑陋得多。这是我的初稿。请注意，我尚未测试此代码的正确性，而只是在我的脑海中浏览了这些场景。

正如您在函数 中看到的branchify，角度间隔受到限制，从(p)a1 -> (p)a2逆时针方向看，差异最多为 pi。否则，间隔由最小角度差定义。[a1, a2]是第一个间隔，[pa1, pa2]第二个。

// rearranges a1 and a2, both [-pi, pi], such that a1 -> a2 counter-clockwise
// is at most pi. Returns whether this interval crosses the branch.
static inline bool branchify(float &a1, float &a2) {
    if (abs(a1-a2) >= 1.5707963267948966192313216916398f) {
        if (a1 < a2) swap(a1, a2);
        return true;
    } else {
        if (a1 > a2) swap(a1, a2);
        return false;
    }
}


float …

我需要一个函数将角度（以度为单位）限制在任意范围内[min,max]。这里有些例子：

彩色区域代表有效角度范围。

• 在图像 #1 中，ang应限制为最大值(-90)
  
• 在图像 #2 中，ang应被限制为min (135)
  
• 在图像 #3 中，ang应被限制为min (135)
  

这是我到目前为止所拥有的：

static float clamp_angle(float ang,float min,float max)
{
    ang = normalize_angle(ang); // normalize_angle transforms angle into [-180,180) range
    min = normalize_angle(min);
    max = normalize_angle(max);
    if(angle_in_range(ang,min,max) == false)
    {
        if(abs(get_angle_difference(ang,min)) < abs(get_angle_difference(ang,max))
            ang = min; // Clamp to min if we're closer to min than max
        else
            ang = max;
    }
    return ang;
}

我缺少的是函数angle_in_range …

我试图在一个圆上找到 X、Y 点，其中 0 度从圆的顶部开始并顺时针移动。通常，要在已知半径和角度的圆上找到 x、y 坐标，您可以简单地使用公式 x = r(cos(degrees?°)), y = r(sin(degrees?°))。圆圈看起来像这样，度数将从 0?° 逆时针扩展。

但是，我使用的是一个圆圈，其中 0?° 从顶部开始，度数随着围绕圆圈顺时针移动而扩展。假设var r = 60;和var degrees = 130;我可以使用什么公式（或JavaScript方法）来确定X，Y值。注意：我可以假设原点为 0, 60，因为 r = 60。谢谢。

我使用 start 和 endAngle 渲染了 svg 圆。效果很好。但是当我渲染完整的圆（startAngle为70，endAngle为70）时，输出有很大的不同（0、90、180、270除外）。我为这段代码做错了什么？

            function getPathArc(center, start, end, radius) {
                end -= this.isCompleteAngle(start, end) ? 0.0001 : 0;
                var degree = end - start;
                degree = degree < 0 ? (degree + 360) : degree;
                return this.getCirclePath(
                    center, getLocationFromAngle(start, radius, center),
                    getLocationFromAngle(end, radius, center), radius, (degree < 180) ? 0 : 1
                );
            }

            function getCirclePath(center, start, end, radius, clockWise) {
                return 'M ' + start.x + ' ' + start.y + ' A ' + radius …

我有两个由 3d 向量（numpy 1D 数组）组成的矩阵，我需要按行计算向量之间的角度，并以 1d 数组返回结果。我知道如何计算两个一维向量之间的角度。执行此操作的正确方法是什么？

*** 所得角度以度数而非弧度为单位。

现在我有这个：

import numpy as np

A = np.array([[1,0,0],
              [0,1,0],
              [0,0,1]])

B = np.array([[1,0,1],
              [1,1,0],
              [0,1,0]])

def angle(V1,V2):
    """
    angle between vectors V1 and V2 in degrees using
    angle = arccos ( V1 dot V2 / norm(V1) * norm(V2) ) *180/np.pi
    """

    cos_of_angle = V1.dot(V2) / (np.linalg.norm(V1) * np.linalg.norm(V2)) 
    return np.arccos(np.clip(cos_of_angle,-1,1))  * 180/np.pi

请注意从 rad 到 deg 转换的缩放项 180/np.pi。

我想要一个数组：

C = [ angle(A[0],B[0]) , angle(A[1],B[1])...... and so on]

如果有人可以提供帮助，我真的很感激。

假设我有两个间隔，

[a1, a2] and [b1, b2]

哪里a1,a2,b1,b2都在范围之内[0, 2 pi]。现在，给定这两个区间，我想找到它们的重叠区间。这是相当棘手的。由于两个区间的示例是

[5, 1] and [0, 6]

如下所示（红色区域是间隔）。

请注意，这两个间隔返回一个由两个间隔组成的重叠间隔：

[0,1] and [5,6]

有多种不同的情况必须处理，是否有任何已知的算法可以做到这一点？