【无标题】

已于 2025-01-07 14:10:57 修改
阅读量83 收藏
点赞数 1
CC 4.0 BY-SA版权
文章标签： c++
于 2025-01-07 14:08:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/sddsdf/article/details/144979587 
#include <iostream>
#include <vector>
#include <deque>
#include <numeric> // for std::accumulate
#include <algorithm> // for std::copy_if

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

struct Compen {
    long lPadIndex;
    unsigned short usArmId; // 总共两个机械臂，0或1
    Dir dir;
    double X, Y, T; // 偏差值
    double dCompensation; // 补偿值
};

// 辅助函数，用于计算指定机械臂ID的最近n个补偿值和偏差值的平均值
// 如果按方向补偿开关关闭，则忽略方向参数
double calculateCompensation(const std::vector<Compen>& data, unsigned short armId, Dir dir, int n, bool useDirection) {
    double sum = 0.0;
    int count = 0;
    std::deque<Compen> filteredData;

    // 如果使用方向补偿，则只考虑相同方向的数据
    if (useDirection) {
        for (const auto& compen : data) {
            if (compen.usArmId == armId && compen.dir == dir && count < n) {
                filteredData.push_back(compen);
                count++;
            }
        }
    } else {
        // 如果不使用方向补偿，则考虑最近n个数据（不考虑方向）
        if (data.size() >= n) {
            filteredData.assign(data.end() - n, data.end());
            count = n;
        } else {
            filteredData.assign(data.begin(), data.end());
            count = data.size();
        }
    }

    // 计算平均值
    for (const auto& compen : filteredData) {
        sum += (compen.dCompensation + compen.X + compen.Y + compen.T);
    }

    return count == 0 ? 0.0 : sum / count;
}

int main() {
    int n = 5; // 滑动平均的窗口大小
    std::vector<Compen> WorkingData[2]; // 存储两个机械臂的数据
    bool useDirectionCompensation = true; // 是否按方向补偿的开关

    // 示例数据添加（在实际应用中，这些数据将来自机械臂的传感器或作业记录）
    // ... 添加数据到WorkingData中

    // 假设我们现在要为机械臂0进行作业
    unsigned short armId = 0;
    Dir currentDir = LEFT;

    // 计算补偿值
    double newCompensation = calculateCompensation(WorkingData[armId], armId, currentDir, n, useDirectionCompensation);

    // 假设我们有一个函数来移动机械臂到指定位置（位置+补偿值）
    // moveArmToPosition(armId, targetPosition + newCompensation);

    // 假设作业后我们得到了新的偏差值
    double newX = 0.15, newY = 0.25, newT = 0.35;

    // 创建一个新的Compen对象来存储这次作业的数据
    Compen newEntry = {WorkingData[armId].size() + 1, armId, currentDir, newX, newY, newT, newCompensation};

    // 将新数据添加到对应机械臂的数据集中
    WorkingData[armId].push_back(newEntry);

    // 输出新添加的补偿值和数据，用于验证
    std::cout << "New Compensation for Arm " << armId << " (Use Direction: " << (useDirectionCompensation ? "Yes" : "No") << "): " << newCompensation << std::endl;
    std::cout << "New Entry: " << newEntry.lPadIndex << ", " << newEntry.usArmId << ", " 
              << (newEntry.dir == LEFT ? "LEFT" : (newEntry.dir == RIGHT ? "RIGHT" : (newEntry.dir == UP ? "UP" : "DOWN"))) 
              << ", " << newEntry.X << ", " << newEntry.Y << ", " << newEntry.T << ", " << newEntry.dCompensation << std::endl;

    // 更改补偿开关并重新计算补偿值（可选，仅用于演示）
    useDirectionCompensation = false;
    newCompensation = calculateCompensation(WorkingData[armId], armId, currentDir, n, useDirectionCompensation);
    std::cout << "New Compensation for Arm " << armId << " (Use Direction: " << (useDirectionCompensation ? "Yes" : "No") << "): " << newCompensation << std::endl;

    return 0;
}

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

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) {}

    double calculateCompensation(const std::vector<Compen>& data, unsigned short armId, Dir dir) {
        if (useDirectionCompensation) {
            return calculateWithDirection(data, armId, dir);
        } else {
            return calculateWithoutDirection(data);
        }
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        workingData[armId].push_back(newEntry);
    }

