Rust异步编程实战:理解async/await与tokio核心机制

Rust异步编程async/await
于 2026-10-29 04:37:19 修改
·本内容遵循CC 4.0 BY-SA版权协议

1. 别急着写代码,先理解 async/await 到底在解决什么问题

很多刚接触 Rust 的朋友,看到 async fn 和 .await 就下意识地用写 JavaScript 或 Python 的思路去套,结果跑出各种莫名其妙的问题。第 13 课我想先从最根上把这件事掰开揉碎讲清楚——Rust 的 async/await 不是“语法糖”,它是一套基于轮询(poll)的协作式调度模型。你只有理解了 Future 是惰性的、await 是挂起点、执行器才是真正驱动力,后面用 tokio 时才知道自己在干什么。

1.1 一个最简单的异步函数,背后发生了什么

先看一段再普通不过的代码:

RUST
async fn fetch_page() -> String {
let content = download_page().await;
format!("页面内容长度: {}", content.len())
}

这里的关键不是 await 本身,而是 async fn 的返回值。你调用 fetch_page() 时,函数体一行都不会执行,它只是构造了一个 Future 对象。你可以把它理解成一张“外卖订单”,下单之后厨房还没开始做菜,订单本身只是一张纸。只有当你把这张订单交给执行器(executor),让执行器去 poll 这个 Future,函数体才会真正跑起来。

poll 这个词很多人觉得抽象,其实可以这样想:执行器隔一段时间问 future:“你准备好了吗?准备好了就把结果给我,没准备好我就去处理别的任务。” 当 fetch_page 内部执行到 download_page().await 时,实际上是在对 download 返回的 future 执行一次 poll。如果下载还没完成,这个 future 会返回 Pending,意思是“我还没好,你可以去干别的了”。于是 fetch_page 这个 future 本身也返回 Pending,状态被保存在一个 Pin<Box<dyn Future>> 或者其他容器里。等到下载完成,执行器再次 poll 它,它会从上次挂起的地方继续执行。

这就是 Rust 异步的核心:编译期状态机 + 运行时轮询。编译器会把一个 async 函数拆成若干个状态,每次 await 就是一个可能挂起的边界点。这比回调函数清晰得多,也比线程切换轻量得多。

1.2 Future 的惰性、Pin 和运行时执行器

既然 Future 是惰性的,那就必须回答一个问题:谁来驱动它?Rust 标准库只提供了 Future trait 和 async/await 语法,但标准库没有执行器。这跟 Go 不一样,Go 的 goroutine 是语言运行时内置的;Rust 选择了把执行器放到第三方库,比如 tokio、async-std、smol。也就是说,你可以在没有操作系统线程概念的嵌入式环境里实现一个极简执行器,也可以在一个多核服务器上跑 tokio 的多线程运行时。

另一个绕不开的概念是 Pin。为什么要 Pin?因为一个 async 函数的内部可能会生成自引用结构——比如你在局部变量里存了一个指向另一个局部变量堆上的指针,而 future 在状态机切换时可能会被移动。如果让编译器默认允许移动,这个内部指针就悬空了。Pin 的作用就是约束 future 在内存中的位置,让它不要被随意搬走。这也是新手最容易遇到的编译错误之一:future is not Send 或 cannot be unpinned。你只要记住:在异步代码里传递 future、跨线程 spawn 任务时,要先考虑它是否满足 Send 和 'static。

那么执行器具体怎么驱动?简单理解就是一个事件循环:它维护一个任务队列和一个 reactor(I/O 事件源),不断从队列里取出任务,调用 poll;如果任务返回 Pending,就把它挂到对应的 I/O 等待列表里,等事件到达再唤醒。tokio 之所以快,很大程度上归功于它对这套机制的精细优化,而不是“线程多”这么简单。

1.3 线程为什么不能直接解决问题

说到异步,总会有人问:“我开 10 个线程不一样吗?” 区别在于线程切换是操作系统内核完成的,每次切换要保存/恢复寄存器、刷新缓存,成本是微秒级;而异步任务切换只是内存里的一个函数调用,成本是纳秒级。更关键的是,线程的数量受系统资源限制,一个 8 核机器开个几千线程能把内存吃光;而 async 任务可以开几十万,因为每个任务只占很小的栈空间(或者根本不需要独立栈)。在 I/O 密集场景(网络请求、数据库读写、文件操作)下,你把任务切成异步,让线程空出来跑别的计算,吞吐量能有数量级提升。

但异步也不是银弹。如果任务是 CPU 密集型的、需要长时间占用核心做计算,异步反而没优势,甚至因为额外调度开销变得更慢。所以正确姿势是:I/O 密集用 async,CPU 密集用线程或 spawn_blocking。

