Question

我很难概念化一个三维矩阵，我需要一个真实表。我试图通过一个3D矩阵，并将每个元素与其相邻的所有其他元素进行比较（但不是对角线）。我有一个函数（truth_table），它应该采用一组3D坐标并返回一个矩阵，告诉我哪些周围的坐标可以安全地调用而不用担心INDEX_OUT_OF_BOUNDS异常。我是N维矩阵的新手，我在制作这个真值表方面遇到了麻烦，这在2D中很容易。

import numpy as np
array_rows=10
array_cols=10
array_height=10
laser_power=2e-3

T_MATRIX=np.full((array_rows,array_cols,array_height),0.0)
H_MATRIX=np.full((array_rows,array_cols,array_height),0.0)
H_MATRIX[5,5,5]=laser_power
constants=0.5

def truth_table(row,col,height):
    skeleton=np.array([
    [[False,False,False],[False,height<array_height-1,False],[False,False,False]],[[False,row>0,False],[col>0,False,col<array_cols-1],[False,row<array_rows-1,False]],[[False,False,False],[False,height>0,False],[False,False,False]]])

def update_T():
    global T_MATRIX
    for row in range(array_rows):
        for col in range(array_cols):
            for height in range(array_height):
                T_MATRIX[row][col][height]+=H_MATRIX[row][col][height]*constants

def reset_H():
    global H_MATRIX
    for row in range(array_rows):
        for col in range(array_cols):
            for height in range(array_height):
                H_MATRIX[row][col][height]=0.0
    H_MATRIX[5,5,5]=laser_power

def update_H():
    global H_MATRIX
    for row in range(array_rows):
        for col in range(array_cols):
            for height in range(array_height):
                my_table=truth_table(row,col,height)
                count=np.sum(my_table)
                T_DIFF=0.0
                AVG_T=0.0
                for r in range(3):
                    for c in range(3):
                        for h in range(3):
                            if(my_table[r][c][h]):
                                T_DIFF+=T_MATRIX[row][col][height]-T_MATRIX[row+(r-1)][col+(c-1)][height+(h-1)]
                if(count>0):
                    AVG_T=T_DIFF/count
                H_MATRIX[row][col][height]+=T_DIFF*constants


def update_stuff():
    ##UPDATE THE TEMP
    update_T()
    reset_H()
    update_H()


update_stuff()
print T_MATRIX[5][5][5]
#print constants

Answer 1

因为这个问题可能会被放弃或关闭，所以这可能有助于您思考这个问题。您似乎正在做的事情是，您有兴趣计算单元格值与其最近邻居的值之间的差异/平均值。

在3D晶格上，细胞的最近邻居位于以下位置（以感兴趣的细胞为中心）：

f = np.zeros((3,3,3))
f[[0,1,1,1,1,2],[1,0,1,1,2,1],[1,1,0,2,1,1]] = 1

可以使用numpy构建

>>> A1 = np.arange(27).reshape(3,3,3)
>>> A1
array([[[ 0,  1,  2],
        [ 3,  4,  5],
        [ 6,  7,  8]],

       [[ 9, 10, 11],
        [12, 13, 14],
        [15, 16, 17]],

       [[18, 19, 20],
        [21, 22, 23],
        [24, 25, 26]]])

>>> A2 = scipy.ndimage.convolve(A1, f)
>>> A2
array([[[ 13,  18,  23],
        [ 28,  33,  38],
        [ 43,  48,  53]],

       [[ 58,  63,  68],
        [ 73,  78,  83],
        [ 88,  93,  98]],

       [[103, 108, 113],
        [118, 123, 128],
        [133, 138, 143]]])

具有任何形状（N1，N2，N3）的3D阵列A1的此最近邻滤波器（或内核）的convolution将为您提供一个新形状的阵列A2（N1，N2，N3） A2中的每个值都是A1中邻居值的总和。例如：

H_MATRIX

A2的第一个条目是13 = 1 + 3 + 9.A2的中间条目是78 = 4 + 10 + 12 + 14 + 16 + 22.

您可以使用这些卷积轻松获得您正在寻找的一些数量。看起来H_MATRIX = constants * (T_MATRIX - convolve(T_MAXTRIX, f))可以简单地通过

构建

使用上面定义的f。或者，您可以定义一个不同的H_MATRIX = constants * convolve(T_MATRIX, f)，其中心位置为1，其他6个位置为-1，这可能只会为您提供public $belongsToMany = [ 'typeswb' => [ 'Yeoman\Wordbank\Models\Type', 'table'=>'yeoman_wordbank_types_pivotb', 'key' =>'word_id ', 'otherKey' => 'type_id ', 'pivot' => ['word_id ', 'type_id '], ], ];。

3D矩阵真值表

1 个答案: