的Javascript：查找二维矩阵（阵列）

我有类似下面的数组矩形的角落位置...的Javascript：查找二维矩阵（阵列）

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

...我想获得一个功能就是能够计算（4个角位置）的1个字符在上面的数组中。

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

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] 
}

我开发了一个函数，能够返回'1 “-characters位（X/Y位上），所以我将得到一个结果阵列（从my_array）所示：

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]]

由于上面的数组列表包括我的矩形它还的所有位置应该包括4个角落位置......但如何获得正确的坐标？

我的想法是过滤阵列最大的x值，最大的y值，最小的x值和最小的y值，以获得4个角。听起来不错，但也有我的角落多种可能性：

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))

所以上面的代码返回是这样的：

{ 
"maxX":[[13,1],[13,2],[13,3],[13,4],[13,5]], // x values are all 13 (max) 
"minX":[[6,1],[6,2],[6,3],[6,4],[6,5]], // x values are all 6 (min) 
"maxY":[[6,5],[7,5],[9,5],[8,5],[10,5],[11,5],[12,5],[13,5]], // y values are all 5 (max) 
"minY":[[7,1],[6,1],[8,1],[9,1],[10,1],[11,1],[12,1],[13,1]] // y values are all 1 (min) 
}

但如何得到正确的坐标从上面的结果每个角落？我绝对无能如何计算是正确的，所以我希望有人能帮助我与我的功能..提前

谢谢，乔纳斯

来源

2017-11-18 Jonas0000

也许正确的一个不存在:-)。当您旋转正方形时，角将位于第1行和第2行之间（或0和1）。如果将光栅图像转换为矢量几何图形，则可以计算确切的位置转角，然后查找最接近的“网格”。 –

好的声音正确...但tbh我不知道如何将矩阵转换为矢量几何.. @AndersFinnJørgensen – Jonas0000

-1

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越小。

来源

2017-11-18 10:39:23

[试试看！]（http://jsbin.com/daconumose/edit?console） –

嘿乔纳斯，你的解决方案看起来非常好。非常感谢。但我得到一个错误，使用顺时针旋转的矩阵。请看这个小提琴：https://jsfiddle.net/ukq6nm91/1/ – Jonas0000

@jonas我不能看到一个广场那里... –

这是对该问题的评论的延伸。转换为矢量并找到离角落最近的“像素”。

如果你能确定的是毗邻广场的“1”（检测变化，从左至右，从上至下）和
标识“1”谁属于哪个广场，你可以边使用“最小距离”计算每个边界的矢量。

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

线的最小距离和交点是标准的几何操作，你可以谷歌。我不记得他们知道。

来源

2017-11-18 10:58:38

的Javascript：查找二维矩阵（阵列）

回答

相关问题