private:
    int n; // 滑动平均窗口大小
    bool useDirectionCompensation;
    std::vector<Compen> workingData[2]; // 存储两个机械臂的数据

    double calculateWithDirection(const std::vector<Compen>& data, unsigned short armId, Dir dir) {
        double sum = 0.0;
        int count = 0;
        for (const auto& compen : data) {
            if (compen.usArmId == armId && compen.dir == dir && count < n) {
                sum += (compen.dCompensation + compen.X + compen.Y + compen.T);
                count++;
            }
        }
        return count == 0 ? 0.0 : sum / count;
    }

    double calculateWithoutDirection(const std::vector<Compen>& data) {
        double sum = 0.0;
        int count = std::min(n, static_cast<int>(data.size()));
        for (int i = 0; i < count; ++i) {
            sum += (data[data.size() - count + i].dCompensation +
                    data[data.size() - count + i].X +
                    data[data.size() - count + i].Y +
                    data[data.size() - count + i].T);
        }
        return count == 0 ? 0.0 : sum / count;
    }
};

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

    // 假设有一些数据
    std::vector<Compen> arm0Data = {
        {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4},
        {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5},
        {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6}
    };

    // 为机械臂0添加数据
    for (const auto& data : arm0Data) {
        calculator.addData(0, data);
    }

    // 计算补偿值
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(calculator.workingData[armId], armId, currentDir);

    // 输出新补偿值
    std::cout << "New Compensation for Arm " << armId << ": " << newCompensation << std::endl;

    // 添加新的补偿数据
    Compen newEntry = {4, armId, currentDir, 0.4, 0.5, 0.6, newCompensation};
    calculator.addData(armId, newEntry);

    // 输出新的补偿值和数据
    std::cout << "New Entry: " << newEntry.lPadIndex << ", " << newEntry.usArmId << ", "
              << (newEntry.dir == LEFT ? "LEFT" : "RIGHT") << ", " << newEntry.X << ", "
              << newEntry.Y << ", " << newEntry.T << ", " << newEntry.dCompensation << std::endl;

    return 0;
}
#include <iostream>
#include <vector>
#include <deque>
#include <numeric>
#include <algorithm>
#include <cassert>

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) {
        // 为每个方向初始化一个 deque 存储补偿数据
        for (int i = 0; i < 4; ++i) {
            directionData[i] = std::deque<Compen>();
        }
    }

    double calculateCompensation(unsigned short armId, Dir dir) {
        if (useDirectionCompensation) {
            // 如果该方向的数据量小于n，则不按方向补偿
            if (directionData[dir].size() < n) {
                std::cout << "Not enough data for direction compensation, falling back to global compensation." << std::endl;
                return calculateWithoutDirection(armId); // 方向数据不足，转为全局补偿
            }
            return calculateWithDirection(armId, dir);
        } else {
            return calculateWithoutDirection(armId);
        }
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        // 按方向将数据添加到对应的 deque
        directionData[newEntry.dir].push_back(newEntry);
        // 如果该方向的数据超过窗口大小，删除最旧的元素
        if (directionData[newEntry.dir].size() > n) {
            directionData[newEntry.dir].pop_front();
        }
    }

