计算机 on 酒中仙

Redis缓存模式详解：提升系统性能的艺术

Thu, 31 Jul 2025 22:34:25 +0800

Redis缓存模式详解：提升系统性能的艺术

引言

在现代分布式系统中，缓存是提高系统性能和减轻数据库压力的关键技术。Redis作为一种高性能的内存数据存储系统，提供了多种缓存模式，每种模式都有其独特的应用场景和优缺点。本文将深入探讨三种主要的Redis缓存模式：Cache Aside、Read Through和Write Through。

1. Cache Aside模式（旁路缓存）

1.1 基本原理

Cache Aside模式是最常用的缓存模式，其核心思想是由应用程序直接控制缓存的读取和更新。

1.2 读取流程

查询缓存
缓存未命中时，从数据库读取数据
将读取的数据写入缓存
返回数据给调用方

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


def get_data(key):
 # 先查询缓存
 value = redis.get(key)

 if value is None:
 # 缓存未命中，从数据库读取
 value = database.get(key)

 # 将数据写入缓存
 if value is not None:
 redis.set(key, value, expire_time)

 return value

1.3 写入流程

更新数据库
删除对应的缓存项

1
2
3
4
5
6


def update_data(key, new_value):
 # 先更新数据库
 database.update(key, new_value)

 # 删除缓存
 redis.delete(key)

1.4 优点与缺点

优点：

实现简单
应用程序对缓存有完全的控制权
灵活性高

缺点：

可能存在短暂的数据不一致性
写操作需要额外的缓存删除步骤

2. Read Through模式（读穿透）

2.1 基本原理

Read Through模式由缓存组件自动处理缓存未命中的情况，应用程序无需关心缓存加载细节。

2.2 工作流程

查询缓存
缓存未命中时，缓存组件自动从数据库加载数据
将数据写入缓存
返回数据

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class ReadThroughCache implements Cache {
 private Database database;

 public Object get(String key) {
 // 缓存组件自动处理缓存未命中
 return cacheStorage.get(key, () -> {
 // 从数据库加载数据
 return database.fetch(key);
 });
 }
}

2.3 优点

对应用程序透明
缓存加载逻辑集中管理
减少应用层代码复杂度

2.4 适用场景

需要统一缓存加载逻辑的系统
微服务架构
复杂的数据获取流程

3. Write Through模式（写穿透）

3.1 基本原理

Write Through模式确保数据同时写入缓存和后端存储，保证数据一致性。

3.2 工作流程

接收写入请求
同时更新缓存和数据库
确认写入成功

1
2
3
4
5
6
7
8
9


def write_data(key, value):
 # 同时写入缓存和数据库
 try:
 cache.set(key, value)
 database.update(key, value)
 return True
 except Exception as e:
 # 处理写入失败的情况
 return False

3.3 优点

强一致性
数据实时同步
降低数据丢失风险

3.4 缺点

写入性能相对较低
增加系统复杂度

4. 性能与一致性权衡

4.1 选择建议

Cache Aside：灵活性高，适合大多数场景
Read Through：适合标准化缓存加载
Write Through：需要强一致性的场景

4.2 性能优化建议

合理设置缓存过期时间
使用本地缓存+ 分布式缓存
针对读多写少场景选择合适模式

结论

理解和正确使用Redis缓存模式是构建高性能、高可靠系统的关键。根据具体业务场景选择合适的缓存模式，能显著提升系统整体性能和用户体验。

参考资料

缓存模式（Cache Aside、Read Through、Write Through）

Rust 连接 MongoDB 和 MySQL 数据库完整教程

Mon, 26 May 2025 18:34:25 +0800

Rust 连接 MongoDB 和 MySQL 数据库完整教程

前言

本文将详细讲解如何在 Rust 项目中连接 MongoDB 和 MySQL 数据库，包括从 .env 文件读取配置，初始化连接，以及解决常见的连接和配置问题。文章分为两部分：

一、使用 Rust 连接 MongoDB
二、使用 Rust 连接 MySQL

一、Rust 连接 MongoDB

1. 项目依赖配置

在Cargo.toml中添加所需依赖：

1
2
3
4


[dependencies]
mongodb = "2.3.0" # 官方 MongoDB 驱动
dotenv = "0.15.0" # 用于加载 .env 文件中的环境变量
tokio = { version = "1", features = ["full"] } # 异步运行时

2. 创建 `.env` 文件

在项目根目录新建 .env，添加 MongoDB URI 和数据库名：

1
2


MONGODB_URI=mongodb://localhost:27017
MONGODB_DB_NAME=life_track

如果使用 MongoDB Atlas，请将 URI 替换为 Atlas 提供的连接字符串。

