#include <Ricom.h>

Collaboration diagram for Ricom:

Public Member Functions
void	draw_ricom_image ()

void	draw_ricom_image (int y0, int ye)

void	draw_stem_image ()

void	draw_stem_image (int y0, int ye)

void	draw_e_field_image ()

void	draw_e_field_image (int y0, int ye)

template<class CameraInterface >
void	run_reconstruction (RICOM::modes mode)

void	reset ()

template<typename T >
void	plot_cbed (std::vector< T > *p_data)

template<typename T , class CameraInterface >
void	process_data (CAMERA::Camera< CameraInterface, CAMERA::FRAME_BASED > *camera)

template<class CameraInterface >
void	process_data (CAMERA::Camera< CameraInterface, CAMERA::EVENT_BASED > *camera)

enum CAMERA::Camera_model	select_mode_by_file (const char *filename)

	Ricom ()

	~Ricom ()

Public Attributes
SocketConnector	socket

std::string	file_path

CAMERA::Camera_BASE	camera

RICOM::modes	mode

bool	b_print2file

int	redraw_interval

int	last_y

ProgressMonitor *	p_prog_mon

bool	b_busy

bool	update_offset

bool	b_vSTEM

bool	b_e_mag

bool	b_plot_cbed

int	cbed_cmap_frames

bool	b_plot2SDL

bool	b_recompute_detector

bool	b_recompute_kernel

Ricom_detector	detector

Ricom_kernel	kernel

std::array< float, 2 >	offset

std::array< float, 2 >	com_public

std::vector< float >	com_map_x

std::vector< float >	com_map_y

std::vector< float >	ricom_data

std::vector< float >	stem_data

std::vector< std::complex< float > >	e_field_data

int	nx

int	ny

int	nxy

int	rep

int	fr_total

int	skip_row

int	skip_img

int	n_threads

int	n_threads_max

int	queue_size

float	fr_freq

float	fr_count

float	fr_count_total

std::atomic< bool >	rescale_ricom

std::atomic< bool >	rescale_stem

std::atomic< bool >	rescale_e_mag

bool	rc_quit

SDL_Surface *	srf_ricom

int	ricom_cmap

SDL_Surface *	srf_stem

int	stem_cmap

SDL_Surface *	srf_cbed

int	cbed_cmap

SDL_Surface *	srf_e_mag

int	e_mag_cmap

Detailed Description

Definition at line 151 of file Ricom.h.

Constructor & Destructor Documentation

◆ Ricom()

Ricom::Ricom ( )

Definition at line 255 of file Ricom.cpp.

             : stem_max(-FLT_MAX), stem_min(FLT_MAX),
                 update_list(),
                 e_mag_max(-FLT_MAX), e_mag_min(FLT_MAX),
                 ricom_max(-FLT_MAX), ricom_min(FLT_MAX),
                 cbed_log(),
                 ricom_mutex(), stem_mutex(), counter_mutex(), e_field_mutex(),
                 socket(), file_path(""),
                 camera(),
                 mode(RICOM::FILE),
                 b_print2file(false),
                 redraw_interval(50),
                 last_y(0),
                 p_prog_mon(nullptr),
                 b_busy(false),
                 update_offset(true),
                 b_vSTEM(false), b_e_mag(false), b_plot_cbed(true), cbed_cmap_frames(1), b_plot2SDL(false),
                 b_recompute_detector(false), b_recompute_kernel(false),
                 detector(),
                 kernel(),
                 offset{127.5, 127.5}, com_public{0.0, 0.0},
                 com_map_x(), com_map_y(),
                 ricom_data(),
                 stem_data(),
                 e_field_data(),
                 nx(256), ny(256), nxy(0),
                 rep(1), fr_total(0),
                 skip_row(1), skip_img(0),
                 n_threads(1), queue_size(64),
                 fr_freq(0.0), fr_count(0.0), fr_count_total(0.0),
                 rescale_ricom(false), rescale_stem(false),
                 rc_quit(false),
                 srf_ricom(NULL), ricom_cmap(9),
                 srf_stem(NULL), stem_cmap(9),
                 srf_cbed(NULL), cbed_cmap(5),
                 srf_e_mag(NULL), e_mag_cmap(12)
{
    n_threads_max = std::thread::hardware_concurrency();
}

◆ ~Ricom()

Ricom::~Ricom ( )

Definition at line 294 of file Ricom.cpp.

294{};

Member Function Documentation

◆ draw_e_field_image() [1/2]