private:
    int n; // 滑动平均窗口大小
    bool useDirectionCompensation;
    std::vector<Compen> workingData[2]; // 存储两个机械臂的数据
    std::deque<Compen> directionData[4]; // 每个方向对应一个 deque

    double calculateWithDirection(unsigned short armId, Dir dir) {
        double sum = 0.0;
        int count = directionData[dir].size();
        for (const auto& compen : directionData[dir]) {
            if (compen.usArmId == armId) {
                sum += (compen.dCompensation + compen.X + compen.Y + compen.T);
            }
        }
        return count == 0 ? 0.0 : sum / count;
    }

    double calculateWithoutDirection(unsigned short armId) {
        double sum = 0.0;
        const auto& data = workingData[armId];
        int count = std::min(n, static_cast<int>(data.size()));
        if (count < n) {
            return 0.0; // 如果数据不足，补偿值为0
        }
        for (int i = 0; i < count; ++i) {
            sum += (data[data.size() - count + i].dCompensation +
                    data[data.size() - count + i].X +
                    data[data.size() - count + i].Y +
                    data[data.size() - count + i].T);
        }
        return count == 0 ? 0.0 : sum / count;
    }
};

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

    // 假设有一些数据
    std::vector<Compen> arm0Data = {
        {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4},
        {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5},
        {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6}
    };

    // 为机械臂0添加数据
    for (const auto& data : arm0Data) {
        calculator.addData(0, data);
    }

    // 计算补偿值
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(armId, currentDir);

    // 输出新补偿值
    std::cout << "New Compensation for Arm " << armId << ": " << newCompensation << std::endl;

    // 添加新的补偿数据
    Compen newEntry = {4, armId, currentDir, 0.4, 0.5, 0.6, newCompensation};
    calculator.addData(armId, newEntry);

    // 输出新的补偿值和数据
    std::cout << "New Entry: " << newEntry.lPadIndex << ", " << newEntry.usArmId << ", "
              << (newEntry.dir == LEFT ? "LEFT" : "RIGHT") << ", " << newEntry.X << ", "
              << newEntry.Y << ", " << newEntry.T << ", " << newEntry.dCompensation << std::endl;

    return 0;
}
#include <iostream>
#include <vector>
#include <deque>
#include <numeric>
#include <algorithm>
#include <cassert>

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) {
        // 为每个方向初始化一个 deque 存储补偿数据
        for (int i = 0; i < 4; ++i) {
            directionData[i] = std::deque<Compen>();
        }
    }

    double calculateCompensation(unsigned short armId, Dir dir) {
        if (useDirectionCompensation) {
            // 如果该方向的数据量小于n，则不按方向补偿
            if (directionData[dir].size() < n) {
                std::cout << "Not enough data for direction compensation, falling back to global compensation." << std::endl;
                return calculateWithoutDirection(armId); // 方向数据不足，转为全局补偿
            }
            return calculateWithDirection(armId, dir);
        } else {
            return calculateWithoutDirection(armId);
        }
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        // 按方向将数据添加到对应的 deque
        directionData[newEntry.dir].push_back(newEntry);
        // 如果该方向的数据超过窗口大小，删除最旧的元素
        if (directionData[newEntry.dir].size() > n) {
            directionData[newEntry.dir].pop_front();
        }

        // 同时将数据添加到全局数据集中
        workingData[armId].push_back(newEntry);
        // 如果全局数据量超过 n 的限制，可以选择保留更多数据，或保持 n 条最新数据
    }

private:
    int n; // 滑动平均窗口大小
    bool useDirectionCompensation;
    std::vector<Compen> workingData[2]; // 存储两个机械臂的全局数据
    std::deque<Compen> directionData[4]; // 每个方向对应一个 deque

    double calculateWithDirection(unsigned short armId, Dir dir) {
        double sum = 0.0;
        int count = directionData[dir].size();
        for (const auto& compen : directionData[dir]) {
            if (compen.usArmId == armId) {
                sum += (compen.dCompensation + compen.X + compen.Y + compen.T);
            }
        }
        return count == 0 ? 0.0 : sum / count;
    }

    double calculateWithoutDirection(unsigned short armId) {
        double sum = 0.0;
        const auto& data = workingData[armId];
        int count = std::min(n, static_cast<int>(data.size()));
        if (count < n) {
            return 0.0; // 如果全局数据不足 n 条，返回 0
        }
        for (int i = 0; i < count; ++i) {
            sum += (data[data.size() - count + i].dCompensation +
                    data[data.size() - count + i].X +
                    data[data.size() - count + i].Y +
                    data[data.size() - count + i].T);
        }
        return count == 0 ? 0.0 : sum / count;
    }
};

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

    // 假设有一些数据
    std::vector<Compen> arm0Data = {
        {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4},
        {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5},
        {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6}
    };

    // 为机械臂0添加数据
    for (const auto& data : arm0Data) {
        calculator.addData(0, data);
    }

    // 计算补偿值
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(armId, currentDir);

    // 输出新补偿值
    std::cout << "New Compensation for Arm " << armId << ": " << newCompensation << std::endl;

    // 添加新的补偿数据
    Compen newEntry = {4, armId, currentDir, 0.4, 0.5, 0.6, newCompensation};
    calculator.addData(armId, newEntry);

    // 输出新的补偿值和数据
    std::cout << "New Entry: " << newEntry.lPadIndex << ", " << newEntry.usArmId << ", "
              << (newEntry.dir == LEFT ? "LEFT" : "RIGHT") << ", " << newEntry.X << ", "
              << newEntry.Y <<
#include <iostream>
#include <vector>
#include <deque>
#include <numeric>
#include <algorithm>
#include <cassert>

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) {
        // 为每个方向初始化一个 deque 存储补偿数据
        for (int i = 0; i < 4; ++i) {
            directionData[i] = std::deque<Compen>();
        }
    }

    double calculateCompensation(unsigned short armId, Dir dir) {
        if (useDirectionCompensation) {
            // 如果该方向的数据量小于n，则不按方向补偿
            if (directionData[dir].size() < n) {
                std::cout << "Not enough data for direction compensation, falling back to global compensation." << std::endl;
                return calculateWithoutDirection(armId); // 方向数据不足，转为全局补偿
            }
            return calculateWithDirection(armId, dir);
        } else {
            return calculateWithoutDirection(armId);
        }
    }

    void addData(unsigned short armId, const Compen& newEntry) {
        // 按方向将数据添加到对应的 deque
        directionData[newEntry.dir].push_back(newEntry);
        // 如果该方向的数据超过窗口大小，删除最旧的元素
        if (directionData[newEntry.dir].size() > n) {
            directionData[newEntry.dir].pop_front();
        }
    }

