Не работает функция map при обработке изображений в цикле и не выводит результаты в csv файл

Сначала программа поворачивает изображение обрезает и сохраняет в цикле набор изображений в цикле в папку output_folder. Потом идёт циклическая обработка изображений этой папки-создаётся набор матриц с 0 и 1 где на пикселе r,g,b<115,115,115 там 1, а в противном случаи 0. Находим сумму матрицы(площадь семечки) Далее нахождение сумм столбцов матриц и находить максимальные по сумме их столбцы в цикле. Также их индексы аналогичные действия необходимо проводить и с строками матриц. В строках с максимальными суммами находить минимальные и максимальные значения индексов столбцов со значениями матрицы 1 и аналогичные действия проводятся со столбцами. По координатам окраин строк и столбцов с максимальными суммами находим точки их пересечения(центры семечек). Потом нужно высчитать части длин и части ширин до и точек их пересечениях. Далее необходимо найти характеристики формы указанные внизу программы. Такие как углы ромба внутри семечки, площади участков за его пределами и соотношения длинны и ширины. Код прилагается:

import csv
import numpy as np
from PIL import Image  # Подключим необходимые библиотеки.
import cv2
import math
import time
import os
from multiprocessing.pool import Pool


def main():
    input_folder = "four"
    output_folder = "RotateCropImages"

    # Создаем выходную папку, если ее еще нет
    if not os.path.exists(output_folder):
        os.makedirs(output_folder)

    # Получаем список файлов в папке с изображениями
    image_files = [f for f in os.listdir(input_folder) if f.endswith(('.png', '.jpg', '.jpeg'))]

    # Указываем угол поворота и обрезку
    rotation_angle = 315
    crop_box = (250, 188, 1248, 883)  # (left, top, right, bottom)

    for image_file in image_files:
        input_path = os.path.join(input_folder, image_file)
        output_path = os.path.join(output_folder, image_file)

        # Открываем изображение
        with Image.open(input_path) as img:
            # Поворачиваем изображение
            rotated_img = img.rotate(rotation_angle)

            # Обрезаем изображение
            cropped_img = rotated_img.crop(crop_box)

            # Сохраняем результат
            cropped_img.save(output_path)

    tp1 = time.time()

    images = []
    for filename in os.listdir(output_folder):
        file_path = os.path.abspath(os.path.join(output_folder, filename))
        if os.path.isfile(file_path):
            images.append(file_path)

    p = Pool(processes=4)

    results = p.map(process_image, images)

    p.close()
    p.join()

    tp2 = time.time()

    print(f'*** Общее время: {tp2 - tp1} ***')

    headers = ['Name', 'lineA', 'lineB', 'lineC', 'lineD', 'firstAngle', 'secondAngle', 'thirdAngle', 'fourthAngle',
               'square', 'S_Dug1', 'S_Dug2', 'S_Dug3', 'S_Dug4', 'zolH', 'zolW', 'heightSeed', 'widthSeed']
    with open('526.csv', 'w', newline='') as f:
        write = csv.writer(f, delimiter=';')
        write.writerow(headers)
        write.writerows(results)

