Python-OpenCV快速教程

import numpy as np
import cv2
import matplotlib.pyplot as plt# 图6-1中的矩阵
img = np.array([
[[255, 0, 0], [0, 255, 0], [0, 0, 255]],
[[255, 255, 0], [255, 0, 255], [0, 255, 255]],
[[255, 255, 255], [128, 128, 128], [0, 0, 0]],
], dtype=np.uint8)# 用matplotlib存储
plt.imsave('img_pyplot.jpg', img)# 用OpenCV存储
cv2.imwrite('img_cv2.jpg', img)

import cv2# 读取一张400x600分辨率的图像
color_img = cv2.imread('test_400x600.jpg')
print(color_img.shape)# 直接读取单通道
gray_img = cv2.imread('test_400x600.jpg', cv2.IMREAD_GRAYSCALE)
print(gray_img.shape)# 把单通道图片保存后，再读取，仍然是3通道，相当于把单通道值复制到3个通道保存
cv2.imwrite('test_grayscale.jpg', gray_img)
reload_grayscale = cv2.imread('test_grayscale.jpg')
print(reload_grayscale.shape)# cv2.IMWRITE_JPEG_QUALITY指定jpg质量，范围0到100，默认95，越高画质越好，文件越大
cv2.imwrite('test_imwrite.jpg', color_img, (cv2.IMWRITE_JPEG_QUALITY, 80))# cv2.IMWRITE_PNG_COMPRESSION指定png质量，范围0到9，默认3，越高文件越小，画质越差
cv2.imwrite('test_imwrite.png', color_img, (cv2.IMWRITE_PNG_COMPRESSION, 5))

import cv2# 读取一张四川大录古藏寨的照片
img = cv2.imread('tiger_tibet_village.jpg')# 缩放成200x200的方形图像
img_200x200 = cv2.resize(img, (, ))# 不直接指定缩放后大小，通过fx和fy指定缩放比例，.5则长宽都为原来一半
# 等效于img_200x300 = cv2.resize(img, (, ))，注意指定大小的格式是(宽度,高度)
# 插值方法默认是cv2.INTER_LINEAR，这里指定为最近邻插值
img_200x300 = cv2.resize(img, (, ), fx=0.5, fy=0.5,
interpolation=cv2.INTER_NEAREST)# 在上张图片的基础上，上下各贴50像素的黑边，生成300x300的图像
img_300x300 = cv2.copyMakeBorder(img, , , , ,
cv2.BORDER_CONSTANT,
value=(, , ))# 对照片中树的部分进行剪裁
patch_tree = img[:, -:-]cv2.imwrite('cropped_tree.jpg', patch_tree)
cv2.imwrite('resized_200x200.jpg', img_200x200)
cv2.imwrite('resized_200x300.jpg', img_200x300)
cv2.imwrite('bordered_300x300.jpg', img_300x300)

