Python 的練手專案：用Python創建一張三維立體畫

本專案生成的三維立體畫設計為用“墻眼”方式觀看，看到它們的最好方法，就是讓眼睛聚焦在影像后面的點（如墻上），有點神奇，一旦在這些圖案中感知到某樣東西，眼睛就會自動將它作為關注的焦點，如果三維影像已“鎖定”，你很難對它視而不見的（如果你仍然無法看到影像，請看Gene Levin的文章“How to View Stereograms and Viewing Practice”[1]，或許有幫助），

圖8-1　一張令人費解的影像，可能讓你感到痛苦[2]

8.1　作業原理

三維立體畫的作業原理是改變影像中圖案之間的線性間距，從而產生深度的錯覺，在觀看三維立體畫中的重復圖案時，大腦會將間距解釋為深度資訊，如果有多個圖案和不同的間距，尤其會這樣，

8.1.1　感知三維立體畫中的深度

如果你的眼睛匯聚在影像背后一個假想的點，大腦將左眼看到的一些點與右眼看到的另一些點匹配起來，你將會看到這些點位于影像之后的一個平面上，到該平面的感知距離取決于圖案中的間距的數量，例如，圖8-2展示了3行A，這些A每行間的距離相等，但它們的水平間距從上至下增加，

如果用“墻眼”的方式來看，圖8-2中最上面一行應該出現在紙后面，中間行應該看起來像在第一行后面一點，底部一行應該出現在最遠的位置，文本“floating text”應該看起來“浮在”這幾行頂部，

為什么大腦將這些圖案的間距解讀為深度？通常情況下，如果看遠處的物體，你的雙眼協作，聚焦并匯聚在同一點，雙眼向內轉，直接指向目標點，但用“墻眼”方式觀看三維立體畫時，聚焦和匯聚發生在不同的位置，眼睛專注于三維立體畫，但大腦將重復的模式看成來自同一個虛擬（虛構的）物件，眼睛匯聚在影像背后的一個點，如圖8-3所示，解耦的聚焦和匯聚疊加在一起，讓你在三維立體畫中看到深度，

圖8-2　線性間距和深度知覺

圖8-3　在三維立體畫中看到深度

三維立體畫的感知深度取決于像素的水平間距，因為圖8-2中的第一行具有最近的間隔，它出現在其他行的前面，然而，如果點的間距在影像中是變化的，大腦將認為每個點處于不同的深度，所以我們會看到一個虛擬的三維影像，

8.1.2　深度圖

“深度圖”是這樣一幅影像：其中每個像素的值表示深度值，即從眼睛到該像素表示的物件部分的距離，深度圖往往表現為一幅灰度圖，亮的區域表示近的點，暗的區域表示遠的點，如圖8-4所示，

圖8-4　深度圖

注意，鯊魚的鼻子是影像中最亮部分，似乎最接近你，朝向尾部的較暗區域看起來最遠，

因為深度圖表示從每個像素中心到眼睛的深度或距離，所以可以用它來獲得與影像中像素位置相關聯的深度值，我們知道，在影像中，水平偏移被認為是深度，所以，如果按照對應像素值深度值的比例，來偏移（圖案）影像中的像素，就會對該像素產生與深度圖一致的深度知覺，如果對所有像素這樣做，最終就會將整個深度圖編碼到影像中，生成三維立體畫，

深度圖的每個像素存盤了深度值，并且該值的解析度取決于表示它的位數，因為本章采用常見的8位影像，深度值的范圍是[0,255]，

順便說一下，圖8-4中的影像就是用于創建圖8-1中的三維立體畫的深度圖，你很快就能學會自己如何做到這一點，

該專案的代碼將遵循以下步驟：

1．讀入深度圖；

2．讀入一幅平鋪影像或創建一個“隨機點”平鋪影像；

3．通過重復平鋪影像創建一幅新影像，該影像的尺寸與深度圖一致；

4．對新影像中的每個像素，根據該像素相關聯的深度值，將它按比例地向右移；

5．將三維立體畫寫入一個檔案，

8.2　所需模塊

本專案使用Pillow讀取圖片，訪問它們的底層資料，創建和修改影像，

8.3　代碼

為了從輸入的深度圖生成三維立體畫，首先重復一幅給定的平鋪影像，生成一幅中間影像，接下來，生成一幅充滿隨機點的平鋪影像，然后進入生成三維立體畫的核心代碼，即利用所提供的深度圖中的資訊，移動輸入的影像，要查看完整的專案，請直接跳到8.4節，

8.3.1　重復給定的平鋪影像

