Python 修改用于搜索图像中最大色点的代码，该代码适用于较小的图像，但不适用于较大的图像

这段代码在图像中找到最大的色斑，并返回一个新图像，其中唯一找到的色斑和互补色作为背景。我的代码使用递归函数，只适用于小图像。我使用一个函数返回一个列表，其中包含给定颜色像素的所有坐标。另一个函数修改矩阵并指定布尔标签（最初为False）。第三个函数返回元组列表。在每个元组中，将有另一个找到的点的坐标列表和列表的长度。（es:list=[（400，[…]），（100，[…]）。此函数调用递归函数，用于研究相邻像素，将布尔值从False更改为True，以避免对同一像素进行两次分析

import immagini

def es1(fname, color, fnameout):
    matrix= immagini.load(fname)
    list=coordinate(matrix,color)
    true_false(matrix)
    dict=dictionary(matrix,list,color)
    biggest_spot=max(dict)[1]
    out=newIm(matrix,biggest_spot,color)
    immagini.save(out,fnameout)
    return len(biggest_spot)


def coordinate(matrix,color):
    list=[]
    for y in list(range(len(matrix))):
        for x in list(range(len(matrix[0]))):
            if matrix[y][x]==color:
                list.append((y,x))
    return list

def true_false(matrix):
    for row in list(range(len(matrix))):
         for col in list(range(len(matrix[0]))):
             matrix[row][col]=[matrix[row][col], False]     

def dicionary(matrix,list,color):
    dictionary_spots=[]
    for coord in list:
        if matrix[coord[0]][coord[1]][0]==color and matrix[coord[0]][coord[1]][1]== False:
            spot=[]
            ric(matrix,coord[0],coord[1],color,spot)
            dictionary_spots.append((len(spot), spot))
    return dictionary_spots


def ric(matrix, row, col, color, spot):
    if matrix[row][col][0]==color and matrix[row][col][1] == False:
        matrix[row][col][1]=True
        spot.append((row,col))
        if row-1>0:
            ric(matrix, row-1, col, color, spot)
        if row+1<len(matrix):
            ric(matrix, row+1, col, color, spot)
        if col+1<len(matrix):
            ric(matrix, row, col+1, color, spot)
        if col-1>0:
            ric(matrix, row, col-1, color, spot)



def newIm(matrix,spot,color): 
    out=[]
    for row in list(range(len(matrix))):
        row=[]
        out.append(out)
    for col in list(range(len(matrix[0]))):
        for elem in out:
            elem.append((255-color[0],255-color[1],255-color[2]))
    for elem in spot:
        out[elem[0]][elem[1]]=colore
    return out

import immagini
def es1（fname、颜色、fnameout）：
矩阵=内隐负荷（fname）
列表=坐标（矩阵、颜色）
真/假（矩阵）
dict=字典（矩阵、列表、颜色）
最大点=最大值（dict）[1]
out=newIm（矩阵、最大斑点、颜色）
伊玛吉尼。拯救（出去，fnameout）
回程镜头（最大镜头）
def坐标（矩阵、颜色）：
列表=[]
对于列表中的y（范围（len（矩阵））：
对于列表中的x（范围（len（矩阵[0]））：
如果矩阵[y][x]==颜色：
列表。追加（（y，x））
返回列表
def true_false（矩阵）：
对于列表中的行（范围（len（矩阵））：
对于列表中的列（范围（len（矩阵[0]））：
矩阵[行][col]=[矩阵[行][col]，False]
定义字典（矩阵、列表、颜色）：
字典\u spots=[]
对于列表中的coord：
如果矩阵[coord[0]][coord[1]][0]==颜色，矩阵[coord[0]][coord[1]]][1]==假：
spot=[]
ric（矩阵，坐标[0]，坐标[1]，颜色，斑点）
字典\u spot.append（（len（spot），spot））
返回字典中的位置
定义ric（矩阵、行、列、颜色、点）：
如果矩阵[row][col][0]==颜色且矩阵[row][col][1]==假：
矩阵[行][col][1]=真
spot.append（（行，列））
如果第1行>0：
ric（矩阵，第1行，颜色，斑点）
如果行+1解决方案：不要使用递归

另一种描述问题的方式是：我试图找到最大的“连接组件”

连接的组件标记是一个已解决的问题，可以通过在图像上进行两次遍历来完成，每次遍历从左到右遍历行，然后从上到下遍历一组行

以下是算法的简要说明（wiki已链接）：

在第一步中，根据当前像素北面和西面的像素将标签简单地分配给每个像素（如果值不匹配，则创建新标签）。如果北像素和西像素在值上匹配，但在标签上不匹配，也可以标记等效

在第二个过程中，使用在第一个过程中找到的等效项将具有等效项的像素标签更改为等效项中的最小标签（这可能是递归的）。这将减少图像中标签的总数





一旦有了标记的图像，就可以通过一次扫描来计算每个连接组件中的像素数，然后通过第二次扫描来更改不是最大的组件中的像素。
到家后，我会仔细看看，但我的第一反应是尝试重构尾部递归。解决这个问题不需要递归。可以使用“连接的组件标签”在图像上进行两次传递以标记不同的组件，然后第三次传递以计算每个组件的大小，第四次传递以更改颜色。请看这里：