（酒驾检测、人脸检测、疲劳检测、模拟口罩数据集制作、防酒驾）-常用的论文所用的python代码总结

P13643822101

已于 2024-01-21 22:23:48 修改

阅读量1.1k

点赞数 19

文章标签： python opencv 计算机视觉

于 2024-01-21 19:18:05 首次发布

本文链接：https://blog.csdn.net/P13643822101/article/details/135733108

版权

汇总：

学习感悟：如果小白建议一行一行的Debug,看够一定量的代码，自己就自然顺手写代码了。汇总上传的东西用在自己电脑上一般都需要适当修改的。

20，水平翻转图片

19，颜色空间装换HSV对比演示

18，光照补偿图片

17，Gamma 变换函数曲线曲线绘制

16，Mish 损失函数曲线绘制

15，摄像头黑屏遮挡检测（摄像头被遮挡就会被检测到”可触发报警“）

14，picture2mp4.py图片按一定的顺序转合成为MP4

13，STM32单片机串口与电脑上位机连接通讯的代码
12，批量修改文件或者文件夹的重命名、按一定的顺序重命名、带序号的命名，以一定的顺序重命名
11，除图片水印
10，加权式双模注意力机制
9，将多张图片调整为统一尺寸纵向横向拼接
8，排序
7，批量打印PDF
6，常用的激活函数曲线绘制代码
5，批量删除或者检查指定格式的文件或者文件夹或者修改文件的命名方式。
4，批量检查删除失真的图片（本代码是自己论文中用到的，供参考修改）

3，批量删除文件名或者重命名文件名、删除文件名中指定的字符、另存为指定的文件后缀名

2，视频处理为图片.py 视频处理为一帧帧的图片并保存（根据需要自己稍加修改）
1，制作pairs.txt对（主要用于人脸识别，）

