vdbsh

已于 2025-01-07 17:40:43 修改
阅读量187 收藏 2
点赞数 1
CC 4.0 BY-SA版权
文章标签： c++
于 2025-01-07 14:21:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sddsdf/article/details/144984954

好的，我们可以简化数据存储逻辑，将所有数据仅存储在 workingData 中，而不单独为每个方向维护数据结构。具体做法如下：

  1. 数据统一存储：

    • 所有的补偿数据按机械臂编号存储在 workingData 中（一个二维 vector）。

  2. 按方向筛选：

    • 在计算补偿时，根据方向条件筛选出符合要求的数据（如果需要按方向补偿）。
    • 当按方向的数据不足时，直接使用全局数据（不考虑方向）。

  3. 清晰简化逻辑：

    • 只需要维护 workingData，减少复杂度。

修改后的代码

#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

enum Dir {
    LEFT,
    RIGHT,
    UP,
    DOWN
};

struct Compen {
    long lPadIndex;           // 数据编号
    unsigned short usArmId;   // 机械臂编号
    Dir dir;                  // 数据方向
    double X, Y, T;           // 偏差值
    double dCompensation;     // 补偿值
};

class CompensationCalculator {
public:
    CompensationCalculator(int windowSize, bool useDirectionCompensation)
        : n(windowSize), useDirectionCompensation(useDirectionCompensation) {
        workingData.resize(2); // 初始化存储空间，支持两个机械臂
    }

    double calculateCompensation(unsigned short armId, Dir dir) {
        const auto& data = workingData[armId];

        // 按方向筛选数据
        std::vector<Compen> filteredData;
        if (useDirectionCompensation) {
            for (const auto& entry : data) {
                if (entry.dir == dir) {
                    filteredData.push_back(entry);
                }
            }
        }

        // 判断是否使用全局补偿
        if (filteredData.size() < n) {
            std::cout << "Not enough data for direction compensation, falling back to global compensation." << std::endl;
            filteredData = data; // 全局补偿使用所有数据
        }

        // 如果全局数据不足，返回补偿值 0
        if (filteredData.size() < n) {
            return 0.0;
        }

        // 取最近 n 条数据计算平均补偿值
        double sum = 0.0;
        for (int i = filteredData.size() - n; i < filteredData.size(); ++i) {
            sum += (filteredData[i].dCompensation +
                    filteredData[i].X +
                    filteredData[i].Y +
                    filteredData[i].T);
        }
        return sum / n;
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        auto& data = workingData[armId];
        data.push_back(newEntry);
        // 如果数据超过 n 条，则移除最早的数据
        if (data.size() > n * 4) { // 假设每个方向最多存储 n 条
            data.erase(data.begin());
        }
    }

private:
    int n;                                     // 滑动窗口大小
    bool useDirectionCompensation;            // 是否按方向补偿
    std::vector<std::vector<Compen>> workingData; // 每个机械臂的数据存储
};

int main() {
    CompensationCalculator calculator(5, true); // 窗口大小为5，启用方向补偿

    // 添加示例数据
    calculator.addData(0, {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4});
    calculator.addData(0, {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5});
    calculator.addData(0, {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6});
    calculator.addData(0, {4, 0, RIGHT, 0.4, 0.5, 0.6, 0.7});

    // 测试按方向补偿
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(armId, currentDir);

    std::cout << "New Compensation for Arm " << armId << " (Direction LEFT): " << newCompensation << std::endl;

    // 测试全局补偿（方向不足时触发）
    currentDir = UP; // 使用新方向，但没有数据
    newCompensation = calculator.calculateCompensation(armId, currentDir);

    std::cout << "New Compensation for Arm " << armId << " (Global Fallback): " << newCompensation << std::endl;

    return 0;
}

关键改动

  1. 数据存储：

    • 所有数据统一存储在 workingData 中，按机械臂编号分类。
    • 每个方向不再独立维护数据结构。

  2. 按方向筛选：

    • 在 calculateCompensation 中，先筛选出符合方向的数据。
    • 如果筛选后数据不足 n 条，则回退到全局数据。

  3. 全局补偿逻辑：

    • 直接使用所有数据计算全局补偿。
    • 如果全局数据不足 n 条，直接返回 0.0。

  4. 数据管理：

    • 每个机械臂最多保留 n * 4 条数据（假设每个方向最多存储 n 条数据）。
    • 超过限制时，移除最早的数据，保证数据队列长度受控。

输出示例

假设数据如下：

  • LEFT 方向数据：3 条
  • RIGHT 方向数据：1 条
  • UP 和 DOWN 方向数据：0 条

程序输出：

Not enough data for direction compensation, falling back to global compensation.
New Compensation for Arm 0 (Direction LEFT): 0.55
Not enough data for direction compensation, falling back to global compensation.
New Compensation for Arm 0 (Global Fallback): 0.575