2. tokio:你真正要接触的异步运行时

tokio 是目前 Rust 生态里事实标准的异步运行时,Hyper、axum、tonic 这些主流库都基于它。学 async 不学 tokio,就像有了驾照不开车上路。但 tokio 提供的东西非常多,一开始不要想着把所有 API 都背下来,先把三个核心组件弄懂:runtime(运行时)、task(任务)、reactor(事件驱动)。这三个点通了,其他都是 API 熟悉度的问题。

2.1 runtime 的两种形态与选择

tokio 的 runtime 有两种主流形态:多线程运行时(multi-thread)和当前线程运行时(current_thread)。你也许已经见过 #[tokio::main] 这个宏,默认就是多线程运行时,它会在你写主函数的地方创建一个 runtime,然后 block_on 进去执行。

形态 使用方式 适用场景 注意事项
多线程运行时 #[tokio::main] Web 服务、混有 CPU/阻塞/IO 的复杂系统 默认线程数等于 CPU 核数,任务会在线程间“偷”着跑
当前线程运行时 #[tokio::main(flavor = "current_thread")] 轻量同步脚本、嵌入式、测试 所有任务挤在一个线程上,代码里不要有阻塞操作

选哪种?如果你只是在写一个小工具、做本地文件处理、或者测试时想让行为更可预测,current_thread 够用。若你跑的是一个 HTTP 服务、要并发处理大量网络请求,多线程运行时才是正解。多线程运行时的内部结构是一个全局任务队列加每个工作线程自己的本地队列,采用“工作窃取”机制:某个线程本地队列空了,会从别人那里偷任务过来执行,这样能最大化利用所有核心。

我经常看到有人这样写:

RUST
# [tokio::main]
async fn main() {
// 一堆耗时计算,还用了 std::thread::sleep
}

直接把这个 CPU 计算放到 async 主函数里跑,没问题,但它会长时间占住某个工作线程,导致其他排在这个线程上的任务延迟被调度。严格来说,对于 CPU 密集任务,你应该用 tokio::task::spawn_blocking 给它放到独立的阻塞线程池,或者用 rayon 并行计算。阻塞线程池的大小也可以配置,默认是 512 个线程,你可以 Builder::new_threaded_runtime().max_blocking_threads(n) 去调。

2.2 spawn、异步任务与 Send 约束

tokio::spawn 大概是除了 await 之外你用得最多的函数。它可以在当前 runtime 里创建一个新的异步任务,返回一个 JoinHandle。举个例子:

RUST
let handle = tokio::spawn(async {
println!("hello from task");
42
});
 
let result = handle.await.unwrap();
println!("得到结果: {}", result);

注意 spawn 要求 future 满足 Send + 'static。Send 是因为多线程运行时的任务可能被扔到任意线程执行;'static 是因为这个 future 需要存活到任务结束,不能借用外部非静态生命周期数据。如果你不小心在 async 块里用了 &str 引用外部的字符串,编译器会马上报错。这时候有两种常见解法:一是把数据 clone 进任务内,二是改用 Arc 共享。'static 约束看起来很烦,其实它是一个保险——多线程异步任务本质上就是给你发出去一个“寄件”,你总不能寄一个写着“请打开这个信封但信封握在别人手里”的包裹吧。

关于 JoinHandle,还有一点容易被忽略:handle.await 返回的是一个 Result<T, JoinError>。如果任务 panic 了,你在这里会收到 Err,而且 panic 不会导致整个程序崩溃。所以如果你不关心子任务的结果,可以直接 handle.abort() 或者让它跑完;但如果你想保证任务内的错误不静默丢失,尽量在任务内部用 Result 返回值,而不是在任务里 panic。

2.3 tokio 的 features 怎么开

新手最容易踩的坑之一:use tokio::time::sleep 报错找不到。因为 tokio 默认只开启少量 feature,其它功能需要显式启用。你在 Cargo.toml 里写:

TOML
[dependencies]
tokio = { version = "1", features = ["full"] }

full 把所有常用特性全打开了,开发期可以偷懒。如果是发布产品,尽量按需精减:

TOML
tokio = { version = "1", features = ["rt-multi-thread", "macros", "time", "sync", "net", "io-util"] }
tokio = { version = "1", features = ["rt", "time"] } # 纯 current_thread 小场景

features 之间有关联,比如 rt-multi-thread 依赖 rt,macros 提供 #[tokio::main]。你如果只写 async/await 语法,不一定要引入 tokio 的 macro,可以用 Runtime::new().unwrap().block_on(async { ... })。我在教学时常跟大家说:先从逻辑学起,再关心 features;一旦功能缺了,CV 错误信息就能定位到缺少哪个 feature——因为 tokio 的编译错误写得相当直白。

