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

import cv2 as cv
import matplotlib.pyplot as plt

# グリッド形式で色空間のチャンネルを表示する関数
def show_color_space_grid(image_path, color_spaces, grid_size=(3, 3), output_filename="color_spaces.png"):
    image = cv.imread(image_path)

    # グリッドを作成
    fig, axs = plt.subplots(grid_size[0], grid_size[1], figsize=(40, 30))

    # 各色空間の変換と表示
    index = 0  # グリッドのインデックス
    for color_space in color_spaces:
        conversion_code = color_space["code"]
        channels = color_space["channels"]
        title = color_space["title"]

        # 指定した色空間に変換
        converted_image = cv.cvtColor(image, conversion_code)

        # 各チャンネルを軸に表示
        for j, channel_name in enumerate(channels):
            row, col = divmod(index, grid_size[1])  # 行と列を計算
            channel_image = converted_image[:, :, j]

            # カラーマップを設定
            cmap = 'gray' # if len(channels) == 1 else None

            # 軸にプロット
            axs[row][col].imshow(channel_image, cmap=cmap)
            axs[row][col].set_title(f"{title} - {channel_name}")
            axs[row][col].axis("off")

            index += 1  

    # ファイルに保存
    plt.tight_layout()
    plt.savefig(output_filename)  
    plt.close() 


# 使用する色空間
color_spaces = [
    {"code": cv.COLOR_BGR2BGRA, "channels": ["B", "G", "R"], "title": "BGR"},
    {"code": cv.COLOR_BGR2HSV, "channels": ["H", "S", "V"], "title": "HSV"},
    {"code": cv.COLOR_BGR2Lab, "channels": ["L", "a", "b"], "title": "Lab"},
    {"code": cv.COLOR_BGR2Luv, "channels": ["L", "u", "v"], "title": "Luv"},
    {"code": cv.COLOR_BGR2HLS, "channels": ["H", "L", "S"], "title": "HLS"},
    {"code": cv.COLOR_BGR2YUV, "channels": ["Y", "U", "V"], "title": "YUV"},
    {"code": cv.COLOR_BGR2XYZ, "channels": ["X", "Y", "Z"], "title": "XYZ"},
    {"code": cv.COLOR_BGR2YCrCb, "channels": ["Y", "Cr", "Cb"], "title": "YCrCb"},
]


image_path = "test.png" 
show_color_space_grid(image_path, color_spaces, grid_size=(8, 3))

1
2
3
4
5
6

>>> 1 | 1
1
>>> 0 & 1
0
>>> 0 & 0
0

1
2
3

black_filter = cv2.inRange(sharped_denoised_img_roi, 0, 180) # 0 ~ 180 => white
img_roi_bitwized_grey = black_filter & sharped_denoised_img_roi 
plt.imshow(img_roi_bitwized_grey , cmap="gray")

 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

import cv2
import numpy as np

#img = cv2.imread('sqimage.png')
img = cv2.imread('tstar2.png')
gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
_,thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)
bw = cv2.bitwise_not(thresh)
contours,hierarchy = cv2.findContours(bw,2,1)
res_img = img // 2 + 128

# 輪郭描画
for cnt in contours:
    cv2.drawContours(res_img,[cnt],0,(255,128,0),2)

for cnt in contours:
    # 凸性の確認
    print('isContourConvex', cv2.isContourConvex(cnt))

    # 凸包(Convex Hull)
    # returnPoints=Trueを指定するとconvex hull上の点の座標
    # False を指定するとconvex hull上の点に対応する
    # 輪郭上の点のインデックスを返す．
    hull = cv2.convexHull(cnt,returnPoints = False)

    # 凸性欠陥情報の取得
    defects = cv2.convexityDefects(cnt,hull)
    if defects is None:
        print('defects is None!')
        continue

    for de in defects:
        #  [ 始点, 終点, 最も遠い点, 最も遠い点までの近似距離] 
        s_idx,e_idx,f_idx,d = de[0,:]   
        start = (*cnt[s_idx][0],)   # 始点
        end = (*cnt[e_idx][0],)     # 終点
        far = (*cnt[f_idx][0],)     # 最も遠い点

        cv2.line(res_img,start,end,(0,255,0),2) # 緑の線分
        cv2.circle(res_img,far,5,[0,0,255],-1) # 赤の点

