python小項目（python實現鑑黃）源碼

時間 2019-11-19
原文原文鏈接
  1 import sys
  2 import os
  3 import _io
  4 from collections import namedtuple
  5 from PIL import Image
  6 
  7 class Nude(object):
  8 
  9     Skin = namedtuple("Skin", "id skin region x y")
 10 
 11     def __init__(self, path_or_image):
 12         # 若 path_or_image 爲 Image.Image 類型的實例，直接賦值
 13         if isinstance(path_or_image, Image.Image):
 14             self.image = path_or_image
 15         # 若 path_or_image 爲 str 類型的實例，打開圖片
 16         elif isinstance(path_or_image, str):
 17             self.image = Image.open(path_or_image)
 18 
 19         # 得到圖片全部顏色通道
 20         bands = self.image.getbands()
 21         # 判斷是否爲單通道圖片（也即灰度圖），是則將灰度圖轉換爲 RGB 圖
 22         if len(bands) == 1:
 23             # 新建相同大小的 RGB 圖像
 24             new_img = Image.new("RGB", self.image.size)
 25             # 拷貝灰度圖 self.image 到 RGB圖 new_img.paste （PIL 自動進行顏色通道轉換）
 26             new_img.paste(self.image)
 27             f = self.image.filename
 28             # 替換 self.image
 29             self.image = new_img
 30             self.image.filename = f
 31 
 32         # 存儲對應圖像全部像素的所有 Skin 對象
 33         self.skin_map = []
 34         # 檢測到的皮膚區域，元素的索引即爲皮膚區域號，元素都是包含一些 Skin 對象的列表
 35         self.detected_regions = []
 36         # 元素都是包含一些 int 對象（區域號）的列表
 37         # 這些元素中的區域號表明的區域都是待合併的區域
 38         self.merge_regions = []
 39         # 整合後的皮膚區域，元素的索引即爲皮膚區域號，元素都是包含一些 Skin 對象的列表
 40         self.skin_regions = []
 41         # 最近合併的兩個皮膚區域的區域號，初始化爲 -1
 42         self.last_from, self.last_to = -1, -1
 43         # 色情圖像判斷結果
 44         self.result = None
 45         # 處理獲得的信息
 46         self.message = None
 47         # 圖像寬高
 48         self.width, self.height = self.image.size
 49         # 圖像總像素
 50         self.total_pixels = self.width * self.height
 51 
 52     def resize(self, maxwidth=1000, maxheight=1000):
 53         """
 54         基於最大寬高按比例重設圖片大小，
 55         注意：這可能影響檢測算法的結果
 56 
 57         若是沒有變化返回 0
 58         原寬度大於 maxwidth 返回 1
 59         原高度大於 maxheight 返回 2
 60         原寬高大於 maxwidth, maxheight 返回 3
 61 
 62         maxwidth - 圖片最大寬度
 63         maxheight - 圖片最大高度
 64         傳遞參數時均可以設置爲 False 來忽略
 65         """
 66         # 存儲返回值
 67         ret = 0
 68         if maxwidth:
 69             if self.width > maxwidth:
 70                 wpercent = (maxwidth / self.width)
 71                 hsize = int((self.height * wpercent))
 72                 fname = self.image.filename
 73                 # Image.LANCZOS 是重採樣濾波器，用於抗鋸齒
 74                 self.image = self.image.resize((maxwidth, hsize), Image.LANCZOS)
 75                 self.image.filename = fname
 76                 self.width, self.height = self.image.size
 77                 self.total_pixels = self.width * self.height
 78                 ret += 1
 79         if maxheight:
 80             if self.height > maxheight:
 81                 hpercent = (maxheight / float(self.height))
 82                 wsize = int((float(self.width) * float(hpercent)))
 83                 fname = self.image.filename
 84                 self.image = self.image.resize((wsize, maxheight), Image.LANCZOS)
 85                 self.image.filename = fname
 86                 self.width, self.height = self.image.size
 87                 self.total_pixels = self.width * self.height
 88                 ret += 2
 89         return ret
 90 
 91     # 分析函數
 92     def parse(self):
 93         # 若是已有結果，返回本對象
 94         if self.result is not None:
 95             return self
 96         # 得到圖片全部像素數據
 97         pixels = self.image.load()
 98         # 遍歷每一個像素
 99         for y in range(self.height):
