python+opencvで画像処理の勉強2 画素ごとの濃淡変換

pythonとOpenCVで画像処理の勉強をします。

### 前回
画像の読み込みと表示

https://qiita.com/tanaka_benkyo/items/7e3c7f07582b648d3232

今回使う画像はペンギンにします。

```python
import cv2
import matplotlib.pyplot as plt

image_path = image_path # 画像のパス
img = cv2.imread(image_path)
img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
img = cv2.resize(img[250:2250, 2200:4200], dsize=None, fx=0.5, fy=0.5)
plt.imshow(img, 'gray')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/2ff836d7-4abf-18ea-f634-44475ba4f13a.png)

## 明るさ・コントラストの変換
ここではグレースケール画像の濃淡変換について説明します。

### トーンカーブ
画像の画素値を変換するために、入力画素値に対しどのように出力値を対応付けるか指定します。
これを指定する関数が**階調変換関数**であり、グラフで表したものを**トーンカーブ**と呼びます。
この後は、いくつかトーンカーブとその変換例を紹介していきます。
ここでは**ルックアップテーブル**と呼ばれる入力画素値と出力画素値の対応表を作成して変換を行います。


#### 折れ線型トーンカーブ
単純な変換ですが、暗くつぶれていた部分を見やすくすることなどによく使用されます。
曲がっている点前後で急に変化する、トーンカーブが平坦な部分で出力値が一定になるなど欠点があります。

まず、使用する画像の画素値(明るさ)のヒストグラムを確認します。

```python
plt.hist(img.flatten(), 256, [0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/8485a33a-1ac7-9927-bff1-164fcdd5c757.png)

ここで、次のトーンカーブを考えてみます。

```python
import numpy as np
import japanize_matplotlib

# 変換前の画素値x
x = np.arange(256)

# 200が255に変換されるように傾きを求める
a = 255 / (200 - 0)

# xを線形変換する
# 画素値の最大値は255である
y = np.clip(a * (x - 0) + 0, 0, 255)

plt.plot(x, y)
plt.xlabel('変換前 x')
plt.ylabel('変換後 y')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/139fcc48-abd0-aa32-9127-e0f6e2c52c0d.png)

これは、現在の画素値が0～200のものは0～255に変換され、現在の画素値が200より大きいものはすべて255に変換されることを表しています。
このyがルックアップテーブルとなります。
このルックアップテーブルを使用して画像を変換するにはLUT()を使います。

```python
img_lut = cv2.LUT(img, y)
plt.imshow(img_lut, 'gray')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/43476bc4-aaa5-11f1-3bdd-4dc7652d5934.png)

ちょっと変化が分かりづらいですが、ヒストグラムを見てみます。

```python
plt.hist(img_lut.flatten(), 256, [0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/ca2f7a5b-c25d-37e9-f843-9a94fbaf7431.png)

確かに先ほど見たヒストグラムが横に広がったような形になったので変換はできているようです。

他にも条件を変えて結果を確認してみます。
まず、折れ線型トーンカーブ用のルックアップテーブルを作成する関数を定義します。

```python
def make_linear_lut(range_min=0, range_max=255, beta=0, a=-1):
    """
    折れ線型トーンカーブのLUTを作成する
    """
    if a >= 0:
        # 傾きを直接決める
        a = a
    else:
        # 傾きの計算
        range_max = range_max
        range_min = range_min
        beta = beta

        a = 255 / (range_max - range_min)
    
    # 変換前の画素値x
    x = np.arange(256)

    # ルックアップテーブルyの作成
    y = np.clip(a * (x - range_min), 0, 255)
    y = np.clip(y + beta, 0, 255).astype('int')
    
    return y
```

3パターンで見てみます。

```python
# 3種類のLUTを作成
x = np.arange(256)
y1 = make_linear_lut(0, 150, 0)
y2 = make_linear_lut(100, 255, 0)
y3 = make_linear_lut(0, 255, 50, 0.5)

fig, ax = plt.subplots(3, 3, figsize=(15, 10))

