Question

我有一个像下面这样的数组......

var my_array = [
  '00000000000000000000000',
  '00000011111111000000000',
  '00000011111111000000000',
  '00000011111111000000000',
  '00000011111111000000000',
  '00000011111111000000000',
  '00000000000000000000000',
]

...我希望得到一个能够计算 1个字符的边界（ 4个角位）的函数上面的数组。

所以我的结果应该是这样的：

var result= {
  'top-left' : [6,1],
  'bottom-left' : [6,5],
  'top-right' : [13,1],
  'bottom-right' : [13,5]
}

此外，该函数应该能够处理旋转的数组，如下面的示例数组：

var rotated_array = [
  "00000000000000000000000",
  "00000000001100000000000",
  "00000000111110000000000",
  "00000001111111000000000",
  "00000111111111100000000",
  "00000111111111000000000",
  "00000011111100000000000",
  "00000001110000000000000",
  "00000000100000000000000",
  "00000000000000000000000",
  "00000000000000000000000"
]

// array ----> result should be something like this:

var result= {
  'top-left' : [5,5],
  'bottom-left' : [8,8],
  'top-right' : [11,1],
  'bottom-right' : [14,4]
}

我开发了一个能够返回＆＃39; 1＆＃39; -characters-positions（x / y-positions）数组的函数，所以我将得到一个结果数组（来自{{ 1}}）像这样：

my_array

因为上面的arraylist包括我的矩形的所有位置，它还应该包括4个角位置......但是如何获得正确的坐标？

我的想法是过滤数组最大xValue，最大yValue，最小xValue和最小yValue以获得4个角。声音很好，但我的角落也有多种可能性：

＆＃13;

var positions = [[7,2],[7,1],[6,1],[6,2],[6,3],[6,4],[6,5],[7,5],[7,4],[7,3],[8,3],[8,2],[8,1],[9,1],[9,2],[9,3],[9,4],[9,5],[8,5],[8,4],[10,5],[10,4],[10,3],[10,2],[10,1],[11,1],[11,2],[11,3],[11,4],[11,5],[12,5],[12,4],[12,3],[12,2],[12,1],[13,1],[13,2],[13,3],[13,4],[13,5]]

＆＃13;

所以上面的代码返回如下内容：

var positions = [[7,2],[7,1],[6,1],[6,2],[6,3],[6,4],[6,5],[7,5],[7,4],[7,3],[8,3],[8,2],[8,1],[9,1],[9,2],[9,3],[9,4],[9,5],[8,5],[8,4],[10,5],[10,4],[10,3],[10,2],[10,1],[11,1],[11,2],[11,3],[11,4],[11,5],[12,5],[12,4],[12,3],[12,2],[12,1],[13,1],[13,2],[13,3],[13,4],[13,5]]


var corners = {
    'maxX': positions.filter(e => e[0] === Math.max(...positions.map(e => e[0]))),
    'minX': positions.filter(e => e[0] === Math.min(...positions.map(e => e[0]))),
    'maxY': positions.filter(e => e[1] === Math.max(...positions.map(e => e[1]))),
    'minY': positions.filter(e => e[1] === Math.min(...positions.map(e => e[1])))
  }
  
console.log(JSON.stringify(corners))

但是如何从上面的结果中获得每个角的正确坐标？我绝对不知道如何计算正确的，所以我希望有人可以帮助我实现我的功能..

提前致谢，乔纳斯

Answer 1

这是对问题的评论的延伸。转换为矢量并找到＆＃34;像素＆＃34;最接近角落。

如果你能识别＆＃34; 1＆＃34;边界正方形（检测从左到右和从上到下的变化）和
确定哪些＆＃34; 1＆＃34;谁属于广场的哪一边，你可以使用＆＃34;最小距离＆＃34;来计算4个边界中每个边界的矢量。

之后，您可以计算线条之间的交点，并且您有角落。

最小距离和交点线是标准的几何运算，你可以google。我不记得他们是对的。

Answer 2

function findExtremes( array ){
  let upRight = array[0],
        downRight = array[0],
        downLeft = array[0],
        upLeft = array[0];

  for(const [x,y] of array){
    if(x < downRight[0] || x === downRight[0] && y < downRight[1]) downRight = [x,y];
    if(x > upRight[0] || x === upRight[0] && y > upRight[1]) upRight = [x,y];

    if(y > upLeft[1] || y === upLeft[1] && x < upLeft[0]) upLeft = [x,y];
    if(y < downLeft[1] || y === downLeft[1] && x > downLeft[0]) downLeft = [x,y];
  }
  return {downRight, downLeft, upRight, upLeft};
}

代码的工作原理如下：

x < downRight[0]

第一部分确保我们采用最小的x值。或者，如果

x === downRight[0]

我们有两个最小的x值，我们采取

 y < downRight[1]

y较小的那个。

Javascript：在2d矩阵（数组）中找到矩形的角位置

2 个答案: