riCOM_cpp
This repository contains the C++ implementation of the riCOM (Real Time Centre Of Mass) algorithm for 4D Scanning electron microscopy.
Public Member Functions | Public Attributes | List of all members
Ricom Class Reference

#include <Ricom.h>

Collaboration diagram for Ricom:
[legend]

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
 
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.

255  : stem_max(-FLT_MAX), stem_min(FLT_MAX),
256  update_list(),
257  e_mag_max(-FLT_MAX), e_mag_min(FLT_MAX),
258  ricom_max(-FLT_MAX), ricom_min(FLT_MAX),
259  cbed_log(),
260  ricom_mutex(), stem_mutex(), counter_mutex(), e_field_mutex(),
261  socket(), file_path(""),
262  camera(),
263  mode(RICOM::FILE),
264  b_print2file(false),
265  redraw_interval(50),
266  last_y(0),
267  p_prog_mon(nullptr),
268  b_busy(false),
269  update_offset(true),
270  b_vSTEM(false), b_e_mag(false), b_plot_cbed(true), b_plot2SDL(false),
271  b_recompute_detector(false), b_recompute_kernel(false),
272  detector(),
273  kernel(),
274  offset{127.5, 127.5}, com_public{0.0, 0.0},
275  com_map_x(), com_map_y(),
276  ricom_data(),
277  stem_data(),
278  e_field_data(),
279  nx(256), ny(256), nxy(0),
280  rep(1), fr_total(0),
281  skip_row(1), skip_img(0),
282  n_threads(1), queue_size(64),
283  fr_freq(0.0), fr_count(0.0), fr_count_total(0.0),
284  rescale_ricom(false), rescale_stem(false),
285  rc_quit(false),
286  srf_ricom(NULL), ricom_cmap(9),
287  srf_stem(NULL), stem_cmap(9),
288  srf_cbed(NULL), cbed_cmap(5),
289  srf_e_mag(NULL), e_mag_cmap(12)
290 {
291  n_threads_max = std::thread::hardware_concurrency();
292 }
Ricom::skip_img
int skip_img
Definition: Ricom.h:249
Ricom::com_public
std::array< float, 2 > com_public
Definition: Ricom.h:235
Ricom::socket
SocketConnector socket
Definition: Ricom.h:216
Ricom::nxy
int nxy
Definition: Ricom.h:245
Ricom::redraw_interval
int redraw_interval
Definition: Ricom.h:221
Ricom::last_y
int last_y
Definition: Ricom.h:222
Ricom::b_busy
bool b_busy
Definition: Ricom.h:224
Ricom::cbed_cmap
int cbed_cmap
Definition: Ricom.h:268
Ricom::b_recompute_detector
bool b_recompute_detector
Definition: Ricom.h:230
Ricom::e_mag_cmap
int e_mag_cmap
Definition: Ricom.h:270
Ricom::n_threads
int n_threads
Definition: Ricom.h:252
Ricom::stem_data
std::vector< float > stem_data
Definition: Ricom.h:239
Ricom::rep
int rep
Definition: Ricom.h:246
Ricom::update_offset
bool update_offset
Definition: Ricom.h:225
Ricom::b_plot2SDL
bool b_plot2SDL
Definition: Ricom.h:229
Ricom::ricom_data
std::vector< float > ricom_data
Definition: Ricom.h:238
Ricom::srf_e_mag
SDL_Surface * srf_e_mag
Definition: Ricom.h:269
Ricom::mode
RICOM::modes mode
Definition: Ricom.h:219
Ricom::rescale_ricom
std::atomic< bool > rescale_ricom
Definition: Ricom.h:258
Ricom::fr_count_total
float fr_count_total
Definition: Ricom.h:257
Ricom::n_threads_max
int n_threads_max
Definition: Ricom.h:253
Ricom::fr_count
float fr_count
Definition: Ricom.h:256
Ricom::e_field_data
std::vector< std::complex< float > > e_field_data
Definition: Ricom.h:240
Ricom::file_path
std::string file_path
Definition: Ricom.h:217
Ricom::nx
int nx
Definition: Ricom.h:243
Ricom::detector
Ricom_detector detector
Definition: Ricom.h:232
Ricom::rc_quit
bool rc_quit
Definition: Ricom.h:261
Ricom::queue_size
int queue_size
Definition: Ricom.h:254
Ricom::b_e_mag
bool b_e_mag
Definition: Ricom.h:227
Ricom::srf_ricom
SDL_Surface * srf_ricom
Definition: Ricom.h:263
Ricom::srf_cbed
SDL_Surface * srf_cbed
Definition: Ricom.h:267
Ricom::fr_total
int fr_total
Definition: Ricom.h:247
Ricom::com_map_x
std::vector< float > com_map_x
Definition: Ricom.h:236
Ricom::p_prog_mon
ProgressMonitor * p_prog_mon
Definition: Ricom.h:223
Ricom::ricom_cmap
int ricom_cmap
Definition: Ricom.h:264
Ricom::b_plot_cbed
bool b_plot_cbed
Definition: Ricom.h:228
Ricom::fr_freq
float fr_freq
Definition: Ricom.h:255
Ricom::srf_stem
SDL_Surface * srf_stem
Definition: Ricom.h:265
Ricom::b_recompute_kernel
bool b_recompute_kernel
Definition: Ricom.h:231
Ricom::com_map_y
std::vector< float > com_map_y
Definition: Ricom.h:237
Ricom::camera
CAMERA::Camera_BASE camera
Definition: Ricom.h:218
Ricom::skip_row
int skip_row
Definition: Ricom.h:248
Ricom::b_vSTEM
bool b_vSTEM
Definition: Ricom.h:226
Ricom::ny
int ny
Definition: Ricom.h:244
Ricom::b_print2file
bool b_print2file
Definition: Ricom.h:220
Ricom::offset
std::array< float, 2 > offset
Definition: Ricom.h:234
Ricom::rescale_stem
std::atomic< bool > rescale_stem
Definition: Ricom.h:259
Ricom::stem_cmap
int stem_cmap
Definition: Ricom.h:266
Ricom::kernel
Ricom_kernel kernel
Definition: Ricom.h:233
RICOM::FILE
@ FILE
Definition: Ricom.h:144

