基于Python的图片识别系统程序

项目介绍

本项目将使用python3去识别图片是否为色情图片，会使用到PIL这个图像处理库，并且编写算法来划分图像的皮肤区域

介绍一下PIL：

PIL（Python Image Library）是一种免费的图像处理工具包，这个软件包提供了基本的图像处理功能，如：改变图像大小，旋转图像，图像格式转化，色场空间转换（这个我不太懂），图像增强（就是改善清晰度，突出图像有用信息），直方图处理，插值（利用已知邻近像素点的灰度值来产生未知像素点的灰度值）和滤波等等。虽然这个软件包要实现复杂的图像处理算法并不太适合，但是python的快速开发能力以及面向对象等等诸多特点使得它非常适合用来进行原型开发。

在 PIL 中，任何一副图像都是用一个 Image 对象表示，而这个类由和它同名的模块导出，因此，要加载一副图像，最简单的形式是这样的：

importImage
img=Image.open(“dip.jpg”)

注意：==第一行的 Image 是模块名；第二行的 img 是一个 Image 对象；== Image 类是在 Image 模块中定义的。关于 Image 模块和 Image 类，切记不要混淆了。现在，我们就可以对 img 进行各种操作了，所有对 img 的 操作最终都会反映到到 dip.img 图像上

环境准备

PIL 2009 年之后就没有更新了，也不支持 Python3 ，于是有了 Alex Clark 领导的公益项目 Pillow 。Pillow 是一个对 PIL 友好的分支，支持 Python3，所以我们这里安装的是 Pillow，这是它的官方文档。

默认已经有python3.0以上和包管理工具pip3。那要执行如下命令升级pip3并安装Pillow 工具包：

sudoinstall-Upip3
sudoinstallPillow

程序原理

根据颜色（肤色）找出图片中皮肤的区域，然后通过一些条件判断是否为色情图片。

程序的关键步骤如下：

遍历每个像素，检查像素颜色是否为肤色

将相邻的肤色像素归为一个皮肤区域，得到若干个皮肤区域

剔除像素数量极少的皮肤区域

我们定义非色情图片的判定规则如下（满足任意一个判断为真）：

皮肤区域的个数小于3个

皮肤区域的像素与图像所有像素的比值小于15%

最大皮肤区域小于总皮肤面积的45%

皮肤区域数量超过60个

这些规则你可以尝试更改，直到程序效果让自己满意为止。关于像素肤色判定这方面，公式可以在网上找到很多，但是世界上不可能有正确率100%的公式。你可以用自己找到的公式，在程序完成后慢慢调试。

RGB颜色模式

第一种：==r > 95 and g > 40 and g < 100 and b > 20 and max([r, g, b]) - min([r, g, b]) > 15 and abs(r - g) > 15 and r > g and r > b==

第二种：==nr = r / (r + g + b), ng = g / (r + g + b), nb = b / (r +g + b)，nr / ng > 1.185 and r * b / (r + g + b) ** 2 > 0.107 and r * g / (r + g + b) ** 2 > 0.112==

HSV颜色模式

==h > 0 and h < 35 and s > 0.23 and s < 0.68==

YCbCr颜色模式

==97.5 <= cb <= 142.5 and 134 <= cr <= 176==

一幅图像有零个到多个的皮肤区域，程序按发现顺序给它们编号，第一个发现的区域编号为0，第n个发现的区域编号为n-1

用一种类型来表示像素，我们给这个类型取名为Skin，包含了像素的一些信息：唯一的编号id、是/否肤色skin、皮肤区域号region、横坐标x、纵坐标y

遍历所有像素时，我们为每个像素创建一个与之对应的Skin对象，并设置对象的所有属性，其中region属性即为像素所在的皮肤区域编号，创建对象时初始化为无意义的None。关于每个像素的id值，左上角为原点，像素id值按照像素坐标排布，那么看起来如下图：

其实id的顺序也即遍历的顺序。遍历所有像素时，创建Skin对象后，如果当前像素为肤色，且相邻的像素有肤色的，那么我们把这些肤色像素归到一个皮肤区域。

相邻像素的定义：通常都能想到是当前像素周围的8个像素，然而实际上只需要定义4个就可以了，位置分别在当前像素的左方，左上方，正上方，右上方。因为另外四个像素都在当前像素后面，我们还未给这4个像素创建对应的Skin对象：