for i, y in enumerate([y1,y2,y3]):
    # トーンカーブ
    ax[0][i].plot(x, y)
    ax[0][i].set_xlim([0, 255])
    ax[0][i].set_ylim([-5, 260])
    ax[0][i].set_xlabel('変換前')
    ax[0][i].set_ylabel('変換後')
    
    # 変換画像
    img_lut = cv2.LUT(img, y)
    ax[1][i].imshow(img_lut, 'gray')
    ax[1][i].set_xticks([])
    ax[1][i].set_yticks([])
    
    # ヒストグラム
    ax[2][i].hist(img_lut.flatten(),256,[0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/55e750db-c7f7-a215-bc33-fc83d23b97fb.png)

画像が暗くなったり、明るくなったりしているのがわかります。
ヒストグラムは0や255などの端の値にカウントが偏っていることも確認できます。

#### 累乗型トーンカーブ
折れ線型トーンカーブでは、トーンカーブの折れ曲がっている点の前後で変換の性質が急激に変わる欠点がありました。
このような折れ線型トーンカーブの欠点に対応するために曲線のトーンカーブを用いることがあります。
以下のような式で変換することを**ガンマ補正**と呼びます。
$$
y = 255(\frac{x}{255})^{\frac{1}{\gamma}}
$$
γ>1でyは上に凸となり画像は明るくなり、γ<1でyは下に凸となり画像は暗くなります。
まずは、ガンマ補正のルックアップテーブルを作る関数を定義します。

```python
def make_gamma_lut(gamma, imax=255):
    """
    ガンマ補正のLUTを作成
    """
    x = np.arange(256)
    y = imax*(x / imax) ** (1/gamma)
    
    return y.astype('int')
```

いくつかの$\gamma$値で作成したトーンカーブを見てみます。

```python
x = np.arange(256)

# ガンマ補正のトーンカーブの描画
gammas = [3.0, 2.0, 1.0, 0.66, 0.33]

plt.figure(figsize=(6,6))
for g in range(len(gammas)):
    y = make_gamma_lut(gammas[g])
    plt.plot(x, y, label=str(gammas[g]));
plt.legend();
plt.xlabel('変換前 x')
plt.ylabel('変換後 y')
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/d223b275-a494-cf4d-ccbc-92be99d9f5a4.png)


折れ線型と違い滑らかに変化しているのが分かります。
これらのトーンカーブによって変換した画像も確認してみます。

```python
# 変換結果の描画
fig2, ax2 = plt.subplots(5, 2, figsize=(10, 20))
for i in range(len(gammas)):
    y = make_gamma_lut(gammas[i])
    img_lut = cv2.LUT(img, y)
    ax2[i][0].imshow(img_lut, 'gray')
    ax2[i][0].set_xticks([])
    ax2[i][0].set_yticks([])
    ax2[i][0].set_title('γ=' + str(gammas[i]))
    
    ax2[i][1].hist(img_lut.flatten(),256,[0,256]);
plt.show()
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/a37a5948-9d4c-8d1f-9998-95c02e86b35d.png)

$\gamma$値が大きいほど明るく、小さくなるほど暗くなっていくのがわかります。
ヒストグラムも端の値にカウントが偏ることがなく元の形状を保っているように見えます。

#### S字トーンカーブ
S字トーンカーブというものもあり、これは画素値が中央に偏っているときなどに使用します。

```python
x = np.arange(256)
# S字カーブを適当に定義
y = ((np.sin(np.pi * (x/255 - 0.5)) + 1)/2 * 255).astype('int')
img_lut = cv2.LUT(img, y)

fig, ax = plt.subplots(1, 3, figsize=(17, 4))
# トーンカーブ
ax[0].plot(x, y);

# 変換後画像
ax[1].imshow(img_lut, 'gray');
ax[1].set_xticks([]);
ax[1].set_yticks([]);

ax[2].hist(img_lut.flatten(),256,[0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/f301f6ba-2a15-f556-92fe-34a2465a4816.png)

#### ヒストグラム平坦化
トーンカーブによる濃淡の変化は、人手で作業する必要があります。
これを自動化する変換方法に**ヒストグラム平坦化**と呼ばれるものがあります。
ヒストグラム平坦化では画素値のヒストグラムが、画素値の全域にわたって均等になるように変換します。
しかし、ある画素値の分布がすでに均等になる値を超えているときなど、均等になることはまれです。
また、**適応的ヒストグラム平坦化**と呼ばれる画像をタイルと呼ばれる小領域に分割し，領域毎にヒストグラム平坦化を適用したものもあります。
ヒストグラム平坦化はcv2.equalizeHist()を、適応的ヒストグラム平坦化はcv2.createCLAHE()を使用します。
これらの処理結果を確認してみます。

```python
# ヒストグラム平坦化
dst1 = cv2.equalizeHist(img)

