MPI_Sobel_2

// ParalellProg_lab1_v2.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"

#include <iostream>
#include <cmath>
#include <algorithm>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/objdetect/objdetect.hpp>
#include <mpi.h>

using namespace std;
using namespace cv;

#define ll long long

const vector<vector<int>> sobel_x = { { -1 , 0 , 1 } ,{ -2 , 0 , 2 } ,{ -1 , 0 , 1 } };
const vector<vector<int>> sobel_y = { { -1 , -2 , -1 } ,{ 0 , 0 , 0 } ,{ 1 , 2 , 1 } };

void Sobel(string & path, int argc, char* argv[]) {
    Mat img = imread(path);


    Mat img_gray, image_blur;
    GaussianBlur(img, image_blur, Size(5, 5), 3, 3);
    cvtColor(image_blur, img_gray, CV_RGB2GRAY);


    int cols = img_gray.cols;
    int rows = img_gray.rows;


    int radius = 1;

    Mat _src;
    copyMakeBorder(img_gray, _src, radius, radius, radius, radius, BORDER_REFLECT101);

    Mat gradient_x = img_gray.clone();
    Mat gradient_y = img_gray.clone();
    Mat gradient_f = img_gray.clone();



    for (int r = radius; r < _src.rows - radius; ++r) {
        for (int c = radius; c < _src.cols - radius; ++c) {
            int sx = 0, sy = 0;
            for (int i = -radius; i <= radius; ++i) {
                for (int j = -radius; j <= radius; ++j) {
                    sx += _src.at<uchar>(r + i, c + j) * sobel_x[i + radius][j + radius];
                    sy += _src.at<uchar>(r + i, c + j) * sobel_y[i + radius][j + radius];
                }
            }
            gradient_x.at<uchar>(r - radius, c - radius) = sx / 30;
            gradient_y.at<uchar>(r - radius, c - radius) = sy / 30;
        }
    }

    Mat absGrad_x, absGrad_y;
    convertScaleAbs(gradient_x, absGrad_x);
    convertScaleAbs(gradient_y, absGrad_y);

    for (int i = 0; i < gradient_f.rows; i++) {
        for (int j = 0; j < gradient_f.cols; j++) {
            gradient_f.at<uchar>(i, j) = sqrt(pow(gradient_x.at<uchar>(i, j), 2) + pow(gradient_y.at<uchar>(i, j), 2));
            gradient_f.at<uchar>(i, j) = gradient_f.at<uchar>(i, j) >= 240 ? 100 : 0;
        }
    }

    imwrite(path + "output.jpg", gradient_f);
}

vector<string> q;

int main(int argc, char* argv[]) {
    ll before = clock();


    int n;

    int worldSize;
    int worldRank;
//  char processorName[MPI_MAX_PROCESSOR_NAME];
//  int nameLength;


    MPI_Init(&argc, &argv);
    MPI_Comm_size(MPI_COMM_WORLD, &worldSize);
    MPI_Comm_rank(MPI_COMM_WORLD, &worldRank);
    MPI_Status status;
//  MPI_Get_processor_name(processorName, &nameLength);
//  cout << worldSize << " " << worldRank << endl

    freopen("files.txt", "r", stdin);
    string str;
    while (getline(cin, str))q.push_back(str);
    n = q.size();


    for (int i = worldRank; i < n; i += worldSize) {
        //  for (int i = 0; i < n; ++i) {
        string file = q[i];
        Sobel(file, argc, argv);
    }
    if (worldRank == 0) {
        ll after = clock();

        cout << "Total time: " << (double)(after - before) / CLOCKS_PER_SEC << " sec" << endl;
        cout << "Average time: " << (double)((after - before) / CLOCKS_PER_SEC) / n << " sec" << endl;

        system("pause");
    }
    MPI_Finalize();
    return 0;
}