// Copyright (2019-2022) Paul Scherrer Institute
// SPDX-License-Identifier: GPL-3.0-or-later

#include <catch2/catch.hpp>

#include "../common/RawToConvertedGeometry.h"

TEST_CASE("RawToConvertedGeometry_Half_and_quarter","[RawToConvertedGeometry]") {
    REQUIRE(half<int32_t>(7, -10, 20) == 3);
    REQUIRE(half<int32_t>(7, 9, 20) == 7);
    REQUIRE(half<int32_t>(27, 9, 20) == 27);

    REQUIRE(half<double>(7, -10, 20) == Approx(3.5));
    REQUIRE(half<double>(7, 9, 20) == 7);
    REQUIRE(half<double>(27, 9, 20) == 27);

    REQUIRE(quarter<int16_t>(6, -10, 20) == 1);
    REQUIRE(quarter<int16_t>(26, -10, 20) == 26);
    REQUIRE(quarter<int16_t>(-16, -10, 20) == -16);
}

TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixel","[RawToConvertedGeometry]") {
    int16_t in[1024];
    int16_t out[1030];
    for (int16_t i = 0; i < 1024; i++)
        in[i] = i;

    LineCopyAndAddMultipixel<int16_t>(out, in);
    REQUIRE(out[0] == 0);
    REQUIRE(out[100] == 100);
    REQUIRE(out[255] == 255);
    REQUIRE(out[255+1] == 255);
    REQUIRE(out[256+1] == 256);
    REQUIRE(out[256+2] == 256);
    REQUIRE(out[259+2] == 259);
    REQUIRE(out[400+2] == 400);
    REQUIRE(out[600+4] == 600);
    REQUIRE(out[768+5] == 768);
    REQUIRE(out[768+6] == 768);
    REQUIRE(out[1000+6] == 1000);
    REQUIRE(out[1015+6] == 1015);
    REQUIRE(out[1029] == 1029 - 6);
}

TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixelNormalRow","[RawToConvertedGeometry]") {
    int16_t in[1024];
    int16_t out[1030];
    for (int16_t i = 0; i < 1024; i++)
        in[i] = i;

    LineCopyAndAdjustMultipixel<int16_t, int16_t>(out, in, 0, 500);
    REQUIRE(out[0] == 0);
    REQUIRE(out[100] == 100);
    REQUIRE(out[255] == 255/2);
    REQUIRE(out[255+1] == 255/2);
    REQUIRE(out[256+1] == 256/2);
    REQUIRE(out[256+2] == 256/2);
    REQUIRE(out[259+2] == 259);
    REQUIRE(out[400+2] == 400);
    REQUIRE(out[600+4] == 600);
    REQUIRE(out[768+5] == 768); // > 500 so not modified
    REQUIRE(out[768+6] == 768); // > 500 so not modified
    REQUIRE(out[1000+6] == 1000);
    REQUIRE(out[1015+6] == 1015);
    REQUIRE(out[1029] == 1029 - 6);
}

TEST_CASE("RawToConvertedGeometry_LineCopyAndAdjustMultipixelBin2x2","[RawToConvertedGeometry]") {
    int16_t in[2048];
    int16_t out[514];
    for (int16_t i = 0; i < 2048; i++)
        in[i] = i;

    LineCopyAndAdjustMultipixelBin2x2<int16_t>(out, in, -1, 6000);
    CHECK(out[0] == 0+1+1024+1025);
    CHECK(out[100] == 200+201+1224+1225);
    CHECK(out[127] == 254+255/2+254+1024+255/2+1024/2);
    CHECK(out[128] == 255/2+256/2+1024/2+255/2+256/2+1024/2);
    CHECK(out[129] == 257+256/2+1024/2+257+1024+256/2);
    CHECK(out[201] == 400+401+400+401+1024+1024);
    CHECK(out[302] == 600+601+600+601+1024+1024);
    CHECK(out[385] == 766+767/2+1024+766+767/2+1024/2);
    CHECK(out[386] == 767/2+768/2+1024/2+1024/2+767/2+768/2);
    CHECK(out[403] == 800+801+800+801+1024+1024);
    CHECK(out[513] == 6000); // overload
}