3. 编写 `database.rs` 来读取配置并建立连接

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39


use mongodb::{Client, Database, options::ClientOptions};
use dotenv::dotenv;
use std::{env, time::Duration};

pub struct DatabaseManager {
 pub db: Database,
}

impl DatabaseManager {
 pub async fn new() -> Result<Self, mongodb::error::Error> {
 // 加载.env环境变量
 dotenv().ok();

 // 从环境变量读取数据库连接配置
 let mongodb_uri = env::var("MONGODB_URI")
 .unwrap_or_else(|_| "mongodb://localhost:27017".to_string());
 let db_name = env::var("MONGODB_DB_NAME")
 .unwrap_or_else(|_| "life_track".to_string());

 println!("Connecting to MongoDB at: {}", mongodb_uri);

 // 解析客户端配置，设置连接超时
 let mut client_options = ClientOptions::parse(&mongodb_uri).await?;
 client_options.connect_timeout = Some(Duration::from_secs(30));
 client_options.server_selection_timeout = Some(Duration::from_secs(30));
 client_options.max_pool_size = Some(10);

 // 创建客户端
 let client = Client::with_options(client_options)?;

 // 连接测试，提前发现连接问题
 client.list_database_names(None, None).await?;
 println!("Database connection successful!");

 let database = client.database(&db_name);

 Ok(DatabaseManager { db: database })
 }
}

4. 在主程序中初始化数据库，保证初始化完成再继续

以 Tauri 应用为例，在 lib.rs 中使用阻塞方式确保初始化：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


tauri::async_runtime::block_on(async {
 match DatabaseManager::new().await {
 Ok(db_manager) => {
 app_handle.manage(db_manager);
 println!("Database initialized successfully");
 }
 Err(e) => {
 eprintln!("Failed to initialize database: {}", e);
 std::process::exit(1);
 }
 }
});

这样可以防止在数据库连接未准备好时执行数据库操作，避免类似 "state not managed for field db" 的错误。

二、Rust 连接 MySQL

1. 项目依赖配置

在 Cargo.toml 中添加 MySQL 连接相关依赖：

1
2
3
4


[dependencies]
mysql_async = "0.28.0" # 异步 MySQL 驱动
dotenv = "0.15.0"
tokio = { version = "1", features = ["full"] }

2. 配置 `.env` 文件

1

MYSQL_URI=mysql://username:password@localhost:3306/life_track

请根据实际情况修改用户名和密码。

3. 编写 `mysql_database.rs` 读取配置并创建连接池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29


use mysql_async::{Pool, Conn, prelude::*};
use dotenv::dotenv;
use std::env;

pub struct MySQLManager {
 pub pool: Pool,
}

impl MySQLManager {
 pub async fn new() -> Result<Self, mysql_async::Error> {
 dotenv().ok();

 let mysql_uri = env::var("MYSQL_URI")
 .unwrap_or_else(|_| "mysql://root:password@localhost:3306/life_track".to_string());

 println!("Connecting to MySQL at: {}", mysql_uri);

 // 创建连接池
 let pool = Pool::new(mysql_uri);

 // 测试连接
 let mut conn = pool.get_conn().await?;
 conn.ping().await?;

 println!("MySQL connection successful!");

 Ok(MySQLManager { pool })
 }
}

4. 在主程序中初始化 MySQL 连接池

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


tokio::runtime::Runtime::new()?.block_on(async {
 match MySQLManager::new().await {
 Ok(mysql_manager) => {
 app_handle.manage(mysql_manager);
 println!("MySQL database initialized successfully");
 }
 Err(e) => {
 eprintln!("Failed to initialize MySQL database: {}", e);
 std::process::exit(1);
 }
 }
});

总结

通过 dotenv 读取 .env 文件中的数据库连接配置，方便灵活管理环境参数。
配置 MongoDB 客户端连接超时参数提高远程连接稳定性，避免连接Atlas时的问题。
使用异步函数并确保数据库完全初始化后再继续业务逻辑，避免状态管理错误。
对 MySQL，使用 mysql_async 创建连接池并测试连接。
运行程序时只需修改 .env，无需改动代码即可切换数据库配置和环境。

希望本文能帮你快速上手 Rust 中 MongoDB 和 MySQL 的数据库连接。

Windows 批处理文件（.bat）应用详解与实用示例

Mon, 26 May 2025 12:34:25 +0800

Windows 批处理文件（.bat）应用详解与实用示例

前言

在 Windows 环境下，批处理文件（Batch file，扩展名 .bat）是自动执行一系列命令和任务的强大工具。无论是自动化重复性工作、简化日常操作，还是批量管理系统设置，批处理脚本都能显著提高效率，减少人为错误，特别适合 Windows 11 用户日常运维和办公自动化。