3. 实操:用 tokio 写一个带限流的并发抓取器

前面的原理讲得再多,不写代码等于零。这节我们做一个小而完整的项目:用 reqwest + tokio 并发抓取一批 URL 的标题,同时限制最大并发数为 5,每个请求超时 10 秒,失败自动重试一次。这个场景几乎适用于任何“批量调接口/爬网页”的工作,也可以推广到并发数据库查询或外部 API 调用。

3.1 先搭一个最小可运行的异步程序

新建一个项目:

BASH
cargo new async-grabber
cd async-grabber

Cargo.toml 先加上依赖:

TOML
tokio = { version = "1", features = ["rt-multi-thread", "macros", "time", "sync"] }
reqwest = { version = "0.12", features = ["rustls-tls"] }

这里没有用 full,是因为我们只想跑通流程。reqwest 默认用系统 TLS,在 Linux 上如果你没装 openssl 的 dev 包会编译失败,所以教学推荐直接用 rustls-tls,纯 Rust 实现,少踩很多系统依赖的坑。

先写一个超简单的异步入口:

RUST
use std::time::Duration;
 
# [tokio::main]
async fn main() {
let now = std::time::Instant::now();
tokio::time::sleep(Duration::from_secs(1)).await;
println!("睡了 1 秒,耗时 {:?}", now.elapsed());
}

注意这里 tokio::time::sleep(...).await 不是真的让线程睡 1 秒,而是让当前任务挂起,当前线程可以去执行其他任务。执行器会在定时器到期后重新唤醒它。你可以用同样的代码开 100 个 sleep 任务,理论上总耗时仍然接近 1 秒,而不是串行执行的 100 秒。

3.2 引入并发度限制:Semaphore 的正确用法

不加限制地 join_all 并发请求,很容易把目标服务器打挂,也容易把自己机器的文件描述符耗尽。tokio 提供了 Semaphore(信号量),它的思路很直观:一个计数器代表还有多少个“许可”(permit),每次任务开始前要先“购买”一个许可,结束后归还。

RUST
use std::sync::Arc;
use tokio::sync::Semaphore;
use reqwest::Client;
 
async fn fetch_url(client: Client, url: String) -> Result<String, reqwest::Error> {
let resp = client.get(&url).send().await?;
let text = resp.text().await?;
let title = extract_title(&text);
Ok(format!("{} -> {}", url, title))
}
 
fn extract_title(html: &str) -> String {
let lower = html.to_lowercase();
if let Some(start) = lower.find("<title>") {
if let Some(end) = lower.find("</title>") {
if let Some(inner) = lower.get(start + 7..end) {
return inner.trim().to_string();
}
}
}
"<未找到标题>".to_string()
}
 
# [tokio::main]
async fn main() {
let urls = vec![
"https://www.rust-lang.org".to_string(),
"https://crates.io".to_string(),
"https://github.com".to_string(),
// 可以继续加...
];
 
let semaphore = Arc::new(Semaphore::new(5));
let client = Client::new();
 
let mut tasks = Vec::new();
for url in urls {
let sem = semaphore.clone();
let client = client.clone();
tasks.push(tokio::spawn(async move {
let _permit = sem.acquire().await.expect("信号量已关闭");
fetch_url(client, url).await
}));
}
 
let results = futures::future::join_all(tasks).await;
for result in results {
match result {
Ok(Ok(line)) => println!("{}", line),
Ok(Err(e)) => eprintln!("请求失败: {}", e),
Err(e) => eprintln!("任务 panic: {}", e),
}
}
}

这里有个细节:let _permit = sem.acquire().await 得到的 SemaphorePermit 会在作用域结束(也就是这个 async 块跑到 fetch_url(...).await 完成之后)自动 drop,从而释放许可。如果你不小心把它写成了 let permit 并在整个任务中持有,也能正常限制并发,但要注意permit 必须保存在任务内,而不是在外部提前 acquire。我们是在任务内部 acquire,所以同一时刻最多 5 个任务处于“已获得许可且正在请求”的状态,其余任务会先挂起,等许可释放后再继续。

3.3 加上超时与重试,让程序更耐操

单纯的 send().await 可能遇到对方迟迟不响应,默认 reqwest 的超时时间很长,甚至可能无限等下去。你需要用 tokio::time::timeout 包一层:

RUST
async fn fetch_with_timeout(client: &Client, url: &str) -> Result<String, Box<dyn std::error::Error>> {
let fut = fetch_url(client.clone(), url.to_string());
match tokio::time::timeout(Duration::from_secs(10), fut).await {
Ok(result) => Ok(result?),
Err(_) => Err("请求超时".into()),
}
}

