javascript - “缝合”多个二维阵列

编辑（重述问题）：
如何使用提供的smoothstep函数在相邻的2d数组之间创建渐变每个数组大小相同，包含0到1之间的值，通过单纯形噪声从边到边平滑过渡。因此，我希望在MaxMUMUM 0.04之间相邻数组值之间的差异。

function smoothstep (min, max, value) {
    var x = Math.max(0, Math.min(1, (value-min)/(max-min)));
    return x*x*(3 - 2*x);
};

我有6个二维数组，包含0到1之间的值来表示球体表面的高度要遍历数组的所有值，请执行以下操作：

for (var i = 0; i < cube.faces.length; i++) {
    for (var x = 0; x < cube.faces[i].heightMap.length; x++) {
        for (var z = 0; z < cube.faces[i].heightMap.length; z++) {
            if (x == 0 || x == cube.faces[i].heightMap.length - 1 || z == 0 || z == cube.faces[i].heightMap.length - 1) {
                switch (i) {
                    case 0:
                        if (x == 0) {
                            //match left of face 1 to top of face 4
                        } else if (z == 0) {
                            //match top of face 1 to top of face 6
                        } else if (z == cube.faces[i].heightMap.length - 1) {
                            //match bottom of face 1 to top of face 5
                        } else {
                            //match right of face 1 to top of face 3
                        }
                        break;
                    case 1:
                        if (x == 0) {
                            //match left of face 2 to bottom of face 3
                        } else if (z == 0) {
                            //match top of face 2 to bottom of face 6
                        } else if (z == cube.faces[i].heightMap.length - 1) {
                            //match bottom of face 2 to bottom of face 5
                        } else {
                            //match right of face 2 to bottom of face 4
                        }
                        break;
                    case 2:
                        if (x == 0) {
                            //match left of face 3 to right of face 5
                        } else if (z == 0) {
                            //~~match top of face 3 to right of face 1~~
                        } else if (z == cube.faces[i].heightMap.length - 1) {
                            //~~match bottom of face 3 to left of face 2~~
                        } else {
                            //match right of face 3 to left of face 6
                        }
                        break;
                    case 3:
                        if (x == 0) {
                            //match left of face 4 to right of face 6
                        } else if (z == 0) {
                            //~~match top of face 4 to left of face 1~~
                        } else if (z == cube.faces[i].heightMap.length - 1) {
                            //~~match bottom of face 4 to right of face 2~~
                        } else {
                            //match right of face 4 to left of face 5
                        }
                        break;
                    case 4:
                        break;
                    case 5:
                        break;
                    default:
                        break;
                }
            }
        }
    }
}

不过，我有一些困难，使面孔匹配。我发现了一个名为“smoothstep”的函数，它似乎正是我所需要的。我不知道如何实现它，我还没有找到一个对我有用的解释。

function smoothstep(min, max, value) {
    var x = Math.max(0, Math.min(1, (value - min) / (max - min)));
    return x * x * (3 - 2 * x);
};

下一页是我学习这种方法的地方，但我无法理解要说什么如果有人有时间的话，你能解释一下我是如何把这个应用到我的情况中的吗？Link to related question

最佳答案

回复：smoothstep，我在python的idle解释器中快速地重新创建了这个函数，这样我就可以将值插入其中并得到即时结果，而且尽可能接近我所知，它所做的只是将最小值拉伸到0，将最大值拉伸到1，然后相应地规范化值参数。
例如，如果提供的参数(0.2, 0.4, 0.3)0.3介于0.2和0.4之间，则函数会将该值规格化为大约0.5
你只是想用与A边和B边相交的50个数组行/列创建一个数字的立体渐变吗？
如果是的话，我不知道smoothstep是不是一条路。
不管怎样，对于这样的事情，我会拿出一张纸，在中间画出一个数组id，然后标记边缘（假设下面的例子中是骰子脸模式）：

        |--A--|
        D  3  B
        |--C--|

        |--A--|
        D  1  B
        |--C--|

|--A--| |--A--| |--A--|
D  2  B D  4  B D  5  B
|--C--| |--C--| |--C--|

        |--A--|
        D  6  B
        |--C--|

然后在你的脑海中把它折叠起来（或者把它剪下来，然后把立方体物理地折叠起来），找到边对，然后画箭头，指示从边向内进入脸的方向（我喜欢用N（orth）、E（ast）、S（outh）、W（est）来想象从边缘往哪个方向走。
航向：

N = Same columnID, Start at max RowID and decrement  (going north)
E = Same rowID, Start at min ColumnID and increment  (going east)
S = Same columnID, Start at min RowID and increment  (going south)
W = Same rowID, Start at max ColumnID and decrement  (going west)

最后你会得到一个类似于var list = [1,B,W,, 5,A,S,], [4,B,W,, 5,D,E,]...etc...]的列表（额外的逗号是有意的，表示列表中的空白，请填写下一步）
现在，这个列表被构建出来，你可以从每个数组中的任何方向抓取值，25行或列，将它插入空白空间中的列表中，你将得到绝对的最小值和最大值。例如var list = [[1,B,W,0.3, 5,A,S,0.7],...etc...]
如果它是一个立体渐变，你只需要做一些简单的数学运算，然后根据它是最小值还是最大值，在适当的方向上，从每个边的起始值开始递增或递减。
如果它比二维数组边之间的直线渐变更复杂，我很抱歉，但可能需要更好的可视化效果。