# 適応的ヒストグラム平坦化
clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8,8))
dst2 = clahe.apply(img)

#描画
plt.figure(figsize=(16, 6))
plt.subplot(2, 3, 1)
plt.title('基画像')
plt.hist(img.flatten(),256,[0,256], color = 'r');

plt.subplot(2, 3, 2)
plt.title('ヒストグラム平坦化')
plt.hist(dst1.flatten(),256,[0,256], color = 'r');

plt.subplot(2, 3, 3)
plt.title('適応的ヒストグラム平坦化')
plt.hist(dst2.flatten(),256,[0,256], color = 'r');

plt.subplot(2, 3, 4)
plt.imshow(img, 'gray');
plt.xticks([]);
plt.yticks([]);

plt.subplot(2, 3, 5)
plt.imshow(dst1, 'gray');
plt.xticks([]);
plt.yticks([]);

plt.subplot(2, 3, 6)
plt.imshow(dst2, 'gray');
plt.xticks([]);
plt.yticks([]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/fb3c9d93-96b2-87f1-850c-08b4a25b9de4.png)


### 特殊な効果
####　濃淡の反転
濃淡を反転させる処理は**ネガ・ポジ反転**と呼ばれます。
ルックアップテーブルを定義してもできますが、cv2.bitwise_not()を使って結果を確認します。

```python
x = np.arange(256)
# LUTではなく関数を使って変換
dst = cv2.bitwise_not(img)

fig, ax = plt.subplots(1, 3, figsize=(17, 4))
# トーンカーブ
ax[0].plot(x, 255-x);

# 変換後画像
ax[1].imshow(dst, 'gray');
ax[1].set_xticks([]);
ax[1].set_yticks([]);

ax[2].hist(dst.flatten(),256,[0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/4e24ed96-7ae5-6c6b-87bf-362f42169c4c.png)

白黒が反転して、ヒストグラムも反転していることがわかります。

#### ポスタリゼーション
階段状のトーンカーブを用いることで、出力画像の画素値を数段階に制限することができます。
このような変換を**ポスタリゼーション**と呼び、2段階のものは**2値化**と呼ばれています。
2値化については、また別の機会に解説します。

まずは、ポスタリゼーション用のルックアップテーブルを作る関数を定義します。

```python
def make_post_lut(n):
    """
    ポスタリゼーション用のLUTを作成
    """
    x = np.arange(256)
    y = np.floor(x/n)*int(255/np.floor(255/n))
    y = y.astype('uint8')
    return y
```

この関数を使って3種類の段数でポスタリゼーションを適用してみます。

```python
c = [64, 32, 8]
x = np.arange(256)

# 変案及び描画
fig, ax = plt.subplots(3, 3, figsize=(14, 10))

for i in range(3):
    y = make_post_lut(c[i])
    ax[0][i].plot(x, y)
    ax[0][i].set_xlim([0, 255])
    ax[0][i].set_ylim([-5, 260])

    img_lut = cv2.LUT(img, y)
    ax[1][i].imshow(img_lut, 'gray')
    ax[1][i].set_xticks([])
    ax[1][i].set_yticks([])
    
    ax[2][i].hist(img_lut.flatten(),256,[0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/e5cc915e-01e5-e6f0-8a5c-8c571355ccfc.png)

画素値のパターンが減っているのが画像からもヒストグラムからもわかります。

#### ソラリゼーション
画像の濃淡の一部を反転させることで、ネガ画像とポジ画像が混ざったような効果が出ることがあります。
この効果を**ソラリゼーション**と呼びます。

```python
x = np.arange(256)
# ソラリゼーション用のLUTを適当に作成
y = ((np.sin(3 * np.pi * (x / 255 + 1 / 2 )) + 1) * 255 / 2).astype('uint8')
img_lut = cv2.LUT(img, y)

fig, ax = plt.subplots(1, 3, figsize=(17, 4))
# トーンカーブ
ax[0].plot(x, y);

# 変換後画像
ax[1].imshow(img_lut, 'gray');
ax[1].set_xticks([]);
ax[1].set_yticks([]);

ax[2].hist(img_lut.flatten(),256,[0,256]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/41543626-5b74-1e61-e7f1-791c10b78160.png)

ネガ・ポジ反転とは違い、完全に反転しているわけではないことが分かります。

## カラー画像の変換 
ここからはカラー画像の変換について説明します。

```python
img = cv2.imread(image_path)
img = cv2.resize(img[250:2250, 2200:4200], dsize=None, fx=0.5, fy=0.5)
img_rgb = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
plt.imshow(img_rgb)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/a6b633c7-910a-ee48-ec62-42d180fccd83.png)