但 timeout 和 Future 的取消有个陷阱:如果 future 内部没有在 await 点检查取消状态,那么 timeout 返回 Err 后,future 可能仍然在后台继续执行。比如一个 sleep 10 秒的任务,你在 1 秒时 timeout,它其实还在 runtime 的任务队列里睡完剩下 9 秒。这通常没问题,但如果那个任务持有某个锁、或者占用了连接池连接,就可能造成资源泄漏或锁的意外延长持有。解法是尽量让 I/O 操作本身具备响应取消的能力——tokio 的网络和 sleep 操作都会在 drop 时取消注册,因此并发代码里用 select! 或 timeout 取消一个 tcp_stream.read(...).await 是安全的。

重试逻辑也很简单,但要注意“指数退避”别太激进:

RUST
async fn fetch_with_retry(client: &Client, url: &str) -> Result<String, Box<dyn std::error::Error>> {
let mut attempt = 0;
loop {
attempt += 1;
match fetch_with_timeout(client, url).await {
Ok(res) => return Ok(res),
Err(e) if attempt < 3 => {
eprintln!("第 {} 次尝试失败: {},1秒后重试", attempt, e);
tokio::time::sleep(Duration::from_secs(1)).await;
}
Err(e) => return Err(format!("重试 {} 次后仍失败: {}", attempt - 1, e).into()),
}
}
}

一般来说,对于 5xx 类错误可以重试,对于 4xx 类客户端错误不要重试,否则可能会把你的账号封掉。更完善的做法是读取 resp.status() 判断状态码是否可重试,这留给读者自己扩展。

3.4 用一个简单的 TCP 服务串联等待机制(可选扩展)

限流抓取只是 async 的一个侧面。如果你在做 Web 服务,tokio 背后真正的功臣是 TcpListener + TcpStream 的异步 I/O 驱动。这里贴一段简单的 echo server,帮你体会 accept().await 的循环:

RUST
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio::net::TcpListener;
 
# [tokio::main]
async fn main() -> std::io::Result<()> {
let listener = TcpListener::bind("127.0.0.1:8080").await?;
println!("监听端口: 8080");
 
loop {
let (mut socket, addr) = listener.accept().await?;
println!("新连接: {}", addr);
tokio::spawn(async move {
let mut buf = vec![0; 1024];
loop {
match socket.read(&mut buf).await {
Ok(0) => {
println!("连接关闭: {}", addr);
break;
}
Ok(n) => {
if socket.write_all(&buf[..n]).await.is_err() {
break;
}
}
Err(_) => break,
}
}
});
}
}

每来一个连接,accept().await 返回,然后 spawn 一个异步任务处理它。这个模型跟 sync 的 std::net 线程池模型最大的区别是:你不需要给每个连接分配一个线程,无论 100 还是 10 万个连接,占用的线程资源基本固定。当然,真实生产环境不会这样裸写 TCP,你会用 axum、actix-web 或者 hyper。但底层逻辑都差不多:监听端口 -> 异步读取请求 -> 异步写回响应 -> 关闭连接。

4. 踩坑记录:async 代码里的隐形杀手

讲完实操,再来聊一聊我在给团队做 Rust 异步代码 review 时反复看到的几类问题。每一个都是真实项目里炸过的雷,写下来给后来人当参考。

4.1 在异步代码中用了阻塞函数和标准库锁

最常见的问题就是在 async 函数里写了 std::thread::sleep 或者 std::sync::Mutex。前者会直接阻塞当前线程,而多线程 runtime 的工作线程被阻塞时,它执行队列里的其他任务全都被卡住。虽然 tokio 加入了新的阻塞任务检测机制,能提示哪些任务阻塞了 runtime,但最好自己养成好习惯:任何阻塞操作都丢进 tokio::task::spawn_blocking:

RUST
use tokio::task;
 
let result = task::spawn_blocking(|| {
std::thread::sleep(std::time::Duration::from_secs(2));
do_cpu_heavy_work()
}).await.unwrap();

std::sync::Mutex 的问题更隐蔽。你在 .await 之前用它保护共享数据,编译器不报错,但一旦这个锁被某个线程持有着并跨越 .await,另一个线程可能也会尝试获取同一个锁,于是死锁或者导致未来阻塞。正确的做法是使用 tokio 的异步锁:tokio::sync::Mutex。它的 lock().await 是异步的,不会阻塞线程。不过异步锁也有额外的等待成本,如果你只是保护一小段不跨越 await 的操作,用标准库锁或者直接改写为局部变量更高效。

4.2 跨 .await 持有非 Send 引用

