基于OpenCV的图形分析辨认02

目录

一、前言

二、实验目的

三、实验内容

四、实验过程

一、前言

编程语言：Python，编程软件：vscode或pycharm，必备的第三方库：OpenCV，numpy，matplotlib，os等等。

关于OpenCV，numpy，matplotlib，os等第三方库的下载方式如下：

第一步，按住【Windows】和【R】调出运行界面，输入【cmd】，回车打开命令行。

第二步，输入以下安装命令（可以先升级一下pip指令）。

pip升级指令：

python -m pip install --upgrade pip

 opencv库的清华源下载：

pip install opencv-python  -i https://pypi.tuna.tsinghua.edu.cn/simple

numpy库的清华源下载：

 pip install numpy  -i https://pypi.tuna.tsinghua.edu.cn/simple

matplotlib库的清华源下载：

pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple

os库的清华源下载：

pip install os  -i https://pypi.tuna.tsinghua.edu.cn/simple 

二、实验目的

1.了解不同图像缩放算法；

2.基于公用图像处理函式库完成图片、视频缩小及放大；

3.根据图像缩放算法，自行撰写代码完成图像及视频数据的缩小及放大；

4.比较及分析公用函式库及自行撰写函式的效能。

三、实验内容

1.任选彩色图片、视频，进行缩小及放大

（1）使用OpenCV函数

（2）不使用OpenCV函数

  1. Nearest-Neighbor interpolation
  2. Bi-linear interpolation

2.在彩色图、视频上任意选取区域執行不同的放大方式，结果如下图

（1）使用OpenCV函数

（2）不使用OpenCV函数

  1. Nearest-Neighbor interpolation
  2. Bi-linear interpolation

四、实验过程

（1）基于OpenCV的图像和视频缩放：

图像代码如下：

import cv2
import matplotlib.pyplot as plt

# 读取原始图像
img_origin = cv2.imread(r"D:\Image\img1.jpg")
# 获取图像的高度和宽度
height, width = img_origin.shape[:2]
# 放大图像
img_amplify = cv2.resize(img_origin, None, fx = 1.25, fy = 1.0, interpolation = cv2.INTER_AREA)
# 缩小图像
img_reduce = cv2.resize(img_origin, None, fx = 0.75, fy = 1.0, interpolation = cv2.INTER_AREA)

# 创建一个大小为(10, 10)的图形
plt.figure(figsize=(10, 10))
# 在第1行第1列的位置创建子图，设置坐标轴可见，设置标题为"origin" 
plt.subplot(1, 3, 1), plt.axis('on'), plt.title("origin")
# 显示原始图像
plt.imshow(cv2.cvtColor(img_origin, cv2.COLOR_BGR2RGB))

# 在第1行第2列的位置创建子图，设置坐标轴可见，设置标题为"amplify: fx = 1.25, fy = 1.0"
plt.subplot(1, 3, 2), plt.axis('on'), plt.title("amplify: fx = 1.25, fy = 1.0")
# 显示放大后的图像
plt.imshow(cv2.cvtColor(img_amplify, cv2.COLOR_BGR2RGB))

# 在第1行第3列的位置创建子图，设置坐标轴可见，设置标题为"reduce: fx = 0.75, fy = 1.0"
plt.subplot(1, 3, 3), plt.axis('on'), plt.title("reduce: fx = 0.75, fy = 1.0")
# 显示缩小后的图像
plt.imshow(cv2.cvtColor(img_reduce, cv2.COLOR_BGR2RGB))

# 调整子图布局
plt.tight_layout()
# 显示图形
plt.show()
# 保存图像
retval = cv2.imwrite(r"D:\Image\image_lab2\img_amplify.jpg", img_amplify)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_reduce.jpg", img_reduce)

代码运行结果：

视频代码如下：

import cv2
import os

cap = cv2.VideoCapture(r"D:\Image\video1.mp4")
currentframe = 0

# 循环读取视频帧并保存为图片
while (True):
    ret, frame = cap.read()
    if ret:
        name = str(currentframe)
        cv2.imwrite(r"D:\Image\image_lab2\video_img\%s.jpg"%name, frame)
        currentframe += 1
    else:
        break

# 释放视频对象
cap.release()

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (1280, 1280)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (720, 720)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = cv2.resize(img, img_size_amplify)
    # 图片缩小
    img_reduce = cv2.resize(img, img_size_reduce)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

基于最近邻插值和双线性插值的图像和视频缩放：

