**Xshell 用于和远程服务器进行ssh访问 





Xftp 用于和远程服务器使用ftp协议传文件**

（Xshell 还可以各种协议和设备连，很强大。）

1 安装，申请免费版的个人就够用了

[https://www.netsarang.com/zh/xshell-download/](https://www.netsarang.com/zh/xshell-download/)

![在这里插入图片描述](/static/img/images/02708.png)

2 连接到服务器

有域名：

打开Xshell，输入命令ssh elvisiky.com，连接到域名，对于没有选项让写入用户名的机器，比如mac，输入命令ssh root@elvisiky.com

没域名直接 ssh 47.94.9.151

 ![在这里插入图片描述](/static/img/images/02709.png)

 ![在这里插入图片描述](/static/img/images/02710.png)

 ![在这里插入图片描述](/static/img/images/02711.png)


 

3 玩一下服务器

![在这里插入图片描述](/static/img/images/02712.png)

 

文件传输

 ![在这里插入图片描述](/static/img/images/02713.png)

Xshell Xftp连接服务器

记得儿时在奶奶家，有一次在有一间屋子玩耍，那是一间存储杂草柴火的屋子，连着猪圈里的老黑猪，背后的门也通着后背的山。我回忆起这里的时候，脑袋给我补充了在另外的时间刻度里奶奶在厨房忙活地做着饭。






常说睹物思人，乡愁寄相思，当我今晚突然回忆起那间屋子的时候，我开始惴惴不安起来。我突然发现我一直以来没有用成段的时间去悼念我的奶奶，我记忆里空空的，可我是想得起来的。现在这个时刻我是回忆起来了，但是也然后在深夜里再也睡不着开始哭起来。


我没有为我奶奶哭多少次，一个手都数得过来。奶奶临终前患癌卧床，我们子孙辈都曾探望。后来几周后的有一天，金光反照精神焕发地做了好多事，第二天就与世长辞而去。我在奶奶的灵堂里看见爸爸憔悴得老了一圈，而我在奶奶灵堂却一直没有哭，只是和姐姐黯然在灵堂外沉默。而后来的这些时光里，每次想到我奶奶，我就泪水决堤不能自已，这次更甚。


奶奶去世了这么多年，我想她的次数却那么少。我不理解我为什么如此慢热，大家可能以为在当时我没有太多过激的感伤，而连我自己也没想到，在后来的这些年里，我思绪兜兜转转回到了家乡奶奶在的那个房子里，我执念着走不出来那个有奶奶在世的地方。


在漫漫岁月里，我才意识到了一些难过的事实，我已经再也见不到她老人家的身影，也不能再听见她老人家呼我名字，也不能再吃到她的饭菜。


回忆是如此洪水野兽地袭来。我想起小时候过年就盛装跋山涉水两个小时去我奶奶家过寒暑假；我想起有夏天在奶奶家吃玉米；我想起在奶奶家的阳台上乘凉看星星；我想起奶奶家的厨房后来才搬到楼下去了；我想起奶奶在地里做农活；我想起奶奶家门前的绿油油的菜和大大的池塘；我想起在奶奶家洗澡；我想起了奶奶家的床和屋子，每一间都有奶奶的故事。我想起了奶奶家门前的那座山。我想起了那条高速公路的建设。我想起奶奶的另一处老房子。想起奶奶临终的虚弱。想起了奶奶的灵堂。想起了奶奶的坟墓。


我的记忆好像是之前被封住了，现在突然一下子都放了出来。而让我更难过的是，这些都只能是回忆，而且还是那么久远的回忆，那么模糊得让人难受的回忆。


人被困在记忆里真是好痛。这种不能释怀的事情让人头痛欲裂。


岁月无情，忙得失去了回忆的权利，偶尔回忆意识起来又没有博学大爱引导，只能涕泗横流。我接受不了奶奶去世带给我的痛，参透不了时间与生死，我是一个俗人。


一段年龄一段思考，或许是以前忙着学习，忙着玩耍，忙着工作吧，现在年龄到了，从没有想的事情和难题都来到了面前。我更相信道法与命运了，仿佛一切都早有安排了。


脑子里的回忆和山上的坟墓，是奶奶留在这世上的不多的东西吧。子孙辈和坟墓相顾无言，唯有泪满行。在这恍惚的一生中，人最终归于尘土，奶奶在另一个世界望我们幸福安康，我在这个世界里守着奶奶那安静的灰烬望她不要挂念一路走好。我想，她和我都知道这只是美好的幻想，但却也是最想成为真实的真实。


希望我在以后过世的时候，大脑能让我在切身游历一遍我的记忆，不要再那么模糊那么快，让我能再看那些人、那些事一遍，再听一遍奶奶的声音，让我在这些歌谣里微笑离场。


2022-07-10 02:00:00

【回忆】奶奶的歌谣

>你不是我权衡利弊之后的选择，而是我怦然心动后，明知不可为而为之的坚定，这是我对这份感情最大的诚意。

【摘录】关于爱情

她说，人最大的烦恼就是记性太好。如果可以把所有东西忘掉，以后的每一天将是一个新的开始。

她说，人最大的烦恼就是记性太好

> 曾经以为老去是很遥远的事情，突然发现，转眼之间，已经度过了数十年！留给我在这人生中的时间，还有多少。

曾经以为老去是很遥远的事情

> “今天的云很好看，想拍给你看，却想到我们很久不联系了，突然觉得，云也没那么好看了”

今天的云很好看

原谅向日葵爱上月亮





原谅鳄鱼爱上圣女果

就是原谅爱

就是原谅彩虹色的诗意

就是原谅孱弱的心在暗夜下的燃烧

原谅她

原谅她们

这本是浪漫的出入口

却被这铁铸的世界

烙上反常的寓言

原谅向日葵爱上月亮

老奶奶对这棵树十分不舍，草木有心，人生岁月中，她与树互见彼此。





生命的轮回里，聚散有时，告别却无时不刻。

摘录

# 背景





背景：手机端需要调用深度学习模型的计算。

方案：python训练模型-->转到MNN框架模型-->放入C++调用（SDK）-->Java调用SDK（JNI）.

MNN Python API   [https://www.yuque.com/mnn/cn/usage_in_python#x8YNO](https://www.yuque.com/mnn/cn/usage_in_python#x8YNO)

# 系统环境

CentOS Linux release 7.9.2009 (Core)

Linux iZuf627r0ggzf84xn57fuvZ 3.10.0-1160.62.1.el7.x86_64

Tesla V100 32G CUDA11

Miniconda3

推荐Linux系统，不推荐Windows系统。

安装：
```shell
sudo yum install cmake3 protobuf -y
```

注意： CMake 3.0 or higher is required， 所以：

```shell
sudo ln -s /usr/bin/cmake3 /usr/bin/cmake
```

# MNN介绍

直接查看文档：[https://github.com/alibaba/MNN/blob/master/README_CN.md](https://github.com/alibaba/MNN/blob/master/README_CN.md)

![在这里插入图片描述](/static/img/images/04846.png)

![在这里插入图片描述](/static/img/images/04847.png)

![在这里插入图片描述](/static/img/images/04848.png)

工具

MNN-Converter：模型转换工具，由Frontends和Graph Optimize构成。前者负责支持不同的训练框架，MNN当前支持Tensorflow(Lite)、Caffe、ONNX(PyTorch/MXNet的模型可先转为ONNX模型再转到MNN)和Torchscripts；后者通过算子融合、算子替代、布局调整等方式优化图，一般离线运行。

MNN-Compress: 模型压缩工具，在一定的精度误差许可下，对MNN模型进行压缩，减少模型体积，提升运行性能。

MNN-Express ：支持带控制流的模型运行，支持调用 MNN 的算子进行自定义的计算。

MNN-CV ：类似 OpenCV ，但核心计算功能基于 MNN 实现的图像处理算法库

MNN-Train ：MNN 训练模块，支持各平台训练

# MNN环境

参考：https://www.yuque.com/mnn/cn/demo_project

下载MNN工程：

```shell
git clone https://github.com/alibaba/MNN.git
```

编译前的选择：

`vim CMakeLists.txt` 我看CMakeLists.txt里的都很有用，我都手动ON上了，以后学习过程中说不定就用了：

![在这里插入图片描述](/static/img/images/04849.png)

编译：

```shell
cd path/to/MNN
# 生成 schema ，可选
cd schema && ./generate.sh
# 进行编译
cd path/to/MNN # 注意回到根目录
mkdir build && cd build
cmake -DMNN_BUILD_DEMO=ON ..
make -j
```

在系统中构建这个MNN后，就能使用MNN提供的众多工具了。

# Python使用MNN

**Python 3.7 支持mnn** 

代码和介绍：[https://github.com/xxddccaa/MNN_Demos](https://github.com/xxddccaa/MNN_Demos)


# 模型转换

[https://www.yuque.com/mnn/cn/model_convert](https://www.yuque.com/mnn/cn/model_convert)

# 参考文章

[https://blog.csdn.net/wl1710582732/article/details/107731147](https://blog.csdn.net/wl1710582732/article/details/107731147)

【推理框架】MNN框架 C++、Python、Java使用例子 Demo

推理框架TensorRT MNN OpenVINO ONNXRuntime的一些信息总结：





![在这里插入图片描述](/static/img/images/04864.png)

手机端阿里MNN框架论文：[https://arxiv.org/abs/2002.12418](https://arxiv.org/abs/2002.12418)，论文介绍：

![在这里插入图片描述](/static/img/images/04865.png)

【深度学习】深度学习推理框架 TensorRT MNN OpenVINO ONNXRuntime

manifest.xml加权限：





```python
<uses-permission
        android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"
        tools:ignore="ProtectedPermissions" />
    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" />
```

oncreate加代码能向用户获取权限：
```python
if (ActivityCompat.checkSelfPermission(this, Manifest.permission.READ_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 1);
        }
        //申请写权限
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);
        }
        //申请创建文件
        if (ActivityCompat.checkSelfPermission(this, Manifest.permission.MANAGE_EXTERNAL_STORAGE) != PackageManager.PERMISSION_GRANTED) {
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.MANAGE_EXTERNAL_STORAGE}, 1);
        }
```

加一个方法：

```python
public static void createFileRecursion(String fileName, Integer height) throws IOException {
        Path path = Paths.get(fileName);
        if (Files.exists(path)) {
            return;
        }
        if (Files.exists(path.getParent())) {
            if (height == 0) {
                Files.createFile(path);
            } else {
                Files.createDirectory(path);
            }
        } else {
            createFileRecursion(path.getParent().toString(), height + 1);
            createFileRecursion(fileName, height);
        }
    }
```

实现写入：

```python
                        try {
                            String jsonPath="/sdcard/Download/1.json";
                            createFileRecursion(jsonPath, 0);
                            FileWriter fileWriter = new FileWriter(jsonPath);
                            fileWriter.write(String.valueOf(msg.obj));
                            fileWriter.flush();
                            fileWriter.close();
                            Log.i("JSON_WRITE", "jsonPath: " + jsonPath);
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
```

【Android】【Java】写一个字符串到Android系统得文件里去存起来，保存字符串到文件

Appendable:[https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html](https://docs.oracle.com/javase/7/docs/api/java/lang/Appendable.html)，接口，允许append。





CharSequence：[https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html](https://docs.oracle.com/javase/8/docs/api/java/lang/CharSequence.html)，接口，字符list操作。

String：[https://docs.oracle.com/javase/7/docs/api/java/lang/String.html](https://docs.oracle.com/javase/7/docs/api/java/lang/String.html)，实现接口CharSequence，String是可哈希的，创建后就无法再改变。

StringBuilder：[https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuilder.html)，本质通过字符数组实现，非线程安全的！其他操作和StringBuffer没大的区别。

StringBuffer：[https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html](https://docs.oracle.com/javase/7/docs/api/java/lang/StringBuffer.html)，本质通过字符数组实现，线程安全！

![在这里插入图片描述](/static/img/images/04813.png)


![在这里插入图片描述](/static/img/images/04814.png)

【Java】java字符串操作，Appendable，CharSequence，String，StringBuilder，StringBuffer

# jar包下载





使用这个jar包：[https://github.com/stleary/JSON-java](https://github.com/stleary/JSON-java)

然后下载这个jar包操作读写文件更方便：[https://commons.apache.org/proper/commons-io/](https://commons.apache.org/proper/commons-io/)

![在这里插入图片描述](/static/img/images/04815.png)


# json对象写入到json文件

```java
package com.item1.hello;
import org.apache.commons.io.FileUtils;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.IOException;
public class test1 {
    // 测试json对象写入到文件
    public static void testJsonWriteFile() throws IOException {
        JSONArray ja = new JSONArray(); //json列表
        JSONObject jo = new JSONObject(); //json字典
        jo.put("filename", "test");
        jo.put("value1", 123);
        jo.put("value2", 12.34);
        jo.put("value2", true);
        ja.put(jo);  //字典推入列表
        File file = new File("json1.json");
        FileUtils.write(file, ja.toString(), "utf-8", false);
    }
    public static void main(String[] args) throws IOException {
        testJsonWriteFile();
    }
}
```

# 读取json文件成json对象



```java
package com.item1.hello;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import java.io.File;
import java.io.IOException;
import org.apache.commons.io.FileUtils;
public class test1 {
    public static void testJsonReadFile() throws IOException {
        File file=new File("json1.json");
        String content= FileUtils.readFileToString(file,"UTF-8");
        System.out.println(content);
        JSONArray ja=new JSONArray(content);
        System.out.println(ja);
    }
    public static void main(String[] args) throws IOException {
        testJsonReadFile();
    }
}
```

# 更多例子

[https://github.com/stleary/JSON-java/blob/master/Examples.md](https://github.com/stleary/JSON-java/blob/master/Examples.md)

【Java】java 读写 json文件，java读写文件

[https://mp.weixin.qq.com/s/6V5FZ8qepuOshFaFBAmn5w](https://mp.weixin.qq.com/s/6V5FZ8qepuOshFaFBAmn5w)

【java】java的命名规范

# 1 下载 





下载安装包：[链接](https://www.oracle.com/java/technologies/downloads/#java8)

![在这里插入图片描述](/static/img/images/04853.png)

# 2 安装

安装就默认安装在C盘最好，安装在其他盘JDK和JRE需要同一路径设置起来有点烦：

![在这里插入图片描述](/static/img/images/04854.png)

# 3 配置环境变量

变量名：`JAVA_HOME`

变量值：`C:\Program Files\Java\jdk1.8.0_333`

变量名：`CLASSPATH`

变量值：`.;%JAVA_HOME%\lib\dt.jar;%JAVA_HOME%\lib\tools.jar;`

变量名：`Path`

变量值：`%JAVA_HOME%\bin;%JAVA_HOME%\jre\bin;`

注意！！！！windows10好像需要绝对路径，而不能使用`%JAVA_HOME%`这样的相对路径。javac 命令不可用的话需要重启一下电脑。

![在这里插入图片描述](/static/img/images/04855.png)

![在这里插入图片描述](/static/img/images/04856.png)

# 4 测试

win+R cmd

![在这里插入图片描述](/static/img/images/04857.png)

![在这里插入图片描述](/static/img/images/04858.png)

【Windows 安装JDK8】如何安装java JDK8

1 下载安装包：[链接](https://www.oracle.com/java/technologies/downloads/#java8)





压缩包解压配置比较麻烦，直接下载RPM包。

![在这里插入图片描述](/static/img/images/04859.png)

2 CentOS7执行：

```bash
rpm -ivh jdk-8u333-linux-x64.rpm
```

【CentOS7 安装JDK8】如何安装java JDK8

三种创建方式





1 Thread Class  继承Thread类

2 Runnable接口  实现Runnable接口

3 Callable接口 实现Callable接口


# 方法一 继承Thread类

步骤：

- 自定义线程类继承Thread类。

- 重写run()方法，编写线程执行体。

- 创建线程对象，调用start()方法启动线程。


注意点：是调用start()方法，而不是run()方法。

![在这里插入图片描述](/static/img/images/00229.png)

举例：
```java
class MyThread1 extends Thread{
    private int breakfast=10;
    private String name;
    public MyThread1(String name){
        this.name=name;
    }
    public void run(){
        for(int i =0;i<500;i++){
            if(this.breakfast>0){
                System.out.println(this.name+"卖早餐---->"+(this.breakfast--));
            }
        }
    }
    public static void main(String[] args) {
        MyThread1 mt1= new MyThread1("一号窗口");
        MyThread1 mt2= new MyThread1("二号窗口");
        MyThread1 mt3= new MyThread1("三号窗口");
        mt1.start();
        mt2.start();
        mt3.start();
    }
}
```

# 方法二  实现Runnable接口

步骤：

- 自定义线程类继承实现Runnable接口。

- 实现run()方法，编写线程执行体。

- 创建线程对象，调用start()方法启动线程。

与  继承Thread类 的区别：[参考1](https://blog.csdn.net/zhaojianting/article/details/97664370)

Runnable的实现方式是实现其接口即可；

Thread的实现方式是继承其类；

Runnable接口支持多继承；

Thread实现了Runnable接口并进行了扩展，而Thread和Runnable的实质是实现的关系，不是同类东西，所以Runnable或Thread本身没有可比性。

推荐：

Runnable接口支持多继承，较为灵活，单个对象可以被多个线程调用，建议平时使用Runnable接口实现多线程。

```java
class MyThread implements Runnable{
 private int ticket = 5;
 public void run(){
  for (int i=0;i<10;i++)
  {
   if(ticket > 0){
    System.out.println("ticket = " + ticket--);
   }
  }
 }
}
public class RunnableDemo{
 public static void main(String[] args){
  MyThread my = new MyThread();
  new Thread(my).start();
  new Thread(my).start();
  new Thread(my).start();
 }
}
```

# 方法三 实现Callable接口

[参考1](http://www.monkey1024.com/javase/653)

步骤：

1.自定义一个类实现java.util.concurrent包下的Callable接口

2.重写call方法

3.将要在线程中执行的代码编写在call方法中

4.创建FutureTask对象

5.将自定义类的对象传入FutureTask构造方法里面

6.创建Thread线程对象

7.将FutureTask对象传入Thread构造方法中

创建Callable的实现类，其中的泛型Integer是call方法的返回值类型：

```java
import java.util.Random;
import java.util.concurrent.Callable;
/**
 * 多线程实现的第三种方法，实现Callable接口 优点： 可以获取返回值 可以抛出异常
 */
//1.定义一个类实现Callable<V>接口
public class MyCallable implements Callable<Integer> {
    // 2.重写call方法
    @Override
    public Integer call() throws Exception {
        // 3.将要执行的代码写在call方法中
        //返回一个随机数
        Random r = new Random();
        int num = r.nextInt(100);
        return num;
    }
}
```

测试类：

```java
MyCallable mc = new MyCallable();
//这里的泛型要跟MyCallable中的泛型一致
FutureTask<Integer> task = new FutureTask<>(mc);
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);
```

lambda写法：

```java
FutureTask<Integer> task = new FutureTask<>(() -> {
    Random r = new Random();
    int num = r.nextInt(100);
    return num;
});
//创建线程对象
Thread t = new Thread(task);
t.start();
//获取线程的运算结果
Integer result = task.get();
System.out.println(result);
```

Java 多线程编程 Java实现多线程的三种方式

# 下载安装obs studio





[https://obsproject.com/download](https://obsproject.com/download)

# 打开obs studio

在来源处添加桌面视频源，点击开始录制。

![在这里插入图片描述](/static/img/images/04540.png)

![在这里插入图片描述](/static/img/images/04541.png)

![在这里插入图片描述](/static/img/images/04542.png)

# 录制分辨率设置

![在这里插入图片描述](/static/img/images/04543.png)

基础画布分辨率一定要与桌面分辨率一样，这样能全屏录制。

![在这里插入图片描述](/static/img/images/04544.png)

# mkv转mp4文件

录制后的文件是mkv文件，转为mp4：

![在这里插入图片描述](/static/img/images/04545.png)

![在这里插入图片描述](/static/img/images/04546.png)

【obs studio】教程，如何录制屏幕和声音成为一个视频

[https://jishuin.proginn.com/p/763bfbd2fb27](https://jishuin.proginn.com/p/763bfbd2fb27)





ClickHouse 是一个用于联机分析（OLAP）的列式数据库管理系统（DBMS）。

最近很火的 ClickHouse 是什么？

# 读取具体哪一帧





这个方法可以获取某一帧：

```python
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
```

# 等待按钮

这个方法可以显示当前帧，然后等待你的按钮：

```python
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
```

这个标志打开可以让你存储一个mp4视频：

```
FLAG_SAVE_VIDEOS = False
```

# 写入解码方式与文件格式对应

不同的视频文件格式通常需要使用不同的编解码器，因此你需要根据你要创建的视频文件格式来选择合适的四字符编码标识。以下是一些常见的视频文件格式和相应的四字符编码标识示例：

1. **H.264 编码**（通常用于.mp4文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'H264')
   ```

2. **XVID 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'XVID')
   ```

3. **MJPG 编码**（通常用于.avi文件，适用于每帧图像质量高的场景）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'MJPG')
   ```

4. **DIVX 编码**（通常用于.avi文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'DIVX')
   ```

5. **VP8 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP80')
   ```

6. **VP9 编码**（通常用于.webm文件）：

   ```python
   fourcc = cv2.VideoWriter_fourcc(*'VP90')
   ```

这些是一些常见的视频文件格式和相应的四字符编码标识示例。根据你的需求和所使用的视频文件格式，选择适合的编码标识以确保视频文件可以正确编码和解码。不同的视频编辑软件和播放器也支持不同的编解码器，因此你可能需要根据最终使用情况进行调整。

# 全部代码


```python
import logging
import time
import cv2
import json
# 读取JSON文件
with open('../inoutdir/long.json', 'r') as f:
    json_data = json.load(f)
# 打开视频文件
cap = cv2.VideoCapture('../inoutdir/long.mp4')
current_frame = 0
# 配置日志记录
logging.basicConfig(level=logging.INFO, format='%(asctime)s [Frame %(frame)d / %(frame_all)d] %(message)s')
logger = logging.getLogger()
FLAG_SAVE_VIDEOS = False
if FLAG_SAVE_VIDEOS:
    output_file = '../output/long_draw.mp4'
    fourcc = cv2.VideoWriter_fourcc(*'mp4v')
    frame_width = int(cap.get(3))
    frame_height = int(cap.get(4))
    out = cv2.VideoWriter(output_file, fourcc, 30, (frame_width, frame_height))
# 初始化时间统计
start_time = time.time()
total_frames = len(json_data)
while True:
    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame)
    ret, frame = cap.read()
    if not ret:
        break
    # 记录时间戳
    frame_timestamp = time.time()
    # 从JSON中获取当前帧的检测结果
    if current_frame < len(json_data):
        detections = json_data[current_frame]['dets']
        # 在每个检测上绘制边界框
        for det in detections:
            x1, y1, x2, y2, score, class_id = det
            color = (0, 255, 0)  # 绿色边界框
            label = f'{int(class_id)},{score:.2f}'
            cv2.rectangle(frame, (int(x1), int(y1)), (int(x2), int(y2)), color, 2)
            # 计算文本位置以确保在框内
            text_x = int(x1)
            text_y = int(y1) - 10
            if text_y - 10 < 0:
                text_y = int(y1) + 20  # 如果文本位置超出了帧的上边界，则将其放在边界框的下方
            cv2.putText(frame, label, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color, 2)
    if FLAG_SAVE_VIDEOS:
        out.write(frame)  # 将当前帧写入输出视频
        current_frame += 1
    else:
        # 显示当前帧
        cv2.imshow('Video Frame', frame)
        # 等待按键输入
        key = cv2.waitKey(0)  # 使用较短的等待时间以确保视频正常播放
        if key == 27:  # ESC
            break
        elif key == ord('q'):  # Q 键（往回跳一帧）
            if current_frame > 0:
                current_frame -= 1
        elif key == ord('w'):  # W 键（往前播放一帧）
            if current_frame < len(json_data) - 1:
                current_frame += 1
    # 计算每一帧消耗的时间并记录到日志中
    frame_processing_time = time.time() - frame_timestamp
    logger.info(f'Frame processed in {frame_processing_time:.4f} seconds',extra={'frame': current_frame, 'frame_all': total_frames})
# 计算总共消耗的时间
total_processing_time = time.time() - start_time
average_frame_time = total_processing_time / total_frames if total_frames > 0 else 0
print(total_processing_time)
print(average_frame_time)
# 释放视频文件、关闭窗口和输出视频文件
cap.release()
if FLAG_SAVE_VIDEOS:
    out.release()
cv2.destroyAllWindows()
```