我們從利用createTiledImage()方法開始，通過平鋪一個圖形檔案，創建一幅新的影像，影像尺寸由dims元組指定，該元組形式為（width, height），

# tile a graphics file to create an intermediate image of a set size
def createTiledImage(tile, dims):
　　# create the new image
?　 img = Image.new('RGB', dims)
　　W, H = dims
　　w, h = tile.size
　　# calculate the number of tiles needed
?　 cols = int(W/w) + 1
?　 rows = int(H/h) + 1
　　# paste the tiles into the image
　　for i in range(rows):
　　　　for j in range(cols):
?　　　　　 img.paste(tile, (j*w, i*h))
　　# output the image
　　return img

在?行，利用提供的尺寸（dims）創建新的Python影像庫（PIL）Image物件，新影像的尺寸由元組dims給出，形式是（width, height），接著，保存平鋪影像和輸出檔案的寬度和高度，在?行，確定列數，在?行，確定中間影像所需的行數，方法是用最終影像的尺寸除以平鋪影像的尺寸，除的結果每次加1，如果輸出影像的尺寸不是正好是平鋪影像的整數倍，這也能確保右邊最后的平鋪影像不會缺失，如果沒有這種預防措施，影像的右邊可能被切斷，然后，在?行，回圈遍歷行和列，并用平鋪影像填充它們，通過乘積(j*w, i*h)，確定平鋪影像左上角的位置，這樣它能對準行和列，完成后，該方法回傳指定尺寸的Image物件，用輸入影像tile平鋪，

8.3.2　從隨機圓創建平鋪影像

如果用戶不提供平鋪影像，就利用createRandomTile()方法，用隨機圓圈創建一張平鋪影像，

# create an image tile filled with random circles
def createRandomTile(dims):
　　# create image
?　 img = Image.new('RGB', dims)
?　 draw = ImageDraw.Draw(img)
　　# set the radius of a random circle to 1% of
　　# width or height, whichever is smaller
?　 r = int(min(*dims)/100)
　　# number of circles
?　 n = 1000
　　# draw random circles
　　for i in range(n):
　　　　# -r makes sure that the circles stay inside and aren't cut off
　　　　# at the edges of the image so that they'll look better when tiled
?　　　 x, y = random.randint(0, dims[0]-r), random.randint(0, dims[1]-r)
?　　　 fill = (random.randint(0, 255), random.randint(0, 255),
　　　　　　　　random.randint(0, 255))
?　　　 draw.ellipse((x-r, y-r, x+r, y+r), fill)
　　return img

在?行，用dim給出的尺寸創建新的Image物件，用ImageDraw.Draw() ?在該影像中畫圓圈，用寬或高中較小值的1/100作為半徑，畫圓圈?（Python的*運算子將dim元組中的寬度和高度值解包，這樣就能傳入到min()方法中），

在?行，設定要畫的圓圈數為1000，然后呼叫random.randint()，獲得范圍為[0, width-r]和[0, height-r]的兩個隨機整數，從而算出每個圓圈的x和y坐標?，“-r”確保生成的圓圈保持在width×height的影像矩形內部，不帶-r，畫的圓圈可能就在影像邊緣，這意味著它會被切掉一部分，如果平鋪這樣的影像來創建三維立體畫，結果不會好看，因為兩個平鋪影像之間沒有空間，

要生成一個隨機圓圈，先畫出輪廓，然后填充顏色，在?行，在[0,255]的范圍內隨機選取RGB值，用選擇顏色填充，最后，在?行，用draw中的ellipse()方法繪制每個圓圈，該方法的第一個引數是圓的邊界矩形，它由左上角和右下角指定，分別為(x-r, y-r)和(x+r, y+r)，其中(x, y)是該圓的圓心，r是半徑，

讓我們在Python解釋器中測驗這種方法，

>>> import autos
>>> img = autos.createRandomTile((256, 256))
>>> img.save('out.png')
>>> exit()

圖8-5展示了測驗的輸出，

圖8-5　嘗試運行createRandomTile()

正如你在圖8-5中看到的，我們已經創建了隨機點的平鋪影像，可以使用它來創建的三維立體畫，

8.3.3　創建三維立體畫

現在，讓我們創建一些三維立體畫，createAutostereogram()方法完成了大部分作業，如下所示：