优化点

  1. 简化存储：

    • 数据仅存储在 workingData 中，按机械臂编号分类。
    • 不再维护按方向的数据队列，逻辑更加清晰。

  2. 统一逻辑：

    • 通过筛选实现按方向补偿，无需额外的数据结构。
    • 方向数据不足时自动回退到全局补偿。

  3. 高效扩展：

    • 支持多方向和多机械臂，易于调整窗口大小。
#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>

enum Dir {
    LEFT,
    RIGHT,
    UP,
    DOWN
};

struct Compen {
    long lPadIndex;           // 数据编号，唯一标识
    unsigned short usArmId;   // 机械臂编号
    Dir dir;                  // 数据方向
    double X, Y, T;           // 偏差值
    double dCompensation;     // 补偿值
};

class CompensationCalculator {
public:
    CompensationCalculator(int windowSize, bool useDirectionCompensation)
        : n(windowSize), useDirectionCompensation(useDirectionCompensation) {
        workingData.resize(2); // 初始化存储空间，支持两个机械臂
    }

    double calculateCompensation(unsigned short armId, Dir dir) {
        auto& data = workingData[armId];

        // 按方向筛选数据
        std::vector<Compen> filteredData;
        if (useDirectionCompensation) {
            for (const auto& entry : data) {
                if (entry.dir == dir) {
                    filteredData.push_back(entry);
                }
            }
        }

        // 判断是否使用全局补偿
        if (filteredData.size() < n) {
            std::cout << "Not enough data for direction compensation, falling back to global compensation." << std::endl;
            filteredData = data; // 全局补偿使用所有数据
        }

        // 如果全局数据不足，返回补偿值 0
        if (filteredData.size() < n) {
            return 0.0;
        }

        // 按 lPadIndex 排序，确保取到最新的数据
        std::sort(filteredData.begin(), filteredData.end(), [](const Compen& a, const Compen& b) {
            return a.lPadIndex < b.lPadIndex;  // 按 lPadIndex 排序
        });

        // 取最近 n 条数据计算平均补偿值
        double sum = 0.0;
        int count = std::min(n, static_cast<int>(filteredData.size()));
        for (int i = filteredData.size() - count; i < filteredData.size(); ++i) {
            sum += (filteredData[i].dCompensation +
                    filteredData[i].X +
                    filteredData[i].Y +
                    filteredData[i].T);
        }
        return sum / count;
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        auto& data = workingData[armId];
        
        // 查找是否已存在相同 lPadIndex 的条目
        auto it = std::find_if(data.begin(), data.end(), [&newEntry](const Compen& entry) {
            return entry.lPadIndex == newEntry.lPadIndex;
        });

        // 如果找到相同的 lPadIndex，则修改数据
        if (it != data.end()) {
            *it = newEntry;
            std::cout << "Updated data for lPadIndex: " << newEntry.lPadIndex << std::endl;
        } else {
            // 否则，添加新数据
            data.push_back(newEntry);
            std::cout << "Added new data for lPadIndex: " << newEntry.lPadIndex << std::endl;
        }

        // 如果数据超过 n 条，则移除最早的数据
        if (data.size() > n * 4) { // 假设每个方向最多存储 n 条数据
            data.erase(data.begin());
        }
    }

private:
    int n;                                     // 滑动窗口大小
    bool useDirectionCompensation;            // 是否按方向补偿
    std::vector<std::vector<Compen>> workingData; // 每个机械臂的数据存储
};