#### R,G,Bトーンカーブによる変換
カラー画像でも同様にトーンカーブによってコントラストの変換ができます。
R,G,B各チャンネルに同じトーンカーブを指定した場合の例を示します。
処理は今までと同様にできます。



```python
# 3種類のLUTを作成
x = np.arange(256)
y1 = make_linear_lut(0, 150, 0)
y2 = make_linear_lut(100, 255, 0)
y3 = make_linear_lut(0, 255, 50, 0.5)

fig, ax = plt.subplots(2, 3, figsize=(15, 8))
for i, y in enumerate([y1,y2,y3]):
    # トーンカーブ
    ax[0][i].plot(x, y)
    ax[0][i].set_xlim([0, 255])
    ax[0][i].set_ylim([-5, 260])
    ax[0][i].set_xlabel('変換前')
    ax[0][i].set_ylabel('変換後')
    
    # 変換画像
    img_lut = cv2.LUT(img_rgb, y)
    ax[1][i].imshow(img_lut)
    ax[1][i].set_xticks([])
    ax[1][i].set_yticks([])
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/5de98f41-181c-f3fd-9513-df8c8c045bcb.png)

画像が暗くなったり明るくなったりしていることが確認できます。


同じトーンカーブを指定しても、意図しない色が出力される場合があります。
その極端な例としてソラリゼーションをした画像を出してみます。

```python
x = np.arange(256)
# ソラリゼーション用のLUTを適当に作成
y = ((np.sin(3 * np.pi * (x / 255 + 1 / 2 )) + 1) * 255 / 2).astype('uint8')
img_lut = cv2.LUT(img_rgb, y)

# 描画
fig, ax = plt.subplots(1, 2, figsize=(10, 4))
ax[0].plot(x, y)

ax[1].imshow(img_lut)
ax[1].set_xticks([]);
ax[1].set_yticks([]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/03d4b6e8-64ed-f710-77fd-fc33d5e5d2bb.png)

1つのチャンネルのみ変換することもあります。

```python
fig, ax = plt.subplots(1, 3, figsize=(16, 5))
for i in range(3):
    tmp_img = img_rgb.copy()
    tmp_img[:,:,i] = cv2.LUT(tmp_img[:,:,i], y1)
    
    ax[i].imshow(tmp_img)
    ax[i].set_title(col[i])
    ax[i].set_xticks([]);
    ax[i].set_yticks([]);
```
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/025438ba-644c-e119-8a60-6a1e46e68a82.png)
![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/3ad21604-c48b-ce07-8ba7-d5c72996a04e.png)

左から赤・緑・青のみ図に示したトーンカーブで変換した画像です。

#### 疑似カラー画像
グレースケール画像の各画素値に対し、チャンネルごとに異なるトーンカーブを用いることで疑似的に色を付けることができます。
この画像を**疑似カラー**と呼びます。