本文将从零开始，系统讲解 Windows 11 如何创建、编辑和运行批处理文件，并通过丰富示例展示其实际应用场景及写法技巧。

一、批处理文件简介与优势

什么是批处理文件？

批处理文件是一个包含 DOS 命令列表的纯文本文件，Windows 命令解释器（cmd.exe）会按顺序执行其内容。它以 .bat 或 .cmd 为后缀名，通过运行批处理文件即可自动完成一系列手动输入命令。

为什么使用批处理文件？

自动执行重复性任务，节省时间和体力
保证任务执行的连贯性和一致性，减少人为失误
实现复杂多步操作的自动化
便携易分享，可在多台机器上运行相同脚本
方便管理文件、网络驱动器映射、程序启动等日常任务

二、如何在 Windows 11 创建和运行批处理文件？

1. 创建基本批处理文件

按下 Windows 键，输入 记事本 并打开。
输入以下内容：
1 2 3

@ECHO OFF ECHO Hi, this is my first batch file. PAUSE
说明：
- @ECHO OFF 隐藏命令回显，只显示输出结果。
- ECHO 用于打印消息。
- PAUSE 命令窗口暂停，等待用户按任意键。
点击“文件” → “另存为”
文件名写为 Test.bat，保存类型选择“所有文件 (.)”，点击保存。
双击 Test.bat，你将在命令提示符窗口中看到欢迎信息。

2. 映射网络驱动器示例

自动映射网络共享路径为本地驱动器盘符：

1
2
3
4


@ECHO OFF
ECHO Create new F: drive mapping
net use F: \\NetworkPath /persistent:yes
PAUSE

把 F: 替换成信用盘符
\\NetworkPath 替换成实际网络共享路径（如 \\192.168.1.100\shared）
保存为 .bat 文件后运行即可自动连接。

3. 添加用户输入与交互

批处理文件也能接收用户输入，实现交互式脚本：

1
2
3
4
5
6


@ECHO OFF
:START
SET /P input=Enter your name:
ECHO Hi %input%! Welcome to the event.
PAUSE
GOTO START

SET /P 用于提示用户输入并将结果存到变量 input
GOTO START 实现循环交互，可以随时输入新名字。

4. 自动打开常用应用程序

帮你一次性启动多款常用软件，提升工作效率：

1
2
3
4
5
6
7
8


@ECHO OFF

start "" "C:\Program Files\Google\Chrome\Application\chrome.exe"
start "" "C:\Program Files\Microsoft Office\root\Office16\WINWORD.EXE"
start "" "C:\Program Files\Slack\Slack.exe"
start "" "C:\Program Files\ShareX\ShareX.exe"

EXIT

注意用完整程序路径替换示例中的路径。
start "" 中的双引号用于占位窗口标题。

5. 批处理实现文本替换示例

假如您有文件 code.txt，要将其中所有的 oldtext 替换为 newtext，可以用批处理这样做：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


@ECHO OFF
SETLOCAL ENABLEDELAYEDEXPANSION

SET "inputFile=code.txt"
SET "outputFile=code_modified.txt"
SET "oldText=oldtext"
SET "newText=newtext"

IF NOT EXIST "%inputFile%" (
 ECHO Input file not found.
 EXIT /B
)

(
FOR /F "usebackq delims=" %%a IN ("%inputFile%") DO (
 SET "line=%%a"
 SET "line=!line:%oldText%=%newText%!"
 ECHO !line!
)
) > "%outputFile%"

ECHO Replacement complete. Output file: %outputFile%

ENDLOCAL

请修改变量 inputFile、oldText 和 newText 以匹配实际需求。
该脚本会生成一个新文件，原文件保持不变。

三、如何编辑与运行批处理文件？

编辑批处理文件

右键 .bat 文件，选择“编辑”即可在记事本中打开和修改。
修改完成后，按 Ctrl+S 保存。

运行批处理文件

直接双击 .bat 文件即可执行。
也可打开命令提示符窗口，通过 cd 命令切换到脚本目录，输入脚本名称后回车运行。

四、批处理文件的使用小贴士

保存位置建议：放在用户“文档”或“桌面”等易访问目录，便于管理。
增强功能：结合 Windows 任务计划程序，可实现定时自动执行。
复杂自动化：批处理适合简单流程，若需要更强功能，推荐 PowerShell 或 Python。
安全注意：避免运行不明来源的批处理文件，以防恶意操作。

结语

Windows 批处理文件为广大用户提供了一种低成本、门槛低的自动化解决方案。掌握它，可以轻松完成文件管理、软件启动、网络驱动映射、自动化文本处理等多种任务。希望本教程能帮助你快速上手批处理编程，从此高效管理你的 Windows 电脑。