void Ricom::draw_e_field_image ( )

Definition at line 518 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(e_field_mutex);
    for (int y = 0; y < ny; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_e_field_pixel(x, y);
        }
    }
}

◆ draw_e_field_image() [2/2]

void Ricom::draw_e_field_image	(	int	y0,
		int	ye
	)

Definition at line 506 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(e_field_mutex);
    for (int y = y0; y <= ye; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_e_field_pixel(x, y);
        }
    }
}

◆ draw_ricom_image() [1/2]

void Ricom::draw_ricom_image ( )

Definition at line 443 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(ricom_mutex);
    for (int y = 0; y < ny; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_ricom_pixel(x, y);
        }
    }
}

◆ draw_ricom_image() [2/2]

void Ricom::draw_ricom_image	(	int	y0,
		int	ye
	)

Definition at line 456 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(ricom_mutex);
    for (int y = y0; y <= ye; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_ricom_pixel(x, y);
        }
    }
}

◆ draw_stem_image() [1/2]

void Ricom::draw_stem_image ( )

Definition at line 481 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(stem_mutex);
    for (int y = 0; y < ny; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_stem_pixel(x, y);
        }
    }
}

◆ draw_stem_image() [2/2]

void Ricom::draw_stem_image	(	int	y0,
		int	ye
	)

Definition at line 494 of file Ricom.cpp.

{
    std::lock_guard<std::mutex> lock(stem_mutex);
    for (int y = y0; y <= ye; y++)
    {
        for (int x = 0; x < nx; x++)
        {
            set_stem_pixel(x, y);
        }
    }
}

◆ plot_cbed()

template<typename T >

void Ricom::plot_cbed ( std::vector< T > * p_data )

Definition at line 557 of file Ricom.cpp.

{
    float v_min = INFINITY;
    float v_max = 0.0;
 
    for (size_t id = 0; id < (*cbed_data).size(); id++)
    {
        T vl = (*cbed_data)[id];
        swap_endianess(vl);
        float vl_f = log1p((float)vl);
        if (vl_f > v_max)
        {
            v_max = vl_f;
        }
        if (vl_f < v_min)
        {
            v_min = vl_f;
        }
        cbed_log[id] = vl_f;
    }
 
    float v_rng = v_max - v_min;
    for (int iy = 0; iy < camera.ny_cam; iy++)
    {
        int iy_t = camera.v[iy] * camera.nx_cam;
        for (int ix = 0; ix < camera.nx_cam; ix++)
        {
            float vl_f = cbed_log[iy_t + camera.u[ix]];
            float val = (vl_f - v_min) / v_rng;
            SDL_Utils::draw_pixel(srf_cbed, ix, iy, val, cbed_cmap);
        }
    }
}

◆ process_data() [1/2]

template<class CameraInterface >

void Ricom::process_data ( CAMERA::Camera< CameraInterface, CAMERA::EVENT_BASED > * camera )

Definition at line 826 of file Ricom.cpp.