将最近邻插值和双线性插值编写成函数文件，命名为【Nearest_Bilinear】，代码如下：

import numpy as np

def Nearest(img, height, width, channels):
    # 创建一个与给定高度、宽度和通道数相同的零数组
    img_nearest = np.zeros(shape=(height, width, channels), dtype=np.uint8)
    
    # 遍历每个像素点
    for i in range(height):
        for j in range(width):
            # 计算在给定高度和宽度下对应的img的行和列
            row = (i / height) * img.shape[0]
            col = (j / width) * img.shape[1]
            # 取最近的整数行和列
            row_near = round(row)
            col_near = round(col)
            # 如果行或列到达img的边界，则向前取整
            if row_near == img.shape[0] or col_near == img.shape[1]:
                row_near -= 1
                col_near -= 1
            
            # 将最近的像素赋值给img_nearest
            img_nearest[i][j] = img[row_near][col_near]
            
    # 返回最近映射后的图像
    return img_nearest

def Bilinear(img, height, width, channels):
    # 生成一个用于存储bilinear插值结果的零矩阵
    img_bilinear = np.zeros(shape=(height, width, channels), dtype=np.uint8)

    # 对矩阵的每一个元素进行插值计算
    for i in range(0, height):
        for j in range(0, width):
            # 计算当前元素所在的行和列的相对位置
            row = (i / height) * img.shape[0]
            col = (j / width) * img.shape[1]
            row_int = int(row)
            col_int = int(col)
            # 计算当前元素所在点的权重
            u = row - row_int
            v = col - col_int
            # 判断当前元素是否越界，若是则调整相对位置
            if row_int == img.shape[0] - 1 or col_int == img.shape[1] - 1:
                row_int -= 1
                col_int -= 1
            # 根据权重进行插值计算
            img_bilinear[i][j] = (1 - u) * (1 - v) * img[row_int][col_int] + (1 - u) * v * img[row_int][col_int + 1] + u * (1 - v) * img[row_int + 1][col_int] + u * v * img[row_int + 1][col_int + 1]
            
    # 返回bilinear插值结果
    return img_bilinear

 后续在实现图像放缩时导入该函数即可，图像放缩代码如下：

import cv2
import matplotlib.pyplot as plt
from Nearest_Bilinear import *

# 读取图像
img = cv2.imread(r"D:\Image\img1.jpg", cv2.IMREAD_COLOR)
# 获取图像的高度、宽度和通道数
height, width, channels = img.shape
print(height, width, channels)

# 对图像进行放大操作，增加200个像素的高度
img_nearest_amplify = Nearest(img, height + 200, width, channels)
# 对图像进行缩小操作，减少200个像素的高度
img_nearest_reduce = Nearest(img, height - 200, width, channels)

# 创建一个大小为10x10的图像窗口
plt.figure(figsize=(10, 10))
# 在第一个子图中显示原始图像
plt.subplot(1, 3, 1), plt.axis('on'), plt.title("origin")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
# 在第二个子图中显示放大后的图像
plt.subplot(1, 3, 2), plt.axis('on'), plt.title("Nearest_amplify")
plt.imshow(cv2.cvtColor(img_nearest_amplify, cv2.COLOR_BGR2RGB))
# 在第三个子图中显示缩小后的图像
plt.subplot(1, 3, 3), plt.axis('on'), plt.title("Nearest_reduce")
plt.imshow(cv2.cvtColor(img_nearest_reduce, cv2.COLOR_BGR2RGB))
plt.tight_layout()
plt.show()

# 对图像进行放大操作，增加200个像素的高度
img_bilinear_amplify = Bilinear(img, height + 200, width, channels)
# 对图像进行缩小操作，减少200个像素的高度
img_bilinear_reduce = Bilinear(img, height - 200, width, channels)

# 创建一个大小为10x10的图像窗口
plt.figure(figsize=(10, 10))
# 在第一个子图中显示原始图像
plt.subplot(1, 3, 1), plt.axis('on'), plt.title("origin")
plt.imshow(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
# 在第二个子图中显示放大后的图像
plt.subplot(1, 3, 2), plt.axis('on'), plt.title("Bilinear_amplify")
plt.imshow(cv2.cvtColor(img_bilinear_amplify, cv2.COLOR_BGR2RGB))
# 在第三个子图中显示缩小后的图像
plt.subplot(1, 3, 3), plt.axis('on'), plt.title("Bilinear_reduce")
plt.imshow(cv2.cvtColor(img_bilinear_reduce, cv2.COLOR_BGR2RGB))
plt.tight_layout()
plt.show()

# 保存图像
retval = cv2.imwrite(r"D:\Image\image_lab2\img_nearest_amplify.jpg", img_nearest_amplify)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_nearest_reduce.jpg", img_nearest_reduce)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_bilinear_amplify.jpg", img_bilinear_amplify)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_bilinear_reduce.jpg", img_bilinear_reduce)