cv2.imshow('convexityDefects test',res_img)
cv2.waitKey(0)
cv2.destroyAllWindows()

 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

import sys

import cv2 as cv
import numpy as np

template_path = sys.argv[1]
target_path = sys.argv[2]
out_path = sys.argv[3] if len(sys.argv) > 3 else "data/out/"

template_img = cv.imread(template_path, cv.IMREAD_GRAYSCALE)
target_img = cv.imread(target_path, cv.IMREAD_GRAYSCALE)

akaze = cv.AKAZE_create()
float_kp, float_des = akaze.detectAndCompute(target_img, None)
ref_kp, ref_des = akaze.detectAndCompute(template_img, None)

bf = cv.BFMatcher()
matches = bf.knnMatch(float_des, ref_des, k=2)

good_matches = []
for m, n in matches:
    if m.distance < 0.75 * n.distance:
        good_matches.append([m])

# 適切なキーポイントを選択
ref_matched_kpts = np.float32([float_kp[m[0].queryIdx].pt for m in good_matches]).reshape(-1, 1, 2)
sensed_matched_kpts = np.float32([ref_kp[m[0].trainIdx].pt for m in good_matches]).reshape(-1, 1, 2)

# ホモグラフィを計算
H, status = cv.findHomography(ref_matched_kpts, sensed_matched_kpts, cv.RANSAC, 5.0)

# 画像を変換
warped_image = cv.warpPerspective(target_img, H, (target_img.shape[1], target_img.shape[0]))

def write_grid(img):
    y_step = 50
    x_step = 50
    img_y, img_x = img.shape[:2]
    # 横線を引く：y_stepからimg_yの手前までy_stepおきに白い(BGRすべて255)横線を引く
    img[y_step:img_y:y_step, :] = 0
    # 縦線を引く：x_stepからimg_xの手前までx_stepおきに白い(BGRすべて255)縦線を引く
    img[:, x_step:img_x:x_step] = 0
    return img

warped_image = write_grid(warped_image)
template_img = write_grid(template_img)
cv.imwrite(f"{out_path}/template.png", template_img)
cv.imwrite(f"{out_path}/warped.png", warped_image)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

im = cv.imread("green-blurred.jpg")
yuv = cv.cvtColor(im, cv.COLOR_BGR2YCrCb) # or COLOR_BGR2YUV, should work equivalently here
#uv = yuv[:,:,(2,3)]
mean = np.mean(yuv, axis=(0,1))
std = np.std(yuv, axis=(0,1))
#mask = ((yuv - mean) / std >= 4.5).any(axis=2)
# EDIT: there needs to be an abs() on that difference, we want magnitudes, no signs
mask = (np.abs(yuv - mean) / std >= 4.5).any(axis=2)
mask_u8 = mask.astype(np.uint8) * 255
#grayscale = (np.abs(yuv - mean) / std / 5).max(axis=2)
cv.imshow("mask", mask_u8)
cv.waitKey(-1)

1
2
3
4
5
6
7
8
9

import cv2
import numpy as np
# contourは輪郭点のリスト cv2.findContours
# areaは図形の面積 cv2.contourArea

def calcCircleLevel (contour, area):
    perimeter = cv2.arcLength(contour, True)
    circle_level = 4.0 * np.pi * area / (perimeter * perimeter); # perimeter = 0 のとき気をつける
    return circle_level

 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

import cv2
from math import log

