Algorithm 两个圆形扇区的交点

我试图解决简单的任务，但我没有找到任何优雅的解决方案

我基本上是求解两个圆形扇区的交点。 每个扇区由（-pi，pi]范围内的2个角度（从atan2 func）给出。 每个选择器占据179.999的最大角度。因此，它可以区分圆形扇区所在的每两个角度

返回值应基于以下内容描述相互交叉：

值1如果第一个角度（虚线角度）在另一个角度之外，则该值表示虚线角度超出另一个角度的程度

基本案例和一些示例如下图所示

问题是，有这么多的案件需要处理，我正在寻找一些优雅的方法来解决它

我只能在单位圆的右侧（cos>0）比较两个角度，因为在左侧，角度数值越大，图形上越低。我尝试在右半部分使用一些投影：

if(x not in <-pi/2, pi/2>)
{
    c = getSign(x)*pi/2;
    x = c - (x - c);
}

if（x不在）
{
c=getSign（x）*pi/2；
x=c-（x-c）；
}

但占据单位圆两半部分的扇区存在一个问题

有这么多的案例…有人知道如何优雅地解决这个问题吗？

---

（我使用C++，但是任何提示或伪代码都很好）

你可以做如下：

将每个扇区规范化为形式（

SU开始

，

SU结束

），其中

SU开始

在（-pi，pi]中，

SU结束

在[

SU开始

，

SU开始+pi

）中

对扇区进行排序（交换），以便

s0\u开始

<

s1\u开始

现在我们只有3个案例（a、b1、b2）：

a）

s1\u开始s0\u结束

：

b1）

s0\u起点+2*pi s1\u终点

：无交叉口

因此，我们得到以下代码：

const double PI = 2.*acos(0.);
struct TSector { double a0, a1; };

// normalized range for angle
bool isNormalized(double a)
{ return -PI < a && a <= PI; }
// special normal form for sector
bool isNormalized(TSector const& s)
{ return isNormalized(s.a0) && s.a0 <= s.a1 && s.a1 < s.a0+PI; }

// normalize a sector to the special form:
// * -PI < a0 <= PI
// * a0 < a1 < a0+PI
void normalize(TSector& s)
{
   assert(isNormalized(s.a0) && isNormalized(s.a1));

   // choose a representation of s.a1 s.t. s.a0 < s.a1 < s.a0+2*PI
   double a1_bigger = (s.a0 <= s.a1) ? s.a1 : s.a1+2*PI;
   if (a1_bigger >= s.a0+PI)
     std::swap(s.a0, s.a1);
   if (s.a1 < s.a0)
     s.a1 += 2*PI;

   assert(isNormalized(s));
}

bool intersectionNormalized(TSector const& s0, TSector const& s1,
                            TSector& intersection)
{
  assert(isNormalized(s0) && isNormalized(s1) && s0.a0 <= s1.a0);

  bool isIntersecting = false;
  if (s1.a0 <= s0.a1) // s1.a0 inside s0 ?
  {
    isIntersecting = true;
    intersection.a0 = s1.a0;
    intersection.a1 = std::min(s0.a1, s1.a1);
  }
  else if (s0.a0+2*PI <= s1.a1) // (s0.a0+2*PI) inside s1 ?
  {
    isIntersecting = true;
    intersection.a0 = s0.a0;
    intersection.a1 = std::min(s0.a1, s1.a1-2*PI);
  }
  assert(!isIntersecting || isNormalized(intersection));

  return isIntersecting;
}

main()
{
  TSector s0, s1;
  s0.a0 = ...
  normalize(s0);
  normalize(s1);
  if (s1.a0 < s0.a0)
    std::swap(s0, s1);
  TSection intersection;
  bool isIntersection = intersectionNormalized(s0, s1, intersection);
}

constdouble PI=2.*acos（0.）；
结构TSector{double a0，a1；}；
//角度的标准化范围
布尔值标准化（双a）
{return-PI