◆ ~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.

519 {
520  std::lock_guard<std::mutex> lock(e_field_mutex);
521  for (int y = 0; y < ny; y++)
522  {
523  for (int x = 0; x < nx; x++)
524  {
525  set_e_field_pixel(x, y);
526  }
527  }
528 }

◆ draw_e_field_image() [2/2]

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

Definition at line 506 of file Ricom.cpp.

507 {
508  std::lock_guard<std::mutex> lock(e_field_mutex);
509  for (int y = y0; y <= ye; y++)
510  {
511  for (int x = 0; x < nx; x++)
512  {
513  set_e_field_pixel(x, y);
514  }
515  }
516 }

◆ draw_ricom_image() [1/2]

void Ricom::draw_ricom_image ( )

Definition at line 443 of file Ricom.cpp.

444 {
445  std::lock_guard<std::mutex> lock(ricom_mutex);
446  for (int y = 0; y < ny; y++)
447  {
448  for (int x = 0; x < nx; x++)
449  {
450  set_ricom_pixel(x, y);
451  }
452  }
453 }

◆ draw_ricom_image() [2/2]

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

Definition at line 456 of file Ricom.cpp.

457 {
458  std::lock_guard<std::mutex> lock(ricom_mutex);
459  for (int y = y0; y <= ye; y++)
460  {
461  for (int x = 0; x < nx; x++)
462  {
463  set_ricom_pixel(x, y);
464  }
465  }
466 }

◆ draw_stem_image() [1/2]

void Ricom::draw_stem_image ( )

Definition at line 481 of file Ricom.cpp.

482 {
483  std::lock_guard<std::mutex> lock(stem_mutex);
484  for (int y = 0; y < ny; y++)
485  {
486  for (int x = 0; x < nx; x++)
487  {
488  set_stem_pixel(x, y);
489  }
490  }
491 }