代码运行结果如下：

 基于最近邻插值的视频缩放代码：

import cv2
import os
from Nearest_Bilinear import *

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (1280, 1280)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (720, 720)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify_Nearest.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce_Nearest.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = Nearest(img, img_size_amplify[0], img_size_amplify[1], 3)
    # 图片缩小
    img_reduce = Nearest(img, img_size_reduce[0], img_size_reduce[1], 3)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

基于双线性插值的视频放缩代码：

import cv2
import os
from Nearest_Bilinear import *

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (1280, 1280)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (720, 720)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify_Bilinear.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce_Bilinear.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = Bilinear(img, img_size_amplify[0], img_size_amplify[1], 3)
    # 图片缩小
    img_reduce = Bilinear(img, img_size_reduce[0], img_size_reduce[1], 3)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

（2）基于OpenCV的局部图像和视频缩放

局部图像的缩放代码如下：

import cv2
import matplotlib.pyplot as plt

# 读取原始图像
img_origin = cv2.imread(r"D:\Image\img1.jpg", cv2.IMREAD_COLOR)
# 获取图像的高度和宽度
height, width = img_origin.shape[:2]
# 定义图像的一部分的坐标范围
y1, y2 = 100, 300
x1, x2 = 100, 300
# 获取图像的一部分
img_part = img_origin[y1:y2, x1:x2]
# 放大图像
img_amplify = cv2.resize(img_part, None, fx=1.25, fy=1.0, interpolation=cv2.INTER_NEAREST)
# 缩小图像
img_reduce = cv2.resize(img_part, None, fx=0.75, fy=1.0, interpolation=cv2.INTER_LINEAR)
# 创建绘图窗口
plt.figure(figsize=(10, 10))
# 绘制图像
plt.subplot(2, 2, 1), plt.axis('on'), plt.title("origin")
plt.imshow(cv2.cvtColor(img_origin, cv2.COLOR_BGR2RGB))
plt.subplot(2, 2, 2), plt.axis('on'), plt.title("part")
plt.imshow(cv2.cvtColor(img_part, cv2.COLOR_BGR2RGB))
plt.subplot(2, 2, 3), plt.axis('on'), plt.title("amplify: fx = 1.25, fy = 1.0")
plt.imshow(cv2.cvtColor(img_amplify, cv2.COLOR_BGR2RGB))
plt.subplot(2, 2, 4), plt.axis('on'), plt.title("reduce: fx = 0.75, fy = 1.0")
plt.imshow(cv2.cvtColor(img_reduce, cv2.COLOR_BGR2RGB))

# 调整子图布局
plt.tight_layout()
# 显示图形
plt.show()

# 保存图像
retval = cv2.imwrite(r"D:\Image\image_lab2\img_part.jpg", img_part)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_amplify_part.jpg", img_amplify)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_reduce_part.jpg", img_reduce)

局部视频的缩放代码如下：

import cv2
import os

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (720, 720)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (250, 250)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify_part.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce_part.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    img = img[100:500, 100:500]
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = cv2.resize(img, img_size_amplify)
    # 图片缩小
    img_reduce = cv2.resize(img, img_size_reduce)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

基于最近邻插值和双线性插值的局部图像和视频缩放：

局部图像的缩放代码如下：

import cv2
import matplotlib.pyplot as plt
from Nearest_Bilinear import *

# 读取图像
img = cv2.imread(r"D:\Image\img1.jpg", cv2.IMREAD_COLOR)
# 获取图像的高度、宽度和通道数
height, width, channels = img.shape
# 定义图像的一部分的坐标范围
y1, y2 = 100, 300
x1, x2 = 100, 300
# 获取图像的一部分
img_part = img[y1:y2, x1:x2]

