小伙伴们都应该听过一种职业叫做“鉴黄师”，就是每天要看无数部毛片，看到手抽筋的那种……毛片固然振奋人心，但是看多了也会产生厌倦，时间长了会彻底失去对美好胴体的兴趣，那就很遗憾了。

好了。现在有一种方法可以使用程序帮你鉴黄，大大减轻了鉴黄师的工作量，这个程序怎么写呢？这正是本文要讨论的。

本文是《用Python鉴黄 》的第一部分，只告诉你怎么鉴别黄图，但还有小黄文和毛片呢？别急，第二部分与第三部分将分别讨论怎样鉴别小黄文与毛片。

先来说一下思路吧，不管做什么，只要有了正确的思路，一切都能引刃而解。

一张图片由什么组成？由许多个像素点在二维空间上按照一定规律组成。我们要鉴别黄图，首先要明白我们的分析对象——这些像素点。

本文所定义的黄图，是指包含有大比例裸露的人体图片。也许你们眼中的黄图不是这样的，但是没关系，在我眼中，这就是黄图了。

人体的肤色有所不同，但如果把颜色映射到颜色编码，还是可以划分出数字区间的，虽然不是100%准确，但可以涵盖大部分的情况了。

请看以下这个代码块
思路：把颜色映射为YCbCr颜色模式（3种颜色模式中的其中一种）下的编码，并根据实践情况对颜色编码划分区间来判断每个像素点是否为人体皮肤。

def _classify_skin(self, r, g, b):
    
    y, cb, cr = self._to_ycbcr(r, g,  b)
    ycbcr_classifier = 97.5 <= cb <= 142.5 and 134 <= cr <= 176
    return ycbcr_classifier

有了这个函数，我们可以判断图片上每一个像素点是否为人体皮肤的肤色。但是，这还是不够，总不能因为图片上的人露了个脸就说这个是黄图吧？当然不能。

那怎么办？
图片中所有符合人体肤色的像素点并不是孤立的，一定会与其他皮肤像素点相邻形成一整块的皮肤。好了，我们就从这里入手。

我们定义非色情图片的判定规则如下（满足任意一个判定为真）：
1.皮肤区域的个数小于 3 个
2.皮肤区域的像素与图像所有像素的比值小于 15%
3.最大皮肤区域小于总皮肤面积的 45%
4.皮肤区域数量超过60个

但是，这并不是唯一标准，每个人的口味都是不同的，因此，对于“黄”的定义也有所不同，你可以按照自己喜欢的方式去定义“黄”。

相信看到这里，小伙伴们已经有了实现思路。我帮你们把思路捋捋顺。

程序的关键步骤如下：
1.遍历每个像素，检测像素颜色是否为肤色
2.将相邻的肤色像素归为一个皮肤区域，得到若干个皮肤区域
3.剔除像素数量极少的皮肤区域

仔细想想这几个关键步骤，你会发现真正的难点在于第二步：怎样才能将皮肤区域正确划分开来呢？

把一张图片“拆散”为一个个按原有顺序排列的像素点，然后从左至右、从上至下遍历。我们就可以判断当前的皮肤像素点相邻的像素点是否为皮肤像素点（对每个像素点使用上文中提到的_classify_skin()函数）：如果是，则将当前像素点与相邻像素点合并为一个皮肤区域；如果不是，则将当前像素点视为皮肤区域的边界。

这里的相邻指的是当前像素点的左、左上、上、右上。

接下来self.parse这个方法的作用在于：遍历图片像素点，检测皮肤区域，分析得到结果。