◆ draw_stem_image() [2/2]

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

Definition at line 494 of file Ricom.cpp.

495 {
496  std::lock_guard<std::mutex> lock(stem_mutex);
497  for (int y = y0; y <= ye; y++)
498  {
499  for (int x = 0; x < nx; x++)
500  {
501  set_stem_pixel(x, y);
502  }
503  }
504 }

◆ plot_cbed()

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

Definition at line 557 of file Ricom.cpp.

558 {
559  float v_min = INFINITY;
560  float v_max = 0.0;
561 
562  for (size_t id = 0; id < (*cbed_data).size(); id++)
563  {
564  T vl = (*cbed_data)[id];
565  swap_endianess(vl);
566  float vl_f = log1p((float)vl);
567  if (vl_f > v_max)
568  {
569  v_max = vl_f;
570  }
571  if (vl_f < v_min)
572  {
573  v_min = vl_f;
574  }
575  cbed_log[id] = vl_f;
576  }
577 
578  float v_rng = v_max - v_min;
579  for (int ix = 0; ix < camera.ny_cam; ix++)
580  {
581  int iy_t = camera.v[ix] * camera.nx_cam;
582  for (int iy = 0; iy < camera.nx_cam; iy++)
583  {
584  float vl_f = cbed_log[iy_t + camera.u[iy]];
585  float val = (vl_f - v_min) / v_rng;
586  SDL_Utils::draw_pixel(srf_cbed, ix, iy, val, cbed_cmap);
587  }
588  }
589 }
CAMERA::Camera_BASE::ny_cam
int ny_cam
Definition: Camera.h:46
CAMERA::Camera_BASE::nx_cam
int nx_cam
Definition: Camera.h:45
CAMERA::Camera_BASE::v
std::vector< int > v
Definition: Camera.h:51
CAMERA::Camera_BASE::u
std::vector< int > u
Definition: Camera.h:50
SDL_Utils::draw_pixel
void draw_pixel(SDL_Surface *surface, int x, int y, float val, int col_map)
Definition: GuiUtils.cpp:97

◆ 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.