实现脚本

直接在python中新建nude.py文件，在这个文件进行代码编写：

导入所需要的模块：

importsys
importos
import_io
fromcollectionsimportnamedtuple
fromPILimportImage

我们将设计一个Nude类：

classNude:

这个类里面我们首先使用collections.namedtuple()定义一个 Skin 类型：

Skin=namedtuple("Skin","idskinregionxy")

collections.namedtuple()函数实际上是一个返回 Python 中标准元组类型子类的一个工厂方法。你需要传递一个类型名和你需要的字段给它，然后它就会返回一个类，你可以初始化这个类，为你定义的字段传递值等。详情参见官方文档。

然后定义 Nude 类的初始化方法：

def__init__(self,path_or_image):

#若path_or_image为Image.Image类型的实例，直接赋值
ifisinstance(path_or_image,Image.Image):
self.image=path_or_image
#若path_or_image为str类型的实例，打开图片
elifisinstance(path_or_image,str):
self.image=Image.open(path_or_image)

#获得图片所有颜色通道
bands=self.image.getbands()
#判断是否为单通道图片（也即灰度图），是则将灰度图转换为RGB图
iflen(bands)==1:
#新建相同大小的RGB图像
new_img=Image.new("RGB",self.image.size)
#拷贝灰度图self.image到RGB图new_img.paste（PIL自动进行颜色通道转换）
new_img.paste(self.image)
f=self.image.filename
#替换self.image
self.image=new_img
self.image.filename=f

#存储对应图像所有像素的全部Skin对象
self.skin_map=[]
#检测到的皮肤区域，元素的索引即为皮肤区域号，元素都是包含一些Skin对象的列表
self.detected_regions=[]
#元素都是包含一些int对象（区域号）的列表
#这些元素中的区域号代表的区域都是待合并的区域
self.merge_regions=[]
#整合后的皮肤区域，元素的索引即为皮肤区域号，元素都是包含一些Skin对象的列表
self.skin_regions=[]
#最近合并的两个皮肤区域的区域号，初始化为-1
self.last_from,self.last_to=-1,-1
#色情图像判断结果
self.result=None
#处理得到的信息
self.message=None
#图像宽高
self.width,self.height=self.image.size
#图像总像素
self.total_pixels=self.width*self.height

isinstane(object, classinfo)如果参数object是参数classinfo的实例，返回真，否则假；参数classinfo可以是一个包含若干type对象的元组，如果参数object是其中任意一个类型的实例，返回真，否则假。

涉及到效率问题，越大的图片所需要消耗的资源与时间越大，因此有时候可能需要对图片进行缩小。所以需要有图片缩小方法：

defresize(self,maxwidth=1000,maxheight=1000):

"""
基于最大宽高按比例重设图片大小，
注意：这可能影响检测算法的结果

如果没有变化返回0
原宽度大于maxwidth返回1
原高度大于maxheight返回2
原宽高大于maxwidth,maxheight返回3

maxwidth-图片最大宽度
maxheight-图片最大高度
传递参数时都可以设置为False来忽略
"""
#存储返回值
ret=0
ifmaxwidth:
ifself.width>maxwidth:
wpercent=(maxwidth/self.width)
hsize=int((self.height*wpercent))
fname=self.image.filename
#Image.LANCZOS是重采样滤波器，用于抗锯齿
self.image=self.image.resize((maxwidth,hsize),Image.LANCZOS)
self.image.filename=fname
self.width,self.height=self.image.size
self.total_pixels=self.width*self.height
ret+=1
ifmaxheight:
ifself.height>maxheight:
hpercent=(maxheight/float(self.height))
wsize=int((float(self.width)*float(hpercent)))
fname=self.image.filename
self.image=self.image.resize((wsize,maxheight),Image.LANCZOS)
self.image.filename=fname
self.width,self.height=self.image.size
self.total_pixels=self.width*self.height
ret+=2
returnret

Image.resize(size, resample=0)

size – 包含宽高像素数的元祖 (width, height) resample – 可选的重采样滤波器

返回Image对象

然后便是最关键之一的解析方法了：

