逐像素循环以计算图像熵的更快方法

Question

我一直在用逐像素卷积运算计算图像的熵，它一直在工作，但速度很慢，随着内核大小的增加执行时间增加。

这是我的函数代码，首先在代码中我使用 gdal 读取图像并将其转换为数组以将其传递给函数。

@jit
def convolution (ArrayES, ImArray, rows, cols, kernel, option):
    for row in prange(rows):
        for col in prange(cols):
            Lx=max(0,col-kernel+1)
            Ux=min(cols,col+kernel+1)
            Ly=max(0,row-kernel+1)
            Uy=min(rows,row+kernel+1)
            mask=ImArray[Ly:Uy,Lx:Ux].flatten()
            He=0.0
            lenVet=mask.size
            horList=list(set(mask))
            if len(horList)==1 and horList.count(0)==1:
                ArrayES[row,col]=0.0
            else:
                T7=time.time()
                prob=[(mask[mask==i]).size/(lenVet*1.0) for i in horList]
                for p in prob:
                    if p>0:
                        He += -1.0*p*np.log2(p)
                if option==0:
                    ArrayES[row,col]=He
                N=len(horList)*1.0
                if N == 1:
                    C=0
                else:
                    Hmax=np.log2(N)
                    C=He/Hmax
                if option==1:
                    ArrayES[row,col]=C
                if option==2:
                    SDL=(1-C)*C
                    ArrayES[row,col]=SDL
                if option==3:
                    D = 0.0
                    for p in prob:
                        D += (p-(1/N))**2
                    LMC=D*C
                    ArrayES[row,col]=LMC
    return ArrayES

问题是当内核数>7时。 我该如何改进它？

Answer 1

与 matlab 类似，加快此类运算的关键称为“矢量化”。基本上，移除 for 循环并将您的计算转换为向量和矩阵运算 - 对于每个步骤，找到一种方法来对所有合格像素进行分组并使用一次调用对其进行操作。

阅读本文了解更多详情

https://www.geeksforgeeks.org/vectorization-in-python/

许多方法类似于matlab中的向量化

https://www.mathworks.com/help/matlab/matlab_prog/vectorization.html https://blogs.mathworks.com/videos/2014/06/04/vectorizing-code-in-matlab/