main.cpp

#include "czi_parser.h"
#include "file_system.h"
#include "utilities/args.hxx"
int main(int argc, char **argv)
{
    args::ArgumentParser argParser("CZI file tools", "Optional arguments are in `[]` necessary in `<>`.");
    // Groups
    args::Group cziFileGroup(argParser, "CZI file input - necessary.", args::Group::Validators::All);
    args::Group mainMethodGroup(argParser, "Methods:", args::Group::Validators::AtMostOne);
    args::Group optionsGroup(argParser, "Program options:", args::Group::Validators::DontCare);
    args::Group compressionGroup(argParser, "Avaible compressions", args::Group::Validators::Xor);

    // Main option, has to be set. Czi file.
    args::ValueFlag<std::string> cziFile(cziFileGroup, "czi file", "CZI file to load.", {'i', "input"});

    // Program methods.
    args::HelpFlag helpMethod(mainMethodGroup, "help", "Print help", {'h', "help"});
    args::Flag reportMethod(mainMethodGroup, "report", "Basic information about CZI file. [verbose]", {"report"});
    args::Flag compressionTestMethod(mainMethodGroup, "compression-test", "Compress subblocks and output compression ratios <compression method>", {"compression-test"});

    // Options
    args::Flag dontParseMetadataOption(optionsGroup, "no metadata", "Dont read metadata byte", {"no-metadata"});
    args::Flag verboseOption(optionsGroup, "verbose", "Extend output of method", {'v', "verbose"});
    args::Flag rleCompressionOption(compressionGroup, "RLE", "RLE compression", {"rle"});
    args::Flag lzCompressionOption(compressionGroup, "LZ", "LZ compression", {"lz"});
    args::Flag gzipCompressionOption(compressionGroup, "GZIP", "GZIP (zlib) compression", {"gzip"});
    args::Flag lzmaCompressionOption(compressionGroup, "LZMA", "LZMA (2?) compression", {"lzma"});

    try
    {
        argParser.helpParams.width *= 2;
        argParser.ParseCLI(argc, argv);
    }
    catch (args::Help &)
    {
        std::cout << argParser;
        return 0;
    }
    catch (args::ValidationError &e)
    {
        printf(RED "%s Check help with -h or --help.\n" RESET, e.what());
        return 1;
    }
    catch (args::ParseError &pe)
    {
        printf(RED "%s Check help with -h or --help.\n" RESET, pe.what());
        return 1;
    }

    CziParser parser(dontParseMetadataOption.Get());
    auto parsedFile = parser.parse_czi_file(cziFile.Get());

    // Test compression method.
    if (compressionTestMethod)
    {
        CompressionMethod cm = CompressionMethod_RLE;

        if (lzCompressionOption)
            cm = CompressionMethod_LZ;
        else if (gzipCompressionOption)
            cm = CompressionMethod_GZIP;
        else if (lzmaCompressionOption)
            cm = CompressionMethod_LZMA;

        parsedFile.test_compression(cm, verboseOption.Matched());
    }

    /*
    std::string cziFile = (argc > 1) ? argv[1] : "/home/mor0146/gitlab/data_project/czi-format/data/CZT-Stack-Anno.czi"; //"/home/mor0146/gitlab/data_project/czi-format/data/m2/exampleSingleChannel.czi";
    if (cziFile == "-v" || cziFile == "--version")
    {
#if DEBUG
        printf("Running `Debug` version\n.");
#else
        printf("Running `Release` version\n.");
#endif
        return 0;
    }

    always_assert(is_file(cziFile));

    std::string method = argc > 2 ? argv[2] : "";
    std::string dumpName = argc > 3 ? argv[3] : "";

    bool report = method == "--report";
    bool reportAll = method == "--report-verbose";
    bool dumpRawImageData = method == "--dump-raw-image-data";
    bool dumpImageData = method == "--dump-images";
    bool nextImageDiff = method == "--diff-next";
    bool testRle = method == "--rle-report";

    auto name = get_filename_without_extension(cziFile);
    auto x = get_files_in_parent_directory(cziFile, true);
    auto y = get_files_with_same_prefix(x, name);

    CziParser parser;
    auto parseResult = parser.parse_czi_file(cziFile);

    if (reportAll)
        parseResult.report_verbose();
    else if (report)
        parseResult.report();
    else if (dumpRawImageData)
    {
        parseResult.dump_image_data(dumpName);
    }
    else if (dumpImageData)
    {
        parseResult.extract_images(dumpName);
    }
    else if (nextImageDiff)
    {
        always_assert(dumpName != "");
        parseResult.differences_between_next(dumpName);
    }
    else if (testRle)
    {
        parseResult.test_rle_encode();
    }

    printf("Finished.\n");
*/
    return 0;
}