用c++写一个区域生长函数

好的，以下是一个简单的C++实现区域生长算法的函数：

#include <iostream>
#include <vector>
#include <queue>
#include <cmath>

using namespace std;

// 定义一个像素的数据结构
struct Pixel {
    int x, y;
    int gray;
    bool visited;
};

// 定义一个区域的数据结构
struct Region {
    int gray_sum;
    int pixel_count;
    vector<Pixel> pixels;
};

// 定义一个比较像素灰度值的仿函数
struct ComparePixel {
    bool operator()(Pixel& p1, Pixel& p2) {
        return p1.gray > p2.gray;
    }
};

// 区域生长算法的函数
vector<Region> region_growing(vector<vector<int>>& image, int threshold) {
    int rows = image.size();
    int cols = image[0].size();
    vector<Region> regions;

    // 遍历整个图像
    for (int i = 0; i < rows; i++) {
        for (int j = 0; j < cols; j++) {
            // 如果当前像素没有被访问过
            if (!image[i][j].visited) {
                // 创建一个新的区域
                Region region;
                region.gray_sum = 0;
                region.pixel_count = 0;

                // 使用优先队列来存储像素
                priority_queue<Pixel, vector<Pixel>, ComparePixel> pq;

                // 将当前像素加入队列
                Pixel seed;
                seed.x = i;
                seed.y = j;
                seed.gray = image[i][j];
                seed.visited = true;
                pq.push(seed);

                // 循环处理队列中的像素
                while (!pq.empty()) {
                    Pixel pixel = pq.top();
                    pq.pop();

                    // 将当前像素加入区域
                    region.gray_sum += pixel.gray;
                    region.pixel_count++;
                    region.pixels.push_back(pixel);

                    // 遍历当前像素的8个相邻像素
                    for (int m = -1; m <= 1; m++) {
                        for (int n = -1; n <= 1; n++) {
                            int x = pixel.x + m;
                            int y = pixel.y + n;

                            // 如果相邻像素在图像范围内且没有被访问过
                            if (x >= 0 && x < rows && y >= 0 && y < cols && !image[x][y].visited) {
                                // 计算相邻像素和当前像素的灰度值差
                                int diff = abs(image[x][y] - pixel.gray);

                                // 如果灰度值差小于阈值，将相邻像素加入队列
                                if (diff < threshold) {
                                    Pixel neighbor;
                                    neighbor.x = x;
                                    neighbor.y = y;
                                    neighbor.gray = image[x][y];
                                    neighbor.visited = true;
                                    pq.push(neighbor);
                                }
                            }
                        }
                    }

                    // 标记当前像素已经被访问过
                    image[pixel.x][pixel.y].visited = true;
                }

                // 将当前区域加入区域集合
                regions.push_back(region);
            }
        }
    }

    return regions;
}

// 测试函数
int main() {
    // 定义一个图像
    vector<vector<int>> image = {
        { 10, 20, 30, 40, 50 },
        { 20, 30, 40, 50, 60 },
        { 30, 40, 50, 60, 70 },
        { 40, 50, 60, 70, 80 },
        { 50, 60, 70, 80, 90 }
    };

    // 执行区域生长算法
    vector<Region> regions = region_growing(image, 10);

    // 输出区域集合
    for (int i = 0; i < regions.size(); i++) {
        cout << "Region " << i << ":\n";
        cout << "  Gray sum: " << regions[i].gray_sum << "\n";
        cout << "  Pixel count: " << regions[i].pixel_count << "\n";
        cout << "  Pixels:\n";
        for (int j = 0; j < regions[i].pixels.size(); j++) {
            cout << "    (" << regions[i].pixels[j].x << ", " << regions[i].pixels[j].y << ")\n";
        }
    }

    return 0;
}

这个函数接受一个二维整数数组作为输入，代表一个灰度图像，还接受一个阈值作为参数。它返回一个区域的集合，每个区域包含一个像素的集合，以及该区域中所有像素的灰度值总和和像素数量。