画像処理の基本計算式まとめ


## はじめに
画像処理において頻繁に使用される基本的な計算式をまとめました。
数学的な定義とPythonの実装例とともに・・

## 1. グレースケール変換

### 数学的定義
RGB画像からグレースケール値 Y への変換式

Y = 0.299R + 0.587G + 0.114B

ここで
- Y: グレースケール値 (0-255)
- R: 赤チャンネルの値 (0-255)
- G: 緑チャンネルの値 (0-255)
- B: 青チャンネルの値 (0-255)

### 実装例
```python:python
def rgb_to_grayscale(r, g, b):
    return 0.299 * r + 0.587 * g + 0.114 * b
```

## 2. 二値化処理

### 単純な閾値処理の数学的定義
画素値 p(x,y) に対する二値化関数 b(x,y)

b(x,y) = {
    255  (p(x,y) ≥ T)
    0    (p(x,y) < T)
}

ここで T は閾値（一般的に128など）を表します。

### 大津の二値化法の数学的定義
クラス間分散 σB²(t) の計算

σB²(t) = ω1(t)ω2(t)[μ1(t) - μ2(t)]²

ここで
- ω1(t): クラス1の画素の出現確率
- ω2(t): クラス2の画素の出現確率
- μ1(t): クラス1の平均値
- μ2(t): クラス2の平均値
- t: 閾値

最適な閾値 T は以下で求められます。
T = argmax[σB²(t)]

### 実装例
```python:python
def threshold(pixel_value, threshold=128):
    return 255 if pixel_value >= threshold else 0

def otsu_threshold(histogram, total_pixels):
    total_mean = sum(i * histogram[i] for i in range(256)) / total_pixels
    
    max_variance = 0
    optimal_threshold = 0
    
    for threshold in range(256):
        w1 = sum(histogram[:threshold])
        if w1 == 0:
            continue
            
        m1 = sum(i * histogram[i] for i in range(threshold)) / w1
        
        w2 = total_pixels - w1
        if w2 == 0:
            continue
            
        m2 = (sum(i * histogram[i] for i in range(threshold, 256))) / w2
        
        variance = w1 * w2 * ((m1 - m2) ** 2)
        
        if variance > max_variance:
            max_variance = variance
            optimal_threshold = threshold
            
    return optimal_threshold
```

## 3. エッジ検出

### Sobelフィルタの数学的定義
水平方向（Gx）と垂直方向（Gy）の勾配

Gx = [
    -1  0  1
    -2  0  2
    -1  0  1
]

Gy = [
    -1  -2  -1
     0   0   0
     1   2   1
]

エッジの強度 G は
G = √(Gx² + Gy²)

エッジの方向 θ は
θ = arctan(Gy/Gx)

### 実装例
```python:python
import numpy as np

sobel_x = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1]
])

sobel_y = np.array([
    [-1, -2, -1],
    [0, 0, 0],
    [1, 2, 1]
])

def sobel_edge_detection(image):
    gradient_x = np.convolve(image, sobel_x, mode='same')
    gradient_y = np.convolve(image, sobel_y, mode='same')
    gradient_magnitude = np.sqrt(gradient_x**2 + gradient_y**2)
    return gradient_magnitude
```

## 4. ガウシアンブラー

### 数学的定義
2次元ガウス関数

G(x,y) = (1/2πσ²)e^(-(x² + y²)/2σ²)

ここで
- σ: 標準偏差（ぼかしの強さ）
- x,y: カーネル内の座標
- e: 自然対数の底

### 実装例
```python:python
def gaussian_kernel(size, sigma):
    kernel = np.zeros((size, size))
    center = size // 2
    
    for i in range(size):
        for j in range(size):
            x = i - center
            y = j - center
            kernel[i, j] = np.exp(-(x**2 + y**2) / (2 * sigma**2))
            
    return kernel / np.sum(kernel)

def gaussian_blur(image, kernel_size=5, sigma=1.0):
    kernel = gaussian_kernel(kernel_size, sigma)
    return np.convolve(image, kernel, mode='same')
```

## 5. ヒストグラム平坦化

### 数学的定義
変換関数

s = T(r) = (L-1)∫[0 to r]p(w)dw

ここで
- r: 入力画素値
- s: 出力画素値
- L: 最大輝度値（通常256）
- p(w): 画素値の確率密度関数

離散的な実装では
s = ((L-1)/MN)Σ[j=0 to k]nj

ここで
- MN: 総画素数
- nj: 輝度値jの画素数
- k: 現在の輝度値

### 実装例
```python:python
def histogram_equalization(image):
    histogram = np.zeros(256)
    for pixel in image.flatten():
        histogram[pixel] += 1
    
    cdf = histogram.cumsum()
    cdf_normalized = (cdf - cdf.min()) * 255 / (cdf.max() - cdf.min())
    
    equalized = cdf_normalized[image]
    return equalized.astype(np.uint8)
```

## まとめ

以上が画像処理の基本的な計算式とその実装例です。

各処理について・・

1. 数学的な定義
2. その意味と効果
3. 実装方法

を説明しました。
これらを組み合わせることで、より複雑な画像処理も実現できます。

:::note alert
実際の使用時は、以下の点に注意してください。
- 入力画像の型やサイズの確認
- エッジケース（画像の端）の適切な処理
- 計算効率の最適化
- メモリ使用量の考慮
:::