尝试将100x100大小的灰度图像分割为39x39大小的重叠块,步长为1。这意味着从右/或下一个像素开始的下一个修补程序只与另一列/或行中的上一个修补程序不同。
代码的大致轮廓:首先计算每个补丁的索引,以便能够 从图像构造面片的二维数组,并能够从面片构造图像:
patches = imgFlat[ind]
“patches”是一个二维数组,每列包含一个向量形式的补丁。
这些面片被处理,每个面片被单独合并,然后用预先计算的索引再次合并到一个图像中。
img = np.sum(patchesWithColFlat[ind],axis=2)
当补丁重叠时,有必要在最后将img与预先计算的权重相乘:
imgOut = weights*imgOut
我的代码非常慢,速度是一个关键问题,因为这应该在大约10^8个补丁上完成。
函数get_index_for_un_patchify和weights_unpatchify可以预先计算一次,因此速度只是patchify和unpatchify的问题。
谢谢你的小费。
卡洛斯
import numpy as np
import scipy
import collections
import random as rand
def get_indices_for_un_patchify(sImg,sP,step):
''' creates indices for fast patchifying and unpatchifying
INPUTS:
sx image size
sp patch size
step offset between two patches (default == [1,1])
OUTPUTS:
patchInd collection with indices
patchInd.img2patch patchifying indices
patch = img(patchInd.img2patch);
patchInd.patch2img unpatchifying indices
NOTE: * for unpatchifying necessary to add a 0 column to the patch matrix
* matrices are constructed row by row, as normally there are less rows than columns in the
patchMtx
'''
lImg = np.prod(sImg)
indImg = np.reshape(range(lImg), sImg)
# no. of patches which fit into the image
sB = (sImg - sP + step) / step
lb = np.prod(sB)
lp = np.prod(sP)
indImg2Patch = np.zeros([lp, lb])
indPatch = np.reshape(range(lp*lb), [lp, lb])
indPatch2Img = np.ones([sImg[0],sImg[1],lp])*(lp*lb+1)
# default value should be last column
iRow = 0;
for jCol in range(sP[1]):
for jRow in range(sP[0]):
tmp1 = np.array(range(0, sImg[0]-sP[0]+1, step[0]))
tmp2 = np.array(range(0, sImg[1]-sP[1]+1, step[1]))
sel1 = jRow + tmp1
sel2 = jCol + tmp2
tmpIndImg2Patch = indImg[sel1,:]
# do not know how to combine following 2 lines in python
tmpIndImg2Patch = tmpIndImg2Patch[:,sel2]
indImg2Patch[iRow, :] = tmpIndImg2Patch.flatten()
# next line not nice, but do not know how to implement it better
indPatch2Img[min(sel1):max(sel1)+1, min(sel2):max(sel2)+1, iRow] = np.reshape(indPatch[iRow, :, np.newaxis], sB)
iRow += 1
pInd = collections.namedtuple
pInd.patch2img = indPatch2Img
pInd.img2patch = indImg2Patch
return pInd
def weights_unpatchify(sImg,pInd):
weights = 1./unpatchify(patchify(np.ones(sImg), pInd), pInd)
return weights
# @profile
def patchify(img,pInd):
imgFlat = img.flat
# imgFlat = img.flatten()
ind = pInd.img2patch.tolist()
patches = imgFlat[ind]
return patches
# @profile
def unpatchify(patches,pInd):
# add a row of zeros to the patches matrix
h,w = patches.shape
patchesWithCol = np.zeros([h+1,w])
patchesWithCol[:-1,:] = patches
patchesWithColFlat = patchesWithCol.flat
# patchesWithColFlat = patchesWithCol.flatten()
ind = pInd.patch2img.tolist()
img = np.sum(patchesWithColFlat[ind],axis=2)
return img
我把这些函数称为这里的随机图像
if __name__ =='__main__':
img = np.random.randint(255,size=[100,100])
sImg = img.shape
sP = np.array([39,39]) # size of patch
step = np.array([1,1]) # sliding window step size
pInd = get_indices_for_un_patchify(sImg,sP,step)
patches = patchify(img,pInd)
imgOut = unpatchify(patches,pInd)
weights = weights_unpatchify(sImg,pInd)
imgOut = weights*imgOut
print 'Difference of img and imgOut = %.7f' %sum(img.flatten() - imgOut.flatten())
“修补”数组的一种有效方法是,使用自定义的strides创建一个视图,即跳转到以下元素的字节数,将窗口数组“修补”到原始数组。把numpy数组看作(美化的)内存块是有帮助的,然后使用steps将索引映射到内存地址。
例如,在
a.itemsize
等于4(即每个元素4字节或32位),并且a.strides
是(20, 4)
(5个元素,1个元素),因此a[1,2]
指第一个元素之后的1*20 + 2*4
字节(或1*5 + 2
元素):事实上,这些元素一个接一个地放在内存中,
0 1 2 3 4 5 6 7 x x
,但是这些步骤让我们将其作为一个2D数组进行索引。在这个概念的基础上,我们可以重写
patchify
如下此函数返回
img
的视图,因此不分配内存,它仅在几十微秒内运行。输出形状并不完全是您想要的,事实上,必须复制它才能得到该形状。在处理比基数组大得多的数组视图时,必须小心,因为操作会触发一个需要分配大量内存的副本。在您的例子中,因为数组不是太大,并且没有那么多补丁,所以应该没问题。
最后,我们可以稍微解开补丁数组:
这不会重现patchify函数的输出,因为您可以按Fortran顺序开发这些修补程序。我建议你改用这个,因为
这将导致以后更自然的索引(即,第一个补丁是patches[0],而不是patches[:,0]用于您的解决方案)。
在numpy中,到处使用C排序也更容易,因为您需要更少的输入(避免了order=-F这样的东西,默认情况下数组是按C顺序创建的…)。
“提示”如果您坚持:
strides = img.itemsize * np.array([1, Y, Y, 1])
,请在contiguous_patches
上使用.reshape(..., order='F')
,最后将其转置.T
相关问题 更多 >
编程相关推荐