827 {
828  // Memory allocation
829  std::vector<size_t> dose_map(nxy);
830  std::vector<size_t> sumx_map(nxy);
831  std::vector<size_t> sumy_map(nxy);
832  std::vector<uint16_t> frame(camera_spec->nx_cam * camera_spec->ny_cam);
833  std::vector<uint16_t> *p_frame = &frame;
834 
835  BoundedThreadPool pool;
836 
837  // Start Thread Pool
838  if (n_threads > 1)
839  pool.init(n_threads, queue_size);
840 
841  std::array<float, 2> com_xy = {0.0, 0.0};
842  std::array<float, 2> *p_com_xy = &com_xy;
843  std::array<float, 2> com_xy_sum = {0.0, 0.0};
844 
845  int ix = 0;
846  int iy = 0;
847  int acc_cbed = 0;
848  int acc_idx = 0;
849 
850  size_t img_num = 0;
851  size_t first_frame = img_num * nxy;
852  size_t end_frame = (img_num + 1) * nxy;
853  size_t fr_total_u = (size_t)fr_total;
854 
855  ProgressMonitor prog_mon(fr_total, !b_print2file, redraw_interval);
856  p_prog_mon = &prog_mon;
857 
858  dose_map.assign(nxy, 0);
859  sumx_map.assign(nxy, 0);
860  sumy_map.assign(nxy, 0);
861  reinit_vectors_limits();
862 
863  while (true)
864  {
865  // process two frames before the probe position to avoid toa problem
866  int idxx = prog_mon.fr_count - nxy * img_num - 2;
867 
868  ++prog_mon;
869  fr_count = prog_mon.fr_count;
870 
871  if (acc_cbed < 3 && b_plot_cbed)
872  {
873  camera_spec->read_frame_com_cbed(prog_mon.fr_count,
874  dose_map, sumx_map, sumy_map,
875  stem_data, b_vSTEM,
876  offset, detector.radius2,
877  frame, acc_idx,
878  first_frame, end_frame);
879  acc_cbed += 1;
880  }
881  else
882  {
883  camera_spec->read_frame_com(prog_mon.fr_count,
884  dose_map, sumx_map, sumy_map,
885  stem_data, b_vSTEM,
886  offset, detector.radius2,
887  first_frame, end_frame);
888  }
889 
890  if (idxx >= 0)
891  {
892  if (dose_map[idxx] == 0)
893  {
894  com_xy[0] = offset[0];
895  com_xy[1] = offset[1];
896  }
897  else
898  {
899  com_xy[0] = sumx_map[idxx] / dose_map[idxx];
900  com_xy[1] = sumy_map[idxx] / dose_map[idxx];
901  }
902  com_map_x[idxx] = com_xy[0];
903  com_map_y[idxx] = com_xy[1];
904  com_xy_sum[0] += com_xy[0];
905  com_xy_sum[1] += com_xy[1];
906 
907  ix = idxx % nx;
908  iy = floor(idxx / nx);
909 
910  if (n_threads > 1)
911  {
912  pool.push_task([=]
913  { icom(com_xy, ix, iy); });
914  }
915  else
916  {
917  icom(p_com_xy, ix, iy);
918  }
919  if (b_e_mag)
920  {
921  compute_electric_field(com_xy, idxx);
922  }
923  }
924 
925  if (prog_mon.report_set)
926  {
927  update_surfaces(iy, p_frame);
928  if (b_plot_cbed)
929  {
930  frame.assign(camera_spec->nx_cam * camera_spec->ny_cam, 0);
931  acc_cbed = 0;
932  acc_idx = fr_count;
933  }
934  fr_freq = prog_mon.fr_freq;
935  rescales_recomputes();
936  for (int i = 0; i < 2; i++)
937  {
938  com_public[i] = com_xy_sum[i] / prog_mon.fr_count_i;
939  com_xy_sum[i] = 0;
940  }
941  prog_mon.reset_flags();
942  last_y = iy;
943  }
944 
945  if (prog_mon.fr_count >= end_frame)
946  {
947  if (prog_mon.fr_count != fr_total_u)
948  {
949  img_num++;
950  first_frame = img_num * nxy;
951  end_frame = (img_num + 1) * nxy;
952  reinit_vectors_limits();
953  dose_map.assign(nxy, 0);
954  sumx_map.assign(nxy, 0);
955  sumy_map.assign(nxy, 0);
956  }
957 
958  if (update_offset)
959  {
960  offset[0] = com_public[0];
961  offset[1] = com_public[1];
962  }
963  }
964 
965  if (prog_mon.fr_count == fr_total_u || rc_quit)
966  {
967  pool.wait_for_completion();
968  p_prog_mon = nullptr;
969  return;
970  }
971  }
972  p_prog_mon = nullptr;
973 }
BoundedThreadPool::init
void init(int n_threads, int limit)
Definition: BoundedThreadPool.hpp:108
BoundedThreadPool::push_task
void push_task(const T &task)
Definition: BoundedThreadPool.hpp:77
Ricom_detector::radius2
std::array< float, 2 > radius2
Definition: Ricom.h:129

◆ 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.