def hudist(f1 , f2):
   def h2m(x):
       if x==0:
          return 0.0
       elif x>0:
          return 1.0/log(x)
       else:
          return -1.0/log(-x)
   def hum(f):
       img = cv2.imread(f , cv2.CV_LOAD_IMAGE_GRAYSCALE)
       assert(img!=None),("failed to open %s" % f)
       moments = cv2.moments(img)
       return cv2.HuMoments(moments)
   hu = hum(f1)
   hu2 = hum(f2)
   d = sum([abs(h2m(x1)-h2m(x2)) for (x1,x2) in zip(hu.T[0],hu2.T[0])])
   return d

if __name__=="__main__":
   imgs = ['Lenna.png','Lena3.jpg','sendo1.jpg','Sendou2.jpg','monnalisa.jpg','apple.jpg','Red_Apple.jpg']
   for f1 in imgs:
       print f1,
       for f2 in imgs:
           v = 100*hudist(f1,f2)
           print ("%5.2f" % v),
       print ""

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

import cv2
import numpy as np
import matplotlib.pyplot as plt
from skimage import sio

url = 'https://upload.wikimedia.org/wikipedia/commons/5/53/OpenCV_Logo_with_text.png'
img = sio.imread(url)

gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
ret, binary = cv2.threshold(gray, 150, 255, cv2.THRESH_BINARY)

contours, hierarchy = cv2.findContours(binary, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)

img_blank = np.ones_like(img) * 255
img_contour_only = cv2.drawContours(img_blank, contours, -1, (0,0,0), 3)

plt.imshow(cv2.cvtColor(img_contour_only, cv2.COLOR_BGR2RGB))
plt.show()

1

contours[輪郭番号][点の番号][0][X座標, Y座標]

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

import numpy as np

def create_contour_from_bbox(minx, miny, maxx, maxy):
    contour = np.array([
        [[minx, miny]],
        [[minx, maxy]],
        [[maxx, maxy]],
        [[maxx, miny]]
    ])
    return [contour]

# 使用例
minx, miny, maxx, maxy = 100, 50, 200, 150
contour = create_contour_from_bbox(minx, miny, maxx, maxy)

1
2
3
4

hierarchy[0][輪郭番号][次の輪郭番号, 前の輪郭番号, 最初子供(内側)の輪郭番号, 親(外側)の輪郭番号]

NOTE: 
- 該当する輪郭番号が無い時は-1 

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

hierarchy[0][0] は [ 3, -1,  1, -1]
hierarchy[0][1] は [-1, -1,  2,  0]
hierarchy[0][2] は [-1, -1, -1,  1]
hierarchy[0][3] は [-1,  0,  4, -1]
hierarchy[0][4] は [-1, -1,  5,  3]
hierarchy[0][5] は [ 6, -1, -1,  4]
hierarchy[0][6] は [-1,  5,  7,  4]
hierarchy[0][7] は [-1, -1,  8,  6]
hierarchy[0][8] は [ 9, -1, -1,  7]
hierarchy[0][9] は [-1,  8, -1,  7]

1
2
3
4
5
6
7
8
9

import codecs
from datetime import datetime, timedelta, timezone

JST = timezone(timedelta(hours=+9), 'JST')

def print_log(message):
    now = datetime.now(JST)
    print(f"{now}: {message}")
    print(f"{now}: {message}", file=codecs.open('log.txt', 'a', 'utf-8'))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

import os
import random

import numpy as np
import torch
from torch.backends import cudnn


def set_seed(seed=42):
    os.environ["PYTHONHASHSEED"] = str(seed)
    random.seed(seed)
    np.random.seed(seed)
    torch.manual_seed(seed)
    if torch.cuda.is_available():
        torch.cuda.manual_seed(seed)
    cudnn.benchmark=True
    cudnn.deterministic = True

  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
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288

import math
from typing import Union

import cv2
import numpy as np
import torch
from PIL import Image
from skimage.metrics import structural_similarity
from torchvision import transforms