{
    // Memory allocation
    std::vector<size_t> dose_map(nxy);
    std::vector<size_t> sumx_map(nxy);
    std::vector<size_t> sumy_map(nxy);
    std::vector<uint16_t> frame(camera_spec->nx_cam * camera_spec->ny_cam);
    std::vector<uint16_t> *p_frame = &frame;
 
    BoundedThreadPool pool;
 
    // Start Thread Pool
    if (n_threads > 1)
        pool.init(n_threads, queue_size);
 
    std::array<float, 2> com_xy = {0.0, 0.0};
    std::array<float, 2> *p_com_xy = &com_xy;
    std::array<float, 2> com_xy_sum = {0.0, 0.0};
 
    int ix = 0;
    int iy = 0;
    int acc_cbed = 0;
    int acc_idx = 0;
 
    size_t img_num = 0;
    size_t first_frame = img_num * nxy;
    size_t end_frame = (img_num + 1) * nxy;
    size_t fr_total_u = (size_t)fr_total;
 
    ProgressMonitor prog_mon(fr_total, !b_print2file, redraw_interval);
    p_prog_mon = &prog_mon;
 
    dose_map.assign(nxy, 0);
    sumx_map.assign(nxy, 0);
    sumy_map.assign(nxy, 0);
    reinit_vectors_limits();
 
    while (true)
    {
        // Process two frames behind to ensure events are accumulated
        // (The event reader handles out-of-order events with its own margin)
        int idxx = prog_mon.fr_count - nxy * img_num - 2;
 
        ++prog_mon;
        fr_count = prog_mon.fr_count;
 
        if (b_plot_cbed && acc_cbed < cbed_cmap_frames)
        {
            // Reset frame only when starting new accumulation window
            if (acc_cbed == 0)
            {
                frame.assign(camera_spec->nx_cam * camera_spec->ny_cam, 0);
                acc_idx = fr_count;
            }
            camera_spec->read_frame_com_cbed(prog_mon.fr_count,
                                             dose_map, sumx_map, sumy_map,
                                             stem_data, b_vSTEM,
                                             offset, detector.radius2,
                                             frame, acc_idx, cbed_cmap_frames,
                                             first_frame, end_frame);
            acc_cbed++;
        }
        else
        {
            camera_spec->read_frame_com(prog_mon.fr_count,
                                        dose_map, sumx_map, sumy_map,
                                        stem_data, b_vSTEM,
                                        offset, detector.radius2,
                                        first_frame, end_frame);
        }
 
        if (idxx >= 0)
        {
            
            if (dose_map[idxx] == 0)
            {
                com_xy[0] = offset[0];
                com_xy[1] = offset[1];
            }
            else
            {
                // Cast to float before division to preserve fractional precision
                com_xy[0] = static_cast<float>(sumx_map[idxx]) / static_cast<float>(dose_map[idxx]);
                com_xy[1] = static_cast<float>(sumy_map[idxx]) / static_cast<float>(dose_map[idxx]);
            }
            com_map_x[idxx] = com_xy[0];
            com_map_y[idxx] = com_xy[1];
            com_xy_sum[0] += com_xy[0];
            com_xy_sum[1] += com_xy[1];
 
            ix = idxx % nx;
            iy = floor(idxx / nx);
 
            if (n_threads > 1)
            {
                pool.push_task([=]
                               { icom(com_xy, ix, iy); });
            }
            else
            {
                icom(p_com_xy, ix, iy);
            }
            if (b_e_mag)
            {
                compute_electric_field(com_xy, idxx);
            }
        }
 
        if (prog_mon.report_set)
        {
            update_surfaces(iy, p_frame);
            if (b_plot_cbed)
            {
                // Only reset counter - frame will be reset when accumulation starts
                acc_cbed = 0;
            }
            fr_freq = prog_mon.fr_freq;
            rescales_recomputes();
            for (int i = 0; i < 2; i++)
            {
                com_public[i] = com_xy_sum[i] / prog_mon.fr_count_i;
                com_xy_sum[i] = 0;
            }
            prog_mon.reset_flags();
            last_y = iy;
        }
 
        if (prog_mon.fr_count >= end_frame)
        {
            if (prog_mon.fr_count != fr_total_u)
            {
                img_num++;
                first_frame = img_num * nxy;
                end_frame = (img_num + 1) * nxy;
                reinit_vectors_limits();
                dose_map.assign(nxy, 0);
                sumx_map.assign(nxy, 0);
                sumy_map.assign(nxy, 0);
            }
 
            if (update_offset)
            {
                offset[0] = com_public[0];
                offset[1] = com_public[1];
            }
        }
 
        if (prog_mon.fr_count == fr_total_u || rc_quit)
        {
            pool.wait_for_completion();
            p_prog_mon = nullptr;
            return;
        }
    }
    p_prog_mon = nullptr;
}

◆ process_data() [2/2]

template<typename T , class CameraInterface >

void Ricom::process_data ( CAMERA::Camera< CameraInterface, CAMERA::FRAME_BASED > * camera )

Definition at line 743 of file Ricom.cpp.

{
    // Memory allocation
    int cam_xy = camera_spec->nx_cam * camera_spec->ny_cam;
    std::vector<T> data(cam_xy);
    std::vector<T> *p_data = &data;
    BoundedThreadPool pool;
 
    // Start Thread Pool
    if (n_threads > 1)
        pool.init(n_threads, queue_size);
 
    std::array<float, 2> com_xy_sum = {0.0, 0.0};
    std::array<float, 2> *p_com_xy_sum = &com_xy_sum;
 
    // Initialize ProgressMonitor Object
    ProgressMonitor prog_mon(fr_total, !b_print2file, redraw_interval);
    p_prog_mon = &prog_mon;
 
    for (int ir = 0; ir < rep; ir++)
    {
        reinit_vectors_limits();
        for (int iy = 0; iy < ny; iy++)
        {
            for (int ix = 0; ix < nx; ix++)
            {
                camera_spec->read_frame(data, !p_prog_mon->first_frame);
                p_prog_mon->first_frame = false;
                if (n_threads > 1)
                {
                    pool.push_task([=]
                                   { com_icom<T>(data, ix, iy, p_com_xy_sum, p_prog_mon); });
                }
                else
                {
                    com_icom<T>(p_data, ix, iy, p_com_xy_sum, p_prog_mon);
                }
 
                if (rc_quit)
                {
                    pool.wait_for_completion();
                    p_prog_mon = nullptr;
                    return;
                };
            }
            skip_frames(skip_row, data, camera_spec);
        }
        skip_frames(skip_img, data, camera_spec);
 
        if (n_threads > 1)
            pool.wait_for_completion();
 
        if (update_offset)
        {
            offset[0] = com_public[0];
            offset[1] = com_public[1];
        }
    }
    p_prog_mon = nullptr;
}