744 {
745  // Memory allocation
746  int cam_xy = camera_spec->nx_cam * camera_spec->ny_cam;
747  std::vector<T> data(cam_xy);
748  std::vector<T> *p_data = &data;
749  BoundedThreadPool pool;
750 
751  // Start Thread Pool
752  if (n_threads > 1)
753  pool.init(n_threads, queue_size);
754 
755  std::array<float, 2> com_xy_sum = {0.0, 0.0};
756  std::array<float, 2> *p_com_xy_sum = &com_xy_sum;
757 
758  // Initialize ProgressMonitor Object
759  ProgressMonitor prog_mon(fr_total, !b_print2file, redraw_interval);
760  p_prog_mon = &prog_mon;
761 
762  for (int ir = 0; ir < rep; ir++)
763  {
764  reinit_vectors_limits();
765  for (int iy = 0; iy < ny; iy++)
766  {
767  for (int ix = 0; ix < nx; ix++)
768  {
769  camera_spec->read_frame(data, !p_prog_mon->first_frame);
770  p_prog_mon->first_frame = false;
771  if (n_threads > 1)
772  {
773  pool.push_task([=]
774  { com_icom<T>(data, ix, iy, p_com_xy_sum, p_prog_mon); });
775  }
776  else
777  {
778  com_icom<T>(p_data, ix, iy, p_com_xy_sum, p_prog_mon);
779  }
780 
781  if (rc_quit)
782  {
783  pool.wait_for_completion();
784  p_prog_mon = nullptr;
785  return;
786  };
787  }
788  skip_frames(skip_row, data, camera_spec);
789  }
790  skip_frames(skip_img, data, camera_spec);
791 
792  if (n_threads > 1)
793  pool.wait_for_completion();
794 
795  if (update_offset)
796  {
797  offset[0] = com_public[0];
798  offset[1] = com_public[1];
799  }
800  }
801  p_prog_mon = nullptr;
802 }

◆ reset()

void Ricom::reset ( )

Definition at line 1055 of file Ricom.cpp.

1056 {
1057  rc_quit = false;
1058  fr_freq = 0;
1059  reinit_vectors_limits();
1060 }

◆ run_reconstruction()

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

Definition at line 977 of file Ricom.cpp.

978 {
979  reset();
980  this->mode = mode;
981  b_busy = true;
982  // Initializations
983  nxy = nx * ny;
984  fr_total = nxy * rep;
985  fr_count = 0;
986 
987  camera.init_uv_default();
988  init_surface();
989 
990  if (b_vSTEM)
991  {
992  detector.compute_detector(camera.nx_cam, camera.ny_cam, offset);
993  }
994 
995  // Compute the integration Kenel
996  kernel.compute_kernel();
997 
998  // Allocate the ricom image and COM arrays
999  ricom_data.resize(nxy);
1000  update_list.init(kernel, nx, ny);
1001  com_map_x.resize(nxy);
1002  com_map_y.resize(nxy);
1003  stem_data.resize(nxy);
1004  e_field_data.resize(nxy);
1005 
1006  // Run camera dependent pipeline
1007  // Implementations are in the Interface Wrappers (src/cameras/XXXWrapper.cpp), but essentially
1008  // they run Ricom::process_data<FRAME_BASED>() or Ricom::process_data<EVENT_BASED>()
1009  switch (camera.type)
1010  {
1011  case CAMERA::FRAME_BASED:
1012  {
1013  CAMERA::Camera<CameraInterface, CAMERA::FRAME_BASED> camera_interface(camera);
1014  camera_interface.run(this);
1015  break;
1016  }
1017  case CAMERA::EVENT_BASED:
1018  {
1019  CAMERA::Camera<CameraInterface, CAMERA::EVENT_BASED> camera_interface(camera);
1020  camera_interface.run(this);
1021  break;
1022  }
1023  }
1024  b_busy = false;
1025  std::cout << std::endl
1026  << "Reconstruction finished successfully." << std::endl;
1027 }
CAMERA::Camera_BASE::type
Camera_type type
Definition: Camera.h:44
CAMERA::Camera_BASE::init_uv_default
void init_uv_default()
Definition: Camera.cpp:20
Ricom_detector::compute_detector
void compute_detector(int nx_cam, int ny_cam, std::array< float, 2 > &offset)
Definition: Ricom.cpp:159
Ricom_kernel::compute_kernel
void compute_kernel()
Definition: Ricom.cpp:21
Ricom::reset
void reset()
Definition: Ricom.cpp:1055
Update_list::init
void init(Ricom_kernel kernel, int nx_ricom, int ny_ricom)
Definition: Ricom.cpp:190
CAMERA::FRAME_BASED
@ FRAME_BASED
Definition: Camera.h:36
CAMERA::EVENT_BASED
@ EVENT_BASED
Definition: Camera.h:37

