python图像分割重组_python – 快速将图像分割成重叠的补丁并将补丁合并到图像中...

偏执的太偏执、 2022-10-25 14:29 258阅读 0赞

尝试将大小为100×100的灰度图像分割成大小为39×39的补丁,重叠,大小为1.这意味着,向下或向下开始一个像素的下一个补丁仅与之前的补丁不同一个额外的列/或行.

粗糙的代码概要：首先计算每个补丁的索引,以便能够

从图像构建补丁的2D阵列,并能够从补丁构建图像：

patches = imgFlat\[ind\]

‘patches’是一个2D数组,每列包含向量形式的补丁.

处理这些修补程序,每个补丁单独,然后再次与预先计算的索引合并到一个图像.

img = np.sum(patchesWithColFlat\[ind\],axis=2)

随着补丁重叠,最终需要将img与预先计算的权重相乘：

imgOut = weights\*imgOut

我的代码真的很慢,速度是一个关键问题,因为这应该在ca上完成. 10 ^ 8个补丁.

函数get\_indices\_for\_un\_patchify和weights\_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())

python图像分割重组_python – 快速将图像分割成重叠的补丁并将补丁合并到图像中...

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Python实现图像分割算法

相关 Python实现GrabCut图像分割算法

相关 Python图像处理：基于边缘/区域的图像分割

相关 python图像分割重组_python – 快速将图像分割成重叠的补丁并将补丁合并到图像中...

相关图像语义分割

相关图像分割___图像分割方法综述

相关图像分割

相关图像分割

相关【opencv-python 3】图像通道分割与合并

相关数字图像处理中的图像分割