◆ reset()

void Ricom::reset ( )

Definition at line 1063 of file Ricom.cpp.

{
    rc_quit = false;
    fr_freq = 0;
    reinit_vectors_limits();
}

◆ run_reconstruction()

template<class CameraInterface >

template void Ricom::run_reconstruction< TimepixInterface > ( RICOM::modes mode )

Definition at line 985 of file Ricom.cpp.

{
    reset();
    this->mode = mode;
    b_busy = true;
    // Initializations
    nxy = nx * ny;
    fr_total = nxy * rep;
    fr_count = 0;
 
    camera.init_uv_default();
    init_surface();
 
    if (b_vSTEM)
    {
        detector.compute_detector(camera.nx_cam, camera.ny_cam, offset);
    }
 
    // Compute the integration Kenel
    kernel.compute_kernel();
 
    // Allocate the ricom image and COM arrays
    ricom_data.resize(nxy);
    update_list.init(kernel, nx, ny);
    com_map_x.resize(nxy);
    com_map_y.resize(nxy);
    stem_data.resize(nxy);
    e_field_data.resize(nxy);
 
    // Run camera dependent pipeline
    // Implementations are in the Interface Wrappers (src/cameras/XXXWrapper.cpp), but essentially
    // they run Ricom::process_data<FRAME_BASED>() or Ricom::process_data<EVENT_BASED>()
    switch (camera.type)
    {
    case CAMERA::FRAME_BASED:
    {
        CAMERA::Camera<CameraInterface, CAMERA::FRAME_BASED> camera_interface(camera);
        camera_interface.run(this);
        break;
    }
    case CAMERA::EVENT_BASED:
    {
        CAMERA::Camera<CameraInterface, CAMERA::EVENT_BASED> camera_interface(camera);
        camera_interface.run(this);
        break;
    }
    }
    b_busy = false;
    std::cout << std::endl
              << "Reconstruction finished successfully." << std::endl;
}

◆ select_mode_by_file()

enum CAMERA::Camera_model Ricom::select_mode_by_file ( const char * filename )

Definition at line 1070 of file Ricom.cpp.

{
    file_path = filename;
    if (std::filesystem::path(filename).extension() == ".t3p")
    {
        mode = RICOM::FILE;
        return CAMERA::TIMEPIX;
    }
    else if (std::filesystem::path(filename).extension() == ".mib")
    {
        mode = RICOM::FILE;
        return CAMERA::MERLIN;
    }
    else
    {
        return CAMERA::TIMEPIX;
    }
}

Member Data Documentation

◆ b_busy

bool Ricom::b_busy

Definition at line 224 of file Ricom.h.

◆ b_e_mag

bool Ricom::b_e_mag

Definition at line 227 of file Ricom.h.

◆ b_plot2SDL

bool Ricom::b_plot2SDL

Definition at line 230 of file Ricom.h.

◆ b_plot_cbed

bool Ricom::b_plot_cbed

Definition at line 228 of file Ricom.h.

◆ b_print2file

bool Ricom::b_print2file

Definition at line 220 of file Ricom.h.

◆ b_recompute_detector

bool Ricom::b_recompute_detector

Definition at line 231 of file Ricom.h.

◆ b_recompute_kernel

bool Ricom::b_recompute_kernel

Definition at line 232 of file Ricom.h.

◆ b_vSTEM

bool Ricom::b_vSTEM

Definition at line 226 of file Ricom.h.

◆ camera

CAMERA::Camera_BASE Ricom::camera

Definition at line 218 of file Ricom.h.

◆ cbed_cmap

int Ricom::cbed_cmap