class CvUtil():
    @staticmethod
    def cv_bgr_to_cv_rgb(img_bgr: np.ndarray) -> np.ndarray:
        return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)

    @staticmethod
    def cv_bgr_to_cv_gray(img_bgr: np.ndarray) -> np.ndarray:
        return cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)

    @classmethod
    def cv_bgr_to_pil(cls, img_bgr: np.ndarray) -> Image.Image:
        """
        ref https://discuss.pytorch.org/t/how-to-transform-images-to-tensors/71447
        """
        img_rgb = cls.cv_bgr_to_cv_rgb(img_bgr)
        return Image.fromarray(img_rgb).convert('RGB')

    @staticmethod
    def cv_to_pil(image: np.ndarray) -> Image.Image:
        '''
        OpenCV型 -> PIL型
        NOTE: cv2のはBGR前提
        ref: https://qiita.com/derodero24/items/f22c22b22451609908ee
        '''
        new_image = image.copy()
        if new_image.ndim == 2:  # モノクロ
            pass
        elif new_image.shape[2] == 3:  # カラー
            new_image = cv2.cvtColor(new_image, cv2.COLOR_BGR2RGB)
        elif new_image.shape[2] == 4:  # 透過
            new_image = cv2.cvtColor(new_image, cv2.COLOR_BGRA2RGBA)
        new_image = Image.fromarray(new_image)
        return new_image


class PilUtil():
    @staticmethod
    def pil_to_normalized_tensor(img_pil: Image.Image) -> torch.Tensor:
        # MNISTは ToTensor() すると [0, 1] になるので0.5を引いて0.5で割って [-1, 1] の範囲に変換する。
        normalize = transforms.Normalize(
            mean=[0.5],
            std=[0.5]
        )  # z = (x - mean) / std

        img_transform = transforms.Compose([
            transforms.Resize((256, 256)),
            transforms.Grayscale(),
            transforms.ToTensor(),  # [0, 255] => [0, 1]
            # normalize, # [0, 1] => [-1, 1]
        ])
        return img_transform(img_pil)

    @staticmethod
    def pil_to_tensor(img_pil: Image.Image) -> torch.Tensor:
        """
        ref https://discuss.pytorch.org/t/pytorch-pil-to-tensor-and-vice-versa/6312/9
        """
        return transforms.ToTensor()(img_pil).unsqueeze_(0)

    @staticmethod
    def pil_to_pil_gray(img_pil: Image.Image) -> Image.Image:
        """
        グレースケール化
        """
        return img_pil.convert('L')

    @staticmethod
    def pil_to_pil_bw(img_pil: Image.Image) -> Image.Image:
        """
        2値化
        """
        return img_pil.convert('1')

    @staticmethod
    def pil_to_cv(image: Image.Image) -> np.ndarray:
        '''
        PIL型 -> OpenCV型
        NOTE: cv2のはBGRになる
        '''
        new_image = np.array(image, dtype=np.uint8)
        if new_image.ndim == 2:  # モノクロ
            pass
        elif new_image.shape[2] == 3:  # カラー
            new_image = cv2.cvtColor(new_image, cv2.COLOR_RGB2BGR)
        elif new_image.shape[2] == 4:  # 透過
            new_image = cv2.cvtColor(new_image, cv2.COLOR_RGBA2BGRA)
        return new_image