# 对图像进行放大操作，增加100个像素的高度
img_nearest_amplify_part = Nearest(img_part, height + 100, width, channels)
# 对图像进行缩小操作，减少100个像素的高度
img_nearest_reduce_part = Nearest(img_part, height - 100, width, channels)
# 创建一个大小为10x10的图像窗口
plt.figure(figsize=(10, 10))
# 在第一个子图中显示原始图像
plt.subplot(1, 3, 1), plt.axis('on'), plt.title("origin")
plt.imshow(cv2.cvtColor(img_part, cv2.COLOR_BGR2RGB))
# 在第二个子图中显示放大后的图像
plt.subplot(1, 3, 2), plt.axis('on'), plt.title("Nearest_amplify")
plt.imshow(cv2.cvtColor(img_nearest_amplify_part, cv2.COLOR_BGR2RGB))
# 在第三个子图中显示缩小后的图像
plt.subplot(1, 3, 3), plt.axis('on'), plt.title("Nearest_reduce")
plt.imshow(cv2.cvtColor(img_nearest_reduce_part, cv2.COLOR_BGR2RGB))
plt.tight_layout()
plt.show()

# 对图像进行放大操作，增加100个像素的高度
img_bilinear_amplify_part = Bilinear(img_part, height + 100, width, channels)
# 对图像进行缩小操作，减少100个像素的高度
img_bilinear_reduce_part = Bilinear(img_part, height - 100, width, channels)
# 创建一个大小为10x10的图像窗口
plt.figure(figsize=(10, 10))
# 在第一个子图中显示原始图像
plt.subplot(1, 3, 1), plt.axis('on'), plt.title("origin")
plt.imshow(cv2.cvtColor(img_part, cv2.COLOR_BGR2RGB))
# 在第二个子图中显示放大后的图像
plt.subplot(1, 3, 2), plt.axis('on'), plt.title("Bilinear_amplify")
plt.imshow(cv2.cvtColor(img_bilinear_amplify_part, cv2.COLOR_BGR2RGB))
# 在第三个子图中显示缩小后的图像
plt.subplot(1, 3, 3), plt.axis('on'), plt.title("Bilinear_reduce")
plt.imshow(cv2.cvtColor(img_bilinear_reduce_part, cv2.COLOR_BGR2RGB))
plt.tight_layout()
plt.show()

# 保存图像
retval = cv2.imwrite(r"D:\Image\image_lab2\img_nearest_amplify_part.jpg", img_nearest_amplify_part)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_nearest_reduce_part.jpg", img_nearest_reduce_part)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_bilinear_amplify_part.jpg", img_bilinear_amplify_part)
retval = cv2.imwrite(r"D:\Image\image_lab2\img_bilinear_reduce_part.jpg", img_bilinear_reduce_part)

基于最近邻插值的局部视频缩放代码：

import cv2
import os
from Nearest_Bilinear import *

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (720, 720)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (250, 250)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify_Nearest_part.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce_Nearest_part.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    img = img[100:500, 100:500]
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = Nearest(img, img_size_amplify[0], img_size_amplify[1], 3)
    # 图片缩小
    img_reduce = Nearest(img, img_size_reduce[0], img_size_reduce[1], 3)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

基于双线性插值的局部视频缩放代码如下：

import cv2
import os
from Nearest_Bilinear import *

video_path = r"D:\Image\image_lab2\video_img"
# 获取视频文件夹中的所有文件
img_files = os.listdir(video_path)
# 统计图片文件数量
img_count = len(img_files)
# 设定视频编解码器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')
# 设定图片大小放大后的目标尺寸
img_size_amplify = (720, 720)
# 设定图片大小缩小后的目标尺寸
img_size_reduce = (250, 250)
# 视频保存路径（放大版本）
video_save_amplify = r"D:\Image\image_lab2\video_amplify_Bilinear_part.mp4"
# 视频保存路径（缩小版本）
video_save_reduce = r"D:\Image\image_lab2\video_reduce_Bilinear_part.mp4"
# 创建放大版本的视频写入对象
video_writer_amplify = cv2.VideoWriter(video_save_amplify, fourcc, 60, img_size_amplify)
# 创建缩小版本的视频写入对象
video_writer_reduce = cv2.VideoWriter(video_save_reduce, fourcc, 60, img_size_reduce)
print("视频放大及缩小开始")

for i in range(0, img_count):
    # 设定图片文件路径
    img_path = video_path + "/" + str(i) + ".jpg"
    # 读取图片
    img = cv2.imread(img_path, cv2.IMREAD_COLOR)
    img = img[100:500, 100:500]
    # 若读取失败则跳过本次循环
    if img is None:
        continue
    # 图片放大
    img_amplify = Bilinear(img, img_size_amplify[0], img_size_amplify[1], 3)
    # 图片缩小
    img_reduce = Bilinear(img, img_size_reduce[0], img_size_reduce[1], 3)
    # 将放大后的图片写入放大版本的视频
    video_writer_amplify.write(img_amplify)
    # 将缩小后的图片写入缩小版本的视频
    video_writer_reduce.write(img_reduce)
    print(f"第{i}张图片合成完成")

