#include <string>
#include "Ricom.h"
#include "Camera.h"

Include dependency graph for main.cpp:

Functions
int	run_cli (int argc, char argv[], Ricom ricom, CAMERA::Default_configurations &hardware_configurations)

int	run_gui (Ricom *ricom, CAMERA::Default_configurations &hardware_configurations)

void	log2file (Ricom *ricom)

std::string	get_os ()

int	main (int argc, char *argv[])

Function Documentation

◆ get_os()

std::string get_os ( )

Definition at line 59 of file main.cpp.

59{return "Unknown"};

◆ log2file()

void log2file ( Ricom * ricom )

Definition at line 83 of file main.cpp.

{
    if (freopen("ricom.log", "a", stdout) == NULL)
    {
        std::cout << "Error redirecting output to log file" << std::endl;
    }
    if (freopen("ricom.log", "a", stderr) == NULL)
    {
        std::cout << "Error redirecting error output to log file" << std::endl;
    }
    ricom->b_print2file = true;
    auto t = std::time(nullptr);
    auto tm = *std::localtime(&t);
    std::cout << std::endl;
    std::cout << "Ricom version " << version << " started at " << std::put_time(&tm, "%d/%m/%Y %H:%M:%S") << std::endl;
    std::cout << "OS: " << get_os() << std::endl;
}

◆ main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 62 of file main.cpp.

{
 
    Ricom ricom;
    CAMERA::Default_configurations hardware_configurations;
 
    if (argc == 1)
    {
#ifdef _WIN32
        FreeConsole();
#endif
        log2file(&ricom);
        return run_gui(&ricom, hardware_configurations);
    }
    else
    {
        return run_cli(argc, argv, &ricom, hardware_configurations);
    }
}

◆ run_cli()

int run_cli	(	int	argc,
		char *	argv[],
		Ricom *	ricom,
		CAMERA::Default_configurations &	hardware_configurations
	)

Definition at line 21 of file RunCLI.cpp.