参考资料

在 Windows 11上创建批处理（.bat）文件的 5 种方法

跨平台桌面应用工具Tauri2.0入门教程

Sat, 24 May 2025 20:34:25 +0800

跨平台桌面应用工具Tauri 2.0入门

前言

Tauri 是一款基于 Rust 的跨平台桌面应用开发框架，能够让开发者使用熟悉的前端技术（HTML、CSS、JavaScript 或现代框架如 React、Vue 等）来构建轻量级、高性能且安全的应用。相比 Electron，Tauri 打包体积更小（约4MB 对比 Electron 50MB），性能更优，占用资源更少。

本教程将带你从零开始创建一个基础的 Tauri 2.0 项目，包含环境搭建、项目初始化、前后端交互、构建打包等步骤，轻松打造跨平台桌面应用。

前提条件

在开始之前，请确保你的开发环境中已经安装并配置好以下内容：

Rust
官网：https://rustup.rs/
按照页面指示安装 Rust 编译工具链。
Node.js 和 npm
官网：https://nodejs.org/
建议安装最新的 LTS 版本。
Tauri CLI
在命令行终端运行：

1

npm install -g @tauri-apps/cli

环境搭建

创建新项目使用官方脚手架工具快速初始化：

NPM:

1

npm create tauri-app@latest

Yarn:

1

yarn create tauri-app

PNPM:

1

pnpm create tauri-app

然后选择适合自己的前端技术栈。

启动开发服务器 执行cd tauri-app进入项目目录后，执行npm install或是pnpm install安装依赖，然后运行：

1

npm run tauri dev

这将启动 Tauri 应用的开发模式，内置热重载，方便实时调试。

创建 Tauri 应用

项目主要分为前端（Web 页面）和后端（Rust）两部分。Tauri 通过命令调用机制，让前端能与后端 Rust 代码通信。

实现前后端通信

编辑 src-tauri/src/main.rs，加入一个简单的命令函数：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


#[tauri::command]
fn greet(name: String) -> String {
 format!("Hello, {}!", name)
}

fn main() {
 tauri::Builder::default()
 .invoke_handler(tauri::generate_handler![greet])
 .run(tauri::generate_context!())
 .expect("error while running tauri application");
}

在前端调用这个命令：

编辑 src/app.js：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


import { invoke } from '@tauri-apps/api/tauri';

async function greet(name) {
 const response = await invoke('greet', { name });
 alert(response);
}

document.getElementById('greet-btn').addEventListener('click', () => {
 greet('TauriUser');
});

更新 index.html，添加一个触发按钮：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8" />
 <meta name="viewport" content="width=device-width, initial-scale=1.0" />
 <title>Tauri App</title>
</head>
<body>
 <button id="greet-btn">Greet</button>
 <script src="app.js"></script>
</body>
</html>

构建与运行

开发模式（带热重载）
1

npm run tauri dev
生产构建
打包成正式版本：
1

npm run tauri build

打包平台应用

Tauri 支持一键针对不同操作系统进行打包：

Windows：

1

npm run tauri build -- --target x86_64-pc-windows-msvc

macOS：

1

npm run tauri build -- --target x86_64-apple-darwin

Linux：

1

npm run tauri build -- --target x86_64-unknown-linux-gnu

（具体命令根据项目配置有所不同，可参考官方文档。）

总结与扩展

至此，你已经完成了一个简单的 Tauri 应用搭建过程，掌握了如何创建项目、实现前后端交互、构建及打包。Tauri 让桌面应用开发变得高效且轻量，非常适合有前端基础的开发者快速入门。

后续你可以尝试：

深入 Rust 后端逻辑，扩展应用功能
使用 Vue、React 等框架改进前端界面
利用 Tauri 丰富的插件系统增强应用能力
探索移动端的支持与多端统一开发

更多资料和示例，推荐访问 Tauri 官方网站：https://tauri.app 和 GitHub 项目。

创建 Tauri 项目

合集 - Tauri(2)

1. Windows 上 Tauri 开发环境配置（2024-09-11）

1. 从头开始创建一个全新 Tauri 项目

在前述部分，我们已详细介绍了如何在 Windows 上搭建 Tauri 的开发环境，包括依赖安装、工具配置，以及常见问题的处理。这为我们的后续开发打下了坚实基础。

如今，我们将学习如何从零开始创建一个完整的 Tauri 项目。这个流程非常简单，Tauri 提供了强大的 CLI 工具，让你只需几条命令就能快速生成一个集成了前端和后端的项目结构。

创建流程

新项目初始化
使用 Tauri 官方提供的命令创建新项目：
1

