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

sudo install -U pip3
sudo install Pillow

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

class Nude:

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

def __init__(self, path_or_image):
    # 若 path_or_image 為 Image.Image 類(lèi)型的實(shí)例，直接賦值
    if isinstance(path_or_image, Image.Image):
        self.image = path_or_image
    # 若 path_or_image 為 str 類(lèi)型的實(shí)例，打開(kāi)圖片
    elif isinstance(path_or_image, str):
        self.image = Image.open(path_or_image)

    # 獲得圖片所有顏色通道
    bands = self.image.getbands()
    # 判斷是否為單通道圖片（也即灰度圖），是則將灰度圖轉(zhuǎn)換為 RGB 圖
    if len(bands) == 1:
        # 新建相同大小的 RGB 圖像
        new_img = Image.new("RGB", self.image.size)
        # 拷貝灰度圖 self.image 到 RGB圖 new_img.paste （PIL 自動(dòng)進(jìn)行顏色通道轉(zhuǎn)換）
        new_img.paste(self.image)
        f = self.image.filename
        # 替換 self.image
        self.image = new_img
        self.image.filename = f

    # 存儲(chǔ)對(duì)應(yīng)圖像所有像素的全部 Skin 對(duì)象
    self.skin_map = []
    # 檢測(cè)到的皮膚區(qū)域，元素的索引即為皮膚區(qū)域號(hào)，元素都是包含一些 Skin 對(duì)象的列表
    self.detected_regions = []
    # 元素都是包含一些 int 對(duì)象（區(qū)域號(hào)）的列表
    # 這些元素中的區(qū)域號(hào)代表的區(qū)域都是待合并的區(qū)域
    self.merge_regions = []
    # 整合后的皮膚區(qū)域，元素的索引即為皮膚區(qū)域號(hào)，元素都是包含一些 Skin 對(duì)象的列表
    self.skin_regions = []
    # 最近合并的兩個(gè)皮膚區(qū)域的區(qū)域號(hào)，初始化為 -1
    self.last_from, self.last_to = -1, -1
    # 色情圖像判斷結(jié)果
    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):
    """
    基于最大寬高按比例重設(shè)圖片大小，
    注意：這可能影響檢測(cè)算法的結(jié)果

    如果沒(méi)有變化返回 0
    原寬度大于 maxwidth 返回 1
    原高度大于 maxheight 返回 2
    原寬高大于 maxwidth, maxheight 返回 3

    maxwidth - 圖片最大寬度
    maxheight - 圖片最大高度
    傳遞參數(shù)時(shí)都可以設(shè)置為 False 來(lái)忽略
    """
    # 存儲(chǔ)返回值
    ret = 0
    if maxwidth:
        if self.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
    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):
    # 如果已有結(jié)果，返回本對(duì)象
    if self.result is not None:
        return self
    # 獲得圖片所有像素?cái)?shù)據(jù)
    pixels = self.image.load()

