Scipy

scipy包含致力于科學計算中常見問題的各個工具箱。它的不同子模塊相應于不同的應用。像插值，積分，優化，圖像處理，統計，特殊函數等等。

scipy可以與其它標準科學計算程序庫進行比較，比如GSL(GNU C或C++科學計算庫)，或者Matlab工具箱。scipy是Python中科學計算程序的核心包; 它用于有效地計算numpy矩陣，來讓numpy和scipy協同工作。

在實現一個程序之前，值得檢查下所需的數據處理方式是否已經在scipy中存在了。作為非專業程序員，科學家總是喜歡重新發明造輪子，導致了充滿漏洞的，未經優化的，很難分享和維護的代碼。相反，Scipy程序經過優化和測試，因此應該盡可能使用。

目錄

警告：這個教程離真正的數值計算介紹很遠。因為枚舉scipy中不同的子模塊和函數非常無聊，我們集中精力代之以幾個例子來給出如何使用scipy進行計算的大致思想。
scipy 由一些特定功能的子模塊組成：

它們全依賴numpy,但是每個之間基本獨立。導入Numpy和這些scipy模塊的標準方式是：

import numpy as np
from scipy import stats   # 其它子模塊相同

主scipy命名空間大多包含真正的numpy函數(嘗試 scipy.cos 就是 np.cos)。這些僅僅是由于歷史原因，通常沒有理由在你的代碼中使用import scipy

一、文件輸入/輸出：scipy.io

導入和保存matlab文件:

In [1]: from scipy import io as spio
In [3]: import numpy as np
In [4]: a = np.ones((3, 3))
In [5]: spio.savemat('file.mat', {'a': a})  # savemat as a dictionary
In [6]: data = spio.loadmat('file.mat', struct_as_record=True)

In [7]: data['a']
Out[7]: 
array([[ 1.,  1.,  1.],
       [ 1.,  1.,  1.],
       [ 1.,  1.,  1.]])

讀取圖片：

In [16]: from scipy import misc
In [17]: misc.imread('scikit.png')
Out[17]: 
array([[[255, 255, 255, 255],
        [255, 255, 255, 255],
        [255, 255, 255, 255],
        ..., 
        ..., 
        [255, 255, 255, 255],
        [255, 255, 255, 255],
        [255, 255, 255, 255]]], dtype=uint8)