100             for x in range(self.width):
101                 # 獲得像素的 RGB 三個通道的值
102                 # [x, y] 是 [(x,y)] 的簡便寫法
103                 r = pixels[x, y][0]   # red
104                 g = pixels[x, y][1]   # green
105                 b = pixels[x, y][2]   # blue
106                 # 判斷當前像素是否爲膚色像素
107                 isSkin = True if self._classify_skin(r, g, b) else False
108                 # 給每一個像素分配惟一 id 值（1, 2, 3...height*width）
109                 # 注意 x, y 的值從零開始
110                 _id = x + y * self.width + 1
111                 # 爲每一個像素建立一個對應的 Skin 對象，並添加到 self.skin_map 中
112                 self.skin_map.append(self.Skin(_id, isSkin, None, x, y))
113                 # 若當前像素不爲膚色像素，跳過這次循環
114                 if not isSkin:
115                     continue
116 
117                 # 設左上角爲原點，相鄰像素爲符號 *，當前像素爲符號 ^，那麼相互位置關係一般以下圖
118                 # ***
119                 # *^
120 
121                 # 存有相鄰像素索引的列表，存放順序爲由大到小，順序改變有影響
122                 # 注意 _id 是從 1 開始的，對應的索引則是 _id-1
123                 check_indexes = [_id - 2, # 當前像素左方的像素
124                                  _id - self.width - 2,  # 當前像素左上方的像素
125                                  _id - self.width - 1,  # 當前像素的上方的像素
126                                  _id - self.width]  # 當前像素右上方的像素
127                 # 用來記錄相鄰像素中膚色像素所在的區域號，初始化爲 -1
128                 region = -1
129                 # 遍歷每個相鄰像素的索引
130                 for index in check_indexes:
131                     # 嘗試索引相鄰像素的 Skin 對象，沒有則跳出循環
132                     try:
133                         self.skin_map[index]
134                     except IndexError:
135                         break
136                     # 相鄰像素若爲膚色像素：
137                     if self.skin_map[index].skin:
138                         # 若相鄰像素與當前像素的 region 均爲有效值，且兩者不一樣，且還沒有添加相同的合併任務
139                         if (self.skin_map[index].region != None and
140                                 region != None and region != -1 and
141                                 self.skin_map[index].region != region and
142                                 self.last_from != region and
143                                 self.last_to != self.skin_map[index].region) :
144                             # 那麼這添加這兩個區域的合併任務
145                             self._add_merge(region, self.skin_map[index].region)
146                         # 記錄此相鄰像素所在的區域號
147                         region = self.skin_map[index].region
148                 # 遍歷完全部相鄰像素後，若 region 仍等於 -1，說明全部相鄰像素都不是膚色像素
149                 if region == -1:
150                     # 更改屬性爲新的區域號，注意元祖是不可變類型，不能直接更改屬性
151                     _skin = self.skin_map[_id - 1]._replace(region=len(self.detected_regions))
152                     self.skin_map[_id - 1] = _skin
153                     # 將此膚色像素所在區域建立爲新區域
154                     self.detected_regions.append([self.skin_map[_id - 1]])
155                 # region 不等於 -1 的同時不等於 None，說明有區域號爲有效值的相鄰膚色像素
156                 elif region != None:
157                     # 將此像素的區域號更改成與相鄰像素相同
158                     _skin = self.skin_map[_id - 1]._replace(region=region)
159                     self.skin_map[_id - 1] = _skin
160                     # 向這個區域的像素列表中添加此像素
161                     self.detected_regions[region].append(self.skin_map[_id - 1])
162         # 完成全部區域合併任務，合併整理後的區域存儲到 self.skin_regions
163         self._merge(self.detected_regions, self.merge_regions)
164         # 分析皮膚區域，獲得斷定結果
165         self._analyse_regions()
166         return self
167 
168 
169     # self.merge_regions 的元素都是包含一些 int 對象（區域號）的列表
170     # self.merge_regions 的元素中的區域號表明的區域都是待合併的區域
171     # 這個方法即是將兩個待合併的區域號添加到 self.merge_regions 中
172     def _add_merge(self, _from, _to):
173         # 兩個區域號賦值給類屬性
174         self.last_from = _from
175         self.last_to = _to
176 
177         # 記錄 self.merge_regions 的某個索引值，初始化爲 -1
178         from_index = -1
179         # 記錄 self.merge_regions 的某個索引值，初始化爲 -1
180         to_index = -1
181 
182 
183         # 遍歷每一個 self.merge_regions 的元素
184         for index, region in enumerate(self.merge_regions):
185             # 遍歷元素中的每一個區域號
186             for r_index in region:
187                 if r_index == _from:
188                     from_index = index
189                 if r_index == _to:
190                     to_index = index
191 
192         # 若兩個區域號都存在於 self.merge_regions 中
193         if from_index != -1 and to_index != -1:
194             # 若是這兩個區域號分別存在於兩個列表中
195             # 那麼合併這兩個列表
196             if from_index != to_index:
197                 self.merge_regions[from_index].extend(self.merge_regions[to_index])
198                 del(self.merge_regions[to_index])
199             return
200 
201         # 若兩個區域號都不存在於 self.merge_regions 中
202         if from_index == -1 and to_index == -1:
203             # 建立新的區域號列表
204             self.merge_regions.append([_from, _to])
205             return
206         # 若兩個區域號中有一個存在於 self.merge_regions 中
207         if from_index != -1 and to_index == -1:
208             # 將不存在於 self.merge_regions 中的那個區域號
209             # 添加到另外一個區域號所在的列表
210             self.merge_regions[from_index].append(_to)
211             return
212         # 若兩個待合併的區域號中有一個存在於 self.merge_regions 中
213         if from_index == -1 and to_index != -1:
214             # 將不存在於 self.merge_regions 中的那個區域號
215             # 添加到另外一個區域號所在的列表
216             self.merge_regions[to_index].append(_from)
217             return
218 
219     # 合併該合併的皮膚區域
220     def _merge(self, detected_regions, merge_regions):
221         # 新建列表 new_detected_regions 
222         # 其元素將是包含一些表明像素的 Skin 對象的列表
223         # new_detected_regions 的元素即表明皮膚區域，元素索引爲區域號
224         new_detected_regions = []
225 
226         # 將 merge_regions 中的元素中的區域號表明的全部區域合併
227         for index, region in enumerate(merge_regions):
228             try:
229                 new_detected_regions[index]
230             except IndexError:
231                 new_detected_regions.append([])
232             for r_index in region:
233                 new_detected_regions[index].extend(detected_regions[r_index])
234                 detected_regions[r_index] = []
235 
236         # 添加剩下的其他皮膚區域到 new_detected_regions
237         for region in detected_regions:
238             if len(region) > 0:
239                 new_detected_regions.append(region)
240 
241         # 清理 new_detected_regions
242         self._clear_regions(new_detected_regions)
243 
244     # 皮膚區域清理函數
245     # 只保存像素數大於指定數量的皮膚區域
246     def _clear_regions(self, detected_regions):
247         for region in detected_regions:
248             if len(region) > 30:
249                 self.skin_regions.append(region)
250 
251     # 分析區域
252     def _analyse_regions(self):
253         # 若是皮膚區域小於 3 個，不是色情
254         if len(self.skin_regions) < 3:
255             self.message = "Less than 3 skin regions ({_skin_regions_size})".format(
256                 _skin_regions_size=len(self.skin_regions))
257             self.result = False
258             return self.result
259 
260         # 爲皮膚區域排序
261         self.skin_regions = sorted(self.skin_regions, key=lambda s: len(s),
262                                    reverse=True)
263 
264         # 計算皮膚總像素數
265         total_skin = float(sum([len(skin_region) for skin_region in self.skin_regions]))
266 
267         # 若是皮膚區域與整個圖像的比值小於 15%，那麼不是色情圖片
268         if total_skin / self.total_pixels * 100 < 15:
269             self.message = "Total skin percentage lower than 15 ({:.2f})".format(total_skin / self.total_pixels * 100)
270             self.result = False
271             return self.result
272 
273         # 若是最大皮膚區域小於總皮膚面積的 45%，不是色情圖片
274         if len(self.skin_regions[0]) / total_skin * 100 < 45:
275             self.message = "The biggest region contains less than 45 ({:.2f})".format(len(self.skin_regions[0]) / total_skin * 100)
276             self.result = False
277             return self.result
278 
279         # 皮膚區域數量超過 60個，不是色情圖片
280         if len(self.skin_regions) > 60:
281             self.message = "More than 60 skin regions ({})".format(len(self.skin_regions))
282             self.result = False
283             return self.result
284 
285         # 其它狀況爲色情圖片
286         self.message = "Nude!!"
287         self.result = True
288         return self.result
289 
290     # 基於像素的膚色檢測技術
291     def _classify_skin(self, r, g, b):
292         # 根據RGB值斷定
293         rgb_classifier = r > 95 and \
294             g > 40 and g < 100 and \
295             b > 20 and \
296             max([r, g, b]) - min([r, g, b]) > 15 and \
297             abs(r - g) > 15 and \
298             r > g and \
299             r > b
300         # 根據處理後的 RGB 值斷定
301         nr, ng, nb = self._to_normalized(r, g, b)
302         norm_rgb_classifier = nr / ng > 1.185 and \
303             float(r * b) / ((r + g + b) ** 2) > 0.107 and \
304             float(r * g) / ((r + g + b) ** 2) > 0.112
305 
306         # HSV 顏色模式下的斷定
307         h, s, v = self._to_hsv(r, g, b)
308         hsv_classifier = h > 0 and \
309             h < 35 and \
310             s > 0.23 and \
311             s < 0.68
312 
313         # YCbCr 顏色模式下的斷定
314         y, cb, cr = self._to_ycbcr(r, g,  b)
315         ycbcr_classifier = 97.5 <= cb <= 142.5 and 134 <= cr <= 176
316 
317         # 效果不是很好，還需改公式
318         # return rgb_classifier or norm_rgb_classifier or hsv_classifier or ycbcr_classifier
319         return ycbcr_classifier
320 
321     def _to_normalized(self, r, g, b):
322         if r == 0:
323             r = 0.0001
324         if g == 0:
325             g = 0.0001
326         if b == 0:
327             b = 0.0001
328         _sum = float(r + g + b)
329         return [r / _sum, g / _sum, b / _sum]
330 
331     def _to_ycbcr(self, r, g, b):
332         # 公式來源：
333         # http://stackoverflow.com/questions/19459831/rgb-to-ycbcr-conversion-problems
334         y = .299*r + .587*g + .114*b
335         cb = 128 - 0.168736*r - 0.331364*g + 0.5*b
336         cr = 128 + 0.5*r - 0.418688*g - 0.081312*b
337         return y, cb, cr
338 
339     def _to_hsv(self, r, g, b):
340         h = 0
341         _sum = float(r + g + b)
342         _max = float(max([r, g, b]))
343         _min = float(min([r, g, b]))
344         diff = float(_max - _min)
345         if _sum == 0:
346             _sum = 0.0001
347 
348         if _max == r:
349             if diff == 0:
350                 h = sys.maxsize
351             else:
352                 h = (g - b) / diff
353         elif _max == g:
354             h = 2 + ((g - r) / diff)
355         else:
356             h = 4 + ((r - g) / diff)
357 
358         h *= 60
359         if h < 0:
360             h += 360
361 
362         return [h, 1.0 - (3.0 * (_min / _sum)), (1.0 / 3.0) * _max]
363 
364     def inspect(self):
365         _image = '{} {} {}×{}'.format(self.image.filename, self.image.format, self.width, self.height)
366         return "{_image}: result={_result} message='{_message}'".format(_image=_image, _result=self.result, _message=self.message)
367 
368     # 將在源文件目錄生成圖片文件，將皮膚區域可視化
369     def showSkinRegions(self):
370         # 未得出結果時方法返回
371         if self.result is None:
372             return
373         # 皮膚像素的 ID 的集合
374         skinIdSet = set()
375         # 將原圖作一份拷貝
376         simage = self.image
377         # 加載數據
378         simageData = simage.load()
379 
380         # 將皮膚像素的 id 存入 skinIdSet
381         for sr in self.skin_regions:
382             for pixel in sr:
383                 skinIdSet.add(pixel.id)
384         # 將圖像中的皮膚像素設爲白色，其他設爲黑色
385         for pixel in self.skin_map:
386             if pixel.id not in skinIdSet:
387                 simageData[pixel.x, pixel.y] = 0, 0, 0
388             else:
389                 simageData[pixel.x, pixel.y] = 255, 255, 255
390         # 源文件絕對路徑
391         filePath = os.path.abspath(self.image.filename)
392         # 源文件所在目錄
393         fileDirectory = os.path.dirname(filePath) + '/'
394         # 源文件的完整文件名
395         fileFullName = os.path.basename(filePath)
396         # 分離源文件的完整文件名獲得文件名和擴展名
397         fileName, fileExtName = os.path.splitext(fileFullName)
398         # 保存圖片
399         simage.save('{}{}_{}{}'.format(fileDirectory, fileName,'Nude' if self.result else 'Normal', fileExtName))
400 
401 if __name__ == "__main__":
402     import argparse
403 
404     parser = argparse.ArgumentParser(description='Detect nudity in images.')
405     parser.add_argument('files', metavar='image', nargs='+',
406                         help='Images you wish to test')
407     parser.add_argument('-r', '--resize', action='store_true',
408                         help='Reduce image size to increase speed of scanning')
409     parser.add_argument('-v', '--visualization', action='store_true',
410                         help='Generating areas of skin image')
411 
412     args = parser.parse_args()
413 
414     for fname in args.files:
415         if os.path.isfile(fname):
416             n = Nude(fname)
417             if args.resize:
418                 n.resize(maxheight=800, maxwidth=600)
419             n.parse()
420             if args.visualization:
421                 n.showSkinRegions()
422             print(n.result, n.inspect())
423         else:
424             print(fname, "is not a file")