def createAutostereogram(dmap, tile):
　　# convert the depth map to a single channel if needed
?　 if dmap.mode is not 'L':
　　　　dmap = dmap.convert('L')
　　# if no image is specified for a tile, create a random circles tile
?　 if not tile:
　　　　tile = createRandomTile((100, 100))
　　# create an image by tiling
?　 img = createTiledImage(tile, dmap.size)
　　# create a shifted image using depth map values
?　 sImg = img.copy()
　　# get access to image pixels by loading the Image object first
?　 pixD = dmap.load()
　　pixS = sImg.load()
　　# shift pixels horizontally based on depth map
?　 cols, rows = sImg.size
　　for j in range(rows):
　　　　for i in range(cols):
?　　　　　 xshift = pixD[i, j]/10
?　　　　　 xpos = i - tile.size[0] + xshift
?　　　　　 if xpos > 0 and xpos < cols:
?　　　　　　　 pixS[i, j] = pixS[xpos, j]
　　# display the shifted image
　　return sImg

在?行，進行完整性檢查，確保深度圖和影像具有相同的尺寸，在?行，如果用戶沒有提供平鋪影像，就創建隨機圓圈平鋪影像，在?行，創建一張平鋪好的影像，符合提供的深度圖的大小，然后，在?行生成這張平鋪好的影像的副本，

在?行，呼叫Image.load()方法，將影像資料加載到記憶體中，該方法允許用形如[i, j]的二維陣列來訪問影像像素，在?行，將影像的尺寸保存為行數和列數，將影像看成單個像素構成的網格，

三維立體畫創建演算法的核心在于，根據從深度圖中收集的資訊，移動平鋪影像中像素的方式，要做到這一點，遍歷平鋪影像，處理每一個像素，在?行，根據深度圖pixD中的相關像素，查找偏移的值，然后將這個深度值除以10，因為這里用的是8位深度圖，這意味著深度的范圍是0到255，如果除以10，得到的深度值范圍是0到25，由于深度圖輸入影像的尺寸通常是幾百像素，所以這些偏移值很合適（嘗試改變除數，看看它如何影響最終影像），

在?行，計算像素的新x位置，用平鋪影像填充三維立體畫，每隔w個像素，像素的值不斷重復，由公式ai = ai + w表示，其中的ai是在x軸下標i處的給定像素的顏色（因為考慮的是像素行，而不是列，所以忽略y方向），

要創建深度感，就要讓間隔（或重復的間距）與該像素的深度圖值成正比，這樣在最終的三維立體畫影像中，每個像素和它前一次（周期地）出現相比，偏移了delta_i，這可以表示為bi=bi-w+δt

這里，bi表示最后的三維立體畫影像中，下標i處給定像素的顏色值，這正是?行所做的事，深度圖值為0（黑色）的像素沒有偏移，被視為背景，

在?行，用偏移的值替換每個像素，在?行，檢查確保沒有試圖訪問不在影像中的像素，因為偏移，在影像邊緣可能發生這種情況，

8.3.4　命令列選項

現在，我們來看看該程式的main()方法，其中提供了一些命令列選項，

　　# create a parser
  　parser = argparse.ArgumentParser(description="Autosterograms...")
　　# add expected arguments
?　 parser.add_argument('--depth', dest='dmFile', required=True)
　　parser.add_argument('--tile', dest='tileFile', required=False)
　　parser.add_argument('--out', dest='outFile', required=False)
　　# parse args
　　args = parser.parse_args()
　　# set the output file
　　outFile = 'as.png'
　　if args.outFile:
　　　　outFile = args.outFile
　　# set tile
　　tileFile = False
　　if args.tileFile:
　　　　tileFile = Image.open(args.tileFile)

在?行，像以前的專案一樣，利用argparse為程式定義了一些命令列選項，一個必需的引數是深度圖檔案，兩個可選的引數是平鋪影像檔案名和輸出檔案名，如果未指定平鋪影像，程式會生成隨機圓圈平鋪影像，如果未指定輸出檔案名，則三維立體畫會輸出到as.png檔案，

8.4　完整代碼

下面是完整的三維立體畫程式，也可以從https://github.com/electronut/pp/blob/ master/autos/autos.py下載這段代碼，

import sys, random, argparse
from PIL import Image, ImageDraw

# create spacing/depth example
def createSpacingDepthExample():
　　tiles = [Image.open('test/a.png'), Image.open('test/b.png'),
　　　　　　 Image.open('test/c.png')]
　　img = Image.new('RGB', (600, 400), (0, 0, 0))
　　spacing = [10, 20, 40]
　　for j, tile in enumerate(tiles):
　　　　for i in range(8):
　　　　　　img.paste(tile, (10 + i*(100 + j*10), 10 + j*100))
　　img.save('sdepth.png')

