边界超像素和邻接矩阵是图像分割和图像处理中常用的概念。下面给出一个解决方法的示例代码：

import numpy as np

def get_adjacency_matrix(image, labels):
    # 获取图像的高度和宽度
    height, width = image.shape[:2]
    
    # 创建一个空的邻接矩阵
    adjacency_matrix = np.zeros((labels.max()+1, labels.max()+1))
    
    # 遍历图像的每个像素
    for y in range(height):
        for x in range(width):
            label = labels[y, x]
            
            # 获取当前像素的邻居像素
            neighbors = get_neighbors(y, x, height, width)
            
            # 遍历邻居像素
            for neighbor in neighbors:
                neighbor_label = labels[neighbor[0], neighbor[1]]
                
                # 如果邻居像素的标签与当前像素的标签不同，说明是边界超像素
                if neighbor_label != label:
                    adjacency_matrix[label, neighbor_label] = 1
    
    return adjacency_matrix

def get_neighbors(y, x, height, width):
    neighbors = []
    
    # 定义8个邻居的相对位置
    offsets = [(-1, -1), (-1, 0), (-1, 1),
               (0, -1),           (0, 1),
               (1, -1),  (1, 0),  (1, 1)]
    
    # 遍历8个邻居的相对位置
    for offset in offsets:
        neighbor_y = y + offset[0]
        neighbor_x = x + offset[1]
        
        # 判断邻居是否在图像范围内
        if neighbor_y >= 0 and neighbor_y < height and neighbor_x >= 0 and neighbor_x < width:
            neighbors.append((neighbor_y, neighbor_x))
    
    return neighbors

# 示例用法
image = np.array([[1, 1, 1, 2, 2, 2],
                  [1, 1, 1, 2, 2, 2],
                  [1, 1, 1, 3, 3, 3],
                  [4, 4, 4, 3, 3, 3],
                  [4, 4, 4, 3, 3, 3]])
labels = np.array([[1, 1, 1, 2, 2, 2],
                   [1, 1, 1, 2, 2, 2],
                   [1, 1, 1, 3, 3, 3],
                   [4, 4, 4, 3, 3, 3],
                   [4, 4, 4, 3, 3, 3]])

adjacency_matrix = get_adjacency_matrix(image, labels)
print(adjacency_matrix)

此代码示例定义了两个函数：get_adjacency_matrix和get_neighbors。get_neighbors函数用于获取一个像素的8个邻居像素的坐标。get_adjacency_matrix函数根据输入的图像和标签，遍历图像的每个像素，判断其邻居像素是否与其标签不同，如果不同则说明是边界超像素，将邻接矩阵中对应位置的值设为1。最后打印出邻接矩阵的结果。

注意，此代码示例仅仅是一个简单的示例，实际应用中可能需要根据具体需求进行修改。