如何为PCL的StatisticalOutlierRemoval过滤实现安全超时取消？

C++标准不支持安全强制终止线程（会导致资源泄漏、锁未释放等问题），必须采用协作式取消逻辑。针对你使用pcl::StatisticalOutlierRemoval的场景，以下是几个可行的实现方案：

方案一：用子进程替代线程（安全无需修改PCL） #

进程可以被安全终止且不会影响主进程的内存状态，适合处理无法中断的阻塞式任务。

实现思路 #

1. 将输入点云序列化到临时文件，传递给子进程
2. 子进程执行过滤逻辑，完成后将结果写入临时文件
3. 主进程监控子进程运行时长，超时则终止子进程并回收资源

代码示例 #

#include <unistd.h>
#include <sys/wait.h>
#include <pcl/io/pcd_io.h>
#include <pcl/filters/statistical_outlier_removal.h>
#include <chrono>
#include <string>

void cloud_filtering_child(const std::string& input_path, const std::string& output_path) {
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr pcl_unfilt(new pcl::PointCloud<pcl::PointXYZRGB>);
    pcl::PointCloud<pcl::PointXYZRGB>::Ptr pcl_filt(new pcl::PointCloud<pcl::PointXYZRGB>);
    
    if (pcl::io::loadPCDFile(input_path, *pcl_unfilt) == -1) exit(1);
    
    pcl::StatisticalOutlierRemoval<pcl::PointXYZRGB> sor;
    sor.setInputCloud(pcl_unfilt);
    sor.setMeanK(50);
    sor.setStddevMulThresh(1.0);
    sor.filter(*pcl_filt);
    
    pcl::io::savePCDFileBinary(output_path, *pcl_filt);
    exit(0);
}

bool cloud_filtering_with_timeout(pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_unfilt, 
                                 pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_filt,
                                 int timeout_seconds) {
    // 生成唯一临时文件名，避免多任务冲突
    auto timestamp = std::chrono::system_clock::now().time_since_epoch().count();
    std::string input_pcd = "/tmp/input_" + std::to_string(timestamp) + ".pcd";
    std::string output_pcd = "/tmp/output_" + std::to_string(timestamp) + ".pcd";
    
    if (pcl::io::savePCDFileBinary(input_pcd, *pcl_unfilt) == -1) {
        return false;
    }
    
    pid_t pid = fork();
    if (pid == 0) {
        cloud_filtering_child(input_pcd, output_pcd);
    } else if (pid > 0) {
        int status;
        pid_t result = waitpid(pid, &status, WNOHANG);
        int elapsed = 0;
        
        while (result == 0 && elapsed < timeout_seconds) {
            sleep(1);
            elapsed++;
            result = waitpid(pid, &status, WNOHANG);
        }
        
        if (result == 0) {
            kill(pid, SIGTERM);
            waitpid(pid, &status, 0); // 回收子进程，避免僵尸进程
            unlink(input_pcd.c_str());
            return false;
        } else {
            if (WIFEXITED(status) && WEXITSTATUS(status) == 0) {
                pcl::io::loadPCDFile(output_pcd, *pcl_filt);
            }
            unlink(input_pcd.c_str());
            unlink(output_pcd.c_str());
            return true;
        }
    } else {
        unlink(input_pcd.c_str());
        return false;
    }
}

方案二：修改PCL源码添加协作式取消（最优雅但需编译PCL） #

如果可以自定义编译PCL，给StatisticalOutlierRemoval添加取消标志，在过滤循环中定期检查，实现优雅退出。

修改步骤 #

1. 在statistical_outlier_removal.h中添加原子取消标志：

#include <atomic>

template <typename PointT>
class StatisticalOutlierRemoval : public Filter<PointT> {
    // 原有成员保持不变
private:
    std::atomic<bool> cancel_requested_{false};
public:
    void cancel() { cancel_requested_.store(true); }
};

2. 在statistical_outlier_removal.cpp的filter方法中插入取消检查：

template <typename PointT>
void StatisticalOutlierRemoval<PointT>::filter(PointCloud &output) {
    // 原有初始化代码保持不变
    
    // 在点处理循环中添加检查
    for (int i = 0; i < indices_->size(); ++i) {
        if (cancel_requested_.load()) {
            output.clear();
            return; // 优雅退出过滤流程
        }
        // 原有点处理逻辑保持不变
    }
    
    // 后续代码保持不变
}

3. 应用层调用示例：

#include <atomic>
#include <future>
#include <thread>

void cloud_filtering(pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_unfilt, 
                     pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_filt,
                     std::atomic<bool>* cancel_flag) {
    // 预处理逻辑
    
    pcl::StatisticalOutlierRemoval<pcl::PointXYZRGB> sor;
    sor.setInputCloud(pcl_unfilt);
    sor.setMeanK(50);
    sor.setStddevMulThresh(1.0);
    
    // 启动后台线程检查取消信号
    std::thread cancel_checker([&sor, cancel_flag]() {
        while (!cancel_flag->load()) {
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }
        sor.cancel();
    });
    
    sor.filter(*pcl_filt);
    cancel_checker.join();
    
    // 后处理逻辑
}

// 使用方式
auto cancel_flag = std::make_shared<std::atomic<bool>>(false);
auto future = std::async(std::launch::async, 
                         cloud_filtering, pcl_unfilt, pcl_filt, cancel_flag.get());

if (future.wait_for(std::chrono::seconds(5)) == std::future_status::timeout) {
    cancel_flag->store(true);
    future.get(); // 等待线程优雅退出
}

方案三：共享取消标志（仅适用于可拆分任务） #

如果cloud_filtering中除了sor.filter()还有其他可拆分的步骤，可以在这些步骤中插入取消检查，但无法中断sor.filter()本身的执行。

代码示例 #

#include <atomic>

std::atomic<bool> task_cancelled_{false};

void cloud_filtering(pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_unfilt, 
                     pcl::PointCloud<pcl::PointXYZRGB>::SharedPtr pcl_filt) {
    if (task_cancelled_.load()) return;
    
    // 预处理逻辑
    if (task_cancelled_.load()) return;
    
    pcl::StatisticalOutlierRemoval<pcl::PointXYZRGB> sor;
    sor.setInputCloud(pcl_unfilt);
    sor.setMeanK(50);
    sor.setStddevMulThresh(1.0);
    sor.filter(*pcl_filt); // 此段无法中断
    
    if (task_cancelled_.load()) {
        pcl_filt->clear();
        return;
    }
    
    // 后处理逻辑
}

// 使用方式
task_cancelled_.store(false);
auto future = std::async(std::launch::async, 
                         &cloud_filtering, this, pcl_unfilt, pcl_filt);

if (future.wait_for(std::chrono::seconds(5)) == std::future_status::timeout) {
    task_cancelled_.store(true);
    future.get();
}

• 方案一的临时文件需使用唯一命名，避免多任务冲突；
• 方案二需要重新编译PCL，预编译版本无法直接使用；
• 方案三仅能在非阻塞步骤中取消，无法中断核心过滤逻辑。

内容的提问来源于stack exchange，提问作者Lucyanno Frota