```python
a = 255 / 50
x = np.arange(256)
yy1 = np.clip(a * x[:161], 0, 255)
yy2 = np.clip(255 - a * (x[161:]-161), 0, 255)

g = np.concatenate([yy1,yy2])
r = make_linear_lut(100, 160, 0)
b = make_linear_lut(100, 50, -1)

tmp_img = np.array([cv2.LUT(img, r), cv2.LUT(img, g), cv2.LUT(img, b)]).transpose(1,2,0).astype(int)

fig, ax = plt.subplots(1, 3, figsize=(16, 3))

ax[0].imshow(img, 'gray')
ax[0].set_xticks([]);
ax[0].set_yticks([]);

ax[1].plot(x, r, 'red')
ax[1].plot(x, g, 'green')
ax[1].plot(x, b, 'blue')

ax[2].imshow(tmp_img)
ax[2].set_xticks([]);
ax[2].set_yticks([]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/08459f0a-83de-71c5-dedc-5b21b7750f91.png)

#### 色相・彩度・明度の変化
カラー画をの変換するとき、直感的に理解しやすい色相・彩度・明度(**マンセル表色系**)に変換したうえで、それぞれの成分を調整する方法もつかわれます。
それぞれの値を変化させたときの画像の変化を確認してみます。

まずは、色相(H)、彩度(S)、明度(V)を変換する関数を定義します。

```python
def change_sv(img, h=1, s=1, v=1):
    """
    彩度と明度を変換する
    RGB -> HSV -> 変換 -> RGB
    """
    img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR) 
    img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
    s_magnification = s
    v_magnification = v
    h_magnification = h
    
    img_hsv[:,:,(0)] = img_hsv[:,:,(0)]*h_magnification
    img_hsv[:,:,(1)] = img_hsv[:,:,(1)]*s_magnification
    img_hsv[:,:,(2)] = img_hsv[:,:,(2)]*v_magnification
    img_bgr = cv2.cvtColor(img_hsv, cv2.COLOR_HSV2BGR)
    
    return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB) 
```

定義した関数を使って、それぞれ変化させていきます。
上から色相(H)、彩度(S)、明度(V)で、右に行くほど値が小さくなります。

```python
H = [1.4, 1, 0.2]
S = [1.4, 1, 0.2]
V = [1.4, 1, 0.2]
types = ['high', 'ref', 'low']

# 変換及び描画
fig, ax = plt.subplots(3, 3, figsize=(15, 15))
for i in range(3):
    dst = change_sv(img_rgb, h=H[i])
    ax[0][i].imshow(dst)
    ax[0][i].set_title('H_'+types[i])
    ax[0][i].set_xticks([])
    ax[0][i].set_yticks([])
    
    dst = change_sv(img_rgb, s=S[i])
    ax[1][i].imshow(dst)
    ax[1][i].set_title('S_'+types[i])
    ax[1][i].set_xticks([])
    ax[1][i].set_yticks([])
    
    dst = change_sv(img_rgb, v=V[i])
    ax[2][i].imshow(dst)
    ax[2][i].set_title('V_'+types[i])
    ax[2][i].set_xticks([])
    ax[2][i].set_yticks([])
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/29d39625-166c-c485-9dc0-c37f52856033.png)

色相(H)が変化すると色が変化、彩度(S)が小さくなるとグレースケールに近くなり、明度(V)が小さくなると暗くなることが確認できました。

## 複数の画像の利用
### 画像間の演算
**画像間演算**とは、複数の画像の同じ位置にある画素ごとに、ある決められた演算を行うものです。
演算には四則演算などの**算術演算**や、ANDやORなどの**論理演算**があります。

```python
img1 = cv2.imread(image_path1)
img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)
img1 = cv2.resize(img1[250:2250, 2200:4200], dsize=None, fx=0.5, fy=0.5)
img1_gray = cv2.cvtColor(img1, cv2.COLOR_RGB2GRAY)

img2 = cv2.imread(image_path2)
img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img2 = cv2.resize(img2[250:2250, 1500:3500], dsize=None, fx=0.5, fy=0.5)
img2_gray = cv2.cvtColor(img2, cv2.COLOR_RGB2GRAY)

fig, ax = plt.subplots(1, 2, figsize=(10, 5))
ax[0].imshow(img1)
ax[1].imshow(img2)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/1fa123b1-0287-af0f-9d07-68c856d5e3f1.png)


#### 加算
画像間の足し算を行います。
cv2.add()がありますが、「+」で計算しても大丈夫です。

```python
# img1 + img2でもよい
dst = cv2.add(img1, img2)

# 描画
plt.imshow(dst)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/8d29cb10-6765-48fc-9058-a6fc2691fbf7.png)

#### 減算
cv2.absdiff()で引き算の結果の絶対値が取得できます。
np.abs(img1 - img2)でも同様の計算ができまが、負の値も出したければimg1 - img2で計算させます。

```python
dst = cv2.absdiff(img1, img2)

# 描画
plt.imshow(dst)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/fe2f3927-5d21-fd55-76f1-b90496cd320b.png)

#### 乗算
cv2.multiply()で計算できますが、そのまま計算すると多くの値が255を超えてしまうので元の値を割るなどして処理します。

```python
dst = cv2.multiply(img1//6, img2//6)

# 描画
plt.imshow(dst)
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/ad3f9ce6-7523-56ca-7592-6b7a71aed198.png)


