做了個圖片識別系統，含檢測正經圖片的源碼

admin

2023年3月11日 10:3 本文熱度 769

項目介紹

本項目將使用python3去識別圖片是否為色情圖片，會使用到PIL這個圖像處理庫，并且編寫算法來劃分圖像的皮膚區域

介紹一下PIL：

PIL（Python Image Library）是一種免費的圖像處理工具包，這個軟件包提供了基本的圖像處理功能，如：改變圖像大小，旋轉圖像，圖像格式轉化，色場空間轉換（這個我不太懂），圖像增強（就是改善清晰度，突出圖像有用信息），直方圖處理，插值（利用已知鄰近像素點的灰度值來產生未知像素點的灰度值）和濾波等等。

雖然這個軟件包要實現復雜的圖像處理算法并不太適合，但是python的快速開發能力以及面向對象等等諸多特點使得它非常適合用來進行原型開發。

在 PIL 中，任何一副圖像都是用一個 Image 對象表示，而這個類由和它同名的模塊導出，因此，要加載一副圖像，最簡單的形式是這樣的：

import Image
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 工具包：

sudo install -U pip3
sudo install Pillow

程序原理

根據顏色（膚色）找出圖片中皮膚的區域，然后通過一些條件判斷是否為色情圖片。

程序的關鍵步驟如下：

遍歷每個像素，檢查像素顏色是否為膚色
將相鄰的膚色像素歸為一個皮膚區域，得到若干個皮膚區域
剔除像素數量極少的皮膚區域

我們定義非色情圖片的判定規則如下（滿足任意一個判斷為真）：

皮膚區域的個數小于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文件，在這個文件進行代碼編寫：

導入所需要的模塊：

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

我們將設計一個Nude類：

class Nude:

這個類里面我們首先使用 collections.namedtuple() 定義一個 Skin 類型：

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

collections.namedtuple() 函數實際上是一個返回 Python 中標準元組類型子類的一個工廠方法。你需要傳遞一個類型名和你需要的字段給它，然后它就會返回一個類，你可以初始化這個類，為你定義的字段傳遞值等。詳情參見官方文檔。

然后定義 Nude 類的初始化方法：

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

    # 獲得圖片所有顏色通道
    bands = self.image.getbands()
    # 判斷是否為單通道圖片（也即灰度圖），是則將灰度圖轉換為 RGB 圖
    if len(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 是其中任意一個類型的實例，返回真，否則假。

涉及到效率問題，越大的圖片所需要消耗的資源與時間越大，因此有時候可能需要對圖片進行縮小。所以需要有圖片縮小方法：

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
            # 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

Image.resize(size, resample=0)

size – 包含寬高像素數的元祖 (width, height) resample – 可選的重采樣濾波器

返回 Image 對象

然后便是最關鍵之一的解析方法了：

def parse(self):
    # 如果已有結果，返回本對象
    if self.result is not None:
        return self
    # 獲得圖片所有像素數據
    pixels = self.image.load()

接著，遍歷每個像素，為每個像素創建對應的 Skin 對象，其中 self._classify_skin() 這個方法是檢測像素顏色是否為膚色：

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 開始編起的，而索引是從 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
            # 遍歷每一個相鄰像素的索引
            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

self._add_merge() 這個方法接收兩個區域號，它將會把兩個區域號添加到 self.merge_regions 中的元素中，self.merge_regions 的每一個元素都是一個列表，這些列表中存放了 1 到多個的區域號，區域號代表的區域是連通的，需要合并。

檢測的圖像里，有些前幾行的像素的相鄰像素并沒有 4 個，所以需要用 try “試錯”。

然后相鄰像素的若是膚色像素，如果兩個像素的皮膚區域號都為有效值且不同，因為兩個區域中的像素相鄰，那么其實這兩個區域是連通的，說明需要合并這兩個區域。記錄下此相鄰膚色像素的區域號，之后便可以將當前像素歸到這個皮膚區域里了。

遍歷完所有相鄰像素后，分兩種情況處理：

所有相鄰像素都不是膚色像素：發現了新的皮膚區域。
存在區域號為有效值的相鄰膚色像素：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])

somenamedtuple._replace(kwargs) 返回一個替換指定字段的值為參數的 namedtuple實例

遍歷完所有像素之后，圖片的皮膚區域劃分初步完成了，只是在變量 self.merge_regions 中還有一些連通的皮膚區域號，它們需要合并，合并之后就可以進行色情圖片判定了：

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

方法 self._merge() 便是用來合并這些連通的皮膚區域的。方法 self._analyse_regions()，運用之前在程序原理一節定義的非色情圖像判定規則，從而得到判定結果。現在編寫我們還沒寫過的調用過的 Nude 類的方法。

首先是 self._classify_skin() 方法，這個方法是檢測像素顏色是否為膚色，之前在程序原理一節已經把膚色判定該公式列舉了出來，現在是用的時候了：

# 基于像素的膚色檢測技術
def _classify_skin(self, r, g, b):
    # 根據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
    # 根據處理后的 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):
    # 公式來源：
    # 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]

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 中

具體的處理方法，見代碼：

ef _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 的元素
    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

    # 若兩個區域號都存在于 self.merge_regions 中
    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

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

在序列中循環時，索引位置和對應值可以使用 enumerate() 函數同時得到，在上面的代碼中，索引位置即為 index ，對應值即為region。self._merge() 方法則是將 self.merge_regions 中的元素中的區域號所代表的區域合并，得到新的皮膚區域列表：

ef _merge(self, detected_regions, merge_regions):
    # 新建列表 new_detected_regions 
    # 其元素將是包含一些代表像素的 Skin 對象的列表
    # new_detected_regions 的元素即代表皮膚區域，元素索引為區域號
    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] = []

    # 添加剩下的其余皮膚區域到 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)

        # 添加剩下的其余皮膚區域到 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)

self._clear_regions() 方法只將像素數大于指定數量的皮膚區域保留到 self.skin_regions ：

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

self._analyse_regions() 是很簡單的，它的工作只是進行一系列判斷，得出圖片是否色情的結論：

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

    # 如果皮膚區域與整個圖像的比值小于 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 = "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)

Nude 類如果就這樣完成了，最后運行腳本時只能得到一些真或假的結果，我們需要更直觀的感受程序的分析效果，我們可以生成一張原圖的副本，不過這個副本圖片中只有黑白色，白色代表皮膚區域，那么這樣我們能直觀感受到程序分析的效果了。

前面的代碼中我們有獲得圖像的像素的 RGB 值的操作，設置像素的 RGB 值也就是其逆操作，還是很簡單的，不過注意設置像素的 RGB 值時不能在原圖上操作：

# 將在源文件目錄生成圖片文件，將皮膚區域可視化
def showSkinRegions(self):
    # 未得出結果時方法返回
    if self.result is None:
        return
    # 皮膚像素的 ID 的集合
    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))

變量 skinIdSet 使用集合而不是列表是有性能上的考量的，Python 中的集合是哈希表實現的，查詢效率很高。最后支持一下命令行參數就大功告成啦！

我們使用 argparse 這個模塊來實現命令行的支持。argparse 模塊使得編寫用戶友好的命令行接口非常容易。程序只需定義好它要求的參數，然后 argparse 將負責如何從 sys.argv 中解析出這些參數。argparse 模塊還會自動生成幫助和使用信息并且當用戶賦給程序非法的參數時產生錯誤信息。

具體使用方法請查看argparse的官方文檔

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")