def process_image(output_path):
    img = Image.open(output_path)  # Открываем изображение
    r, g, b = cv2.split(img)
    bit_matrix_r = (r < 115)
    bit_matrix_g = (g < 115)
    bit_matrix_b = (b < 115)
    bit_matrix = np.multiply(np.multiply(bit_matrix_r, bit_matrix_g), bit_matrix_b)
    numb_matrix = bit_matrix.astype(int)
    max_row_coordinates, max_col_coordinates = find_suit_coordinates(numb_matrix)# Функцией find_suit_coordinates() находим столбцы и строки матриц с максимальными суммами
    min_r = min(max_row_coordinates)
    max_r = max(max_row_coordinates)
    max_c = max(max_col_coordinates)
    min_c = min(max_col_coordinates)

    x_min_r_coordinate = [coordinates[0] for coordinates in
                          min_r]  # Генератор списка для извлечения значений координаты x

    print("Массив индексов строк с максимальной по x:", x_min_r_coordinate)

    y_min_r_coordinate = [coordinates[1] for coordinates in
                          min_r]  # Генератор списка для извлечения значений координаты y

    print("Массив индексов строк с максимальной по y:", y_min_r_coordinate)
    x_max_r_coordinate = [coordinates[0] for coordinates in
                          max_r]  # Генератор списка для извлечения значений координаты x

    print("Массив индексов столбцов с максимальной по x:", x_max_r_coordinate)

    y_max_r_coordinate = [coordinates[1] for coordinates in
                          max_r]  # Генератор списка для извлечения значений координаты y

    print("Массив индексов столбцов с максимальной по y:", y_max_r_coordinate)
    x_min_c_coordinate = [coordinates[0] for coordinates in
                          min_c]  # Генератор списка для извлечения значений координаты x

    print("Массив индексов строк с максимальной по x:", x_min_c_coordinate)

    y_min_c_coordinate = [coordinates[1] for coordinates in
                          min_c]  # Генератор списка для извлечения значений координаты y

    print("Массив индексов строк с максимальной по y:", y_min_c_coordinate)
    x_max_c_coordinate = [coordinates[0] for coordinates in
                          max_c]  # Генератор списка для извлечения значений координаты x

    print("Массив индексов столбцов с максимальной по x:", x_max_c_coordinate)

    y_max_c_coordinate = [coordinates[1] for coordinates in
                          max_c]  # Генератор списка для извлечения значений координаты y

    print("Массив индексов столбцов с максимальной по y:", y_max_c_coordinate)  # div = xd[0] * yd[1] - xd[1] * yd[0]
    l_1_list = [[(x_min_r_coordinate[i], y_min_r_coordinate[i]), (x_max_r_coordinate[i], y_max_r_coordinate[i])] for i
                in range(len(min_r))]
    l_2_list = [[(x_min_c_coordinate[i], y_min_c_coordinate[i]), (x_max_c_coordinate[i], y_max_c_coordinate[i])] for i
                in range(len(min_c))]
    square = 0
    for i in range(len(numb_matrix)):
        for j in range(len(numb_matrix[i])):
            square += numb_matrix[i][j]
    for L_1, L_2 in zip(l_1_list, l_2_list):
        xd = (L_1[0][0] - L_1[1][0], L_2[0][0] - L_2[1][0])
        yd = (L_1[0][1] - L_1[1][1], L_2[0][1] - L_2[1][1])

        div = xd[0] * yd[1] - xd[1] * yd[0]
        if div == 0:
            raise Exception('lines do not intersect')
        d = (L_1[0][0] * L_1[1][1] - L_1[0][1] * L_1[1][0], L_2[0][0] * L_2[1][1] - L_2[0][1] * L_2[1][0])
        x = (d[0] * xd[1] - d[1] * xd[0]) / div  # Координата пересечения по y
        y = (d[0] * yd[1] - d[1] * yd[0]) / div  # Координата пересечения по x
        print("Точка пересечения:", (x, y))
        line_a = y - np.array(y_min_r_coordinate)
        line_b = np.array(y_max_r_coordinate) - np.array(y)
        line_c = np.array(x) - np.array(x_min_c_coordinate)
        line_d = np.array(x_max_c_coordinate) - np.array(x)

        rs1 = line_a * line_c / 2  # Площадь 1 треугольника
        rs2 = line_c * line_b / 2  # Площадь 2 треугольника
        rs3 = line_b * line_d / 2  # Площадь 3 треугольника
        rs4 = line_a * line_d / 2  # Площадь 4 треугольника
        rmb = rs1 + rs2 + rs3 + rs4 #Перимепр ромба
        r_proportion1 = rs1 / rmb #Кофициент деления площади 1 участка на всю площадь
        r_proportion2 = rs2 / rmb #Коэфициент деления площади 2 участка на всю площадь
        r_proportion3 = rs3 / rmb #Коэфициент деления площади 3 участка на всю площадь
        r_proportion4 = rs4 / rmb #Коэфициент деления площади 4 участка на всю площадь
        square1 = square * r_proportion1# Площадь 1 части
        square2 = square * r_proportion2# Площадь 2 части

        square3 = square * r_proportion3# Площадь 3 части

        square4 = square * r_proportion4# Площадь 4 части


        s_dug1 = square1 - rs1#Площадь участка за пределами первого треугольника ромба
        s_dug2 = square2 - rs2#Площадь участка за пределами второго треугольника ромба

        s_dug3 = square3 - rs3#Площадь участка за пределами третего треугольника ромба

        s_dug4 = square4 - rs4#Площадь участка за пределами четвёртого треугольника ромба


        hip1 = (np.array(line_a) ** 2 + np.array(line_c) ** 2) ** 0.5#Расчёт длинны 1 гипотенузы 
        hip2 = (np.array(line_c) ** 2 + np.array(line_b) ** 2) ** 0.5#Расчёт длинны 2 гипотенузы  
        hip3 = (np.array(line_c) ** 2 + np.array(line_d) ** 2) ** 0.5#Расчёт длинны 3 гипотенузы 
        hip4 = (np.array(line_a) ** 2 + np.array(line_d) ** 2) ** 0.5#Расчёт длинны 4 гипотенузы [![введите сюда описание изображения][1]][1]

        sinus_beta1 = line_c / hip1
        sinus_beta2 = line_c / hip2
        sinus_beta3 = line_d / hip3
        sinus_beta4 = line_d / hip4
        beta1 = np.arcsin(sinus_beta1) * (180 / math.pi)# Первая половина 1 угла
        beta2 = np.arcsin(sinus_beta2) * (180 / math.pi)# Первая половина 3 угла
        beta3 = np.arcsin(sinus_beta3) * (180 / math.pi)# Вторая половина 3 угла
        beta4 = np.arcsin(sinus_beta4) * (180 / math.pi)# Вторая половина 1 угла
        alpha1 = 90 - beta1  # Первая половина 2 угла
        alpha2 = 90 - beta2  # Первал половина 4 угла
        alpha3 = 90 - beta3  # Вторая половина 4 угла
        alpha4 = 90 - beta4  # Вторая половина 2 угла
        first_angle = beta1 + beta4  # Первый угол
        second_angle = alpha1 + alpha2  # Второй укол
        third_angle = beta2 + beta3  # Третий угол
        fourth_angle = alpha3 + alpha4  # Четвёртый угол
        zol_height = (line_c + line_d) / line_c  # Соотношение участков ширин
        zol_width = (line_a + line_b) / line_a  # Соотношение участков длин
        width_seed = line_a + line_b  # Ширина семечки
        height_seed = line_c + line_d  # Длинна семечки
        return (line_a, line_b, line_c, line_d, first_angle, second_angle, third_angle, fourth_angle,
                square, s_dug1, s_dug2, s_dug3, s_dug4, zol_height, zol_width, height_seed, width_seed)