private:
    int n; // 滑动平均窗口大小
    bool useDirectionCompensation;
    std::vector<Compen> workingData[2]; // 存储两个机械臂的数据
    std::deque<Compen> directionData[4]; // 每个方向对应一个 deque

    double calculateWithDirection(unsigned short armId, Dir dir) {
        double sum = 0.0;
        int count = directionData[dir].size();
        for (const auto& compen : directionData[dir]) {
            if (compen.usArmId == armId) {
                sum += (compen.dCompensation + compen.X + compen.Y + compen.T);
            }
        }
        return count == 0 ? 0.0 : sum / count;
    }

    double calculateWithoutDirection(unsigned short armId) {
        double sum = 0.0;
        const auto& data = workingData[armId];
        int count = std::min(n, static_cast<int>(data.size()));
        if (count < n) {
            return 0.0; // 如果数据不足，补偿值为0
        }
        for (int i = 0; i < count; ++i) {
            sum += (data[data.size() - count + i].dCompensation +
                    data[data.size() - count + i].X +
                    data[data.size() - count + i].Y +
                    data[data.size() - count + i].T);
        }
        return count == 0 ? 0.0 : sum / count;
    }
};

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

    // 假设有一些数据
    std::vector<Compen> arm0Data = {
        {1, 0, LEFT, 0.1, 0.2, 0.3, 0.4},
        {2, 0, LEFT, 0.2, 0.3, 0.4, 0.5},
        {3, 0, LEFT, 0.3, 0.4, 0.5, 0.6}
    };

    // 为机械臂0添加数据
    for (const auto& data : arm0Data) {
        calculator.addData(0, data);
    }

    // 计算补偿值
    unsigned short armId = 0;
    Dir currentDir = LEFT;
    double newCompensation = calculator.calculateCompensation(armId, currentDir);

    // 输出新补偿值
    std::cout << "New Compensation for Arm " << armId << ": " << newCompensation << std::endl;

    // 添加新的补偿数据
    Compen newEntry = {4, armId, currentDir, 0.4, 0.5, 0.6, newCompensation};
    calculator.addData(armId, newEntry);

    // 输出新的补偿值和数据
    std::cout << "New Entry: " << newEntry.lPadIndex << ", " << newEntry.usArmId << ", "
              << (newEntry.dir == LEFT ? "LEFT" : "RIGHT") << ", " << newEntry.X << ", "
              << newEntry.Y << ", " << newEntry.T << ", " << newEntry.dCompensation << std::endl;

    return 0;
}
风水共舞
关注
【无标题】获取网页文本
bvip911的博客
10-09 8万+
‘李元豪 from https://www.zhilu.space’= ‘李元豪 from https://www.zhilu.space’= ‘李元豪 from https://www.zhilu.space’= ‘李元豪 from https://www.zhilu.space’
Qt-无标题窗口
学而思
05-21 8471
        今天学习了下无标题窗口，于是来记录下我的学习过程首先建立一个Qt Widgets Application继承QWidget类创建完后直接运行就得到了如下效果那么，既然是无标题窗口就要去掉窗口栏啊，于是加上setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);去掉标题栏，但是这样整个窗口就不能移动...
