🔍 灰度图像连通域分析 (C++实现)

#include <iostream>
#include <vector>
#include <stack>
#include <cmath>

struct Point {
    int row, col;
    Point(int r, int c) : row(r), col(c) {}
};

class ConnectedComponentAnalysis {
private:
    std::vector<std::vector<int>> grayImage;
    std::vector<std::vector<bool>> visited;
    std::vector<std::vector<int>> result;
    int height, width;
    int componentCount;
    int threshold;
    
    // 4邻域方向：上、右、下、左
    int directions[4][2] = {{-1, 0}, {0, 1}, {1, 0}, {0, -1}};
    
    // 检查坐标是否有效
    bool isValid(int row, int col) {
        return row >= 0 && row < height && col >= 0 && col < width;
    }
    
    // 非递归DFS实现
    void dfsNonRecursive(int startRow, int startCol) {
        std::stack<Point> stack;
        stack.push(Point(startRow, startCol));
        
        int currentComponent = ++componentCount;
        
        while (!stack.empty()) {
            Point current = stack.top();
            stack.pop();
            
            int row = current.row;
            int col = current.col;
            
            // 如果已经访问过，跳过
            if (visited[row][col]) continue;
            
            // 标记为已访问并设置连通域ID
            visited[row][col] = true;
            result[row][col] = currentComponent;
            
            // 检查4邻域
            for (int i = 0; i < 4; i++) {
                int newRow = row + directions[i][0];
                int newCol = col + directions[i][1];
                
                // 边界检查和访问状态检查
                if (isValid(newRow, newCol) && !visited[newRow][newCol]) {
                    // 灰度值差异检查
                    int grayDiff = abs(grayImage[row][col] - grayImage[newRow][newCol]);
                    
                    if (grayDiff < threshold) {
                        stack.push(Point(newRow, newCol));
                    }
                }
            }
        }
    }
    
public:
    ConnectedComponentAnalysis(const std::vector<std::vector<int>>& image, int thresh = 20) 
        : grayImage(image), threshold(thresh) {
        height = image.size();
        width = image[0].size();
        componentCount = 0;
        
        // 初始化访问标记数组和结果数组
        visited.assign(height, std::vector<bool>(width, false));
        result.assign(height, std::vector<int>(width, 0));
    }
    
    // 执行连通域分析
    void analyze() {
        componentCount = 0;
        
        // 遍历所有像素
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                // 对未访问的像素执行连通域检测
                if (!visited[i][j]) {
                    dfsNonRecursive(i, j);
                }
            }
        }
    }
    
    // 获取结果
    const std::vector<std::vector<int>>& getResult() const {
        return result;
    }
    
    // 获取连通域数量
    int getComponentCount() const {
        return componentCount;
    }
    
    // 打印结果
    void printResult() {
        std::cout << "连通域分析结果:" << std::endl;
        std::cout << "图像尺寸: " << height << "x" << width << std::endl;
        std::cout << "连通域数量: " << componentCount << std::endl;
        std::cout << "阈值: " << threshold << std::endl;
        
        std::cout << "\n连通域标记矩阵:" << std::endl;
        for (int i = 0; i < height; i++) {
            for (int j = 0; j < width; j++) {
                std::cout << result[i][j] << " ";
            }
            std::cout << std::endl;
        }
    }
};

// 使用示例
int main() {
    // 创建测试图像 (8x8)
    std::vector<std::vector<int>> testImage = {
        {50, 52, 48, 120, 125, 200, 198, 202},
        {49, 51, 47, 118, 122, 201, 199, 203},
        {53, 50, 49, 119, 121, 197, 200, 201},
        {120, 118, 122, 125, 123, 120, 118, 122},
        {125, 123, 121, 124, 126, 119, 121, 120},
        {200, 198, 202, 120, 118, 50, 52, 48},
        {199, 201, 200, 122, 121, 49, 51, 47},
        {203, 197, 199, 124, 123, 53, 50, 49}
    };
    
    // 创建连通域分析对象
    ConnectedComponentAnalysis cca(testImage, 20);
    
    // 执行分析
    cca.analyze();
    
    // 输出结果
    cca.printResult();
    
    return 0;
}