defparse(self):
#如果已有结果，返回本对象
ifself.resultisnotNone:
returnself
#获得图片所有像素数据
pixels=self.image.load()

接着，遍历每个像素，为每个像素创建对应的Skin对象，其中self._classify_skin()这个方法是检测像素颜色是否为肤色：

foryinrange(self.height):

forxinrange(self.width):
#得到像素的RGB三个通道的值
#[x,y]是[(x,y)]的简便写法
r=pixels[x,y][0]#red
g=pixels[x,y][1]#green
b=pixels[x,y][2]#blue
#判断当前像素是否为肤色像素
isSkin=Trueifself._classify_skin(r,g,b)elseFalse
#给每个像素分配唯一id值（1,2,3...height*width）
#注意x,y的值从零开始
_id=x+y*self.width+1
#为每个像素创建一个对应的Skin对象，并添加到self.skin_map中
self.skin_map.append(self.Skin(_id,isSkin,None,x,y))

若当前像素并不是肤色，那么跳过本次循环，继续遍历：

#若当前像素不为肤色像素，跳过此次循环

ifnotisSkin:
continue

若当前像素是肤色像素，那么就需要处理了，先遍历其相邻像素。

一定要注意相邻像素的索引值，因为像素的id值是从1开始编起的，而索引是从0编起的。变量_id是存有当前像素的id值， 所以当前像素在self.skin_map中的索引值为_id - 1，以此类推，那么其左方的相邻像素在self.skin_map中的索引值为_id - 1 - 1，左上方为_id - 1 - self.width - 1，上方为_id - 1 - self.width，右上方为_id - 1 - self.width + 1：

#设左上角为原点，相邻像素为符号*，当前像素为符号^，那么相互位置关系通常如下图
#***
#*^

#存有相邻像素索引的列表，存放顺序为由大到小，顺序改变有影响
#注意_id是从1开始的，对应的索引则是_id-1
check_indexes=[_id-2,#当前像素左方的像素
_id-self.width-2,#当前像素左上方的像素
_id-self.width-1,#当前像素的上方的像素
_id-self.width]#当前像素右上方的像素

把id值从0编起：

#用来记录相邻像素中肤色像素所在的区域号，初始化为-1
region=-1
#遍历每一个相邻像素的索引
forindexincheck_indexes:
#尝试索引相邻像素的Skin对象，没有则跳出循环
try:
self.skin_map[index]
exceptIndexError:
break
#相邻像素若为肤色像素：
ifself.skin_map[index].skin:
#若相邻像素与当前像素的region均为有效值，且二者不同，且尚未添加相同的合并任务
if(self.skin_map[index].region!=Noneand
region!=Noneandregion!=-1and
self.skin_map[index].region!=regionand
self.last_from!=regionand
self.last_to!=self.skin_map[index].region):
#那么这添加这两个区域的合并任务
self._add_merge(region,self.skin_map[index].region)
#记录此相邻像素所在的区域号
region=self.skin_map[index].region

self._add_merge()这个方法接收两个区域号，它将会把两个区域号添加到self.merge_regions中的元素中，self.merge_regions的每一个元素都是一个列表，这些列表中存放了 1 到多个的区域号，区域号代表的区域是连通的，需要合并。

检测的图像里，有些前几行的像素的相邻像素并没有 4 个，所以需要用try“试错”。

然后相邻像素的若是肤色像素，如果两个像素的皮肤区域号都为有效值且不同，因为两个区域中的像素相邻，那么其实这两个区域是连通的，说明需要合并这两个区域。记录下此相邻肤色像素的区域号，之后便可以将当前像素归到这个皮肤区域里了。

遍历完所有相邻像素后，分两种情况处理：

所有相邻像素都不是肤色像素：发现了新的皮肤区域。

存在区域号为有效值的相邻肤色像素：region 的中存储的值有用了，把当前像素归到这个相邻像素所在的区域。