int main() {
    CompensationCalculator calculator(5, true); // 窗口大小为5，启用方向补偿

    // 添加示例数据
    calculator.addData(0, {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4});
    calculator.addData(0, {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5});
    calculator.addData(0, {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6});
    calculator.addData(0, {4, 0, RIGHT, 0.4, 0.5, 0.6, 0.7});

    // 测试按方向补偿
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(armId, currentDir);

    std::cout << "New Compensation for Arm " << armId << " (Direction LEFT): " << newCompensation << std::endl;

    // 修改已有的 lPadIndex 为 2 的数据
    calculator.addData(0, {2, 0, LEFT, 0.25, 0.35, 0.45, 0.55});  // 更新 lPadIndex 为 2 的数据

    // 再次计算补偿
    newCompensation = calculator.calculateCompensation(armId, currentDir);
    std::cout << "New Compensation after Update for Arm " << armId << " (Direction LEFT): " << newCompensation << std::endl;

    // 测试全局补偿（方向不足时触发）
    currentDir = UP; // 使用新方向，但没有数据
    newCompensation = calculator.calculateCompensation(armId, currentDir);

    std::cout << "New Compensation for Arm " << armId << " (Global Fallback): " << newCompensation << std::endl;

    return 0;
}
风水共舞
关注
C++ : list的模拟
2402_87310323的博客
07-25 615
找到pos前的节点位置，这里保存一下pos迭代器中的节点指针指向的前一个节点的指针_prev即可找到pos前的节点位置prev ，用new去申请一个值为val的节点作为要插入的新节点newnode，同时由于插入了一个节点，那么_size也应该对应加1。erase——初始状态无论有数据节点还是没有数据节点，这里的头节点都存在，不能被删除，所以应该使用asseert断言一下pos不等于头节点 ，删除一个节点之后list对象中的有效节点个数_size应该对应减一 ，必须是引用传参的形式，否则会造成无穷递归 ，
C语言（十）
2302_80202237的博客
07-24 331
函数是面向过程编程思想的具体体现，主要作用：降低程序之间的耦合性提高代码的复用性和可维护性一个完整的 C 程序由**一个或多个程序模块（源文件）**组成。为便于开发与调试，通常会将代码拆分为多个源文件，并组合成一个整体程序。每个源文件是一个编译单位，即 C 编译器以“源文件”为单位进行编译。程序从main()函数开始执行，调用其他函数后，执行完再返回到main()，最终在main()结束程序运行。用户根据需要自定义提高模块化和代码复用能力。
C++视觉算法实战指南
keny-大成的博客
07-23 822
本文介绍了C++在计算机视觉领域的常用算法实现，涵盖OpenCV图像处理、PCL点云处理和OpenCV DNN模块三大方向。主要内容包括：1. OpenCV基础：图像滤波、边缘检测、特征匹配等传统算法实现；2. PCL点云处理：滤波、分割、配准、特征提取等点云操作方法；3. OpenCV DNN模块：YOLO、ResNet等深度学习模型的部署应用。文章提供了大量可直接运行的代码示例，适合开发者快速实现各类视觉任务，同时强调了算法选择和性能优化的注意事项。
STL内建函数对象
m0_53506460的博客
07-22 176
这个在实际开发中基本上用不到，因此可以选择性的忽略。功能描述：实现关系对比。
Effective C++ 条款02：尽量以 const, enum, inline 替换 #define
君鼎的博客
07-25 356
Effective_C++_02
嵌入式——C语言：函数②
2501_91498265的博客
07-24 762
else if不满足代码加入编译。#ifdef 定义了宏，代码加入编译。1.1#include:包含一个文件，文件会在预处理编译时展开。3.4调用函数的文件只需加对应函数的.h头文件即可使用该函数。3.3功能代码.h主要负责声明功能代码.c的功能函数。函数①的补充：extern（多文件编写一个代码时常用）3.2功能代码.c负责功能代码编写。2.注意：数组传递到函数体内部与外部操作是同一数组。
【C++】二叉搜索数
最新发布
Shengmc的博客
07-25 629
二叉搜索树又称二叉排序树，它或者是⼀棵空树，或者是具有以下性质的二叉树。
C++ 扫描局域网某个端口是否开放（如 5555 ）(android adb) 线程并发加速
chenhao0568的专栏
07-23 874
方法能否发现 ADB？扫描速度准确性推荐度ICMP ping只能判断设备是否在线中等不能判断端口⭐⭐TCP 端口扫描（如上）✅ 可判断 5555 是否开放快速（可并发）✅ ✅⭐⭐⭐⭐⭐把这段代码封装成 GUI 小工具？加上线程并发加速？加上 JSON 日志输出？你可以告诉我，我可以一步步帮你构建成专业扫描器。
C++符合快速入门(有java和js基础的)
2302_77002233的博客
07-24 378
【代码】C++符合快速入门(有java和js基础的)
C++扩展 --- 并发支持库（下）
Small_entreprene的博客
07-24 1220
本文介绍了C++11并发支持库中三种重要的锁管理工具。lock_guard采用RAII机制自动管理互斥锁，在构造时加锁，析构时解锁，确保异常安全。unique_lock功能更丰富，支持延迟锁定、尝试锁定和移动语义，提供更灵活的锁管理。std::lock函数能原子性地锁定多个互斥锁，避免死锁问题。此外，文章还讲解了std::call_once的用法，保证多线程环境下某个函数只执行一次。这些工具能有效解决多线程编程中的资源管理、死锁预防等问题，提高代码的健壮性和安全性。
【C++】第十八节—一文万字详解 | map和set的使用
稻草人
07-22 5548
set的声明如下，T就是set底层关键字的类型，也就是我们上面说的keyset默认要求T支持小于比较，如果不支持或者想按自己的需求走可以自行实现仿函数传给第二个模版参数set底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给第三个参数。⼀般情况下，我们都不需要传后两个模版参数。set底层是用红黑树实现，增删查效率是 ，迭代器遍历是走的搜索树的中序，所以是有序的。O(logN)
C语言面向对象编程
m0_59749585的博客
07-22 325
list_head每一个list_head实际就是两个指针：指向下一个节点和上一个节点。宏 / 函数作用定义并初始化链表头初始化某个节点（通常用于结构体内嵌）添加到链表头部添加到链表尾部删除节点判断链表是否为空遍历链表（不获取结构体）遍历链表（获取结构体指针）安全遍历（可删除）
C++ 智能指针
2401_82978699的博客
07-23 459
摘要：智能指针解决了C++手动内存管理的痛点，包括内存泄漏、重复释放和异常安全问题。C++11提供三种核心智能指针：unique_ptr（独占所有权，不可复制，只能转移）、shared_ptr（共享所有权，引用计数机制）和weak_ptr（弱引用，解决循环引用问题）。最佳实践推荐使用std::make_unique和std::make_shared创建智能指针，既保证异常安全又提升性能。智能指针通过RAII技术自动管理资源生命周期，将资源获取与对象初始化绑定，释放与对象销毁绑定，是现代化C++内存管理的核心
C++ explicit 上下文相关转换
刘杰的博客
07-24 544
C++ 允许程序员为自己的类定义转换规则，主要有两种方式[3][4]转换构造函数 (Converting Constructor)：一个可以只用一个参数调用的构造函数（非explicit它定义了如何将参数类型转换为类类型。转换运算符 (Conversion Operator)：一种特殊的类成员函数，定义了如何将类类型转换为其他类型[5]。默认情况下，这些用户定义的转换可以是隐式的，即编译器可以在需要时自动调用它们，无需程序员显式指示[4]。explicit。
C++初学者3——变量与常量
xdlka的博客
07-23 1248
C++初学者看过来，详细的初学者课程——变量与常量已经发布啦，快来学习学习，全网全详细的讲解。
【补题】Codeforces Round 735 (Div. 2) C. Mikasa
2401_87294509的博客
07-25 153
2.很明显，0~m对应得到的值没有规律，甚至异或出来的值都不一定再0~m内，但是假设我们要获得的值是x，那么。1.首先很容易观察到n>m的时候，一定不存在，因为要有0，一定要有m=n。，然后试图特判出mex，构造出来的最小可能就是m所带来的，这个点非常难判。3.这看起来毫无关联，但是我们构造的是答案x，我们先试图构造。，c是某个不属于0~m的值，因为异或的性质，可以知道。，但是在这个过程中，从高位到低位贪心构造，如果发现。，在那一刻已经满足了x>=m+1，直接跳出就行了。x有一个性质x>=m+1。
【加解密与C】Rot系列(四)Rot8000
geesehoward20000的博客
07-22 1164
Rot8000 是一种基于 Unicode 字符集的旋转加密算法，类似于经典的 Rot13，但扩展到了更大的字符范围（通常是 Unicode 的基本多语言平面，即 U+0000 到 U+FFFF）。Rot13 仅适用于 26 个拉丁字母，而 Rot8000 通过覆盖更多字符（如中文、符号等），增强了加密的灵活性和趣味性。
深入解析MIPI C-PHY (三）C-PHY 功耗屠龙刀
GateWorld的博客
07-22 916
当MIPI D-PHY v2.5已将电压摆幅压缩至200mV，C-PHY仍能实现46.4mW系统级功耗节省（同4K30帧场景），其秘密在于三重架构革新：电流模驱动精准控能、 三线共模噪声抵消、 协议层休眠革命。
现代 C++ 开发工作流（VSCode / Cursor）
滴水成川
07-25 154
本文介绍了现代C++开发的工作流配置，包括环境要求（C++编译器、CMake、clangd）、VSCode/Cursor插件安装建议（clangd、CMake Tools等）、clangd的安装与配置方法、CMake项目初始化流程、以及.clangd和VSCode的可选配置示例。最后提供了日常工作流总结，从初始化构建到代码编写、补全、调试的全流程指引，并提示首次打开项目时的索引等待时间及常见问题排查方法。该配置适用于需要高效C++开发的场景。
学习C++、QT---32（QT库中如何进行事件重写实现我们的放大缩小字体功能）
你的潜力远比你想象的更大，别给自己设限。
07-22 998
《Qt控件开发中的父子关系与事件处理机制解析》 本文深入解析了Qt开发中的两个核心技术点：控件父子关系和事件处理机制。在父子关系方面，详细阐述了parent参数的核心作用，包括建立控件层级、实现自动内存管理（父控件销毁时自动删除子控件）以及决定显示效果。文章通过具体示例展示了传递parent与不传递的区别，并解释了Qt采用这种设计的原因。在事件处理部分，重点分析了wheelEvent、keyPressEvent等事件的重写方法，强调在扩展功能时需要合理调用父类事件处理函数以保留默认行为，并详细说明了acce
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值