pnpm create tauri-app --rc
在此过程中，你会被引导选择前端框架（比如 Vue、React 或纯 HTML/JavaScript），工具会自动帮你生成基础项目。
启动开发环境
进入项目目录后，运行以下命令启动开发：
1

pnpm tauri dev
系统会自动构建桌面应用，并在 Windows 上以窗口显示。

2. 将 Tauri 集成到已有的 Web 项目中

如果你已经有了一个 Web 项目（React、Vue等），想要快速转化为桌面应用，可以将 Tauri 集成到现有项目中，使其变成一个桌面版。

集成步骤

进入现有项目目录
确保你的项目已经是 Node.js 管理（即有 package.json 文件）。
安装 Tauri 依赖
执行：
1

pnpm add -D @tauri-apps/cli@next
初始化 Tauri 配置
在项目中运行：
1

npx tauri init
系统会提示你配置应用信息（如应用名、窗口标题、前端资源路径等），根据提示填写即可。

配置完成后，src-tauri 文件夹会生成，包含所有 Tauri 配置和 Rust 代码。
运行项目以进行调试
使用命令：
1

pnpm tauri dev
你会看到你的 Web 项目在桌面窗口中运行，已经实现标准的与桌面交互。

这样，你的现有 Web 应用就变成了一个桌面应用，能调用 Tauri 提供的丰富 API，实现对操作系统的访问。

小结

通过以上两种方式，无论是全新开发，还是在已有项目基础上集成，你都能轻松在 Windows 上快速启动 Tauri 应用。
接下来，我们将深入学习 Tauri API，掌握如何利用 Rust 后端增强应用功能，实现更复杂的交互与功能扩展。

相机标定及棋盘格标定法详解

Tue, 20 May 2025 18:34:25 +0800

相机标定及棋盘格标定法详解

什么是相机标定？

相机标定（Camera Calibration）是指通过一组已知空间几何结构的物体（如棋盘格）拍摄图像，计算出相机的内参矩阵和畸变系数的过程。

这一步使得我们能够从二维图像像素坐标恢复三维空间信息，或者进行精准的图像几何校正。标定结果通常包括：

相机内参矩阵 $K$