In [18]: import matplotlib.pyplot as plt
In [19]: plt.imread('scikit.png')
Out[19]: 
array([[[ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        ..., 

       [[ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        ..., 
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.],
        [ 1.,  1.,  1.,  1.]]], dtype=float32)

載入txt文件：

numpy.loadtxt()
numpy.savetxt()

智能導入文本/csv文件：

numpy.genfromtxt()
numpy.recfromcsv()

高速，有效率但numpy特有的二進制格式：

numpy.save()
numpy.load()

二、特殊函數：scipy.special

特殊函數是先驗函數。scipy.special的文檔字符串寫得非常好，所以我們不在這里列出所有函數。常用的有：

• 貝塞爾函數，如scipy.special.jn() (整數n階貝塞爾函數)
• 橢圓函數: scipy.special.ellipj() (雅可比橢圓函數，……)
• 伽馬函數：scipy.special.gamma()，還要注意scipy.special.gammaln,這個函數給出對數坐標的伽馬函數，因此有更高的數值精度。

三、線性代數運算：scipy.linalg

scipy.linalg模塊提供標準線性代數運算，依賴于底層有效率的實現(BLAS，LAPACK)。

scipy.linalg.det()函數計算方陣的行列式：

In [22]: from scipy import linalg

In [23]: arr = np.array([[1, 2],
   ....:                [3, 4]])

In [24]: linalg.det(arr)
Out[24]: -2.0

In [25]: linalg.det(np.ones((3,4)))
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-25-375ad1d49940> in <module>()
----> 1 linalg.det(np.ones((3,4)))

/usr/lib/python2.7/site-packages/scipy/linalg/basic.pyc in det(a, overwrite_a)
    398     a1 = np.asarray_chkfinite(a)
    399     if len(a1.shape) != 2 or a1.shape[0] != a1.shape[1]:
--> 400         raise ValueError('expected square matrix')
    401     overwrite_a = overwrite_a or _datacopied(a1, a)
    402     fdet, = get_flinalg_funcs(('det',), (a1,))

ValueError: expected square matrix
py.linalg.inv()

函數計算方陣的逆：

In [26]: arr = np.array([[1, 2],
                [3, 4]])

In [27]: iarr = linalg.inv(arr)

In [28]: iarr
Out[28]: 
array([[-2. ,  1. ],
       [ 1.5, -0.5]])

In [29]: np.allclose(np.dot(arr, iarr), np.eye(2))
Out[29]: True

最后計算奇異陣的逆(它的行列式為0)將會引發(raise)LinAlgError：

In [32]: arr = np.array([[3, 2],
                [6, 4]])

In [33]: linalg.inv(arr)
---------------------------------------------------------------------------
LinAlgError                               Traceback (most recent call last)
<ipython-input-33-52c04c854a80> in <module>()
----> 1 linalg.inv(arr)

/usr/lib/python2.7/site-packages/scipy/linalg/basic.pyc in inv(a, overwrite_a)
    346             inv_a, info = getri(lu, piv, overwrite_lu=1)
    347     if info > 0:
--> 348         raise LinAlgError("singular matrix")
    349     if info < 0:
    350         raise ValueError('illegal value in %d-th argument of internal '

LinAlgError: singular matrix

還有更多高級運算，如奇異值分解(SVD):

In [34]: arr = np.arange(9).reshape((3, 3)) + np.diag([1, 0, 1])
In [35]: uarr, spec, vharr = linalg.svd(arr)

它的結果數組譜是：

In [36]: spec
Out[36]: array([ 14.88982544,   0.45294236,   0.29654967])

原始矩陣可以由svd的輸出用np.dot點乘重新組合得到：

In [37]: sarr = np.diag(spec)
In [38]: svd_mat = uarr.dot(sarr).dot(vharr)
In [39]: np.allclose(svd_mat, arr)
Out[39]: True

SVD在信號處理和統計中運用很廣。許多其它標準分解(QR,LU,Cholesky,Schur)，還有線性系統的解也可以從scipy.linalg中獲得。

四、快速傅里葉變換：scipy.fftpack

scipy.fftpack模塊用來計算快速傅里葉變換。作為示例，一個(噪聲)輸入信號可能像這樣：

In [40]: time_step = 0.02
In [41]: period = 5
In [42]: time_vec = np.arange(0, 20, time_step)
In [43]: sig = np.sin(2 * np.pi / period * time_vec) + \
   ....: 0.5 * np.random.randn(time_vec.size)

觀測者并不指導信號頻率，僅僅等間隔取樣信號sig。信號應該來自一個真實的函數所以傅里葉變換將是對稱的。scipy.fftpack.fftfreq()函數將生成取樣頻率，scipy.fftpack.fft()將計算快速傅里葉變換：

因為功率結果是對稱的，僅僅需要使用譜的正值部分來找出頻率：

In [48]: pidxs = np.where(sample_freq > 0)
In [49]: freqs = sample_freq[pidxs]
In [50]: power = np.abs(sig_fft)[pidxs]

信號頻率可以這樣被找到：

In [51]: freq = freqs[power.argmax()]
In [52]: np.allclose(freq, 1./period)
Out[52]: True

現在高頻噪聲將被從傅里葉變換信號中移除：

In [53]: sig_fft[np.abs(sample_freq) > freq] = 0

得到濾波信號，可以用scipy.fftpack.ifft函數計算：

In [54]: main_sig = fftpack.ifft(sig_fft)

結果可以這樣可視化：

In [55]: plt.figure()
Out[55]: <matplotlib.figure.Figure at 0x4a9fb50>

In [56]: plt.plot(time_vec, sig)
Out[56]: [<matplotlib.lines.Line2D at 0x4ad3790>]

In [57]: plt.plot(time_vec, main_sig, linewidth=3)
/usr/lib/python2.7/site-packages/numpy/core/numeric.py:320: ComplexWarning: Casting complex values to real discards the imaginary part
  return array(a, dtype, copy=False, order=order)
Out[57]: [<matplotlib.lines.Line2D at 0x4ad3dd0>]

In [58]: plt.xlabel('Time [s]')
Out[58]: <matplotlib.text.Text at 0x4aad050>

In [59]: plt.ylabel('Amplitude')
Out[59]: <matplotlib.text.Text at 0x4aadbd0>

In [60]: plt.show()

五、numpy.fft

Numpy也有一個FFT實現(numpy.fft)。然而，通常scipy的應該優先使用，因為它使用了更有效率的底層實現。

工作示例：找到原始周期

工作示例：高斯圖像模糊

卷積：

f_1(t) = \int dt’K(t-t’)f_0(t’)

\tilde{f_1}(\omega)=\tilde{K}(\omega)\tilde{f_0}(\omega)

練習：登月圖片消噪

檢查提供的圖像moonlanding.png，該圖像被周期噪聲嚴重污染了。在這個練習中，我們旨在使用快速傅里葉變換清除噪聲。
用plt.imread加載圖像。
使用scipy.fftpack中的2-D傅里葉函數找到并繪制圖像的譜線(傅里葉變換)。可視化這個譜線對你有問題嗎？如果有，為什么？
這個譜包含高頻和低頻成分。噪聲是在譜線的高頻部分中，所以設置一些成分為0(使用數組切片)。
應用逆傅里葉變換來看最后的圖像。
我的消除噪聲實例……

六、優化和擬合：scipy.optimize

優化是找到最小值或等式的數值解的問題。

scipy.optimization子模塊提供了函數最小值(標量或多維)、曲線擬合和尋找等式的根的有用算法。

from scipy import optimize

找到標量函數的最小值

讓我們定義以下函數

In [2]: def f(x):
   ...:     return x**2 + 10 * np.sin(x)

In [3]: x = np.arange(-10, 10, 0.1)

In [4]: plt.plot(x, f(x))
Out[4]: [<matplotlib.lines.Line2D at 0x3e2a4d0>]

In [5]: plt.show()

該函數在大約-1.3有個全局最小值,在3.8有個局部最小值。

找到這個函數最小值一般而有效的方法是從初始點使用梯度下降法。BFGS算法^1是做這個的好方法：

In [6]: optimize.fmin_bfgs(f, 0)
Optimization terminated successfully.
         Current function value: -7.945823
         Iterations: 5
         Function evaluations: 24
         Gradient evaluations: 8
Out[6]: array([-1.30644003])

這個方法一個可能的問題在于，如果函數有局部最小值，算法會因初始點不同找到這些局部最小而不是全局最小:

In [7]: optimize.fmin_bfgs(f, 3, disp=0)
Out[7]: array([ 3.83746663])

如果我們不知道全局最小值的鄰近值來選定初始點，我們需要借助于耗費資源些的全局優化。為了找到全局最小點，最簡單的算法是蠻力算法^2，該算法求出給定格點的每個函數值。

In [10]: grid = (-10, 10, 0.1)
In [11]: xmin_global = optimize.brute(f, (grid,))
In [12]: xmin_global
Out[12]: array([-1.30641113])

對于大點的格點，scipy.optimize.brute()變得非常慢。scipy.optimize.anneal()提供了使用模擬退火的替代函數。對已知的不同類別全局優化問題存在更有效率的算法，但這已經超出scipy的范圍。一些有用全局優化軟件包是OpenOpt、IPOPT、PyGMO和PyEvolve。

為了找到局部最小，我們把變量限制在(0, 10)之間，使用scipy.optimize.fminbound():

In [13]: xmin_local = optimize.fminbound(f, 0, 10)
In [14]: xmin_local
Out[14]: 3.8374671194983834

注意：在高級章節部分數學優化：找到函數最小值中有關于尋找函數最小值更詳細的討論。

找到標量函數的根

為了尋找根，例如令f(x)=0的點，對以上的用來示例的函數f我們可以使用scipy.optimize.fsolve():

In [17]: root = optimize.fsolve(f, 1)  # 我們的初始猜測是1
In [18]: root
Out[18]: array([ 0.])

注意僅僅一個根被找到。檢查f的圖像在-2.5附近有第二個根。我們可以通過調整我們的初始猜測找到這一確切值：

In [19]: root = optimize.fsolve(f, -2.5)
In [20]: root
Out[20]: array([-2.47948183])

曲線擬合

假設我們有從被噪聲污染的f中抽樣到的數據：

In [21]: xdata = np.linspace(-10, 10, num=20)
In [22]: ydata = f(xdata) + np.random.randn(xdata.size)

如果我們知道函數形式(當前情況是x^2 + sin(x))，但是不知道幅度。我們可以通過最小二乘擬合擬合來找到幅度。首先我們定義一個用來擬合的函數：

In [23]: def f2(x, a, b):
   ....:     return a*x**2 + b*np.sin(x)

然后我們可以使用scipy.optimize.curve_fit()來找到a和b：

In [24]: guess = [2, 2]
In [25]: params, params_covariance = optimize.curve_fit(f2, xdata, ydata, guess)
In [26]: params
Out[26]: array([  1.00439471,  10.04911441])

現在我們找到了f的最小值和根并且對它使用了曲線擬合。我們將一切放在一個單獨的圖像中:

注意：Scipy>=0.11中提供所有最小化和根尋找算法的統一接口scipy.optimize.minimize(),scipy.optimize.minimize_scalar()和scipy.optimize.root()。它們允許通過method關鍵字方便地比較不同算法。

你可以在scipy.optimize中找到用來解決多維問題的相同功能的算法。

練習：曲線擬合溫度數據

在阿拉斯加每個月的溫度上下限，從一月開始，以攝氏單位給出。
max: 17, 19, 21, 28, 33, 38, 37, 37, 31, 23, 19, 18
min: -62, -59, -56, -46, -32, -18, -9, -13, -25, -46, -52, -58
繪制這些溫度限
定義函數來描述最小和最大溫度。
提示：這個函數以一年為周期。
提示：包括時間偏移。
對數據使用這個函數scipy.optimize.curve_fit()
繪制結果。是否擬合合理？
如果不合理，為什么？
擬合精度的最大最小溫度的時間偏移是否一樣？

練習：2維最小化

六峰值駝背函數：

f(x,y) = (4 - 2.1x^2 + \frac{x^4}{3})x^2 + xy + (4y^2 - 4)y^2

有全局和多個局部最小。找到這個函數的全局最小。

提示：

變量應該限制在-2 < x < 2 , -1 < y < 1.
使用numpy.meshgrid()和plt.imshow來可視地搜尋區域。
使用scipy.optimize.fmin_bfgs()或其它多維極小化器。
這里有多少極小值？這些點上的函數值是多少？如果初始猜測是(x, y) = (0, 0)會發生什么？

參見總結練習非線性最小二乘擬合：在點抽取地形激光雷達數據上的應用，來看另一個，更高級的例子。

七、統計和隨機數： scipy.stats

scipy.stats包括統計工具和隨機過程的概率過程。各個隨機過程的隨機數生成器可以從numpy.random中找到。

直方圖和概率密度函數

給定一個隨機過程的觀察值，它們的直方圖是隨機過程的pdf(概率密度函數)的估計器：

In [1]: import numpy as np
In [2]: a = np.random.normal(size=1000)
In [3]: bins = np.arange(-4, 5)
In [4]: bins
Out[4]: array([-4, -3, -2, -1,  0,  1,  2,  3,  4])

In [5]: histogram = np.histogram(a, bins=bins, normed=True)[0]
In [6]: bins = 0.5*(bins[1:] + bins[:-1])
In [7]: bins
Out[7]: array([-3.5, -2.5, -1.5, -0.5,  0.5,  1.5,  2.5,  3.5])

In [8]: from scipy import stats
In [9]: b = stats.norm.pdf(bins)  # norm是正態分布
In [10]: import matplotlib.pyplot as plt
In [11]: plt.plot(bins, histogram)
Out[11]: [<matplotlib.lines.Line2D at 0x3378b10>]

In [12]: plt.plot(bins, b)
Out[12]: [<matplotlib.lines.Line2D at 0x3378fd0>]

In [13]: plt.show()

如果我們知道隨機過程屬于給定的隨機過程族，比如正態過程。我們可以對觀測值進行最大似然擬合來估計基本分布參數。這里我們對觀測值擬合一個正態過程：

In [14]: loc, std = stats.norm.fit(a)
In [15]: loc
Out[15]: 0.0052651057415999758

In [16]: std
Out[16]: 0.97945439802779732

練習：概率分布

從參數為1的伽馬分布生成1000個隨機數,然后繪制這些樣點的直方圖。你能夠在其上繪制pdf嗎(應該匹配)？

另外：這些分布有些有用的方法。通過閱讀它們的文檔字符串或使用IPython的tab補全來探索它們。你能夠通過對你的隨機變量使用擬合找到形狀參數1嗎？

百分位

中位數是來觀測值之下一半之上一半的值。

In [3]: np.median(a)
Out[3]: -0.047679175711778043

它也被叫作50百分位點，因為有50%的觀測值在它之下：

In [6]: stats.scoreatpercentile(a, 50)
Out[6]: -0.047679175711778043

同樣我們可以計算百分之九十百分點：

In [7]: stats.scoreatpercentile(a, 90)
Out[7]: 1.2541592439997036

百分位是CDF的一個估計器(累積分布函數)。

統計檢測

統計檢測是決策指示。例如，我們有兩個樣本集，我們假設它們由高斯過程生成。我們可以使用T檢驗來決定是否兩個樣本值顯著不同：

In [8]: a = np.random.normal(0, 1, size=100)
In [9]: b = np.random.normal(1, 1, size=10)
In [10]: stats.ttest_ind(a, b)
Out[10]: (array(-2.4119199601156796), 0.01755485116571583)

輸出結果由以下部分組成：

• T統計量：它是這么一種標志，與不同兩個隨機過程之間成比例并且幅度和差異的顯著程度有關^3。
• p值：兩個過程相同的概率。如果接近1,這兩個過程是幾乎完全相同的。越靠近零，兩個過程越可能有不同的均值。

八、插值：scipy.interpolate

scipy.interpolate對從實驗數據擬合函數來求值沒有測量值存在的點非常有用。這個模塊基于來自netlib項目的FITPACK Fortran 子程序。

通過想象接近正弦函數的實驗數據：

In [1]: measured_time = np.linspace(0, 1, 10)
In [2]: noise = (np.random.random(10)*2 - 1) * 1e-1
In [3]: measures = np.sin(2 * np.pi * measured_time) + noise

scipy.interpolate.interp1d類會構建線性插值函數：

In [4]: from scipy.interpolate import interp1d
In [5]: linear_interp = interp1d(measured_time, measures)

然后scipy.interpolate.linear_interp實例需要被用來求得感興趣時間點的值：

In [6]: computed_time = np.linspace(0, 1, 50)
In [7]: linear_results = linear_interp(computed_time)

三次插值也能通過提供可選關鍵字參數kind來選擇：[^4]

In [8]: cubic_interp = interp1d(measured_time, measures, kind='cubic')
In [9]: cubic_results = cubic_interp(computed_time)

結果現在被集合在以下Matplotlib圖像中

scipy.interpolate.interp2d與scipy.interpolate.interp1d相似，但是面向二維數組。注意，對interp族，計算時間必須在測量時間范圍內。參見Maximum wind speed prediction at the Sprog? station的總結練習獲得更高級的插值示例。

九、數值積分：scipy.integrate Fusy,

最通用的積分程序是scipy.integrate.quad():

In [10]: from scipy.integrate import quad
In [11]: res, err = quad(np.sin, 0, np.pi/2)
In [12]: np.allclose(res, 1)
Out[12]: True

In [13]: np.allclose(err, 1 - res)
Out[13]: True

其它可用的積分方案有fixed_quad, quadrature, romberg。

scipy.integrate也是用來積分常微分方程(ODE)的功能程序。特別是，scipy.integrate.odeint()是個使用LSODA(Livermore Solver for Ordinary Differential equations with Automatic method switching for stiff and non-stiff problems)通用積分器。參見ODEPACK Fortran library獲得更多細節。

odeint解決這種形式的一階ODE系統：

dy/dt = rhs(y1, y2, .., t0,...)

作為簡介，讓我們解決ODEdy/dt = -2y,區間t = 0..4,初始條件y(t=0) = 1。首先函數計算導數的位置需要被定義：

In [17]: def calc_derivative(ypos, time, counter_arr):
   ....:     counter_arr += 1
   ....:     return -2 * ypos                                               
   ....: 

一個額外的參數counter_arr被添加，用來說明函數可能在單個時間步中被多次調用，直到解收斂。計數數組被定義成：

In [18]: counter = np.zeros((1,), dtype=np.uint16)
彈道將被計算：

In [19]: from scipy.integrate import odeint                                 
In [20]: time_vec = np.linspace(0, 4, 40)                                   
In [21]: yvec, info = odeint(calc_derivative, 1, time_vec,
   ....: args=(counter,), full_output=Tru)

因此導函數可以被調用40次(即時間步長數)，

In [22]: counter
Out[22]: array([129], dtype=uint16)

十個最初的時間點(time step)每個的累積迭代次數，可以這樣獲得：

In [23]: info['nfe'][:10]
Out[23]: array([31, 35, 43, 49, 53, 57, 59, 63, 65, 69], dtype=int32)

注意到在第一個時間步的解需要更多的迭代。解yvec的軌道現在可以被畫出：

另一個使用scipy.integrate.odeint()的例子是一個阻尼彈簧-質點振蕩器(二階振蕩)。附加在彈簧上質點的位置服從二階常微分方程y'' + eps wo y' + wo^2 y= 0。其中wo^2 = k/m,k是彈簧常數，m是質量，eps=c/(2 m wo)，c是阻尼系數。(譯者：為什么不用latex……)對于這個例子，我們選擇如下參數：

In [24]: mass = 0.5  # kg
In [25]: kspring = 4  # N/m
In [26]: cviscous = 0.4  # N s/m

所以系統將是阻尼振蕩，因為:

In [27]: eps = cviscous / (2 * mass * np.sqrt(kspring/mass))
In [28]: eps < 1
Out[28]: True

對于scipy,integrate.odeint()求解器，二階方程需要被轉化成一個包含向量Y =y,y'的兩個一階方程的系統。定義nu = 2 eps * wo = c / m和om = wo^2 = k/m很方便：

In [29]: nu_coef = cviscous /mass
In [30]: om_coef = kspring / mass

因此函數將計算速度和加速度通過：

In [31]: def calc_deri(yvec, time, nuc, omc):
   ....:     return (yvec[1], -nuc * yvec[1] - omc * yvec[0])
   ....: 

In [32]: time_vec = np.linspace(0, 10, 100)

In [33]: yarr = odeint(calc_deri, (1, 0), time_vec, args=(nu_coef, om_coef))

最終的位置和速度在如下Matplotlib圖像中顯示

Scipy中不存在偏微分方程(PDE)求解器,一些解決PDE問題的Python軟件包可以得到，像fipy和SfePy

(譯者注:Python科學計算中洛倫茲吸引子微分方程的求解

十、信號處理：scipy.signal

In [34]: from scipy import signal

scipy.signal.detrend()：移除信號的線性趨勢：

In [35]: t = np.linspace(0, 5, 100)
In [36]: x = t + np.random.normal(size=100)
In [39]: import pylab as pl
In [40]: pl.plot(t, x, linewidth=3)
Out[40]: [<matplotlib.lines.Line2D at 0x3903c90>]

In [41]: pl.plot(t, signal.detrend(x), linewidth=3)
Out[41]: [<matplotlib.lines.Line2D at 0x3b38810>]
detrend

scipy.signal.resample():使用FFT重采樣n個點。

In [42]: t = np.linspace(0, 5, 100)
In [43]: x = np.sin(t)
In [44]: pl.plot(t, x, linewidth=3)
Out[44]: [<matplotlib.lines.Line2D at 0x3f08a90>]

In [45]: pl.plot(t[::2], signal.resample(x, 50), 'ko')
Out[45]: [<matplotlib.lines.Line2D at 0x3f12950>]
resample

• Signal中有許多窗函數：scipy.signal.hamming(), scipy.signal.bartlett(), scipy.signal.blackman()…

• Signal中有濾波器(中值濾波scipy.signal.medfilt(), 維納濾波scipy.signal.wiener())，但是我們將在圖像部分討論。

十一、圖像處理：scipy.ndimage

scipy中致力于圖像處理的子模塊是scipy,ndimage。

In [49]: from scipy import ndimage

圖像處理程序可以根據它們執行的操作類別來分類。

圖像的幾何變換:

改變方向，分辨率等

In [50]: from scipy import misc
In [51]: lena = misc.lena()
In [52]: shifted_lena = ndimage.shift(lena, (50, 50))
In [53]: shifted_lena2 = ndimage.shift(lena, (50, 50), mode='nearest')
In [54]: rotated_lena = ndimage.rotate(lena, 30)
In [55]: cropped_lena = lena[50:-50, 50:-50]
In [56]: zoomed_lena = ndimage.zoom(lena, 2)
In [57]: zoomed_lena.shape
Out[57]: (1024, 1024)

In [63]: pl.subplot(321)
Out[63]: <matplotlib.axes.AxesSubplot at 0x4c00d90>

In [64]: pl.imshow(lena, cmap=cm.gray)
Out[64]: <matplotlib.image.AxesImage at 0x493aad0>

In [65]: pl.subplot(322)
Out[65]: <matplotlib.axes.AxesSubplot at 0x4941a10>

In [66]: #等

圖像濾鏡

In [76]: from scipy import misc
In [77]: lena = misc.lena()
In [78]: import numpy as np
In [79]: noisy_lena = np.copy(lena).astype(np.float)
In [80]: noisy_lena += lena.std()*0.5*np.random.standard_normal(lena.shape)
In [81]: blurred_lena = ndimage.gaussian_filter(noisy_lena, sigma=3)
In [82]: median_lena = ndimage.median_filter(blurred_lena, size=5)
In [83]: from scipy import signal
In [84]: wiener_lena = signal.wiener(blurred_lena, (5,5))

許多其它scipy.ndimage.filters和scipy.signal中的濾鏡可以被應用到圖像中。

練習: 比較不同濾鏡圖像的直方圖

數學形態學

數學形態學是源于幾何論的數學形態學。它具有結合結構的特點并變換幾何結構。二值圖(黑白圖)，特別能被用該理論轉換：要轉換的集合是鄰近的非零值像素。這個理論也被拓展到灰度圖中。

基本的數學形態操作使用一個結構元素(structuring element)來改變其它幾何結構。

讓我們首先生成一個結構元素：

In [129]: el = ndimage.generate_binary_structure(2, 1)
In [130]: el
Out[130]: 
array([[False,  True, False],
       [ True,  True,  True],
       [False,  True, False]], dtype=bool)

In [131]: el.astype(np.int)
Out[131]: 
array([[0, 1, 0],
       [1, 1, 1],
       [0, 1, 0]])

• 腐蝕

In [132]: a = np.zeros((7,7), dtype=int)
In [133]: a[1:6, 2:5] = 1
In [134]: a
Out[134]: 
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])

In [135]: ndimage.binary_erosion(a).astype(a.dtype)
Out[135]: 
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 1, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])