def parse(self):
    # 如果已有结果，返回本对象
    if self.result is not None:
        return self
    # 获得图片所有像素数据
    pixels = self.image.load()
    for y in range(self.height):
       for x in range(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 = True if self._classify_skin(r, g, b) else False
           # 给每个像素分配唯一 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))
            # 若当前像素不为肤色像素，跳过此次循环
            if not isSkin:
               continue
            # 若当前像素是肤色像素，那么就需要处理了，先遍历其相邻像素
            # 设左上角为原点，相邻像素为符号 *，当前像素为符号 ^，那么相互位置关系通常如下图
            # 存有相邻像素索引的列表，存放顺序为由大到小，顺序改变有影响
            # 注意 _id 是从 1 开始的，对应的索引则是 _id-1
            check_indexes = [_id - 2, # 当前像素左方的像素
                             _id - self.width - 2,  # 当前像素左上方的像素
                             _id - self.width - 1,  # 当前像素的上方的像素
                             _id - self.width]  # 当前像素右上方的像素
            # 用来记录相邻像素中肤色像素所在的区域号，初始化为 -1
            region = -1
            # 遍历每一个相邻像素的索引
            for index in check_indexes:
                # 尝试索引相邻像素的 Skin 对象，没有则跳出循环
                try:
                    self.skin_map[index]
                except IndexError:
                    break
                # 相邻像素若为肤色像素：
                if self.skin_map[index].skin:
                    # 若相邻像素与当前像素的 region 均为有效值，且二者不同，且尚未添加相同的合并任务
                    if (self.skin_map[index].region != None and
                            region != None and region != -1 and
                            self.skin_map[index].region != region and
                            self.last_from != region and
                            self.last_to != self.skin_map[index].region) :
                        # 那么这添加这两个区域的合并任务
                        self._add_merge(region, self.skin_map[index].region)
                    # 记录此相邻像素所在的区域号
                    region = self.skin_map[index].region
                    # 遍历完所有相邻像素后，若 region 仍等于 -1，说明所有相邻像素都不是肤色像素
            if region == -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，说明有区域号为有效值的相邻肤色像素
            elif region != 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])
    #遍历完所有像素之后，图片的皮肤区域划分初步完成了，只是在变量 self.merge_regions 中还有一些连通的皮肤区域号，它们需要合并，合并之后就可以进行色情图片判定了。
    # 完成所有区域合并任务，合并整理后的区域存储到 self.skin_regions
    self._merge(self.detected_regions, self.merge_regions)
    # 分析皮肤区域，得到判定结果
    self._analyse_regions()
    return self

下面来看看self._merge、self._analyse_regions、self._add_merge 方法的具体代码实现。

self._add_merge这个方法用来将像素点合并成皮肤区域。

def _add_merge(self, _from, _to):
    
    self.last_from = _from
    self.last_to = _to

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

    
    for index, region in enumerate(self.merge_regions):
        
        for r_index in region:
            if r_index == _from:
                from_index = index
            if r_index == _to:
                to_index = index

    
    if from_index != -1 and to_index != -1:
        
        # 那么合并这两个列表
        if from_index != to_index:
            self.merge_regions[from_index].extend(self.merge_regions[to_index])
            del(self.merge_regions[to_index])
        return

    
    if from_index == -1 and to_index == -1:
        
        self.merge_regions.append([_from, _to])
        return
    
    if from_index != -1 and to_index == -1:
        
        # 添加到另一个区域号所在的列表
        self.merge_regions[from_index].append(_to)
        return
    
    if from_index == -1 and to_index != -1:
        
        # 添加到另一个区域号所在的列表
        self.merge_regions[to_index].append(_from)
        return

经过以上这个方法，皮肤区域已经被检测出并被添加到self.merge_regions列表中了，但是这些皮肤区域之间可能存在着连通（实际上在图片上是整块皮肤，只是由于几何关系没有被一开始就确认为是同一块皮肤区域），所以我们还需要作进一步处理，把连通的皮肤区域找出来，并把它们合并为整块皮肤。

那么，我们怎样找到连通的皮肤区域并进行合并呢？看下面的代码。

def _merge(self, detected_regions, merge_regions):
    
    # 其元素将是包含一些代表像素的 Skin 对象的列表
    
    new_detected_regions = []

    # 将 merge_regions 中的元素中的区域号代表的所有区域合并
    for index, region in enumerate(merge_regions):
        try:
            new_detected_regions[index]
        except IndexError:
            new_detected_regions.append([])
        for r_index in region:
            new_detected_regions[index].extend(detected_regions[r_index])
            detected_regions[r_index] = []

    
    for region in detected_regions:
        if len(region) > 0:
            new_detected_regions.append(region)

    
    self._clear_regions(new_detected_regions)

到这一步，有的皮肤区域只有很少的像素点，没有实际意义，需要进行清理。就用以下方法。

# 只保存像素数大于指定数量的皮肤区域
def _clear_regions(self, detected_regions):
    for region in detected_regions:
        if len(region) > 30:
            self.skin_regions.append(region)