$$K = \begin{bmatrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 \ \end{bmatrix}$$
其中，$f_x, f_y$ 是水平和竖直方向上的焦距（像素单位），$c_x, c_y$ 是主点坐标。
畸变系数 $D$
包含径向和切向畸变参数，如 $k_1, k_2, p_1, p_2, k_3$ 等。
旋转和平移向量 用于描述相机坐标系与世界坐标系之间的位置关系。

相机标定是计算相机内外参的过程。通过标定，我们能获得：

内参（Intrinsic Parameters）：相机的固有属性，如焦距$(f_x, f_y)$、光心位置$(c_x, c_y)$和畸变参数。
外参（Extrinsic Parameters）：相机相对于世界坐标系的位置和朝向，即旋转矩阵$R$和平移向量$t$。

标定的目标是建立3D物体坐标与图像坐标之间的映射关系。

在计算机视觉中，标定后的相机矩阵$K$通常表示为：

$$K = \begin{bmatrix} f_x & 0 & c_x \ 0 & f_y & c_y \ 0 & 0 & 1 \ \end{bmatrix}$$

结合畸变参数，可以纠正成像中的径向和切向畸变。

棋盘格标定法

棋盘格标定法是工业界和学术界应用最为广泛的标定方式，因其角点容易定位且结构规则。

简介

棋盘格标定法利用具有已知几何形状的二维平面棋盘作为标定样板。其关键步骤包括：

准备棋盘格
典型棋盘由黑白相间的方格组成，角点（内角交点）作为标定点。
在多张不同角度的棋盘图像中检测角点
使用OpenCV的findChessboardCorners()函数自动定位棋盘格内角点。
亚像素级角点精确化
通过cornerSubPix()精细调整角点位置，提高标定精度。
对应三维空间点与二维图像点
三维点多为棋盘格上预先定义的规则坐标，例如$(0,0,0),(1,0,0),\ldots$。
调用calibrateCamera()计算相机内外参
通过最小化重投影误差的优化方法，求得相机参数。

核心步骤：

准备一个具有多个方格单元的棋盘格标定板，已知单元格大小（如 $20 \times 20$ 毫米）。
采集多张棋盘格在不同姿态的图像。
使用角点检测算法找到每张图像中棋盘格的角点（图像点）。
结合棋盘格的物理坐标（空间点），利用对应点进行相机参数求解。

数学模型

在针孔相机模型下，三维空间点 $P_w = (X_w, Y_w, Z_w)$ 通过变换到相机坐标系后投影到像素坐标 $p = (u, v)$：

$$s \begin{bmatrix} u \ v \ 1 \ \end{bmatrix} = K \begin{bmatrix} R & t \end{bmatrix} \begin{bmatrix} X_w \ Y_w \ Z_w \ 1 \ \end{bmatrix}$$

其中：

$s$ 是尺度因子。
$R$ 是旋转矩阵，$t$ 是平移向量。
$K$ 是内参矩阵。

根据上述方程，给定一组标定点的空间坐标及其对应像素点，利用非线性优化（如Levenberg-Marquardt）求解 $K$、$R$、$t$ 和畸变参数。

投影模型

世界坐标系中的3D点$X_w = [X,Y,Z,1]^T$通过相机坐标变换和投影变为图像点$x = [u,v]^T$：

$$s \begin{bmatrix} u \ v \ 1 \end{bmatrix} = K [R \quad t] \begin{bmatrix} X \ Y \ Z \ 1 \end{bmatrix}$$

其中：

$K$为相机内参矩阵
$R$为3×3旋转矩阵
$t$为3×1平移向量
$s$为尺度因子

重投影误差

最小化目标是重投影误差：

$$\min_{K, R_i, t_i} \sum_{i=1}^N \sum_{j=1}^M | x_{ij} - \hat{x}_{ij} |^2$$

其中：

$x_{ij}$为第$i$幅图中第$j$个检测到的角点
$\hat{x}_{ij}$为第$i$幅图对应的3D点经过投影后的点

优化完成后，即得到相机的内外参数和畸变系数。

相机标定Python实现及说明

下面代码通过模块化和详细注释，提高代码的可读性和复用性。

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121


import numpy as np
import cv2 as cv
import glob

def prepare_object_points(pattern_size):
 """
 生成棋盘格的三维世界坐标点，以平面（z=0）上的规则点。

 Parameters:
 pattern_size (tuple): 风格为（内角点列数, 内角点行数）

 Returns:
 objp (ndarray): 形如(N, 3)，每行为一个3D点
 """
 objp = np.zeros((pattern_size[1] * pattern_size[0], 3), np.float32)
 objp[:, :2] = np.mgrid[0:pattern_size[0], 0:pattern_size[1]].T.reshape(-1, 2)
 return objp

def find_corners(images, pattern_size, criteria):
 """
 在多张图像中寻找棋盘格角点，并做亚像素级精细调整

 Parameters:
 images (list): 图像路径列表
 pattern_size (tuple): 棋盘格内角点尺寸 (cols, rows)
 criteria (tuple): 角点精细化迭代终止标准

 Returns:
 objpoints (list): 3D点世界坐标列表
 imgpoints (list): 2D图像坐标点列表
 img_shape (tuple): 图像尺寸(宽, 高)
 """
 objp = prepare_object_points(pattern_size)
 objpoints = [] # 三维点列表
 imgpoints = [] # 二维点列表

 for fname in images:
 img = cv.imread(fname)
 if img is None:
 print(f"Warning: unable to load image {fname}")
 continue
 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)
 ret, corners = cv.findChessboardCorners(gray, pattern_size, None)

 if ret:
 # 亚像素级角点精细化
 corners_refined = cv.cornerSubPix(gray, corners, (11, 11), (-1, -1), criteria)
 objpoints.append(objp)
 imgpoints.append(corners_refined)

 # 可视化检测效果
 cv.drawChessboardCorners(img, pattern_size, corners_refined, ret)
 cv.imshow('Corners Detection', img)
 cv.waitKey(500) # 展示500ms
 cv.destroyAllWindows()

 if not imgpoints:
 raise RuntimeError("未检测到任何有效棋盘格角点！请检查图片路径及参数设置。")
 return objpoints, imgpoints, gray.shape[::-1]

def calibrate_camera(objpoints, imgpoints, image_size):
 """
 利用世界坐标和图像坐标计算相机内参和畸变参数

 Parameters:
 objpoints (list): 三维点集列表
 imgpoints (list): 二维点集列表
 image_size (tuple): 图像尺寸 (宽, 高)

 Returns:
 ret (float): RMS重投影误差
 mtx (ndarray): 相机矩阵
 dist (ndarray): 畸变系数
 rvecs (list): 旋转向量列表
 tvecs (list): 平移向量列表
 """
 ret, mtx, dist, rvecs, tvecs = cv.calibrateCamera(
 objpoints, imgpoints, image_size, None, None
 )
 return ret, mtx, dist, rvecs, tvecs

