py_vprocessing/kernels.py at main · Monster-Gem/py_vprocessing · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
import numpy as np

kernel = {
    'Identity': np.array([[0, 0, 0],
                          [0, 1, 0],
                          [0, 0, 0]]),
    'Edge detection': np.array([[1, 0, -1],
                                [0, 0, 0],
                                [-1, 0, 1]]),
    'Laplacian': np.array([[0, -1, 0],
                           [-1, 4, -1],
                           [0, -1, 0]]),
    'Laplacian w/ diagonals': np.array([[-1, -1, -1],
                                        [-1, 8, -1],
                                        [-1, -1, -1]]),
    'Laplacian of gaussian': np.array([[0, 0, -1, 0, 0],
                                       [0, -1, -2, -1, 0],
                                       [-1, -2, 16, -2, -1],
                                       [0, -1, -2, -1, 0],
                                       [0, 0, -1, 0, 0]]),
    'Scharr': np.array([[-3, 0, 3],
                        [-10, 0, 10],
                        [-3, 0, 3]]),
    'Sobel edge horizontal': np.array([[-1, -2, -1],
                                       [0, 0, 0],
                                       [1, 2, 1]]),
    'Sobel edge vertical': np.array([[-1, 0, 1],
                                     [-2, 0, 2],
                                     [-1, 0, 1]]),
    'Line detection horizontal': np.array([[-1, -1, -1],
                                           [2, 2, 2],
                                           [-1, -1, -1]]),
    'Line detection vertical': np.array([[-1, 2, -1],
                                         [-1, 2, -1],
                                         [-1, 2, -1]]),
    'Line detection 45°': np.array([[-1, -1, 2],
                                     [-1, 2, -1],
                                     [2, -1, -1]]),
    'Line detection 135°': np.array([[2, -1, -1],
                                      [-1, 2, -1],
                                      [-1, -1, 2]]),
    'Box blur': (1/9)*np.ones((3, 3)),
    'Gaussian blur 3x3': (1/16)*np.array([[1, 2, 1],
                                          [2, 4, 2],
                                          [1, 2, 1]]),
    'Gaussian blur 5x5': (1/256)*np.array([[1, 4, 6, 4, 1],
                                           [4, 16, 24, 16, 4],
                                           [6, 24, 36, 24, 6],
                                           [4, 16, 24, 16, 4],
                                           [1, 4, 6, 4, 1]]),
    'Sharpen': np.array([[0, -1, 0],
                         [-1, 5, -1],
                         [0, -1, 0]]),
    'Unsharp masking': (-1/256)*np.array([[1, 4, 6, 4, 1],
                                          [4, 16, 24, 16, 4],
                                          [6, 24, -476, 24, 6],
                                          [4, 16, 24, 16, 4],
                                          [1, 4, 6, 4, 1]]),
}