需求：

因项目需求中有对照片分辨率的具体要求，需要进行已有照片的批量分辨率处理。已有照片统一为1024*768分辨率，要求处理成320*240 / 240*200两种分辨率形式。

难点：

对方要求中的240*200分辨率大小与我们已有照片分辨率不是同一个比例的。

解决方案：

如果直接resize(240,200)后，结果必要会存在变形的情况，那么需要考虑对目标进行裁剪。方法是先按较大的边进行等比例压缩，压缩后再根据目标比例选取中间区域进行裁剪。

# -*- coding:utf-8 -*-

"""批量调整照片大小

"""

__author__ = fatway

__email__ = fatway#gmail.com

VERSION = "Photo Resizer v1.0 build 2010-8-25"

import os

import sys

import time

import glob

import Image

class PicResizer:

"""根据指定的目录，对该目录下的所有照片进行大小调整

"""

def __init__(self, picpath, bakpath):

'''初始化参数'''

self.picpath = picpath

self.bakpath = bakpath

logfile = bakpath + "/log" + time.strftime("%Y%m%d%H%M") + ".txt"

self.log = open(logfile, "a")

def pic_walker(self, path):

'''获取指定目录下的所有JPG照片，不递归深入查找'''

target = []

for files in glob.glob(path + "/*.jpg"):

filepath,filename = os.path.split(files) # todo: mark

target.append(filename)

return target

def check_folder(self, subFolderName):

'''检查目标文件夹是否存在，不存在则创建之'''

foldername = self.bakpath + '/' + subFolderName

print foldername

if not os.path.isdir(foldername):

os.mkdir(foldername)

#return 0

return foldername

def pic_info(self, img):

'''获取照片的尺寸'''

w, h = img.size

if w>h:

return w, h, 0 # 横版照片

else:

return w, h, 1 # 竖版照片

def comp_num(self, x, y):

'''比较两个实数

如果是用直接比较话会出现经典的整数除得0问题

'''

x = float(x)

y = float(y)

return float(x/y)

def pic_resize(self, picname, p_w, p_h):

'''根据设定的尺寸，对指定照片进行像素调整'''

# 获取指定照片的规格，一般是1024,768

img = Image.open(picname)

w, h, isVertical = self.pic_info(img)

# 判断照片横竖，为竖版的话对调w,h

if isVertical:

p_w, p_h = p_h, p_w

# 如果照片调整比例合适，直接输出

if self.comp_num(p_h, p_w) == self.comp_num(h, w):

target = img.resize(

(int(p_w), int(p_h)),

Image.ANTIALIAS # hack: 参数呐！高保真必备！

)

# ANTIALIAS: a high-quality downsampling filter

# BILINEAR: linear interpolation in a 2x2 environment

# BICUBIC: cubic spline interpolation in a 4x4 environment

return target

# 比例不合适就需要对照片进行计算，保证输出照片的正中位置

# 算法灵感来源于ColorStrom

if self.comp_num(p_h, p_w) > self.comp_num(h, w):

# 240/320 > 360/576 偏高照片的处理

# 以高为基准先调整照片大小

p_w_n = p_h * self.comp_num(w,h) # 根据新高按比例设置新宽

temp_img = img.resize(

(int(p_w_n), int(p_h)),

Image.ANTIALIAS

)

# 获取中间选定大小区域

c = (p_w_n - p_w)/2 # 边条大小

box = (c, 0, c+p_w, p_h) # 选定容器

box = tuple(map(int, box)) # 转换成crop需要的int形参数

target = temp_img.crop(box)

return target

else:

# 偏宽的照片

# 以宽为基准先调整照片大小

p_h_n = p_w * self.comp_num(h, w) # 根据新宽按比例设置新高

temp_img = img.resize(

(int(p_w), int(p_h_n)),

Image.ANTIALIAS

)

# 获取新图像

c = (p_h_n - p_h)/2

box = (0, c, p_w, c+p_h)

box = tuple(map(int, box))

target = temp_img.crop(box)

return target

def run_auto(self, *args):

'''运行调整照片尺寸进程

接纳规格列表，每个规格为一个tuple

'''

