目錄

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

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

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

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

之前在網上看到用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檔案物件賦值給imgA和imgB，判斷到那些想要白圖到原圖效果的圖片，則在記憶體中生成一張純白色的圖片物件賦值給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 
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
Python - 批量生成幻影坦克圖片
     
 
    目錄
    
        
        一、準備圖片
        二、Python+PIL程式碼實現過程
        三、完整程式碼檔案
        
    

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

幻影坦克（Mirage Tank），《紅色警戒2》以及《尤里的復仇》中盟 

  
 

    

    
    
網絡工程師工具：python批量生成配置
     
 2-2   通過   alt   idl   sta   執行   快速   http   ati   訴求：網絡工程實施過程中，配置量巨大，人工輸出耗時長，配置錯誤率高；因此通過腳本來實現配置快速輸出，提高配置輸出的可靠性和以及效率
 
前提：安裝好python3.0+，並通過pip 安裝xlrd（cmd下 

  
 

    

    
    
Python 批量生成中文姓名（百家姓）
     
 遍歷   []   enc   image   只需要   BE   數據   標簽   append   　　最近需要造一部分數據，需要用到人名，與其用腳本生成一些隨機組合的漢字，不如在網上爬一些看似真實的姓名，所以找來了姓氏大全的網站，網址：http://www.resgain.net/xsdq.html 

  
 

    

    
    
shell-批量裁剪各個尺寸的圖教程一(執行裁剪批量生成對應尺寸圖片)
     
 
                

我的需求


本地有幾百張原圖，尺寸大小不清楚，在這些原圖基礎上進行裁剪，生成一批230x80尺寸的素材圖。


目錄結構



以下是指令碼

#!/bin/bash
#/usr/local/bin/bin/convert image/photos9.jpg -grav 

  
 

    

    
    
python批量生成銀行卡號
     
 
								
								            
						
                # -*- coding: utf-8 -*-
__author__ = 'Administrator'
__time__ = '2018-07-27 下午 2:38'

import string
i 

  
 

    

    
    
python批量生成手機號
     
 
								
								            
						
                # -*- coding: utf-8 -*-
__author__ = 'Administrator'
__time__ = '2018-05-07 下午 4:20'
import string
im 

  
 

    

    
    
Python批量生成csv檔案
     
 
							
							
							引子： 生成的 txt 檔名稱事先不知道，其名稱根據資料範圍的不同生成不同名稱的 txt 檔案，主要應用 str(x) + ‘.txt’ 加以實現。
下面來一個簡單的範例：
把資料寫入 n1-n2.txt 中，n1,n2 由迴圈產生
import pandas  

  
 

    

    
    
Python批量將多張圖片拼接為PDF
     
 
                參考部落格：http://ilovin.me/2017-04-18/stitch-img-to-pdf/   算是技術雜談類的吧......最近碰到一個問題，想要把一個資料夾下的圖片拼接起來生成一個PDF檔案，並且該PDF檔案每頁都具有相同的A4大小。其實生成PDF這件事有許 

  
 

    

    
    
Python 批量下載驗證碼圖片及切割驗證碼圖片，識別驗證碼，並以識別的文字重命令驗證碼
     
 
                
1、Python 批量下載驗證碼圖片
2、批量切割驗證碼圖片
3、識別驗證碼，並以識別的文字重命令驗證碼


#!C:/Python27
#coding=utf-8
import pytesseract
from pytesser import *
from PIL imp 

  
 

    

    
    
Python批量生成垃圾郵件內容
     
 
                    

                    

                    
                    
                    問題背景：這個文章的程式碼是為下一篇關於貝葉斯分類的文章做準備的，用來生成一些模擬的垃圾郵件。一 

  
 

    

    
    
Python批量唯美類圖片
     
 lose   __name__   itl   -a   htm   4.0   __main__   ron   quest   效果圖：
　　
實現代碼：

# -*- coding: UTF-8 -*-
import requests
import re

urls = [‘http:/ 

  
 

    

    
    
python  批量生成xml標記文件(連通域坐標分割)
     
 odi   寫入   spa   文件   報錯   ffi   glob   npr   所有   
#!/usr/bin/python
# -*- coding=utf-8 -*-
# author : Manuel
# date: 2019-05-15

from xml.etree imp 

  
 

    

    
    
Python批量匯入圖片生成PowerPoint 2007+檔案
     
 
說明：本文是“Python批量爬取微信公眾號文章中的圖片”的後續文章，用來把從公眾號批量抓取的圖片還原為PowerPoint
 2007檔案。
使用方法：安裝擴充套件庫python-pptx，然後把上文中抓取的圖片和本程式放在同一個資料夾。
import osimport pptxfrom pptx.uti 

  
 

    

    
    
python批量下載色影無忌和蜂鳥的圖片 爬蟲小應用
     
 exce   pen   應用   content   沒有   str1   .com   pat   tar   

有些冗余信息。由於之前測試正則表達式。所以沒有把它們給移走。只是不影響使用。# -*- coding:utf-8 -*-
import re,urllib,sys,os,time


de 

  
 

    

    
    
用Python寫一個批量生成賬號的函數（用戶控制數據長度、數據條數）
     
 shuf   open   小寫   長度   數據   ase   函數   用戶控制   app   # 1、寫一個函數，批量生成一些註冊使用的賬號：[email protected]/*  */，長度由用戶輸入，產生多少條也由用戶輸入，用戶名不能重復，用戶名必須由大寫字母、小寫字母、數字組成
 

  
 

    

    
    
批量生成測試非重復命名的圖片數據
     
 pep   value   fhe   ifd   prefix   msr   cve   進行   iap   今天要測試100萬的圖片數據的上傳工作,測試指標:100萬的上傳總耗時,調用接口的耗時,圖片處理耗時等.
但是一個問題是沒有100萬張圖片,咋整啊,感覺有人在坑我,絕壁是故意的.讓我想辦法搞一百 

  
 

    

    
    
Python批量修改圖片格式和尺寸
     
 click   alias   cli   項目   重新   ide   urllib   文本   直接   


 




Python批量修改圖片格式和尺寸

備註：
1.導入了PIL庫，是處理圖片用的，很強大;
2.導入了的win32庫，是判斷隱藏文件用的，我們的項目需要刪除隱藏文件，不需要的可以 

  
 

    

    
    
python 批量下載網頁裏的圖片
     
 www   file   header   range   .html   filename   表達   則表達式   進行   python 3.*
import requestsimport sys,re#設置提取圖片url 的正則表達式imgre = re.compile(r"<img 

  
 

    

    
    
利用Python批量爬取XKCD動漫圖片，並批量儲存
     
  
  
  
 import requests, os, bs4

url = 'https://xkcd.com'
os.makedirs('xkcd',exist_ok = True)

while not url.endswith('#'):
    
    # download the page
 

  
 

    

    
    
Python:批量按xml標註將目標crop剪下圖片並按類儲存到相應資料夾
     
  
 
 from __future__ import division import os from PIL import Image import xml.dom.minidom import numpy as np ImgPath = '/'  AnnoPath = '' ProcessedP