如果你在 async 块里使用 Rc、RefCell 或者其他非 Send 类型,编译时会收到 future cannot be sent between threads safely 的错误。因为多线程 runtime 可能在 await 边界处把 future 迁移到另一个线程。有人觉得烦,就试图用 current_thread runtime 绕过。如果业务逻辑确实完全单线程,那可行;但如果你的目标是服务端并发,正确姿势是把非 Send 类型改成 Arc + Mutex 或 Arc + RwLock,或者只在这段代码里让它短暂存在,不跨越 await。

还有一个相对少见的坑:async 块内部借用局部数组的切片,编译器也可能推断出一个不满足 'static 的生命周期。解决办法通常是 Box::pin 之前先 collect 或者把数据 move 进任务。遇到这种错误,别硬调代码,先看错误信息里提示的 'static 是从哪个变量引入的,再做数据归属调整。

4.3 运行时初始化失败或嵌套 block_on

有人会写自己的线程池,然后在里面逐个创建 tokio runtime:

RUST
for _ in 0..threads {
std::thread::spawn(|| {
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async { ... });
});
}

这在某些场景下是合理的,但要注意每个 runtime 都有自己的事件循环线程池,如果你创建几十个 runtime,就等于创建了几百个线程,物理内存和调度负担都很大。更合理的是创建一个全局 runtime,然后用 Runtime::block_on 在需要的入口使用,或者在其他线程里通过 Handle::try_current 拿到句柄再 spawn 进去。

还有个非常经典的错误:在一个 tokio 异步任务内部再调用 Runtime::block_on。因为你已经处于异步上下文,block_on 会阻塞当前线程,还会去处理 runtime 里的其他任务,容易造成死锁。如果确实需要一个新 runtime 来隔离任务,至少要建立独立的 runtime 并小心地跨线程传递;但一般不需要,直接用 spawn 就行。

4.4 依赖拉取慢、镜像源配置速查

Rust 开发中另一个让新手当场崩溃的问题是 cargo build 拉取 crates.io 很慢,尤其在国内网络环境下,tokio 这样的大型依赖可能要拉好几分钟。解决办法是配置 crates.io 镜像源。在你本机的 ~/.cargo/config.toml(Windows 是 C:\Users\你的用户名\.cargo\config.toml)里写入:

TOML
[source.crates-io]
replace-with = "rsproxy-sparse"
 
[source.rsproxy-sparse]
registry = "sparse+https://rsproxy.cn/index/"

这种 sparse+ 协议是较新的索引方式,比旧的 git 索引快很多。另外还可以配置 [net] git-fetch-with-cli = true(可选)来复用你系统里已有的 git 客户端。不同镜像的域名和地址会变化,建议大家自己去官方文档查最新配置,别轻信博客里写死的老地址。配置完成之后,重新 cargo build,速度提升极明显。

4.5 一张速查表:从症状到解法

症状 可能原因 快速解法
程序卡住不退出,CPU 0% async 任务一直在 Pending,执行器以为还有活要干 检查是否所有 tokio 线程都退出了;用 select! 加超时
reqwest 请求一直不返回 没有设置超时 用 tokio::time::timeout 包裹
多线程 runtime 下日志乱序 任务被多个线程执行 不要依赖打印顺序,用 tracing 带 span 追踪
编译错误 future is not Send 异步块内使用了 Rc/RefCell 换成 Arc/异步锁/局部变量
编译错误 missing feature tokio 没打开相应 feature 按报错补 feature,或直接用 full
运行时 panic:There is no reactor running 没有 tokio runtime 就在调 tokio::time/net 进入 #[tokio::main] 或 block_on 后再用
cargo build 极慢 crates.io 源慢 配置国内镜像源

写异步代码这么多年,我的核心体会是:先顺着“共享数据 -> 任务边界 -> 阻塞点”这个链条把模型想清楚,再落笔写 spawn。不要一上来就把每个函数都变成 async。有些函数里面全是 CPU 计算,写成 async 只会增加无谓的调度开销;有些函数虽然内部没有网络 I/O,但会被上层 await 后才能拿到结果,这时候保持 async 反而让调用链更统一。

另外,调试 tokio 程序时,一定要学会 tokio-console 这个工具。它可以直观看到当前 runtime 里所有任务的调度状态、等待位置和阻塞时长,比打印日志高效得多。版本更新很快,装法直接看它的 GitHub README 就行。如果手头没有图形界面,也可以先用 RUST_LOG=trace 打开 tracing 日志观察关键事件。

如果你正准备开始写自己的第一个 async 项目,我建议从一个小工具练手,而不是一上来就造 Web 框架。先把 spawn、select!、Semaphore、mpsc channel 这四个组件用熟,再把它们组合起来解决一个实际问题,比如批处理脚本、消息转发中间件、定时任务调度器。你对异步的掌控感会很快建立起来。

