javascript：在数组中查找重叠的圆

如何修复此代码以正确检测重叠圆？ 通过测试起点的位置指定第一个圆。第一个圆应该是重叠圆贴图的基础。现在，它只在被测圆在一条非分支线上重叠时起作用

（单个圆为[x，y，半径]）

var圆=[
[6, 19, 1],
[6, 11, 4],
[8, 17, 3],
[19, 19, 2],
[19, 11, 4],
[15, 7, 6],
[12, 19, 4]
];
var i=0；
var j=0；
var start=[10,19]；
var=false；
var重叠=[]；
var isInside=功能（点、列表、检查、推送）{
var temp=list.filter（函数（项）{return Math.pow（项[0]-点[0]，2）+Math.pow（项[1]-点[1]，2）<项[2]*项[2]}）；
if（push）{overlapping=overlapping.concat（temp）}；
返回温度长度>0
};
starts=isInside（开始，圆圈，开始，真）；
var overlappingCircleTest=函数（）{
如果（j0）{
var i=重叠长度-1；
var r0=重叠[i][2]；
var r1=圆[j][2]；
var x0=重叠[i][0]；
var x1=圆[j][0]；
var y0=重叠[i][1]；
变量y1=圆[j][1]；
if（Math.hypot（x0-x1，y0-y1）所以这里有一个非常基本的碰撞检查系统。每当你更新时，运行碰撞并传递你正在检查碰撞的圆的参数

function Collision (x, y, r) {
    for (i=0; i<circles.length; i++) {
        //Distance formula
        if (Math.sqrt((x-circles[i].x)(x-circles[i].x) + (y-circles[i].y)(y-circles[i].y) < r) {
            return true;
    }
}

此外，您还可以查看我创建的一个项目的源代码，该项目使用许多圆圈，并检查所有圆圈与播放器之间的碰撞。
因此，这里有一个非常基本的碰撞检查系统。无论何时更新，都要运行碰撞并传递要检查碰撞的圆圈的参数

function Collision (x, y, r) {
    for (i=0; i<circles.length; i++) {
        //Distance formula
        if (Math.sqrt((x-circles[i].x)(x-circles[i].x) + (y-circles[i].y)(y-circles[i].y) < r) {
            return true;
    }
}

此外，您可以查看我创建的一个项目的来源，该项目使用了许多圆圈，并检查所有圆圈与播放器之间的碰撞。
这里有一个更完整的答案，我没有尝试将圆圈可视化，因此我很难确定这是否完全正确，但我认为这应该会让您更接近

我认为算法是O（N^2），所以不会很快，但我采取的策略是在每个重叠的圆上建立一个索引，然后使用该点找到一个，然后基本上通过重叠索引递归，找到它在一个组中关联的所有圆

代码如下：

function circleCollisionDetect (c1, c2) {
  var dx = c1[0] - c2[0]
  var dy = c1[1] - c2[1]
  var distance = Math.sqrt(dx * dx + dy * dy)
  return distance < c1[2] + c2[2]
}

function circlePointCollisionDetect (p, c) {
  const dx = p[0] - c[0]
  const dy = p[1] - c[1]
  const distance = Math.sqrt(dx * dx + dy * dy)
  return distance < c[2]
}

function search (i, circles, index) {
  const group = []
  function follow(i) {
    if (!~group.indexOf(i)) {
      group.push(i)
      const overlaps = index[i]
      for (let x = 0, n = overlaps.length; x < n; x++) {
        follow(overlaps[x])
      }
    }
  }
  follow(i)
  return group
}

const circles = [
  [6, 19, 1],
  [6, 11, 4],
  [8, 17, 3],
  [19, 19, 2],
  [19, 11, 4],
  [15, 7, 6],
  [12, 19, 4]
]
const overlaps = []
const p = [10, 19]

// Find one that overlaps the starting point
const c = circles.find(c => circlePointCollisionDetect(p, c))
const start = circles.indexOf(c)

// Build an index of all overlapping circles
for (let a = 0, n = circles.length; a < n; a++) {
  for (let b = 0; b < n; b++) {
    const c1 = circles[a]
    const c2 = circles[b]
    if (c1 === c2) continue;
    if (!overlaps[a]) overlaps[a] = []
    if (circleCollisionDetect(c1, c2)) overlaps[a].push(b)
  }
}

// Next search through the index recursively for unique overlapping circles
const overlapping = search(start, circles, overlaps)

console.log('start:', start)
console.log('index:', overlaps)
console.log('overlapping:', overlapping)

因此，基本上，除了
[19,19,2]
之外，它们都是相互重叠的，对吗？
这里有一个更完整的答案，我没有试图将圆圈形象化，所以我很难确定这是完全正确的，但我认为这会让你更接近

我认为算法是O（N^2），所以不会很快，但我采取的策略是在每个重叠的圆上建立一个索引，然后使用该点找到一个，然后基本上通过重叠索引递归，找到它在一个组中关联的所有圆

代码如下：

function circleCollisionDetect (c1, c2) {
  var dx = c1[0] - c2[0]
  var dy = c1[1] - c2[1]
  var distance = Math.sqrt(dx * dx + dy * dy)
  return distance < c1[2] + c2[2]
}

function circlePointCollisionDetect (p, c) {
  const dx = p[0] - c[0]
  const dy = p[1] - c[1]
  const distance = Math.sqrt(dx * dx + dy * dy)
  return distance < c[2]
}

function search (i, circles, index) {
  const group = []
  function follow(i) {
    if (!~group.indexOf(i)) {
      group.push(i)
      const overlaps = index[i]
      for (let x = 0, n = overlaps.length; x < n; x++) {
        follow(overlaps[x])
      }
    }
  }
  follow(i)
  return group
}

const circles = [
  [6, 19, 1],
  [6, 11, 4],
  [8, 17, 3],
  [19, 19, 2],
  [19, 11, 4],
  [15, 7, 6],
  [12, 19, 4]
]
const overlaps = []
const p = [10, 19]

// Find one that overlaps the starting point
const c = circles.find(c => circlePointCollisionDetect(p, c))
const start = circles.indexOf(c)

// Build an index of all overlapping circles
for (let a = 0, n = circles.length; a < n; a++) {
  for (let b = 0; b < n; b++) {
    const c1 = circles[a]
    const c2 = circles[b]
    if (c1 === c2) continue;
    if (!overlaps[a]) overlaps[a] = []
    if (circleCollisionDetect(c1, c2)) overlaps[a].push(b)
  }
}

// Next search through the index recursively for unique overlapping circles
const overlapping = search(start, circles, overlaps)

console.log('start:', start)
console.log('index:', overlaps)
console.log('overlapping:', overlapping)

因此，基本上它们都是相互重叠的，除了
[19,19,2]
，是否正确？
您是指相互重叠的圆还是与起点重叠的圆？彼此重叠，但开始重叠的第一个圆是起点在其中的圆。请注意，起点在其中的圆可以不止一个。然后，您希望所有重叠的圆都从这里开始在一个组中相互关联？不仅仅是那些与起始圆重叠的圆？嗯，是的，我想是的。基本上，从“圆”数组中我想过滤掉重叠的圆（数组“重叠”），但其中至少有一个必须有起始点。你关心算法是O（N^2）吗或者我们在这里讨论的最大圆集大小是多少？你是指相互重叠的圆还是与起点重叠的圆？相互重叠，但开始重叠的第一个圆是起点在其中的圆。请注意，起点在其中的圆可以不止一个。然后嗯，你想把所有相互重叠的圆放在一个组中吗？不仅仅是那些与起始圆重叠的圆？嗯，是的，我想是这样。基本上，从“圆”数组中，我想过滤掉重叠的圆（数组“重叠”），但其中至少有一个必须有起始点。你关心算法是O（N^2）吗或者我们在这里讨论的最大圆集大小是多少？是的，但是如何正确地循环圆？我想创建一个重叠圆的分支树，其中至少有一个必须有起点。使用搜索算法更新HMI想运行它，但它抛出错误“重叠未定义”。此外，我忘了o添加我们也有一个终点，就像起点一样，它必须在一个重叠的圆圈中。它基本上是关于建立一个重叠圆圈的路线图，起始圆圈包含起点，最后一个圆圈包含终点。为我的原始帖子添加了澄清。好的，再试一次，我在重命名某个圆圈时把它弄糟了在这里发布之前，它还没有处理结束点，但它应该能够。虽然我认为这个问题的答案是，要解决这个问题，你需要建立一个所有重叠的索引。然后你可以使用这个重叠索引来解决你的问题，或者任何与重叠圆相关的问题。是的，但是如何循环这个问题呢圆是否正确？我想创建一个重叠圆的分支树，其中至少有一个必须有起点。使用搜索算法更新HMI想运行它，但它抛出错误“重叠未定义”。此外，我忘了添加我们也有一个终点，就像起点一样，它必须在重叠的c中ircles。它基本上是关于构建重叠圆的路线图，起始圆包含sta
start: 2
index: [ [ 2 ], [ 2, 5 ], [ 0, 1, 6 ], [], [ 5 ], [ 1, 4 ], [ 2 ] ]
overlapping: [ 2, 0, 1, 5, 4, 6 ]