for y in range(self.height):
        for x in range(self.width):
            # 得到像素的 RGB 三個(gè)通道的值
            # [x, y] 是 [(x,y)] 的簡(jiǎn)便寫(xiě)法
            r = pixels[x, y][0]   # red
            g = pixels[x, y][1]   # green
            b = pixels[x, y][2]   # blue
            # 判斷當(dāng)前像素是否為膚色像素
            isSkin = True if self._classify_skin(r, g, b) else False
            # 給每個(gè)像素分配唯一 id 值（1, 2, 3...height*width）
            # 注意 x, y 的值從零開(kāi)始
            _id = x + y * self.width + 1
            # 為每個(gè)像素創(chuàng)建一個(gè)對(duì)應(yīng)的 Skin 對(duì)象，并添加到 self.skin_map 中
            self.skin_map.append(self.Skin(_id, isSkin, None, x, y))

            # 若當(dāng)前像素不為膚色像素，跳過(guò)此次循環(huán)
            if not isSkin:
                continue

            # 設(shè)左上角為原點(diǎn)，相鄰像素為符號(hào) *，當(dāng)前像素為符號(hào) ^，那么相互位置關(guān)系通常如下圖
            # ***
            # *^

            # 存有相鄰像素索引的列表，存放順序?yàn)橛纱蟮叫?，順序改變有影?/span>
            # 注意 _id 是從 1 開(kāi)始的，對(duì)應(yīng)的索引則是 _id-1
            check_indexes = [_id - 2, # 當(dāng)前像素左方的像素
                             _id - self.width - 2,  # 當(dāng)前像素左上方的像素
                             _id - self.width - 1,  # 當(dāng)前像素的上方的像素
                             _id - self.width]  # 當(dāng)前像素右上方的像素

          # 用來(lái)記錄相鄰像素中膚色像素所在的區(qū)域號(hào)，初始化為 -1
            region = -1
            # 遍歷每一個(gè)相鄰像素的索引
            for index in check_indexes:
                # 嘗試索引相鄰像素的 Skin 對(duì)象，沒(méi)有則跳出循環(huán)
                try:
                    self.skin_map[index]
                except IndexError:
                    break
                # 相鄰像素若為膚色像素：
                if self.skin_map[index].skin:
                    # 若相鄰像素與當(dāng)前像素的 region 均為有效值，且二者不同，且尚未添加相同的合并任務(wù)
                    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) :
                        # 那么這添加這兩個(gè)區(qū)域的合并任務(wù)
                        self._add_merge(region, self.skin_map[index].region)
                    # 記錄此相鄰像素所在的區(qū)域號(hào)
                    region = self.skin_map[index].region

          # 遍歷完所有相鄰像素后，若 region 仍等于 -1，說(shuō)明所有相鄰像素都不是膚色像素
            if region == -1:
                # 更改屬性為新的區(qū)域號(hào)，注意元祖是不可變類(lèi)型，不能直接更改屬性
                _skin = self.skin_map[_id - 1]._replace(region=len(self.detected_regions))
                self.skin_map[_id - 1] = _skin
                # 將此膚色像素所在區(qū)域創(chuàng)建為新區(qū)域
                self.detected_regions.append([self.skin_map[_id - 1]])
            # region 不等于 -1 的同時(shí)不等于 None，說(shuō)明有區(qū)域號(hào)為有效值的相鄰膚色像素
            elif region != None:
                # 將此像素的區(qū)域號(hào)更改為與相鄰像素相同
                _skin = self.skin_map[_id - 1]._replace(region=region)
                self.skin_map[_id - 1] = _skin
                # 向這個(gè)區(qū)域的像素列表中添加此像素
                self.detected_regions[region].append(self.skin_map[_id - 1])

    # 完成所有區(qū)域合并任務(wù)，合并整理后的區(qū)域存儲(chǔ)到 self.skin_regions
    self._merge(self.detected_regions, self.merge_regions)
    # 分析皮膚區(qū)域，得到判定結(jié)果
    self._analyse_regions()
    return self

# 基于像素的膚色檢測(cè)技術(shù)
def _classify_skin(self, r, g, b):
    # 根據(jù)RGB值判定
    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
    # 根據(jù)處理后的 RGB 值判定
    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

    # HSV 顏色模式下的判定
    h, s, v = self._to_hsv(r, g, b)
    hsv_classifier = h > 0 and \
        h < 35 and \
        s > 0.23 and \
        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):
    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):
    # 公式來(lái)源：
    # 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
    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]