#### 論理演算
AND、OR、XOR、NOTの関数がそれぞれ用意されています。
それぞれの結果を確認します。

```python
im1 = cv2.bitwise_or(img1_gray, img2_gray)
im2 = cv2.bitwise_and(img1_gray, img2_gray)
im3 = cv2.bitwise_xor(img1_gray, img2_gray)
im4 = cv2.bitwise_not(img1_gray)

fig, ax = plt.subplots(2, 2, figsize=(10, 10))

ax[0][0].imshow(im1, 'gray');
ax[0][0].set_xticks([]);
ax[0][0].set_yticks([]);
ax[0][0].set_title('or');

ax[0][1].imshow(im2, 'gray');
ax[0][1].set_xticks([]);
ax[0][1].set_yticks([]);
ax[0][1].set_title('and');

ax[1][0].imshow(im3, 'gray');
ax[1][0].set_xticks([]);
ax[1][0].set_yticks([]);
ax[1][0].set_title('xor');

ax[1][1].imshow(im4, 'gray');
ax[1][1].set_xticks([]);
ax[1][1].set_yticks([]);
ax[1][1].set_title('not');
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/cb094d32-104e-791c-782b-75b39e043a6a.png)

#### アルファブレンディング
2枚の画像の重み付きの平均値を計算することを**ブレンディング**といいます。
α（重み）の値を時間的に変化させて、ある画像から別の画像へ変化させることができます。
このような手法は**ディゾルブ**または**オーバーラップ**と呼ばれています。

cv2.addWeighted()を使って、オーバーラップをしてみたいと思います。

```python
alpha = [1.0, 0.75, 0.5, 0.25, 0]

fig, ax = plt.subplots(1, 5, figsize=(18, 6))
for i in range(5):
    dst = cv2.addWeighted(img1, alpha[i], img2, (1-alpha[i]), 0)
    ax[i].imshow(dst)
    ax[i].set_xticks([]);
    ax[i].set_yticks([]);
    ax[i].set_title("α=" + str(alpha[i]))
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/2c03fbf7-5347-e4e2-3bd6-f0080e79f7f5.png)

左から右へ徐々に画像が変化していくことが分かります。

### マスク処理
画像のある部分を使うか指定したい場合に、画素ごとに1,0で指定した画像(**マスク画像**)をあらかじめ作成し、それに基づいて画像を取得することを**マスク処理**と呼びます。

```python
height = img1_gray.shape[0]
width = img1_gray.shape[1]

img_mask = np.zeros((height, width, 3), np.uint8)
img_mask[height//4:height*3//4, width//4:width*3//4, :] = [255]

dst = cv2.bitwise_and(img1, img_mask)

fig, ax = plt.subplots(1, 3, figsize=(16, 4))
ax[0].imshow(img1);
ax[0].set_title("基画像");
ax[0].set_xticks([]);
ax[0].set_yticks([]);

ax[1].imshow(img_mask);
ax[1].set_title("マスク画像");
ax[1].set_xticks([]);
ax[1].set_yticks([]);

ax[2].imshow(dst)
ax[2].set_title("マスク処理");
ax[2].set_xticks([]);
ax[2].set_yticks([]);
```

![image.png](https://qiita-image-store.s3.ap-northeast-1.amazonaws.com/0/2358656/46ea827e-3dfb-6399-9eef-bdbb3600d934.png)

これで画素ごとに濃淡を変化させる処理の基礎は押さえました。
次回はフィルタ処理について説明したいと思います。

### 次回
空間フィルタリング

https://qiita.com/tanaka_benkyo/items/2b4460f1cc0ed6a685eb

### 参考文献

https://www.amazon.co.jp/%E3%83%87%E3%82%A3%E3%82%B8%E3%82%BF%E3%83%AB%E7%94%BB%E5%83%8F%E5%87%A6%E7%90%86-%E6%94%B9%E8%A8%82%E7%AC%AC%E4%BA%8C%E7%89%88-%E3%83%87%E3%82%A3%E3%82%B8%E3%82%BF%E3%83%AB%E7%94%BB%E5%83%8F%E5%87%A6%E7%90%86%E7%B7%A8%E9%9B%86%E5%A7%94%E5%93%A1%E4%BC%9A/dp/490347464X