#遍历完所有相邻像素后，若region仍等于-1，说明所有相邻像素都不是肤色像素
ifregion==-1:
#更改属性为新的区域号，注意元祖是不可变类型，不能直接更改属性
_skin=self.skin_map[_id-1]._replace(region=len(self.detected_regions))
self.skin_map[_id-1]=_skin
#将此肤色像素所在区域创建为新区域
self.detected_regions.append([self.skin_map[_id-1]])
#region不等于-1的同时不等于None，说明有区域号为有效值的相邻肤色像素
elifregion!=None:
#将此像素的区域号更改为与相邻像素相同
_skin=self.skin_map[_id-1]._replace(region=region)
self.skin_map[_id-1]=_skin
#向这个区域的像素列表中添加此像素
self.detected_regions[region].append(self.skin_map[_id-1])

somenamedtuple._replace(kwargs)返回一个替换指定字段的值为参数的namedtuple实例

遍历完所有像素之后，图片的皮肤区域划分初步完成了，只是在变量self.merge_regions中还有一些连通的皮肤区域号，它们需要合并，合并之后就可以进行色情图片判定了：

#完成所有区域合并任务，合并整理后的区域存储到self.skin_regions
self._merge(self.detected_regions,self.merge_regions)
#分析皮肤区域，得到判定结果
self._analyse_regions()
returnself

方法self._merge()便是用来合并这些连通的皮肤区域的。方法self._analyse_regions()，运用之前在程序原理一节定义的非色情图像判定规则，从而得到判定结果。现在编写我们还没写过的调用过的Nude类的方法。

首先是self._classify_skin()方法，这个方法是检测像素颜色是否为肤色，之前在程序原理一节已经把肤色判定该公式列举了出来，现在是用的时候了：

#基于像素的肤色检测技术
def_classify_skin(self,r,g,b):
#根据RGB值判定
rgb_classifier=r>95and
g>40andg< 100 and 
        b >20and
max([r,g,b])-min([r,g,b])>15and
abs(r-g)>15and
r>gand
r>b
#根据处理后的RGB值判定
nr,ng,nb=self._to_normalized(r,g,b)
norm_rgb_classifier=nr/ng>1.185and
float(r*b)/((r+g+b)**2)>0.107and
float(r*g)/((r+g+b)**2)>0.112

#HSV颜色模式下的判定
h,s,v=self._to_hsv(r,g,b)
hsv_classifier=h>0and
h< 35 and 
        s >0.23and
s< 0.68

    # YCbCr 颜色模式下的判定
    y, cb, cr = self._to_ycbcr(r, g,  b)
    ycbcr_classifier = 97.5 <= cb <= 142.5 and 134 <= cr <= 176

    # 效果不是很好，还需改公式
    # return rgb_classifier or norm_rgb_classifier or hsv_classifier or ycbcr_classifier
    return ycbcr_classifier

颜色模式的转换并不是本实验的重点，转换公式可以在网上找到，这里我们直接拿来用就行：

def_to_normalized(self,r,g,b):
ifr==0:
r=0.0001
ifg==0:
g=0.0001
ifb==0:
b=0.0001
_sum=float(r+g+b)
return[r/_sum,g/_sum,b/_sum]

def_to_ycbcr(self,r,g,b):
#公式来源：
#http://stackoverflow.com/questions/19459831/rgb-to-ycbcr-conversion-problems
y=.299*r+.587*g+.114*b
cb=128-0.168736*r-0.331364*g+0.5*b
cr=128+0.5*r-0.418688*g-0.081312*b
returny,cb,cr

def_to_hsv(self,r,g,b):
h=0
_sum=float(r+g+b)
_max=float(max([r,g,b]))
_min=float(min([r,g,b]))
diff=float(_max-_min)
if_sum==0:
_sum=0.0001

if_max==r:
ifdiff==0:
h=sys.maxsize
else:
h=(g-b)/diff
elif_max==g:
h=2+((g-r)/diff)
else:
h=4+((r-g)/diff)

h*=60
ifh< 0:
        h += 360

    return [h, 1.0 - (3.0 * (_min / _sum)), (1.0 / 3.0) * _max]

self._add_merge()方法主要是对self.merge_regions操作，而self.merge_regions 的元素都是包含一些 int 对象（区域号）的列表，列表中的区域号代表的区域都是待合并的区。self._add_merge()方法接收两个区域号，将之添加到self.merge_regions中。

这两个区域号以怎样的形式添加，要分 3 种情况处理：

传入的两个区域号都存在于self.merge_regions中

传入的两个区域号有一个区域号存在于self.merge_regions中

传入的两个区域号都不存在于self.merge_regions中