ef _add_merge(self, _from, _to):
    # 兩個(gè)區(qū)域號(hào)賦值給類(lèi)屬性
    self.last_from = _from
    self.last_to = _to
    
    # 記錄 self.merge_regions 的某個(gè)索引值，初始化為 -1
    from_index = -1
    # 記錄 self.merge_regions 的某個(gè)索引值，初始化為 -1
    to_index = -1


    # 遍歷每個(gè) self.merge_regions 的元素
    for index, region in enumerate(self.merge_regions):
        # 遍歷元素中的每個(gè)區(qū)域號(hào)
        for r_index in region:
            if r_index == _from:
                from_index = index
            if r_index == _to:
                to_index = index

    # 若兩個(gè)區(qū)域號(hào)都存在于 self.merge_regions 中
    if from_index != -1 and to_index != -1:
        # 如果這兩個(gè)區(qū)域號(hào)分別存在于兩個(gè)列表中
        # 那么合并這兩個(gè)列表
        if from_index != to_index:
            self.merge_regions[from_index].extend(self.merge_regions[to_index])
            del(self.merge_regions[to_index])
        return

    # 若兩個(gè)區(qū)域號(hào)都不存在于 self.merge_regions 中
    if from_index == -1 and to_index == -1:
        # 創(chuàng)建新的區(qū)域號(hào)列表
        self.merge_regions.append([_from, _to])
        return
    # 若兩個(gè)區(qū)域號(hào)中有一個(gè)存在于 self.merge_regions 中
    if from_index != -1 and to_index == -1:
        # 將不存在于 self.merge_regions 中的那個(gè)區(qū)域號(hào)
        # 添加到另一個(gè)區(qū)域號(hào)所在的列表
        self.merge_regions[from_index].append(_to)
        return
    # 若兩個(gè)待合并的區(qū)域號(hào)中有一個(gè)存在于 self.merge_regions 中
    if from_index == -1 and to_index != -1:
        # 將不存在于 self.merge_regions 中的那個(gè)區(qū)域號(hào)
        # 添加到另一個(gè)區(qū)域號(hào)所在的列表
        self.merge_regions[to_index].append(_from)
        return

ef _merge(self, detected_regions, merge_regions):
    # 新建列表 new_detected_regions 
    # 其元素將是包含一些代表像素的 Skin 對(duì)象的列表
    # new_detected_regions 的元素即代表皮膚區(qū)域，元素索引為區(qū)域號(hào)
    new_detected_regions = []

    # 將 merge_regions 中的元素中的區(qū)域號(hào)代表的所有區(qū)域合并
    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] = []

    # 添加剩下的其余皮膚區(qū)域到 new_detected_regions
    for region in detected_regions:
        if len(region) > 0:
            new_detected_regions.append(region)

    # 清理 new_detected_regions
    self._clear_regions(new_detected_regions)

        # 添加剩下的其余皮膚區(qū)域到 new_detected_regions
        for region in detected_regions:
            if len(region) > 0:
                new_detected_regions.append(region)

        # 清理 new_detected_regions
        self._clear_regions(new_detected_regions)

# 皮膚區(qū)域清理函數(shù)
# 只保存像素?cái)?shù)大于指定數(shù)量的皮膚區(qū)域
def _clear_regions(self, detected_regions):
    for region in detected_regions:
        if len(region) > 30:
            self.skin_regions.append(region)

# 分析區(qū)域
def _analyse_regions(self):
    # 如果皮膚區(qū)域小于 3 個(gè)，不是色情
    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

    # 為皮膚區(qū)域排序
    self.skin_regions = sorted(self.skin_regions, key=lambda s: len(s),
                               reverse=True)

    # 計(jì)算皮膚總像素?cái)?shù)
    total_skin = float(sum([len(skin_region) for skin_region in self.skin_regions]))

    # 如果皮膚區(qū)域與整個(gè)圖像的比值小于 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

    # 如果最大皮膚區(qū)域小于總皮膚面積的 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

    # 皮膚區(qū)域數(shù)量超過(guò) 60個(gè)，不是色情圖片
    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 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)

# 將在源文件目錄生成圖片文件，將皮膚區(qū)域可視化
def showSkinRegions(self):
    # 未得出結(jié)果時(shí)方法返回
    if self.result is None:
        return
    # 皮膚像素的 ID 的集合
    skinIdSet = set()
    # 將原圖做一份拷貝
    simage = self.image
    # 加載數(shù)據(jù)
    simageData = simage.load()

    # 將皮膚像素的 id 存入 skinIdSet
    for sr in self.skin_regions:
        for pixel in sr:
            skinIdSet.add(pixel.id)
    # 將圖像中的皮膚像素設(shè)為白色，其余設(shè)為黑色
    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
    # 源文件絕對(duì)路徑
    filePath = os.path.abspath(self.image.filename)
    # 源文件所在目錄
    fileDirectory = os.path.dirname(filePath) + '/'
    # 源文件的完整文件名
    fileFullName = os.path.basename(filePath)
    # 分離源文件的完整文件名得到文件名和擴(kuò)展名
    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 nude.py -v 1.jpg