如何基于OpenCV的SuperpixelSLIC高效计算超像素标签的8连通邻域？

刚好之前做过超像素邻域分析的需求，给你分享一个用OpenCV高效实现8连通超像素邻域计算的方法，比逐像素遍历快太多了！

核心思路 #

不用逐个像素检查8邻域（这种方法在大图像上慢到离谱），我们可以利用形态学膨胀结合集合运算来快速定位相邻超像素：

1. 对每个超像素标签的掩码做8连通膨胀（用3x3全1结构元素），膨胀后的区域会包含原超像素和所有8连通相邻的超像素。
2. 用膨胀后的掩码减去原掩码，得到的就是仅包含相邻超像素的区域。
3. 提取这个区域内的所有标签，去重后就是当前超像素的邻域集合。

Python实现示例 #

import cv2
import numpy as np

# 示例：你提供的超像素标签图（实际中替换为SuperpixelSLIC输出的labels）
labels = np.array([
    [1,1,1,2,2,3,3,3,3],
    [1,1,2,2,2,2,3,3,4],
    [1,2,2,2,3,3,3,4,4],
    [5,5,5,2,4,4,4,4,4]
], dtype=np.int32)

# 获取所有唯一的超像素标签
unique_labels = np.unique(labels)

# 存储每个标签的邻域集合
label_neighbors = {}

# 8连通膨胀的结构元素（3x3全1矩阵）
kernel = np.ones((3, 3), np.uint8)

for label in unique_labels:
    # 1. 创建当前标签的二值掩码
    mask = (labels == label).astype(np.uint8)
    # 2. 对掩码做8连通膨胀
    dilated_mask = cv2.dilate(mask, kernel, iterations=1)
    # 3. 计算相邻区域的掩码：膨胀区域 - 原标签区域
    neighbor_mask = dilated_mask - mask
    # 4. 提取相邻区域的标签并去重，排除自身（理论上不会出现，但保险）
    neighbors = np.unique(labels[neighbor_mask > 0])
    neighbors = neighbors[neighbors != label]
    # 5. 存储结果为集合
    label_neighbors[label] = set(neighbors)

# 打印验证结果
for lbl, neigh in label_neighbors.items():
    print(f"标签{lbl}的邻域为{neigh}")

运行这段代码后，输出完全符合你给出的示例结果：

标签1的邻域为{2, 5}
标签2的邻域为{1, 3, 4, 5}
标签3的邻域为{2, 4}
标签4的邻域为{2, 3}
标签5的邻域为{1, 2}

C++实现思路 #

如果是用C++开发，核心逻辑完全一致，只是API调用略有不同：

1. 用cv::compare创建标签掩码，cv::dilate执行膨胀操作。
2. 遍历相邻掩码区域的像素，用std::set存储去重后的邻域标签。

#include <opencv2/opencv.hpp>
#include <unordered_map>
#include <set>
#include <algorithm>

using namespace cv;
using namespace std;

int main() {
    // 示例标签图
    Mat labels = (Mat_<int>(4,9) << 
        1,1,1,2,2,3,3,3,3,
        1,1,2,2,2,2,3,3,4,
        1,2,2,2,3,3,3,4,4,
        5,5,5,2,4,4,4,4,4);

    // 获取唯一标签
    vector<int> unique_labels;
    sort(labels.begin<int>(), labels.end<int>());
    unique_copy(labels.begin<int>(), labels.end<int>(), back_inserter(unique_labels));

    unordered_map<int, set<int>> label_neighbors;
    Mat kernel = getStructuringElement(MORPH_RECT, Size(3,3));

    for (int label : unique_labels) {
        Mat mask;
        compare(labels, label, mask, CMP_EQ);
        mask.convertTo(mask, CV_8U);
        Mat dilated_mask;
        dilate(mask, dilated_mask, kernel);
        Mat neighbor_mask = dilated_mask - mask;

        set<int> neighbors;
        // 遍历相邻区域提取标签
        for (int y = 0; y < labels.rows; ++y) {
            const int* labels_row = labels.ptr<int>(y);
            const uchar* mask_row = neighbor_mask.ptr<uchar>(y);
            for (int x = 0; x < labels.cols; ++x) {
                if (mask_row[x]) {
                    int neighbor_label = labels_row[x];
                    if (neighbor_label != label) {
                        neighbors.insert(neighbor_label);
                    }
                }
            }
        }
        label_neighbors[label] = neighbors;
    }

    // 输出结果
    for (const auto& pair : label_neighbors) {
        cout << "标签" << pair.first << "的邻域为{";
        bool first = true;
        for (int n : pair.second) {
            if (!first) cout << ", ";
            cout << n;
            first = false;
        }
        cout << "}" << endl;
    }

    return 0;
}

效率优化点 #

• 用OpenCV内置的形态学操作：底层是优化的C实现，比纯Python/C遍历像素快几个数量级，尤其适合大尺寸图像。
• 提前获取唯一标签：避免重复处理相同标签，减少不必要的计算。
• 选择合适的标签数据类型：用np.int32（Python）或int（C++）存储标签，避免浮点型带来的性能损耗和精度问题。

内容的提问来源于stack exchange，提问作者Pavel Angel Mendoza Villafane