# 通过cv2.cvtColor把图像从BGR转换到HSV
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)# H空间中，绿色比黄色的值高一点，所以给每个像素+，黄色的树叶就会变绿
turn_green_hsv = img_hsv.copy()
turn_green_hsv[:, :, ] = (turn_green_hsv[:, :, ]+) %
turn_green_img = cv2.cvtColor(turn_green_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('turn_green.jpg', turn_green_img)# 减小饱和度会让图像损失鲜艳，变得更灰
colorless_hsv = img_hsv.copy()
colorless_hsv[:, :, ] = 0.5 * colorless_hsv[:, :, ]
colorless_img = cv2.cvtColor(colorless_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('colorless.jpg', colorless_img)# 减小明度为原来一半
darker_hsv = img_hsv.copy()
darker_hsv[:, :, ] = 0.5 * darker_hsv[:, :, ]
darker_img = cv2.cvtColor(darker_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('darker.jpg', darker_img)

import numpy as np# 分通道计算每个通道的直方图
hist_b = cv2.calcHist([img], [], None, [], [, ])
hist_g = cv2.calcHist([img], [], None, [], [, ])
hist_r = cv2.calcHist([img], [], None, [], [, ])# 定义Gamma矫正的函数
def gamma_trans(img, gamma):
# 具体做法是先归一化到1，然后gamma作为指数值求出新的像素值再还原
gamma_table = [np.power(x/255.0, gamma)*255.0 for x in range()]
gamma_table = np.round(np.array(gamma_table)).astype(np.uint8) # 实现这个映射用的是OpenCV的查表函数
return cv2.LUT(img, gamma_table)# 执行Gamma矫正，小于1的值让暗部细节大量提升，同时亮部细节少量提升
img_corrected = gamma_trans(img, 0.5)
cv2.imwrite('gamma_corrected.jpg', img_corrected)# 分通道计算Gamma矫正后的直方图
hist_b_corrected = cv2.calcHist([img_corrected], [], None, [], [, ])
hist_g_corrected = cv2.calcHist([img_corrected], [], None, [], [, ])
hist_r_corrected = cv2.calcHist([img_corrected], [], None, [], [, ])# 将直方图进行可视化
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3Dfig = plt.figure()pix_hists = [
[hist_b, hist_g, hist_r],
[hist_b_corrected, hist_g_corrected, hist_r_corrected]
]pix_vals = range()
for sub_plt, pix_hist in zip([, ], pix_hists):
ax = fig.add_subplot(sub_plt, projection='3d')
for c, z, channel_hist in zip(['b', 'g', 'r'], [, , ], pix_hist):
cs = [c] *
ax.bar(pix_vals, channel_hist, zs=z, zdir='y', color=cs, alpha=0.618, edgecolor='none', lw=) ax.set_xlabel('Pixel Values')
ax.set_xlim([, ])
ax.set_ylabel('Channels')
ax.set_zlabel('Counts')plt.show()

import cv2
import numpy as np# 读取一张斯里兰卡拍摄的大象照片
img = cv2.imread('lanka_safari.jpg')# 沿着横纵轴放大1.6倍，然后平移(-,-)，最后沿原图大小截取，等效于裁剪并放大
M_crop_elephant = np.array([
[1.6, , -],
[, 1.6, -]
], dtype=np.float32)img_elephant = cv2.warpAffine(img, M_crop_elephant, (, ))
cv2.imwrite('lanka_elephant.jpg', img_elephant)# x轴的剪切变换，角度15°
theta = * np.pi /
M_shear = np.array([
[, np.tan(theta), ],
[, , ]
], dtype=np.float32)img_sheared = cv2.warpAffine(img, M_shear, (, ))
cv2.imwrite('lanka_safari_sheared.jpg', img_sheared)# 顺时针旋转，角度15°
M_rotate = np.array([
[np.cos(theta), -np.sin(theta), ],
[np.sin(theta), np.cos(theta), ]
], dtype=np.float32)img_rotated = cv2.warpAffine(img, M_rotate, (, ))
cv2.imwrite('lanka_safari_rotated.jpg', img_rotated)# 某种变换，具体旋转+缩放+旋转组合可以通过SVD分解理解
M = np.array([
[, 1.5, -],
[0.5, , -]
], dtype=np.float32)img_transformed = cv2.warpAffine(img, M, (, ))
cv2.imwrite('lanka_safari_transformed.jpg', img_transformed)

import numpy as np
import cv2# 定义一块宽600，高400的画布，初始化为白色
canvas = np.zeros((400, 600, 3), dtype=np.uint8) + 255# 画一条纵向的正中央的黑色分界线
cv2.line(canvas, (300, 0), (300, 399), (0, 0, 0), 2)# 画一条右半部份画面以150为界的横向分界线
cv2.line(canvas, (300, 149), (599, 149), (0, 0, 0), 2)# 左半部分的右下角画个红色的圆
cv2.circle(canvas, (200, 300), 75, (0, 0, 255), 5)# 左半部分的左下角画个蓝色的矩形
cv2.rectangle(canvas, (20, 240), (100, 360), (255, 0, 0), thickness=3)# 定义两个三角形，并执行内部绿色填充
triangles = np.array([
[(200, 240), (145, 333), (255, 333)],
[(60, 180), (20, 237), (100, 237)]])
cv2.fillPoly(canvas, triangles, (0, 255, 0))# 画一个黄色五角星
# 第一步通过旋转角度的办法求出五个顶点
phi = 4 * np.pi / 5
rotations = [[[np.cos(i * phi), -np.sin(i * phi)], [i * np.sin(phi), np.cos(i * phi)]] for i in range(1, 5)]
pentagram = np.array([[[[0, -1]] + [np.dot(m, (0, -1)) for m in rotations]]], dtype=np.float)# 定义缩放倍数和平移向量把五角星画在左半部分画面的上方
pentagram = np.round(pentagram * 80 + np.array([160, 120])).astype(np.int)# 将5个顶点作为多边形顶点连线，得到五角星
cv2.polylines(canvas, pentagram, True, (0, 255, 255), 9)# 按像素为间隔从左至右在画面右半部份的上方画出HSV空间的色调连续变化
for x in range(302, 600):
color_pixel = np.array([[[round(180*float(x-302)/298), 255, 255]]], dtype=np.uint8)
line_color = [int(c) for c in cv2.cvtColor(color_pixel, cv2.COLOR_HSV2BGR)[0][0]]
cv2.line(canvas, (x, 0), (x, 147), line_color)# 如果定义圆的线宽大于半斤，则等效于画圆点，随机在画面右下角的框内生成坐标
np.random.seed(42)
n_pts = 30
pts_x = np.random.randint(310, 590, n_pts)
pts_y = np.random.randint(160, 390, n_pts)
pts = zip(pts_x, pts_y)# 画出每个点，颜色随机
for pt in pts:
pt_color = [int(c) for c in np.random.randint(0, 255, 3)]
cv2.circle(canvas, pt, 3, pt_color, 5)# 在左半部分最上方打印文字
cv2.putText(canvas,
'Python-OpenCV Drawing Example',
(5, 15),
cv2.FONT_HERSHEY_SIMPLEX,
0.5,
(0, 0, 0),
1)cv2.imshow('Example of basic drawing functions', canvas)
cv2.waitKey()

import cv2
import timeinterval = 60 # 捕获图像的间隔，单位：秒
num_frames = 500 # 捕获图像的总帧数
out_fps = 24 # 输出文件的帧率# VideoCapture(0)表示打开默认的相机
cap = cv2.VideoCapture(0)# 获取捕获的分辨率
size =(int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)),
int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)))# 设置要保存视频的编码，分辨率和帧率
video = cv2.VideoWriter(
"time_lapse.avi",
cv2.VideoWriter_fourcc('M','P','4','2'),
out_fps,
size
)# 对于一些低画质的摄像头，前面的帧可能不稳定，略过
for i in range(42):
cap.read()# 开始捕获，通过read()函数获取捕获的帧
try:
for i in range(num_frames):
_, frame = cap.read()
video.write(frame) # 如果希望把每一帧也存成文件，比如制作GIF，则取消下面的注释
# filename = '{:0>6d}.png'.format(i)
# cv2.imwrite(filename, frame) print('Frame {} is captured.'.format(i))
time.sleep(interval)
except KeyboardInterrupt:
# 提前停止捕获
print('Stopped! {}/{} frames captured!'.format(i, num_frames))# 释放资源并写入视频文件
video.release()
cap.release()