具体的处理方法，见代码：

def_add_merge(self,_from,_to):
#两个区域号赋值给类属性
self.last_from=_from
self.last_to=_to

#记录self.merge_regions的某个索引值，初始化为-1
from_index=-1
#记录self.merge_regions的某个索引值，初始化为-1
to_index=-1


#遍历每个self.merge_regions的元素
forindex,regioninenumerate(self.merge_regions):
#遍历元素中的每个区域号
forr_indexinregion:
ifr_index==_from:
from_index=index
ifr_index==_to:
to_index=index

#若两个区域号都存在于self.merge_regions中
iffrom_index!=-1andto_index!=-1:
#如果这两个区域号分别存在于两个列表中
#那么合并这两个列表
iffrom_index!=to_index:
self.merge_regions[from_index].extend(self.merge_regions[to_index])
del(self.merge_regions[to_index])
return

#若两个区域号都不存在于self.merge_regions中
iffrom_index==-1andto_index==-1:
#创建新的区域号列表
self.merge_regions.append([_from,_to])
return
#若两个区域号中有一个存在于self.merge_regions中
iffrom_index!=-1andto_index==-1:
#将不存在于self.merge_regions中的那个区域号
#添加到另一个区域号所在的列表
self.merge_regions[from_index].append(_to)
return
#若两个待合并的区域号中有一个存在于self.merge_regions中
iffrom_index==-1andto_index!=-1:
#将不存在于self.merge_regions中的那个区域号
#添加到另一个区域号所在的列表
self.merge_regions[to_index].append(_from)
return

在序列中循环时，索引位置和对应值可以使用enumerate()函数同时得到，在上面的代码中，索引位置即为index，对应值即为region。self._merge()方法则是将self.merge_regions中的元素中的区域号所代表的区域合并，得到新的皮肤区域列表：

def_merge(self,detected_regions,merge_regions):
#新建列表new_detected_regions
#其元素将是包含一些代表像素的Skin对象的列表
#new_detected_regions的元素即代表皮肤区域，元素索引为区域号
new_detected_regions=[]

#将merge_regions中的元素中的区域号代表的所有区域合并
forindex,regioninenumerate(merge_regions):
try:
new_detected_regions[index]
exceptIndexError:
new_detected_regions.append([])
forr_indexinregion:
new_detected_regions[index].extend(detected_regions[r_index])
detected_regions[r_index]=[]

#添加剩下的其余皮肤区域到new_detected_regions
forregionindetected_regions:
iflen(region)>0:
new_detected_regions.append(region)

#清理new_detected_regions
self._clear_regions(new_detected_regions)

#添加剩下的其余皮肤区域到new_detected_regions
forregionindetected_regions:
iflen(region)>0:
new_detected_regions.append(region)

#清理new_detected_regions
self._clear_regions(new_detected_regions)

self._clear_regions()方法只将像素数大于指定数量的皮肤区域保留到self.skin_regions：

#皮肤区域清理函数
#只保存像素数大于指定数量的皮肤区域
def_clear_regions(self,detected_regions):
forregionindetected_regions:
iflen(region)>30:
self.skin_regions.append(region)

self._analyse_regions()是很简单的，它的工作只是进行一系列判断，得出图片是否色情的结论：

#分析区域
def_analyse_regions(self):
#如果皮肤区域小于3个，不是色情
iflen(self.skin_regions)< 3:
        self.message = "Less than 3 skin regions ({_skin_regions_size})".format(
            _skin_regions_size=len(self.skin_regions))
        self.result = False
        return self.result

    # 为皮肤区域排序
    self.skin_regions = sorted(self.skin_regions, key=lambda s: len(s),
                               reverse=True)

    # 计算皮肤总像素数
    total_skin = float(sum([len(skin_region) for skin_region in self.skin_regions]))

    # 如果皮肤区域与整个图像的比值小于 15%，那么不是色情图片
    if total_skin / self.total_pixels * 100 < 15:
        self.message = "Total skin percentage lower than 15 ({:.2f})".format(total_skin / self.total_pixels * 100)
        self.result = False
        return self.result

    # 如果最大皮肤区域小于总皮肤面积的 45%，不是色情图片
    if len(self.skin_regions[0]) / total_skin * 100 < 45:
        self.message = "The biggest region contains less than 45 ({:.2f})".format(len(self.skin_regions[0]) / total_skin * 100)
        self.result = False
        return self.result

    # 皮肤区域数量超过 60个，不是色情图片
    if len(self.skin_regions) >60:
