数字图像处理课设

sterne 发布于

数字图像的课设部分代码吧算是，用来往word报告里复制粘贴的

1

1.1图像显示

1
2
3
4
5
6
7
import cv2
from im.to_label import to_label

def im_show(label,path):
    img = cv2.imread(path)

    to_label(label,img)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
# to_label是一个输出图像到qt界面label的函数，多次使用，后面不再描述
import cv2
from PyQt5.QtGui import QImage, QPixmap
from PyQt5 import QtCore


def to_label(label,nimg):
    # 显示到label
    height, width, channel = nimg.shape
    bytesPerLine = 3 * width
    cv2.cvtColor(nimg, cv2.COLOR_BGR2RGB, nimg)
    # print(img.data)
    QImg = QImage(nimg.data, width, height, bytesPerLine, QImage.Format_RGB888)
    pixmap = QPixmap.fromImage(QImg)
    label.setGeometry(QtCore.QRect(10, 10, width, height))
    label.setPixmap(pixmap)

2图像属性

1
2
3
def im_properties(path):
    img = cv2.imread(path)
    return path, img.shape, img.size, img.dtype

3图像灰度化

1
2
3
4
5
6
7
8
9
10
11
import cv2
from im.save_file import save_file
from im.to_label import to_label_gray


def im_graying(label,path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    to_label_gray(label,img)
    return save_file(img,path,'graying')
1
2
3
4
5
6
7
8
9
10
11
# to_label_gray是一个输出灰度图像到qt界面label的函数，多次使用，后面不再描述
def to_label_gray(label,nimg):
    # 显示到label
    height, width = nimg.shape
    # bytesPerComponent = 1
    bytesPerLine = width
    # cv2.cvtColor(img, cv2.COLOR_GRAY2RGB, img)
    QImg = QImage(nimg.data, width, height, bytesPerLine, QImage.Format_Grayscale8)
    pixmap = QPixmap.fromImage(QImg)
    label.setGeometry(QtCore.QRect(10, 10, width, height))
    label.setPixmap(pixmap)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# save_file函数，根据操作名称添加一个后缀并保存
import cv2
import os


def save_file(nimg, path, sub_name):
    # 根据路径读图片名称
    full_name = path[path.rfind('\\') + 1:]
    name = full_name[0:full_name.find('.')]
    suffix = full_name[full_name.rfind('.'):]
    # 名称格式：图像原名+操作名sub_name+格式
    path = os.getcwd() + '\\image\\' + name + '_' + sub_name + suffix
    cv2.imwrite(path, nimg)

    return path

2

2.1移动

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
import cv2
import numpy as np

from im.save_file import save_file
from im.to_label import to_label


def im_move(label, path, dx=0, dy=0, expand=0):
    img = cv2.imread(path)

    if expand == 0:
        height, width, channels = img.shape
    else:
        height, width, channels = img.shape
        height = height + dy
        width = width + dx

    nimg = np.ones((height, width, channels), np.uint8) * 255
    for ni in range(width):
        for nj in range(height):
            i = ni - dx
            j = nj - dy
            if 0 <= i < width and 0 <= j < height:
                nimg[nj, ni] = img[j, i]  # ?坐标

    path = save_file(nimg,path,'moved')

    to_label(label,nimg)

    return path

2.2缩小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# qt窗口中判断使用放大/缩小的方法
    def accept(self):
        x = float(self.lineEdit.text())
        y = float(self.lineEdit_2.text())
        # 处理不合法数值（非负）
        if x >= 0 and y >= 0:
            if x >= 100 and y >= 100:
                expand = 1  # 放大
                self.signal_re.emit(x, y, expand)
                self.close()
            elif x <= 100 and y <= 100:
                expand = 0  # 缩小or不变
                self.signal_re.emit(x, y, expand)
                self.close()
            else:
                QMessageBox.warning(QWidget(), 'warning', '不支持同时放大和缩小...')
        else:
            QMessageBox.warning(QWidget(), 'warning', '数值不合法！')

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
import numpy as np

from im.save_file import save_file
from im.to_label import to_label


# kx ky缩放倍数
def im_shrink(label, path, kx, ky):
    img = cv2.imread(path)
    height, width, channels = img.shape
    kx = float(kx / 100)
    ky = float(ky / 100)
    x = round(width * kx)
    y = round(height * ky)
    nimg = np.zeros((y, x, channels), np.uint8)

    for ni in range(x):
        for nj in range(y):
            i = round(ni * float(1 / kx))
            j = round(nj * float(1 / ky))
            nimg[nj, ni] = img[j, i]

    path = save_file(nimg,path,'shrink')

    to_label(nimg,label)

    # 当前的属性要变化
    return path

2.3放大

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
import cv2
import numpy as np

from im.save_file import save_file
from im.to_label import to_label

def im_magnify(label, path, kx, ky):
    img = cv2.imread(path)
    height, width, channels = img.shape
    kx = float(kx / 100)
    ky = float(ky / 100)
    x = round(width * kx)
    y = round(height * ky)
    nimg = np.zeros((y, x, channels), np.uint8)

    temp = np.zeros((height, width), list)  # 存第一次被赋值的点坐标
    ttemp = np.zeros((y, x), int)  # 存新图中这个点是否访问
    lastx = -1
    # 划分子块
    for ni in range(x):
        lasty = -1
        for nj in range(y):
            i = round(ni / kx)
            j = round(nj / ky)
            if i >= width: i = width - 1
            if j >= height: j = height - 1
            # 不是最后一行、最后一列
            if i != width - 1 and j != height - 1:
                # 都是左上角的，是ij的第一次变化
                if temp[j, i] == 0:
                    nimg[nj, ni] = img[j, i]
                    temp[j, i] = [nj, ni]
                    ttemp[nj, ni] = 1
            else:
                # 最后一行而非最后一列
                if i == width - 1 and j != height - 1 \
                        and ni == x - 1 and nj != y - 1:
                    if lasty != j:
                        nimg[nj, ni] = img[j, i]
                        lasty = j
                        temp[j, i] = [nj, ni]
                        ttemp[nj, ni] = 1

                # 最后一列而非最后一行
                if i != width - 1 and j == height - 1 \
                        and ni != x - 1 and nj == y - 1:
                    if lastx != i:
                        nimg[nj, ni] = img[j, i]
                        lastx = i
                        temp[j, i] = [nj, ni]
                        ttemp[nj, ni] = 1

                # 最后一个像素
                if i == width - 1 and j == height - 1 \
                        and ni == x - 1 and nj == y - 1:
                    nimg[nj, ni] = img[j, i]
                    temp[j, i] = [nj, ni]
                    ttemp[nj, ni] = 1

    # 所有填充像素所在列
    for ni in range(x):
        if ttemp[0, ni] != 0:
            for nj in range(y):
                if ttemp[nj, ni] == 0:
                    if nj == 2 and ni == 94:
                        print('check')
                    ttemp[nj, ni] = 1
                    i = round(ni / kx)
                    j = round(nj / ky)
                    if i >= width: i = width - 1
                    if j >= height: j = height - 1
                    if j != height - 1:
                        a = temp[j, i]
                        b = temp[j + 1, i]
                    else:
                        a = temp[j - 1, i]
                        b = temp[j, i]
                    k = float((nj - a[0] + 1) / (b[0] - a[0] + 1))
                    nimg[nj, ni] = (1 - k) * nimg[a[0], a[1]] + k * (nimg[b[0], b[1]])

    # 行
    for nj in range(y):
        for ni in range(x):
            if ttemp[nj, ni] == 0:
                ttemp[nj, ni] = 1
                i = round(ni / kx)
                j = round(nj / ky)
                if i >= width: i = width - 1
                if j >= height: j = height - 1
                if i != width - 1:
                    a = temp[j, i]
                    b = temp[j, i + 1]
                else:
                    a = temp[j, i - 1]
                    b = temp[j, i]
                k = float((ni - a[1] + 1) / (b[1] - a[1] + 1))
                nimg[nj, ni] = (1 - k) * nimg[a[0], a[1]] + k * nimg[b[0], b[1]]

    path = save_file(nimg,path,'magnify')

    to_label(label,nimg)

    # 当前的属性要变化
    return path

3

3.1灰度直方图

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
import matplotlib.pyplot as plt
import cv2
import os

import numpy as np

from im.to_label import to_label


def im_histogram_gray(label, path, suffix_name=''):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    img_b = cv2.calcHist([img], [0], None, [256], [0, 255])  # B分量灰度图的直方图

    plt.clf()
    x = np.arange(256)
    img_his = img_b.flatten()
    plt.bar(x, img_his)

    full_name = path[path.rfind('\\') + 1:]
    name = full_name[0:full_name.find('.')]
    suffix = full_name[full_name.rfind('.'):]
    npath = os.getcwd() + '\\image\\' + name + suffix_name + suffix
    plt.savefig(npath)

    # 读灰度直方图
    nimg = cv2.imread(npath)
    to_label(label,nimg)

    return path

3.2均衡化

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

from im.save_file import save_file
from im.to_label import to_label_gray


def im_equalize(label, path):
    img = cv2.imread(path)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 必须要是灰度才能均衡化
    nimg = cv2.equalizeHist(gray)

    to_label_gray(label,nimg)

    return save_file(nimg,path,'equalize')

4

椒盐噪声

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import cv2
import numpy as np
from im.save_file import save_file
from im.to_label import to_label

def im_saltnoise(label, path, n=2000):
    img = cv2.imread(path)

    height, width, channel = img.shape

    for i in range(n):
        x = np.random.randint(1, width)
        y = np.random.randint(1, height)
        if np.random.randint(0, 2) == 0:
            img[x, y] = 0
        else:
            img[x, y] = 255

    path = save_file(img,path,'saltnoise')
    to_label(label,img)

    return path

高斯噪声

1
2
3
4
5
6
7
8
9
10
11
12
13
14
def im_gaussnoise(label, path, mu=0, sigma=0.1):
    img = cv2.imread(path)

    img = np.array(img / 255, float)
    noise = np.random.normal(mu, sigma, img.shape)
    img = img + noise

    nimg = np.clip(img,-1.0,1.0) 
    nimg = abs(nimg*255).astype(np.uint8)

    path = save_file(nimg,path,'gaussnoise')
    to_label(label,nimg)

    return path

均值滤波

1
2
3
4
5
6
7
8
def im_meanfilter(label, path):
    img = cv2.imread(path)
    nimg = cv2.blur(img, (3, 3))

    path = save_file(nimg, path, 'meanfiltering')
    to_label(label,nimg)
    
    return path

中值滤波

1
2
3
4
5
6
7
8
def im_medianfilter(label,path):
    img = cv2.imread(path)
    nimg = cv2.medianBlur(img, 3)

    path = save_file(nimg, path, 'medianfiltering')
    to_label(label,nimg)

    return path

高斯滤波

1
2
3
4
5
6
7
8
def im_gaussfilter(label,path):
    img = cv2.imread(path)
    nimg = cv2.GaussianBlur(img, (3,3),2,1)

    path = save_file(nimg, path, 'gaussfiltering')
    to_label(label,nimg)

    return path

5

normal

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import cv2
import numpy as np

from im.save_file import save_file
from im.to_label import to_label_gray


def im_sharpen(label, path):
    img = cv2.imread(path)
    height, width, channels = img.shape
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    nimg = np.zeros((height, width, channels), np.uint8)

    for i in range(width):
        for j in range(height):
            nimg[j, i] = np.sqrt((img[j, i] - img[j, i - 1]) ** 2 + (img[j, i] - img[j - 1, i]) ** 2).astype(np.uint8)

    path = save_file(nimg, path, 'sharpen4')
    to_label_gray(label, nimg)

    return path

roberts

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
def im_sharpen_roberts(label, path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # 2. Roberts算子
    kernelx = np.array([[-1, 0], [0, 1]], dtype=int)
    kernely = np.array([[0, -1], [1, 0]], dtype=int)
    # 3. 卷积操作
    x = cv2.filter2D(nimg, cv2.CV_16S, kernelx)
    y = cv2.filter2D(nimg, cv2.CV_16S, kernely)
    # 4. 数据格式转换 知识盲区
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    nimg = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

    path = save_file(nimg, path, 'sharpenroberts')
    to_label_gray(label, nimg)

    return path

sobel

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def im_sharpen_sobel(label, path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    kernelx = np.array([[-1, -2, -1], [0, 0, 0], [1, 2, 1]], dtype=int)
    kernely = np.array([[1, 0, -1], [2, 0, -2], [1, 0, -1]], dtype=int)
    x = cv2.filter2D(nimg, cv2.CV_16S, kernelx)
    y = cv2.filter2D(nimg, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    nimg = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

    path = save_file(nimg, path, 'sharpensobel')
    to_label_gray(label, nimg)

    return path

prewitt

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
def im_sharpen_prewitt(label, path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    kernelx = np.array([[-1, -1, -1], [0, 0, 0], [1, 1, 1]], dtype=int)
    kernely = np.array([[1, 0, -1], [1, 0, -1], [1, 0, -1]], dtype=int)
    x = cv2.filter2D(nimg, cv2.CV_16S, kernelx)
    y = cv2.filter2D(nimg, cv2.CV_16S, kernely)
    absX = cv2.convertScaleAbs(x)
    absY = cv2.convertScaleAbs(y)
    nimg = cv2.addWeighted(absX, 0.5, absY, 0.5, 0)

    path = save_file(nimg, path, 'sharpenprewitt')
    to_label_gray(label, nimg)

    return path

krisch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
def im_sharpen_krisch(label, path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    height, width, channels = img.shape
    filtered_list = np.zeros((8, height, width))
    kernel = [np.array([[5, 5, 5], [-3, 0, -3], [-3, -3, -3]]), np.array([[-3, 5, 5], [-3, 0, 5], [-3, -3, -3]]),
              np.array([[-3, -3, 5], [-3, 0, 5], [-3, -3, 5]]), np.array([[-3, -3, -3], [-3, 0, 5], [-3, 5, 5]]),
              np.array([[-3, -3, -3], [-3, 0, -3], [5, 5, 5]]), np.array([[-3, -3, -3], [5, 0, -3], [5, 5, -3]]),
              np.array([[5, -3, -3], [5, 0, -3], [5, -3, -3]]), np.array([[5, 5, -3], [5, 0, -3], [-3, -3, -3]])]

    for i in range(8):
        out = cv2.filter2D(nimg, cv2.CV_16S, kernel[i])
        filtered_list[i] = out

    final = np.max(filtered_list, axis=0)  # 取八个方向中的最大值，也就是取第0维的最大值作为图像该点，滤波之后的新的像素值
    final[np.where(final >= 255)] = 255  # 令像素值大于255的点等于255
    final[np.where(final < 255)] = 0  # 令像素值小于255的点等于0
    final = final.astype(np.uint8)

    path = save_file(final, path, 'sharpenkrisch')
    to_label_gray(label, final)

    return path

laplacian

1
2
3
4
5
6
7
8
9
10
def im_sharpen_laplacian(label, path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    nimg = cv2.Laplacian(nimg, cv2.CV_16S, ksize=3)
    nimg = cv2.convertScaleAbs(nimg)

    path = save_file(nimg, path, 'sharpenlaplacian')
    to_label_gray(label, nimg)

    return path

canny

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# Canny算子
# Canny方法不容易受噪声干扰，能够检测到真正的弱边缘。
# 优点在于，使用两种不同的阈值分别检测强边缘和弱边缘，并且当弱边缘和强边缘相连时，才将弱边缘包含在输出图像中。
def im_sharpen_canny(label,path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 高斯滤波降噪
    gaussian = cv2.GaussianBlur(img, (3, 3), 0)
    # Canny算子
    nimg = cv2.Canny(gaussian, 50, 180)

    path = save_file(nimg, path, 'sharpencanny')
    to_label_gray(label, nimg)

    return path

log

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
# LOG算子
# 根据图像的信噪比来求检测边缘的最优滤波器。
# 该算法首先对图像做高斯滤波，然后再求其拉普拉斯（ Laplacian ）二阶导数，
# 根据二阶导数的过零点来检测图像的边界，即通过检测滤波结果的零交叉（ Zero crossings ）来获得图像或物体的边缘。
# LOG 算子实际上是把 Gauss 滤波和 Laplacian 滤波结合了起来，先平滑掉噪声，再进行边缘检测。
# LOG 算子与视觉生理中的数学模型相似，因此在图像处理领域中得到了广泛的应用。
# 它具有抗干扰能力强，边界定位精度高，边缘连续性好，能有效提取对比度弱的边界等特点。
def im_sharpen_log(label,path):
    img = cv2.imread(path)
    nimg = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    # 先通过高斯滤波降噪
    gaussian = cv2.GaussianBlur(nimg, (3, 3), 0)
    # 再通过拉普拉斯算子做边缘检测
    dst = cv2.Laplacian(gaussian, cv2.CV_16S, ksize=3)
    log = cv2.convertScaleAbs(dst)

    path = save_file(log, path, 'sharpenlog')
    to_label_gray(label, log)

    return path

6

固定阈值分割

1
2
3
4
5
6
7
def im_threshold(label, path, ret):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    ret, nimg = cv2.threshold(img, ret, 255, cv2.THRESH_BINARY)

    to_label_gray(label,nimg)
    return save_file(nimg,path,'threshold')

迭代阈值分割

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
def im_threshold_iter(label,path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    iter = img.mean()

    while True:
        t0 = img[img < iter].mean()  # 背景平均灰度值
        t1 = img[img >= iter].mean()  # 前景平均灰度值
        t = (t0 + t1) / 2
        if iter == t:  # 可适当放宽条件， abs(T - t) < 1
            break
        iter = t
    iter = int(iter)
    print(f"Best Threshold = {iter}")
    ret, nimg = cv2.threshold(img, iter, 255, cv2.THRESH_BINARY)

    to_label_gray(label,nimg)
    save_file(nimg, path, 'threiter')
    return iter

空间阈值分割

1
2
3
4
5
6
7
def im_threshold_adapt(label, path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    nimg = cv2.adaptiveThreshold(img, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 9, 4)

    to_label_gray(label,nimg)
    save_file(nimg, path, 'threadapt')

区域生长

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
import cv2
import numpy as np

from im.save_file import save_file
from im.to_label import to_label, to_label_gray


# 求两个点的差值
def getGrayDiff(image, currentPoint, tmpPoint):
    return abs(int(image[currentPoint[0], currentPoint[1]]) - int(image[tmpPoint[0], tmpPoint[1]]))


# 区域生长算法
def regional_growth(gray, seeds, threshold=5):
    # 每次区域生长的时候的像素之间的八个邻接点
    connects = [(-1, -1), (0, -1), (1, -1), (1, 0), (1, 1), (0, 1), (-1, 1), (-1, 0)]
    threshold = threshold  # 生长时候的相似性阈值，默认即灰度级不相差超过15以内的都算为相同
    height, weight = gray.shape
    seedMark = np.zeros(gray.shape)
    seedList = []
    for seed in seeds:
        if gray.shape[0] > seed[0] > 0 and gray.shape[1] > seed[1] > 0:
            seedList.append(seed)  # 将添加到的列表中
    # print(seedList)
    label = 1  # 标记点的flag
    while len(seedList) > 0:  # 如果列表里还存在点
        currentPoint = seedList.pop(0)  # 将最前面的那个抛出
        seedMark[currentPoint[0], currentPoint[1]] = label  # 将对应位置的点标志为1
        for i in range(8):  # 对这个点周围的8个点一次进行相似性判断
            tmpX = currentPoint[0] + connects[i][0]
            tmpY = currentPoint[1] + connects[i][1]
            if tmpX < 0 or tmpY < 0 or tmpX >= height or tmpY >= weight:  # 如果超出限定的阈值范围
                continue  # 跳过并继续
            grayDiff = getGrayDiff(gray, currentPoint, (tmpX, tmpY))  # 计算此点与像素点的灰度级之差
            if grayDiff < threshold and seedMark[tmpX, tmpY] == 0:
                seedMark[tmpX, tmpY] = label
                seedList.append((tmpX, tmpY))
    return seedMark


# 初始种子选择
def originalSeed(gray):
    ret, img1 = cv2.threshold(gray, 127, 255, cv2.THRESH_BINARY)  # 二值图，种子区域(不同划分可获得不同种子)
    retval, labels, stats, centroids = cv2.connectedComponentsWithStats(img1)  # 进行连通域操作，取其质点
    centroids = centroids.astype(int)  # 转化为整数
    # seed = []
    # for i  in range(img1.shape[0]):
    #     for j in range(img1.shape[1]):
    #         if(img1[i,j] == 255):
    #             seed.append([i,j])

    return centroids


def im_seedgrowth(label,path):
    img = cv2.imread(path)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    seed = originalSeed(img)
    nimg = regional_growth(img, seed)
    nimg = nimg.astype(np.uint8)

    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            if nimg[j,i] == 0:
                nimg[j,i] = 255

    to_label_gray(label,nimg)
    save_file(nimg,path,'seedgrowth')

7

erode

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

from im.save_file import save_file
from im.to_label import to_label


def im_erode(label, path):
    img = cv2.imread(path)
    nimg = cv2.erode(img, (3, 3), iterations=1)

    path = save_file(nimg, path, 'erode')
    to_label(label, nimg)
    return path

dilate

1
2
3
4
5
6
7
8
def im_dilate(label, path):
    img = cv2.imread(path)
    nimg = cv2.dilate(img, (3, 3), iterations=1)

    path = save_file(nimg, path, 'erode')
    to_label(label, nimg)
    return path

STERNE

STERNE

SDUer，大一入门，大二入土，大三老东西！

63
1
20
NOTICE

这里还什么都没有呢喵~

CATEGORYS
TAGS
ACM Arc CCPC HPC bot c cpp deeplearning games hexo java maths pyqt python qt recommends review sql srtp test