# 获取所有图片列表

imglist = self.pic_walker(self.picpath)

# 处理照片

for img in imglist:

imgfile = self.picpath + "/" + img # 完整照片名称

try:

for std in args:

w, h = std[0], std[1] # 获取目标照片规格

# 定义目标文件

opfile = self.check_folder(str(w)+"x"+str(h)) + "/" + img

tempimg = self.pic_resize(imgfile, int(w), int(h))

tempimg.save(opfile, 'jpeg')

#self.log.write(str(img) + "\tOK\n")

except:

self.log.write(str(img) + "\tErr\n")

print '-->' + img

print "Done."

def main():

'''主函数'''

# picpath = bakpath = raw_input("type your photo's path:")

# 修改源照片文件夹路径

picpath = "E:/BB_Exchange"

# 修改为你的目标路径

bakpath = "E:/BB_Exchange"

# 实例一个进程并运行

resizer = PicResizer(picpath, bakpath)

resizer.run_auto((320, 240),(240,200))

if __name__ == "__main__":

sys.exit(main())

我首先要说的是，你的“只装箱”方式似乎很不寻常，我想这正是@ljetibo在评论中所指的。在“优化”讨论之后，我将回到这个话题。在

首先，您可以通过去掉对np.copy的多余调用来稍微改进代码，因为您只需将重新绑定到传入的img的视图。ravel操作将返回一个副本，除非图像形状是binning因子bin_fac的倍数。在

现在，虽然列表理解速度很快，但是您正在从一个可能不连续的列表中重新创建一个numpy数组，这意味着您要再次将内存从一个位置复制到另一个位置。这些都是消耗效率的操作。在

您可能感兴趣的是在原始图像上生成一个内存高效的视图。这就是as_strided的作用：from numpy.lib.stride_tricks import as_strided

def strided_rescale(g, bin_fac):

strided = as_strided(g,

shape=(g.shape[0]//bin_fac, g.shape[1]//bin_fac, bin_fac, bin_fac),

strides=((g.strides[0]*bin_fac, g.strides[1]*bin_fac)+g.strides))

return strided.mean(axis=-1).mean(axis=-1) # order is NOT important! See notes..

时序考虑表明，这通常比原始方法快一点，随着装箱因子的增加，性能得到改善：

^{2}$

我相信在数组相等性方面观察到的细微差异是由于复制操作，即从numpy数据类型返回到普通Python浮点，反之亦然。但我不能百分之百肯定。在

现在优化讨论已经结束，让我们回到您的binning方法。在当前的实现中，您已经将图像分割成正方形、不重叠的区域。在这个故事的其余部分，这些子矩阵不必是正方形的，它们可以是矩形的(如果图像的纵横比可以改变的话)，并且结论仍然有效。所以，在每个子矩阵中，取行平均值，然后取结果列向量的平均值。很容易从数学上证明，这和取整个子矩阵的平均值是一样的。这是个好消息，因为这意味着在上面显示的strided_rescale函数中，您可以简单地将return语句替换为：return gstr.mean(axis=(-2,-1))

这将给你另一个(小)提速。在

我认为使用^{}是一个非常好的建议，直到我用一个dtype在ndarrays上尝试过了！= np.uint8公司. 即使如此，必须正确选择mode参数，并且它似乎只取子矩阵的左上角：In [39]: a = np.arange(16, dtype=np.uint8).reshape(4,4)

In [40]: a

Out[40]:

array([[ 0, 1, 2, 3],

[ 4, 5, 6, 7],

[ 8, 9, 10, 11],

[12, 13, 14, 15]], dtype=uint8)

In [41]: imresize(a, (2,2), mode='P')

Out[41]:

array([[ 0, 2],

[ 8, 10]], dtype=uint8)

In [42]: imresize(a, (2,2), mode='L')

Out[42]:

array([[0, 1],

[6, 7]], dtype=uint8)

这可能不是你想要的。所以stride_技巧对实际的binning很有效。如果您希望平滑调整大小的行为(例如，通过使用样条插值)，您将看到Python图像库和所有在幕后使用它的函数，例如OpenCV，它也提供了summarized in this post的大小调整行为。在