(ps:另外还有视频检测、疲劳检测、酒驾检测、口罩人脸识别、、低光照改善、人脸对称修复、高精度模拟口罩佩戴、PYQT5（给图片或视频中人脸佩戴模拟口罩、酒驾人脸检测上位机、涉及多个文件夹不方便上传，如有需要私信联系qq:1228119957）

1，制作pairs.txt对（主要用于人脸识别，）

"""
By Fivethousand

输入图片二级目录根目录，随机生成该图片集的验证集（图片对+label)
"""
import os
import random

correct_label="1"
error_label="0"
def V_S_G(loadpath,savepath="./AutoSaved.txt",split=" ",same_num=3000,diff_num=3000): #V_S_G refers to Verification-set-generator
f = open(savepath, 'a+')
f.seek(0)
f.truncate() # 清空文件
subfile_list1 = os.listdir(loadpath) #一级子文件名列表
dictionary={}
for file in subfile_list1:
subfile_list2=os.listdir(os.path.join(loadpath,file) ) #某一个一级子文件下的二级子文件列表
dictionary[file]=subfile_list2 #将该列表存入字典中，索引值为其母文件名

for file in subfile_list1: #生成相同的图片对
count=2*same_num
if count>len(dictionary[file]):
count=len(dictionary[file])
if count%2 is not 0: #必须保证count是偶数
count=count-1
rdlist=random.sample(range(0,len(dictionary[file])),count) #生成相同的图片对
for i in range(int(count/2)):
# first=os.path.join(loadpath,file,dictionary[file][rdlist[2*i]]) #备份
# second=os.path.join(loadpath, file, dictionary[file][rdlist[2 * i + 1]]) #备份
first=os.path.join(file+'/',dictionary[file][rdlist[2*i]])
second=os.path.join(file+'/', dictionary[file][rdlist[2 * i + 1]])

f.write(first+split+second+split+correct_label+"\n")

wrong_pair_num=diff_num
if(diff_num>len(subfile_list1)):
wrong_pair_num=len(subfile_list1)
for i in range(wrong_pair_num): #生成不相同的图片对
rdpair=random.sample(range(0,len(subfile_list1)),2)
first_file_name=subfile_list1[rdpair[0]]
first_rd=random.sample(range(0,len(dictionary[first_file_name])),1)[0]
# first=os.path.join(loadpath,first_file_name,dictionary[first_file_name][first_rd]) # 备份
first = os.path.join(first_file_name+'/',dictionary[first_file_name][first_rd])

second_file_name=subfile_list1[rdpair[1]]
second_rd=random.sample(range(0,len(dictionary[second_file_name])),1)[0]
# second=os.path.join(loadpath,second_file_name,dictionary[second_file_name][second_rd]) #备份保留的是绝对路径
second = os.path.join(second_file_name+'/',dictionary[second_file_name][second_rd])
f.write(first+split+second+split+error_label+"\n")
f.close()

V_S_G("D:\\pycharm\\pytorch-1\\facenet-pytorch-main_aded\\facenet-pytorch-main\\test\\WH_ed_peopele_cleaned_all_masked_AF_Before_aligned")

2，视频处理为图片.py 视频处理为一帧帧的图片并保存（根据需要自己稍加修改）

import cv2
import os
import sys
# 读取文件路径，视频文件所在位置
input_path = r"C:\\Users\\12281\\Desktop\\7\\000"
#设定每隔多少帧截取一帧
fram_interval = 1
filenames = os.listdir(input_path)
video_prefix = input_path.split(os.sep)[-1]
#自动建立一个新文件夹，名称为原文件夹名称后加上_frames
frame_path = '{}_frame'.format(input_path)
if not os.path.exists(frame_path):
os.mkdir(frame_path)
cap = cv2.VideoCapture()
for filename in filenames:
filepath = os.sep.join([input_path,filename])
cap.open(filepath)
#获取视频帧数
n_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
#若画质低，则略过头帧
#for i in range(42):
#cap.read()
for i in range(n_frames):
ret, frame = cap.read()
#每隔frame_interval帧进行一次截屏操作
if i % fram_interval == 0:
imagename = '{}_{:0>6d}.jpg'.format(filename.split('.')[0], i)
imagepath = os.sep.join([frame_path, imagename])
print('exported {}!'.format(imagepath))
cv2.imwrite(imagepath, frame)
#图片重命名
path="C:\\Users\\12281\\Desktop\\7_frame"
#获取该目录下所有文件，存入列表中
fileList=os.listdir(path)
n=0
m=0
for i in fileList:
#设置旧文件名
oldname=path+ os.sep + fileList[n]
#设置新文件名
newname=path+os.sep +"train"+str(m+1)+".jpg"
os.rename(oldname, newname)
print(oldname, '======>', newname)
n+=1
m+=1
cap.release()

3，批量删除文件名或者重命名文件名、删除文件名中指定的字符、另存为指定的文件后缀名

'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import cv2
import numpy as np
import PIL.Image as Image

path = 'C:\\Users\\12281\\Desktop\\AFDB_masked_2dian' # 文件夹地址
path_save = 'C:\\Users\\12281\\Desktop\\AFDB_masked_2dian'

os.rename( # 实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root,re_name ))
except: # 报错的话就会执行下面的东西
t= "___"+name
os.rename( # 防止更改后的文件名与先有的文件名重复，这里做个记号实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root, t))

if __name__ == "__main__":
fond()

4，删除失真图片.py 批量检查删除失真的图片（本代码是自己论文中用到的，供参考修改）

# "燕山大学机械工程“
# 职业：学生
# 开发时间：2022-08-02 8:36
'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import cv2
import numpy as np
import PIL.Image as Image

path = 'C:\\Users\\12281\\Desktop\\train_2dian' # 文件夹地址
path_save = 'C:\\Users\\12281\\Desktop\\train_2dian'

def fond():
count=0
for root, dirs, files in os.walk(path, topdown=False):
new_root = root.replace(path, path_save) # 原路径保存
for name in files: # dirs：Prints out sub-directories from root.# files 具体文件名字

img=cv2.imread(os.path.join(new_root, name))

shape= img.shape
H= shape[0]
W= shape[1]
if W<224 or H<224:
os.remove(os.path.join(new_root, name))
count=count+1
print(count)
else:
continue

if __name__ == "__main__":

fond()

5，删除或保留指定格式的文件或者文件夹.py 批量删除或者检查指定格式的文件或者文件夹或者修改文件的命名方式。

# __Author:Wu
# date: 2019/12/3
# 工具功能：
# 遍历指定文件夹，留下需要的文件（使用后缀名识别），并且删除空文件夹
# 随后删除指定文件夹。(可选)
# 然后把这个文件夹压缩
import os
import sys
import shutil
import zipfile

def fileFilter(dirpath):
for root, dirs, files in os.walk(dirpath):
for file in files:
# 获取文件所属目录
# 获取文件路径
rFindFileIndex = file.rfind('.')
fileExtname = file[rFindFileIndex + 1:]
# 删除指定后缀名的文件
# if not (fileExtname == 'jpg' or fileExtname == 'png' or fileExtname == 'zip'):
if not (fileExtname == 'jpg' or fileExtname == 'png'):
os.remove(os.path.join(root, file))
print('删除不需要的文件' + file)
else:
pass
# 删除空文件夹
if not os.listdir(root):
print("文件夹" + root + "为空，删除")
os.rmdir(root)

# 删除指定名称的文件夹
# for roots in root:
# if roots == '新建文件夹':
# shutil.rmtree(roots)
# os.mkdir(roots)
print("已留下所需文件")

# 删除空文件夹
def delete_null_dirs(dires):
dirs_list = []
for root, dirs, files in os.walk(dires):
dirs_list.append(root)
for root in dirs_list[::-1]:
if not os.listdir(root):
print("删除空目录：" + root)
os.rmdir(root)

# 压缩文件夹
def zipdir(srcPath, dstname):
workzip = zipfile.ZipFile(dstname, "w", zipfile.ZIP_DEFLATED)
for dirpath, dirs, files in os.walk(srcPath):
for filename in files:
workzip.write(os.path.join(dirpath, filename))
print(filename + "压缩完成")
workzip.close

# 获取操作文件夹名称
def direname(dirspath):
finddirIndex = dirpath.split("\\")
global dirname
dirname = finddirIndex[-1]

if __name__ == "__main__":
# dirpath = str(input("请输入要处理的文件夹路径"))
# dirname = ''
#

dirpath = "C:\\Users\\12281\\Desktop\\7"
delete_null_dirs(dirpath)
fileFilter(dirpath)
# direname(dirpath)
# zipdir(dirpath, dirname + ".zip")
print("完成，按任意键退出")
input()

6，损失曲线.py 常用的激活函数曲线绘制代码

import numpy as np
import matplotlib.pyplot as plt
# from vtkmodules.numpy_interface.algorithms import ln
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
# 0 设置字体
from torch import nn

plt.rc('font', family='Times New Roman', size=15)

# 1.1 定义sigmoid函数
def sigmoid(x):
return 1. / (1 + np.exp(-x))

# 1.2 定义tanh函数
def tanh(x):
return (np.exp(x) - np.exp(-x)) / (np.exp(x) + np.exp(-x))

# 1.3 定义relu函数
class h_sigmoid(nn.Module):
def __init__(self, inplace=True):
super(h_sigmoid, self).__init__()
self.relu = nn.ReLU6(inplace=inplace)

def forward(self, x):
return self.relu(x + 3) / 6

def relu(x): # relu6
y=np.where(x < 0, 0, x)
x=np.where(y>6, 6, y)
return x

# 1.4 定义prelu函数
def Leaky_ReLU(x):
return np.where(x < 0, x * 0.5, x)

def Mish(x):
return x * tanh(ln(1 + np.exp(x)))

# 2.1 定义绘制函数sigmoid函数
def plot_sigmoid():
x = np.arange(-10, 10, 0.1)
y = sigmoid(x)
fig = plt.figure() # 如果使用plt.figure(1)表示定位（创建）第一个画板，如果没有参数默认创建一个新的画板，如果plt.figure(figsize = (2,2)) ，表示figure 的大小为宽、长
ax = fig.add_subplot(111) # 表示前面两个1表示1*1大小，最后面一个1表示第1个
ax.spines['top'].set_color('none') # ax.spines设置坐标轴位置，set_color设置坐标轴边的颜色
ax.spines['right'].set_color('none')
ax.spines['left'].set_position(('data', 0))
ax.plot(x, y, color="black", lw=3) # 设置曲线颜色，线宽
plt.xticks(fontsize=15) # 设置坐标轴的刻度子字体大小
plt.yticks(fontsize=15)
plt.xlim([-10.05, 10.05]) # 设置坐标轴范围
plt.ylim([-0.02, 1.02])
plt.tight_layout() # 自动调整子图参数
plt.show() # 显示绘图

# 2.2 定义绘制函数tanh函数
def plot_tanh():
x = np.arange(-10, 10, 0.1)
y = tanh(x)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.spines['left'].set_position(('data', 0))
ax.spines['bottom'].set_position(('data', 0))
ax.plot(x, y, color="black", lw=3)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim([-10.05, 10.05])
plt.ylim([-0.02, 1.02])
ax.set_yticks([-1.0, -0.5, 0.5, 1.0])
ax.set_xticks([-10, -5, 5, 10])
plt.tight_layout()
plt.show()

# 2.3 定义绘制函数relu函数
def plot_relu():
x = np.arange(-10, 10, 0.1)
# h_sigmoid
# y = relu(x)
y=h_sigmoid(x)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.spines['left'].set_position(('data', 0))
ax.plot(x, y, color="black", lw=3)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.xlim([-10.05, 10.05])
plt.ylim([-0.02, 1.02])
ax.set_yticks([2, 4, 6, 8, 10])
plt.tight_layout()
plt.show()

# 2.4 定义绘制函数Leaky_ReLU函数
def plot_Leaky_relu():
x = np.arange(-10, 10, 0.1)
y = Leaky_ReLU(x)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.spines['left'].set_position(('data', 0))
ax.spines['bottom'].set_position(('data', 0))
ax.plot(x, y, color="black", lw=3)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.tight_layout()
plt.show()

def plot_Mish():
x = np.arange(-10, 10, 0.1)
y = Mish(x)
fig = plt.figure()
ax = fig.add_subplot(111)
ax.spines['top'].set_color('none')
ax.spines['right'].set_color('none')
ax.spines['left'].set_position(('data', 0))
ax.spines['bottom'].set_position(('data', 0))
ax.plot(x, y, color="black", lw=3)
plt.xticks(fontsize=15)
plt.yticks(fontsize=15)
plt.tight_layout()
plt.show()

# 3 运行程序
h_sigmoid=h_sigmoid()
plot_sigmoid()
plot_tanh()
plot_relu()
plot_Leaky_relu()
plot_Mish()

7，批量打印pdF.py 批量打印PDF

import win32api
import os

if __name__ == '__main__':
path = r"C:\\Users\\12281\\Desktop\\p" # 或path =str(input("请输入文件夹的绝对路径"))
files = [path + "\\" + i for i in os.listdir(path)] # 获取文件夹下的文件名，并拼接完整路径。

for filename in files:
print(filename)
win32api.ShellExecute(0, "print", filename, None, ".", 0)

'''
参数说明：
"print"：选择的操作是打印；
"filename"：这里是输入文件名；
"None"：这里是打印机的设置，代表使用默认打印机；
"."：（无说明）
"0"：此参数应设置为0。
'''

8,排序Loss_rank排序.py 排序

# 开发时间：2022-07-22 7:05

'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import numpy as np

# 函数功能为：筛选出文件夹下所有后缀名为.txt的文件
def screen():
path = '/FA3_960_group_cov_first_stride1' # 文件夹地址
txt_list = [] # 创建一个空列表用于存放文件夹下所有后缀为.txt的文件名称
file_list = os.listdir(path)       # 获取path文件夹下的所有文件，并生成列表
for i in file_list:
file_ext = os.path.splitext(i)     # 分离文件前后缀，front为前缀名，ext为后缀名
front, ext = file_ext                           # 将前后缀分别赋予front和ext

if ext == '.pth': # 判断如果后缀名为.txt则将该文件名添加到txt_list的列表当中去
txt_list.append(i)
return txt_list

if __name__ == "__main__":
top=3
# a=[]
txt_list=screen()
val_loss_min= txt_list[:] # 列表赋值,注意sort()函数改变原来的列表函数返回值是空值即None
train_loss_min= txt_list[:]
sum_loss_min= txt_list[:]
list_pre= txt_list[:]
val_loss_min.sort(key=lambda x: (float(x.split('loss')[2].split('.pth')[0])),reverse=False) # 不能直接赋值给一个空列表默认降序
train_loss_min.sort(key=lambda x: (float(x.split('loss')[1].split('-')[0]))) # 训练集损失排序升序
sum_loss_min.sort(key=lambda x:(float(x.split('loss')[1].split('-')[0])+float(x.split('loss')[2].split('.pth')[0]))) # 按键进行排序

print("val_loss_min_top%d:\n"%top,val_loss_min[0:top]) # 输出前3个val_loss 最小的三个值
print(('-'*100))
# print(a)
print("train_loss_min_top%d:\n"%top,train_loss_min[0:top])
print(('-' * 100))
print("sum_loss_min_top%d\n"%top,sum_loss_min[0:top])

9，论文图片拼接.py 将多张图片调整为统一尺寸纵向横向拼接

# "燕山大学机械工程“
# 职业：学生
# 开发时间：2022-07-28 21:55
import cv2
import numpy as np
import os
import numpy as np # 数值计算工具包
import cv2 # 读取格式是BRG
import os

datasets_path = "C:\\Users\\12281\\Desktop\\6"
desize=(144,256)
list=[]
def cv_show(imge, name):
cv2.imshow(str(name), imge) # str(name)需要进行一个字符串的转换
cv2.waitKey(0)
cv2.destroyAllWindows()
if __name__ == "__main__":

types_name = os.listdir(datasets_path)
for id, type_name in enumerate(types_name):
photos_path = os.path.join(datasets_path, type_name) # 图片的绝对路径
type_name = cv2.imread(photos_path)
type_name=cv2.resize(type_name,(112,112))
list.append(type_name)
t=tuple(list)
result=np.hstack(t)
cv2.imwrite('cd.jpg', result)
cv_show(result,result)

10，加权式双模注意力机制.py 加权式双模注意力机制

# "燕山大学机械工程“
# 职业：学生
# 开发时间：2022-07-25 14:17

import torch
import torch.nn as nn
import math

class h_sigmoid(nn.Module):
def __init__(self, inplace=True):
super(h_sigmoid, self).__init__()
self.relu = nn.ReLU6(inplace=inplace)

def forward(self, x):
return self.relu(x + 3) / 6

class h_swish(nn.Module):
def __init__(self, inplace=True):
super(h_swish, self).__init__()
self.sigmoid = h_sigmoid(inplace=inplace)

def forward(self, x):
return x * self.sigmoid(x)

def conv_bn(inp, oup, stride=1):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
nn.ReLU6()
)

def conv_dw(inp, oup, stride=1):
return nn.Sequential(
nn.Conv2d(inp, inp, 3, stride, 1, groups=inp, bias=False),
nn.BatchNorm2d(inp),
# nn.ReLU6(),
h_swish(), # 这里用H-swish 代替relu6

nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
# nn.ReLU6(), #
h_sigmoid(), # 这里更换了Relu6()激活函数
)

def conv_3x3_bn(inp, oup, stride):
return nn.Sequential(
nn.Conv2d(inp, oup, 3, stride, 1, bias=False),
nn.BatchNorm2d(oup),
h_swish()
)

def conv_1x1_bn(inp, oup):
return nn.Sequential(
nn.Conv2d(inp, oup, 1, 1, 0, bias=False),
nn.BatchNorm2d(oup),
h_swish()
)

class ChannelAttention(nn.Module): # 通道
def __init__(self, in_planes, ratio=4): # ratio 缩放倍率：这里先设为4 后期参数可以调
super(ChannelAttention, self).__init__()

self.conv_dw = conv_dw(inp=in_planes, oup=in_planes, stride=1)

# self.avg_pool = nn.AdaptiveAvgPool2d(1) # 通道深度方向全局和最大池化
# self.max_pool = nn.AdaptiveMaxPool2d(1)

# 利用1x1卷积代替全连接
self.fc1 = nn.Conv2d(in_planes, in_planes // ratio, 1, bias=False)
# self.relu1 = nn.ReLU()
self.fc2 = nn.Conv2d(in_planes // ratio, in_planes, 1, bias=False)
self.h_sigmoid = h_sigmoid()
# self.sigmoid = nn.Sigmoid()
self.h_swish = h_swish()

def forward(self, x):
AC = self.conv_dw(x) # 通过深度可分离卷积空间维度信息聚合

# Vm:对AC每个通道求和作为分母
Vm = torch.sum(AC,dim=2, keepdim=True) # Vm 就是权重向量计算公式的分母
Vm = torch.sum(Vm,dim=3, keepdim=True) # Vm 就是权重向量计算公式的分母
# 加权求分母
Vz = AC*x # 点积
V = torch.div(Vz, Vm) # 得到权重向量
# 权重向量激活
Vt1 = self.fc1(V)
Vt1 = self.h_swish(Vt1)
Vt2 = self.fc2(Vt1) # 还原通道
C = self.h_sigmoid(Vt2)
# 用激活后的权重向量进行对输入特征校准
return C

class SpatialAttention(nn.Module):
def __init__(self, channel,kernel_size=7):
super(SpatialAttention, self).__init__()
self.conv_dw = conv_dw(inp=channel,oup=channel,stride=1)
# self.conv_N = nn.Conv2d(in_channels=channel, out_channels=channel, kernel_size=3, stride=1, padding=1, bias=False) # 正常卷积不改变c、w、h 这里可以换为深度可分离卷积
self.conv_S2 = nn.Conv2d(1, 1, kernel_size=3, stride=2, padding=1, bias=False) # 步长为2的卷积 w、h 都压缩一倍
self.conv_N2 = nn.Conv2d(1, 1, kernel_size=3, stride=1, padding=1,bias=False) # 正常卷积
self.relu = nn.ReLU6() # 这里可以改为H-sigmoid
self.t_conv = nn.ConvTranspose2d(in_channels=1,out_channels=1,stride=2,kernel_size=4, # 反卷积
padding=1,
output_padding=0, # 注意这里是2d不是1d
bias=False
)
# self.bn = nn.BatchNorm2d(channel)
self.h_swish=h_swish()
# self.Sigmoid = nn.Sigmoid()
# assert kernel_size in (3, 7), 'kernel size must be 3 or 7'
# padding = 3 if kernel_size == 7 else 1 # padding=int(kernel_size//2)
# self.conv1 = nn.Conv2d(2, 1, kernel_size, padding=padding, bias=False) # 输入的是2通道输出是1通道一次卷积
# self.sigmoid = nn.Sigmoid()
self.h_sigmoid=h_sigmoid()

def forward(self, x):
# s = self.conv_N(x)
A= self.conv_dw(x) # 深度可分离卷积，进行通道信息聚合
# s = self.bn(s)
# s = self.Sigmoid(s) # s 特征Y注意力池化聚合权重 A

Sm = torch.sum(A, dim=1, keepdim=True) # 通道增加的方向进行求和，通道变成1
Sz = A*x # 分子聚合权重A相乘输入特征点积
sz = torch.sum(Sz, dim=1, keepdim=True)
TS = torch.div(sz, Sm) # 点除与点乘相反
t = self.conv_S2(TS) # 步长为2降采样卷积 W,H 缩短一半
t = self.h_swish(t) # 激活
t = self.conv_N2(t) # 普通卷积
t = self.h_swish(t) # h-swish激活
t = self.t_conv(t) # 上采样卷积
S= self.h_sigmoid(t) # 这个就是最终要输出的权重
return S

class DAC(nn.Module):
def __init__(self, channel, ratio=8, kernel_size=3):
super(DAC, self).__init__()
self.channelattention = ChannelAttention(channel, ratio=ratio)
def forward(self, x):
C = self.channelattention(x)
return C

class DAS(nn.Module):
def __init__(self, channel, ratio=8, kernel_size=3):
super(DAS, self).__init__()
# self.channelattention = ChannelAttention(channel, ratio=ratio)
self.spatialattention = SpatialAttention(channel,kernel_size=kernel_size)

def forward(self, x):
# x = x * self.channelattention(x)
S = self.spatialattention(x)
return S

class DACS_block(nn.Module):
def __init__(self, channel, ratio=8, kernel_size=7):
super(DACS_block, self).__init__()
self.channelattention = DAC(channel, ratio=ratio)
self.spatialattention = DAS(channel,kernel_size=kernel_size)

def forward(self, x):
x = x * self.channelattention(x)
x = x * self.spatialattention(x)
return x

if __name__ == "__main__":
print("-"*70)
model = DACS_block(channel=160)#channel 需要给输入通道的
print(model)
inputs = torch.randn(2,160,160,160) # 正态分布的初始化一个张量4维度
print(inputs)
outputs = model(inputs)
model_dict = model.state_dict()
print(outputs.shape)

11，除水印.py 除图片水印

import cv2
import numpy as np

if __name__ =='__main__':
img_path = "C:\\Users\\12281\\Desktop\\12\\0.jpg"

img1 = cv2.imread(img_path)
cv2.namedWindow('img1',cv2.WINDOW_FREERATIO)
cv2.imshow('img1',img1)

# 转化为灰度图
gray = cv2.cvtColor(img1,cv2.COLOR_BGR2GRAY)
# 创建一个白画布
ellipse_img = np.full((img1.shape[0],img1.shape[1],3),0,dtype = np.uint8)
print(ellipse_img.shape,ellipse_img[0][0])
gray = cv2.GaussianBlur(gray,(5,5),0) # 高斯处理
# 应用霍夫圆检测,检测出所有圆
circles = cv2.HoughCircles(gray,cv2.HOUGH_GRADIENT,1,gray.shape[0]/8,100,100,100,0)

# 找到最大的圆
measure = 0.0
x = 0.0
y = 0.0
for circle in (circles[0]):
if circle[2] > measure:
measure = circle[2]
x = circle[0]
y = circle[1]

# 绘制圆
cv2.circle(img1,(x,y),3,(0,255,0),-1,8,0)
cv2.circle(img1,(x,y),int(measure),(0,255,0),2,8,0)
# 绘制相同大小的圆
ellipse_img = cv2.ellipse(ellipse_img,(x,y),(int(measure),int(measure)),0,0,360,(255,255,255),-1,8)
print(f'center x is {x} ,y is {y}, radius is {measure}')
ellipse_img = cv2.cvtColor(ellipse_img,cv2.COLOR_BGR2GRAY)

result = cv2.bitwise_and(gray,ellipse_img)

cv2.namedWindow('bitwise and',cv2.WINDOW_FREERATIO)
cv2.imshow('bitwise and',result)

# 估计圆图像像素强度
x = result[int(x+30)][int(y)]
print(f'intensity is {x}')

# 阈值分割
_,ellipse_img = cv2.threshold(result,int(x) - 10,250,cv2.THRESH_BINARY)
# print('ellipse_img shape is {}'.format(ellipse_img.shape))
cv2.namedWindow('threshold',cv2.WINDOW_FREERATIO)
cv2.imshow('threshold',ellipse_img)

# 使用 bitwise_or 方法
print('shape ------------\n')
print(ellipse_img.shape,gray.shape)
res = cv2.bitwise_or(gray,ellipse_img)

cv2.namedWindow('bitwise_or',cv2.WINDOW_FREERATIO)
cv2.imshow('bitwise_or',res)

cv2.waitKey(0)

12，删除指定字符.py 批量修改文件或者文件夹的重命名、按一定的顺序重命名、带序号的命名，以一定的顺序重命名

'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import cv2
import numpy as np
import PIL.Image as Image

path = 'C:\\Users\\12281\\Desktop\\process0' # 文件夹地址
path_save ='C:\\Users\\12281\\Desktop\\process_test'

def fond():
for root, dirs, files in os.walk(path, topdown=False):
new_root = root.replace(path, path_save) # 原路径保存
for name in files: # dirs：Prints out sub-directories from root.# files 具体文件名字
t = 0
file_ext = os.path.splitext(name) # 分离文件前后缀，front为前缀名，ext为后缀名
front, ext = file_ext # 将前后缀分别赋予front和ext
if ext != '.jpg':
# if front[-1]== '.':
re_name=name[:-4]+".jpg"
try:
os.rename( # 实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root,re_name ))
except: # 报错的话就会执行下面的东西
t= "_"+name
os.rename( # 防止更改后的文件名与先有的文件名重复，这里做个记号实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root, t))

if __name__ == "__main__":
fond()

另一个

'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import cv2
import numpy as np
import PIL.Image as Image

path = 'C:\\Users\\12281\\Desktop\\test' # 文件夹地址
path_save = 'C:\\Users\\12281\\Desktop\\test'

def fond():
for root, dirs, files in os.walk(path, topdown=False):
new_root = root.replace(path, path_save) # 原路径保存
for name in files: # dirs：Prints out sub-directories from root.# files 具体文件名字
file_ext = os.path.splitext(name) # 分离文件前后缀，front为前缀名，ext为后缀名
front, ext = file_ext # 将前后缀分别赋予front和ext
if front== 'unmasked':
n=len(files)-1
t = str(n)+".jpg"
try:
os.rename( # 实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root, t))
except: # 报错的话就会执行下面的东西
t= "_"+t
os.rename( # 实现重命名操作
os.path.join(new_root, name),
os.path.join(new_root, t))

if __name__ == "__main__":
fond()

删除或保留指定格式的文件或者文件夹.py保留文件名中包含有指定字符的文件夹

'''
按文件名进行排序输出“最大”或“最小”文件名字
'''
import os
import cv2
import numpy as np
import PIL.Image as Image
import shutil

path = 'C:\\Users\\12281\\Desktop\\CASIA_masked' # 文件夹地址
path_save = 'C:\\Users\\12281\\Desktop\\CASIA_masked'

def fond():
count=0
for root, dirs, files in os.walk(path, topdown=False):
for dir in dirs: # dirs：Prints out sub-directories from root.# files 具体文件名字
try:
if dir.split("_")[1] == "mk":
pass
except:
# os.remove(os.path.join(root, dir)) # 这个只能删除某个文件
# os.remove –删除文件。
# os.rmdir –删除文件夹。
# shutil.rmtree –删除目录及其所有内容。
shutil.rmtree(os.path.join(root, dir)) # 删除文件夹极其内部的文件
count = count + 1
pass
print(count)

if __name__ == "__main__":

fond()
13，com串口_test.py STM32单片机串口与电脑上位机连接通讯的代码

#!/usr/bin/python
# encoding:utf-8
#
import time
import serial
import serial.tools.list_ports

plist = list(serial.tools.list_ports.comports()) # 使用此方法得到可用的usb口数据，把是串口的输出成列表
if len(plist) <= 0: # 如果输出的列表是空的说明没有打开任何串口
print("没有发现端口!")
else:
plist_0 = list(plist[0])
print(plist)
serialName = plist_0[0]
print("可用端口名>>>",serialName)
ser = serial.Serial(serialName, 9600, 8, 'N', 1) # 设置了第一个串口号，波特率数据位奇偶校验停止位
while True:
ser.write('A'.encode()) # 向串口内写入数据'A' 两位数分别对应了单片机的两个
count = ser.inWaiting() # 当没有数据传回电脑时，程序顺序执行到此处进行等待
if count > 0:
recive = ser.read(count) # 电脑读取单片机回传数据的方法
if len(recive)==5: # 如果检测成果则就开始执行下面进入到编码和识别阶段
print("识别成功")
print(recive)
time.sleep(0.8) # 延时操作，程序顺序等待0.2秒
print("success")
# ser.write('01\r\n'.encode()) # 1代表电量，0代表熄灭
# time.sleep(0.2)

# !/usr/bin/python
# encoding:utf-8
#
# import serial
# import serial.tools.list_ports
#
# """查看可用串口操作"""
# plist = list(serial.tools.list_ports.comports())
# if len(plist) <= 0:
# print("没有发现端口!")
# else:
# plist_0 = list(plist[0])
# serialName = plist_0[0]
# # serialFd = serial.Serial(serialName, 9600, timeout=60)
# print("可用端口名>>>", serialName)
#
# '''电脑接收数据'''
#
# def recive_serial():
# ser = serial.Serial(serialName, 9600, 8, 'N', 1) # 设置了第一个串口号，波特率，读超时设置
# # ser.open()
# while True:
# # ser.write('10\r\n'.encode())
# count = ser.inWaiting() # 当没有数据传回电脑时，程序顺序执行到此处进行等待
# if count > 0:
# recive = ser.read(count) # 电脑读取单片机回传数据的方法
# # if recive == b'01\r\n': # 没有经过处理，直接硬骇识别
# if len(recive) == 2: # 如果检测成果则就开始执行下面进入到编码和识别阶段
# print("识别成功")
# print(recive)
# recive_serial()

另一个

import serial

# 串口打开函数
def open_ser():
port = 'COM7' # 串口号
baudrate = 115200 # 波特率
try:
global ser
ser = serial.Serial(port, baudrate, timeout=2)
if ser.isOpen() == True:
print("串口打开成功")
except Exception as exc:
print("串口打开异常", exc)

# 数据发送
def send_msg():
try:
send_datas = input("请输入要发送的数据:\n")
ser.write(str(send_datas + '\r\n').encode("gbk"))
print('-' * 80)
print("已发送数据:")
print(send_datas)
print('-' * 80)
# send_datas1 = 875
# ser.write(str(send_datas1).encode("gbk"))
# print("已发送数据:", send_datas1)
except Exception as exc:
print("发送异常", exc)

# 接收数据
def read_msg():
try:
print("等待接收数据......")
while True:
data = ser.read(ser.in_waiting).decode('gbk')
if data != '':
break
print('-' * 80)
print("已接受到数据:")
print(data)
print('-' * 80)
except Exception as exc:
print("读取异常", exc)

# 关闭串口
def close_ser():
try:
ser.close()
if ser.isOpen():
print("串口未关闭")
else:
print("串口已关闭")
except Exception as exc:
print("串口关闭异常", exc)

if __name__ == '__main__':
ser = None
open_ser() # 打开串口

while 1:
print('----------请选择你要进行的操作----------')
print('---1:发送数据--2:接收数据--3:关闭串口---')
op = input('请输入:')
if op == '1':
send_msg() # 写数据
if op == '2':
read_msg() # 读数据2
if op == '3':
close_ser() # 关闭串口
break

14，picture2mp4.py图片按一定的顺序转合成为MP4

import numpy as np
import cv2
import os

# 1.每张图像大小
size = (2500, 1900)
print("每张图片的大小为({},{})".format(size[0], size[1]))
# 2.设置源路径与保存路径
src_path ='C:\\Users\\12281\\Desktop\\7\\0.0\\'
sav_path ='C:\\Users\\12281\\Desktop\\7\\organoid4.mp4'
# 3.获取图片总的个数
all_files = os.listdir(src_path)
index = len(all_files)
print("图片总数为:" + str(index) + "张")
# 4.设置视频写入器
fourcc = cv2.VideoWriter_fourcc(*'mp4v') # MP4格式
# 完成写入对象的创建，第一个参数是合成之后的视频的名称，第二个参数是可以使用的编码器，第三个参数是帧率即每秒钟展示多少张图片，第四个参数是图片大小信息
videowrite = cv2.VideoWriter(sav_path, fourcc, 2, size) # 2是每秒的帧数，size是图片尺寸
# 5.临时存放图片的数组
img_array = []

# 6.读取所有jpg格式的图片 (这里图片命名是0-index.jpg example: 0.jpg 1.jpg ...)
for filename in [src_path + r'{0}.jpg'.format(i) for i in range(0, index)]:
img = cv2.imread(filename)
if img is None:
print(filename + " is error!")
continue
img_array.append(img)
# 7.合成视频
for i in range(0, index):
img_array[i] = cv2.resize(img_array[i], (2500, 1900))
videowrite.write(img_array[i])
print('第{}张图片合成成功'.format(i))
print('------done!!!-------')

或者下面的这个

import numpy as np
import cv2
import os

# 1.每张图像大小
size = (2500, 1900)
print("每张图片的大小为({},{})".format(size[0], size[1]))
# 2.设置源路径与保存路径
src_path ='C:\\Users\\12281\\Desktop\\7\\0.0\\'
sav_path ='C:\\Users\\12281\\Desktop\\7\\organoid4.mp4'
# 3.获取图片总的个数
all_files = os.listdir(src_path)
index = len(all_files)
print("图片总数为:" + str(index) + "张")
# 4.设置视频写入器
fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4格式
# 完成写入对象的创建，第一个参数是合成之后的视频的名称，第二个参数是可以使用的编码器，第三个参数是帧率即每秒钟展示多少张图片，第四个参数是图片大小信息
videowrite = cv2.VideoWriter(sav_path, fourcc, 2, size)  # 2是每秒的帧数，size是图片尺寸
# 5.临时存放图片的数组
img_array = []

# 6.读取所有jpg格式的图片 (这里图片命名是0-index.jpg example: 0.jpg 1.jpg ...)
for filename in [src_path + r'{0}.jpg'.format(i) for i in range(0, index)]:
    img = cv2.imread(filename)
    if img is None:
        print(filename + " is error!")
        continue
    img_array.append(img)
# 7.合成视频
for i in range(0, index):
    img_array[i] = cv2.resize(img_array[i], (2500, 1900))
    videowrite.write(img_array[i])
    print('第{}张图片合成成功'.format(i))
print('------done!!!-------')

15，摄像头黑屏遮挡检测（摄像头被遮挡就会被检测到”可以触发报警“）
# 开发时间：2023-03-24 20:59
import numpy as np
import cv2
from PIL import Image, ImageDraw, ImageFont

if __name__ == '__main__':
cap = cv2.VideoCapture(0)
cap.set(3, 112)
cap.set(4, 112)
# cv2.namedWindow('test_cam', cv2.WINDOW_NORMAL) # 窗口大小可设置

def cv2AddChineseText(img, text, position, textColor=(0, 255, 0), textSize=30):
if (isinstance(img, np.ndarray)): # 判断是否OpenCV图片类型
img = Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
# 创建一个可以在给定图像上绘图的对象
draw = ImageDraw.Draw(img)
# 字体的格式
fontStyle = ImageFont.truetype(
"simsun.ttc", textSize, encoding="utf-8")
# 绘制文本
draw.text(position, text, textColor, font=fontStyle)
# 转换回OpenCV格式
return cv2.cvtColor(np.asarray(img), cv2.COLOR_RGB2BGR)

while True:
ret, frame = cap.read() # 读取视频

if ret is False: # 当所有帧读取完毕后退出循环
print('视频读取失败 or 视频读取完毕')
break
s=np.var(frame)
v=np.mean(frame)
if s<=2000:
# pass
frame = cv2AddChineseText(frame, "已遮挡!!!", (10, 20), (255, 0, 0), 100)
print(s)
# print(v)
# frame = cv2.putText(frame, "s= %.2f" % (fps), (0, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) # 1指1号字

cv2.imshow("video", frame) # p 重复一帧帧的显示
c = cv2.waitKey(1) & 0xff # p cv2.waitkey(1)返回值为-1，参数为0 按任意键跳出等待 esc 的asii为27 谁个0xff与都是谁
if c == 27:
cap.release()
break
print("Video Detection Done!")

16，Mish 损失函数曲线绘制

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

e = math.e


def tanh(x):
    return (e ** x - e ** (-x)) / (e ** x + e ** (-x))


def softplus(x):
    return math.log(1 + pow(e, x))


def mish(x):
    return x * tanh(softplus(x))


x = np.linspace(-5, 5, 1000)
y = np.linspace(-5, 5, 1000)
for i in range(1000):
    y[i] = mish(x[i])
plt.plot(x, y, color='orange', linewidth=2, label='Mish')
plt.legend()
plt.savefig('mish.jpg')
plt.show()

17，Gamma 变换函数曲线曲线绘制

import numpy as np
import matplotlib.pyplot as plt


font1 = {'family' : 'Times New Roman',

'weight' : 'normal',

'size' : 18,

}

gamma0 = 4.0
gamma1= 1/2.2

gamma3=1/4.0
gamma4=2.2

x = np.arange(0, 256, 1)
y1= 255 / (pow(255,gamma0))   *    (pow(x,gamma0))
y2= 255 / (pow(255,gamma1))   *    (pow(x,gamma1))

y4= 255 / (pow(255,gamma3))   *    (pow(x,gamma3))

y5= 255 / (pow(255,gamma4))   *    (pow(x,gamma4))
# y5= 255 / (pow(255,gamma2))   *    (pow(x,gamma2))
# y6= 255 / (pow(255,1/gamma2))   *    (pow(x,1/gamma2))


y7=x
# y2=pow(x,gamma)
# plt.subplot(2,2,1)
A=plt.plot(x,y1,'b',label='gamma = 4.0')
B=plt.plot(x,y2,'r',label='gamma = 1/2.2')

# legend = plt.legend(handles=[A,B],prop=font1)

C=plt.plot(y4,'g',label='gamma = 1/4.0')

D=plt.plot(y5,'m',label='gamma = 2.2')

E=plt.plot(y7,'--',label='gamma = 1',)


plt.xlabel('Input',font1)
plt.ylabel('Output',font1)
# plt.title('Gamma correction')
plt.legend()
plt.savefig('gamma_curve.png')
plt.show()
#
# a = np.arange(0, 256, 1)
# plt.figure(1)
# plt.subplot(2, 2, 1)
# plt.plot(a)  # 原始
#
# b = ((a + 0.5) / 256)
# plt.subplot(2, 2, 2)
# plt.plot(b)  # 归一化
#
# c = pow(b, 1 / gamma)
# plt.subplot(2, 2, 3)
# plt.plot(c)  # 校正
#
# d = c * 256 - 0.5
# plt.subplot(2, 2, 4)
# plt.plot(d)  # 反归一化
# plt.show()

18，图片光照补偿

# "燕山大学机械工程“
# 职业：学生
# 开发时间：2022-06-07 11:21
import cv2
import numpy as np

def unevenLightCompensate(img, blockSize):
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
    average = np.mean(gray)

    rows_new = int(np.ceil(gray.shape[0] / blockSize))
    # gray.shape[0]取元组中的第一个位置的元素。
    #rows_new=34 行方向被分成34块
    cols_new = int(np.ceil(gray.shape[1] / blockSize))
    # 列方向被分成30块
    # np.ceil 函数返回输入值的上限，即对于输入 x（-1.7） ，返回最小的整数 i （-1），使得 i> = x。向上取整
    # np.floor 返回不大于输入参数的最大整数。 即对于输入值 x ，将返回最大的整数 i ，使得 i <= x。向下取整
    blockImage = np.zeros((rows_new, cols_new), dtype=np.float32)
    # 34x30的0矩阵
    for r in range(rows_new):
        for c in range(cols_new):
            rowmin = r * blockSize
            rowmax = (r + 1) * blockSize
            if (rowmax > gray.shape[0]):
                rowmax = gray.shape[0]
            colmin = c * blockSize
            colmax = (c + 1) * blockSize
            if (colmax > gray.shape[1]):
                colmax = gray.shape[1]

            imageROI = gray[rowmin:rowmax, colmin:colmax]
            # imageROI 的shape是个元组——取出时类似数组，大小是（9*9）的
            temaver = np.mean(imageROI)
            #对每一个block求均值，一个blocksize大小是9*9
            #第一个block中的均值求出得227.44
            # 按列进行遍历的，第一个行块，对应下面各列进行遍历，得到各个区域得均值
            # 对创建得34x30的0矩阵进行赋值（34、30也代表图片被分成了多少个块）
            blockImage[r, c] = temaver
    # 各块均值减去原始输入灰度图总的均值
    blockImage = blockImage - average
    # 将原图片转化width和height可以自己任意指定，不论大小
    # 默认使用双线性插值法；interpolation 插值
    # interpolation（插值）：这个是指定插值的方式，图像缩放之后，肯定像素要进行重新计算的，就靠这个参数来指定重新计算像素的方式，有以下几种：
    # INTER_NEAREST - 最邻近插值
    # INTER_LINEAR - 双线性插值，如果最后一个参数你不指定，默认使用这种方法
    # INTER_CUBIC - 4x4像素邻域内的双立方插值
    # INTER_LANCZOS4 - 8x8像素邻域内的Lanczos插值
    # ————————————————
    # 版权声明：本文为CSDN博主「AI bro」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
    # 原文链接：https://blog.csdn.net/weixin_41466575/article/details/113058802
    blockImage2 = cv2.resize(blockImage, (gray.shape[1], gray.shape[0]), interpolation=cv2.INTER_CUBIC)

    gray2 = gray.astype(np.float32)
    dst = gray2 - blockImage2
    dst = dst.astype(np.uint8)
    dst = cv2.GaussianBlur(dst, (3, 3), 0)
    dst = cv2.cvtColor(dst, cv2.COLOR_GRAY2BGR)

    return dst

if __name__ == '__main__':
    file = '4.jpg'
    blockSize = 9
    img = cv2.imread(file)
    dst = unevenLightCompensate(img, blockSize)

    result = np.concatenate([img, dst], axis=1)

    cv2.imshow('result', result)
    cv2.waitKey(0)

19,HSV颜色空间转换

# 开发时间：2022-06-06 20:05
import cv2
import numpy as np
from matplotlib import pyplot as plt

img = cv2.imread('scene.png')
# 通过cv2.cvtColor把图像从BGR转换到HSV
img_hsv = cv2.cvtColor(img, cv2.COLOR_BGR2HSV)
# H空间中，通过增加像素灰度值可以改变图像的色调
turn_green_hsv = img_hsv.copy()
turn_green_hsv[:, :, 0] = (turn_green_hsv[:, :, 0] + 150) % 180
# 表仅对turn_green_hsv[:, :, 0]的通道0即H（色调）的数值相加在取余，前两个参数分别为：w、h宽度和高度；HSV，H通道取值范围[0:180]
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[:, :, 1] = 0.5 * colorless_hsv[:, :, 1]
colorless_img = cv2.cvtColor(colorless_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('../../test_function/colorless.jpg', colorless_img)

# 减小明度为原来一半
darker_hsv = img_hsv.copy()
darker_hsv[:, :, 2] = 0.5 * darker_hsv[:, :, 2]
darker_img = cv2.cvtColor(darker_hsv, cv2.COLOR_HSV2BGR)
cv2.imwrite('darker.jpg', darker_img)

20，水平翻转图片

# 职业：学生
# 开发时间：2022-04-24 16:46
import os

import cv2
import sys
# 从视频中获取图片
import torch
from PIL import Image


def CatchPICFromVideo(window_name,img_array):
    # cv2.namedWindow(window_name)
    # 视频来源，可以来自一段已存好的视频，也可以直接来自USB摄像头
    # 告诉OpenCV使用人脸识别分类器
    # classfier = cv2.CascadeClassifier("D://pycharm//renlianku_model//haarcascade_frontalface_alt2.xml")

    # 识别出人脸后要画的边框的颜色，RGB格式 用绿色框画出来
    # color = (0, 255, 0)

    # num = 0
    while cap.isOpened():
        ok, frame = cap.read()  # 读取一帧数据

        if not ok:
            break
        # frame = frame[:, ::-1, :]
        # frame=torch.Tensor(frame)
        # frame = frame.transpose(Image.FLIP_LEFT_RIGHT)  # 水平翻转
        # frame = frame.numpy()
        # frame=cv2.flip(frame, 1)
        frame=frame[:, ::-1, :]
        img_array.append(frame)
    print(len(img_array))
    cap.release()
    cv2.destroyAllWindows()
    return img_array
if __name__ == '__main__':
    dir_origin_path='D:\\pycharm\\pytorch-1\\facenet-retinaface-pytorch-main-gpu-ing\\3D_CNNaction\\data\\ucf101\\normal'
    num = 400
    size = (160, 160)
    sav_path = 'C:\\Users\\12281\\Desktop\\normal_flip'
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    for root, dirs, files in os.walk(dir_origin_path, topdown=False):
        for name in files:
            imgpath = os.path.join(root, name)
            cap = cv2.VideoCapture(imgpath)
            img_array = []
            sav_path_end = os.path.join(sav_path, str(num) + '.mp4')
            if not os.path.isdir(sav_path):
                os.makedirs(sav_path)
            videowrite = cv2.VideoWriter(sav_path_end, fourcc, 2,size)
            img_array  = CatchPICFromVideo('mywindow',img_array)#p05-20相对路径的表示方法
            for i in range(len(img_array)):
                img_array[i] = cv2.resize(img_array[i], (160,160))
                videowrite.write(img_array[i])
                print('第{}张图片合成成功'.format(i))
            num=num+1
            print('------done!!!-------')



# size = (2500, 1900)
# print("每张图片的大小为({},{})".format(size[0], size[1]))
# # 2.设置源路径与保存路径
#
# sav_path ='C:\\Users\\12281\\Desktop\\7\\organoid4.mp4'
# # 3.获取图片总的个数
# all_files = os.listdir(src_path)
# index = len(all_files)
# print("图片总数为:" + str(index) + "张")
# # 4.设置视频写入器
# fourcc = cv2.VideoWriter_fourcc(*'mp4v')  # MP4格式
# # 完成写入对象的创建，第一个参数是合成之后的视频的名称，第二个参数是可以使用的编码器，第三个参数是帧率即每秒钟展示多少张图片，第四个参数是图片大小信息
# videowrite = cv2.VideoWriter(sav_path, fourcc, 2, size)  # 2是每秒的帧数，size是图片尺寸
# # 5.临时存放图片的数组
# img_array = []
#
# # 6.读取所有jpg格式的图片 (这里图片命名是0-index.jpg example: 0.jpg 1.jpg ...)
# for filename in [src_path + r'{0}.jpg'.format(i) for i in range(0, index)]:
#     img = cv2.imread(filename)
#     if img is None:
#         print(filename + " is error!")
#         continue
#     img_array.append(img)
# # 7.合成视频
# for i in range(0, index):
#     img_array[i] = cv2.resize(img_array[i], (2500, 1900))
#     videowrite.write(img_array[i])
#     print('第{}张图片合成成功'.format(i))
# print('------done!!!-------')

P13643822101

关注

19
点赞
踩
22

收藏

觉得还不错? 一键收藏
0
评论
（酒驾检测、人脸检测、疲劳检测、模拟口罩数据集制作、防酒驾）-常用的论文所用的python代码总结

sum_loss_min.sort(key=lambda x:(float(x.split('loss')[1].split('-')[0])+float(x.split('loss')[2].split('.pth')[0]))) # 按键进行排序。# frame = cv2.putText(frame, "s= %.2f" % (fps), (0, 40), cv2.FONT_HERSHEY_SIMPLEX, 1, (0, 255, 0), 2) # 1指1号字。
复制链接

扫一扫