# create an image filled with random circles
def createRandomTile(dims):
　　# create image
　　img = Image.new('RGB', dims)
　　draw = ImageDraw.Draw(img)
　　# set the radius of a random circle to 1% of
　　# width or height, whichever is smaller
　　r = int(min(*dims)/100)
　　# number of circles
　　n = 1000
　　# draw random circles
　　for i in range(n):
　　　　# -r makes sure that the circles stay inside and aren't cut off
　　　　# at the edges of the image so that they'll look better when tiled
　　　　x, y = random.randint(0, dims[0]-r), random.randint(0, dims[1]-r)
　　　　fill = (random.randint(0, 255), random.randint(0, 255),
　　　　　　　　random.randint(0, 255))
　　　　draw.ellipse((x-r, y-r, x+r, y+r), fill)
　　# return image
　　return img

# tile a graphics file to create an intermediate image of a set size
def createTiledImage(tile, dims):
　　# create the new image
　　img = Image.new('RGB', dims)
　　W, H = dims
　　w, h = tile.size
　　# calculate the number of tiles needed
　　cols = int(W/w) + 1
　　rows = int(H/h) + 1
　　# paste the tiles into the image
　　for i in range(rows):
　　　　for j in range(cols):
　　　　　　img.paste(tile, (j*w, i*h))
　　# output the image
　　return img

# create a depth map for testing
def createDepthMap(dims):
　　dmap = Image.new('L', dims)
　　dmap.paste(10, (200, 25, 300, 125))
　　dmap.paste(30, (200, 150, 300, 250))
　　dmap.paste(20, (200, 275, 300, 375))
　　return dmap

# given a depth map image and an input image,
# create a new image with pixels shifted according to depth
def createDepthShiftedImage(dmap, img):
　　# size check
　　assert dmap.size == img.size

# create shifted image
sImg = img.copy()
# get pixel access
pixD = dmap.load()
pixS = sImg.load()
# shift pixels output based on depth map
cols, rows = sImg.size
for j in range(rows):
　　for i in range(cols):
　　　　xshift = pixD[i, j]/10
　　　　xpos = i - 140 + xshift
　　　　if xpos > 0 and xpos < cols:
　　　　　　pixS[i, j] = pixS[xpos, j]
　　# return shifted image
　　return sImg

# given a depth map (image) and an input image,
# create a new image with pixels shifted according to depth
def createAutostereogram(dmap, tile):
　　# convert the depth map to a single channel if needed
　　if dmap.mode is not 'L':
　　　　dmap = dmap.convert('L')
　　# if no image is specified for a tile, create a random circles tile
　　if not tile:
　　　　tile = createRandomTile((100, 100))
　　# create an image by tiling
　　img = createTiledImage(tile, dmap.size)
　　# create a shifted image using depth map values
　　sImg = img.copy()
　　# get access to image pixels by loading the Image object first
　　pixD = dmap.load()
　　pixS = sImg.load()
　　# shift pixels horizontally based on depth map
　　cols, rows = sImg.size
　　for j in range(rows):
　　　　for i in range(cols):
　　　　　　xshift = pixD[i, j]/10
　　　　　　xpos = i - tile.size[0] + xshift
　　　　　　if xpos > 0 and xpos < cols:
　　　　　　　　pixS[i, j] = pixS[xpos, j]
　　# return shifted image
　　return sImg

# main() function
def main():
　　# use sys.argv if needed
　　print('creating autostereogram...')
　　# create parser
　　parser = argparse.ArgumentParser(description="Autosterograms...")
　　# add expected arguments
　　parser.add_argument('--depth', dest='dmFile', required=True)
　　parser.add_argument('--tile', dest='tileFile', required=False)
　　parser.add_argument('--out', dest='outFile', required=False)
　　# parse args
　　args = parser.parse_args()
　　# set the output file
　　outFile = 'as.png'
　　if args.outFile:
　　　　outFile = args.outFile
　　# set tile
　　tileFile = False
　　if args.tileFile:
　　　　tileFile = Image.open(args.tileFile)
　　# open depth map
　　dmImg = Image.open(args.dmFile)
　　# create stereogram
　　asImg = createAutostereogram(dmImg, tileFile)
　　# write output
　　asImg.save(outFile)

# call main
if __name__ == '__main__':
　　main()

8.5　運行三維立體畫生成程式

現在，我們用凳子（stool-depth.png）的深度圖運行該程式，

$ python3 autos.py --depth data/stool-depth.png

圖8-6左邊展示了深度圖，右邊展示了生成的三維立體畫，因為沒有為平鋪提供影像，這張三維立體畫使用了隨機生成的平鋪影像，

圖8-6　autos.py運行示例

現在，讓我們給定一個平鋪影像作為輸入，像前面一樣使用stool-depth.png深度圖，但這一次，提供影像escher-tile.jpg[3]作為平鋪影像，