Definition at line 269 of file Ricom.h.

◆ cbed_cmap_frames

int Ricom::cbed_cmap_frames

Definition at line 229 of file Ricom.h.

◆ com_map_x

std::vector<float> Ricom::com_map_x

Definition at line 237 of file Ricom.h.

◆ com_map_y

std::vector<float> Ricom::com_map_y

Definition at line 238 of file Ricom.h.

◆ com_public

std::array<float, 2> Ricom::com_public

Definition at line 236 of file Ricom.h.

◆ detector

Ricom_detector Ricom::detector

Definition at line 233 of file Ricom.h.

◆ e_field_data

std::vector<std::complex<float> > Ricom::e_field_data

Definition at line 241 of file Ricom.h.

◆ e_mag_cmap

int Ricom::e_mag_cmap

Definition at line 271 of file Ricom.h.

◆ file_path

std::string Ricom::file_path

Definition at line 217 of file Ricom.h.

◆ fr_count

float Ricom::fr_count

Definition at line 257 of file Ricom.h.

◆ fr_count_total

float Ricom::fr_count_total

Definition at line 258 of file Ricom.h.

◆ fr_freq

float Ricom::fr_freq

Definition at line 256 of file Ricom.h.

◆ fr_total

int Ricom::fr_total

Definition at line 248 of file Ricom.h.

◆ kernel

Ricom_kernel Ricom::kernel

Definition at line 234 of file Ricom.h.

◆ last_y

int Ricom::last_y

Definition at line 222 of file Ricom.h.

◆ mode

RICOM::modes Ricom::mode

Definition at line 219 of file Ricom.h.

◆ n_threads

int Ricom::n_threads

Definition at line 253 of file Ricom.h.

◆ n_threads_max

int Ricom::n_threads_max

Definition at line 254 of file Ricom.h.

◆ nx

int Ricom::nx

Definition at line 244 of file Ricom.h.

◆ nxy

int Ricom::nxy

Definition at line 246 of file Ricom.h.

◆ ny

int Ricom::ny

Definition at line 245 of file Ricom.h.

◆ offset

std::array<float, 2> Ricom::offset

Definition at line 235 of file Ricom.h.

◆ p_prog_mon

ProgressMonitor* Ricom::p_prog_mon

Definition at line 223 of file Ricom.h.

◆ queue_size

int Ricom::queue_size

Definition at line 255 of file Ricom.h.

◆ rc_quit

bool Ricom::rc_quit

Definition at line 262 of file Ricom.h.

◆ redraw_interval

int Ricom::redraw_interval

Definition at line 221 of file Ricom.h.

◆ rep

int Ricom::rep

Definition at line 247 of file Ricom.h.

◆ rescale_e_mag

std::atomic<bool> Ricom::rescale_e_mag

Definition at line 261 of file Ricom.h.

◆ rescale_ricom

std::atomic<bool> Ricom::rescale_ricom

Definition at line 259 of file Ricom.h.

◆ rescale_stem

std::atomic<bool> Ricom::rescale_stem

Definition at line 260 of file Ricom.h.

◆ ricom_cmap

int Ricom::ricom_cmap

Definition at line 265 of file Ricom.h.

◆ ricom_data

std::vector<float> Ricom::ricom_data

Definition at line 239 of file Ricom.h.

◆ skip_img

int Ricom::skip_img

Definition at line 250 of file Ricom.h.

◆ skip_row

int Ricom::skip_row

Definition at line 249 of file Ricom.h.

◆ socket

SocketConnector Ricom::socket

Definition at line 216 of file Ricom.h.

◆ srf_cbed

SDL_Surface* Ricom::srf_cbed

Definition at line 268 of file Ricom.h.

◆ srf_e_mag

SDL_Surface* Ricom::srf_e_mag

Definition at line 270 of file Ricom.h.

◆ srf_ricom

SDL_Surface* Ricom::srf_ricom

Definition at line 264 of file Ricom.h.

◆ srf_stem

SDL_Surface* Ricom::srf_stem

Definition at line 266 of file Ricom.h.

◆ stem_cmap

int Ricom::stem_cmap

Definition at line 267 of file Ricom.h.

◆ stem_data

std::vector<float> Ricom::stem_data

Definition at line 240 of file Ricom.h.

◆ update_offset

bool Ricom::update_offset

Definition at line 225 of file Ricom.h.

The documentation for this class was generated from the following files:

src/Ricom.h
src/Ricom.cpp

Public Member Functions

Public Attributes