1. 程式人生 > >Python - 批量生成幻影坦克圖片

Python - 批量生成幻影坦克圖片

目錄

  • 一、準備圖片
  • 二、Python+PIL程式碼實現過程
  • 三、完整程式碼檔案

說到幻影坦克,我就想起紅色警戒裡的……

幻影坦克(Mirage Tank),《紅色警戒2》以及《尤里的復仇》中盟軍的一款偽裝坦克,盟軍王牌坦克之一。是愛因斯坦在德國黑森林中研發的一種坦克。雖然它無法隱形,但它卻可以利用先進的光線偏折原理可以偽裝成樹木(岩石或草叢)來隱藏自己。
在一些MOD中,幻影坦克可以選擇變換的樹木,這樣便可以和背景的樹木融合,而不會令人生疑。

額!這是從什麼百科ctrl+v過來的嗎。我跟你說個P~ UBG

不過話說回來,裡面有一句說到和背景融合,這大概就是這種圖片的原理所在了。
一些聊天軟體或網站總是以白色背景和黑色背景(夜間模式)顯示圖片,你在預設的白色背景下看到一張圖(圖A),但是點選放大卻變成另一張圖(圖B)。這是因為檢視詳情使用的背景是黑色背景。

之前在網上看到用PS製作幻影坦克效果圖的方法,瞭解到幾個圖層混合模式的公式,也錄製過PS動作來自動化操作。但總感覺不夠效率,作為極客嘛,當然是要用程式碼來完成這些事情。


一、準備圖片

  • 建立一個資料夾Import,將你要處理的所有圖片都放到這個資料夾裡
  • 圖片的命名方式:
    • 白色背景顯示圖A、黑色背景顯示圖B這種形式的,圖B的檔名字是圖A的名字加字尾_d

      例如,圖A為1.png,圖B則為1_d.png,與之配對成為一組即可
    • 表面是白色圖片(圖A),點選顯示隱藏圖片(圖B)。這裡並不需要你指定一張白色圖片,不需要更改圖片名字,程式找不到與之配對的字尾_d圖片,會自動生成白色圖片(圖A)
    • 相反的,表面看是圖片(圖A),點選卻消失成純黑色(圖B)。只需要在圖片名字加字尾_black

二、Python+PIL程式碼實現過程

Ⅰ. 初始化

注:指令碼檔案與 Import資料夾在同一目錄

  • 執行,匯入模組,定義變數,建立匯出目錄Export,並將工作目錄切換到Import

    # -*- coding: utf-8 -*-
    # python 3.7.2
    # 2019/04/21 by sryml.
    
    import os
    import math
    
    from timeit import timeit
    from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
    from multiprocessing import cpu_count
    
    #
    import numba as nb
    import numpy as np
    
    from PIL import Image
    
    
    # ---
    IMPORT_FOLDER = 'Import'
    EXPORT_FOLDER = 'Export'
    IMAGE_FILES = []
    
    #
    ALIGN2_A = 0
    ALIGN2_B = 1
    ALIGN2_MAX = 'max'
    
    NO_MODIFT = 0
    STRETCH = 1
    CONSTRAINT_RATIO = 2
    
    # ---
    
    
    if __name__ == '__main__':
        if not os.path.exists(EXPORT_FOLDER):
            os.makedirs(EXPORT_FOLDER)
        os.chdir(IMPORT_FOLDER)


Ⅱ. 將所有要處理的圖片檔案新增到列表

  • 執行all_img2list()
    獲取當前目錄(Import)所有檔案,按名字升序排序。將字尾帶_d的圖B與圖A配對一組,白圖到原圖,原圖到黑圖的圖片也進行相關標記並存到一個列表。每個元組將生成一張幻影坦克圖片

    def all_img2list():
        global IMAGE_FILES
        IMAGE_FILES= []
        Imgs = os.listdir('./')
        Imgs.sort(key= lambda i: os.path.splitext(i)[0])
    
        for i in Imgs:
            name = os.path.splitext(i)
            imgB= name[0]+'_d' + name[1]
    
            if imgB in Imgs:
                Imgs.remove(imgB)
                img_group= (i,imgB)
            elif name[0][-6:].lower() == '_black':
                img_group= (i,'_black')
            else:
                img_group= (i,None)
    
            IMAGE_FILES.append(img_group)