print("视频放大及缩小完成")

都看到最后了，不点个赞吗？

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/434959.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【python 1】----Pytest基础知识

【python 1】----Pytest基础知识

定义 用于编写和执行Python测试全功能测试框架（工具），是一个第三方库 安装 pip insatll pytest 安装pytest --version 校验 pytest的组成构成 不写调用语句也可以执行函数内容 在用例运行语句里面： -s:指的是开启与终端的…
阅读更多...
【CSP试题回顾】201512-2-消除类游戏

【CSP试题回顾】201512-2-消除类游戏

CSP-201512-2-消除类游戏 解题思路 输入棋盘大小和颜色: 首先，程序从标准输入读取两个整数n和m，分别代表棋盘的行数和列数。然后，程序读取接下来的n行输入，每行包含m个整数，代表棋盘上每个方格中的棋子颜色。 初始化…
阅读更多...
电子台账：通过标签颜色快速区分某月账页是否为空、是否锁定

电子台账：通过标签颜色快速区分某月账页是否为空、是否锁定

目录 1 数据为空的账页，标签顶部没有标记色条 2 包含有效数据的账页且未进行锁定，标签顶部为深绿色标记色条 3 包含有效数据的账页且被锁定，标签顶部为橙色标记色条 通过设置账页标签的颜色，快速区分哪些月份的账页数据为空&am…
阅读更多...
【书生·浦语大模型实战营】第6节 OpenCompass 大模型评测 课后作业

【书生·浦语大模型实战营】第6节 OpenCompass 大模型评测 课后作业

OpenCompass 大模型评测 0. 课程链接1. 课后作业1.1 基础作业1.2 进阶作业 2. 结业总结 0. 课程链接 链接：https://github.com/InternLM/tutorial/blob/main/opencompass/opencompass_tutorial.md 1. 课后作业 1.1 基础作业 使用 OpenCompass 评测 InternLM2-Cha…
阅读更多...
python高级之元类

python高级之元类

python高级之元类 一、Type创建类1、传统方式创建类2、非传统方式 二、元类三、总结 一、Type创建类 class A(object):def __init__(self, name):self.name namedef __new__(cls, *args, **kwargs):data object.__new__(cls)return data根据类创建对象 objA(‘kobe’) 1、执…
阅读更多...
机器视觉相关网站推荐

机器视觉相关网站推荐

机器视觉相关网站推荐 - 知乎计算机视觉（Computer Vision）最近这几年发展迅速，技术论坛和QQ群也如雨后春笋，特别是人脸检测/识别领域。近段时间云从君从研究院那里探得了好几个论坛，收藏了若干网站，记录下&…
阅读更多...
领域驱动设计（Domain-Driven Design DDD)——战略设计2

领域驱动设计（Domain-Driven Design DDD)——战略设计2

二、保持模型的完整性 2、模式：Continuous Integration 定义一个Bounded Context后，必须让它保持合理。 当很多人在同一个Bounded Context中工作时，模型很容易发生分裂。团队越大，问题就越大，但即使是3、4个人的团队也…
阅读更多...
状压dp详解，棋盘式、集合型，OJ详解

状压dp详解，棋盘式、集合型，OJ详解

文章目录 零、引例-小国王1.问题描述2.暴力枚举3.多维dp4.维度压缩 一、状压dp1.认识状压dp2.棋盘式(基于连通性)2.1小国王2.1.1题目链接2.1.2思路分析2.1.3AC代码 2.2玉米田2.2.1题目链接2.2.2思路分析2.2.3AC代码 2.3炮兵阵地2.3.1题目链接2.3.2思路分析2.3.3AC代码 2.4蒙德里…
阅读更多...
C++ 快速排序快速选择OJ

C++ 快速排序快速选择OJ

目录 1、75. 颜色分类 2、912. 排序数组 3、 215. 数组中的第K个最大元素 4、LCR 159. 库存管理 III 1、75. 颜色分类 思路：利用快速排序思路，使用三指针分块进行优化。 [0,left]——小于key[left1,right-1]——等于key[right,nums.size()]——大于k…
阅读更多...
抖店怎么做起来？2024新版操作逻辑，做项目要做一米宽万米深