# 腐蝕移除對象使結構更小
In [136]: ndimage.binary_erosion(a, structure=np.ones((5,5))).astype(a.dtype)
Out[136]: 
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])

• 膨脹

In [137]: a = np.zeros((5,5))
In [138]: a[2, 2] = 1
In [139]: a
Out[139]: 
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

In [140]: ndimage.binary_dilation(a).astype(a.dtype)
Out[140]: 
array([[ 0.,  0.,  0.,  0.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  1.,  1.,  1.,  0.],
       [ 0.,  0.,  1.,  0.,  0.],
       [ 0.,  0.,  0.,  0.,  0.]])

• 開操作(opening)

In [141]: a = np.zeros((5,5), dtype=np.int)

In [142]: a[1:4, 1:4] = 1; a[4, 4] = 1

In [143]: a
Out[143]: 
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 1]])

# 開操作可以移除小的對象
In [145]: ndimage.binary_opening(a, structure=np.ones((3,3))).astype(np.int)Out[145]: 
array([[0, 0, 0, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 0, 0, 0]])

# 開操作也能平滑邊角
In [147]: ndimage.binary_opening(a).astype(np.int)
Out[147]: 
array([[0, 0, 0, 0, 0],
       [0, 0, 1, 0, 0],
       [0, 1, 1, 1, 0],
       [0, 0, 1, 0, 0],
       [0, 0, 0, 0, 0]])