基于Python+Open CV的手势识别算法设计
伴随着人工智能时代的到来,人机交互的领域也逐渐成为研究的一大方向;其中,手势识别是人机交互领域的一项关键技术,自此手势识别也迎来了一波高潮,近几年无论是在消费领域、电子领域、数码领域、家电领域甚至汽车领域上,都能或多或少的见到手势识别的身影。 手势识别在设计智能高效的人机界面方面具有至关重要的作用, 目前手势识别已应用到手语识别、智能监控、到虚拟现实等各个领域,手势识别的原理都是利用各种传感器(例如红外、摄像头等)对手部的形态进行捕捉并进行建模,形成一个模型信息的序列帧,而后将这些信息序列转换为机器能够识别的相对应指令(例如打开、切换菜单、移动等)来完成控制。 采用Python的集成开发环境Pycharm进行本次课程设计,在Pycharm中进行需要库(模块)的下载,调取电脑摄像头,按帧读取摄像头采集到的头像,形态学处理,图像旋转(由于摄像头采集到的图像是镜像,需要用cv2.flip将摄像头采集到的图像进行处理),选取图片中固定位置作为手势输入,用红线画出手势识别框,基于hsv的肤色检测,进行高斯滤波,找出轮廓,求出图像中手势的凹凸点,手指间角度求取。
努力学习前端的小陈
ArcGIS Pro入门制图教程
地理信息系统 (GIS) 是一种使用地图显示和分析数据的方式。在本教程中,您将学习桌面 GIS 应用程序 ArcGIS Pro 的基础知识。新加坡的一家旅行社希望制作一款宣传册,用于向游客介绍距离市中心热门目的地最近的火车站。该宣传册将与带有文本信息的地图相结合,并在城市的自助设备中出售。您将帮助该旅行社绘制旅游景点的地图,分析其与火车站的距离以及更改地图的外观以使其在视觉上更具吸引力。在 ArcGIS Pro 中,地图和数据通常被组织在一个工程中。开始制作地图之前,您将创建一个工程。
科研online
ArcGIS Pro 布局创建与地图加载全流程解析
本文详细解析了ArcGIS Pro中布局创建与地图加载的全流程。针对从ArcMap转来的用户,重点阐述了布局与地图解耦的核心设计理念,并提供了从新建布局、设置参考比例尺、加载地图框到深度控制与精细化排版的实用技巧,帮助用户高效制作专业地图。
您的账号已被封禁
ArcGIS PRO布局视图避坑指南:地图框添加与专题图制作的5个关键步骤
本文针对ArcGIS PRO用户在布局视图中制作专题图时遇到的常见问题,提供了地图框添加与专题图制作的5个关键步骤避坑指南。从理解布局视图思维、数据框预处理、地图元素协同配置,到深化视觉层次与最终输出检查,系统讲解了如何高效产出严谨美观的专业地图,帮助用户跨越从数据分析到地图输出的最后一公里。
冰炭不同炉
ROS-CV-ImageConverter:将ROS图像转换为OpenCV(cv :: Mat)类型的图像
ROS-CV图像转换器 依存关系 cv_bridge(ROS软件包)
Willis Wang
计算机视觉图像处理-CV2与图像插值算法
用最近邻插值与双线性插值原理完成图像缩放 最近邻插值,是指将目标图像中的点,对应到源图像中后,找到最相邻的整数点,作为插值后的输。缺点:使用最近邻插值算法处理图像放大时,在图象中可能出现明显的块状效应 双线性插值,在两个方向上做三次线性插值。使用双线性插值算法处理图像放大时,在图象中可能出现马赛克 代码 import cv2 img = cv2.imread(’./xiabang.jpg’, cv2.IMREAD_UNCHANGED) #缩放比例 scale_percent = 0.3 width = int(img.shape[1] * scale_percent) height = int
weixin_38697274
基于水平集CV模型的图像分割(Matlab代码)
基于水平集CV模型的图像分割(Matlab代码),全套代码
小宇QAQ
导向滤波(guide_filter)的python实现
导向滤波(guide_filter)的python实现,可以结合暗通道;理论实现比较好的图像去噪效果。
zachzhan_g
ArcGIS Pro 如何新建布局
你是否已经习惯了在ArcGIS中数据视图和布局视图之间来回切换,到了ArcGIS Pro中却找不到二者之间切换的按钮,即使新建布局后却发现地图怎么却是一片空白。从上面的图中可以看到,虽然新建了布局,但是地图还是空白的,如果想要显示地图还需要加载一下,将地图加载进来。在新建的布局上绘制一个框,作为地图显示的范围,绘制后可以看到地图已经完成加载,如下图所示。在菜单栏上选择插入,点击新建布局下拉箭头,选择一个合适的尺寸,如下图所示。点击后完成布局的新建,新建的布局如下图所示。
水经注GIS
ArcGIS Pro数据修复与图层管理实战指南
本文是ArcGIS Pro数据修复与图层管理的实战指南。针对数据源丢失导致的“红色叹号”问题,详细讲解了一键批量修复和进阶手动修复策略,并分享了使用相对路径、打包工程等防患于未然的黄金法则。同时,深入介绍了如何利用图层组进行高效的地图内容组织、比例尺控制与批量操作,帮助用户构建清晰、智能的专业地图,大幅提升GIS项目管理效率。
Tomato
ArcGIS Pro布局设计实战:从空白页面到专业地图输出的完整工作流
本文详细解析了ArcGIS Pro中从“新建布局”开始,到输出专业地图的完整工作流。内容涵盖布局哲学、地图框深度运用、制图元素集成及视觉排版等核心环节,旨在帮助中级用户掌握项目驱动的现代化制图方法,实现从数据到出版级地图的精准转化。
AnjneyMidha
ArcGIS PRO布局视图避坑指南:地图框添加与坐标系设置的5个常见错误
本文针对ArcGIS PRO用户在布局视图中常遇的难题,重点解析了地图框添加与坐标系设置的5个常见错误。从地图框的创建逻辑、坐标系冲突的根源剖析,到地图范围控制、元素联动更新以及打印导出设置,提供了一套完整的避坑指南与实战解决方案,帮助用户高效、精准地完成地图制图与输出工作。
重离子猫猫
ArcGIS Pro布局设计避坑指南:为什么你的地图总是显示空白?
本文深入解析ArcGIS Pro布局设计中地图显示空白的常见问题,提供从基础操作到高级排错的完整解决方案。重点讲解地图框的正确使用方法、布局元素配置技巧,以及多地图框协同工作等进阶功能,帮助用户快速掌握专业地图制作的核心技术。
习翔宇
CV算法(MATLAB)
chan 和 vese 提出的经典CV模型
beastLOVE
GrabCut:使用opencv-python cv2.grabCut交互式剪切图像
GrabCut 使用opencv-python cv2.grabCut交互式剪切图像
Aaron Gary
Opencv-Python图像透视变换cv2.warpPerspective的示例
今天小编就为大家分享一篇关于Opencv-Python图像透视变换cv2.warpPerspective的示例,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
weixin_38711369
leetcodecv-Kylin:CV算法岗面经&LeetCode刷题总结
leetcode cv Kylin CV算法岗面经 & LeetCode刷题总结 不断更新中。。。。 面试&笔试经验 LeetCode
weixin_38499553
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS.pdf
基恩士CV-X系列相机控制器用户手册CV-X Series Users Manual_CHS真的很不错,
weixin_43905342
ArcGIS布局视图方向调整与优化技巧
地图布局方向是GIS制图的基础设置,直接影响空间数据的可视化效果。横向(Landscape)和竖向(Portrait)布局通过调整页面长宽比例,可优化不同地理要素的展示方式。在ArcGIS等专业制图软件中,方向设置会联动影响比例尺、图例等核心元素的自动适配逻辑。本文以A4纸张为例,详解通过页面设置、Python脚本批处理等技术手段实现布局方向的高效调整,并针对比例尺失准、图例溢出等典型问题提供工程解决方案。特别适用于带状区域地图制作等需要最大化利用版面空间的场景,可提升40%以上的图面利用率。
塞音菩光
ArcGIS Pro 3.4必学新功能:符号系统与布局视图的可见性联动(含省时技巧)
ArcGIS Pro 3.4引入了符号系统与布局视图的可见性联动功能,通过唯一值符号化和复选框控制,实现原子级要素显示/隐藏。这一创新极大提升了制图效率,支持在符号系统窗格、内容窗格和布局视图中同步操作,特别适合城市规划、环境监测等需要动态展示的场景。
t8u9v0
ArcGIS Pro 布局创建与地图加载全攻略
本文详细解析了ArcGIS Pro中布局与地图分离的设计哲学,并提供了从新建布局到加载地图的完整操作指南。重点介绍了如何通过“插入”选项卡新建布局、选择合适的页面尺寸,以及使用地图框工具将项目中的地图动态链接至布局。文章还涵盖了地图范围控制、比例尺锁定、图例添加等深度定制技巧,帮助用户高效创建专业地图并导出为高质量成果。
milk8
ArcGIS多图布局实战:从数据框管理到批量导出的完整指南
在地理信息系统(GIS)制图领域,将多张地图高效整合到单一版面是提升分析报告专业性与表现力的关键技术。其核心原理在于理解并运用数据框与布局视图的分离机制,通过独立的数据框承载不同区域或专题的地理数据,并在统一的布局视图中进行精确排版与视觉整合。这项技术的核心价值在于实现了制图流程的标准化与自动化,避免了传统拼图方式带来的效率低下与更新困难问题,尤其适用于区域对比、时间序列分析、综合评估报告等需要多视角、多维度展示地理信息的应用场景。本文聚焦于ArcGIS Pro平台,深入剖析了多图布局中数据框范围联动、地图
aaa1231722
monolithic-cv:CV算法的集合
单片-cv 计算机视觉算法转储
晨曦姜
改进的cv图像分割
改进的cv图像分割,对学习cv模型有帮助
a904235765
C++实现基于暗通道与导向滤波的图像去雾算法
资源下载链接为: https://pan.quark.cn/s/1bfadf00ae14 在图像处理领域,图像去雾技术用于消除大气散射导致的模糊,提升图像清晰度和视觉质量。本文将介绍一种基于暗通道和导向滤波的图像去雾算法,并探讨如何使用C++和OpenCV库实现。 暗通道理论由Jia等人于2006年提出。他们发现自然场景中存在一些低亮度像素,通常位于无直射光区域。这些像素被称为暗通道像素,可用于估计大气散射模型中的透射率。具体方法是将图像分块,在每块中找到最暗像素值作为暗通道像素。 大气散射模型是图像去雾的基础,描述了光线在大气中传播时的散射影响。模型公式为: I(x)=T(x)×J(x)+A×(1−T(x)) 其中,T(x)是透射率,J(x)是无雾图像亮度,A是全局大气光。透射率与散射程度成反比,无雾图像亮度反映物体本身色彩。 利用暗通道先验,可以近似估计透射率。假设D(x)为暗通道像素,透射率T(x)可通过迭代公式计算: T k+1 (x)= max(D)+ϵ D(x) +(1− max(D)+ϵ D(x) )×T k (x) 其中,k是迭代次数,ϵ是小常数,用于避免除零。 估计透射率后,使用导向滤波器平滑透射率图,减少噪声和边缘失真。导向滤波是一种自适应局部滤波方法,可保持图像边缘细节,同时进行平滑处理。在图像去雾中,它根据图像梯度信息指导滤波过程,更好地恢复图像清晰度。 通过大气散射模型,可得到去雾后的图像: J out (x)= T(x) I(x)−A×(1−T(x)) +A 在C++中,可借助OpenCV库处理图像数据。首先读取输入图像,然后提取暗通道,估计透射率,应用导向滤波,最终恢复无雾图像。OpenCV提供了丰富的图像处理函数,如cv::split用于分离通道,cv::min用于找最小值,cv::filter2D用于导向滤波,cv::imwrite用于保存
KaiyuanCode
cv模型图像分割matlab源程序
cv模型 matlab 图像分割源码,逻辑清晰,注释详尽。
phoenix01
CV图像分割
从pud找到的CV图像分割代码,代码的通过较少的迭代次数就可以实现图像的分割,对学习CV分割有帮助。
a904235765
ArcGIS Pro 3.0 布局视图实战:5分钟搞定专业地图的图例、比例尺与指北针
本文详细介绍了ArcGIS Pro 3.0布局视图的实战技巧,帮助用户在5分钟内高效添加图例、比例尺与指北针,打造专业地图。通过智能图例、动态比例尺和现代化指北针设计,提升制图效率与美观度,特别适合GIS初学者和从ArcMap迁移的用户。
weixin_30652491
ArcGIS Pro界面突然消失?3种恢复方法+自定义布局技巧
本文针对ArcGIS Pro用户常见的操作界面元素突然消失问题,提供了三种核心恢复方法:通过“视图”功能区一键唤回、利用“重置窗格”命令恢复默认布局,以及通过应用程序设置进行深度恢复。文章还深入讲解了如何通过停靠、分组窗格以及自定义功能区等技巧,打造高效个性化的操作界面,帮助用户从被动解决问题转向主动优化工作环境。
nnn11
[UE5蓝图基础二]1.[1d混合空间] 走和跑的动画切换(shift切换)
再双击”run”进去 我们需要给他指定一个动画姿势,这里就需要给他我们前面做的”1d”混合空间,然后可以看到”1d” 上有个speed参数,代表的速度 从前面的逻辑来看需要通过控制速度来切换动画,那么必然不能写死速度,把速度提升为变量传递进来即可,所以就得到以下蓝图节点。混合空间的概念:混合空间就是可以将角色多个动画混合在一起 ,我们创建动画类就是创建个”Animation”文件夹 在文件夹内创建混合空间。我们目前要实现的是一个走和跑的功能 那么创建1d即可。到这一步混合空间已经做完 下一步做”动画蓝图”
朝而往的朝