mainc

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include "generator.h"

#define MATRIX_SIZE 100 // Размер матрицы
#define FILTER_SIZE 3   // Размер фильтра

double matrix[MATRIX_SIZE][MATRIX_SIZE];
double matrix_eroded[MATRIX_SIZE][MATRIX_SIZE];
double matrix_dilated[MATRIX_SIZE][MATRIX_SIZE];

// Операция эрозии
void *erosion(void *arg) {
    int *startRow = (int *)arg;
    int endRow = (*startRow) + FILTER_SIZE;

    // Временная матрица для хранения результата эрозии
    double tempMatrix[FILTER_SIZE][FILTER_SIZE];

    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            double min = inputMatrix[i][j]; // Начальное значение минимума

            // Проходимся по всем элементам ядра
            for (int k = 0; k < FILTER_SIZE; k++) {
                for (int l = 0; l < FILTER_SIZE; l++) {
                    // Если вышли за границы матрицы, игнорируем этот элемент ядра
                    if (i + k - FILTER_SIZE/2 < 0 || i + k - FILTER_SIZE/2 >= MATRIX_SIZE ||
                        j + l - FILTER_SIZE/2 < 0 || j + l - FILTER_SIZE/2 >= MATRIX_SIZE) {
                        continue;
                    }

                    // Обновляем минимум, если нашли меньшее значение
                    if (inputMatrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2] < min) {
                        min = inputMatrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2];
                    }
                }
            }

            // Сохраняем результат эрозии во временной матрице
            tempMatrix[i - *startRow][j] = min;
        }
    }

    // Копируем результат эрозии из временной матрицы в выходную матрицу
    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            outputMatrix[i][j] = tempMatrix[i - *startRow][j];
        }
    }

    pthread_exit(NULL);
}

// Операция наращивания
void *dilation(void *arg) {
    int *startRow = (int *)arg;
    int endRow = (*startRow) + FILTER_SIZE;

    // Временная матрица для хранения результата наращивания
    double tempMatrix[FILTER_SIZE][FILTER_SIZE];

    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            double max = inputMatrix[i][j]; // Начальное значение максимума

            // Проходимся по всем элементам ядра
            for (int k = 0; k < FILTER_SIZE; k++) {
                for (int l = 0; l < FILTER_SIZE; l++) {
                    // Если вышли за границы матрицы, игнорируем этот элемент ядра
                    if (i + k - FILTER_SIZE/2 < 0 || i + k - FILTER_SIZE/2 >= MATRIX_SIZE ||
                        j + l - FILTER_SIZE/2 < 0 || j + l - FILTER_SIZE/2 >= MATRIX_SIZE) {
                        continue;
                    }

                    // Обновляем максимум, если нашли большее значение
                    if (inputMatrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2] > max) {
                        max = inputMatrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2];
                    }
                }
            }

            // Сохраняем результат наращивания во временной матрице
            tempMatrix[i - *startRow][j] = max;
        }
    }

    // Копируем результат наращивания из временной матрицы в выходную матрицу
    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            outputMatrix[i][j] = tempMatrix[i - *startRow][j];
        }
    }

    pthread_exit(NULL);
}

int main() {
    generate_matrix(matrix);
    // Загрузка данных в матрицу (можно использовать случайные значения для примера)
    // Ваш код для загрузки данных в матрицу здесь

    // Создание потоков
    pthread_t threads[MATRIX_SIZE - FILTER_SIZE + 1];
    int threadArgs[MATRIX_SIZE - FILTER_SIZE + 1];

    // Запуск потоков для фильтрации эрозией
    for (int i = 0; i < MATRIX_SIZE - FILTER_SIZE + 1; i++) {
        threadArgs[i] = i;
        pthread_create(&threads[i], NULL, erosion, &threadArgs[i]);
    }

    // Ожидание завершения потоков
    for (int i = 0; i < MATRIX_SIZE - FILTER_SIZE + 1; i++) {
        pthread_join(threads[i], NULL);
    }

    // Запуск потоков для фильтрации наращиванием
    for (int i = 0; i < MATRIX_SIZE - FILTER_SIZE + 1; i++) {
        threadArgs[i] = i;
        pthread_create(&threads[i], NULL, dilation, &threadArgs[i]);
    }

    // Ожидание завершения потоков
    for (int i = 0; i < MATRIX_SIZE - FILTER_SIZE + 1; i++) {
        pthread_join(threads[i], NULL);
    }

    // Сохранение результатов в файл или вывод на экран
    // Ваш код для сохранения результатов здесь
    printf("Result of erosion:\n");
    for (int i = 0; i < MATRIX_SIZE; ++i){
    for (int j = 0; j < MATRIX_SIZE; ++j){
       printf("%f", result_dilated[i][j]);
        }
        printf("\n");
    }

    printf("Result of dilation:\n");
    for (int i = 0; i < MATRIX_SIZE; ++i){
    for (int j = 0; j < MATRIX_SIZE; ++j){
       printf("%f", result_dilated[i][j]);
        }
        printf("\n");
    }

    return 0;
}