• 閉操作(closing): ndimage.binary_closing

練習: 查看開操作腐蝕，然后膨脹的量。

一個開操作移除小的結構，而一個閉操作填補小的空洞。這種操作因此可被用來“清理”圖像。

In [149]: a = np.zeros((50, 50))
In [150]: a[10:-10, 10:-10] = 1
In [151]: a += 0.25*np.random.standard_normal(a.shape)
In [152]: mask = a>=0.5
In [153]: opened_mask = ndimage.binary_opening(mask)
In [154]: closed_mask = ndimage.binary_closing(opened_mask)

練習: 驗證重構區域比初始區域更小。(如果閉操作在開操作之前則相反)

對灰度值圖像，腐蝕(或者是膨脹)相當于用被集中在所關心像素點的結構元素所覆蓋像素的最小(或最大)值替代當前像素點。

In [173]: a = np.zeros((7,7), dtype=np.int)
In [174]: a[1:6, 1:6] = 3
In [175]: a[4,4] = 2; a[2,3] = 1
In [176]: a
Out[176]: 
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 3, 3, 3, 3, 3, 0],
       [0, 3, 3, 1, 3, 3, 0],
       [0, 3, 3, 3, 3, 3, 0],
       [0, 3, 3, 3, 2, 3, 0],
       [0, 3, 3, 3, 3, 3, 0],
       [0, 0, 0, 0, 0, 0, 0]])