$ python3 autos.py --depth data/stool-depth.png –tile data/escher-tile.jpg

圖8-7展示了輸出，

圖8-7　使用平鋪影像的autos.py運行示例

8.6　小結

在本專案中，我們學習了如何創建三維立體畫，給定深度圖的影像，我們現在可以創建隨機點的三維立體畫，或用提供的影像來平鋪，

如果你想知道如何利用編程來理解和探索想法，那么你可以看看這本《Python極客專案編程》，這本書的專案假設你了解基本的Python語法和基本的編程概念，并假設你熟悉高中數學知識，我已經盡了最大的努力，詳細解釋了所有專案中需要的數學知識，

《Python極客專案編程》

《Python極客專案編程(異步圖書出品)》([美],Mahesh,Venkitachalam)【摘要 書評 試讀】- 京東圖書?item.jd.com

本書包含了一組富有想象力的編程專案，它們將引導你用Python 來制作影像和音樂、模擬現實世界的現象，并與

Arduino 和樹莓派這樣的硬體進行互動，你將學習使用常見的Python 工具和庫，如numpy、matplotlib 和pygame，

來完成以下作業：

● 利用引數方程和turtle模塊生成萬花尺圖案；

● 通過模擬頻率泛音在計算機上創作音樂；

● 將圖形影像轉換為ASCII文本圖形；

● 撰寫一個三維立體畫程式，生成隱藏在隨機圖案下的3D影像；

● 通過探索粒子系統、透明度和廣告牌技術，利用OpenGL著色器制作逼真的影片；

● 利用來自CT和MRI掃描的資料實作3D可視化；

● 將計算機連接到Arduino編程，創建回應音樂的激光秀，

通過本書，你可以享受作為極客的真正樂趣！

作者通過一系列不簡單的專案，向你展示如何用Python來解決各種實際問題，在學習這些專案時，你將探索Python編程語言的細微差別，并學習如何使用一些流行的Python庫，但也許更重要的是，你將學習如何將問題分解成幾個部分，開發一個演算法來解決這個問題，然后從頭用Python來實作一個解決方案，解決現實世界的問題可能很難，因為它們往往是開放式的，并且需要各個領域的專業知識，但Python提供了一些工具，協助解決問題，克服困難，尋找實際問題的解決方案，這是成為專家級程式員的旅途中最重要的環節，

讓我們來看看有哪些練手專案？

第一部分：熱身運動

第1章展示了如何決議iTunes播放串列檔案，并從中收集有用的資訊，如音軌長度和共同的音軌，在第2章中，我們使用引數方程及海龜作圖法，繪制類似萬花尺產生的那些曲線，

第1章 決議iTunes播放串列

第2章 萬花尺

第二部分：模擬生命

這部分是用數學模型來模擬現象，在第3章中，我們將學習如何實作Conway游戲的生命游戲演算法，產生動態的模式來創建其他模式，以模擬一種人工生命，第4章展示了如何用Karplus-Strong演算法來創建逼真的彈撥音，然后，在第5章中，我們將學習如何實作類鳥群演算法，模擬鳥類的聚集行為，

第3章 Conway生命游戲

第4章 用Karplus-Strong演算法產生音樂泛音

第5章 類鳥群：仿真鳥群

第三部分：影像之樂

這部分介紹使用Python讀取和操作2D影像，第6章展示了如何根據影像創建ASCII碼藝術圖，在第7章中，我們將進行照片拼接，在第8章中，我們將學習如何生成三維立體圖，它讓人產生3D影像的錯覺，

第6章 ASCII文本圖形

第7章 照片馬賽克

第8章 三維立體畫

第四部分：走進三維

這一部分的專案使用OpenGL的3D圖形庫，第9章介紹使用OpenGL創建簡單3D圖形的基本知識，在第10章中，我們將創建粒子模擬的煙花噴泉，它用數學和OpenGL著色器來計算和渲染，在第11章中，我們將使用OpenGL著色器來實作立體光線投射演算法，來渲染立體資料，該技術常用于醫療影像，如MRI和CT掃描，

第9章 理解OpenGL

第10章 粒子系統

第11章 體渲染

第五部分：玩轉硬體

在最后一部分中，我們將用Python來探索Arduino微控制器和樹莓派，在第12章中，我們將利用Arduino，通過一個簡單電路讀取并標繪傳感器資料，在第13章中，我們將利用Python和Arduino來控制兩個旋轉鏡和激光器，生成回應聲音的激光秀，在第14章中，我們將使用樹莓派打造一個基于網路的氣象監測系統，

第12章 Arduino簡介

第13章 激光音樂秀

第14章 基于樹莓派的天氣監控器