TEST_CASE("RawToConvertedGeometry_LineCopyAndAdjustMultipixelBin2x2MidRow","[RawToConvertedGeometry]") {
    int16_t in[1024];
    int16_t out[514];
    for (int16_t i = 0; i < 1024; i++)
        in[i] = i;

    LineCopyAndAdjustMultipixelBin2x2MidRow<int16_t>(out, in, -1, 2000);
    REQUIRE(out[0] == 0+1);
    REQUIRE(out[100] == 200 + 201);
    REQUIRE(out[127] == 254 + 255/2);
    REQUIRE(out[128] == 256/2 + 255/2);
    REQUIRE(out[129] == 256/2 + 257);
    REQUIRE(out[201] == 400+401);
    REQUIRE(out[302] == 600+601);
    REQUIRE(out[385] == 766+767/2);
    REQUIRE(out[386] == 767/2+768/2);
    REQUIRE(out[403] == 800+801);
    REQUIRE(out[513] == 2000); // overload
}

TEST_CASE("RawToConvertedGeometry_TransferModuleAdjustMultipixelsBin2x2","[RawToConvertedGeometry]") {
    int16_t in[RAW_MODULE_SIZE];
    int16_t out[(CONVERTED_MODULE_COLS/2) * (CONVERTED_MODULE_LINES/2)];
    for (int i = 0; i < RAW_MODULE_SIZE; i++)
        in[i] = i % 1024;

    TransferModuleAdjustMultipixelsBin2x2<int16_t>(out, in, (CONVERTED_MODULE_COLS/2), -1, 8000);

    CHECK(out[0] == 0 + 1 + 0 + 1);
    CHECK(out[1] == 2 + 3 + 2 + 3);
    CHECK(out[513] == 1020 + 1021 + 1020 + 1021);
    CHECK(out[514] == 1022 + 1023 + 1022 + 1023);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 1] == 2 + 3 + 2 + 3);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 127] == 2*(254 + 255/2));
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 100 + 128] == 2*(255/2 + 256/2));
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 128] == 0 + 1);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 1] == 2 + 3);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 127] == 254+255/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 128] == 255/2+256/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 128 + 128 + 129 * 2] == 767/2+768/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 129] == 0 + 1);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 1] == 2 + 3);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 127] == 254+255/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 128] == 255/2+256/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * 129 + 128 + 129 * 2] == 767/2+768/2);
    CHECK(out[(CONVERTED_MODULE_COLS/2) * (CONVERTED_MODULE_LINES/2) - 1] == 1022+1023+1022+1023);
}

TEST_CASE("RawToConvertedGeometry_LineCopyAndAddMultipixelMiddleRow","[RawToConvertedGeometry]") {
    int16_t in[1024];
    int16_t out[1030];
    for (int16_t i = 0; i < 1024; i++)
        in[i] = i;

    LineCopyAndAdjustMultipixelMidRow<int16_t, int16_t>(out, in, 0, 500);
    REQUIRE(out[0] == 0);
    REQUIRE(out[100] == 100/2);
    REQUIRE(out[255] == 255/4);
    REQUIRE(out[255+1] == 255/4);
    REQUIRE(out[256+1] == 256/4);
    REQUIRE(out[256+2] == 256/4);
    REQUIRE(out[259+2] == 259/2);
    REQUIRE(out[400+2] == 400/2);
    REQUIRE(out[600+4] == 600); // > 500 so not modified
    REQUIRE(out[768+5] == 768); // > 500 so not modified
    REQUIRE(out[768+6] == 768); // > 500 so not modified
    REQUIRE(out[1000+6] == 1000); // > 500 so not modified
    REQUIRE(out[1015+6] == 1015); // > 500 so not modified
    REQUIRE(out[1029] == 1029 - 6); // > 500 so not modified
}