def find_max_rows(numb_matrix):# Функция поиска строк с максимальными суммами 
    max_sum = 0
    max_row_indices = []
    for i, row in enumerate(numb_matrix):
        row_sum = sum(row)
        if row_sum > max_sum:
            max_sum = row_sum
            max_row_indices = [i]  # Обновляем список индексов с максимальной суммой
        elif row_sum == max_sum:
            max_row_indices.append(i)  # Добавляем текущий индекс к списку
    return max_row_indices


def find_max_columns(numb_matrix):# Функция поиска столбцов с максимальными суммами
    # Транспонирование матрицы
    transposed_matrix = list(zip(*numb_matrix))

    max_sum = 0
    max_column_indices = []

    for i, column in enumerate(transposed_matrix):
        column_sum = sum(column)
        if column_sum > max_sum:
            max_sum = column_sum
            max_column_indices = [i]
        elif column_sum == max_sum:
            max_column_indices.append(i)

    return max_column_indices


def find_suit_coordinates(numb_matrix):
    max_row_indices = find_max_rows(numb_matrix)
    max_col_indices = find_max_columns(numb_matrix)

    suit_coordinates = []

    # Проходим по каждому индексу строки с максимальной суммой
    for max_row_index in max_row_indices:
        max_row = numb_matrix[max_row_index]
        max_row_ones = [i for i, val in enumerate(max_row) if val == 1]
        # Добавляем координаты максимальных строк с единицами
        suit_coordinates.extend([(max_row_index, col) for col in max_row_ones])

    # Проходим по каждому индексу столбца с максимальной суммой
    for max_col_index in max_col_indices:
        max_col = [numb_matrix[i][max_col_index] for i in range(len(numb_matrix))]
        max_col_ones = [i for i, val in enumerate(max_col) if val == 1]
        # Добавляем координаты максимальных столбцов с единицами
        suit_coordinates.extend([(row, max_col_index) for row in max_col_ones])

    return suit_coordinates


if __name__ == '__main__':
    main()