{
    ricom->b_plot_cbed = false;
    std::string save_img = "";
    std::string save_dat = "";
    
    // command line arguments
    for (int i = 1; i < argc; i++)
    {
        if (i + 1 != argc)
        {
            // Set filename to read from .mib file
            if (strcmp(argv[i], "-filename") == 0)
            {
                ricom->camera = hardware_configurations[ricom->select_mode_by_file(argv[i + 1])];
                i++;
            }
            // Set IP of camera for TCP connection
            if (strcmp(argv[i], "-ip") == 0)
            {
                ricom->socket.ip = argv[i + 1];
                ricom->mode = RICOM::TCP;
                i++;
            }
            // Set port data-read port of camera
            if (strcmp(argv[i], "-port") == 0)
            {
                ricom->socket.port = std::stoi(argv[i + 1]);
                ricom->mode = RICOM::TCP;
                i++;
            }
            // Set width of image
            if (strcmp(argv[i], "-nx") == 0)
            {
                ricom->nx = std::stoi(argv[i + 1]);
                i++;
            }
            // Set height of image
            if (strcmp(argv[i], "-ny") == 0)
            {
                ricom->ny = std::stoi(argv[i + 1]);
                i++;
            }
            // Set width of camera
            if (strcmp(argv[i], "-cam_nx") == 0)
            {
                ricom->camera.nx_cam = std::stoi(argv[i + 1]);
                ricom->offset[0] = ((float)ricom->camera.nx_cam - 1) / 2;
                i++;
            }
            // Set height of camera
            if (strcmp(argv[i], "-cam_ny") == 0)
            {
                ricom->camera.ny_cam = std::stoi(argv[i + 1]);
                ricom->offset[1] = ((float)ricom->camera.ny_cam - 1) / 2;
                i++;
            }
            // Set skip per row
            if (strcmp(argv[i], "-skipr") == 0)
            {
                ricom->skip_row = std::stoi(argv[i + 1]);
                i++;
            }
            // Set skip per image
            if (strcmp(argv[i], "-skipi") == 0)
            {
                ricom->skip_img = std::stoi(argv[i + 1]);
                i++;
            }
            // Set kernel size
            if (strcmp(argv[i], "-k") == 0)
            {
                ricom->kernel.kernel_size = std::stoi(argv[i + 1]);
                i++;
            }
            // Set CBED Rotation
            if (strcmp(argv[i], "-r") == 0)
            {
                ricom->kernel.rotation = std::stof(argv[i + 1]);
                i++;
            }
            // Set CBED center offset
            if (strcmp(argv[i], "-offset") == 0)
            {
                ricom->offset[0] = std::stof(argv[i + 1]);
                i++;
                ricom->offset[1] = std::stof(argv[i + 1]);
                i++;
            }
            // Set CBED center offset
            if (strcmp(argv[i], "-update_offset") == 0)
            {
                ricom->update_offset = (bool)std::stoi(argv[i + 1]);
                i++;
            }
            // Set STEM radii
            if (strcmp(argv[i], "-radius") == 0)
            {
                ricom->b_vSTEM = true;
                ricom->detector.radius[0] = std::stof(argv[i + 1]);
                i++;
                ricom->detector.radius[1] = std::stof(argv[i + 1]);
                i++;
            }
            // Set kernel filter
            if (strcmp(argv[i], "-f") == 0)
            {
                ricom->kernel.b_filter = true;
                ricom->kernel.kernel_filter_frequency[0] = std::stoi(argv[i + 1]);
                i++;
                ricom->kernel.kernel_filter_frequency[1] = std::stoi(argv[i + 1]);
                i++;
            }
            // Set depth of pixel for raw mode
            if (strcmp(argv[i], "-depth") == 0)
            {
                ricom->camera.depth = std::stoi(argv[i + 1]);
                ricom->camera.model = CAMERA::MERLIN;
                i++;
            }
            // Set number of repetitions
            if (strcmp(argv[i], "-rep") == 0)
            {
                ricom->rep = std::stoi(argv[i + 1]);
                i++;
            }
            // Set Dwell Time
            if (strcmp(argv[i], "-dwell_time") == 0)
            {
                ricom->camera.dwell_time = std::stof(argv[i + 1]);
                ricom->camera.model = CAMERA::TIMEPIX;
                i++;
            }
            // Set Number of threads
            if (strcmp(argv[i], "-threads") == 0)
            {
                ricom->n_threads = std::stoi(argv[i + 1]);
                i++;
            }
            // Set Number queue size
            if (strcmp(argv[i], "-queue_size") == 0)
            {
                ricom->queue_size = std::stoi(argv[i + 1]);
                i++;
            }
            // Set redraw interval in ms
            if (strcmp(argv[i], "-redraw_interval") == 0)
            {
                ricom->redraw_interval = std::stoi(argv[i + 1]);
                ricom->b_plot2SDL = true;
                i++;
            }
            // Set path to save reconstruction image
            if (strcmp(argv[i], "-save_img_path") == 0)
            {
                save_img = argv[i + 1];
                ricom->b_plot2SDL = true;
                i++;
            }
            // Set path to save reconstruction data
            if (strcmp(argv[i], "-save_data_path") == 0)
            {
                save_dat = argv[i + 1];
                i++;
            }
            // plot electric field
            if (strcmp(argv[i], "-plot_e_field") == 0)
            {
                ricom->b_e_mag = (bool)std::stoi(argv[i + 1]);
                i++;
            }
        }
    }
 
    if (ricom->b_plot2SDL)
    {
        std::vector<SdlImageWindow> image_windows;
        std::thread run_thread;
        run_thread = std::thread(RICOM::run_ricom, ricom, ricom->mode);
        while (ricom->srf_ricom == NULL)
        {
            SDL_Delay(ricom->redraw_interval);
        }
 
        run_thread.detach();
 
        // // Initializing SDL
        SDL_DisplayMode DM; // To get the current display size
        SDL_Event event;    // Event variable
 
        SDL_Init(SDL_INIT_EVERYTHING);
        SDL_GetCurrentDisplayMode(0, &DM);
        float scale = (std::min)(((float)DM.w) / ricom->nx, ((float)DM.h) / ricom->ny) * 0.8;
        bool b_redraw = false;
        image_windows.push_back(SdlImageWindow("riCOM", ricom->srf_ricom, ricom->nx, ricom->ny, scale));
        if (ricom->b_vSTEM)
        {
            image_windows.push_back(SdlImageWindow("vSTEM", ricom->srf_stem, ricom->nx, ricom->ny, scale));
        }
        if (ricom->b_e_mag)
        {
            image_windows.push_back(SdlImageWindow("E-Field", ricom->srf_e_mag, ricom->nx, ricom->ny, scale));
        }
 
        bool b_open_window = true;
        while (b_open_window)
        {
            if (ricom->p_prog_mon != nullptr)
            {
                if (ricom->p_prog_mon->report_set_public)
                {
                    b_redraw = true;
                    ricom->p_prog_mon->report_set_public = false;
                }
                else
                {
                    b_redraw = true;
                }
            }
 
            if (b_redraw)
            {
                for (auto &wnd : image_windows)
                {
                    wnd.update_image();
                }
            }
 
            while (SDL_PollEvent(&event))
            {
                if (event.type == SDL_QUIT ||
                    (event.type == SDL_WINDOWEVENT &&
                     event.window.event == SDL_WINDOWEVENT_CLOSE))
                {
                    ricom->rc_quit = true;
                    SDL_Delay(ricom->redraw_interval);
                    b_open_window = false;
                }
            }
        }
    }
    else
    {
        RICOM::run_ricom(ricom, ricom->mode);
    }
    if (save_dat != "")
    {
        save_numpy(&save_dat, ricom->nx, ricom->ny, &ricom->ricom_data);
        std::cout << "riCOM reconstruction data saved as " + save_dat << std::endl;
    }
    if (save_img != "")
    {
        save_image(&save_img, ricom->srf_ricom);
        std::cout << "riCOM reconstruction image saved as " + save_img << std::endl;
    }
    return 0;
}

◆ run_gui()

int run_gui	(	Ricom *	ricom,
		CAMERA::Default_configurations &	hardware_configurations
	)

Definition at line 68 of file RunGUI.cpp.