谷歌浏览器打开无标题
mp2020xuexi的博客
01-16 1785
谷歌浏览器
C#中实现无标题栏窗体拖动的代码
热门推荐
百锦再的博客
01-18 1万+
事件来实现拖动功能。当鼠标按下时，我们标记鼠标正在拖动，并保存当前坐标。在鼠标移动时，如果鼠标正在拖动，我们更新窗体的位置，使其跟随鼠标移动。当鼠标释放时，我们取消拖动标记。请注意，在窗体上添加了对应事件处理程序的窗体控件属性应该设置为对应的事件处理程序方法。在窗体设计视图，选择属性窗格，在事件选项卡中为。在C#中实现无标题栏窗体拖动的代码可以通过处理鼠标事件来实现。这样，当你在运行窗体时，你就可以通过鼠标拖动窗体来改变其位置。事件分别选择对应的处理程序方法。在这个示例代码中，我们通过处理。
C# 移动无标题栏无边框窗体的3种方法
SabreWulf
03-13 2413
目录 第一种：手工移动 第二种：调用系统API 1.引入下面代码 前提需要引入命名空间using System.Runtime.InteropServices 2.增加鼠标按下事件发送消息，让系统误以为按下是标题栏 第三种，重写 WndProc 第一种：手工移动 直接通过修改窗体位置从而达到移动窗体的效果 //定义一个位置信息Point用于存储鼠标位置 private Point mPoint; /// <summary>
【无标题】一不错的网站
shen_haidabiaoge的博客
05-18 2631
大家要谅解我呀，我这是没有办法
Qt实现改变无标题栏窗体大小及移动窗体
danshiming的博客
11-10 4473
Qt实现鼠标左键拖动无标题栏窗体右下角改变窗体大小及移动窗体
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
precy_wm的博客
01-03 2764
Chrome显示无标题错误代码STATUS_INVALID_IMAGE_HASH
WIN32无标题栏窗口移动方法种种
ZDT_zdh的博客
11-02 3032
WIN32无标题栏窗口移动方法种种 转载来源：http://blog.youkuaiyun.com/fuyun_cloud/article/details/8008197     首先，看看在正常情况下系统是怎样来移动程序窗口的。当使用者在程序窗口标题栏区域（非工作区）内，按下鼠标左键时将会发生下列事情：  ◆ 系统向该窗口过程函数发送WM_NCLBUTTONDOWN消息。  ◆ WM_NC...
c#实现无标题栏窗口的拖动
09-05
本篇文章将详细讲解如何在C#中实现这种无标题栏窗口的拖动以及其他基本操作。 首先，为了实现无标题栏窗口的拖动，我们需要处理窗体的鼠标事件。窗体的`FormBorderStyle`属性应设置为`None`，这会去除窗体的边框和...
Qt无标题窗口
05-21
在本文中，我们将深入探讨如何使用Qt框架创建一个无标题窗口，这在界面设计和自定义标题栏美化中非常有用。我们将关注`framelesswidget.cpp`、`main.cpp`、`framelesswidget.h`等核心文件，理解它们在实现无标题窗口...
C#创建无标题栏窗体
03-16
摘要:C#源码,菜单窗体,无标题栏窗体　C#创建无标题栏窗体源码，实际上是动态显示或隐藏窗体的标题栏，当隐藏的时候就类似窗体没有了标题栏，当显示标题栏的时候，鼠标按住标题栏即可拖动窗体，以前记得网友需要此...
Delphi实现拖动按钮移动无标题栏窗口
05-11
摘要:Delphi源码,界面编程,窗体拖动,无标题栏 无标题栏的窗体的拖动功能实现，Delphi添加一个可拖动窗体的按钮，通过对此按钮的控制可移动窗体，实现按住标题栏移动窗口的功能，无标题栏也就不能显示最大化、最小化...
VC去掉'无标题'字样的方法.zip
11-21
在使用Visual C++进行编程时，我们经常会在创建新的窗口或者对话框时默认看到标题栏显示为“无标题”。这可能会对用户界面的美观性和专业性造成一定的影响。本资料包提供了一种方法来帮助开发者去掉这个“无标题”...
C语言（十）
最新发布
2302_80202237的博客
07-24 306
函数是面向过程编程思想的具体体现，主要作用：降低程序之间的耦合性提高代码的复用性和可维护性一个完整的 C 程序由**一个或多个程序模块（源文件）**组成。为便于开发与调试，通常会将代码拆分为多个源文件，并组合成一个整体程序。每个源文件是一个编译单位，即 C 编译器以“源文件”为单位进行编译。程序从main()函数开始执行，调用其他函数后，执行完再返回到main()，最终在main()结束程序运行。用户根据需要自定义提高模块化和代码复用能力。
vscode gdb调试c语言过程
m0_63472758的博客
07-22 230
主要是配置一下两个文件。
C++视觉算法实战指南
keny-大成的博客
07-23 651
本文介绍了C++在计算机视觉领域的常用算法实现，涵盖OpenCV图像处理、PCL点云处理和OpenCV DNN模块三大方向。主要内容包括：1. OpenCV基础：图像滤波、边缘检测、特征匹配等传统算法实现；2. PCL点云处理：滤波、分割、配准、特征提取等点云操作方法；3. OpenCV DNN模块：YOLO、ResNet等深度学习模型的部署应用。文章提供了大量可直接运行的代码示例，适合开发者快速实现各类视觉任务，同时强调了算法选择和性能优化的注意事项。
【MediaTek】AN7563编译wlan_hwifi出现en_npu.c:42:10: fatal error:
wgl307293845的博客
07-24 15
问题日志。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值