self.message="Morethan60skinregions({})".format(len(self.skin_regions))
self.result=False
returnself.result

#其它情况为色情图片
self.message="Nude!!"
self.result=True
returnself.result

然后可以组织下分析得出的信息：

definspect(self):
_image='{}{}{}×{}'.format(self.image.filename,self.image.format,self.width,self.height)
return"{_image}:result={_result}message='{_message}'".format(_image=_image,_result=self.result,_message=self.message)

Nude类如果就这样完成了，最后运行脚本时只能得到一些真或假的结果，我们需要更直观的感受程序的分析效果，我们可以生成一张原图的副本，不过这个副本图片中只有黑白色，白色代表皮肤区域，那么这样我们能直观感受到程序分析的效果了。

前面的代码中我们有获得图像的像素的 RGB 值的操作，设置像素的 RGB 值也就是其逆操作，还是很简单的，不过注意设置像素的 RGB 值时不能在原图上操作：

#将在源文件目录生成图片文件，将皮肤区域可视化
defshowSkinRegions(self):
#未得出结果时方法返回
ifself.resultisNone:
return
#皮肤像素的ID的集合
skinIdSet=set()
#将原图做一份拷贝
simage=self.image
#加载数据
simageData=simage.load()

#将皮肤像素的id存入skinIdSet
forsrinself.skin_regions:
forpixelinsr:
skinIdSet.add(pixel.id)
#将图像中的皮肤像素设为白色，其余设为黑色
forpixelinself.skin_map:
ifpixel.idnotinskinIdSet:
simageData[pixel.x,pixel.y]=0,0,0
else:
simageData[pixel.x,pixel.y]=255,255,255
#源文件绝对路径
filePath=os.path.abspath(self.image.filename)
#源文件所在目录
fileDirectory=os.path.dirname(filePath)+'/'
#源文件的完整文件名
fileFullName=os.path.basename(filePath)
#分离源文件的完整文件名得到文件名和扩展名
fileName,fileExtName=os.path.splitext(fileFullName)
#保存图片
simage.save('{}{}_{}{}'.format(fileDirectory,fileName,'Nude'ifself.resultelse'Normal',fileExtName))

变量skinIdSet使用集合而不是列表是有性能上的考量的，Python 中的集合是哈希表实现的，查询效率很高。最后支持一下命令行参数就大功告成啦！我们使用argparse这个模块来实现命令行的支持。argparse 模块使得编写用户友好的命令行接口非常容易。程序只需定义好它要求的参数，然后 argparse 将负责如何从 sys.argv 中解析出这些参数。argparse 模块还会自动生成帮助和使用信息并且当用户赋给程序非法的参数时产生错误信息。

具体使用方法请查看argparse的官方文档

if__name__=="__main__":
importargparse

parser=argparse.ArgumentParser(description='Detectnudityinimages.')
parser.add_argument('files',metavar='image',nargs='+',
help='Imagesyouwishtotest')
parser.add_argument('-r','--resize',action='store_true',
help='Reduceimagesizetoincreasespeedofscanning')
parser.add_argument('-v','--visualization',action='store_true',
help='Generatingareasofskinimage')

args=parser.parse_args()

forfnameinargs.files:
ifos.path.isfile(fname):
n=Nude(fname)
ifargs.resize:
n.resize(maxheight=800,maxwidth=600)
n.parse()
ifargs.visualization:
n.showSkinRegions()
print(n.result,n.inspect())
else:
print(fname,"isnotafile")

测试效果

先来一张很正经的测试图片：

在PyCharm中的终端运行下面的命令执行脚本，注意是python3而不是python：

python3nude.py-v1.jpg

运行截图：

总结

这个项目就是熟悉了一下PIL的使用，了解了色情图片检查的原理。主要实现难点是在皮肤区域的检测与整合这一方面。项目还有许多可以改进的地方，比如肤色检测公式，色情判定条件，还有性能问题，我得去学习一下用多线程或多进程提高性能。

编辑：黄飞