如何使用Python的images库确定图像中线条的颜色层级

针对你的需求，我们可以通过分析线条交叉点的颜色来判断层级——因为上层的线条会覆盖下层的，交叉点的像素颜色就是处于更上层的线条颜色。结合你提到的图像是RGB元组矩阵的形式，我整理了一套具体的实现步骤和代码示例：

核心思路 #

线条都是直线且颜色唯一，背景色已知。两个线条交叉时，交叉点的像素颜色属于上层线条，下层线条的像素会被覆盖。我们可以通过收集所有交叉点的颜色关系，再用拓扑排序得到最终的层级顺序。

具体实现步骤 #

1. 提取所有线条颜色 #

首先遍历整个图像矩阵，收集所有不等于背景色的RGB元组，这些就是所有线条的颜色（因为线条颜色各不相同）。

def get_line_colors(image_matrix, bg_color):
    line_colors = set()
    for row in image_matrix:
        for pixel in row:
            if pixel != bg_color:
                line_colors.add(pixel)
    return list(line_colors)

2. 收集颜色的覆盖关系 #

遍历图像中的每个像素，检查当前像素的上下左右相邻区域：如果当前像素是线条颜色X，相邻像素是另一种线条颜色Y，说明X在交叉位置覆盖了Y，我们就记录一条「Y被X覆盖」的关系。

def get_cover_relations(image_matrix, bg_color, line_colors):
    # 构建颜色到索引的映射，方便后续拓扑排序
    color_to_idx = {color: idx for idx, color in enumerate(line_colors)}
    n = len(line_colors)
    # 邻接表和入度数组，用于拓扑排序
    adj = [[] for _ in range(n)]
    in_degree = [0] * n
    # 遍历每个像素
    rows = len(image_matrix)
    cols = len(image_matrix[0]) if rows > 0 else 0
    directions = [(-1,0), (1,0), (0,-1), (0,1)]  # 上下左右四个方向
    
    for i in range(rows):
        for j in range(cols):
            current_color = image_matrix[i][j]
            if current_color == bg_color:
                continue
            # 检查相邻像素
            for dx, dy in directions:
                ni, nj = i + dx, j + dy
                if 0 <= ni < rows and 0 <= nj < cols:
                    neighbor_color = image_matrix[ni][nj]
                    if neighbor_color != bg_color and neighbor_color != current_color:
                        # 说明current_color覆盖了neighbor_color，添加关系 neighbor_color -> current_color
                        u = color_to_idx[neighbor_color]
                        v = color_to_idx[current_color]
                        # 避免重复添加关系
                        if v not in adj[u]:
                            adj[u].append(v)
                            in_degree[v] += 1
    return adj, in_degree, color_to_idx

3. 拓扑排序得到层级顺序 #

通过拓扑排序，我们可以把覆盖关系转化为从上层到下层的顺序。最终结果会把最上层的颜色放在最前面，最后加上背景色。

from collections import deque

def topological_sort(adj, in_degree, color_to_idx):
    # 反转颜色映射：索引到颜色
    idx_to_color = {idx: color for color, idx in color_to_idx.items()}
    q = deque()
    # 初始化队列，入度为0的节点（最上层的颜色）
    for i in range(len(in_degree)):
        if in_degree[i] == 0:
            q.append(i)
    result = []
    while q:
        u = q.popleft()
        result.append(idx_to_color[u])
        for v in adj[u]:
            in_degree[v] -= 1
            if in_degree[v] == 0:
                q.append(v)
    # 最后加上背景色
    return result + [bg_color]

4. 整合所有步骤 #

把上面的函数整合起来，就可以得到最终的颜色层级：

# 示例用法
# 假设image_matrix是你的图像矩阵，bg_color是背景色(示例中的灰色RGB为(192,192,192))
bg_color = (192, 192, 192)
# 替换成你的实际图像矩阵
image_matrix = [
    [(192,192,192), (255,255,255), (255,255,255)],
    [(255,0,0), (255,255,255), (0,255,0)],
    [(255,0,0), (255,0,0), (0,255,0)]
]

line_colors = get_line_colors(image_matrix, bg_color)
adj, in_degree, color_to_idx = get_cover_relations(image_matrix, bg_color, line_colors)
color_hierarchy = topological_sort(adj, in_degree, color_to_idx)

print("颜色层级（从上层到下层）：", color_hierarchy)
# 示例输出：[(255,255,255), (255,0,0), (0,255,0), (192,192,192)]

注意事项 #

• 这个方法依赖于线条交叉点的像素能被检测到，如果线条是1像素宽，相邻检测完全有效；如果线条更粗，可以调整检测范围（比如检查更大的邻域）。
• 确保背景色的RGB值完全准确，否则会把背景误判为线条颜色。
• 如果线条平行无交叉，它们的层级无法通过交叉点判断，这种情况可以根据业务需求补充额外规则（比如按纵向/横向位置排序）。

内容的提问来源于stack exchange，提问作者QueensGambyte