个人中心
文章发布
退出
作者热门文章
- ubuntu12.04环境下使用kvm ioctl接口实现最简单的虚拟机
- Ubuntu 通过无线网络安装Ubuntu Server启动系统后连接无线网络的方法
- 在Ubuntu上搭建网桥的方法
- ubuntu 虚拟机上网方式及相关配置详解
40
4
CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.
这篇CFSDN的博客文章opencv python简易文档之图像处理算法由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.
上一篇已经给大家介绍了opencv python图片基本操作的相关内容，这里继续介绍图像处理算法，下面来一起看看吧 。
|
1
2
3
4
5
|
import
cv2
#opencv读取的格式是bgr
img
=
cv2.imread(
'cat.jpg'
)
# 将图片转为灰度图像操作
img_gray
=
cv2.cvtcolor(img,cv2.color_bgr2gray)
img_gray.shape
|
h - 色调（主波长）.
s - 饱和度（纯度/颜色的阴影）.
v值（强度） 。
|
1
2
3
4
5
|
import
cv2
hsv
=
cv2.cvtcolor(img,cv2.color_bgr2hsv)
cv2.imshow(
"hsv"
, hsv)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
ret, dst = cv2.threshold(src, thresh, maxval, type) 。
src： 输入图，只能输入单通道图像，通常来说为灰度图 。
dst： 输出图 。
thresh： 阈值 。
maxval： 当像素值超过了阈值（或者小于阈值，根据type来决定），所赋予的值 。
type：二值化操作的类型，包含以下5种类型： cv2.thresh_binary； cv2.thresh_binary_inv； cv2.thresh_trunc； cv2.thresh_tozero；cv2.thresh_tozero_inv 。
cv2.thresh_binary 超过阈值部分取maxval（最大值），否则取0 。
cv2.thresh_binary_inv thresh_binary的反转 。
cv2.thresh_trunc 大于阈值部分设为阈值，否则不变 。
cv2.thresh_tozero 大于阈值部分不改变，否则设为0 。
cv2.thresh_tozero_inv thresh_tozero的反转 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
ret, thresh1
=
cv2.threshold(img_gray,
127
,
255
, cv2.thresh_binary)
ret, thresh2
=
cv2.threshold(img_gray,
127
,
255
, cv2.thresh_binary_inv)
ret, thresh3
=
cv2.threshold(img_gray,
127
,
255
, cv2.thresh_trunc)
ret, thresh4
=
cv2.threshold(img_gray,
127
,
255
, cv2.thresh_tozero)
ret, thresh5
=
cv2.threshold(img_gray,
127
,
255
, cv2.thresh_tozero_inv)
titles
=
[
'original image'
,
'binary'
,
'binary_inv'
,
'trunc'
,
'tozero'
,
'tozero_inv'
]
images
=
[img, thresh1, thresh2, thresh3, thresh4, thresh5]
for
i
in
range
(
6
):
plt.subplot(
2
,
3
, i
+
1
), plt.imshow(images[i],
'gray'
)
plt.title(titles[i])
plt.xticks([]), plt.yticks([])
plt.show()
|
使用均值滤波实现图像平滑 。
|
1
2
3
4
5
6
7
8
|
# 均值滤波
# 简单的平均卷积操作
# 使用3*3的卷积和
blur
=
cv2.blur(img, (
3
,
3
))
cv2.imshow(
'blur'
, blur)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
使用方框滤波实现图像平滑:
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
|
# 方框滤波
# 基本和均值一样，可以选择归一化
box
=
cv2.boxfilter(img,
-
1
,(
3
,
3
), normalize
=
true)
cv2.imshow(
'box'
, box)
cv2.waitkey(
0
)
cv2.destroyallwindows()
# 方框滤波
# 基本和均值一样，可以选择归一化,容易越界，越界后值为255
box
=
cv2.boxfilter(img,
-
1
,(
3
,
3
), normalize
=
false)
cv2.imshow(
'box'
, box)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
使用高斯滤波实现图像平滑:
|
1
2
3
4
5
6
7
|
# 高斯滤波
# 高斯模糊的卷积核里的数值是满足高斯分布，相当于更重视距离
aussian
=
cv2.gaussianblur(img, (
5
,
5
),
1
)
cv2.imshow(
'aussian'
, aussian)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
使用中值滤波实现图像平滑:
|
1
2
3
4
5
6
7
|
# 中值滤波
# 相当于用中值代替
median
=
cv2.medianblur(img,
5
)
# 中值滤波
cv2.imshow(
'median'
, median)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
使用np将所有处理图片拼接显示
|
1
2
3
4
5
6
|
# 展示所有的
res
=
np.hstack((blur,aussian,median))
#print (res)
cv2.imshow(
'median vs average'
, res)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
腐蚀操作可以用于去除图像中的毛刺 。
|
1
2
3
4
5
6
7
|
# iterations为腐蚀操作的迭代次数
kernel
=
np.ones((
3
,
3
),np.uint8)
erosion
=
cv2.erode(img,kernel,iterations
=
1
)
cv2.imshow(
'erosion'
, erosion)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
膨胀操作通常与腐蚀操作配合使用 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
# 先对图像进行腐蚀操作去除干扰信息
# kernel 为卷积核大小
kernel
=
np.ones((
3
,
3
),np.uint8)
dige_erosion
=
cv2.erode(img,kernel,iterations
=
1
)
cv2.imshow(
'erosion'
, erosion)
cv2.waitkey(
0
)
cv2.destroyallwindows()
# 对图像进行膨胀操作将干扰信息以外的腐蚀部分复原
kernel
=
np.ones((
3
,
3
),np.uint8)
dige_dilate
=
cv2.dilate(dige_erosion,kernel,iterations
=
1
)
cv2.imshow(
'dilate'
, dige_dilate)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
开运算：先腐蚀，再膨胀 。
闭运算：先膨胀，再腐蚀 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
# 开：先腐蚀，再膨胀
img
=
cv2.imread(
'dige.png'
)
kernel
=
np.ones((
5
,
5
),np.uint8)
opening
=
cv2.morphologyex(img, cv2.morph_open, kernel)
cv2.imshow(
'opening'
, opening)
cv2.waitkey(
0
)
cv2.destroyallwindows()
# 闭：先膨胀，再腐蚀
img
=
cv2.imread(
'dige.png'
)
kernel
=
np.ones((
5
,
5
),np.uint8)
closing
=
cv2.morphologyex(img, cv2.morph_close, kernel)
cv2.imshow(
'closing'
, closing)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
提取图片边缘信息 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
|
# 梯度=膨胀-腐蚀
pie
=
cv2.imread(
'pie.png'
)
kernel
=
np.ones((
7
,
7
),np.uint8)
dilate
=
cv2.dilate(pie,kernel,iterations
=
5
)
erosion
=
cv2.erode(pie,kernel,iterations
=
5
)
res
=
np.hstack((dilate,erosion))
cv2.imshow(
'res'
, res)
cv2.waitkey(
0
)
cv2.destroyallwindows()
gradient
=
cv2.morphologyex(pie, cv2.morph_gradient, kernel)
cv2.imshow(
'gradient'
, gradient)
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
礼帽 = 原始输入-开运算结果 。
黑帽 = 闭运算-原始输入 。
|
1
2
3
4
5
6
7
8
9
10
11
12
|
#礼帽
img
=
cv2.imread(
'dige.png'
)
tophat
=
cv2.morphologyex(img, cv2.morph_tophat, kernel)
cv2.imshow(
'tophat'
, tophat)
cv2.waitkey(
0
)
cv2.destroyallwindows()
#黑帽
img
=
cv2.imread(
'dige.png'
)
blackhat
=
cv2.morphologyex(img,cv2.morph_blackhat, kernel)
cv2.imshow(
'blackhat '
, blackhat )
cv2.waitkey(
0
)
cv2.destroyallwindows()
|
通过像素差异提取图片边缘 。
sobel算子 。
scharr算子 。
laplacian算子 。
对于梯度更敏感 。
检测图像像素梯度变换gx为水平梯度检测，gy为垂直梯度检测。gx与gy相当于前面提到的卷积和.
|
1
2
3
4
5
|
dst
=
cv2.sobel(src, ddepth, dx, dy, ksize)
# ddepth:图像的深度
# dx和dy分别表示水平和竖直方向
# ksize是sobel算子的大小
# 在opencv中像素小于0的点直接被认为是0
|
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
# 计算gx
sobelx
=
cv2.sobel(img,cv2.cv_64f,
1
,
0
,ksize
=
3
)
# 将负数部分转为正数
sobelx
=
cv2.convertscaleabs(sobelx)
cv_show(sobelx,
'sobelx'
)
# 计算gy
sobelx
=
cv2.sobel(img,cv2.cv_64f,
0
,
1
,ksize
=
3
)
# 将负数部分转为正数
sobelx
=
cv2.convertscaleabs(sobelx)
cv_show(sobelx,
'sobelx'
)
# 计算gx与gy的加和
sobelxy
=
cv2.addweighted(sobelx,
0.5
,sobely,
0.5
,
0
)
cv_show(sobelxy,
'sobelxy'
)
|
不同算子之间的差异 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
#不同算子的差异
img
=
cv2.imread(
'lena.jpg'
,cv2.imread_grayscale)
sobelx
=
cv2.sobel(img,cv2.cv_64f,
1
,
0
,ksize
=
3
)
sobely
=
cv2.sobel(img,cv2.cv_64f,
0
,
1
,ksize
=
3
)
sobelx
=
cv2.convertscaleabs(sobelx)
sobely
=
cv2.convertscaleabs(sobely)
sobelxy
=
cv2.addweighted(sobelx,
0.5
,sobely,
0.5
,
0
)
scharrx
=
cv2.scharr(img,cv2.cv_64f,
1
,
0
)
scharry
=
cv2.scharr(img,cv2.cv_64f,
0
,
1
)
scharrx
=
cv2.convertscaleabs(scharrx)
scharry
=
cv2.convertscaleabs(scharry)
scharrxy
=
cv2.addweighted(scharrx,
0.5
,scharry,
0.5
,
0
)
laplacian
=
cv2.laplacian(img,cv2.cv_64f)
laplacian
=
cv2.convertscaleabs(laplacian)
res
=
np.hstack((sobelxy,scharrxy,laplacian))
cv_show(res,
'res'
)
|
使用高斯滤波器，以平滑图像，滤除噪声.
计算图像中每个像素点的梯度强度和方向.
应用非极大值（non-maximum suppression）抑制，以消除边缘检测带来的杂散响应.
应用双阈值（double-threshold）检测来确定真实的和潜在的边缘.
通过抑制孤立的弱边缘最终完成边缘检测.
1:高斯滤波器 。
卷积核为符合高斯分布的数据，主要将图像平滑.
2:梯度和方向 。
3：非极大值抑制 。
4：双阈值检测 。
|
1
2
3
4
5
6
7
|
img
=
cv2.imread(
"lena.jpg"
,cv2.imread_grayscale)
v1
=
cv2.canny(img,
80
,
150
)
v2
=
cv2.canny(img,
50
,
100
)
res
=
np.hstack((v1,v2))
cv_show(res,
'res'
)
|
高斯金字塔 。
拉普拉斯金字塔 。
主要用于特征提取 。
高斯金字塔：向下采样方法（缩小） 。
高斯金字塔：向上采样方法（放大） 。
|
1
2
3
4
|
# 向上变换
up
=
cv2.pyrup(img)
# 向下变换
down
=
cv2.pyrdown(img)
|
拉普拉斯金字塔 。
|
1
2
3
4
|
down
=
cv2.pyrdown(img)
down_up
=
cv2.pyrup(down)
l_1
=
img
-
down_up
cv_show(l_1,
'l_1'
)
|
cv2.findcontours(img,mode,method) 。
mode:轮廓检索模式 。
retr_external ：只检索最外面的轮廓； 。
retr_list：检索所有的轮廓，并将其保存到一条链表当中； 。
retr_ccomp：检索所有的轮廓，并将他们组织为两层：顶层是各部分的外部边界，第二层是空洞的边界,
retr_tree：检索所有的轮廓，并重构嵌套轮廓的整个层次,
method:轮廓逼近方法 。
chain_approx_none：以freeman链码的方式输出轮廓，所有其他方法输出多边形（顶点的序列）.
chain_approx_simple:压缩水平的、垂直的和斜的部分，也就是，函数只保留他们的终点部分.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
img
=
cv2.imread(
'contours.png'
)
gray
=
cv2.cvtcolor(img, cv2.color_bgr2gray)
ret, thresh
=
cv2.threshold(gray,
127
,
255
, cv2.thresh_binary)
cv_show(thresh,
'thresh'
)
# 提取轮廓
binary, contours, hierarchy
=
cv2.findcontours(thresh, cv2.retr_tree, cv2.chain_approx_none)
# 绘制轮廓
#传入绘制图像，轮廓，轮廓索引，颜色模式，线条厚度
# 注意需要copy,要不原图会变。。。
draw_img
=
img.copy()
res
=
cv2.drawcontours(draw_img, contours,
-
1
, (
0
,
0
,
255
),
2
)
cv_show(res,
'res'
)
|
轮廓特征 。
|
1
2
3
4
5
6
|
# 选取轮廓 0表示第一个轮廓
cnt
=
contours[
0
]
#面积
cv2.contourarea(cnt)
#周长，true表示闭合的
cv2.arclength(cnt,true)
|
轮廓近似 。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
epsilon
=
0.15
*
cv2.arclength(cnt,true)
approx
=
cv2.approxpolydp(cnt,epsilon,true)
draw_img
=
img.copy()
res
=
cv2.drawcontours(draw_img, [approx],
-
1
, (
0
,
0
,
255
),
2
)
cv_show(res,
'res'
)
# 外接矩形
img
=
cv2.imread(
'contours.png'
)
gray
=
cv2.cvtcolor(img, cv2.color_bgr2gray)
ret, thresh
=
cv2.threshold(gray,
127
,
255
, cv2.thresh_binary)
binary, contours, hierarchy
=
cv2.findcontours(thresh, cv2.retr_tree, cv2.chain_approx_none)
cnt
=
contours[
0
]
x,y,w,h
=
cv2.boundingrect(cnt)
img
=
cv2.rectangle(img,(x,y),(x
+
w,y
+
h),(
0
,
255
,
0
),
2
)
cv_show(img,
'img'
)
# 外接圆
(x,y),radius
=
cv2.minenclosingcircle(cnt)
center
=
(
int
(x),
int
(y))
radius
=
int
(radius)
img
=
cv2.circle(img,center,radius,(
0
,
255
,
0
),
2
)
cv_show(img,
'img'
)
|
用于统计图片像素值分布,x轴表示像素值（0-255），y轴表示该像素值对应个数.
cv2.calchist(images,channels,mask,histsize,ranges) 。
images: 原图像图像格式为 uint8 或 float32。当传入函数时应 用中括号 [] 括来例如[img] 。
channels: 同样用中括号括来它会告函数我们统幅图 像的直方图。如果入图像是灰度图它的值就是 [0]如果是彩色图像 的传入的参数可以是 [0][1][2] 它们分别对应着 bgr.
mask: 掩模图像。统整幅图像的直方图就把它为 none。但是如 果你想统图像某一分的直方图的你就制作一个掩模图像并 使用它.
histsize:bin 的数目。也应用中括号括来 。
ranges: 像素值范围常为 [0256] 。
|
1
2
3
4
5
6
7
8
9
10
11
|
# 统计灰度图的直方图
img
=
cv2.imread(
'cat.jpg'
,
0
)
#0表示灰度图
hist
=
cv2.calchist([img],[
0
],none,[
256
],[
0
,
256
])
hist.shape
# 统计三通道直方图
img
=
cv2.imread(
'cat.jpg'
)
color
=
(
'b'
,
'g'
,
'r'
)
for
i,col
in
enumerate
(color):
histr
=
cv2.calchist([img],[i],none,[
256
],[
0
,
256
])
plt.plot(histr,color
=
col)
plt.xlim([
0
,
256
])
|
mask操作:
|
1
2
3
4
5
6
7
8
9
10
11
|
# 创建mask
mask
=
np.zeros(img.shape[:
2
], np.uint8)
print
(mask.shape)
mask[
100
:
300
,
100
:
400
]
=
255
cv_show(mask,
'mask'
)
# 将mask与图像融合
masked_img
=
cv2.bitwise_and(img, img, mask
=
mask)
#与操作
cv_show(masked_img,
'masked_img'
)
# 使用mask进行直方图统计与非mask进行直方图统计
hist_full
=
cv2.calchist([img], [
0
], none, [
256
], [
0
,
256
])
hist_mask
=
cv2.calchist([img], [
0
], mask, [
256
], [
0
,
256
])
|
是图像像素分布更加均匀.
|
1
2
3
4
|
# 直方图均衡化
equ
=
cv2.equalizehist(img)
plt.hist(equ.ravel(),
256
)
plt.show()
|
通过将图片划分为局部图片，然后进行直方图均衡化处理.
|
1
|
clahe
=
cv2.createclahe(cliplimit
=
2.0
, tilegridsize
=
(
8
,
8
))
|
时域-》频域 。
傅里叶变换的作用 。
高频：变化剧烈的灰度分量，例如边界 。
低频：变化缓慢的灰度分量，例如一片大海 。
滤波 。
低通滤波器：只保留低频，会使得图像模糊，相当于对于边界的处理.
高通滤波器：只保留高频，会使得图像细节增强，相当于对于非边界的处理.
opencv中主要就是cv2.dft()和cv2.idft()，输入图像需要先转换成np.float32 格式.
得到的结果中频率为0的部分会在左上角，通常要转换到中心位置，可以通过shift变换来实现.
cv2.dft()返回的结果是双通道的（实部，虚部），通常还需要转换成图像格式才能展示（0,255）.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
|
import
numpy as np
import
cv2
from
matplotlib
import
pyplot as plt
img
=
cv2.imread(
'lena.jpg'
,
0
)
img_float32
=
np.float32(img)
dft
=
cv2.dft(img_float32, flags
=
cv2.dft_complex_output)
dft_shift
=
np.fft.fftshift(dft)
# 得到灰度图能表示的形式
magnitude_spectrum
=
20
*
np.log(cv2.magnitude(dft_shift[:,:,
0
],dft_shift[:,:,
1
]))
plt.subplot(
121
),plt.imshow(img, cmap
=
'gray'
)
plt.title(
'input image'
), plt.xticks([]), plt.yticks([])
plt.subplot(
122
),plt.imshow(magnitude_spectrum, cmap
=
'gray'
)
plt.title(
'magnitude spectrum'
), plt.xticks([]), plt.yticks([])
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
|
# 低频滤波
import
numpy as np
import
cv2
from
matplotlib
import
pyplot as plt
img
=
cv2.imread(
'lena.jpg'
,
0
)
img_float32
=
np.float32(img)
dft
=
cv2.dft(img_float32, flags
=
cv2.dft_complex_output)
dft_shift
=
np.fft.fftshift(dft)
rows, cols
=
img.shape
crow, ccol
=
int
(rows
/
2
) ,
int
(cols
/
2
)
# 中心位置
# 低通滤波
mask
=
np.zeros((rows, cols,
2
), np.uint8)
mask[crow
-
30
:crow
+
30
, ccol
-
30
:ccol
+
30
]
=
1
# idft
fshift
=
dft_shift
*
mask
f_ishift
=
np.fft.ifftshift(fshift)
img_back
=
cv2.idft(f_ishift)
img_back
=
cv2.magnitude(img_back[:,:,
0
],img_back[:,:,
1
])
plt.subplot(
121
),plt.imshow(img, cmap
=
'gray'
)
plt.title(
'input image'
), plt.xticks([]), plt.yticks([])
plt.subplot(
122
),plt.imshow(img_back, cmap
=
'gray'
)
plt.title(
'result'
), plt.xticks([]), plt.yticks([])
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
|
# 高频滤波
img
=
cv2.imread(
'lena.jpg'
,
0
)
img_float32
=
np.float32(img)
dft
=
cv2.dft(img_float32, flags
=
cv2.dft_complex_output)
dft_shift
=
np.fft.fftshift(dft)
rows, cols
=
img.shape
crow, ccol
=
int
(rows
/
2
) ,
int
(cols
/
2
)
# 中心位置
# 高通滤波
mask
=
np.ones((rows, cols,
2
), np.uint8)
mask[crow
-
30
:crow
+
30
, ccol
-
30
:ccol
+
30
]
=
0
# idft
fshift
=
dft_shift
*
mask
f_ishift
=
np.fft.ifftshift(fshift)
img_back
=
cv2.idft(f_ishift)
img_back
=
cv2.magnitude(img_back[:,:,
0
],img_back[:,:,
1
])
plt.subplot(
121
),plt.imshow(img, cmap
=
'gray'
)
plt.title(
'input image'
), plt.xticks([]), plt.yticks([])
plt.subplot(
122
),plt.imshow(img_back, cmap
=
'gray'
)
plt.title(
'result'
), plt.xticks([]), plt.yticks([])
plt.show()
|
结果（高通对非边界值不友好） 。
模板匹配和卷积原理很像，模板在原图像上从原点开始滑动，计算模板与（图像被模板覆盖的地方）的差别程度，这个差别程度的计算方法在opencv里有6种，然后将每次计算的结果放入一个矩阵里，作为结果输出。假如原图形是axb大小，而模板是axb大小，则输出结果的矩阵是(a-a+1)x(b-b+1) 。
|
1
2
3
4
|
# 模板匹配
img
=
cv2.imread(
'lena.jpg'
,
0
)
template
=
cv2.imread(
'face.jpg'
,
0
)
h, w
=
template.shape[:
2
]
|
tm_sqdiff：计算平方不同，计算出来的值越小，越相关 。
tm_ccorr：计算相关性，计算出来的值越大，越相关 。
tm_ccoeff：计算相关系数，计算出来的值越大，越相关 。
tm_sqdiff_normed：计算归一化平方不同，计算出来的值越接近0，越相关 。
tm_ccorr_normed：计算归一化相关性，计算出来的值越接近1，越相关 。
tm_ccoeff_normed：计算归一化相关系数，计算出来的值越接近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
|
methods
=
[
'cv2.tm_ccoeff'
,
'cv2.tm_ccoeff_normed'
,
'cv2.tm_ccorr'
,
'cv2.tm_ccorr_normed'
,
'cv2.tm_sqdiff'
,
'cv2.tm_sqdiff_normed'
]
for
meth
in
methods:
img2
=
img.copy()
# 匹配方法的真值
method
=
eval
(meth)
print
(method)
res
=
cv2.matchtemplate(img, template, method)
min_val, max_val, min_loc, max_loc
=
cv2.minmaxloc(res)
# 如果是平方差匹配tm_sqdiff或归一化平方差匹配tm_sqdiff_normed，取最小值
if
method
in
[cv2.tm_sqdiff, cv2.tm_sqdiff_normed]:
top_left
=
min_loc
else
:
top_left
=
max_loc
bottom_right
=
(top_left[
0
]
+
w, top_left[
1
]
+
h)
# 画矩形
cv2.rectangle(img2, top_left, bottom_right,
255
,
2
)
plt.subplot(
121
), plt.imshow(res, cmap
=
'gray'
)
plt.xticks([]), plt.yticks([])
# 隐藏坐标轴
plt.subplot(
122
), plt.imshow(img2, cmap
=
'gray'
)
plt.xticks([]), plt.yticks([])
plt.suptitle(meth)
plt.show()
|
到此这篇关于opencv python简易文档之图像处理算法的文章就介绍到这了,更多相关opencv python图像处理算法内容请搜索我以前的文章或继续浏览下面的相关文章希望大家以后多多支持我！ 。
原文链接：https://blog.csdn.net/Kyrie6c/article/details/119545926 。
最后此篇关于opencv python简易文档之图像处理算法的文章就讲到这里了,如果你想了解更多关于opencv python简易文档之图像处理算法的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。
40
4
0
我正在处理一组标记为 160 个组的 173k 点。我想通过合并最接近的(到 9 或 10 个组)来减少组/集群的数量。我搜索过 sklearn 或类似的库，但没有成功。 我猜它只是通过 knn 聚类
我有一个扁平数字列表，这些数字逻辑上以 3 为一组，其中每个三元组是 (number, __ignored, flag[0 or 1])，例如: [7,56,1, 8,0,0, 2,0,0, 6,1,
我正在使用 pipenv 来管理我的包。我想编写一个 python 脚本来调用另一个使用不同虚拟环境(VE)的 python 脚本。 如何运行使用 VE1 的 python 脚本 1 并调用另一个 p
假设我有一个文件 script.py 位于 path = "foo/bar/script.py"。我正在寻找一种在 Python 中通过函数 execute_script() 从我的主要 Python
这听起来像是谜语或笑话，但实际上我还没有找到这个问题的答案。 问题到底是什么？ 我想运行 2 个脚本。在第一个脚本中，我调用另一个脚本，但我希望它们继续并行，而不是在两个单独的线程中。主要是我不希望第
我有一个带有 python 2.5.5 的软件。我想发送一个命令，该命令将在 python 2.7.5 中启动一个脚本，然后继续执行该脚本。 我试过用 #!python2.7.5 和http://re
我在 python 命令行(使用 python 2.7)中，并尝试运行 Python 脚本。我的操作系统是 Windows 7。我已将我的目录设置为包含我所有脚本的文件夹，使用: os.chdir("
剧透:部分解决(见最后)。 以下是使用 Python 嵌入的代码示例: #include int main(int argc, char** argv) { Py_SetPythonHome
假设我有以下列表，对应于及时的股票价格: prices = [1, 3, 7, 10, 9, 8, 5, 3, 6, 8, 12, 9, 6, 10, 13, 8, 4, 11] 我想确定以下总体上最
所以我试图在选择某个单选按钮时更改此框架的背景。 我的框架位于一个类中，并且单选按钮的功能位于该类之外。 (这样我就可以在所有其他框架上调用它们。) 问题是每当我选择单选按钮时都会出现以下错误: co
我正在尝试将字符串与 python 中的正则表达式进行比较，如下所示， #!/usr/bin/env python3 import re str1 = "Expecting property name
考虑以下原型(prototype) Boost.Python 模块，该模块从单独的 C++ 头文件中引入类“D”。 /* file: a/b.cpp */ BOOST_PYTHON_MODULE(c)
如何编写一个程序来“识别函数调用的行号？” python 检查模块提供了定位行号的选项，但是， def di(): return inspect.currentframe().f_back.f_l
我已经使用 macports 安装了 Python 2.7，并且由于我的 $PATH 变量，这就是我输入 $ python 时得到的变量。然而，virtualenv 默认使用 Python 2.6，除
我只想问如何加快 python 上的 re.search 速度。 我有一个很长的字符串行，长度为 176861(即带有一些符号的字母数字字符)，我使用此函数测试了该行以进行研究: def getExe
list1= [u'%app%%General%%Council%', u'%people%', u'%people%%Regional%%Council%%Mandate%', u'%ppp%%Ge
这个问题在这里已经有了答案: Is it Pythonic to use list comprehensions for just side effects? (7 个答案) 关闭 4 个月前。 告
我想用 Python 将两个列表组合成一个列表，方法如下: a = [1,1,1,2,2,2,3,3,3,3] b= ["Sun", "is", "bright", "June","and" ,"Ju
我正在运行带有最新 Boost 发行版 (1.55.0) 的 Mac OS X 10.8.4 (Darwin 12.4.0)。我正在按照说明 here构建包含在我的发行版中的教程 Boost-Pyth
学习 Python，我正在尝试制作一个没有任何第 3 方库的网络抓取工具，这样过程对我来说并没有简化，而且我知道我在做什么。我浏览了一些在线资源，但所有这些都让我对某些事情感到困惑。 html 看起来
我是一名优秀的程序员,十分优秀！