import numpy as np
import cv2'''
定义裁剪函数，四个参数分别是：
左上角横坐标x0
左上角纵坐标y0
裁剪宽度w
裁剪高度h
'''
crop_image = lambda img, x0, y0, w, h: img[y0:y0+h, x0:x0+w]'''
随机裁剪
area_ratio为裁剪画面占原画面的比例
hw_vari是扰动占原高宽比的比例范围
'''
def random_crop(img, area_ratio, hw_vari):
h, w = img.shape[:2]
hw_delta = np.random.uniform(-hw_vari, hw_vari)
hw_mult = 1 + hw_delta# 下标进行裁剪，宽高必须是正整数
w_crop = int(round(w*np.sqrt(area_ratio*hw_mult)))# 裁剪宽度不可超过原图可裁剪宽度
if w_crop > w:
w_crop = w h_crop = int(round(h*np.sqrt(area_ratio/hw_mult)))
if h_crop > h:
h_crop = h# 随机生成左上角的位置
x0 = np.random.randint(0, w-w_crop+1)
y0 = np.random.randint(0, h-h_crop+1) return crop_image(img, x0, y0, w_crop, h_crop)'''
定义旋转函数：
angle是逆时针旋转的角度
crop是个布尔值，表明是否要裁剪去除黑边
'''
def rotate_image(img, angle, crop):
h, w = img.shape[:2]# 旋转角度的周期是360°
angle %= 360# 用OpenCV内置函数计算仿射矩阵
M_rotate = cv2.getRotationMatrix2D((w/2, h/2), angle, 1)# 得到旋转后的图像
img_rotated = cv2.warpAffine(img, M_rotate, (w, h))# 如果需要裁剪去除黑边
if crop:
# 对于裁剪角度的等效周期是180°
angle_crop = angle % 180# 并且关于90°对称
if angle_crop > 90:
angle_crop = 180 - angle_crop# 转化角度为弧度
theta = angle_crop * np.pi / 180.0# 计算高宽比
hw_ratio = float(h) / float(w)# 计算裁剪边长系数的分子项
tan_theta = np.tan(theta)
numerator = np.cos(theta) + np.sin(theta) * tan_theta# 计算分母项中和宽高比相关的项
r = hw_ratio if h > w else 1 / hw_ratio# 计算分母项
denominator = r * tan_theta + 1# 计算最终的边长系数
crop_mult = numerator / denominator# 得到裁剪区域
w_crop = int(round(crop_mult*w))
h_crop = int(round(crop_mult*h))
x0 = int((w-w_crop)/2)
y0 = int((h-h_crop)/2) img_rotated = crop_image(img_rotated, x0, y0, w_crop, h_crop) return img_rotated'''
随机旋转
angle_vari是旋转角度的范围[-angle_vari, angle_vari)
p_crop是要进行去黑边裁剪的比例
'''
def random_rotate(img, angle_vari, p_crop):
angle = np.random.uniform(-angle_vari, angle_vari)
crop = False if np.random.random() > p_crop else True
return rotate_image(img, angle, crop)'''
定义hsv变换函数：
hue_delta是色调变化比例
sat_delta是饱和度变化比例
val_delta是明度变化比例
'''
def hsv_transform(img, hue_delta, sat_mult, val_mult):
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV).astype(np.float)
img_hsv[:, :, 0] = (img_hsv[:, :, 0] + hue_delta) % 180
img_hsv[:, :, 1] *= sat_mult
img_hsv[:,

import os
import argparse
import random
import math
from multiprocessing import Process
from multiprocessing import cpu_countimport cv2# 导入image_augmentation.py为一个可调用模块
import image_augmentation as ia# 利用Python的argparse模块读取输入输出和各种扰动参数
def parse_args():
parser = argparse.ArgumentParser(
description='A Simple Image Data Augmentation Tool',
formatter_class=argparse.ArgumentDefaultsHelpFormatter) parser.add_argument('input_dir',
help='Directory containing images')
parser.add_argument('output_dir',
help='Directory for augmented images')
parser.add_argument('num',
help='Number of images to be augmented',
type=int) parser.add_argument('--num_procs',
help='Number of processes for paralleled augmentation',
type=int, default=cpu_count()) parser.add_argument('--p_mirror',
help='Ratio to mirror an image',
type=float, default=0.5) parser.add_argument('--p_crop',
help='Ratio to randomly crop an image',
type=float, default=1.0)
parser.add_argument('--crop_size',
help='The ratio of cropped image size to original image size, in area',
type=float, default=0.8)
parser.add_argument('--crop_hw_vari',
help='Variation of h/w ratio',
type=float, default=0.1) parser.add_argument('--p_rotate',
help='Ratio to randomly rotate an image',
type=float, default=1.0)
parser.add_argument('--p_rotate_crop',
help='Ratio to crop out the empty part in a rotated image',
type=float, default=1.0)
parser.add_argument('--rotate_angle_vari',
help='Variation range of rotate angle',
type=float, default=10.0) parser.add_argument('--p_hsv',
help='Ratio to randomly change gamma of an image',
type=float, default=1.0)
parser.add_argument('--hue_vari',
help='Variation of hue',
type=int, default=10)
parser.add_argument('--sat_vari',
help='Variation of saturation',
type=float, default=0.1)
parser.add_argument('--val_vari',
help='Variation of value',
type=float, default=0.1) parser.add_argument('--p_gamma',
help='Ratio to randomly change gamma of an image',
type=float, default=1.0)
parser.add_argument('--gamma_vari',
help='Variation of gamma',
type=float, default=2.0) args = parser.parse_args()
args.input_dir = args.input_dir.rstrip('/')
args.output_dir = args.output_dir.rstrip('/') return args'''
根据进程数和要增加的目标图片数，
生成每个进程要处理的文件列表和每个文件要增加的数目
'''
def generate_image_list(args):
# 获取所有文件名和文件总数
filenames = os.listdir(args.input_dir)
num_imgs = len(filenames)# 计算平均处理的数目并向下取整
num_ave_aug = int(math.floor(args.num/num_imgs))# 剩下的部分不足平均分配到每一个文件，所以做成一个随机幸运列表
# 对于幸运的文件就多增加一个，凑够指定的数目
rem = args.num - num_ave_aug*num_imgs
lucky_seq = [True]*rem + [False]*(num_imgs-rem)
random.shuffle(lucky_seq)# 根据平均分配和幸运表策略，
# 生成每个文件的全路径和对应要增加的数目并放到一个list里
img_list = [
(os.sep.join([args.input_dir, filename]), num_ave_aug+1 if lucky else num_ave_aug)
for filename, lucky in zip(filenames, lucky_seq)
]# 文件可能大小不一，处理时间也不一样，
# 所以随机打乱，尽可能保证处理时间均匀
random.shuffle(img_list)# 生成每个进程的文件列表，
# 尽可能均匀地划分每个进程要处理的数目
length = float(num_imgs) / float(args.num_procs)
indices = [int(round(i * length

import cv2img = cv2.imread('Aitutaki.png')
cv2.imshow('Honeymoon Island', img)
cv2.waitKey()

import os
from itertools import cycle
import cv2# 列出frames文件夹下的所有图片
filenames = os.listdir('frames')# 通过itertools.cycle生成一个无限循环的迭代器，每次迭代都输出下一张图像对象
img_iter = cycle([cv2.imread(os.sep.join(['frames', x])) for x in filenames])key =
while key & 0xFF != :
cv2.imshow('Animation', next(img_iter))
key = cv2.waitKey()

while key != :
cv2.imshow('Honeymoon Island', img)
key = cv2.waitKey()
# 如果获取的键值小于256则作为ascii码输出对应字符，否则直接输出值
msg = '{} is pressed'.format(chr(key) if key < else key)
print(msg)

import os
import cv2# tkinter是Python内置的简单GUI库，实现一些比如打开文件夹，确认删除等操作十分方便
from tkFileDialog import askdirectory
from tkMessageBox import askyesno# 定义标注窗口的默认名称
WINDOW_NAME = 'Simple Bounding Box Labeling Tool'# 定义画面刷新的大概帧率（是否能达到取决于电脑性能）
FPS = # 定义支持的图像格式
SUPPOTED_FORMATS = ['jpg', 'jpeg', 'png']# 定义默认物体框的名字为Object，颜色蓝色，当没有用户自定义物体时用默认物体
DEFAULT_COLOR = {'Object': (, , )}# 定义灰色，用于信息显示的背景和未定义物体框的显示
COLOR_GRAY = (, , )# 在图像下方多出BAR_HEIGHT这么多像素的区域用于显示文件名和当前标注物体等信息
BAR_HEIGHT = # 上下左右，ESC及删除键对应的cv.waitKey()的返回值
# 注意这个值根据操作系统不同有不同，可以通过6..2中的代码获取
KEY_UP =
KEY_DOWN =
KEY_LEFT =
KEY_RIGHT =
KEY_ESC =
KEY_DELETE = # 空键用于默认循环
KEY_EMPTY = get_bbox_name = '{}.bbox'.format# 定义物体框标注工具类
class SimpleBBoxLabeling: def __init__(self, data_dir, fps=FPS, window_name=None):
self._data_dir = data_dir
self.fps = fps
self.window_name = window_name if window_name else WINDOW_NAME #pt0是正在画的左上角坐标，pt1是鼠标所在坐标
self._pt0 = None
self._pt1 = None # 表明当前是否正在画框的状态标记
self._drawing = False # 当前标注物体的名称
self._cur_label = None # 当前图像对应的所有已标注框
self._bboxes = [] # 如果有用户自定义的标注信息则读取，否则用默认的物体和颜色
label_path = '{}.labels'.format(self._data_dir)
self.label_colors = DEFAULT_COLOR if not os.path.exists(label_path) else self.load_labels(label_path) # 获取已经标注的文件列表和还未标注的文件列表
imagefiles = [x for x in os.listdir(self._data_dir) if x[x.rfind('.') + :].lower() in SUPPOTED_FORMATS]
labeled = [x for x in imagefiles if os.path.exists(get_bbox_name(x))]
to_be_labeled = [x for x in imagefiles if x not in labeled] # 每次打开一个文件夹，都自动从还未标注的第一张开始
self._filelist = labeled + to_be_labeled
self._index = len(labeled)
if self._index > len(self._filelist) - :
self._index = len(self._filelist) - # 鼠标回调函数
def _mouse_ops(self, event, x, y, flags, param): # 按下左键时，坐标为左上角，同时表明开始画框，改变drawing标记为True
if event == cv2.EVENT_LBUTTONDOWN:
self._drawing = True
self._pt0 = (x, y) # 左键抬起，表明当前框画完了，坐标记为右下角，并保存，同时改变drawing标记为False
elif event == cv2.EVENT_LBUTTONUP:
self._drawing = False
self._pt1 = (x, y)
self._bboxes.append((self._cur_label, (self._pt0, self._pt1))) # 实时更新右下角坐标方便画框
elif event == cv2.EVENT_MOUSEMOVE:
self._pt1 = (x, y) # 鼠标右键删除最近画好的框
elif event == cv2.EVENT_RBUTTONUP:
if self._bboxes:
self._bboxes.pop() # 清除所有标注框和当前状态
def _clean_bbox(self):
self._pt0 = None
self._pt1 = None
self._drawing = False
self._bboxes = [] # 画标注框和当前信息的函数
def _draw_bbox(self, img): # 在图像下方多出BAR_HEIGHT这么多像素的区域用于显示文件名和当前标注物体等信息
h, w = img.shape[:]
canvas = cv2.copyMakeBorder(img, , BAR_HEIGHT, , , cv2.BORDER_CONSTANT, value=COLOR_GRAY) # 正在标注的物体信息，如果鼠标左键已经按下，则显示两个点坐标，否则显示当前待标注物体的名称
label_msg = '{}: {}, {}'.format(self._cur_label, self._pt0, self._pt1) \
if self._drawing \
else 'Current label: {}'.format