抖店怎么做起来？2024新版操作逻辑，做项目要做一米宽万米深

我是王路飞。 不知不觉间，我已经在抖音电商这条赛道深耕走过了四年。 这四年里，我们有了自己的黑标品牌旗舰，有了自己的仓库配套周边，有了自己的模式体系人员，有了数不清的类目和产品操作经验。 收获着身后团队伙伴…
阅读更多...
107. sort( )方法-排序列表元素（上）

107. sort( )方法-排序列表元素（上）

107. sort( )方法-排序列表元素（上） 【目录】 文章目录 107. sort( )方法-排序列表元素（上）1. 作用2. 语法3. 数值列表排序4. key str.lower 排序时不区分字母大小写5. 如何理解区分大小写6. key len 按照元素的长度进行排序7.…
阅读更多...
Objective-C blocks 概要

Objective-C blocks 概要

1.block的使用 1.1什么是block？ Blocks是C语言的扩充功能：带有自动变量（局部变量）的匿名函数。 “带有自动变量”在Blocks中表现为“截取自动变量" “匿名函数”就是“不带名称的函数” 块，封装了函数调用及调用…
阅读更多...
Tailscale中继服务derper使用docker-compose部署

Tailscale中继服务derper使用docker-compose部署

docker启动 docker run --restart always \--name derper -p 12345:12345 -p 3478:3478/udp \-v /root/.acme.sh/xxxx/:/app/certs \-e DERP_CERT_MODEmanual \-e DERP_ADDR12345 \-e DERP_DOMAINxxxx \-d ghcr.io/yangchuansheng/derper:latestdocker-compose启动 version: …
阅读更多...
STM32（18）I2C

STM32（18）I2C

串口通信缺点 一个设备就需要一个串口，单片机可能没有那么多串口外设 总线/非总线 主机：负责管理总线，可控制波特率、数据的通信方向 波特率：由主机产生波特率信号 数据的传输 每个从机都有7位地址，最后移位是读&a…
阅读更多...
Android开发教程入门，那些被大厂优化的程序员们

Android开发教程入门，那些被大厂优化的程序员们

Binder原理 1、概述 Android系统中，涉及到多进程间的通信底层都是依赖于Binder IPC机制。例如当进程A中的Activity要向进程B中的Service通信，这便需要依赖于Binder IPC。不仅于此，整个Android系统架构中，大量采用了Binder机制作…
阅读更多...
计算机形式严峻，二本计算机研究生有没有必要读？

计算机形式严峻，二本计算机研究生有没有必要读？

有一说一，不值得 现在的就业形式确实严峻，但是我觉得读一个二本的研究生并不能给你带来太大的价值，首先就是就业投简历的时候，面试官面对大量的简历，往往都是先按照学校筛选，985和211的放在一块&#xff0…
阅读更多...
画图解题思路（ ccf 201512-3）

画图解题思路（ ccf 201512-3）

分析 首先需要转换坐标系，可以将两个坐标系的点写出来，对比一下找规律 可以发现题目中的坐标(x, y)转变成数组坐标系为(n - y - 1, x); 然后再判断是画线还是填充 画线：先转换题目坐标，再遍历画线 填充：采用dfs
阅读更多...
如何比较字形相同但编码不同的两个字

如何比较字形相同但编码不同的两个字

今天在做字符串比较时遇到个很新奇的问题，在此记录一下。 字符串比较最常用的方法就是equals方法，来看一下下面这个比较会返回什么结果呢？ public static void main(String[] args) {{String s1 "⽹"; // 12153String s2 "…
阅读更多...
HplusAdmin ASP.NET基本权限管理系统

HplusAdmin ASP.NET基本权限管理系统

HplusAdmin 介绍 一套ASP.NET WebForm(不用控件) hplusasp.netsqlserver 基本权限管理系统 http://hplus.baocaige.top 暂不开源，需要的滴滴或者留下邮箱！！！ 账号 普通账号 账号：user 密码：Aa123456普…
阅读更多...
【笔记版】edgecore.yaml分析总结

【笔记版】edgecore.yaml分析总结

1. 文件路径 /etc/kubeedge/config edgecore.yaml是该目录下唯一的文件 附上链接：edgecore.yaml 2. 文件生成方式 2.1 方式一 使用keadm安装部署的方式，执行完keadm join --cloudcore-ipportcloudcore监听的IP地址:端口（默认为10002&…
阅读更多...
最新文章

Copyright @ 2022~2023