Ⅲ. 自動化處理,多程序任務分配

  • 執行AutoMTank()
    不想讓cpu滿載執行,程序數量為cpu總核心減1,將列表裡所有元組分成N等份集合的列表task_assign(N為程序數量)

    def AutoMTank():
        cpu  = cpu_count()-1
        pool = ProcessPoolExecutor(cpu) #max_workers=4
        L    = IMAGE_FILES
        F    = int(len(L)/cpu)
        task_assign = [L[n*F:] if (n+1)==cpu else L[n*F:(n+1)*F] for n in range(cpu)]
        results = list(pool.map(FlashMakeMTank, task_assign))
    
        pool.shutdown()
    
        print ('\n%d輛幻影坦克製作完成!' % len(IMAGE_FILES))
  • 每個程序對接到的任務列表進行多執行緒處理:FlashMakeMTank
    因為是圖片演算法處理,屬於計算密集型,執行緒數量不需要太多。經過測試多執行緒還是有點效率提升的,執行緒數就設定為cpu核心數吧。

    def FlashMakeMTank(task):
        pool = ThreadPoolExecutor(cpu_count())
        results = list(pool.map(MakeMTank, task))
        pool.shutdown()


Ⅳ. 盟軍戰車工廠

  • 每個執行緒都將它接到的任務 - 圖片組丟給我們的盟軍戰車工廠:MakeMTank 來生產幻影坦克
  • 開頭是開啟圖A和圖B檔案物件賦值給imgAimgB,判斷到那些想要白圖到原圖效果的圖片,則在記憶體中生成一張純白色的圖片物件賦值給imgA原圖到黑圖則生成純黑色圖片物件賦值給imgB
  • 別以為這戰車工廠看起來這麼短,實際上演算法都是通過呼叫函式獲得返回結果,解釋起來可有點費勁

    def MakeMTank(i_group):
        ratios= [0,0]
        align= []
        if not i_group[1]:
            imgB= Image.open(i_group[0])
            imgA= Image.new('L',imgB.size,(255,))
        elif i_group[1]=='_black':
            imgA= Image.open(i_group[0])
            imgB= Image.new('L',imgA.size,(0,))
        else:
            imgA= Image.open(i_group[0])
            imgB= Image.open(i_group[1])
            ratios= [0.5,-0.5] #明度比值
    
            # ALIGN2_MAX(取最大的寬和最大的高) ALIGN2_A(縮放到圖A) ALIGN2_B(縮放到圖B) 
            # NO_MODIFT(不修改)  STRETCH(拉伸)  CONSTRAINT_RATIO(約束比例)
            align= [ALIGN2_B, CONSTRAINT_RATIO]
    
        A_Size,B_Size= imgA.size,imgB.size
        img_objs= [imgA,imgB]
        for n,img in enumerate(img_objs):
            if img.mode== 'RGBA':
                img= img.convert('RGB')
            img_array= np.array(img)
            if img.mode != 'L' and ( [(img_array[:,:,i]==img_array[:,:,2]).all() for i in range(2)]!= [True,True] ):
                img= Desaturate(img_array) #去色
            else:
                img= img.convert('L')
    
            if align and (A_Size!=B_Size):
                img= ImgAlign(n,img,A_Size,B_Size,align) #影象對齊
    
            if ratios[n]:
                img= Lightness(img,ratios[n]) #明度
            img_objs[n]= img
    
        imgA,imgB = img_objs
    
        imgA = Invert(imgA) #反相
        imgO = LinearDodge(imgA, imgB) #線性減淡(新增)
        imgR = Divide(imgO, imgB) #劃分
        imgR_mask = AddMask(imgR, imgO) #新增透明蒙版
    
        name= os.path.splitext(i_group[0])[0]
        imgR_mask.save('../'+EXPORT_FOLDER+'/' + name+'.png')
  • 圖片物件開啟完成之後呢,把它們放到一個列表裡遍歷它進行操作
  • 首先判斷到圖片模式是否為RGBA,最後的A表示這張圖片是帶有透明通道的。而我們的幻影坦克原理就是利用的透明通道,怎能讓它來胡攪蠻纏呢,速速將它轉換為RGB模式
  • 接著將影象物件轉為陣列,判斷這張圖片如果不是灰度模式並且還沒有去色的情況下,那就要對它進行去色操作了。
    去完色的再將它轉為灰度模式。

    有些人可能對灰度去色有什麼誤解,灰度 ≠ 去色,這是重點。雖然它們的結果都是灰色的圖片,但是演算法不一樣,呈現的圖片對比度也不一樣,直接轉成灰度的坦克是沒有靈魂的。RGB圖片直接轉灰度會丟失一些細節,所以要對它進行去色操作。下面的操作都是仿照PS的步驟來處理了

  • (1) 去色函式:Desaturate
    • 公式:( max(r,g,b) + min(r,g,b) ) / 2
      每個畫素取其RGB顏色中最大與最小值的均數
    • 這個函式接受一個數組引數

    例如某個畫素RGB值(233,50,23),計算得出 (233+23) / 2 = 128,這時候此畫素點三個通道都是同一個值(128,128,128)
    這個演算法過程消耗的效能較多,像一張1000*1000的圖片就得進行一百萬次計算,因此我使用了numba.jit加速。
    對圖片陣列進行操作,使用argsort()將所有畫素的RGB值從小到大排序並返回一個索引陣列。
    uint8型別的值的範圍在0~255,若計算出的值不在這範圍則會丟擲溢位錯誤,因此使用了int
    我建立了一個灰度圖片陣列data,將每一個對應畫素的均值賦值給它,相當於去色後再轉為灰度模式。
    最後返回由陣列轉換成的圖片物件

    @nb.jit
    def Desaturate(img_array):
        idx_array = img_array.argsort()
        width   = img_array.shape[1]
        height  = img_array.shape[0]
        data    = np.zeros((height,width),dtype=np.uint8)
        for x in range(height):
            for y in range(width):
                idx= idx_array[x,y]
                color_min= img_array[x,y, idx[0]]
                color_max= img_array[x,y, idx[2]]
                data[x,y]= round( (int(color_min) + int(color_max)) / 2 )
        return Image.fromarray(data)


  • (2) 影象對齊:ImgAlign
    • 對齊方式(列表型別兩個值)

      對齊目標 縮放影象
      ALIGN2_MAX 取最大的寬和最大的高 NO_MODIFT 不修改(縮小或僅畫布)
      ALIGN2_A 圖A STRETCH 拉伸
      ALIGN2_B 圖B CONSTRAINT_RATIO 約束比例
      例如我要把圖A對齊到圖B且按比例縮放:mode = [ALIGN2_B, CONSTRAINT_RATIO]
    • 這個函式接受5個引數
      ①當前圖片序號(0代表圖A,1代表圖B)
      ②當前圖片物件
      ③ - ④圖A和圖B的尺寸
      ⑤對齊方式

    def ImgAlign(idx,img,A_Size,B_Size,mode):
        size= img.size
        old_size= (A_Size,B_Size)
    
        if mode[0]== ALIGN2_MAX:
            total_size= max(A_Size[0], B_Size[0]), max(A_Size[1], B_Size[1])
            if size != total_size:
                if mode[1]== STRETCH:
                    img= img.resize(total_size, Image.ANTIALIAS)
                else:
                    new_img= Image.new('L',total_size, (255 if idx==0 else 0,))
                    diff= (total_size[0]-size[0],total_size[1]-size[1])
                    min_diff= min(diff[0],diff[1])
                    if min_diff != 0 and mode[1]:
                        idx= diff.index(min_diff)
                        scale= total_size[idx] / size[idx]
                        resize= [total_size[idx], round(size[1-idx]*scale)]
                        if idx:
                            resize.reverse()
                        img= img.resize(resize, Image.ANTIALIAS)
                    new_img.paste(img, [(total_size[i]-img.size[i])//2 for i in range(2)])
                    img= new_img
        elif idx != mode[0]:
            total_size= old_size[mode[0]]
            if mode[1]== STRETCH:
                img= img.resize(total_size, Image.ANTIALIAS)
            else:
                new_img= Image.new('L',total_size, (255 if idx==0 else 0,))
                diff= (total_size[0]-size[0],total_size[1]-size[1])
                min_diff= min(diff[0],diff[1])
                if (min_diff > 0 and mode[1]) or (min_diff < 0):
                    idx= diff.index(min_diff)
                    scale= total_size[idx] / size[idx]
                    resize= [total_size[idx], round(size[1-idx]*scale)]
                    if idx:
                        resize.reverse()
                    img= img.resize(resize, Image.ANTIALIAS)
                new_img.paste(img, [(total_size[i]-img.size[i])//2 for i in range(2)])
                img= new_img
    
        return img


  • (3) 明度函式:Lightness
    • 公式:255 * ratio + img * (1-ratio)
             0 * ratio + img * (1-ratio)
      為什麼是兩條公式呢,可以看到只有 255和 0的區別,一個是提高明度,一個是降低
    • 注意,明度 ≠ 亮度,用亮度做出來的坦克是畸形的。亮度對顏色0和255不會起任何作用,任你怎麼加亮度,我白是白,黑仍然是黑。這又涉及到幻影坦克效果的原理了,圖A每個畫素值必須大於圖B對應的畫素值,否則將沒有透明度效果。
    • 所以,最好的效果就是圖A明度提高50%,圖B降低50%
    • 這個函式接受2個引數
      ①圖片物件
      ②明度比值(-1~1)
      儘量仿照PS的演算法結果,提高明度的值為向下取整,降低明度為向上取整

      def Lightness(img,ratio):
          if ratio>0:
              return img.point(lambda i: int(i*(1-ratio) + 255*ratio))
          return img.point(lambda i: math.ceil(i*(1+ratio)))
    • 實際上這是圖層的不透明度混合公式,PS中,明度的實現就是在當前圖層的上方建立一個白色或黑色圖層,然後調整其透明度即可。所以,
      明度調  100% 相當於白色圖層的不透明度為100%,顯示純白
      明度調 -100% 相當於黑色圖層的不透明度為100%,顯示純黑。

看到這裡,要暫停一下了。是不是感覺說了這麼多都沒有提到幻影坦克的詳細原理,是的,只有當你理解了PS的不透明度混合公式,你才能理解後面的步驟。

  • (3-x) 重點!!推導幻影坦克的原理……
    • 這裡需要用到PS的幾個圖層混合模式
    • 不透明度混合公式:Img輸出 = Img上 * o + Img下 * (1 - o)
      小字母o代表不透明度。想一想,把兩張圖片匯入到PS,上面的圖層命名為imgA,下面的圖層為imgB。
      當imgA的不透明度為100%(o=1)時,根據圖層混合公式得到img輸出=imgA,也就是完全顯示上層影象。
      當imgA的不透明度為0%(o=0)時,得到img輸出=imgB,完全顯示下層影象。
      當不透明度為50%,自然就看到了A與B的混合影象。

      但是我們要將這兩張圖給整進一張圖裡,然後在類似手機QQ這種只有白色背景和黑色背景的環境下,分別顯示出imgA和imgB。聽起來有點抽象,不要慌,我們來列方程。假設這張最終成果圖為imgR

      ImgA = ImgR * o + 255 * (1 - o) 白色背景下
      ImgB = ImgR * o +     0 * (1 - o) 黑色背景下(點選放大後)

      這時候ImgR充當上圖層(Img上)。它有一個固定不透明度o,或者說是它的圖層蒙版(ImgO表示ImgR的蒙版),蒙版的畫素值為0~255的單通道灰度色值。填充為黑色0相當於圖層的不透明度為0%,填充為白色相當於圖層不透明度為100%。那麼這個固定不透明度 o 實際上就是 ⑨ o = ImgO / 255
      而Img下就是聊天軟體中的白色背景和黑色背景兩種可能了。

    現在來解一下方程,由②得:






    ImgR = ImgB / o

    將⑨ o = ImgO / 255 代入得

    ImgR = ImgB / ImgO * 255

    將③和⑨代入①得:






    ImgA = (ImgB / ImgO * 255) * (ImgO / 255) + 255 * (1 - ImgO / 255)

    ImgA = ImgB / ImgO * ImgO / 255 * 255 + 255 * (1 - ImgO / 255)


    ImgA = ImgB + 2551 - 255(ImgO / 255)

    ImgA = ImgB + 255 - ImgO


    ImgO = (255 - ImgA) + ImgB

    那麼現在,ImgB是我們已知的要在黑色背景下顯示的影象,只要拿到ImgO就可以得出成品圖ImgR了。
    (255 - ImgA) 這個是什麼意思,就是PS中的反相操作啦。讓我們回到程式碼操作

  • (4) 反相函式:Invert
    • 公式:255 - Img
      即對每個畫素進行 255-畫素值

      def Invert(img):
          return img.point(lambda i: 255-i)

      反ImgA = Invert(ImgA )
      然後這個反相後的ImgA(反ImgA)與ImgB相加,即PS中的線性減淡模式

  • (5) 線性減淡(新增):LinearDodge
    • 公式:Img上 + Img下

      def LinearDodge(imgA, imgB):
          size = imgA.size
          imgO = Image.new('L',size,(0,))
          pxA= imgA.load()
          pxB= imgB.load()
          pxO= imgO.load()
          for x in range(size[0]):
              for y in range(size[1]):
                  pxO[x,y] = (pxA[x,y]+pxB[x,y],)
          return imgO

      至此得到 ImgO = LinearDodge(反ImgA, ImgB)
      注:之前我們說過ImgA的所有畫素值必須大於ImgB。如果小於或等於,那麼反相後加自身(或加比自身大的值)就是255了。因為ImgO是成果圖ImgR的透明蒙版,ImgO=255意味著不透明度為100%,就沒有透明效果了。

      接著看方程式子③ ImgR = ImgB / ImgO * 255,這便是PS的一種圖層混合模式劃分了

  • (6) 劃分:Divide
    • 公式:Img下 / Img上 * 255
    • 幾個注意的條件
      ①若混合色為黑色,基色非黑結果為白色、基色為黑結果為黑色(混合色是Img上,基色是Img下)
      ②若混合色為白色則結果為基色
      ③若混合色與基色相同則結果為白色
      不妨可以在PS中一試便知真假

      def Divide(imgO, imgB):
          size = imgB.size
          imgR = Image.new('L',size,(0,))
          pxB= imgB.load()
          pxO= imgO.load()
          pxR= imgR.load()
          for x in range(size[0]):
              for y in range(size[1]):
                  o=pxO[x,y]
                  b=pxB[x,y]
                  if o==0:
                      #如混合色為黑色,基色非黑結果為白色、基色為黑結果為黑色
                      color= (b and 255 or 0,)
                  elif o==255:
                      #混合色為白色則結果為基色
                      color=(b,)
                  elif o==b:
                      #混合色與基色相同則結果為白色
                      color=(255,)
                  else:
                      color=(round((b/o)*255),)
                  pxR[x,y] = color
          return imgR

      呼叫劃分函式ImgR = Divide(ImgO, ImgB),終於,我們得到了夢寐以求的成果圖ImgR
      但不要忘了它的不透明度,把ImgO新增為它的圖層蒙版

  • (6) 最後:新增透明蒙版並儲存
    def AddMask(imgR,imgO):
        img = imgR.convert("RGBA")
        img.putalpha(imgO)
        return img

    imgR_mask = AddMask(imgR, imgO)

    name= os.path.splitext(i_group[0])[0]
    imgR_mask.save('../'+EXPORT_FOLDER+'/' + name+'.png')
    儲存在匯出資料夾。。。
  • 個人感覺

    這個指令碼生成的幻影坦克與PS做的相比就猶如真假美猴王一般,說到美猴王,我就想起……



三、完整程式碼檔案

  • MirageTank.py
# -*- coding: utf-8 -*-
# python 3.7.2
# 2019/04/21 by sryml.

import os
import math

from timeit import timeit
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from multiprocessing import cpu_count

#
import numba as nb
import numpy as np

from PIL import Image


# ---
IMPORT_FOLDER = 'Import'
EXPORT_FOLDER = 'Export'
IMAGE_FILES = []

#
ALIGN2_A = 0
ALIGN2_B = 1
ALIGN2_MAX = 'max'

NO_MODIFT = 0
STRETCH = 1
CONSTRAINT_RATIO = 2

# ---




### 影象對齊
def ImgAlign(idx,img,A_Size,B_Size,mode):
    size= img.size
    old_size= (A_Size,B_Size)

    if mode[0]== ALIGN2_MAX:
        total_size= max(A_Size[0], B_Size[0]), max(A_Size[1], B_Size[1])
        if size != total_size:
            if mode[1]== STRETCH:
                img= img.resize(total_size, Image.ANTIALIAS)
            else:
                new_img= Image.new('L',total_size, (255 if idx==0 else 0,))
                diff= (total_size[0]-size[0],total_size[1]-size[1])
                min_diff= min(diff[0],diff[1])
                if min_diff != 0 and mode[1]:
                    idx= diff.index(min_diff)
                    scale= total_size[idx] / size[idx]
                    resize= [total_size[idx], round(size[1-idx]*scale)]
                    if idx:
                        resize.reverse()
                    img= img.resize(resize, Image.ANTIALIAS)
                new_img.paste(img, [(total_size[i]-img.size[i])//2 for i in range(2)])
                img= new_img
    elif idx != mode[0]:
        total_size= old_size[mode[0]]
        if mode[1]== STRETCH:
            img= img.resize(total_size, Image.ANTIALIAS)
        else:
            new_img= Image.new('L',total_size, (255 if idx==0 else 0,))
            diff= (total_size[0]-size[0],total_size[1]-size[1])
            min_diff= min(diff[0],diff[1])
            if (min_diff > 0 and mode[1]) or (min_diff < 0):
                idx= diff.index(min_diff)
                scale= total_size[idx] / size[idx]
                resize= [total_size[idx], round(size[1-idx]*scale)]
                if idx:
                    resize.reverse()
                img= img.resize(resize, Image.ANTIALIAS)
            new_img.paste(img, [(total_size[i]-img.size[i])//2 for i in range(2)])
            img= new_img
            
    return img


### 去色
@nb.jit
def Desaturate(img_array):
    idx_array = img_array.argsort()
    width   = img_array.shape[1]
    height  = img_array.shape[0]
    data    = np.zeros((height,width),dtype=np.uint8)
    for x in range(height):
        for y in range(width):
            idx= idx_array[x,y]
            color_min= img_array[x,y, idx[0]]
            color_max= img_array[x,y, idx[2]]
            data[x,y]= round( (int(color_min) + int(color_max)) / 2 )
    return Image.fromarray(data)
                

### 明度
def Lightness(img,ratio):
    if ratio>0:
        return img.point(lambda i: int(i*(1-ratio) + 255*ratio))
    return img.point(lambda i: math.ceil(i*(1+ratio)))

    
### 反相
def Invert(img):
    return img.point(lambda i: 255-i)
    

### 線性減淡(新增)
def LinearDodge(imgA, imgB):
    size = imgA.size
    imgO = Image.new('L',size,(0,))
    pxA= imgA.load()
    pxB= imgB.load()
    pxO= imgO.load()
    for x in range(size[0]):
        for y in range(size[1]):
            pxO[x,y] = (pxA[x,y]+pxB[x,y],)
    return imgO

    
### 劃分
def Divide(imgO, imgB):
    size = imgB.size
    imgR = Image.new('L',size,(0,))
    pxB= imgB.load()
    pxO= imgO.load()
    pxR= imgR.load()
    for x in range(size[0]):
        for y in range(size[1]):
            o=pxO[x,y]
            b=pxB[x,y]
            if o==0:
                #如混合色為黑色,基色非黑結果為白色、基色為黑結果為黑色
                color= (b and 255 or 0,)
            elif o==255:
                #混合色為白色則結果為基色
                color=(b,)
            elif o==b:
                #混合色與基色相同則結果為白色
                color=(255,)
            else:
                color=(round((b/o)*255),)
            pxR[x,y] = color
    return imgR

    
def AddMask(imgR,imgO):
    img = imgR.convert("RGBA")
    img.putalpha(imgO)
    return img



####
#### 將所有要處理的圖片檔案新增到列表
def all_img2list():
    global IMAGE_FILES
    IMAGE_FILES= []
    Imgs = os.listdir('./')
    Imgs.sort(key= lambda i: os.path.splitext(i)[0])
    
    for i in Imgs:
        name = os.path.splitext(i)
        imgB= name[0]+'_d' + name[1]
        
        if imgB in Imgs:
            Imgs.remove(imgB)
            img_group= (i,imgB)
        elif name[0][-6:].lower() == '_black':
            img_group= (i,'_black')
        else:
            img_group= (i,None)
            
        IMAGE_FILES.append(img_group)
    

def MakeMTank(i_group):
    ratios= [0,0]
    align= []
    if not i_group[1]:
        imgB= Image.open(i_group[0])
        imgA= Image.new('L',imgB.size,(255,))
    elif i_group[1]=='_black':
        imgA= Image.open(i_group[0])
        imgB= Image.new('L',imgA.size,(0,))
    else:
        imgA= Image.open(i_group[0])
        imgB= Image.open(i_group[1])
        ratios= [0.5,-0.5] #明度比值
        
        # ALIGN2_MAX(取最大的寬和最大的高) ALIGN2_A(縮放到圖A) ALIGN2_B(縮放到圖B) 
        # NO_MODIFT(不修改)  STRETCH(拉伸)  CONSTRAINT_RATIO(約束比例)
        align= [ALIGN2_B, CONSTRAINT_RATIO]
        
    A_Size,B_Size= imgA.size,imgB.size
    img_objs= [imgA,imgB]
    for n,img in enumerate(img_objs):
        if img.mode== 'RGBA':
            img= img.convert('RGB')
        img_array= np.array(img)
        if img.mode != 'L' and ( [(img_array[:,:,i]==img_array[:,:,2]).all() for i in range(2)]!= [True,True] ):
            img= Desaturate(img_array) #去色
        else:
            img= img.convert('L')
            
        if align and (A_Size!=B_Size):
            img= ImgAlign(n,img,A_Size,B_Size,align) #影象對齊
                    
        if ratios[n]:
            img= Lightness(img,ratios[n]) #明度
        img_objs[n]= img
        
    imgA,imgB = img_objs
    
    imgA = Invert(imgA) #反相
    imgO = LinearDodge(imgA, imgB) #線性減淡(新增)
    imgR = Divide(imgO, imgB) #劃分
    imgR_mask = AddMask(imgR, imgO) #新增透明蒙版

    name= os.path.splitext(i_group[0])[0]
    imgR_mask.save('../'+EXPORT_FOLDER+'/' + name+'.png')


    
def FlashMakeMTank(task):
    pool = ThreadPoolExecutor(cpu_count())
    results = list(pool.map(MakeMTank, task))
    pool.shutdown()
    
        
def AutoMTank():
    cpu  = cpu_count()-1
    pool = ProcessPoolExecutor(cpu) #max_workers=4
    L    = IMAGE_FILES
    F    = int(len(L)/cpu)
    task_assign = [L[n*F:] if (n+1)==cpu else L[n*F:(n+1)*F] for n in range(cpu)]
    results = list(pool.map(FlashMakeMTank, task_assign))

    pool.shutdown()
        
    print ('\n%d輛幻影坦克製作完成!' % len(IMAGE_FILES))

        
    
# ---

def Fire():
    all_img2list()
    sec = timeit(lambda:AutoMTank(),number=1)
    print ('Time used: {} sec'.format(sec))
    s= input('\n按回車鍵退出...\n')



if __name__ == '__main__':
    if not os.path.exists(EXPORT_FOLDER):
        os.makedirs(EXPORT_FOLDER)
    os.chdir(IMPORT_FOLDER)
    
    while True:
        s= input('>>> 按F進入坦克:')
        if s.upper()== 'F':
            print ('少女祈禱中...')
            Fire() #開炮
            break
        elif not s:
            break