def compute_reprojection_error(objpoints, imgpoints, rvecs, tvecs, mtx, dist):
 """
 计算所有图像的平均重投影误差，衡量标定精度

 Returns:
 mean_error (float): 平均误差
 """
 total_error = 0
 for i in range(len(objpoints)):
 imgpoints_proj, _ = cv.projectPoints(objpoints[i], rvecs[i], tvecs[i], mtx, dist)
 error = cv.norm(imgpoints[i], imgpoints_proj, cv.NORM_L2) / len(imgpoints_proj)
 total_error += error
 mean_error = total_error / len(objpoints)
 return mean_error

def main():
 # 棋盘内角点尺寸(列, 行)
 pattern_size = (24, 13)

 # 迭代终止条件
 criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)

 # 读取所有标定图像路径，确保图像覆盖不同角度和视场
 images = glob.glob('data/cali/*.jpg')

 objpoints, imgpoints, image_size = find_corners(images, pattern_size, criteria)
 ret, mtx, dist, rvecs, tvecs = calibrate_camera(objpoints, imgpoints, image_size)

 mean_error = compute_reprojection_error(objpoints, imgpoints, rvecs, tvecs, mtx, dist)

 print(f"标定完成，重投影误差 (RMS): {ret}")
 print(f"平均重投影误差: {mean_error}")
 print(f"相机矩阵:\n{mtx}")
 print(f"畸变系数:\n{dist.ravel()}")

 # 保存参数，方便未来加载与使用
 np.savez('camera_calibration.npz', mtx=mtx, dist=dist, rvecs=rvecs, tvecs=tvecs)

if __name__ == "__main__":
 main()

小结：

相机标定是获取相机准确内外参数的基础，广泛应用于机器视觉、三维重建等领域。
棋盘格标定法因其简单直观、角点检测稳定，是最常用的标定方法。
通过多视角棋盘图像，检测角点，亚像素精细化，配合OpenCV的calibrateCamera函数完成相机参数估计。
最终通过重投影误差评估标定结果的准确性，误差越小越好。
优化代码结构可以提升易懂性与复用性，便于实际工业或科研项目中的应用。

姿态估计的Python代码优化与详解

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90


import numpy as np
import cv2 as cv
import glob

def load_calibration_data(filepath='B.npz'):
 """加载相机内参和畸变参数"""
 with np.load(filepath) as data:
 mtx = data['mtx']
 dist = data['dist']
 return mtx, dist

def draw_cube(img, imgpts):
 """
 在图像上绘制3D立方体的投影
 - imgpts: 8个立方体顶点的二维投影点
 """
 imgpts = np.int32(imgpts).reshape(-1, 2)

 # 绘制底面（绿色填充）
 img = cv.drawContours(img, [imgpts[:4]], -1, (0, 255, 0), -3)
 # 绘制柱子（蓝色线条）
 for i, j in zip(range(4), range(4, 8)):
 img = cv.line(img, tuple(imgpts[i]), tuple(imgpts[j]), (255, 0, 0), 3)
 # 绘制顶部（红色线条）
 img = cv.drawContours(img, [imgpts[4:]], -1, (0, 0, 255), 3)
 return img

def main():
 # 加载相机参数
 mtx, dist = load_calibration_data('B.npz')

 # 设置棋盘格大小，这里(24, 13)表示24×13个内角点
 chessboard_size = (24, 13)

 # 生成世界坐标系中的棋盘格点，Z=0平面
 objp = np.zeros((chessboard_size[0] * chessboard_size[1], 3), np.float32)
 objp[:, :2] = np.mgrid[0:chessboard_size[0], 0:chessboard_size[1]].T.reshape(-1, 2)

 # 设置亚像素角点检测的终止条件
 criteria = (cv.TERM_CRITERIA_EPS + cv.TERM_CRITERIA_MAX_ITER, 30, 0.001)

 # 定义一个3D立方体的8个顶点，用于投影
 cube_size = 3 # 立方体边长，单位与棋盘格点一致
 axis = np.float32([
 [0, 0, 0], [0, cube_size, 0], [cube_size, cube_size, 0], [cube_size, 0, 0],
 [0, 0, -cube_size], [0, cube_size, -cube_size], [cube_size, cube_size, -cube_size], [cube_size, 0, -cube_size]
 ])

 # 读取所有测试图像
 image_files = glob.glob('data/pose/*.jpg')

 for fname in image_files:
 img = cv.imread(fname)
 gray = cv.cvtColor(img, cv.COLOR_BGR2GRAY)

 # 寻找棋盘格角点
 ret, corners = cv.findChessboardCorners(gray, chessboard_size, None)
 if not ret:
 print(f"未检测到角点: {fname}")
 continue

 # 亚像素级角点优化
 corners_subpix = cv.cornerSubPix(
 gray, corners, winSize=(11, 11), zeroZone=(-1, -1), criteria=criteria
 )

 # 使用solvePnP估计姿态
 ret, rvec, tvec = cv.solvePnP(objp, corners_subpix, mtx, dist)
 if not ret:
 print(f"姿态估计失败: {fname}")
 continue

 # 将3D立方体顶点投影到图像平面
 imgpts, _ = cv.projectPoints(axis, rvec, tvec, mtx, dist)

 # 绘制立方体
 img = draw_cube(img, imgpts)

 # 显示结果图像
 cv.imshow('Pose Estimation', img)
 key = cv.waitKey(0) & 0xFF
 if key == ord('s'): # 按's'键保存结果图
 save_path = fname.rsplit('.', 1)[0] + '_pose.png'
 cv.imwrite(save_path, img)
 print(f'图像保存为 {save_path}')

 cv.destroyAllWindows()