class TensorUtil():
    @staticmethod
    def tensor_to_pil(img_tensor: torch.Tensor) -> Image.Image:
        """
        ref https://discuss.pytorch.org/t/pytorch-pil-to-tensor-and-vice-versa/6312/9
        """
        return transforms.ToPILImage()(img_tensor.squeeze_(0))

    @staticmethod
    def np_2d_to_pil_bw_img(np_2d: np.ndarray) -> Image.Image:
        """
        ref: https://stackoverflow.com/questions/37558523/converting-2d-numpy-array-of-grayscale-values-to-a-pil-image
        """
        return Image.fromarray(np.uint8(np_2d * 255), 'L')

    @staticmethod
    def tensor_2d_to_pil_bw_img(tensor_2_axis: torch.Tensor) -> Image.Image:
        """
        2次元のテンソルを白黒のPILの画像に変換
        ref: https://discuss.pytorch.org/t/pytorch-pil-to-tensor-and-vice-versa/6312/8
        """
        tensor_3_axis = TensorUtil.torch_add_dim(tensor_2_axis)
        im = transforms.ToPILImage()(tensor_3_axis).convert("L")
        return im

    @staticmethod
    def tensor_to_np(x_tensor: torch.Tensor) -> np.ndarray:
        # numpyはCPUのメモリを使うので、一旦CPUに落とす
        device = x_tensor.device
        # NOTE: ndarrayの場合はコピーはcopy()
        x_np = x_tensor.to('cpu').detach().numpy().copy()
        x_tensor = x_tensor.to(device)  # テンソルを元にもどス
        return x_np

    @staticmethod
    def tensor_to_np_gray(x_tensor: torch.Tensor) -> np.ndarray:
        """
        TODO: 一つのテンソルのみを受け取るように修正するべき
        tensorを白黒の画像に変換する
        tensorの構造は: (channnel, width, height)
        """
        # x_tensors = 0.5 * (x_tensors + 1)  # [-1,1] => [0, 1]
        x_tensor = x_tensor.clamp(0, 1)  # np.clipと同じ、[0, 1]にデータを収める
        x_tensor = x_tensor.view(1, 256, 256)
        img_gray = x_tensor.cpu().numpy()
        return img_gray

    @staticmethod
    def torch_remove_dim(x_tensor: torch.Tensor) -> torch.Tensor:
        """
        tensorの次元削除。データローダーのテンソル -> 画像化の時によく使う
        """
        return x_tensor.squeeze()

    @staticmethod
    def torch_add_dim(x_tensor: torch.Tensor) -> torch.Tensor:
        """
        tensorの次元拡張。画像 -> データローダーのデータ化の時によく使う
        """
        return torch.unsqueeze(x_tensor, 0)

    @classmethod
    def torch_create_dummy_2dim(cls, x_tensor: torch.Tensor) -> torch.Tensor:
        """
        x_tensor: [1, x, x]
        バッチノーマライゼーションをモデルで入れている時に使用する。
        1つのtensorだとエラーが出てしまうので、便宜上形式的に同じ画像を入れて回避する。
        ref: https://discuss.pytorch.org/t/appending-to-a-tensor/2665/11
        """
        x1_tensor = cls.torch_add_dim(x_tensor)
        x2_tensor = cls.torch_add_dim(x_tensor)
        return torch.cat([x1_tensor.clone(), x2_tensor.clone()], dim=0)


class NumpyUtil():
    @staticmethod
    def np_to_tensor(x_np: np.ndarray) -> torch.Tensor:
        """
        ref: https://tzmi.hatenablog.com/entry/2020/02/16/170928
        """
        x_np = x_np.astype(np.float32)
        # NOTE: tensorの場合はコピーはclone()
        x_tensor = torch.from_numpy(x_np).clone()
        device = 'cuda' if torch.cuda.is_available() else 'cpu'
        x_tensor = x_tensor.to(device)
        return x_tensor

    @staticmethod
    def np_add_dim(np_2d_arr: np.ndarray) -> np.ndarray:
        """
        軸を増やす。使用用途としては、二次元配列を白黒画像化したいときなど。
        """
        return np.expand_dims(np_2d_arr, 0)


class TypeCheckUtil():
    @staticmethod
    def is_pil(any_img) -> bool:
        return isinstance(any_img, Image.Image)

    @staticmethod
    def is_np(any_img) -> bool:
        """
        npかどうかのみ
        """
        return isinstance(any_img, np.ndarray)

    @staticmethod
    def is_tensor(any_img) -> bool:
        return isinstance(any_img, torch.Tensor)

    def is_cv(any) -> bool:
        """
        TODO
        """
        pass


