mainc-2

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <time.h>

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

double matrix[MATRIX_SIZE][MATRIX_SIZE];
double matrix_erosion[MATRIX_SIZE][MATRIX_SIZE];
double matrix_dilation[MATRIX_SIZE][MATRIX_SIZE];

void generate_matrix(double matrix[MATRIX_SIZE][MATRIX_SIZE]) {
    // Инициализация генератора случайных чисел
    srand(time(NULL));

    // Заполнение матрицы случайными значениями
    for (int i = 0; i < MATRIX_SIZE; ++i) {
        for (int j = 0; j < MATRIX_SIZE; ++j) {
            matrix[i][j] = (double)rand() / RAND_MAX;
            printf("%.2f ", matrix[i][j]);
        }
        printf("\n");
    }
}

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

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

    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            double min = matrix[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 (matrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2] < min) {
                        min = matrix[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++) {
            matrix_erosion[i][j] = tempMatrix[i - *startRow][j];
        }
    }

    pthread_exit(NULL);
}

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

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

    for (int i = *startRow; i < endRow; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            double max = matrix[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 (matrix[i + k - FILTER_SIZE/2][j + l - FILTER_SIZE/2] > max) {
                        max = matrix[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++) {
            matrix_dilation[i][j] = tempMatrix[i - *startRow][j];
        }
    }

    pthread_exit(NULL);
}

int main() {
    clock_t start, end;
    double cpu_time_used;
    //Генерация матрицы
    generate_matrix(matrix);

    printf("Создание потоков\n");
    pthread_t threads[MATRIX_SIZE - FILTER_SIZE + 1];
    int threadArgs[MATRIX_SIZE - FILTER_SIZE + 1];

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

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

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

    printf("Ожидание завершения потоков\n");
    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", matrix_erosion[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", matrix_dilation[i][j]);
        }
        printf("\n");
    }

    end = clock();
    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
    printf("Программа выполнялась %.2f секунд\n", cpu_time_used);

    return 0;
}