使用多线程加速处理这一段vector<Edge1D_Result>edges;for (int i = 0; i < m; i++) { edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i] , m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest); for (int i = 0; i < edges.size(); i++) { m_vpdEdgePoints.push_back(edges[i].m_pdEdgePoint); m_vdEdgeGradient.push_back(edges[i].m_dGradient); } }保护变量edges

可以使用std::mutex来保护变量edges。具体实现如下：

1. 在头文件中添加#include<mutex>

2. 在成员变量中添加std::mutex m_mutex;

3. 在对edges进行操作的代码块前后加上锁和解锁操作：

m_mutex.lock();
for (int i = 0; i < m; i++) {
    edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i] , m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest); 
    for (int i = 0; i < edges.size(); i++) {
        m_vpdEdgePoints.push_back(edges[i].m_pdEdgePoint);
        m_vdEdgeGradient.push_back(edges[i].m_dGradient);
    } 
}
m_mutex.unlock();

这样保证了在一个线程对edges进行操作时，其他线程无法同时访问edges。

相关问题

使用多线程加速处理这一段for循环vector<Edge1D_Result>edges;for (int i = 0; i < m; i++) { edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i] , m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest); for (int i = 0; i < edges.size(); i++) { m_vpdEdgePoints.push_back(edges[i].m_pdEdgePoint); m_vdEdgeGradient.push_back(edges[i].m_dGradient); } }保护变量edges

可以使用互斥锁mutex来保护变量edges。具体操作如下：

1. 在头文件中包含<mutex>。

2. 在for循环外定义一个mutex对象，例如：std::mutex mtx_edges。

3. 在for循环内对edges进行操作时，加锁mtx_edges，操作完成后解锁。

代码示例：

#include <mutex>

std::vector<Edge1D_Result> edges;
std::mutex mtx_edges;

for (int i = 0; i < m; i++) {
    edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i], m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest);
    // 加锁
    mtx_edges.lock();
    for (int j = 0; j < edges.size(); j++) {
        m_vpdEdgePoints.push_back(edges[j].m_pdEdgePoint);
        m_vdEdgeGradient.push_back(edges[j].m_dGradient);
    }
    // 解锁
    mtx_edges.unlock();
}

创建多线程加速处理这一段for循环vector<Edge1D_Result>edges;for (int i = 0; i < m; i++) { edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i] , m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest); for (int i = 0; i < edges.size(); i++) { m_vpdEdgePoints.push_back(edges[i].m_pdEdgePoint); m_vdEdgeGradient.push_back(edges[i].m_dGradient); } }保护变量edges

可以使用std::mutex来保护变量edges，确保多个线程不会同时访问它。以下是示例代码：

vector<Edge1D_Result> edges;
std::mutex edges_mutex;

void processEdges() {
    // 处理edges之前先获取锁
    edges_mutex.lock();
    for (int i = 0; i < m; i++) {
        vector<Edge1D_Result> temp_edges = Extract1DEdgeCircle.Get1DEdge(RoiMat, m_vpdEquinoxPoints[i], m_dMeasureLength, m_dMeasureHeight, m_vdMeasureAngle[i], m_dSigma, m_nThresholdCircle, m_nTranslationCircle == 1 ? Translation::Poisitive : Translation::Negative, Selection::Strongest);
        // 释放锁，让其他线程可以访问edges
        edges_mutex.unlock();
        // 处理临时的edges
        for (int i = 0; i < temp_edges.size(); i++) {
            m_vpdEdgePoints.push_back(temp_edges[i].m_pdEdgePoint);
            m_vdEdgeGradient.push_back(temp_edges[i].m_dGradient);
        }
        // 获取锁，再次访问edges
        edges_mutex.lock();
        // 将临时的edges合并到主线程的edges中
        edges.insert(edges.end(), temp_edges.begin(), temp_edges.end());
    }
    // 释放锁
    edges_mutex.unlock();
}

// 创建多线程
std::vector<std::thread> threads;
for (int i = 0; i < num_threads; i++) {
    threads.push_back(std::thread(processEdges));
}

// 等待所有线程结束
for (auto& thread : threads) {
    thread.join();
}

在这个示例中，我们使用了std::mutex来保护变量edges。在每个线程中，我们首先获取锁，并提取出一批1D边缘。然后，我们释放锁，让其他线程可以访问edges，同时在当前线程中处理临时的edges。最后，我们再次获取锁，将临时的edges合并到主线程的edges中。这样，我们就可以使用多线程加速处理for循环中的任务，并且确保变量edges的安全访问。