class ImageUitl():
    @staticmethod
    def get_img_info(any_img):
        """
        Dimensions-of-an-input-image
        """
        if isinstance(any_img, Image.Image):  # PIL
            w, h = any_img.size
            return h, w
        elif isinstance(any_img, torch.Tensor):  # Torch
            # https://discuss.pytorch.org/t/dimensions-of-an-input-image/19439
            c, h, w = any_img.size()
            return h, w
        elif np.shape(any_img) == ():  # OPENCV
            # https://answers.opencv.org/question/185629/in-python-is-there-a-method-or-operator-to-determine-if-a-frame-is-empty-or-an-all-zero-matrix/
            h, w, c = any_img.shape
            return h, w
        else:
            raise AssertionError("it's not compatible image type")

    @staticmethod
    def split_img_horizontally(img_cv_bgr: np.ndarray, n: int) -> np.ndarray:
        """
        n枚に画像を分割する
        """
        if n is None:
            raise AssertionError("Failed to split image.")

        height, width, _ = img_cv_bgr.shape
        blob_width = math.floor(width / n)
        y1 = 0
        y2 = height

        buff = []
        for i in range(n):
            x1 = i * blob_width
            x2 = (i + 1) * blob_width
            c = img_cv_bgr[y1: y2, x1: x2]  # img_rgb.crop((x1, y1, x2, y2))
            buff.append(c)
        return buff

    @staticmethod
    def img_save(any_img: Union[np.ndarray, Image.Image], file_path: str):
        if TypeCheckUtil.is_pil(any_img):
            any_img.save(file_path)
        elif TypeCheckUtil.is_np(any_img):
            cv2.imwrite(file_path, any_img)
        else:
            raise AssertionError("failed to get image")

    @staticmethod
    def mse(x, y):
        return np.linalg.norm(x - y)

    @staticmethod
    def ssim(input_img, output_img, kernel_size=15, is_data_range = False):
        kernel = np.ones((kernel_size, kernel_size), np.float32) / 255
        output_img = cv2.filter2D(output_img, -1, kernel)
        input_img = cv2.filter2D(input_img, -1, kernel)
        if is_data_range:
            return structural_similarity(
                input_img,
                output_img,
                data_range=input_img.max() - input_img.min(),
            )
        else:
            return structural_similarity(
                input_img,
                output_img,
            )

1
2
3
4

import cv2
img = cv2.imread('./fig.png')
img_pad = cv2.copyMakeBorder(img, 50, 50, 50, 50, cv2.BORDER_CONSTANT, (0,0,0))
cv2.imwrite('./fig_pad.png', img_pad)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import matplotlib.pyplot as plt
import numpy as np
from torch.utils.data import DataLoader

def confirm_img(train_loader: DataLoader):
    images, labels = iter(train_loader).next()

    images = images.clamp(0, 1)  # np.clipと同じ、[0, 1]にデータを収める
    images = images.view(images.size(0), 1, 256, 256)

    image_gray = images[0].squeeze().cpu().numpy()
    plt.imshow(image_gray, cmap="gray")
    plt.show()

    plt.hist(images[0].flatten(), bins=256, range=(0, 1))
    plt.show()

 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

import math
import random
import numpy as np
import cv2
import matplotlib.pyplot as plt

def show_image(img_bgr, title):
    plt.imshow(img_bgr)
    plt.title(title)
    plt.show()

def show_contours_with_multi_colors(contours, img_bgr, title):
    for cnt in contours:
        color = [random.randinit(0, 2455) for _ in range(3)]
        cv2.drawContours(img_bgr, [cnt], -1, color, -1)
    plt.imshow(img_bgr)
    plt.title(title)
    plt.show()

def show_contours_with_one_color(contours, img_bgr, title):
    cv2.drawContours(img_bgr, [contours], -1, (0,255,0), -1)
    plt.imshow(img_bgr)
    plt.title(title)
    plt.show()

def show_all_contours(contours, img_bgr):
    for cnt in contours:
        cv2.drawContours(img_bgr, [cnt], -1, (0,0,0), -1)
        plt.show()

 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

import os
import cv2
import numpy