◆ select_mode_by_file()

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

Definition at line 1055 of file Ricom.cpp.

1063 {
1064  file_path = filename;
1065  if (std::filesystem::path(filename).extension() == ".t3p")
1066  {
1067  mode = RICOM::FILE;
1068  return CAMERA::TIMEPIX;
1069  }
1070  else if (std::filesystem::path(filename).extension() == ".mib")
1071  {
1072  mode = RICOM::FILE;
1073  return CAMERA::MERLIN;
1074  }
1075  else
1076  {
1077  return CAMERA::TIMEPIX;
1078  }
1079 }
CAMERA::TIMEPIX
@ TIMEPIX
Definition: Camera.h:30
CAMERA::MERLIN
@ MERLIN
Definition: Camera.h:29

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 229 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 230 of file Ricom.h.

◆ b_recompute_kernel

bool Ricom::b_recompute_kernel

Definition at line 231 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 268 of file Ricom.h.

◆ com_map_x

std::vector<float> Ricom::com_map_x

Definition at line 236 of file Ricom.h.

◆ com_map_y

std::vector<float> Ricom::com_map_y

Definition at line 237 of file Ricom.h.

◆ com_public

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

Definition at line 235 of file Ricom.h.

◆ detector

Ricom_detector Ricom::detector

Definition at line 232 of file Ricom.h.

◆ e_field_data

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

Definition at line 240 of file Ricom.h.

◆ e_mag_cmap

int Ricom::e_mag_cmap

Definition at line 270 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 256 of file Ricom.h.

◆ fr_count_total

float Ricom::fr_count_total

Definition at line 257 of file Ricom.h.

◆ fr_freq

float Ricom::fr_freq

Definition at line 255 of file Ricom.h.

◆ fr_total

int Ricom::fr_total

Definition at line 247 of file Ricom.h.

◆ kernel

Ricom_kernel Ricom::kernel

Definition at line 233 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 252 of file Ricom.h.

◆ n_threads_max

int Ricom::n_threads_max

Definition at line 253 of file Ricom.h.

◆ nx

int Ricom::nx

Definition at line 243 of file Ricom.h.

◆ nxy

int Ricom::nxy

Definition at line 245 of file Ricom.h.

◆ ny

int Ricom::ny

Definition at line 244 of file Ricom.h.

◆ offset

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

Definition at line 234 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 254 of file Ricom.h.

◆ rc_quit

bool Ricom::rc_quit

Definition at line 261 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 246 of file Ricom.h.

◆ rescale_e_mag

std::atomic<bool> Ricom::rescale_e_mag

Definition at line 260 of file Ricom.h.

◆ rescale_ricom

std::atomic<bool> Ricom::rescale_ricom

Definition at line 258 of file Ricom.h.

◆ rescale_stem

std::atomic<bool> Ricom::rescale_stem

Definition at line 259 of file Ricom.h.

◆ ricom_cmap

int Ricom::ricom_cmap

Definition at line 264 of file Ricom.h.

◆ ricom_data

std::vector<float> Ricom::ricom_data

Definition at line 238 of file Ricom.h.

◆ skip_img

int Ricom::skip_img

Definition at line 249 of file Ricom.h.

◆ skip_row

int Ricom::skip_row

Definition at line 248 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 267 of file Ricom.h.

◆ srf_e_mag

SDL_Surface* Ricom::srf_e_mag

Definition at line 269 of file Ricom.h.

◆ srf_ricom

SDL_Surface* Ricom::srf_ricom

Definition at line 263 of file Ricom.h.

◆ srf_stem

SDL_Surface* Ricom::srf_stem

Definition at line 265 of file Ricom.h.

◆ stem_cmap

int Ricom::stem_cmap

Definition at line 266 of file Ricom.h.

◆ stem_data

std::vector<float> Ricom::stem_data

Definition at line 239 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:
Generated by doxygen 1.9.1