Проблема соединения фоток после их разбивки

#include <mpi.h>
#include <opencv2/opencv.hpp>
#include <iostream>
#include <vector>
#include <chrono>
 
using namespace std;
using namespace cv;
using namespace chrono;
 
// Функция обнаружения границ (разностный метод)
void detectEdges(const Mat& input, Mat& output) {
    output = input.clone();
    int rows = input.rows, cols = input.cols;
 
    for (int y = 1; y < rows - 1; y++) {
        for (int x = 1; x < cols - 1; x++) {
            int A = input.at<uchar>(y - 1, x - 1);
            int B = input.at<uchar>(y - 1, x);
            int C = input.at<uchar>(y - 1, x + 1);
            int H = input.at<uchar>(y, x - 1);
            int D = input.at<uchar>(y, x + 1);
            int G = input.at<uchar>(y + 1, x - 1);
            int F = input.at<uchar>(y + 1, x);
            int E = input.at<uchar>(y + 1, x + 1);
 
            int newValue = abs(A + B + C - G - F - E) + abs(A + H + G - C - D - E);
            output.at<uchar>(y, x) = saturate_cast<uchar>(newValue);
        }
    }
}
 
// Фильтр усреднения (подавление зернистого шума)
void reduceNoise(const Mat& input, Mat& output) {
    output = input.clone();
    int rows = input.rows, cols = input.cols;
 
    for (int y = 1; y < rows - 1; y++) {
        for (int x = 1; x < cols - 1; x++) {
            int sum = 0;
            for (int dy = -1; dy <= 1; dy++) {
                for (int dx = -1; dx <= 1; dx++) {
                    sum += input.at<uchar>(y + dy, x + dx);
                }
            }
            output.at<uchar>(y, x) = sum / 9;
        }
    }
}
 
int main(int argc, char** argv) {
    MPI_Init(&argc, &argv);
 
    int rank, size;
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
 
    if (size != 4) {
        if (rank == 0) cout << "Run the program with 4 processes!" << endl;
        MPI_Finalize();
        return -1;
    }
 
    Mat img;
    int rows = 0, cols = 0;
 
 
    if (rank == 0) {
        img = imread("E:/img102.png", IMREAD_GRAYSCALE);
        if (img.empty()) {
            cerr << "Error loading image!" << endl;
            MPI_Abort(MPI_COMM_WORLD, 1);
        }
        rows = img.rows;
        cols = img.cols;
    }
 
    MPI_Bcast(&rows, 1, MPI_INT, 0, MPI_COMM_WORLD);
    MPI_Bcast(&cols, 1, MPI_INT, 0, MPI_COMM_WORLD);
 
    if (rows == 0 || cols == 0) {
        cerr << "Error: Incorrect image dimensions!" << endl;
        MPI_Abort(MPI_COMM_WORLD, 1);
    }
 
    int baseHeight = rows / 3;
    int remainder = rows % 3;
    vector<int> sendcounts(4, 0), displs(4, 0);
 
    auto startTotal = high_resolution_clock::now();
 
    for (int i = 1; i < 4; i++) {
        sendcounts[i] = (baseHeight + (i == 3 ? remainder : 0)) * cols;
        displs[i] = (i == 1) ? 0 : displs[i - 1] + sendcounts[i - 1];
    }
 
    int partHeight = (rank == 0) ? 0 : (rank == 3 ? baseHeight + remainder : baseHeight);
    Mat part(partHeight, cols, CV_8UC1);
 
    MPI_Scatterv(img.data, sendcounts.data(), displs.data(), MPI_UNSIGNED_CHAR, (rank == 0 ? nullptr : part.data), partHeight * cols, MPI_UNSIGNED_CHAR, 0, MPI_COMM_WORLD);
 
    Mat edgePart, denoisedPart;
    double edgeTime = 0.0, noiseTime = 0.0;
 
    if (rank != 0) {
        auto start = high_resolution_clock::now();
        detectEdges(part, edgePart);
        auto end = high_resolution_clock::now();
        edgeTime = duration<double>(end - start).count();
        cout << "Process " << rank << " edge detection time: " << edgeTime << " sec" << endl;
 
        start = high_resolution_clock::now();
        reduceNoise(edgePart, denoisedPart);
        end = high_resolution_clock::now();
        noiseTime = duration<double>(end - start).count();
        cout << "Process " << rank << " noise reduction time: " << noiseTime << " sec" << endl;
    }
 
    MPI_Gatherv((rank == 0 ? nullptr : denoisedPart.data), partHeight * cols, MPI_UNSIGNED_CHAR, img.data, sendcounts.data(), displs.data(), MPI_UNSIGNED_CHAR, 0, MPI_COMM_WORLD);
 
    auto endTotal = high_resolution_clock::now();
    double totalTime = duration<double>(endTotal - startTotal).count();
    if (rank == 0) {
        cout << "Total execution time: " << totalTime << " sec" << endl;
    }
 
    if (rank == 0) {
        imwrite("processed_image.jpg", img);
        cout << "Final processed image saved!" << endl;
    }
 
    MPI_Finalize();
}