def calculate_contour_distance(contour1, contour2): 
    x1, y1, w1, h1 = cv2.boundingRect(contour1)
    c_x1 = x1 + w1/2
    c_y1 = y1 + h1/2

    x2, y2, w2, h2 = cv2.boundingRect(contour2)
    c_x2 = x2 + w2/2
    c_y2 = y2 + h2/2

    # NOTE: 
    # - XとYについての距離の最大値を取る
    # - 項事に考える
    #   - a = abs(c_x1 - c_x2) : 2つのbboxの中心点の距離
    #   - b = (w1 + w2)/2 : 2つのbboxの平均幅
    #   - c = a - b : 2つのbboxのサイズを加味した距離（同じ中心点の距離でも、小さいbbox程離れて、多いbbox程近くなる）
    return max(abs(c_x1 - c_x2) - (w1 + w2)/2, abs(c_y1 - c_y2) - (h1 + h2)/2)

def merge_contours(contour1, contour2):
    return numpy.concatenate((contour1, contour2), axis=0)

def agglomerative_cluster(contours, threshold_distance=40.0):
    current_contours = contours
    while len(current_contours) > 1:
        min_distance = None
        min_coordinate = None

        for x in range(len(current_contours)-1):
            for y in range(x+1, len(current_contours)):
                distance = calculate_contour_distance(current_contours[x], current_contours[y])
                if min_distance is None:
                    min_distance = distance
                    min_coordinate = (x, y)
                elif distance < min_distance:
                    min_distance = distance
                    min_coordinate = (x, y)

        if min_distance < threshold_distance:
            index1, index2 = min_coordinate
            current_contours[index1] = merge_contours(current_contours[index1], current_contours[index2])
            del current_contours[index2]
        else: 
            break

    return current_contours

 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

import cv2
import numpy as np
import matplotlib.pyplot as plt

image_path = "test.png"
image = cv2.imread(image_path, cv2.IMREAD_GRAYSCALE)
# image = np.random.randint(0, 256, (100, 100), dtype=np.uint8)

gray_image = cv2.cvtColor(cv2.cvtColor(image, cv2.COLOR_GRAY2BGR), cv2.COLOR_BGR2GRAY)

histogram = cv2.calcHist([gray_image], [0], None, [256], [0, 256])

_, otsu_thresh = cv2.threshold(gray_image, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)

adaptive_mean = cv2.adaptiveThreshold(gray_image, 255, cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)

adaptive_gaussian = cv2.adaptiveThreshold(gray_image, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2)

fig_adjusted, axes_adjusted = plt.subplots(6, 5, figsize=(20, 24))

for i, ax in enumerate(axes_adjusted.flatten()[:25]):
    _, thresh_image = cv2.threshold(gray_image, i * 10, 255, cv2.THRESH_BINARY)
    ax.imshow(thresh_image, cmap='gray', vmin=0, vmax=255)
    ax.set_title(f'Threshold = {i * 10}')
    ax.axis('off')

ax_hist_adjusted = plt.subplot2grid((6, 5), (5, 0), colspan=3, fig=fig_adjusted)
ax_hist_adjusted.plot(histogram)
ax_hist_adjusted.set_title('Grayscale Histogram')
ax_hist_adjusted.set_xlabel('Pixel value')
ax_hist_adjusted.set_ylabel('Frequency')

ax_otsu_adjusted = plt.subplot2grid((6, 5), (5, 3), fig=fig_adjusted)
ax_otsu_adjusted.imshow(otsu_thresh, cmap='gray')
ax_otsu_adjusted.set_title('Otsu Thresholding')
ax_otsu_adjusted.axis('off')

ax_adaptive_mean_adjusted = plt.subplot2grid((6, 5), (5, 4), fig=fig_adjusted)
ax_adaptive_mean_adjusted.imshow(adaptive_mean, cmap='gray')
ax_adaptive_mean_adjusted.set_title('Adaptive Mean Thresholding')
ax_adaptive_mean_adjusted.axis('off')

plt.tight_layout()
fig_adjusted.savefig('binarization.png')