TEST_CASE("RawToConvertedGeometry_Transform","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2, {4,4,6,6}, 0,0, false);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(2) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    std::vector<uint32_t> input(x.GetModulesNum(3) * RAW_MODULE_SIZE);
    std::vector<uint32_t> output(x.GetPixelsNum());

    for (uint32_t i = 0; i < x.GetModulesNum(3) * RAW_MODULE_SIZE; i++) input[i] = i;

    for (int i = 0; i < x.GetModulesNum(3); i++)
        TransferModule<uint32_t, uint32_t>(output.data() + x.GetPixel0OfModule(i),
                                           input.data() + i * RAW_MODULE_SIZE,
                                           (x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum());

    REQUIRE(output[0] == input[0]);
    REQUIRE(output[253] == input[253]);
    REQUIRE(output[256] == input[255]);
    REQUIRE(output[1029] == input[1023]);

    // Row just below middle row
    REQUIRE(output[254*(2*1030)+1006] == input[254*1024+1000]);

    // Middle row
    REQUIRE(output[255*(2*1030)+518] == input[255*1024+514]);
    REQUIRE(output[256*(2*1030)+518] == input[255*1024+514]);

    // Split corner (module 0)
    REQUIRE(output[255*(2*1030)+255] == input[255*1024+255]);
    REQUIRE(output[256*(2*1030)+255] == input[255*1024+255]);
    REQUIRE(output[255*(2*1030)+256] == input[255*1024+255]);
    REQUIRE(output[256*(2*1030)+256] == input[255*1024+255]);

    // Split corner (module 0)
    REQUIRE(output[258*(2*1030)+255] == input[256*1024+255]);
    REQUIRE(output[257*(2*1030)+255] == input[256*1024+255]);
    REQUIRE(output[258*(2*1030)+256] == input[256*1024+255]);
    REQUIRE(output[257*(2*1030)+256] == input[256*1024+255]);

    // Row just above middle row
    REQUIRE(output[259*(2*1030)+302] == input[257*1024+300]);

    // Split corner (module 1)
    REQUIRE(output[255*(2*1030)+1030+255] == input[512*1024+255*1024+255]);
    REQUIRE(output[256*(2*1030)+1030+255] == input[512*1024+255*1024+255]);
    REQUIRE(output[255*(2*1030)+1030+256] == input[512*1024+255*1024+255]);
    REQUIRE(output[256*(2*1030)+1030+256] == input[512*1024+255*1024+255]);

    // Module 1
    REQUIRE(output[1030+5] == input[512*1024 + 5]);
    REQUIRE(output[1030+256] == input[512*1024 + 255]);

    // Module 2
    REQUIRE(output[1030*514*2 + 256] == input[512*1024*2 + 255]);
}

TEST_CASE("RawToConvertedGeometry_Transform_AdjustMultipixels","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2, {4,4,6,6}, 0, 0, false);

    x.Mode(DetectorMode::Conversion);
    x.Summation(2); // Ensure the image is 32-bit
    REQUIRE(x.GetPixelDepth() == 4);

    REQUIRE(x.GetModulesNum(3) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    std::vector<int32_t> input(x.GetModulesNum(3) * RAW_MODULE_SIZE);
    std::vector<int32_t> output(x.GetPixelsNum());

    for (int32_t i = 0; i < x.GetModulesNum(3) * RAW_MODULE_SIZE; i++) input[i] = i % x.GetOverflow();

    for (int i = 0; i < x.GetModulesNum(3); i++)
        TransferModuleAdjustMultipixels<int32_t, int32_t>(output.data() + x.GetPixel0OfModule(i),
                                                          input.data() + i * RAW_MODULE_SIZE,
                                                          (x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum(),
                                                          x.GetUnderflow(), x.GetOverflow());

    REQUIRE(output[0] == input[0]);
    REQUIRE(output[253] == input[253]);
    REQUIRE(output[256] == input[255]/2);
    REQUIRE(output[1029] == input[1023]);

    // Row just below middle row
    REQUIRE(output[254*(2*1030)+1006] == input[254*1024+1000]);

    // Middle row
    REQUIRE(output[255*(2*1030)+518] == input[255*1024+514]/2);
    REQUIRE(output[256*(2*1030)+518] == input[255*1024+514]/2);

    // Split corner (module 0)
    REQUIRE(output[255*(2*1030)+255] == input[255*1024+255]/4);
    REQUIRE(output[256*(2*1030)+255] == input[255*1024+255]/4);
    REQUIRE(output[255*(2*1030)+256] == input[255*1024+255]/4);
    REQUIRE(output[256*(2*1030)+256] == input[255*1024+255]/4);

    // Split corner (module 0)
    REQUIRE(output[258*(2*1030)+255] == input[256*1024+255]/4);
    REQUIRE(output[257*(2*1030)+255] == input[256*1024+255]/4);
    REQUIRE(output[258*(2*1030)+256] == input[256*1024+255]/4);
    REQUIRE(output[257*(2*1030)+256] == input[256*1024+255]/4);

    // Row just above middle row
    REQUIRE(output[259*(2*1030)+302] == input[257*1024+300]);

    // Split corner (module 1)
    REQUIRE(output[255*(2*1030)+1030+255] == input[512*1024+255*1024+255]/4);
    REQUIRE(output[256*(2*1030)+1030+255] == input[512*1024+255*1024+255]/4);
    REQUIRE(output[255*(2*1030)+1030+256] == input[512*1024+255*1024+255]/4);
    REQUIRE(output[256*(2*1030)+1030+256] == input[512*1024+255*1024+255]/4);

    // Module 1
    REQUIRE(output[1030+5] == input[512*1024 + 5]);
    REQUIRE(output[1030+256] == input[512*1024 + 255] / 2);

    // Module 2
    REQUIRE(output[1030*514*2 + 256] == input[512*1024*2 + 255] / 2);
}


TEST_CASE("RawToConvertedGeometry_Transform_AdjustMultipixelsBin2x2","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2, {4,4}, 8, 36, true);

    x.Mode(DetectorMode::Conversion);
    x.Summation(2).Binning2x2(true);

    REQUIRE(x.GetPixelDepth() == 4);

    std::vector<int32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
    std::vector<int32_t> output(x.GetPixelsNum());

    for (int32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
        input[i] = i % 98765;

    for (int i = 0; i < x.GetModulesNum(); i++)
        TransferModuleAdjustMultipixelsBin2x2<int32_t>(output.data() + x.GetPixel0OfModule(i),
                                                          input.data() + i * RAW_MODULE_SIZE,
                                                          (x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum(),
                                                          x.GetUnderflow(),
                                                          x.GetOverflow());


    CHECK(output[0] == input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS] + input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+1]
                       + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS] + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+1]);

    CHECK(output[124/2] == input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+124] + input[(6*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+125]
                       + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+124] + input[(6*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+125]);

    CHECK(output[1038/2] == input[(7*RAW_MODULE_LINES+511)*RAW_MODULE_COLS] + input[(7*RAW_MODULE_LINES+511)*RAW_MODULE_COLS+1]
                       + input[(7*RAW_MODULE_LINES+510)*RAW_MODULE_COLS] + input[(7*RAW_MODULE_LINES+510)*RAW_MODULE_COLS+1]);

    CHECK(output[((514+36)/2+513/2)*x.GetXPixelsNum()] == input[(4*RAW_MODULE_LINES)*RAW_MODULE_COLS] + input[(4*RAW_MODULE_LINES)*RAW_MODULE_COLS+1]
                       + input[(4*RAW_MODULE_LINES+1)*RAW_MODULE_COLS] + input[(4*RAW_MODULE_LINES+1)*RAW_MODULE_COLS+1]);
    
    CHECK(output[(x.GetYPixelsNum()-1)*x.GetXPixelsNum()] == input[0] + input[1] + input[1024] + input[1025]);
}

TEST_CASE("RawToConvertedGeometry_Transform_upside_down","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(3) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    auto input = (uint32_t *) calloc(x.GetModulesNum(2) * RAW_MODULE_SIZE, sizeof(uint32_t));
    auto output = (uint32_t *) calloc(x.GetPixelsNum(), sizeof(uint32_t));
    for (uint32_t i = 0; i < x.GetModulesNum(3) * RAW_MODULE_SIZE; i++) input[i] = i;

    for (int i = 0; i < x.GetModulesNum(3); i++)
        TransferModule<uint32_t, uint32_t>(output + x.GetPixel0OfModule(i + x.GetFirstModuleOfDataStream(3)),
                                           input + i * RAW_MODULE_SIZE,
                                           (x.IsUpsideDown() ? -1 : 1) * x.GetXPixelsNum());

    REQUIRE(output[514*1030*4+0] == input[511*1024+0]);
    REQUIRE(output[514*1030*4+253] == input[511*1024+253]);
    REQUIRE(output[514*1030*4+256] == input[511*1024+255]);
    REQUIRE(output[514*1030*4+1029] == input[511*1024+1023]);

    // Row just below middle row
    REQUIRE(output[514*1030*4+254*(2*1030)+1006] == input[257*1024+1000]);

    // Middle row
    REQUIRE(output[514*1030*4+255*(2*1030)+518] == input[256*1024+514]);
    REQUIRE(output[514*1030*4+256*(2*1030)+518] == input[256*1024+514]);

    // Split corner (module 0)
    REQUIRE(output[514*1030*4+255*(2*1030)+255] == input[256*1024+255]);
    REQUIRE(output[514*1030*4+256*(2*1030)+255] == input[256*1024+255]);
    REQUIRE(output[514*1030*4+255*(2*1030)+256] == input[256*1024+255]);
    REQUIRE(output[514*1030*4+256*(2*1030)+256] == input[256*1024+255]);

    // Split corner (module 0)
    REQUIRE(output[514*1030*4+258*(2*1030)+255] == input[255*1024+255]);
    REQUIRE(output[514*1030*4+257*(2*1030)+255] == input[255*1024+255]);
    REQUIRE(output[514*1030*4+258*(2*1030)+256] == input[255*1024+255]);
    REQUIRE(output[514*1030*4+257*(2*1030)+256] == input[255*1024+255]);

    // Row just above middle row
    REQUIRE(output[514*1030*4+259*(2*1030)+302] == input[254*1024+300]);

    // Split corner (module 1)
    REQUIRE(output[514*1030*4+257*(2*1030)+1030+255] == input[512*1024+255*1024+255]);
    REQUIRE(output[514*1030*4+258*(2*1030)+1030+255] == input[512*1024+255*1024+255]);
    REQUIRE(output[514*1030*4+257*(2*1030)+1030+256] == input[512*1024+255*1024+255]);
    REQUIRE(output[514*1030*4+258*(2*1030)+1030+256] == input[512*1024+255*1024+255]);

    // Module 1
    REQUIRE(output[514*1030*4+1030+5] == input[512*1024 + 511*1024 + 5]);
    REQUIRE(output[514*1030*4+1030+256] == input[512*1024 + 511*1024 + 255]);

    // Module 2
    REQUIRE(output[1030*514*2 + 256] == input[512*1024*2 + 511*1024 + 255]);

    free(input);
    free(output);
}

TEST_CASE("RawToConvertedGeometry","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(2) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    auto input = (uint32_t *) calloc(x.GetModulesNum() * RAW_MODULE_SIZE, sizeof(uint32_t));
    auto output = (uint32_t *) calloc(x.GetPixelsNum(), sizeof(uint32_t));

    auto input2 = (uint32_t *) calloc(x.GetModulesNum() * RAW_MODULE_SIZE, sizeof(uint32_t));

    for (uint32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
        input[i] = 3*i-1;

    RawToConvertedGeometry<uint32_t, uint32_t>(x, output, input);
    ConvertedToRawGeometry<uint32_t>(x, input2, output);

    uint64_t diff = 0;
    for (int i = 0; i < x.GetModulesNum(2) * RAW_MODULE_SIZE; i++) {
        if (input[i] != input2[i]) diff++;
    }
    REQUIRE(diff == 0);

    free(input);
    free(output);
    free(input2);
}

TEST_CASE("RawToConvertedGeometry_int64","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(2) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    std::vector<uint32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
    std::vector<uint64_t> output(x.GetPixelsNum());
    std::vector<uint64_t> input2(x.GetModulesNum() * RAW_MODULE_SIZE);

    for (uint32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
        input[i] = 3*i-1;

    RawToConvertedGeometry<uint64_t, uint32_t>(x, output.data(), input.data());
    ConvertedToRawGeometry<uint64_t>(x, input2.data(), output.data());

    uint64_t diff = 0;
    for (int i = 0; i < x.GetModulesNum(2) * RAW_MODULE_SIZE; i++) {
        if (input[i] != input2[i]) diff++;
    }
    REQUIRE(diff == 0);
}

TEST_CASE("RawToConvertedGeometry_FP","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2,{4,4,6,6}, 0, 0, true);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(2) == 6);
    REQUIRE(x.GetPixelsNum() == CONVERTED_MODULE_SIZE * x.GetModulesNum());

    std::vector<uint32_t> input(x.GetModulesNum() * RAW_MODULE_SIZE);
    std::vector<double> output(x.GetPixelsNum());
    std::vector<double> input2(x.GetModulesNum() * RAW_MODULE_SIZE);

    for (uint32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
        input[i] = 3*i-1;

    RawToConvertedGeometry<double, uint32_t>(x, output.data(), input.data());
    ConvertedToRawGeometry<double>(x, input2.data(), output.data());

    uint64_t diff = 0;
    for (int i = 0; i < x.GetModulesNum(2) * RAW_MODULE_SIZE; i++) {
        if (input[i] != Approx(input2[i])) diff++;
    }
    REQUIRE(diff == 0);
}

TEST_CASE("RawToConvertedGeometry_Gaps","[RawToConvertedGeometry]") {
    DiffractionExperiment x(2,{4,4}, 8, 36, true);

    x.Mode(DetectorMode::Conversion);
    REQUIRE(x.GetModulesNum(1) == 4);
    REQUIRE(x.GetXPixelsNum() == 2 * CONVERTED_MODULE_COLS + 8);
    REQUIRE(x.GetYPixelsNum() == 4 * CONVERTED_MODULE_LINES + 3*36);
    REQUIRE(x.GetPixelsNum() == x.GetXPixelsNum() * x.GetYPixelsNum());

    auto input = (uint32_t *) calloc(x.GetModulesNum() * RAW_MODULE_SIZE, sizeof(uint32_t));
    auto output = (uint32_t *) calloc(x.GetPixelsNum(), sizeof(uint32_t));

    auto input2 = (uint32_t *) calloc(x.GetModulesNum() * RAW_MODULE_SIZE, sizeof(uint32_t));

    for (uint32_t i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++)
        input[i] = 3*i-1;

    RawToConvertedGeometry<uint32_t, uint32_t>(x, output, input);
    ConvertedToRawGeometry<uint32_t>(x, input2, output);

    uint64_t diff = 0;
    for (int i = 0; i < x.GetModulesNum() * RAW_MODULE_SIZE; i++) {
        if (input[i] != input2[i]) diff++;
    }
    REQUIRE(diff == 0);

    free(input);
    free(output);
    free(input2);
}

TEST_CASE("RawToConvertedCoordinate","[RawToConvertedGeometry]") {
    DiffractionExperiment experiment(2,{4,4}, 8, 36, true);

    auto [x1,y1] = RawToConvertedCoordinate(experiment, 0, 0);
    REQUIRE(x1 == 0);
    REQUIRE(y1 == 2163);

    auto [x2,y2] = RawToConvertedCoordinate(experiment, 1, RAW_MODULE_COLS-1);
    REQUIRE(x2 == 2067);
    REQUIRE(y2 == 2163);

    auto [x3,y3] = RawToConvertedCoordinate(experiment, 6, RAW_MODULE_COLS* (RAW_MODULE_LINES-1));
    REQUIRE(x3 == 0);
    REQUIRE(y3 == 0);

    auto [x4,y4] = RawToConvertedCoordinate(experiment, 3, RAW_MODULE_COLS*258 + 811);
    REQUIRE(x4 == 1030+8+811 + 3*2);
    REQUIRE(y4 == 2163-(514+36+258+2));

    auto [x5,y5] = RawToConvertedCoordinate(experiment, 7, RAW_MODULE_SIZE-1);
    REQUIRE(x5 == 2067);
    REQUIRE(y5 == 0);
}