In [177]: ndimage.grey_erosion(a, size=(3,3))
Out[177]: 
array([[0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 1, 1, 1, 0, 0],
       [0, 0, 3, 2, 2, 0, 0],
       [0, 0, 0, 0, 0, 0, 0],
       [0, 0, 0, 0, 0, 0, 0]])

圖像測量

讓我們首先生成一個漂亮的合成圖像：

In [178]: x, y = np.indices((100, 100))
In [179]: sig = np.sin(2*np.pi*x/50.)*np.sin(2*np.pi*y/50.)*(1+x*y/50.**2)**2

In [180]: mask = sig > 1 

#現在我們查找圖像中對象的各種信息：
In [181]: labels, nb = ndimage.label(mask)
In [182]: nb
Out[182]: 8

In [183]: areas = ndimage.sum(mask, labels, xrange(1, labels.max()+1))
In [184]: areas
Out[184]: array([ 190.,   45.,  424.,  278.,  459.,  190.,  549.,  424.])

In [185]: maxima = ndimage.maximum(sig, labels, xrange(1, labels.max()+1))
In [186]: maxima
Out[186]: 
array([  1.80238238,   1.13527605,   5.51954079,   2.49611818,
         6.71673619,   1.80238238,  16.76547217,   5.51954079])

In [187]: ndimage.find_objects(labels==4)
Out[187]: [(slice(30L, 48L, None), slice(30L, 48L, None))]

In [188]: sl = ndimage.find_objects(labels==4)
In [189]: import pylab as pl
In [190]: pl.imshow(sig[sl[0]])  
Out[190]: <matplotlib.image.AxesImage at 0xb2fdcd0>

參見總結練習Image processing application: counting bubbles and unmolten grains獲取更多高級示例。

總結練習

總結練習主要使用Numpy，Scipy和Matplotlib。它們提供一些現實生活中用Python計算的示例。既然基本的Numpy和scipy使用已經被介紹了，歡迎有興趣的用戶嘗試這些練習。

練習：

斯普羅站最大風速預測

非線性最小二乘擬合：地形雷達數據的點提取

圖像處理應用：計數氣泡和未融顆粒

建議的解：

圖像處理練習解的示例:玻璃中的未融顆粒