if __name__ == "__main__":
 main()

代码详解和优化说明：

结构化设计

将标定数据加载封装成函数 load_calibration_data 便于复用和维护。
使用 main() 函数组织流程，清晰分离功能模块。
处理每张图像时，增加角点检测成功与否的判断，输出友好提示。

变量和参数说明

chessboard_size 定义棋盘格内角点数目，和标定板物理结构一致。
objp 是棋盘格角点的三维世界坐标（假定Z=0平面），匹配图像角点对应关系。
criteria 为亚像素角点优化的迭代终止条件，保证检测角点高精度。
cube_size 方便调整立方体尺寸。

绘制加强

绘制时区分底面、边柱和顶面，颜色更直观（绿色底面、蓝色柱子、红色顶面）。
线宽和填充颜色根据功能区分，提升视觉效果。

交互体验

支持手动查看每张图像
支持按s键保存图像，方便批量结果保存。

总结

本文介绍了相机标定的基本原理和基于棋盘格的经典标定方法，结合数学模型重点阐述了相机内参数与变换关系。

通过重写的姿态估计代码，提供了实际如何利用OpenCV接口进行姿态求解与3D物体投影的实践示例，代码更规范，注释及变量命名清晰，便于学习和扩展。

计算机 on 酒中仙

Redis缓存模式详解：提升系统性能的艺术

Redis缓存模式详解：提升系统性能的艺术

引言

1. Cache Aside模式（旁路缓存）

1.1 基本原理

1.2 读取流程

1.3 写入流程

1.4 优点与缺点

2. Read Through模式（读穿透）

2.1 基本原理

2.2 工作流程

2.3 优点

2.4 适用场景

3. Write Through模式（写穿透）

3.1 基本原理

3.2 工作流程

3.3 优点

3.4 缺点

4. 性能与一致性权衡

4.1 选择建议

4.2 性能优化建议

结论

参考资料

Rust 连接 MongoDB 和 MySQL 数据库完整教程

Rust 连接 MongoDB 和 MySQL 数据库完整教程

前言

一、Rust 连接 MongoDB

1. 项目依赖配置

2. 创建 .env 文件

3. 编写 database.rs 来读取配置并建立连接

4. 在主程序中初始化数据库，保证初始化完成再继续

二、Rust 连接 MySQL

1. 项目依赖配置

2. 配置 .env 文件

3. 编写 mysql_database.rs 读取配置并创建连接池

4. 在主程序中初始化 MySQL 连接池

总结

Windows 批处理文件（.bat）应用详解与实用示例

Windows 批处理文件（.bat）应用详解与实用示例

前言

一、批处理文件简介与优势

什么是批处理文件？

为什么使用批处理文件？

二、如何在 Windows 11 创建和运行批处理文件？

1. 创建基本批处理文件

2. 映射网络驱动器示例

3. 添加用户输入与交互

4. 自动打开常用应用程序

5. 批处理实现文本替换示例

三、如何编辑与运行批处理文件？

编辑批处理文件

运行批处理文件

四、批处理文件的使用小贴士

结语

参考资料

跨平台桌面应用工具Tauri2.0入门教程

跨平台桌面应用工具Tauri 2.0入门

前言

前提条件

环境搭建

创建 Tauri 应用

实现前后端通信

构建与运行

打包平台应用

总结与扩展

创建 Tauri 项目

1. 从头开始创建一个全新 Tauri 项目

创建流程

2. 将 Tauri 集成到已有的 Web 项目中

集成步骤

小结

相机标定及棋盘格标定法详解

相机标定及棋盘格标定法详解

什么是相机标定？

棋盘格标定法

简介

核心步骤：

数学模型

投影模型

2. 创建 `.env` 文件

3. 编写 `database.rs` 来读取配置并建立连接

2. 配置 `.env` 文件

3. 编写 `mysql_database.rs` 读取配置并创建连接池