最后，分析判断图片是否为黄图，就看下面这个方法了。

def _analyse_regions(self):
    
    if len(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]))

    
    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

    
    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

    
    if len(self.skin_regions) > 60:
        self.message = "More than 60 skin regions ({})".format(len(self.skin_regions))
        self.result = False
        return self.result

    
    self.message = "Nude!!"
    self.result = True
    return self.result

到此，我们已经做完了这个demo里最核心的部分：皮肤检测分析。但是还有许多“非核心”的代码没有提及，但是其实最核心也是最难的这部分掌握了，其他的就问题不大了。基于肤色的色情图片识别算法是在一篇论文中找到的，有兴趣可以找来看看。如果想把这个demo跑起来也是可以的，下面有完整代码，复制下来就可以了。

完整代码：

import sys
import os
import _io
from collections import namedtuple
from PIL import Image

class Nude(object):

    Skin = namedtuple("Skin", "id skin region x y")

    def __init__(self, path_or_image):
        
        if isinstance(path_or_image, Image.Image):
            self.image = path_or_image
        
        elif isinstance(path_or_image, str):
            self.image = Image.open(path_or_image)

        
        bands = self.image.getbands()
        # 判断是否为单通道图片（也即灰度图），是则将灰度图转换为 RGB 图
        if len(bands) == 1:
            
            new_img = Image.new("RGB", self.image.size)
            
            new_img.paste(self.image)
            f = self.image.filename
            # 替换 self.image
            self.image = new_img
            self.image.filename = f

        
        self.skin_map = []
        # 检测到的皮肤区域，元素的索引即为皮肤区域号，元素都是包含一些 Skin 对象的列表
        self.detected_regions = []
        
        # 这些元素中的区域号代表的区域都是待合并的区域
        self.merge_regions = []
        
        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

    def resize(self, maxwidth=1000, maxheight=1000):
        """
        基于最大宽高按比例重设图片大小，
        注意：这可能影响检测算法的结果

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

        maxwidth - 图片最大宽度
        maxheight - 图片最大高度
        传递参数时都可以设置为 False 来忽略
        """
        
        ret = 0
        if maxwidth:
            if self.width > maxwidth:
                wpercent = (maxwidth / self.width)
                hsize = int((self.height * wpercent))
                fname = self.image.filename
                
                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
        if maxheight:
            if self.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
        return ret

    
    def parse(self):
        
        if self.result is not None:
            return self
        
        pixels = self.image.load()
        # 遍历每个像素
        for y in range(self.height):
            for x in range(self.width):
                
                # [x, y] 是 [(x,y)] 的简便写法
                r = pixels[x, y][0]   
                g = pixels[x, y][1]   
                b = pixels[x, y][2]   
                # 判断当前像素是否为肤色像素
                isSkin = True if self._classify_skin(r, g, b) else False
                
                # 注意 x, y 的值从零开始
                _id = x + y * self.width + 1
                
                self.skin_map.append(self.Skin(_id, isSkin, None, x, y))
                
                if not isSkin:
                    continue

                
                # ***
                

                # 存有相邻像素索引的列表，存放顺序为由大到小，顺序改变有影响
                
                check_indexes = [_id - 2, 
                                 _id - self.width - 2,  
                                 _id - self.width - 1,  
                                 _id - self.width]  # 当前像素右上方的像素
                
                region = -1
                
                for index in check_indexes:
                    
                    try:
                        self.skin_map[index]
                    except IndexError:
                        break
                    
                    if self.skin_map[index].skin:
                        
                        if (self.skin_map[index].region != None and
                                region != None and region != -1 and
                                self.skin_map[index].region != region and
                                self.last_from != region and
                                self.last_to != self.skin_map[index].region) :
                            
                            self._add_merge(region, self.skin_map[index].region)
                        # 记录此相邻像素所在的区域号
                        region = self.skin_map[index].region
                
                if region == -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]])
                
                elif region != 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])
        
        self._merge(self.detected_regions, self.merge_regions)
        # 分析皮肤区域，得到判定结果
        self._analyse_regions()
        return self


    
    # self.merge_regions 的元素中的区域号代表的区域都是待合并的区域
    
    def _add_merge(self, _from, _to):
        
        self.last_from = _from
        self.last_to = _to

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


        
        for index, region in enumerate(self.merge_regions):
            
            for r_index in region:
                if r_index == _from:
                    from_index = index
                if r_index == _to:
                    to_index = index

        
        if from_index != -1 and to_index != -1:
            
            # 那么合并这两个列表
            if from_index != to_index:
                self.merge_regions[from_index].extend(self.merge_regions[to_index])
                del(self.merge_regions[to_index])
            return

        
        if from_index == -1 and to_index == -1:
            
            self.merge_regions.append([_from, _to])
            return
        
        if from_index != -1 and to_index == -1:
            
            # 添加到另一个区域号所在的列表
            self.merge_regions[from_index].append(_to)
            return
        
        if from_index == -1 and to_index != -1:
            
            # 添加到另一个区域号所在的列表
            self.merge_regions[to_index].append(_from)
            return

    
    def _merge(self, detected_regions, merge_regions):
        
        # 其元素将是包含一些代表像素的 Skin 对象的列表
        
        new_detected_regions = []

        # 将 merge_regions 中的元素中的区域号代表的所有区域合并
        for index, region in enumerate(merge_regions):
            try:
                new_detected_regions[index]
            except IndexError:
                new_detected_regions.append([])
            for r_index in region:
                new_detected_regions[index].extend(detected_regions[r_index])
                detected_regions[r_index] = []

        
        for region in detected_regions:
            if len(region) > 0:
                new_detected_regions.append(region)

        
        self._clear_regions(new_detected_regions)

    # 皮肤区域清理函数
    
    def _clear_regions(self, detected_regions):
        for region in detected_regions:
            if len(region) > 30:
                self.skin_regions.append(region)

    
    def _analyse_regions(self):
        
        if len(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]))

        
        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

        
        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

        
        if len(self.skin_regions) > 60:
            self.message = "More than 60 skin regions ({})".format(len(self.skin_regions))
            self.result = False
            return self.result

        
        self.message = "Nude!!"
        self.result = True
        return self.result

    
    def _classify_skin(self, r, g, b):
        
        rgb_classifier = 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, ng, nb = self._to_normalized(r, g, b)
        norm_rgb_classifier = nr / ng > 1.185 and \
            float(r * b) / ((r + g + b) ** 2) > 0.107 and \
            float(r * g) / ((r + g + b) ** 2) > 0.112

        
        h, s, v = self._to_hsv(r, g, b)
        hsv_classifier = h > 0 and \
            h < 35 and \
            s > 0.23 and \
            s < 0.68

        
        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):
        if r == 0:
            r = 0.0001
        if g == 0:
            g = 0.0001
        if b == 0:
            b = 0.0001
        _sum = float(r + g + b)
        return [r / _sum, g / _sum, b / _sum]

    def _to_ycbcr(self, r, g, b):
        
        # http://*.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
        return y, 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:
            if diff == 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
        if h < 0:
            h += 360

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

    def inspect(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)

    
    def showSkinRegions(self):
        
        if self.result is None:
            return
        
        skinIdSet = set()
        # 将原图做一份拷贝
        simage = self.image
        
        simageData = simage.load()

        # 将皮肤像素的 id 存入 skinIdSet
        for sr in self.skin_regions:
            for pixel in sr:
                skinIdSet.add(pixel.id)
        
        for pixel in self.skin_map:
            if pixel.id not in skinIdSet:
                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' if self.result else 'Normal', fileExtName))

if __name__ == "__main__":
    import argparse

    parser = argparse.ArgumentParser(description='Detect nudity in images.')
    parser.add_argument('files', metavar='image', nargs='+',
                        help='Images you wish to test')
    parser.add_argument('-r', '--resize', action='store_true',
                        help='Reduce image size to increase speed of scanning')
    parser.add_argument('-v', '--visualization', action='store_true',
                        help='Generating areas of skin image')

    args = parser.parse_args()

    for fname in args.files:
        if os.path.isfile(fname):
            n = Nude(fname)
            if args.resize:
                n.resize(maxheight=800, maxwidth=600)
            n.parse()
            if args.visualization:
                n.showSkinRegions()
            print(n.result, n.inspect())
        else:
            print(fname, "is not a file")

运行：

$ python3 script.py -v a.jpg b.jpg

a.jpg

b.jpg

结果如下：