MTF
parameters.h
1 #ifndef MTF_PARAMETERS_H
2 #define MTF_PARAMETERS_H
3 
4 //#include <cstddef>
5 #include <stdio.h>
6 #include <stdlib.h>
7 #include <vector>
8 #include <iostream>
9 
10 #include "boost/filesystem/operations.hpp"
11 #include "opencv2/core/core.hpp"
12 
13 #include "mtf/Macros/common.h"
14 #include "datasets.h"
15 
16 namespace fs = boost::filesystem;
17 
18 #define VID_FNAME "nl_bookI_s3"
19 #define VID_FMT "mpg"
20 
21 #define IMG_FOLDER "nl_bookI_s3"
22 #define IMG_FMT "jpg"
23 
24 #define ROOT_FOLDER "../../Datasets/TMT"
25 
26 #define FW_DEV_NAME "firewire_cam"
27 #define FW_DEV_PATH "/dev/fw1"
28 #define FW_DEV_FMT "i1V1f7o3r150"
29 
30 #define USB_DEV_NAME "usb_cam"
31 #define USB_DEV_PATH "/dev/video0"
32 #define USB_DEV_FMT "I1B4r0N0"
33 
34 #define CV_CAM_ID 0
35 
36 #define CASCADE_MAX_TRACKERS 10
37 #define MAX_ABS_PATH 500
38 
39 #define parse_param(param_name, param_func)\
40  do{if(!strcmp(arg_name, #param_name)){\
41  param_name = param_func(arg_val);\
42  return;\
43  }} while(0)
44 #define parse_param_vec(param_name, param_func)\
45  do{if(!strcmp(arg_name, #param_name)){\
46  param_name.push_back(param_func(arg_val));\
47  return;\
48  }} while(0)
49 
50 #define parse_cfg(fname) \
51  fargc = readParams(fargv, (config_dir + "/" + fname).c_str());\
52  if(fargc){\
53  if(!parseArgumentPairs(fargv.data(), fargc)){\
54  printf("Error in parsing %s\n", fname);\
55  return false;\
56  }\
57  fargv.clear();\
58  }
59 
60 #define atof32(x) static_cast<float>(atof(x))
61 
62 namespace mtf{
63  namespace params{
64  // folder where the config files mtf.cfg, modules.cfg and multi.cfg are located
65  std::string config_dir = "Config";
66 
67  /* default parameters */
68  int seq_id = 0;
69  int actor_id = 0;
70  std::string db_root_path = "../../../Datasets";
71  std::string actor;
72  std::string seq_path;
73  std::string seq_name;
74  std::string seq_fmt;
75  bool invert_seq = false;
76  unsigned int n_trackers = 1;
77  bool track_single_obj = false;
78  char pipeline = 'c';
79  char img_source = 'j';
80  double img_resize_factor = 1.0;
81  int input_buffer_size = 10;
82  int buffer_id = 0;
83 
85  int mtf_visualize = 1;
86  int pause_after_frame = 0;
87  bool print_corners = false;
88  bool print_fps = false;
89  int show_corner_ids = 0;
90  int show_ground_truth = 0;
91  int reinit_gt_from_bin = 1;
92  int read_obj_from_file = 0;
93  int read_obj_from_gt = 1;
94  bool sel_quad_obj = false;
95  int line_thickness = 2;
96  int record_frames = 0;
97  bool gt_write_ssm_params = false;
98  int write_tracking_data = 0;
99  bool overwrite_gt = 0;
100  int show_proc_img = 0;
101  int write_objs = 0;
102  char rec_source = 'u';
103  std::string rec_seq_suffix;
104  int rec_fps = 24;
105  std::vector<std::string> tracker_labels;
106 
107  int reinit_at_each_frame = 0;
108  int reset_at_each_frame = 0;
109  bool reset_to_init = false;
110  int reinit_on_failure = false;
111  double reinit_err_thresh = 5.0;
112  int reinit_frame_skip = 5;
113  bool reinit_with_new_obj = false;
114 
115  bool use_reinit_gt = false;
116  bool use_opt_gt = false;
117  std::string opt_gt_ssm = "2";
118  int debug_mode = 0;
119  int reset_template = 0;
120  int patch_size = 0;
121 
122  std::string read_obj_fname = "sel_objs/selected_objects.txt";
123  std::string write_obj_fname = "sel_objs/selected_objects.txt";
124  std::string tracking_data_fname;
125  std::string record_frames_fname, record_frames_dir;
126 
128  int xv_visualize = 0;
129  int xv_steps_per_frame = 1;
130  /* only for pyramidal trackers */
131  int xv_no_of_levels = 2;
132  double xv_scale = 0.5;
133  /* for xvision grid tracker */
134  int xv_patch_size = 32;
135  int xv_tracker_type = 't';
136  int xvg_grid_size_x = 4;
137  int xvg_grid_size_y = -1;
138  int xvg_reset_pos = 0;
139  int xvg_reset_wts = 0;
140  double xvg_sel_reset_thresh = 1.0;
141  int xvg_pause_after_line = 0;
142  int xvg_show_tracked_pts = 0;
143  int xvg_use_constant_slope = 0;
144  int xvg_use_ls = 0;
145  int xvg_update_wts = 0;
146  double xvg_inter_alpha_thresh = 0.10;
147  double xvg_intra_alpha_thresh = 0.05;
148  int xvg_adjust_grid = 0;
149  int xvg_adjust_lines = 1;
150 
152  unsigned int mtf_res = 50;
153  unsigned int resx = 50;
154  unsigned int resy = 50;
155  int init_frame_id = 0;
156  int start_frame_id = 0;
157  int end_frame_id = 0;
158  int frame_gap = 1;
159  int max_iters = 10;
160  double epsilon = 0.01;
161  char* mtf_sm = "esm";
162  char* mtf_am = "ssd";
163  char* mtf_ssm = "8";
164  char* mtf_ilm = "0";
165  bool enable_nt = false;
166  bool invalid_state_check = true;
167  double invalid_state_err_thresh = 0;
168  bool uchar_input = false;
169 
170  bool ic_update_ssm = true;
171  bool ic_chained_warp = true;
172  int ic_hess_type = 0;
173 
174  bool fc_chained_warp = false;
175  int fc_hess_type = 1;
176  bool fc_write_ssm_updates = false;
177  bool fc_show_grid = false;
178  bool fc_show_patch = false;
179  double fc_patch_resize_factor = 1.0;
180  bool fc_debug_mode = false;
181 
182  int fa_hess_type = 1;
183  bool fa_show_grid = false;
184  bool fa_show_patch = false;
185  double fa_patch_resize_factor = 1.0;
186  bool fa_write_frames = false;
187 
188  int ia_hess_type = 1;
189 
190  int esm_jac_type = 1;
191  int esm_hess_type = 2;
192  bool esm_chained_warp = false;
193 
194  bool sec_ord_hess = false;
195  bool leven_marq = false;
196  double lm_delta_init = 0.01;
197  double lm_delta_update = 10;
198 
199  bool enable_learning = false;
200  double learning_rate = 0.5;
201 
202 
203  bool ssd_show_template = false;
204 
205  double nssd_norm_pix_min = 0.0;
206  double nssd_norm_pix_max = 1.0;
207 
208  double zncc_likelihood_alpha = 50;
209 
210  double res_from_size = 0;
211  int show_tracking_error = 0;
212  int write_tracking_error = 0;
213  int write_tracking_sr = 0;
214  vectord sr_err_thresh;
215 
216  vector_s obj_cols;
217  std::string fps_col = "green";
218  std::string gt_col = "green";
219  std::string err_col = "green";
220 
221  int tracking_err_type = 0;
222  bool show_jaccard_error = false;
223  double grad_eps = 1e-8;
224  double hess_eps = 1.0;
225  double likelihood_alpha = 1.0;
226  double likelihood_beta = 0.0;
227  bool dist_from_likelihood = false;
228 
229  std::string pre_proc_type = "gauss";
231  bool pre_proc_hist_eq = false;
233  int gauss_kernel_size = 5;
234  double gauss_sigma_x = 3;
235  double gauss_sigma_y = 3;
237  int med_kernel_size = 5;
239  int box_kernel_size = 5;
241  int bil_diameter = 5;
242  double bil_sigma_col = 15;
243  double bil_sigma_space = 15;
245  int sobel_kernel_size = 5;
246  bool sobel_normalize = false;
248  double aniso_lambda = 0.14285714285;
249  double aniso_kappa = 30;
250  unsigned int aniso_n_iters = 15;
251 
253  int aff_normalized_init = 0;
254  int aff_pt_based_sampling = 0;
255 
257  int laff_normalized_init = 0;
258  double laff_grad_eps = 1e-8;
259 
261  int hom_normalized_init = 0;
262  bool hom_corner_based_sampling = true;
263 
265  int lhom_normalized_init = 0;
266  double lhom_grad_eps = 1e-8;
267 
269  int cbh_normalized_init = 0;
270  double cbh_grad_eps = 1e-8;
271 
273  bool asrt_normalized_init = false;
274  int asrt_pt_based_sampling = 0;
275 
277  bool sim_normalized_init = false;
278  bool sim_geom_sampling = true;
279  int sim_pt_based_sampling = 0;
280  int sim_n_model_pts = 2;
281 
283  int iso_pt_based_sampling = 0;
284 
286  int sl3_normalized_init = 0;
287  bool sl3_iterative_sample_mean = true;
288  int sl3_sample_mean_max_iters = 10;
289  double sl3_sample_mean_eps = 1e-4;
290  bool sl3_debug_mode = 0;
291 
293  int spl_control_size = 10;
294  double spl_control_overlap = 1;
295  int spl_interp_type = 0;
296  bool spl_static_wts = true;
297  bool spl_debug_mode = 0;
298 
300  int scv_hist_type = 0;
301  bool scv_use_bspl = 0;
302  int scv_n_bins = 256;
303  double scv_preseed = 0;
304  bool scv_pou = 1;
305  bool scv_weighted_mapping = 1;
306  bool scv_mapped_gradient = 1;
307  bool scv_affine_mapping = 0;
308  bool scv_once_per_frame = 0;
309  bool scv_approx_dist_feat = true;
310  double scv_likelihood_alpha = 0;
311 
313  int lscv_sub_regions = 3;
314  int lscv_spacing = 10;
315  bool lscv_show_subregions = false;
316 
318  int lkld_n_bins = 8;
319  double lkld_pre_seed = 0.1;
320  bool lkld_pou = 1;
321  int lkld_sub_regions = 0;
322  int lkld_spacing = 1;
323 
325  bool ncc_fast_hess = false;
326  double ncc_likelihood_alpha = 50;
327 
329  double spss_k = 0.01;
330  double spss_likelihood_alpha = 50;
331 
333  int ssim_pix_proc_type = 0;
334  double ssim_k1 = 0.01;
335  double ssim_k2 = 0.03;
336  double ssim_likelihood_alpha = 50;
337 
339  std::string sum_am1, sum_am2;
340 
341  char *pix_mapper = nullptr;
342 
344  int mi_n_bins = 8;
345  double mi_pre_seed = 10;
346  bool mi_pou = false;
347  double mi_likelihood_alpha = 50;
348 
350  int ccre_n_bins = 8;
351  double ccre_pre_seed = 10;
352  bool ccre_pou = false;
353  bool ccre_symmetrical_grad = false;
354  int ccre_n_blocks = 0;
355  double ccre_likelihood_alpha = 50;
356 
358  double ngf_eta = 5.0;
359  bool ngf_use_ssd = false;
360 
362  int nn_max_iters = 10;
363  int nn_n_samples = 1000;
364  vectori nn_ssm_sigma_ids;
365  vectori nn_ssm_mean_ids;
366  double nn_corner_sigma_d = 0.04;
367  double nn_corner_sigma_t = 0.06;
368  vectord nn_pix_sigma;
369  int nn_n_trees = 6;
370  double nn_ssm_sigma_prec = 1.1;
371  int nn_index_type = 1;
372  int nn_search_type = 0;
373  bool nn_additive_update = false;
374  int nn_show_samples = 0;
375  int nn_add_samples_gap = 0;
376  int nn_n_samples_to_add = 0;
377  int nn_remove_samples = 0;
378  bool nn_save_index = false;
379  bool nn_load_index = false;
380  int nn_saved_index_fid = 0;
382  int nn_gnn_degree = 250;
383  int nn_gnn_max_steps = 10;
384  int nn_gnn_cmpt_dist_thresh = 10000;
385  bool nn_gnn_random_start = false;
386  bool nn_gnn_verbose = false;
387  int nn_fgnn_index_type = 0;
389  int nn_srch_checks = 32;
390  float nn_srch_eps = 0.0;
391  bool nn_srch_sorted = true;
392  int nn_srch_max_neighbors = -1;
393  int nn_srch_cores = 1;
394  bool nn_srch_matrices_in_gpu_ram = false;
395  int nn_srch_use_heap = 2;
396  int nn_kdt_trees = 6;
397  int nn_km_branching = 32;
398  int nn_km_iterations = 11;
399  int nn_km_centers_init = 0;
400  float nn_km_cb_index = 0.2f;
401  int nn_kdts_leaf_max_size = 10;
402  int nn_kdtc_leaf_max_size = 64;
403  int nn_hc_branching = 32;
404  int nn_hc_trees = 4;
405  int nn_hc_leaf_max_size = 100;
406  int nn_hc_centers_init = 0;
407  float nn_auto_target_precision = 0.9f;
408  float nn_auto_build_weight = 0.01f;
409  float nn_auto_memory_weight = 0.0f;
410  float nn_auto_sample_fraction = 0.1f;
411 
412  // Multi Layer Nearest Filter
413  int nnk_n_layers;
414  vectorvi nnk_ssm_sigma_ids;
415 
417  int rg_max_iters = 10;
418  int rg_n_samples = 1000;
419  vectori rg_ssm_sigma_ids;
420  vectori rg_ssm_mean_ids;
421  vectord rg_pix_sigma;
422  bool rg_additive_update = false;
423  int rg_show_samples = 0;
424  int rg_add_points = 0;
425  int rg_remove_points = 0;
426  bool rg_save_index = false;
427  bool rg_load_index = false;
428  int rg_saved_index_fid = 0;
429  int rg_nepochs = 10;
430  int rg_bs = 128;
431  bool rg_preproc = true;
432  char *rg_solver = nullptr;
433  char *rg_train = nullptr;
434  char *rg_mean = nullptr;
435  bool rg_dbg = false;
436  bool rg_pretrained = false;
437 
439  double riu_likelihood_alpha = 50.0;
440 
442  double sd_learning_rate = 0.1;
443 
445  bool gb_additive_update = false;
446 
448  bool pgb_additive_update = false;
449  int pgb_sub_regions_x = 3;
450  int pgb_sub_regions_y = 3;
451 
453  bool rbf_additive_update = false;
454  int rbf_n_ctrl_pts_x = 3;
455  int rbf_n_ctrl_pts_y = 3;
456 
458  int pf_max_iters = 1;
459  int pf_n_particles = 100;
460  int pf_dynamic_model = 1;
461  int pf_update_type = 0;
462  int pf_likelihood_func = 0;
463  int pf_resampling_type = 0;
464  int pf_mean_type = 1;
465  bool pf_reset_to_mean = false;
466  vectori pf_ssm_sigma_ids;
467  vectori pf_ssm_mean_ids;
468  bool pf_update_distr_wts = false;
469  double pf_min_distr_wt = 0.1;
470  double pf_adaptive_resampling_thresh = 0;
471  double pf_measurement_sigma = 0.1;
472  vectord pf_pix_sigma;
473  int pf_show_particles = 0;
474  bool pf_jacobian_as_sigma = false;
475  bool pf_debug_mode = false;
476 
478  int pfk_n_layers;
479  vectorvi pfk_ssm_sigma_ids;
480 
482  vectorvd ssm_sigma;
483  vectorvd ssm_mean;
484 
485  vectorvd am_sigma;
486  vectorvd am_mean;
487 
489  char* hrch_sm = "iclk";
490  char* hrch_am = "ssd";
491 
493  int casc_n_trackers = 2;
494  bool casc_enable_feedback = 1;
495  bool casc_auto_reinit = false;
496  double casc_reinit_err_thresh = 1.0;
497  int casc_reinit_frame_gap = 1;
498 
500  char* grid_sm = "iclk";
501  char* grid_am = "ssd";
502  char* grid_ssm = "2";
503  char* grid_ilm = "0";
504 
505  int grid_res = 10;
506  int grid_patch_size = 10;
507  int grid_patch_res = 0;
508  int grid_reset_at_each_frame = 1;
509  bool grid_dyn_patch_size = false;
510  bool grid_patch_centroid_inside = true;
511  double grid_fb_err_thresh = 0;
512  bool grid_fb_reinit = 0;
513  bool grid_show_trackers = false;
514  bool grid_show_tracker_edges = false;
515  bool grid_use_tbb = true;
517  int grid_pyramid_levels = 2;
518  bool grid_use_min_eig_vals = 0;
519  bool grid_rgb_input = false;
520  double grid_min_eig_thresh = 1e-4;
521 
522  std::string feat_detector_type = "orb";
523  std::string feat_descriptor_type = "orb";
524  double feat_max_dist_ratio = 0.75;
525  int feat_min_matches = 10;
526  bool feat_rebuild_index = false;
527  bool feat_use_cv_flann = true;
528  bool feat_show_keypoints = 0;
529  bool feat_show_matches = 0;
530  bool feat_debug_mode = 0;
531 
532  bool grid_use_const_grad = true;
533 
534  int sift_n_features = 0;
535  int sift_n_octave_layers = 3;
536  double sift_contrast_thresh = 0.04;
537  double sift_edge_thresh = 10;
538  double sift_sigma = 1.6;
539 
540  double surf_hessian_threshold = 100;
541  int surf_n_octaves = 4;
542  int surf_n_octave_layers = 3;
543  bool surf_extended = false;
544  bool surf_upright = false;
545 
546  int brisk_thresh = 30;
547  int brisk_octaves = 3;
548  float brisk_pattern_scale = 1.0f;
549 
550  int orb_n_features = 500;
551  float orb_scale_factor = 1.2f;
552  int orb_n_levels = 8;
553  int orb_edge_threshold = 31;
554  int orb_first_level = 0;
555  int orb_WTA_K = 2;
556  int orb_score_type = 0;
557  int orb_patch_size = 31;
558  int orb_fast_threshold = 20;
559 
560  int mser_delta = 5;
561  int mser_min_area = 60;
562  int mser_max_area = 14400;
563  double mser_max_variation = 0.25;
564  double mser_min_diversity = .2;
565  int mser_max_evolution = 200;
566  double mser_area_threshold = 1.01;
567  double mser_min_margin = 0.003;
568  int mser_edge_blur_size = 5;
569 
570  int fast_threshold = 10;
571  bool fast_non_max_suppression = true;
572  int fast_type = 2;
573 
574  int agast_threshold = 10;
575  bool agast_non_max_suppression = true;
576  int agast_type = 3;
577 
578  int gftt_max_corners = 1000;
579  double gftt_quality_level = 0.01;
580  double gftt_min_distance = 1;
581  int gftt_block_size = 3;
582  bool gftt_use_harris_detector = false;
583  double gftt_k = 0.04;
584 
585  int brief_bytes = 32;
586  bool brief_use_orientation = false;
587 
588  bool freak_orientation_normalized = true;
589  bool freak_scale_normalized = true;
590  float freak_pattern_scale = 22.0f;
591  int freak_n_octaves = 4;
592 
593  int lucid_kernel = 1;
594  int lucid_blur_kernel = 2;
595 
596  int latch_bytes = 32;
597  bool latch_rotation_invariance = true;
598  int latch_half_ssd_size = 3;
599 
600  float daisy_radius = 15;
601  int daisy_q_radius = 3;
602  int daisy_q_theta = 8;
603  int daisy_q_hist = 8;
604  int daisy_norm = 100;
605  vectorf daisy_H;
606  bool daisy_interpolation = true;
607  bool daisy_use_orientation = false;
608 
609  int vgg_desc = 100;
610  float vgg_isigma = 1.4f;
611  bool vgg_img_normalize = true;
612  bool vgg_use_scale_orientation = true;
613  float vgg_scale_factor = 6.25f;
614  bool vgg_dsc_normalize = false;
615 
616  int boost_desc_desc = 302;
617  bool boost_desc_use_scale_orientation = true;
618  float boost_desc_scale_factor = 6.25f;
619 
620  int star_max_size = 45;
621  int star_response_threshold = 30;
622  int star_line_threshold_projected = 10;
623  int star_line_threshold_binarized = 8;
624  int star_suppress_nonmax_size = 5;
625 
626  int msd_patch_radius = 3;
627  int msd_search_area_radius = 5;
628  int msd_nms_radius = 5;
629  int msd_nms_scale_radius = 0;
630  float msd_th_saliency = 250.0f;
631  int msd_kNN = 4;
632  float msd_scale_factor = 1.25f;
633  int msd_n_scales = -1;
634  bool msd_compute_orientation = false;
635 
637  int est_method = 0;
638  double est_ransac_reproj_thresh = 10;
639  int est_n_model_pts = 4;
640  int est_max_iters = 2000;
641  int est_max_subset_attempts = 300;
642  bool est_use_boost_rng = false;
643  double est_confidence = 0.995;
644  bool est_refine = true;
645  int est_lm_max_iters = 10;
646 
647 
648  char* line_sm = "iclk";
649  char* line_am = "ssd";
650  char* line_ssm = "2";
651  int line_grid_size = 5;
652  int line_patch_size = 25;
653  bool line_use_constant_slope = false;
654  bool line_use_ls = false;
655  double line_inter_alpha_thresh = 0.1;
656  double line_intra_alpha_thresh = 0.05;
657  bool line_reset_pos = false;
658  bool line_reset_template = false;
659  bool line_debug_mode = false;
660 
662  char* rkl_sm = "iclk";
663  bool rkl_enable_spi = true;
664  bool rkl_enable_feedback = true;
665  bool rkl_failure_detection = true;
666  double rkl_failure_thresh = 15.0;
667 
669  int prl_n_trackers = 1;
670  int prl_estimation_method = 0;
671  bool prl_reset_to_mean = false;
672  bool prl_auto_reinit = false;
673  double prl_reinit_err_thresh = 1.0;
674  int prl_reinit_frame_gap = 1;
675 
677  std::string pyr_sm = "fc";
678  int pyr_no_of_levels = 3;
679  double pyr_scale_factor = 0.50;
680  bool pyr_scale_res = true;
681  bool pyr_show_levels = false;
682 
684  char* diag_am = "ssd";
685  char* diag_ssm = "2";
686  char* diag_ilm = "0";
687  bool diag_3d = false;
688  std::vector<int> diag_3d_ids = { 0, 1 };
689  int diag_frame_gap = 0;
690  double diag_range = 0;
691  std::vector<double> diag_ssm_range;
692  std::vector<double> diag_am_range;
693  int diag_ssm_range_id = 0;
694  int diag_am_range_id = 0;
695  std::string diag_gen_norm = "000";// Norm,FeatNorm
696  std::string diag_gen_jac = "000";// Std,ESM,Diff
697  std::string diag_gen_hess = "0000";// Std,ESM,InitSelf,CurrSelf
698  std::string diag_gen_hess2 = "0000";// Std2,ESM2,InitSelf2,CurrSelf2
699  std::string diag_gen_hess_sum = "0000";// Std, Std2, Self, Self2
700  std::string diag_gen_num = "000"; // Jac, Hess, NHess
701  std::string diag_gen_ssm = "0";// ssm params
702 
703  bool diag_bin = true;
704  bool diag_inv = true;
705  bool diag_show_data = false;
706  bool diag_show_corners = false;
707  bool diag_show_patches = false;
708  bool diag_verbose = false;
709 
710  double diag_grad_diff = 0.1;
711  int diag_res = 50;
712  int diag_update_type = 0;
713  int diag_start_id = 0;
714  int diag_end_id = 0;
715 
716  std::string diag_out_prefix;
717 
718 
719  bool diag_enable_validation = false;
720  double diag_validation_prec = 1e-20;
721 
722  bool esm_spi_enable = false;
723  double esm_spi_thresh = 10;
724 
726  double dsst_padding = 1;
727  double dsst_sigma = 1.0 / 16;
728  double dsst_scale_sigma = 1.0 / 4;
729  double dsst_lambda = 1e-2;
730  double dsst_learning_rate = 0.025;
731  int dsst_number_scales = 33;
732  int dsst_number_rots = 21;
733  double dsst_scale_step = 1.02;
734  double dsst_rot_step = 2;
735  int dsst_resize_factor = 4;
736  int dsst_is_scaling = 1;
737  int dsst_is_rotating = 1;
738  int dsst_bin_size = 1;
739 
741  double kcf_padding; //extra area surrounding the target
742  double kcf_lambda; //regularization
743  double kcf_output_sigma_factor; //spatial bandwidth (proportional to target)
744  double kcf_interp_factor; //linear interpolation factor for adaptation
745  double kcf_kernel_sigma; //gaussian kernel bandwidth
747  int kcf_number_scales;
748  double kcf_scale_step;
749  double kcf_scale_model_max_area;
750  double kcf_scale_sigma_factor;
751  double kcf_scale_learning_rate;
752  bool kcf_is_scaling;
753  int kcf_resize_factor;
754 
755  int mil_algorithm = 100;
756  int mil_num_classifiers = 100;
757  float mil_overlap = 0.99f;
758  float mil_search_factor = 2.0f;
759  float mil_pos_radius_train = 4.0f;
760  int mil_neg_num_train = 65;
761  int mil_num_features = 250;
762 
764  bool cmt_estimate_scale = true;
765  bool cmt_estimate_rotation = false;
766  char* cmt_feat_detector = "FAST";
767  char* cmt_desc_extractor = "BRISK";
768  double cmt_resize_factor = 0.5;
769 
771  bool tld_tracker_enabled = true;
772  bool tld_detector_enabled = true;
773  bool tld_learning_enabled = true;
774  bool tld_alternating = false;
775 
777  int rct_min_n_rect = 2;
778  int rct_max_n_rect = 4;
779  int rct_n_feat = 50;
780  int rct_rad_outer_pos = 4;
781  int rct_rad_search_win = 25;
782  double rct_learning_rate = 0.85;
783 
784  std::string strk_config_path = "Config/struck.cfg";
785 
787  char* vptt_sm = "fclk";
788  char* vptt_am = "ssd";
789  char* vptt_ssm = "8";
790  int vptt_max_iters = 30;
791  int vptt_res = 50;
792  double vptt_lambda = 0.001;
793  double vptt_thresh_grad = 60;
794  int vptt_pyr_n_levels = 0;
795  int vptt_pyr_level_to_stop = 1;
796 
798  int vp_usb_n_buffers = 3;
799  std::string vp_usb_res = "0";
800  std::string vp_usb_fps = "0";
801  std::string vp_fw_res = "0";
802  std::string vp_fw_fps = "0";
803  std::string vp_fw_depth = "0";
804  std::string vp_fw_iso = "0";
805  bool vp_fw_print_info;
806  float vp_pg_fw_shutter_ms;
807  float vp_pg_fw_gain;
808  float vp_pg_fw_exposure;
809  float vp_pg_fw_brightness;
810 
812  std::string cv3_tracker_type = "mil";
813 
815  int pfsl3_p_x = 40;
816  int pfsl3_p_y = 40;
817  double pfsl3_rot = 0;
818  double pfsl3_ncc_std = 0.1;
819  double pfsl3_pca_std = 10;
820  std::vector<double> pfsl3_state_std;
821  double pfsl3_ar_p = 0.5;
822  int pfsl3_n = 40;
823  int pfsl3_n_c = 10;
824  int pfsl3_n_iter = 5;
825  int pfsl3_sampling = 0;
826  int pfsl3_capture = 0;
827  int pfsl3_mean_check = 0;
828  int pfsl3_outlier_flag = 0;
829  int pfsl3_len = 100;
830  int pfsl3_init_size = 15;
831  int pfsl3_update_period = 5;
832  float pfsl3_ff = 0.99f;
833  double pfsl3_basis_thr = 0.95;
834  int pfsl3_max_num_basis = 30;
835  int pfsl3_max_num_used_basis = 10;
836  bool pfsl3_show_weights = false;
837  bool pfsl3_show_templates = false;
838  bool pfsl3_debug_mode = false;
839 
841  bool gtrn_do_train = true;
842  int gtrn_gpu_id = 0;
843  bool gtrn_show_intermediate_output = false;
844  std::string gtrn_model_file = "Data/GOTURN/tracker.prototxt";
845  std::string gtrn_trained_file = "Data/GOTURN/solver.prototxt";
846 
848  float dft_res_to_l = 1e-10f;
849  float dft_p_to_l = 5e-5f;
850  int dft_max_iter = 50;
851  int dft_max_iter_single_level = 10;
852  std::vector<float> dft_pyramid_smoothing_variance = { 7 };
853  float dft_presmoothing_variance = 1;
854  int dft_n_control_points_on_edge = 25;
855  bool dft_b_adaptative_choice_of_points = 0;
856  bool dft_b_normalize_descriptors = 0;
857  int dft_optimization_type = 2;
858 
859  int frg_n_bins = 16;
860  int frg_search_margin = 7;
861  int frg_hist_cmp_metric = 3;
862  double frg_resize_factor = 0.5;
863  bool frg_show_window = false;
864 
866  std::vector<int> extracted_frame_ids = { 0, 1, 2, 3, 4 };
867  int extraction_id = 0;
868  // PCA
869  int pca_n_eigenvec = 16;
870  int pca_batchsize = 5;
871  float pca_f_factor = 0.95f;
872  bool pca_show_basis = false;
873 
875  int dfm_nfmaps = 1;
876  char* dfm_layer_name = "conv1";
877  int dfm_vis = 0;
878  int dfm_zncc = 0;
879  char *dfm_model_f_name = "../../../VGG_Models/VGG_deploy.prototxt";
880  char *dfm_params_f_name = "../../../VGG_Models/VGG_CNN_F.caffemodel";
881  char *dfm_mean_f_name = "../../../VGG_Models/VGG_mean.binaryproto";
882 
884  int spi_type = 0;
885  double spi_pix_diff_thresh = 10;
886  double spi_grad_thresh = 0.005;
887  bool spi_grad_use_union = false;
888  // GFTT
889  int spi_gftt_max_corners = 1000;
890  double spi_gftt_quality_level = 0.01;
891  double spi_gftt_min_distance = 0;
892  int spi_gftt_block_size = 3;
893  bool spi_gftt_use_harris_detector = false;
894  double spi_gftt_k = 0.04;
895  // SPI with GFTT
896  bool spi_gftt_use_union = false;
897  int spi_gftt_neigh_offset = 0;
898 
900  std::string reg_ssm = "8";
901  std::string reg_ilm = "0";
902  int reg_track_border = 0;
903  bool reg_grayscale_img = false;
904  bool reg_show_output = true;
905  bool reg_save_as_video = false;
906  int reg_video_fps = 24;
907 
909  std::string syn_ssm = "c8";
910  std::string syn_ilm = "0";
911  int syn_frame_id = 0;
912  bool syn_grayscale_img = false;
913  bool syn_continuous_warping = true;
914  vectori syn_ssm_sigma_ids, syn_ssm_mean_ids;
915  vectori syn_am_sigma_ids, syn_am_mean_ids;
916  double syn_pix_sigma = 0;
917  bool syn_am_on_obj = false;
918  bool syn_warp_entire_image = false;
919  int syn_background_type = 0;
920  bool syn_use_inv_warp = false;
921  std::string syn_out_suffix;
922  int syn_n_frames = 1;
923  bool syn_add_noise = true;
924  double syn_noise_mean = 0.0;
925  double syn_noise_sigma = 1.0;
926  bool syn_save_as_video = false;
927  int syn_video_fps = 24;
928  int syn_jpg_quality = 100;
929  bool syn_show_output = true;
930 
932  bool mos_inv_tracking = true;
933  int mos_use_norm_corners = true;
934  int mos_track_border = 100;
935  int mos_border_width = 200;
936  int mos_border_height = 200;
937  int mos_init_offset_x = 0;
938  int mos_init_offset_y = 0;
939  int mos_disp_width = 200;
940  int mos_disp_height = 200;
941  bool mos_show_grid = false;
942  bool mos_show_tracked_img = false;
943  bool mos_show_patch = false;
944  bool mos_show_mask = false;
945  bool mos_use_write_mask = false;
946  bool mos_save_img = true;
947  std::string mos_out_fname;
948  std::string mos_out_fmt = "jpg";
949 
951  std::vector<std::string> qr_input;
952  std::string qr_root_dir = "Data/QRTracker";
953  std::string qr_detector_ssm = "4";
954  double qr_duplicate_min_dist = 50;
955  double qr_min_size = 10;
956  bool qr_init_with_rect = 1;
957  int qr_n_markers = -1;
959  int py_visualize = 1;
960  int py_live_init = 1;
962  int mex_visualize = 1;
963  int mex_live_init = 1;
964 
965  inline void split(const std::string &s, char delim, std::vector<std::string> &elems) {
966  stringstream ss(s);
967  std::string item;
968  while(getline(ss, item, delim)) {
969  if(!item.empty()){
970  elems.push_back(item);
971  }
972  }
973  }
974 
975  inline int readParams(std::vector<char*> &fargv, const char* fname = "mtf.cfg"){
976 #ifdef _WIN32
977  FILE *fid;
978  errno_t err;
979  if((err = fopen_s(&fid, fname, "r")) != 0) {
980  printf("Parameter file: %s not found: %s\n",
981  fname, strerror(err));
982  return 0;
983  }
984 #else
985  FILE *fid = fopen(fname, "r");
986  if(!fid){
987  printf("\n Parameter file: %s not found\n", fname);
988  return 0;
989  }
990 #endif
991 
992  // one extra entry at the beginning to maintain compatibilty with the C/C++
993  // command line argument convention
994  fargv.push_back(nullptr);
995  int arg_id = 0;
996  while(!feof(fid)){
997  char *temp = new char[500];
998  fgets(temp, 500, fid);
999  strtok(temp, "\n");
1000  strtok(temp, "\r");
1001  if(strlen(temp) <= 1 || temp[0] == '#'){
1002  delete(temp);
1003  continue;
1004  }
1005  fargv.push_back(temp);
1006  ++arg_id;
1007  //printf("arg %d: %s\n", arg_id, fargv[arg_id]);
1008  }
1009  fclose(fid);
1010  return arg_id + 1;
1011  }
1012 
1013  inline void processStringParam(std::string &str_out, const char* param){
1014  if(!strcmp(param, "#")){
1015  // use default value
1016  return;
1017  }
1018  str_out = std::string(param);
1019  }
1020 
1021  inline void processStringParam(char* &str_out, const char* param){
1022  //printf("-----------------------\n");
1023  //printf("param: %s\n", param);
1024  //printf("use_default: %c\n", use_default);
1025  if(!strcmp(param, "#")){
1026  // use default value
1027  return;
1028  }
1029  //if((strlen(param) == 2) && (param[0] == '0') && (param[1] == '0')){
1030  // return;
1031  //}
1032  //if(str_out){ delete(str_out); }
1033 
1034  str_out = new char[strlen(param) + 1];
1035  strcpy(str_out, param);
1036  //printf("str_out: %s\n", str_out);
1037  }
1038  // convert a string of comma (or other specified character) separated values
1039  // into a vector of doubles
1040  inline vectord atof_arr(char *str, const char *sep = ","){
1041  char *param_str = strtok(str, sep);
1042  std::vector<double> param_arr;
1043  //printf("atof_arr::str: %s\n", str);
1044  //printf("atof_arr::param_arr:\n");
1045  while(param_str){
1046  double param_num = atof(param_str);
1047  param_arr.push_back(param_num);
1048  //printf("%f\t", param_num);
1049  param_str = strtok(nullptr, sep);
1050  }
1051  //printf("\n");
1052  //std::string str_temp(str);
1053  //for(int i = 0; i < str_temp.length(); ++i){
1054  // if(str_temp[i] == sep)
1055  // str_temp[i] = ' ';
1056  //}
1057  //printf("atof_arr::str_temp: %s\n", str_temp.c_str());
1058  //std::stringstream ss(str);
1059  //double temp;
1060  //while(ss >> temp)
1061  // param_arr.push_back(temp);
1062  return param_arr;
1063  }
1064  inline vectorf atof32_arr(char *str, const char *sep = ","){
1065  char *param_str = strtok(str, sep);
1066  std::vector<float> param_arr;
1067  while(param_str){
1068  float param_num = atof32(param_str);
1069  param_arr.push_back(param_num);
1070  param_str = strtok(nullptr, sep);
1071  }
1072  return param_arr;
1073  }
1074  inline vectori atoi_arr(char *str, const char *sep = ","){
1075  char *param_str = strtok(str, sep);
1076  std::vector<int> param_arr;
1077  //printf("atof_arr::str: %s\n", str);
1078  //printf("atof_arr::param_arr:\n");
1079  while(param_str){
1080  int param_num = atoi(param_str);
1081  param_arr.push_back(param_num);
1082  //printf("%f\t", param_num);
1083  param_str = strtok(nullptr, sep);
1084  }
1085  //printf("\n");
1086  //std::string str_temp(str);
1087  //for(int i = 0; i < str_temp.length(); ++i){
1088  // if(str_temp[i] == sep)
1089  // str_temp[i] = ' ';
1090  //}
1091  //printf("atof_arr::str_temp: %s\n", str_temp.c_str());
1092  //std::stringstream ss(str);
1093  //double temp;
1094  //while(ss >> temp)
1095  // param_arr.push_back(temp);
1096  return param_arr;
1097  }
1098  inline vector_s string_arr(char *str, const char *sep = ","){
1099  char *param_str = strtok(str, sep);
1100  vector_s param_arr;
1101  while(param_str){
1102  param_arr.push_back(std::string(param_str));
1103  param_str = strtok(nullptr, sep);
1104  }
1105  return param_arr;
1106  }
1107  inline char atoc(char *arg_val){ return arg_val[0]; }
1108  inline int atoc_i(char *arg_val){ return arg_val[0] - '0'; }
1109 
1110  inline void processAgrumentUnchained(char *arg_name, char *arg_val,
1111  char *arg_prefix = nullptr){
1112  if(arg_val[0] == '#'){ return; }
1113  parse_param(n_trackers, atoi);
1114  parse_param(track_single_obj, atoi);
1115  parse_param(seq_id, atoi);
1116  parse_param(actor_id, atoi);
1117  parse_param(pipeline, atoc);
1118  parse_param(img_source, atoc);
1119  parse_param(rec_source, atoc);
1120  parse_param(rec_fps, atoi);
1121  parse_param(rec_seq_suffix, std::string);
1122  parse_param(img_resize_factor, atof);
1123  parse_param(gt_write_ssm_params, atoi);
1124  parse_param(write_tracking_data, atoc_i);
1125  parse_param(overwrite_gt, atoc_i);
1126  parse_param(tracking_data_fname, std::string);
1127  parse_param(record_frames_fname, std::string);
1128  parse_param(record_frames_dir, std::string);
1129  parse_param(read_obj_fname, std::string);
1130  parse_param(write_obj_fname, std::string);
1131  parse_param(mtf_visualize, atoc_i);
1132  parse_param(show_ground_truth, atoc_i);
1133  parse_param(xv_visualize, atoc_i);
1134  parse_param(read_obj_from_gt, atoi);
1135  parse_param(sel_quad_obj, atoi);
1136  }
1137 
1138  inline void processAgrument(char *arg_name, char *arg_val,
1139  char *arg_prefix = nullptr){
1140  if(arg_val[0] == '#'){ return; }
1141  if(!strcmp(arg_name, "n_trackers")){
1142  n_trackers = static_cast<unsigned int>(atoi(arg_val));
1143  return;
1144  }
1145  if(!strcmp(arg_name, "track_single_obj")){
1146  track_single_obj = atoi(arg_val);
1147  return;
1148  }
1149  if(!strcmp(arg_name, "source_id") || !strcmp(arg_name, "seq_id")){
1150  seq_id = atoi(arg_val);
1151  return;
1152  }
1153  if(!strcmp(arg_name, "actor_id")){
1154  actor_id = atoi(arg_val);
1155  return;
1156  }
1157  if(!strcmp(arg_name, "pipeline")){
1158  pipeline = arg_val[0];
1159  return;
1160  }
1161  if(!strcmp(arg_name, "img_source")){
1162  img_source = arg_val[0];
1163  return;
1164  }
1165  if(!strcmp(arg_name, "rec_source")){
1166  rec_source = arg_val[0];
1167  return;
1168  }
1169  if(!strcmp(arg_name, "rec_fps")){
1170  rec_fps = atoi(arg_val);
1171  return;
1172  }
1173  if(!strcmp(arg_name, "rec_seq_suffix")){
1174  rec_seq_suffix = std::string(arg_val);
1175  return;
1176  }
1177  if(!strcmp(arg_name, "img_resize_factor")){
1178  img_resize_factor = atof(arg_val);
1179  return;
1180  }
1181  if(!strcmp(arg_name, "gt_write_ssm_params")){
1182  gt_write_ssm_params = atoi(arg_val);
1183  return;
1184  }
1185  if(!strcmp(arg_name, "write_tracking_data")){
1186  write_tracking_data = arg_val[0] - '0';
1187  return;
1188  }
1189  if(!strcmp(arg_name, "overwrite_gt")){
1190  overwrite_gt = arg_val[0] - '0';
1191  return;
1192  }
1193  if(!strcmp(arg_name, "tracking_data_fname")){
1194  tracking_data_fname = std::string(arg_val);
1195  return;
1196  }
1197  if(!strcmp(arg_name, "record_frames_fname")){
1198  record_frames_fname = std::string(arg_val);
1199  return;
1200  }
1201  if(!strcmp(arg_name, "record_frames_dir")){
1202  record_frames_dir = std::string(arg_val);
1203  return;
1204  }
1205  if(!strcmp(arg_name, "read_obj_fname")){
1206  read_obj_fname = std::string(arg_val);
1207  return;
1208  }
1209  if(!strcmp(arg_name, "write_obj_fname")){
1210  write_obj_fname = std::string(arg_val);
1211  return;
1212  }
1213  if(!strcmp(arg_name, "show_corner_ids")){
1214  show_corner_ids = arg_val[0] - '0';
1215  return;
1216  }
1217  if(!strcmp(arg_name, "tracker_labels")){
1218  tracker_labels.push_back(std::string(arg_val));
1219  return;
1220  }
1221  if(!strcmp(arg_name, "mtf_visualize")){
1222  mtf_visualize = arg_val[0] - '0';
1223  return;
1224  }
1225  if(!strcmp(arg_name, "show_ground_truth")){
1226  show_ground_truth = arg_val[0] - '0';
1227  return;
1228  }
1229  if(!strcmp(arg_name, "xv_visualize")){
1230  xv_visualize = arg_val[0] - '0';
1231  return;
1232  }
1233  if(!strcmp(arg_name, "read_obj_from_gt")){
1234  read_obj_from_gt = atoi(arg_val);
1235  return;
1236  }
1237  if(!strcmp(arg_name, "sel_quad_obj")){
1238  sel_quad_obj = atoi(arg_val);
1239  return;
1240  }
1241  if(!strcmp(arg_name, "line_thickness")){
1242  line_thickness = atoi(arg_val);
1243  return;
1244  }
1245  if(!strcmp(arg_name, "reinit_gt_from_bin")){
1246  reinit_gt_from_bin = arg_val[0] - '0';
1247  return;
1248  }
1249  if(!strcmp(arg_name, "read_obj_from_file")){
1250  read_obj_from_file = arg_val[0] - '0';
1251  return;
1252  }
1253  if(!strcmp(arg_name, "write_objs")){
1254  write_objs = arg_val[0] - '0';
1255  return;
1256  }
1257  if(!strcmp(arg_name, "record_frames")){
1258  record_frames = arg_val[0] - '0';
1259  return;
1260  }
1261  if(!strcmp(arg_name, "source_name") || !strcmp(arg_name, "seq_name")){
1262  seq_name = std::string(arg_val);
1263  return;
1264  }
1265  if(!strcmp(arg_name, "source_path") || !strcmp(arg_name, "seq_path")){
1266  seq_path = std::string(arg_val);
1267  return;
1268  }
1269  if(!strcmp(arg_name, "source_fmt") || !strcmp(arg_name, "seq_fmt")){
1270  seq_fmt = std::string(arg_val);
1271  return;
1272  }
1273  if(!strcmp(arg_name, "invert_seq")){
1274  invert_seq = atoi(arg_val);
1275  return;
1276  }
1277  if(!strcmp(arg_name, "patch_size")){
1278  patch_size = atoi(arg_val);
1279  return;
1280  }
1281  if(!strcmp(arg_name, "db_root_path") || !strcmp(arg_name, "root_path")){
1282  db_root_path = std::string(arg_val);
1283  return;
1284  }
1286  if(!strcmp(arg_name, "xv_scale")){
1287  xv_scale = atof(arg_val);
1288  return;
1289  }
1290  if(!strcmp(arg_name, "xv_no_of_levels")){
1291  xv_no_of_levels = atoi(arg_val);
1292  return;
1293  }
1294  if(!strcmp(arg_name, "xv_steps_per_frame")){
1295  xv_steps_per_frame = atoi(arg_val);
1296  return;
1297  }
1298  if(!strcmp(arg_name, "xv_patch_size")){
1299  xv_patch_size = atoi(arg_val);
1300  return;
1301  }
1302  if(!strcmp(arg_name, "xvg_grid_size_x")){
1303  xvg_grid_size_x = atoi(arg_val);
1304  return;
1305  }
1306  if(!strcmp(arg_name, "xvg_grid_size_y")){
1307  xvg_grid_size_y = atoi(arg_val);
1308  return;
1309  }
1310  if(!strcmp(arg_name, "xvg_adjust_grid")){
1311  xvg_adjust_grid = arg_val[0] - '0';
1312  return;
1313  }
1314  if(!strcmp(arg_name, "xvg_adjust_lines")){
1315  xvg_adjust_lines = arg_val[0] - '0';
1316  return;
1317  }
1318  if(!strcmp(arg_name, "xvg_reset_pos")){
1319  xvg_reset_pos = atoi(arg_val);
1320  return;
1321  }
1322  if(!strcmp(arg_name, "xvg_reset_wts")){
1323  xvg_reset_wts = atoi(arg_val);
1324  return;
1325  }
1326  if(!strcmp(arg_name, "xvg_pause_after_line")){
1327  xvg_pause_after_line = atoi(arg_val);
1328  return;
1329  }
1330  if(!strcmp(arg_name, "xvg_use_constant_slope")){
1331  xvg_use_constant_slope = atoi(arg_val);
1332  return;
1333  }
1334  if(!strcmp(arg_name, "xvg_use_ls")){
1335  xvg_use_ls = atoi(arg_val);
1336  return;
1337  }
1338  if(!strcmp(arg_name, "xvg_inter_alpha_thresh")){
1339  xvg_inter_alpha_thresh = atof(arg_val);
1340  return;
1341  }
1342  if(!strcmp(arg_name, "xvg_intra_alpha_thresh")){
1343  xvg_intra_alpha_thresh = atof(arg_val);
1344  return;
1345  }
1346  if(!strcmp(arg_name, "xvg_show_tracked_pts")){
1347  xvg_show_tracked_pts = atoi(arg_val);
1348  return;
1349  }
1350  if(!strcmp(arg_name, "xvg_update_wts")){
1351  xvg_update_wts = atoi(arg_val);
1352  return;
1353  }
1354  if(!strcmp(arg_name, "xvg_sel_reset_thresh")){
1355  xvg_sel_reset_thresh = atof(arg_val);
1356  return;
1357  }
1358 
1359  if(!strcmp(arg_name, "reset_template")){
1360  reset_template = atoi(arg_val);
1361  return;
1362  }
1363  if(!strcmp(arg_name, "debug_mode")){
1364  debug_mode = atoi(arg_val);
1365  return;
1366  }
1367  if(!strcmp(arg_name, "pause_after_frame")){
1368  pause_after_frame = atoi(arg_val);
1369  return;
1370  }
1371  if(!strcmp(arg_name, "print_corners")){
1372  print_corners = atoi(arg_val);
1373  return;
1374  }
1375  if(!strcmp(arg_name, "print_fps")){
1376  print_fps = atoi(arg_val);
1377  return;
1378  }
1379  if(!strcmp(arg_name, "show_proc_img")){
1380  show_proc_img = atoi(arg_val);
1381  return;
1382  }
1383  if(!strcmp(arg_name, "res_from_size")){
1384  res_from_size = atof(arg_val);
1385  return;
1386  }
1387  if(!strcmp(arg_name, "mtf_res")){
1388  mtf_res = atoi(arg_val);
1389  return;
1390  }
1391  if(!strcmp(arg_name, "resx")){
1392  resx = atoi(arg_val);
1393  return;
1394  }
1395  if(!strcmp(arg_name, "resy")){
1396  resy = atoi(arg_val);
1397  return;
1398  }
1399  if(!strcmp(arg_name, "epsilon")){
1400  epsilon = atof(arg_val);
1401  return;
1402  }
1403  if(!strcmp(arg_name, "max_iters")){
1404  max_iters = atoi(arg_val);
1405  return;
1406  }
1407  if(!strcmp(arg_name, "mtf_sm")){
1408  processStringParam(mtf_sm, arg_val);
1409  return;
1410  }
1411  if(!strcmp(arg_name, "mtf_am")){
1412  processStringParam(mtf_am, arg_val);
1413  return;
1414  }
1415  if(!strcmp(arg_name, "mtf_ssm")){
1416  processStringParam(mtf_ssm, arg_val);
1417  return;
1418  }
1419  if(!strcmp(arg_name, "mtf_ilm")){
1420  processStringParam(mtf_ilm, arg_val);
1421  return;
1422  }
1423  if(!strcmp(arg_name, "enable_nt")){
1424  enable_nt = atoi(arg_val);
1425  return;
1426  }
1427  if(!strcmp(arg_name, "invalid_state_err_thresh")){
1428  invalid_state_err_thresh = atof(arg_val);
1429  return;
1430  }
1431  if(!strcmp(arg_name, "invalid_state_check")){
1432  invalid_state_check = atoi(arg_val);
1433  return;
1434  }
1435  if(!strcmp(arg_name, "uchar_input")){
1436  uchar_input = atoi(arg_val);
1437  return;
1438  }
1440  if(!strcmp(arg_name, "ic_update_ssm")){
1441  ic_update_ssm = atoi(arg_val);
1442  return;
1443  }
1444  if(!strcmp(arg_name, "ic_chained_warp")){
1445  ic_chained_warp = atoi(arg_val);
1446  return;
1447  }
1448  if(!strcmp(arg_name, "ic_hess_type")){
1449  ic_hess_type = atoi(arg_val);
1450  return;
1451  }
1453  if(!strcmp(arg_name, "fc_chained_warp")){
1454  fc_chained_warp = atoi(arg_val);
1455  return;
1456  }
1457  if(!strcmp(arg_name, "fc_hess_type")){
1458  fc_hess_type = atoi(arg_val);
1459  return;
1460  }
1461  if(!strcmp(arg_name, "fc_write_ssm_updates")){
1462  fc_write_ssm_updates = atoi(arg_val);
1463  return;
1464  }
1465  if(!strcmp(arg_name, "fc_show_grid")){
1466  fc_show_grid = atoi(arg_val);
1467  return;
1468  }
1469  if(!strcmp(arg_name, "fc_show_patch")){
1470  fc_show_patch = atoi(arg_val);
1471  return;
1472  }
1473  if(!strcmp(arg_name, "fc_patch_resize_factor")){
1474  fc_patch_resize_factor = atoi(arg_val);
1475  return;
1476  }
1477  if(!strcmp(arg_name, "fc_debug_mode")){
1478  fc_debug_mode = atoi(arg_val);
1479  return;
1480  }
1481  // IA/FA
1482  if(!strcmp(arg_name, "ia_hess_type")){
1483  ia_hess_type = atoi(arg_val);
1484  return;
1485  }
1486  if(!strcmp(arg_name, "fa_hess_type")){
1487  fa_hess_type = atoi(arg_val);
1488  return;
1489  }
1490  if(!strcmp(arg_name, "fa_show_grid")){
1491  fa_show_grid = atoi(arg_val);
1492  return;
1493  }
1494  if(!strcmp(arg_name, "fa_patch_resize_factor")){
1495  fa_patch_resize_factor = atof(arg_val);
1496  return;
1497  }
1498  if(!strcmp(arg_name, "fa_show_patch")){
1499  fa_show_patch = atoi(arg_val);
1500  return;
1501  }
1502  if(!strcmp(arg_name, "fa_write_frames")){
1503  fa_write_frames = atoi(arg_val);
1504  return;
1505  }
1507  if(!strcmp(arg_name, "ssd_show_template")){
1508  ssd_show_template = atoi(arg_val);
1509  return;
1510  }
1511 
1512  if(!strcmp(arg_name, "input_buffer_size")){
1513  input_buffer_size = atoi(arg_val);
1514  return;
1515  }
1516  if(!strcmp(arg_name, "nssd_norm_pix_max")){
1517  nssd_norm_pix_max = atof(arg_val);
1518  return;
1519  }
1520  if(!strcmp(arg_name, "nssd_norm_pix_min")){
1521  nssd_norm_pix_min = atof(arg_val);
1522  return;
1523  }
1524  if(!strcmp(arg_name, "zncc_likelihood_alpha")){
1525  zncc_likelihood_alpha = atof(arg_val);
1526  return;
1527  }
1528  if(!strcmp(arg_name, "init_frame_id")){
1529  init_frame_id = atoi(arg_val);
1530  return;
1531  }
1532  if(!strcmp(arg_name, "start_frame_id")){
1533  start_frame_id = atoi(arg_val);
1534  return;
1535  }
1536  if(!strcmp(arg_name, "frame_gap")){
1537  frame_gap = atoi(arg_val);
1538  return;
1539  }
1540  if(!strcmp(arg_name, "end_frame_id")){
1541  end_frame_id = atoi(arg_val);
1542  return;
1543  }
1544  if(!strcmp(arg_name, "show_tracking_error")){
1545  show_tracking_error = atoi(arg_val);
1546  return;
1547  }
1548  if(!strcmp(arg_name, "write_tracking_error")){
1549  write_tracking_error = atoi(arg_val);
1550  return;
1551  }
1552  if(!strcmp(arg_name, "write_tracking_sr")){
1553  write_tracking_sr = atoi(arg_val);
1554  return;
1555  }
1556  if(!strcmp(arg_name, "sr_err_thresh")){
1557  sr_err_thresh = atof_arr(arg_val);
1558  return;
1559  }
1560  if(!strcmp(arg_name, "fps_col")){
1561  fps_col = std::string(arg_val);
1562  return;
1563  }
1564  if(!strcmp(arg_name, "obj_cols")){
1565  obj_cols = string_arr(arg_val);
1566  return;
1567  }
1568  if(!strcmp(arg_name, "gt_col")){
1569  gt_col = std::string(arg_val);
1570  return;
1571  }
1572  if(!strcmp(arg_name, "err_col")){
1573  err_col = std::string(arg_val);
1574  return;
1575  }
1576  if(!strcmp(arg_name, "tracking_err_type")){
1577  tracking_err_type = atoi(arg_val);
1578  return;
1579  }
1580  if(!strcmp(arg_name, "show_jaccard_error")){
1581  show_jaccard_error = atoi(arg_val);
1582  return;
1583  }
1584  if(!strcmp(arg_name, "grad_eps")){
1585  grad_eps = strtod(arg_val, nullptr);
1586  return;
1587  }
1588  if(!strcmp(arg_name, "hess_eps")){
1589  hess_eps = strtod(arg_val, nullptr);
1590  return;
1591  }
1592  if(!strcmp(arg_name, "likelihood_alpha")){
1593  likelihood_alpha = strtod(arg_val, nullptr);
1594  return;
1595  }
1596  if(!strcmp(arg_name, "likelihood_beta")){
1597  likelihood_beta = strtod(arg_val, nullptr);
1598  return;
1599  }
1600  if(!strcmp(arg_name, "dist_from_likelihood")){
1601  dist_from_likelihood = atoi(arg_val);
1602  return;
1603  }
1605  if(!strcmp(arg_name, "reinit_at_each_frame")){
1606  reinit_at_each_frame = atoi(arg_val);
1607  return;
1608  }
1609  if(!strcmp(arg_name, "reset_at_each_frame")){
1610  reset_at_each_frame = atoi(arg_val);
1611  return;
1612  }
1613  if(!strcmp(arg_name, "reset_to_init")){
1614  reset_to_init = atoi(arg_val);
1615  return;
1616  }
1617  if(!strcmp(arg_name, "reinit_on_failure")){
1618  reinit_on_failure = atoi(arg_val);
1619  return;
1620  }
1621  if(!strcmp(arg_name, "reinit_err_thresh")){
1622  reinit_err_thresh = atof(arg_val);
1623  return;
1624  }
1625  if(!strcmp(arg_name, "reinit_frame_skip")){
1626  reinit_frame_skip = atoi(arg_val);
1627  return;
1628  }
1629  if(!strcmp(arg_name, "reinit_with_new_obj")){
1630  reinit_with_new_obj = atoi(arg_val);
1631  return;
1632  }
1634  if(!strcmp(arg_name, "use_reinit_gt")){
1635  use_reinit_gt = atoi(arg_val);
1636  return;
1637  }
1639  if(!strcmp(arg_name, "use_opt_gt")){
1640  use_opt_gt = atoi(arg_val);
1641  return;
1642  }
1643  if(!strcmp(arg_name, "opt_gt_ssm")){
1644  opt_gt_ssm = std::string(arg_val);
1645  return;
1646  }
1648  if(!strcmp(arg_name, "pre_proc_type")){
1649  pre_proc_type = std::string(arg_val);
1650  return;
1651  }
1652  if(!strcmp(arg_name, "pre_proc_hist_eq")){
1653  pre_proc_hist_eq = atoi(arg_val);
1654  return;
1655  }
1657  if(!strcmp(arg_name, "gauss_kernel_size")){
1658  gauss_kernel_size = atoi(arg_val);
1659  return;
1660  }
1661  if(!strcmp(arg_name, "gauss_sigma_x")){
1662  gauss_sigma_x = atof(arg_val);
1663  return;
1664  }
1665  if(!strcmp(arg_name, "gauss_sigma_y")){
1666  gauss_sigma_y = atof(arg_val);
1667  return;
1668  }
1670  if(!strcmp(arg_name, "med_kernel_size")){
1671  med_kernel_size = atoi(arg_val);
1672  return;
1673  }
1675  if(!strcmp(arg_name, "box_kernel_size")){
1676  box_kernel_size = atoi(arg_val);
1677  return;
1678  }
1680  if(!strcmp(arg_name, "bil_diameter")){
1681  bil_diameter = atoi(arg_val);
1682  return;
1683  }
1684  if(!strcmp(arg_name, "bil_sigma_col")){
1685  bil_sigma_col = atof(arg_val);
1686  return;
1687  }
1688  if(!strcmp(arg_name, "bil_sigma_space")){
1689  bil_sigma_space = atof(arg_val);
1690  return;
1691  }
1693  if(!strcmp(arg_name, "sobel_kernel_size")){
1694  sobel_kernel_size = atoi(arg_val);
1695  return;
1696  }
1697  if(!strcmp(arg_name, "sobel_normalize")){
1698  sobel_normalize = atoi(arg_val);
1699  return;
1700  }
1702  if(!strcmp(arg_name, "aniso_lambda")){
1703  aniso_lambda = atof(arg_val);
1704  return;
1705  }
1706  if(!strcmp(arg_name, "aniso_kappa")){
1707  aniso_kappa = atof(arg_val);
1708  return;
1709  }
1710  if(!strcmp(arg_name, "aniso_n_iters")){
1711  aniso_n_iters = atoi(arg_val);
1712  return;
1713  }
1715  if(!strcmp(arg_name, "aff_normalized_init")){
1716  aff_normalized_init = atoi(arg_val);
1717  return;
1718  }
1719  if(!strcmp(arg_name, "aff_pt_based_sampling")){
1720  aff_pt_based_sampling = atoi(arg_val);
1721  return;
1722  }
1724  if(!strcmp(arg_name, "laff_normalized_init")){
1725  laff_normalized_init = atoi(arg_val);
1726  return;
1727  }
1728  if(!strcmp(arg_name, "laff_grad_eps")){
1729  laff_grad_eps = atof(arg_val);
1730  return;
1731  }
1733  if(!strcmp(arg_name, "hom_normalized_init")){
1734  hom_normalized_init = atoi(arg_val);
1735  return;
1736  }
1737  if(!strcmp(arg_name, "hom_corner_based_sampling")){
1738  hom_corner_based_sampling = atoi(arg_val);
1739  return;
1740  }
1742  if(!strcmp(arg_name, "lhom_normalized_init")){
1743  lhom_normalized_init = atoi(arg_val);
1744  return;
1745  }
1746  if(!strcmp(arg_name, "lhom_grad_eps")){
1747  lhom_grad_eps = atof(arg_val);
1748  return;
1749  }
1751  if(!strcmp(arg_name, "asrt_normalized_init")){
1752  asrt_normalized_init = atoi(arg_val);
1753  return;
1754  }
1755  if(!strcmp(arg_name, "asrt_pt_based_sampling")){
1756  asrt_pt_based_sampling = atoi(arg_val);
1757  return;
1758  }
1760  if(!strcmp(arg_name, "sim_normalized_init")){
1761  sim_normalized_init = atoi(arg_val);
1762  return;
1763  }
1764  if(!strcmp(arg_name, "sim_n_model_pts")){
1765  sim_n_model_pts = atoi(arg_val);
1766  return;
1767  }
1768  if(!strcmp(arg_name, "sim_geom_sampling")){
1769  sim_geom_sampling = atoi(arg_val);
1770  return;
1771  }
1772  if(!strcmp(arg_name, "sim_pt_based_sampling")){
1773  sim_pt_based_sampling = atoi(arg_val);
1774  return;
1775  }
1777  if(!strcmp(arg_name, "iso_pt_based_sampling")){
1778  iso_pt_based_sampling = atoi(arg_val);
1779  return;
1780  }
1782  if(!strcmp(arg_name, "sl3_normalized_init")){
1783  sl3_normalized_init = atoi(arg_val);
1784  return;
1785  }
1786  if(!strcmp(arg_name, "sl3_iterative_sample_mean")){
1787  sl3_iterative_sample_mean = atoi(arg_val);
1788  return;
1789  }
1790  if(!strcmp(arg_name, "sl3_sample_mean_max_iters")){
1791  sl3_sample_mean_max_iters = atoi(arg_val);
1792  return;
1793  }
1794  if(!strcmp(arg_name, "sl3_sample_mean_eps")){
1795  sl3_sample_mean_eps = atof(arg_val);
1796  return;
1797  }
1798  if(!strcmp(arg_name, "sl3_debug_mode")){
1799  sl3_debug_mode = atoi(arg_val);
1800  return;
1801  }
1803  if(!strcmp(arg_name, "cbh_normalized_init")){
1804  cbh_normalized_init = atoi(arg_val);
1805  return;
1806  }
1807  if(!strcmp(arg_name, "cbh_grad_eps")){
1808  cbh_grad_eps = atof(arg_val);
1809  return;
1810  }
1812  if(!strcmp(arg_name, "spl_control_size")){
1813  spl_control_size = atoi(arg_val);
1814  return;
1815  }
1816  if(!strcmp(arg_name, "spl_control_overlap")){
1817  spl_control_overlap = atof(arg_val);
1818  return;
1819  }
1820  if(!strcmp(arg_name, "spl_interp_type")){
1821  spl_interp_type = atoi(arg_val);
1822  return;
1823  }
1824  if(!strcmp(arg_name, "spl_static_wts")){
1825  spl_static_wts = atoi(arg_val);
1826  return;
1827  }
1828  if(!strcmp(arg_name, "spl_debug_mode")){
1829  spl_debug_mode = atoi(arg_val);
1830  return;
1831  }
1833  if(!strcmp(arg_name, "scv_hist_type")){
1834  scv_hist_type = atoi(arg_val);
1835  return;
1836  }
1837  if(!strcmp(arg_name, "scv_use_bspl")){
1838  scv_use_bspl = atoi(arg_val);
1839  return;
1840  }
1841  if(!strcmp(arg_name, "scv_n_bins")){
1842  scv_n_bins = atoi(arg_val);
1843  return;
1844  }
1845  if(!strcmp(arg_name, "scv_preseed")){
1846  scv_preseed = atof(arg_val);
1847  return;
1848  }
1849  if(!strcmp(arg_name, "scv_pou")){
1850  scv_pou = atoi(arg_val);
1851  return;
1852  }
1853  if(!strcmp(arg_name, "scv_weighted_mapping")){
1854  scv_weighted_mapping = atoi(arg_val);
1855  return;
1856  }
1857  if(!strcmp(arg_name, "scv_mapped_gradient")){
1858  scv_mapped_gradient = atoi(arg_val);
1859  return;
1860  }
1861  if(!strcmp(arg_name, "scv_affine_mapping")){
1862  scv_affine_mapping = atoi(arg_val);
1863  return;
1864  }
1865  if(!strcmp(arg_name, "scv_once_per_frame")){
1866  scv_once_per_frame = atoi(arg_val);
1867  return;
1868  }
1869  if(!strcmp(arg_name, "scv_approx_dist_feat")){
1870  scv_approx_dist_feat = atoi(arg_val);
1871  return;
1872  }
1873  if(!strcmp(arg_name, "scv_likelihood_alpha")){
1874  scv_likelihood_alpha = atof(arg_val);
1875  return;
1876  }
1878  if(!strcmp(arg_name, "lscv_sub_regions")){
1879  lscv_sub_regions = atoi(arg_val);
1880  return;
1881  }
1882  if(!strcmp(arg_name, "lscv_spacing")){
1883  lscv_spacing = atoi(arg_val);
1884  return;
1885  }
1886  if(!strcmp(arg_name, "lscv_show_subregions")){
1887  lscv_show_subregions = atoi(arg_val);
1888  return;
1889  }
1891  if(!strcmp(arg_name, "lkld_pre_seed")){
1892  lkld_pre_seed = atof(arg_val);
1893  return;
1894  }
1895  if(!strcmp(arg_name, "lkld_pou")){
1896  lkld_pou = atoi(arg_val);
1897  return;
1898  }
1899  if(!strcmp(arg_name, "lkld_n_bins")){
1900  lkld_n_bins = atoi(arg_val);
1901  return;
1902  }
1903  if(!strcmp(arg_name, "lkld_sub_regions")){
1904  lkld_sub_regions = atoi(arg_val);
1905  return;
1906  }
1907  if(!strcmp(arg_name, "lkld_spacing")){
1908  lkld_spacing = atoi(arg_val);
1909  return;
1910  }
1912  if(!strcmp(arg_name, "ncc_fast_hess")){
1913  ncc_fast_hess = atoi(arg_val);
1914  return;
1915  }
1916  if(!strcmp(arg_name, "ncc_likelihood_alpha")){
1917  ncc_likelihood_alpha = atof(arg_val);
1918  return;
1919  }
1921  if(!strcmp(arg_name, "spss_k")){
1922  spss_k = atof(arg_val);
1923  return;
1924  }
1925  if(!strcmp(arg_name, "spss_likelihood_alpha")){
1926  spss_likelihood_alpha = atof(arg_val);
1927  return;
1928  }
1930  if(!strcmp(arg_name, "ssim_pix_proc_type")){
1931  ssim_pix_proc_type = atoi(arg_val);
1932  return;
1933  }
1934  if(!strcmp(arg_name, "ssim_k1")){
1935  ssim_k1 = atof(arg_val);
1936  return;
1937  }
1938  if(!strcmp(arg_name, "ssim_k2")){
1939  ssim_k2 = atof(arg_val);
1940  return;
1941  }
1942  if(!strcmp(arg_name, "ssim_likelihood_alpha")){
1943  ssim_likelihood_alpha = atof(arg_val);
1944  return;
1945  }
1947  if(!strcmp(arg_name, "sum_am1")){
1948  sum_am1 = std::string(arg_val);
1949  return;
1950  }
1951  if(!strcmp(arg_name, "sum_am2")){
1952  sum_am2 = std::string(arg_val);
1953  return;
1954  }
1956  if(!strcmp(arg_name, "sec_ord_hess")){
1957  sec_ord_hess = atoi(arg_val);
1958  return;
1959  }
1960  if(!strcmp(arg_name, "leven_marq")){
1961  leven_marq = atoi(arg_val);
1962  return;
1963  }
1964  if(!strcmp(arg_name, "lm_delta_init")){
1965  lm_delta_init = atof(arg_val);
1966  return;
1967  }
1968  if(!strcmp(arg_name, "lm_delta_update")){
1969  lm_delta_update = atof(arg_val);
1970  return;
1971  }
1973  if(!strcmp(arg_name, "enable_learning")){
1974  enable_learning = atof(arg_val);
1975  return;
1976  }
1977  if(!strcmp(arg_name, "learning_rate")){
1978  learning_rate = atof(arg_val);
1979  return;
1980  }
1982  if(!strcmp(arg_name, "esm_hess_type")){
1983  esm_hess_type = atoi(arg_val);
1984  return;
1985  }
1986  if(!strcmp(arg_name, "esm_jac_type")){
1987  esm_jac_type = atoi(arg_val);
1988  return;
1989  }
1990  if(!strcmp(arg_name, "esm_chained_warp")){
1991  esm_chained_warp = atoi(arg_val);
1992  return;
1993  }
1995  if(!strcmp(arg_name, "mi_pre_seed")){
1996  mi_pre_seed = atof(arg_val);
1997  return;
1998  }
1999  if(!strcmp(arg_name, "mi_pou")){
2000  mi_pou = atoi(arg_val);
2001  return;
2002  }
2003  if(!strcmp(arg_name, "mi_n_bins")){
2004  mi_n_bins = atoi(arg_val);
2005  return;
2006  }
2007  if(!strcmp(arg_name, "mi_likelihood_alpha")){
2008  mi_likelihood_alpha = atof(arg_val);
2009  return;
2010  }
2012  if(!strcmp(arg_name, "ccre_pre_seed")){
2013  ccre_pre_seed = atof(arg_val);
2014  return;
2015  }
2016  if(!strcmp(arg_name, "ccre_pou")){
2017  ccre_pou = atoi(arg_val);
2018  return;
2019  }
2020  if(!strcmp(arg_name, "ccre_n_bins")){
2021  ccre_n_bins = atoi(arg_val);
2022  return;
2023  }
2024  if(!strcmp(arg_name, "ccre_symmetrical_grad")){
2025  ccre_symmetrical_grad = atoi(arg_val);
2026  return;
2027  }
2028  if(!strcmp(arg_name, "ccre_n_blocks")){
2029  ccre_n_blocks = atoi(arg_val);
2030  return;
2031  }
2032  if(!strcmp(arg_name, "ccre_likelihood_alpha")){
2033  ccre_likelihood_alpha = atof(arg_val);
2034  return;
2035  }
2037  if(!strcmp(arg_name, "ngf_eta")){
2038  ngf_eta = atof(arg_val);
2039  return;
2040  }
2041  if(!strcmp(arg_name, "ngf_use_ssd")){
2042  ngf_use_ssd = atoi(arg_val);
2043  return;
2044  }
2046  if(!strcmp(arg_name, "diag_am")){
2047  processStringParam(diag_am, arg_val);
2048  return;
2049  }
2050  if(!strcmp(arg_name, "diag_ssm")){
2051  processStringParam(diag_ssm, arg_val);
2052  return;
2053  }
2054  if(!strcmp(arg_name, "diag_ilm")){
2055  processStringParam(diag_ilm, arg_val);
2056  return;
2057  }
2058  if(!strcmp(arg_name, "diag_range")){
2059  diag_range = atof(arg_val);
2060  return;
2061  }
2062  if(!strcmp(arg_name, "diag_ssm_range")){
2063  diag_ssm_range = atof_arr(arg_val);
2064  return;
2065  }
2066  if(!strcmp(arg_name, "diag_ssm_range_id")){
2067  diag_ssm_range_id = atoi(arg_val);
2068  return;
2069  }
2070  if(!strcmp(arg_name, "diag_am_range_id")){
2071  diag_am_range_id = atoi(arg_val);
2072  return;
2073  }
2074  if(!strcmp(arg_name, "diag_res")){
2075  diag_res = atoi(arg_val);
2076  return;
2077  }
2078  if(!strcmp(arg_name, "diag_3d")){
2079  diag_3d = atoi(arg_val);
2080  return;
2081  }
2082  if(!strcmp(arg_name, "diag_3d_ids")){
2083  diag_3d_ids = atoi_arr(arg_val);
2084  return;
2085  }
2086  if(!strcmp(arg_name, "diag_update_type")){
2087  diag_update_type = atoi(arg_val);
2088  return;
2089  }
2090  if(!strcmp(arg_name, "diag_start_id")){
2091  diag_start_id = atoi(arg_val);
2092  return;
2093  }
2094  if(!strcmp(arg_name, "diag_end_id")){
2095  diag_end_id = atoi(arg_val);
2096  return;
2097  }
2098  if(!strcmp(arg_name, "diag_grad_diff")){
2099  diag_grad_diff = atof(arg_val);
2100  return;
2101  }
2102  if(!strcmp(arg_name, "diag_gen_norm")){
2103  diag_gen_norm = std::string(arg_val);
2104  return;
2105  }
2106  if(!strcmp(arg_name, "diag_gen_jac")){
2107  diag_gen_jac = std::string(arg_val);
2108  return;
2109  }
2110  if(!strcmp(arg_name, "diag_gen_hess")){
2111  diag_gen_hess = std::string(arg_val);
2112  return;
2113  }
2114  if(!strcmp(arg_name, "diag_gen_hess2")){
2115  diag_gen_hess2 = std::string(arg_val);
2116  return;
2117  }
2118  if(!strcmp(arg_name, "diag_gen_hess_sum")){
2119  diag_gen_hess_sum = std::string(arg_val);
2120  return;
2121  }
2122  if(!strcmp(arg_name, "diag_gen_num")){
2123  diag_gen_num = std::string(arg_val);
2124  return;
2125  }
2126  if(!strcmp(arg_name, "diag_gen_ssm")){
2127  diag_gen_ssm = std::string(arg_val);
2128  return;
2129  }
2130  if(!strcmp(arg_name, "diag_bin")){
2131  diag_bin = atoi(arg_val);
2132  return;
2133  }
2134  if(!strcmp(arg_name, "diag_inv")){
2135  diag_inv = atoi(arg_val);
2136  return;
2137  }
2138  if(!strcmp(arg_name, "diag_frame_gap")){
2139  diag_frame_gap = atoi(arg_val);
2140  return;
2141  }
2142  if(!strcmp(arg_name, "diag_show_data")){
2143  diag_show_data = atoi(arg_val);
2144  return;
2145  }
2146  if(!strcmp(arg_name, "diag_show_corners")){
2147  diag_show_corners = atoi(arg_val);
2148  return;
2149  }
2150  if(!strcmp(arg_name, "diag_show_patches")){
2151  diag_show_patches = atoi(arg_val);
2152  return;
2153  }
2154  if(!strcmp(arg_name, "diag_verbose")){
2155  diag_verbose = atoi(arg_val);
2156  return;
2157  }
2158  if(!strcmp(arg_name, "diag_enable_validation")){
2159  diag_enable_validation = atoi(arg_val);
2160  return;
2161  }
2162  if(!strcmp(arg_name, "diag_validation_prec")){
2163  diag_validation_prec = atof(arg_val);
2164  return;
2165  }
2166  if(!strcmp(arg_name, "diag_out_prefix")){
2167  diag_out_prefix = std::string(arg_val);
2168  return;
2169  }
2171  if(!strcmp(arg_name, "esm_spi_enable")){
2172  esm_spi_enable = atoi(arg_val);
2173  return;
2174  }
2175  if(!strcmp(arg_name, "esm_spi_thresh")){
2176  esm_spi_thresh = atof(arg_val);
2177  return;
2178  }
2179 
2180  if(!strcmp(arg_name, "pix_mapper")){
2181  processStringParam(pix_mapper, arg_val);;
2182  return;
2183  }
2185  if(!strcmp(arg_name, "nn_max_iters")){
2186  nn_max_iters = atoi(arg_val);
2187  return;
2188  }
2189  if(!strcmp(arg_name, "nn_n_samples")){
2190  nn_n_samples = atoi(arg_val);
2191  return;
2192  }
2193  if(!strcmp(arg_name, "nn_ssm_sigma_prec")){
2194  nn_ssm_sigma_prec = atof(arg_val);
2195  return;
2196  }
2197  if(!strcmp(arg_name, "nn_additive_update")){
2198  nn_additive_update = atoi(arg_val);
2199  return;
2200  }
2201  if(!strcmp(arg_name, "nn_show_samples")){
2202  nn_show_samples = atoi(arg_val);
2203  return;
2204  }
2205  if(!strcmp(arg_name, "nn_add_samples_gap")){
2206  nn_add_samples_gap = atoi(arg_val);
2207  return;
2208  }
2209  if(!strcmp(arg_name, "nn_n_samples_to_add")){
2210  nn_n_samples_to_add = atoi(arg_val);
2211  return;
2212  }
2213  if(!strcmp(arg_name, "nn_remove_samples")){
2214  nn_remove_samples = atoi(arg_val);
2215  return;
2216  }
2217  if(!strcmp(arg_name, "nn_ssm_sigma_ids")){
2218  nn_ssm_sigma_ids = atoi_arr(arg_val);
2219  return;
2220  }
2221  if(!strcmp(arg_name, "nn_ssm_mean_ids")){
2222  nn_ssm_mean_ids = atoi_arr(arg_val);
2223  return;
2224  }
2225  if(!strcmp(arg_name, "nn_corner_sigma_d")){
2226  nn_corner_sigma_d = atof(arg_val);
2227  return;
2228  }
2229  if(!strcmp(arg_name, "nn_corner_sigma_t")){
2230  nn_corner_sigma_t = atof(arg_val);
2231  return;
2232  }
2233  if(!strcmp(arg_name, "nn_pix_sigma")){
2234  nn_pix_sigma = atof_arr(arg_val);
2235  return;
2236  }
2237  if(!strcmp(arg_name, "nn_n_trees")){
2238  nn_n_trees = atoi(arg_val);
2239  return;
2240  }
2241  if(!strcmp(arg_name, "nn_index_type")){
2242  nn_index_type = atoi(arg_val);
2243  return;
2244  }
2245  if(!strcmp(arg_name, "nn_search_type")){
2246  nn_search_type = atoi(arg_val);
2247  return;
2248  }
2249  if(!strcmp(arg_name, "nn_save_index")){
2250  nn_save_index = atoi(arg_val);
2251  return;
2252  }
2253  if(!strcmp(arg_name, "nn_load_index")){
2254  nn_load_index = atoi(arg_val);
2255  return;
2256  }
2257  if(!strcmp(arg_name, "nn_saved_index_fid")){
2258  nn_saved_index_fid = atoi(arg_val);
2259  return;
2260  }
2262  if(!strcmp(arg_name, "nn_srch_checks")){
2263  nn_srch_checks = atoi(arg_val);
2264  return;
2265  }
2266  if(!strcmp(arg_name, "nn_srch_eps")){
2267  nn_srch_eps = atof32(arg_val);
2268  return;
2269  }
2270  if(!strcmp(arg_name, "nn_srch_sorted")){
2271  nn_srch_sorted = atoi(arg_val);
2272  return;
2273  }
2274  if(!strcmp(arg_name, "nn_srch_max_neighbors")){
2275  nn_srch_max_neighbors = atoi(arg_val);
2276  return;
2277  }
2278  if(!strcmp(arg_name, "nn_srch_cores")){
2279  nn_srch_cores = atoi(arg_val);
2280  return;
2281  }
2282  if(!strcmp(arg_name, "nn_srch_matrices_in_gpu_ram")){
2283  nn_srch_matrices_in_gpu_ram = atoi(arg_val);
2284  return;
2285  }
2286  if(!strcmp(arg_name, "nn_srch_use_heap")){
2287  nn_srch_use_heap = atoi(arg_val);
2288  return;
2289  }
2290  if(!strcmp(arg_name, "nn_gnn_degree")){
2291  nn_gnn_degree = atoi(arg_val);
2292  return;
2293  }
2294  if(!strcmp(arg_name, "nn_gnn_max_steps")){
2295  nn_gnn_max_steps = atoi(arg_val);
2296  return;
2297  }
2298  if(!strcmp(arg_name, "nn_gnn_cmpt_dist_thresh")){
2299  nn_gnn_cmpt_dist_thresh = atoi(arg_val);
2300  return;
2301  }
2302  if(!strcmp(arg_name, "nn_gnn_random_start")){
2303  nn_gnn_random_start = atoi(arg_val);
2304  return;
2305  }
2306  if(!strcmp(arg_name, "nn_fgnn_index_type")){
2307  nn_fgnn_index_type = atoi(arg_val);
2308  return;
2309  }
2310  if(!strcmp(arg_name, "nn_gnn_verbose")){
2311  nn_gnn_verbose = atoi(arg_val);
2312  return;
2313  }
2314  if(!strcmp(arg_name, "nn_kdt_trees")){
2315  nn_kdt_trees = atoi(arg_val);
2316  return;
2317  }
2318  if(!strcmp(arg_name, "nn_km_branching")){
2319  nn_km_branching = atoi(arg_val);
2320  return;
2321  }
2322  if(!strcmp(arg_name, "nn_km_iterations")){
2323  nn_km_iterations = atoi(arg_val);
2324  return;
2325  }
2326  if(!strcmp(arg_name, "nn_km_centers_init")){
2327  nn_km_centers_init = atoi(arg_val);
2328  return;
2329  }
2330  if(!strcmp(arg_name, "nn_km_cb_index")){
2331  nn_km_cb_index = atof32(arg_val);
2332  return;
2333  }
2334  if(!strcmp(arg_name, "nn_kdts_leaf_max_size")){
2335  nn_kdts_leaf_max_size = atoi(arg_val);
2336  return;
2337  }
2338  if(!strcmp(arg_name, "nn_kdtc_leaf_max_size")){
2339  nn_kdtc_leaf_max_size = atoi(arg_val);
2340  return;
2341  }
2342  if(!strcmp(arg_name, "nn_hc_branching")){
2343  nn_hc_branching = atoi(arg_val);
2344  return;
2345  }
2346  if(!strcmp(arg_name, "nn_hc_centers_init")){
2347  nn_hc_centers_init = atoi(arg_val);
2348  return;
2349  }
2350  if(!strcmp(arg_name, "nn_hc_trees")){
2351  nn_hc_trees = atoi(arg_val);
2352  return;
2353  }
2354  if(!strcmp(arg_name, "nn_hc_leaf_max_size")){
2355  nn_hc_leaf_max_size = atoi(arg_val);
2356  return;
2357  }
2358  if(!strcmp(arg_name, "nn_auto_target_precision")){
2359  nn_auto_target_precision = atof32(arg_val);
2360  return;
2361  }
2362  if(!strcmp(arg_name, "ann_uto_build_weight")){
2363  nn_auto_build_weight = atof32(arg_val);
2364  return;
2365  }
2366  if(!strcmp(arg_name, "nn_auto_memory_weight")){
2367  nn_auto_memory_weight = atof32(arg_val);
2368  return;
2369  }
2370  if(!strcmp(arg_name, "nn_auto_sample_fraction")){
2371  nn_auto_sample_fraction = atof32(arg_val);
2372  return;
2373  }
2374  if(!strcmp(arg_name, "nnk_n_layers")){
2375  nnk_n_layers = atoi(arg_val);
2376  return;
2377  }
2378  if(!strcmp(arg_name, "nnk_ssm_sigma_ids")){
2379  nnk_ssm_sigma_ids.push_back(atoi_arr(arg_val));
2380  return;
2381  }
2383  if(!strcmp(arg_name, "rg_max_iters")){
2384  rg_max_iters = atoi(arg_val);
2385  return;
2386  }
2387  if(!strcmp(arg_name, "rg_n_samples")){
2388  rg_n_samples = atoi(arg_val);
2389  return;
2390  }
2391  if(!strcmp(arg_name, "rg_additive_update")){
2392  rg_additive_update = atoi(arg_val);
2393  return;
2394  }
2395  if(!strcmp(arg_name, "rg_show_samples")){
2396  rg_show_samples = atoi(arg_val);
2397  return;
2398  }
2399  if(!strcmp(arg_name, "rg_add_points")){
2400  rg_add_points = atoi(arg_val);
2401  return;
2402  }
2403  if(!strcmp(arg_name, "rg_remove_points")){
2404  rg_remove_points = atoi(arg_val);
2405  return;
2406  }
2407  if(!strcmp(arg_name, "rg_ssm_sigma_ids")){
2408  rg_ssm_sigma_ids = atoi_arr(arg_val);
2409  return;
2410  }
2411  if(!strcmp(arg_name, "rg_ssm_mean_ids")){
2412  rg_ssm_mean_ids = atoi_arr(arg_val);
2413  return;
2414  }
2415  if(!strcmp(arg_name, "rg_pix_sigma")){
2416  rg_pix_sigma = atof_arr(arg_val);
2417  return;
2418  }
2419  if(!strcmp(arg_name, "rg_save_index")){
2420  rg_save_index = atoi(arg_val);
2421  return;
2422  }
2423  if(!strcmp(arg_name, "rg_load_index")){
2424  rg_load_index = atoi(arg_val);
2425  return;
2426  }
2427  if(!strcmp(arg_name, "rg_saved_index_fid")){
2428  rg_saved_index_fid = atoi(arg_val);
2429  return;
2430  }
2431  if(!strcmp(arg_name, "rg_nepochs")){
2432  rg_nepochs = atoi(arg_val);
2433  return;
2434  }
2435  if(!strcmp(arg_name, "rg_bs")){
2436  rg_bs = atoi(arg_val);
2437  return;
2438  }
2439  if(!strcmp(arg_name, "rg_preproc")){
2440  rg_preproc = atoi(arg_val);
2441  return;
2442  }
2443  if(!strcmp(arg_name, "rg_solver")){
2444  processStringParam(rg_solver, arg_val);;
2445  return;
2446  }
2447  if(!strcmp(arg_name, "rg_train")){
2448  processStringParam(rg_train, arg_val);;
2449  return;
2450  }
2451  if(!strcmp(arg_name, "rg_mean")){
2452  processStringParam(rg_mean, arg_val);;
2453  return;
2454  }
2455  if(!strcmp(arg_name, "rg_dbg")){
2456  rg_dbg = atoi(arg_val);
2457  return;
2458  }
2459  if(!strcmp(arg_name, "rg_pretrained")){
2460  rg_pretrained = atoi(arg_val);
2461  return;
2462  }
2463 
2465  if(!strcmp(arg_name, "riu_likelihood_alpha")){
2466  riu_likelihood_alpha = atof(arg_val);
2467  return;
2468  }
2470  if(!strcmp(arg_name, "hrch_sm")){
2471  processStringParam(hrch_sm, arg_val);
2472  return;
2473  }
2474  if(!strcmp(arg_name, "hrch_am")){
2475  processStringParam(hrch_am, arg_val);
2476  return;
2477  }
2479  if(!strcmp(arg_name, "casc_n_trackers")){
2480  casc_n_trackers = atoi(arg_val);
2481  return;
2482  }
2483  if(!strcmp(arg_name, "casc_enable_feedback")){
2484  casc_enable_feedback = atoi(arg_val);
2485  return;
2486  }
2487  if(!strcmp(arg_name, "casc_auto_reinit")) {
2488  casc_auto_reinit = atoi(arg_val);
2489  return;
2490  }
2491  if(!strcmp(arg_name, "casc_reinit_err_thresh")) {
2492  casc_reinit_err_thresh = atof(arg_val);
2493  return;
2494  }
2495  if(!strcmp(arg_name, "casc_reinit_frame_gap")) {
2496  casc_reinit_frame_gap = atoi(arg_val);
2497  return;
2498  }
2500  if(!strcmp(arg_name, "grid_sm")){
2501  processStringParam(grid_sm, arg_val);
2502  return;
2503  }
2504  if(!strcmp(arg_name, "grid_am")){
2505  processStringParam(grid_am, arg_val);
2506  return;
2507  }
2508  if(!strcmp(arg_name, "grid_ssm")){
2509  processStringParam(grid_ssm, arg_val);
2510  return;
2511  }
2512  if(!strcmp(arg_name, "grid_ilm")){
2513  processStringParam(grid_ilm, arg_val);
2514  return;
2515  }
2516  if(!strcmp(arg_name, "grid_res")){
2517  grid_res = atoi(arg_val);
2518  return;
2519  }
2520  if(!strcmp(arg_name, "grid_patch_size")){
2521  grid_patch_size = atoi(arg_val);
2522  return;
2523  }
2524  if(!strcmp(arg_name, "grid_patch_res")){
2525  grid_patch_res = atoi(arg_val);
2526  return;
2527  }
2528  if(!strcmp(arg_name, "grid_reset_at_each_frame")){
2529  grid_reset_at_each_frame = atoi(arg_val);
2530  return;
2531  }
2532  if(!strcmp(arg_name, "grid_dyn_patch_size")){
2533  grid_dyn_patch_size = atoi(arg_val);
2534  return;
2535  }
2536  if(!strcmp(arg_name, "grid_patch_centroid_inside")){
2537  grid_patch_centroid_inside = atoi(arg_val);
2538  return;
2539  }
2540  if(!strcmp(arg_name, "grid_show_trackers")){
2541  grid_show_trackers = atoi(arg_val);
2542  return;
2543  }
2544  if(!strcmp(arg_name, "grid_show_tracker_edges")){
2545  grid_show_tracker_edges = atoi(arg_val);
2546  return;
2547  }
2548  if(!strcmp(arg_name, "grid_use_tbb")){
2549  grid_use_tbb = atoi(arg_val);
2550  return;
2551  }
2552  if(!strcmp(arg_name, "grid_pyramid_levels")){
2553  grid_pyramid_levels = atoi(arg_val);
2554  return;
2555  }
2556  if(!strcmp(arg_name, "grid_use_min_eig_vals")){
2557  grid_use_min_eig_vals = atoi(arg_val);
2558  return;
2559  }
2560  if(!strcmp(arg_name, "grid_rgb_input")){
2561  grid_rgb_input = atoi(arg_val);
2562  return;
2563  }
2564  if(!strcmp(arg_name, "grid_min_eig_thresh")){
2565  grid_min_eig_thresh = atof(arg_val);
2566  return;
2567  }
2568  if(!strcmp(arg_name, "grid_fb_err_thresh")){
2569  grid_fb_err_thresh = atof(arg_val);
2570  return;
2571  }
2572  if(!strcmp(arg_name, "grid_fb_reinit")){
2573  grid_fb_reinit = atoi(arg_val);
2574  return;
2575  }
2576  if(!strcmp(arg_name, "grid_use_const_grad")){
2577  grid_use_const_grad = atoi(arg_val);
2578  return;
2579  }
2581  if(!strcmp(arg_name, "feat_detector_type")){
2582  feat_detector_type = std::string(arg_val);
2583  return;
2584  }
2585  if(!strcmp(arg_name, "feat_descriptor_type")){
2586  feat_descriptor_type = std::string(arg_val);
2587  return;
2588  }
2589  if(!strcmp(arg_name, "feat_max_dist_ratio")){
2590  feat_max_dist_ratio = atof(arg_val);
2591  return;
2592  } if(!strcmp(arg_name, "feat_min_matches")){
2593  feat_min_matches = atoi(arg_val);
2594  return;
2595  }
2596  if(!strcmp(arg_name, "feat_rebuild_index")){
2597  feat_rebuild_index = atoi(arg_val);
2598  return;
2599  }
2600  if(!strcmp(arg_name, "feat_use_cv_flann")){
2601  feat_use_cv_flann = atoi(arg_val);
2602  return;
2603  } if(!strcmp(arg_name, "feat_show_keypoints")){
2604  feat_show_keypoints = atoi(arg_val);
2605  return;
2606  } if(!strcmp(arg_name, "feat_show_matches")){
2607  feat_show_matches = atoi(arg_val);
2608  return;
2609  } if(!strcmp(arg_name, "feat_debug_mode")){
2610  feat_debug_mode = atoi(arg_val);
2611  return;
2612  }
2613 
2615  if(!strcmp(arg_name, "sift_n_features")){
2616  sift_n_features = atoi(arg_val);
2617  return;
2618  }
2619  if(!strcmp(arg_name, "sift_n_octave_layers")){
2620  sift_n_octave_layers = atoi(arg_val);
2621  return;
2622  }
2623  if(!strcmp(arg_name, "sift_edge_thresh")){
2624  sift_edge_thresh = atof(arg_val);
2625  return;
2626  }
2627  if(!strcmp(arg_name, "sift_contrast_thresh")){
2628  sift_contrast_thresh = atof(arg_val);
2629  return;
2630  }
2631  if(!strcmp(arg_name, "sift_sigma")){
2632  sift_sigma = atof(arg_val);
2633  return;
2634  }
2636  if(!strcmp(arg_name, "surf_hessian_threshold")){
2637  surf_hessian_threshold = atof(arg_val);
2638  return;
2639  }
2640  if(!strcmp(arg_name, "surf_n_octaves")){
2641  surf_n_octaves = atoi(arg_val);
2642  return;
2643  }
2644  if(!strcmp(arg_name, "surf_n_octave_layers")){
2645  surf_n_octave_layers = atoi(arg_val);
2646  return;
2647  }
2648  if(!strcmp(arg_name, "surf_extended")){
2649  surf_extended = atoi(arg_val);
2650  return;
2651  }
2652  if(!strcmp(arg_name, "surf_upright")){
2653  surf_upright = atoi(arg_val);
2654  return;
2655  }
2657  if(!strcmp(arg_name, "fast_non_max_suppression")){
2658  fast_non_max_suppression = atoi(arg_val);
2659  return;
2660  }
2661  if(!strcmp(arg_name, "fast_threshold")){
2662  fast_threshold = atoi(arg_val);
2663  return;
2664  }
2665  if(!strcmp(arg_name, "fast_type")){
2666  fast_type = atoi(arg_val);
2667  return;
2668  }
2670  if(!strcmp(arg_name, "brisk_thresh")){
2671  brisk_thresh = atoi(arg_val);
2672  return;
2673  }
2674  if(!strcmp(arg_name, "brisk_octaves")){
2675  brisk_octaves = atoi(arg_val);
2676  return;
2677  }
2678  if(!strcmp(arg_name, "brisk_pattern_scale")){
2679  brisk_pattern_scale = atof32(arg_val);
2680  return;
2681  }
2683  if(!strcmp(arg_name, "mser_delta")){
2684  mser_delta = atoi(arg_val);
2685  return;
2686  }
2687  if(!strcmp(arg_name, "mser_min_area")){
2688  mser_min_area = atoi(arg_val);
2689  return;
2690  }
2691  if(!strcmp(arg_name, "mser_max_area")){
2692  mser_max_area = atoi(arg_val);
2693  return;
2694  }
2695  if(!strcmp(arg_name, "mser_max_evolution")){
2696  mser_max_evolution = atoi(arg_val);
2697  return;
2698  }
2699  if(!strcmp(arg_name, "mser_edge_blur_size")){
2700  mser_edge_blur_size = atoi(arg_val);
2701  return;
2702  }
2703  if(!strcmp(arg_name, "mser_max_variation")){
2704  mser_max_variation = atof(arg_val);
2705  return;
2706  }
2707  if(!strcmp(arg_name, "mser_min_diversity")){
2708  mser_min_diversity = atof(arg_val);
2709  return;
2710  }
2711  if(!strcmp(arg_name, "mser_area_threshold")){
2712  mser_area_threshold = atof(arg_val);
2713  return;
2714  }
2715  if(!strcmp(arg_name, "mser_min_margin")){
2716  mser_min_margin = atof(arg_val);
2717  return;
2718  }
2720  if(!strcmp(arg_name, "orb_n_features")){
2721  orb_n_features = atoi(arg_val);
2722  return;
2723  }
2724  if(!strcmp(arg_name, "orb_scale_factor")){
2725  orb_scale_factor = atof32(arg_val);
2726  return;
2727  }
2728  if(!strcmp(arg_name, "orb_n_levels")){
2729  orb_n_levels = atoi(arg_val);
2730  return;
2731  }
2732  if(!strcmp(arg_name, "orb_edge_threshold")){
2733  orb_edge_threshold = atoi(arg_val);
2734  return;
2735  }
2736  if(!strcmp(arg_name, "orb_first_level")){
2737  orb_first_level = atoi(arg_val);
2738  return;
2739  }
2740  if(!strcmp(arg_name, "orb_WTA_K")){
2741  orb_WTA_K = atoi(arg_val);
2742  return;
2743  }
2744  if(!strcmp(arg_name, "orb_score_type")){
2745  orb_score_type = atoi(arg_val);
2746  return;
2747  }
2748  if(!strcmp(arg_name, "orb_patch_size")){
2749  orb_patch_size = atoi(arg_val);
2750  return;
2751  }
2752  if(!strcmp(arg_name, "orb_fast_threshold")){
2753  orb_fast_threshold = atoi(arg_val);
2754  return;
2755  }
2757  if(!strcmp(arg_name, "agast_non_max_suppression")){
2758  agast_non_max_suppression = atoi(arg_val);
2759  return;
2760  }
2761  if(!strcmp(arg_name, "agast_threshold")){
2762  agast_threshold = atoi(arg_val);
2763  return;
2764  }
2765  if(!strcmp(arg_name, "agast_type")){
2766  agast_type = atoi(arg_val);
2767  return;
2768  }
2770  if(!strcmp(arg_name, "gftt_max_corners")){
2771  gftt_max_corners = atoi(arg_val);
2772  return;
2773  }
2774  if(!strcmp(arg_name, "gftt_quality_level")){
2775  gftt_quality_level = atof(arg_val);
2776  return;
2777  }
2778  if(!strcmp(arg_name, "gftt_min_distance")){
2779  gftt_min_distance = atof(arg_val);
2780  return;
2781  }
2782  if(!strcmp(arg_name, "gftt_block_size")){
2783  gftt_block_size = atoi(arg_val);
2784  return;
2785  }
2786  if(!strcmp(arg_name, "gftt_use_harris_detector")){
2787  gftt_use_harris_detector = atoi(arg_val);
2788  return;
2789  }
2790  if(!strcmp(arg_name, "gftt_k")){
2791  gftt_k = atof(arg_val);
2792  return;
2793  }
2795  if(!strcmp(arg_name, "brief_bytes")){
2796  brief_bytes = atoi(arg_val);
2797  return;
2798  }
2799  if(!strcmp(arg_name, "brief_use_orientation")){
2800  brief_use_orientation = atoi(arg_val);
2801  return;
2802  }
2804  if(!strcmp(arg_name, "freak_orientation_normalized")){
2805  freak_orientation_normalized = atoi(arg_val);
2806  return;
2807  }
2808  if(!strcmp(arg_name, "freak_scale_normalized")){
2809  freak_scale_normalized = atoi(arg_val);
2810  return;
2811  }
2812  if(!strcmp(arg_name, "freak_pattern_scale")){
2813  freak_pattern_scale = atof32(arg_val);
2814  return;
2815  }
2816  if(!strcmp(arg_name, "freak_n_octaves")){
2817  freak_n_octaves = atoi(arg_val);
2818  return;
2819  }
2821  if(!strcmp(arg_name, "lucid_kernel")){
2822  lucid_kernel = atoi(arg_val);
2823  return;
2824  }
2825  if(!strcmp(arg_name, "lucid_blur_kernel")){
2826  lucid_blur_kernel = atoi(arg_val);
2827  return;
2828  }
2830  if(!strcmp(arg_name, "latch_bytes")){
2831  latch_bytes = atoi(arg_val);
2832  return;
2833  }
2834  if(!strcmp(arg_name, "latch_rotation_invariance")){
2835  latch_rotation_invariance = atoi(arg_val);
2836  return;
2837  }
2838  if(!strcmp(arg_name, "latch_half_ssd_size")){
2839  latch_half_ssd_size = atoi(arg_val);
2840  return;
2841  }
2843  if(!strcmp(arg_name, "daisy_radius")){
2844  daisy_radius = atof32(arg_val);
2845  return;
2846  }
2847  if(!strcmp(arg_name, "daisy_q_radius")){
2848  daisy_q_radius = atoi(arg_val);
2849  return;
2850  }
2851  if(!strcmp(arg_name, "daisy_q_theta")){
2852  daisy_q_theta = atoi(arg_val);
2853  return;
2854  }
2855  if(!strcmp(arg_name, "daisy_q_hist")){
2856  daisy_q_hist = atoi(arg_val);
2857  return;
2858  }
2859  if(!strcmp(arg_name, "daisy_H")){
2860  daisy_H = atof32_arr(arg_val);
2861  return;
2862  }
2863  if(!strcmp(arg_name, "daisy_interpolation")){
2864  daisy_interpolation = atoi(arg_val);
2865  return;
2866  }
2867  if(!strcmp(arg_name, "daisy_use_orientation")){
2868  daisy_use_orientation = atoi(arg_val);
2869  return;
2870  }
2872  if(!strcmp(arg_name, "vgg_desc")){
2873  vgg_desc = atoi(arg_val);
2874  return;
2875  }
2876  if(!strcmp(arg_name, "vgg_isigma")){
2877  vgg_isigma = atof32(arg_val);
2878  return;
2879  }
2880  if(!strcmp(arg_name, "vgg_img_normalize")){
2881  vgg_img_normalize = atoi(arg_val);
2882  return;
2883  }
2884  if(!strcmp(arg_name, "vgg_use_scale_orientation")){
2885  vgg_use_scale_orientation = atoi(arg_val);
2886  return;
2887  }
2888  if(!strcmp(arg_name, "vgg_scale_factor")){
2889  vgg_scale_factor = atof32(arg_val);
2890  return;
2891  }
2892  if(!strcmp(arg_name, "vgg_dsc_normalize")){
2893  vgg_dsc_normalize = atoi(arg_val);
2894  return;
2895  }
2897  if(!strcmp(arg_name, "boost_desc_desc")){
2898  boost_desc_desc = atoi(arg_val);
2899  return;
2900  }
2901  if(!strcmp(arg_name, "boost_desc_use_scale_orientation")){
2902  boost_desc_use_scale_orientation = atoi(arg_val);
2903  return;
2904  }
2905  if(!strcmp(arg_name, "boost_desc_scale_factor")){
2906  boost_desc_scale_factor = atof32(arg_val);
2907  return;
2908  }
2910  if(!strcmp(arg_name, "star_max_size")){
2911  star_max_size = atoi(arg_val);
2912  return;
2913  }
2914  if(!strcmp(arg_name, "star_response_threshold")){
2915  star_response_threshold = atoi(arg_val);
2916  return;
2917  }
2918  if(!strcmp(arg_name, "star_line_threshold_projected")){
2919  star_line_threshold_projected = atoi(arg_val);
2920  return;
2921  }
2922  if(!strcmp(arg_name, "star_line_threshold_binarized")){
2923  star_line_threshold_binarized = atoi(arg_val);
2924  return;
2925  }
2926  if(!strcmp(arg_name, "star_suppress_nonmax_size")){
2927  star_suppress_nonmax_size = atoi(arg_val);
2928  return;
2929  }
2931  if(!strcmp(arg_name, "msd_patch_radius")){
2932  msd_patch_radius = atoi(arg_val);
2933  return;
2934  }
2935  if(!strcmp(arg_name, "msd_search_area_radius")){
2936  msd_search_area_radius = atoi(arg_val);
2937  return;
2938  }
2939  if(!strcmp(arg_name, "msd_nms_radius")){
2940  msd_nms_radius = atoi(arg_val);
2941  return;
2942  }
2943  if(!strcmp(arg_name, "msd_nms_scale_radius")){
2944  msd_nms_scale_radius = atoi(arg_val);
2945  return;
2946  }
2947  if(!strcmp(arg_name, "msd_th_saliency")){
2948  msd_th_saliency = atof32(arg_val);
2949  return;
2950  }
2951  if(!strcmp(arg_name, "msd_kNN")){
2952  msd_kNN = atoi(arg_val);
2953  return;
2954  }
2955  if(!strcmp(arg_name, "msd_scale_factor")){
2956  msd_scale_factor = atof32(arg_val);
2957  return;
2958  }
2959  if(!strcmp(arg_name, "msd_n_scales")){
2960  msd_n_scales = atoi(arg_val);
2961  return;
2962  }
2963  if(!strcmp(arg_name, "msd_compute_orientation")){
2964  msd_compute_orientation = atoi(arg_val);
2965  return;
2966  }
2967 
2969  if(!strcmp(arg_name, "est_method")){
2970  est_method = atoi(arg_val);
2971  return;
2972  }
2973  if(!strcmp(arg_name, "est_ransac_reproj_thresh")){
2974  est_ransac_reproj_thresh = atof(arg_val);
2975  return;
2976  }
2977  if(!strcmp(arg_name, "est_n_model_pts")){
2978  est_n_model_pts = atoi(arg_val);
2979  return;
2980  }
2981  if(!strcmp(arg_name, "est_max_iters")){
2982  est_max_iters = atoi(arg_val);
2983  return;
2984  }
2985  if(!strcmp(arg_name, "est_max_subset_attempts")){
2986  est_max_subset_attempts = atoi(arg_val);
2987  return;
2988  }
2989  if(!strcmp(arg_name, "est_use_boost_rng")){
2990  est_use_boost_rng = atoi(arg_val);
2991  return;
2992  }
2993  if(!strcmp(arg_name, "est_confidence")){
2994  est_confidence = atof(arg_val);
2995  return;
2996  }
2997  if(!strcmp(arg_name, "est_refine")){
2998  est_refine = atoi(arg_val);
2999  return;
3000  }
3001  if(!strcmp(arg_name, "est_lm_max_iters")){
3002  est_lm_max_iters = atoi(arg_val);
3003  return;
3004  }
3006  if(!strcmp(arg_name, "rkl_sm")){
3007  processStringParam(rkl_sm, arg_val);
3008  return;
3009  }
3010  if(!strcmp(arg_name, "rkl_enable_spi")){
3011  rkl_enable_spi = atoi(arg_val);
3012  return;
3013  }
3014  if(!strcmp(arg_name, "rkl_enable_feedback")){
3015  rkl_enable_feedback = atoi(arg_val);
3016  return;
3017  }
3018  if(!strcmp(arg_name, "rkl_failure_detection")){
3019  rkl_failure_detection = atoi(arg_val);
3020  return;
3021  }
3022  if(!strcmp(arg_name, "rkl_failure_thresh")){
3023  rkl_failure_thresh = atof(arg_val);
3024  return;
3025  }
3027  if(!strcmp(arg_name, "prl_n_trackers")) {
3028  prl_n_trackers = atoi(arg_val);
3029  return;
3030  }
3031  if(!strcmp(arg_name, "prl_estimation_method")) {
3032  prl_estimation_method = atoi(arg_val);
3033  return;
3034  }
3035  if(!strcmp(arg_name, "prl_reset_to_mean")) {
3036  prl_reset_to_mean = atoi(arg_val);
3037  return;
3038  }
3039  if(!strcmp(arg_name, "prl_auto_reinit")) {
3040  prl_auto_reinit = atoi(arg_val);
3041  return;
3042  }
3043  if(!strcmp(arg_name, "prl_reinit_err_thresh")) {
3044  prl_reinit_err_thresh = atof(arg_val);
3045  return;
3046  }
3047  if(!strcmp(arg_name, "prl_reinit_frame_gap")) {
3048  prl_reinit_frame_gap = atoi(arg_val);
3049  return;
3050  }
3052  if(!strcmp(arg_name, "pyr_sm")) {
3053  pyr_sm = std::string(arg_val);
3054  return;
3055  }
3056  if(!strcmp(arg_name, "pyr_no_of_levels")) {
3057  pyr_no_of_levels = atoi(arg_val);
3058  return;
3059  }
3060  if(!strcmp(arg_name, "pyr_scale_factor")) {
3061  pyr_scale_factor = atof(arg_val);
3062  return;
3063  }
3064  if(!strcmp(arg_name, "pyr_scale_res")) {
3065  pyr_scale_res = atoi(arg_val);
3066  return;
3067  }
3068  if(!strcmp(arg_name, "pyr_show_levels")) {
3069  pyr_show_levels = atoi(arg_val);
3070  return;
3071  }
3073  if(!strcmp(arg_name, "sd_learning_rate")){
3074  sd_learning_rate = atof(arg_val);
3075  return;
3076  }
3078  if(!strcmp(arg_name, "gb_additive_update")){
3079  gb_additive_update = atoi(arg_val);
3080  return;
3081  }
3083  if(!strcmp(arg_name, "pgb_additive_update")){
3084  pgb_additive_update = atoi(arg_val);
3085  return;
3086  }
3087  if(!strcmp(arg_name, "pgb_sub_regions_x")){
3088  pgb_sub_regions_x = atoi(arg_val);
3089  return;
3090  }
3091  if(!strcmp(arg_name, "pgb_sub_regions_y")){
3092  pgb_sub_regions_y = atoi(arg_val);
3093  return;
3094  }
3096  if(!strcmp(arg_name, "rbf_additive_update")){
3097  rbf_additive_update = atoi(arg_val);
3098  return;
3099  }
3100  if(!strcmp(arg_name, "rbf_n_ctrl_pts_x")){
3101  rbf_n_ctrl_pts_x = atoi(arg_val);
3102  return;
3103  }
3104  if(!strcmp(arg_name, "rbf_n_ctrl_pts_y")){
3105  rbf_n_ctrl_pts_y = atoi(arg_val);
3106  return;
3107  }
3109  if(!strcmp(arg_name, "pf_max_iters")){
3110  pf_max_iters = atoi(arg_val);
3111  return;
3112  }
3113  if(!strcmp(arg_name, "pf_n_particles")){
3114  pf_n_particles = atoi(arg_val);
3115  return;
3116  }
3117  if(!strcmp(arg_name, "pf_dynamic_model")){
3118  pf_dynamic_model = atoi(arg_val);
3119  return;
3120  }
3121  if(!strcmp(arg_name, "pf_update_type")){
3122  pf_update_type = atoi(arg_val);
3123  return;
3124  }
3125  if(!strcmp(arg_name, "pf_likelihood_func")){
3126  pf_likelihood_func = atoi(arg_val);
3127  return;
3128  }
3129  if(!strcmp(arg_name, "pf_resampling_type")){
3130  pf_resampling_type = atoi(arg_val);
3131  return;
3132  }
3133  if(!strcmp(arg_name, "pf_reset_to_mean")){
3134  pf_reset_to_mean = atoi(arg_val);
3135  return;
3136  }
3137  if(!strcmp(arg_name, "pf_mean_type")){
3138  pf_mean_type = atoi(arg_val);
3139  return;
3140  }
3141  if(!strcmp(arg_name, "pf_ssm_sigma_ids")){
3142  pf_ssm_sigma_ids = atoi_arr(arg_val);
3143  return;
3144  }
3145  if(!strcmp(arg_name, "pf_ssm_mean_ids")){
3146  pf_ssm_mean_ids = atoi_arr(arg_val);
3147  return;
3148  }
3149  if(!strcmp(arg_name, "pf_update_distr_wts")){
3150  pf_update_distr_wts = atoi(arg_val);
3151  return;
3152  }
3153  if(!strcmp(arg_name, "pf_min_distr_wt")){
3154  pf_min_distr_wt = atof(arg_val);
3155  return;
3156  }
3157  if(!strcmp(arg_name, "pf_adaptive_resampling_thresh")){
3158  pf_adaptive_resampling_thresh = atof(arg_val);
3159  return;
3160  }
3161  if(!strcmp(arg_name, "pf_measurement_sigma")){
3162  pf_measurement_sigma = atof(arg_val);
3163  return;
3164  }
3165  if(!strcmp(arg_name, "pf_pix_sigma")){
3166  pf_pix_sigma = atof_arr(arg_val);
3167  return;
3168  }
3169  if(!strcmp(arg_name, "pf_show_particles")){
3170  pf_show_particles = atoi(arg_val);
3171  return;
3172  }
3173  if(!strcmp(arg_name, "pf_jacobian_as_sigma")){
3174  pf_jacobian_as_sigma = atoi(arg_val);
3175  return;
3176  }
3177  if(!strcmp(arg_name, "pf_debug_mode")){
3178  pf_debug_mode = atoi(arg_val);
3179  return;
3180  }
3182  if(!strcmp(arg_name, "pfk_n_layers")){
3183  pfk_n_layers = atoi(arg_val);
3184  return;
3185  }
3186  if(!strcmp(arg_name, "pfk_ssm_sigma_ids")){
3187  pfk_ssm_sigma_ids.push_back(atoi_arr(arg_val));
3188  return;
3189  }
3191  if(!strcmp(arg_name, "ssm_sigma")){
3192  ssm_sigma.push_back(atof_arr(arg_val));
3193  return;
3194  }
3195  if(!strcmp(arg_name, "ssm_mean")){
3196  ssm_mean.push_back(atof_arr(arg_val));
3197  return;
3198  }
3199  if(!strcmp(arg_name, "am_sigma")){
3200  am_sigma.push_back(atof_arr(arg_val));
3201  return;
3202  }
3203  if(!strcmp(arg_name, "am_mean")){
3204  am_mean.push_back(atof_arr(arg_val));
3205  return;
3206  }
3208  if(!strcmp(arg_name, "cmt_estimate_scale")){
3209  cmt_estimate_scale = atoi(arg_val);
3210  return;
3211  }
3212  if(!strcmp(arg_name, "cmt_estimate_rotation")){
3213  cmt_estimate_rotation = atoi(arg_val);
3214  return;
3215  }
3216  if(!strcmp(arg_name, "cmt_feat_detector")){
3217  processStringParam(cmt_feat_detector, arg_val);
3218  return;
3219  }
3220  if(!strcmp(arg_name, "cmt_desc_extractor")){
3221  processStringParam(cmt_desc_extractor, arg_val);
3222  return;
3223  }
3224  if(!strcmp(arg_name, "cmt_resize_factor")){
3225  cmt_resize_factor = atof(arg_val);
3226  return;
3227  }
3229  if(!strcmp(arg_name, "dsst_sigma")){
3230  dsst_sigma = atof(arg_val);
3231  return;
3232  }
3233  if(!strcmp(arg_name, "dsst_scale_sigma")){
3234  dsst_scale_sigma = atof(arg_val);
3235  return;
3236  }
3237  if(!strcmp(arg_name, "dsst_lambda")){
3238  dsst_lambda = atof(arg_val);
3239  return;
3240  }
3241  if(!strcmp(arg_name, "dsst_learning_rate")){
3242  dsst_learning_rate = atof(arg_val);
3243  return;
3244  }
3245  if(!strcmp(arg_name, "dsst_number_scales")){
3246  dsst_number_scales = atoi(arg_val);
3247  return;
3248  }
3249  if(!strcmp(arg_name, "dsst_number_rots")){
3250  dsst_number_rots = atoi(arg_val);
3251  return;
3252  }
3253  if(!strcmp(arg_name, "dsst_scale_step")){
3254  dsst_scale_step = atof(arg_val);
3255  return;
3256  }
3257  if(!strcmp(arg_name, "dsst_rot_step")){
3258  dsst_rot_step = atof(arg_val);
3259  return;
3260  }
3261  if(!strcmp(arg_name, "dsst_padding")){
3262  dsst_padding = atoi(arg_val);
3263  return;
3264  }
3265  if(!strcmp(arg_name, "dsst_resize_factor")){
3266  dsst_resize_factor = atoi(arg_val);
3267  return;
3268  }
3269  if(!strcmp(arg_name, "dsst_is_scaling")){
3270  dsst_is_scaling = atoi(arg_val);
3271  return;
3272  }
3273  if(!strcmp(arg_name, "dsst_is_rotating")){
3274  dsst_is_rotating = atoi(arg_val);
3275  return;
3276  }
3277  if(!strcmp(arg_name, "dsst_bin_size")){
3278  dsst_bin_size = atoi(arg_val);
3279  return;
3280  }
3282  if(!strcmp(arg_name, "kcf_output_sigma_factor")){
3283  kcf_output_sigma_factor = atof(arg_val);
3284  return;
3285  }
3286  if(!strcmp(arg_name, "kcf_interp_factor")){
3287  kcf_interp_factor = atof(arg_val);
3288  return;
3289  }
3290  if(!strcmp(arg_name, "kcf_lambda")){
3291  kcf_lambda = atof(arg_val);
3292  return;
3293  }
3294  if(!strcmp(arg_name, "kcf_kernel_sigma")){
3295  kcf_kernel_sigma = atof(arg_val);
3296  return;
3297  }
3298  if(!strcmp(arg_name, "kcf_number_scales")){
3299  kcf_number_scales = atoi(arg_val);
3300  return;
3301  }
3302  if(!strcmp(arg_name, "kcf_scale_step")){
3303  kcf_scale_step = atof(arg_val);
3304  return;
3305  }
3306  if(!strcmp(arg_name, "kcf_padding")){
3307  kcf_padding = atoi(arg_val);
3308  return;
3309  }
3310  if(!strcmp(arg_name, "kcf_resize_factor")){
3311  kcf_resize_factor = atoi(arg_val);
3312  return;
3313  }
3314  if(!strcmp(arg_name, "kcf_scale_model_max_area")){
3315  kcf_scale_model_max_area = atof(arg_val);
3316  return;
3317  }
3318  if(!strcmp(arg_name, "kcf_scale_sigma_factor")){
3319  kcf_scale_sigma_factor = atof(arg_val);
3320  return;
3321  }
3322  if(!strcmp(arg_name, "kcf_scale_learning_rate")){
3323  kcf_scale_learning_rate = atof(arg_val);
3324  return;
3325  }
3326  if(!strcmp(arg_name, "kcf_is_scaling")){
3327  kcf_is_scaling = atoi(arg_val);
3328  return;
3329  }
3331  if(!strcmp(arg_name, "mil_algorithm")){
3332  mil_algorithm = atoi(arg_val);
3333  return;
3334  }
3335  if(!strcmp(arg_name, "mil_num_classifiers")){
3336  mil_num_classifiers = atoi(arg_val);
3337  return;
3338  }
3339  if(!strcmp(arg_name, "mil_overlap")){
3340  mil_overlap = atof32(arg_val);
3341  return;
3342  }
3343  if(!strcmp(arg_name, "mil_search_factor")){
3344  mil_search_factor = atof32(arg_val);
3345  return;
3346  }
3347  if(!strcmp(arg_name, "mil_pos_radius_train")){
3348  mil_pos_radius_train = atof32(arg_val);
3349  return;
3350  }
3351  if(!strcmp(arg_name, "mil_neg_num_train")){
3352  mil_neg_num_train = atoi(arg_val);
3353  return;
3354  }
3355  if(!strcmp(arg_name, "mil_num_features")){
3356  mil_num_features = atoi(arg_val);
3357  return;
3358  }
3360  if(!strcmp(arg_name, "tld_detector_enabled")){
3361  tld_detector_enabled = atoi(arg_val);
3362  return;
3363  }
3364  if(!strcmp(arg_name, "tld_learning_enabled")){
3365  tld_learning_enabled = atoi(arg_val);
3366  return;
3367  }
3368  if(!strcmp(arg_name, "tld_tracker_enabled")){
3369  tld_tracker_enabled = atoi(arg_val);
3370  return;
3371  }
3372  if(!strcmp(arg_name, "tld_alternating")){
3373  tld_alternating = atoi(arg_val);
3374  return;
3375  }
3377  if(!strcmp(arg_name, "rct_min_n_rect")){
3378  rct_min_n_rect = atoi(arg_val);
3379  return;
3380  }
3381  if(!strcmp(arg_name, "rct_max_n_rect")){
3382  rct_max_n_rect = atoi(arg_val);
3383  return;
3384  }
3385  if(!strcmp(arg_name, "rct_n_feat")){
3386  rct_n_feat = atoi(arg_val);
3387  return;
3388  }
3389  if(!strcmp(arg_name, "rct_rad_outer_pos")){
3390  rct_rad_outer_pos = atoi(arg_val);
3391  return;
3392  }
3393  if(!strcmp(arg_name, "rct_rad_search_win")){
3394  rct_rad_search_win = atoi(arg_val);
3395  return;
3396  }
3397  if(!strcmp(arg_name, "rct_learning_rate")){
3398  rct_learning_rate = atof(arg_val);
3399  return;
3400  }
3402  if(!strcmp(arg_name, "strk_config_path")){
3403  strk_config_path = std::string(arg_val);
3404  return;
3405  }
3407  if(!strcmp(arg_name, "vptt_sm")){
3408  processStringParam(vptt_sm, arg_val);
3409  return;
3410  }
3411  if(!strcmp(arg_name, "vptt_am")){
3412  processStringParam(vptt_am, arg_val);
3413  return;
3414  }
3415  if(!strcmp(arg_name, "vptt_ssm")){
3416  processStringParam(vptt_ssm, arg_val);
3417  return;
3418  }
3419  if(!strcmp(arg_name, "vptt_max_iters")){
3420  vptt_max_iters = atoi(arg_val);
3421  return;
3422  }
3423  if(!strcmp(arg_name, "vptt_res")){
3424  vptt_res = atoi(arg_val);
3425  return;
3426  }
3427  if(!strcmp(arg_name, "vptt_pyr_n_levels")){
3428  vptt_pyr_n_levels = atoi(arg_val);
3429  return;
3430  }
3431  if(!strcmp(arg_name, "vptt_pyr_level_to_stop")){
3432  vptt_pyr_level_to_stop = atoi(arg_val);
3433  return;
3434  }
3435  if(!strcmp(arg_name, "vptt_lambda")){
3436  vptt_lambda = atof(arg_val);
3437  return;
3438  }
3439  if(!strcmp(arg_name, "vptt_thresh_grad")){
3440  vptt_thresh_grad = atof(arg_val);
3441  return;
3442  }
3444  if(!strcmp(arg_name, "vp_usb_res")){
3445  vp_usb_res = std::string(arg_val);
3446  return;
3447  }
3448  if(!strcmp(arg_name, "vp_usb_fps")){
3449  vp_usb_fps = std::string(arg_val);
3450  return;
3451  }
3452  if(!strcmp(arg_name, "vp_usb_n_buffers")){
3453  vp_usb_n_buffers = atoi(arg_val);
3454  return;
3455  }
3456  if(!strcmp(arg_name, "vp_fw_res")){
3457  vp_fw_res = std::string(arg_val);
3458  return;
3459  }
3460  if(!strcmp(arg_name, "vp_fw_fps")){
3461  vp_fw_fps = std::string(arg_val);
3462  return;
3463  }
3464  if(!strcmp(arg_name, "vp_fw_depth")){
3465  vp_fw_depth = std::string(arg_val);
3466  return;
3467  }
3468  if(!strcmp(arg_name, "vp_fw_iso")){
3469  vp_fw_iso = std::string(arg_val);
3470  return;
3471  }
3472  if(!strcmp(arg_name, " vp_fw_print_info")){
3473  vp_fw_print_info = atoi(arg_val);
3474  return;
3475  }
3476  if(!strcmp(arg_name, " vp_pg_fw_shutter_ms")){
3477  vp_pg_fw_shutter_ms = atof32(arg_val);
3478  return;
3479  }
3480  if(!strcmp(arg_name, " vp_pg_fw_gain")){
3481  vp_pg_fw_gain = atof32(arg_val);
3482  return;
3483  }
3484  if(!strcmp(arg_name, " vp_pg_fw_exposure")){
3485  vp_pg_fw_exposure = atof32(arg_val);
3486  return;
3487  }
3488  if(!strcmp(arg_name, " vp_pg_fw_brightness")){
3489  vp_pg_fw_brightness = atof32(arg_val);
3490  return;
3491  }
3493  if(!strcmp(arg_name, "cv3_tracker_type")){
3494  cv3_tracker_type = std::string(arg_val);
3495  return;
3496  }
3498  if(!strcmp(arg_name, "pfsl3_p_x")){
3499  pfsl3_p_x = atoi(arg_val);
3500  return;
3501  }
3502  if(!strcmp(arg_name, "pfsl3_p_y")){
3503  pfsl3_p_y = atoi(arg_val);
3504  return;
3505  }
3506  if(!strcmp(arg_name, "pfsl3_rot")){
3507  pfsl3_rot = atof(arg_val);
3508  return;
3509  }
3510  if(!strcmp(arg_name, "pfsl3_ncc_std")){
3511  pfsl3_ncc_std = atof(arg_val);
3512  return;
3513  }
3514  if(!strcmp(arg_name, "pfsl3_pca_std")){
3515  pfsl3_pca_std = atof(arg_val);
3516  return;
3517  }
3518  if(!strcmp(arg_name, "pfsl3_state_std")){
3519  pfsl3_state_std = atof_arr(arg_val);
3520  return;
3521  }
3522  if(!strcmp(arg_name, "pfsl3_ar_p")){
3523  pfsl3_ar_p = atoi(arg_val);
3524  return;
3525  }
3526  if(!strcmp(arg_name, "pfsl3_n")){
3527  pfsl3_n = atoi(arg_val);
3528  return;
3529  }
3530  if(!strcmp(arg_name, "pfsl3_n_c")){
3531  pfsl3_n_c = atoi(arg_val);
3532  return;
3533  }
3534  if(!strcmp(arg_name, "pfsl3_n_iter")){
3535  pfsl3_n_iter = atoi(arg_val);
3536  return;
3537  }
3538  if(!strcmp(arg_name, "pfsl3_sampling")){
3539  pfsl3_sampling = atoi(arg_val);
3540  return;
3541  }
3542  if(!strcmp(arg_name, "pfsl3_capture")){
3543  pfsl3_capture = atoi(arg_val);
3544  return;
3545  }
3546  if(!strcmp(arg_name, "pfsl3_mean_check")){
3547  pfsl3_mean_check = atoi(arg_val);
3548  return;
3549  }
3550  if(!strcmp(arg_name, "pfsl3_outlier_flag")){
3551  pfsl3_outlier_flag = atoi(arg_val);
3552  return;
3553  }
3554  if(!strcmp(arg_name, "pfsl3_len")){
3555  pfsl3_len = atoi(arg_val);
3556  return;
3557  }
3558  if(!strcmp(arg_name, "pfsl3_init_size")){
3559  pfsl3_init_size = atoi(arg_val);
3560  return;
3561  }
3562  if(!strcmp(arg_name, "pfsl3_update_period")){
3563  pfsl3_update_period = atoi(arg_val);
3564  return;
3565  }
3566  if(!strcmp(arg_name, "pfsl3_ff")){
3567  pfsl3_ff = atof32(arg_val);
3568  return;
3569  }
3570  if(!strcmp(arg_name, "pfsl3_basis_thr")){
3571  pfsl3_basis_thr = atof(arg_val);
3572  return;
3573  }
3574  if(!strcmp(arg_name, "pfsl3_max_num_basis")){
3575  pfsl3_max_num_basis = atoi(arg_val);
3576  return;
3577  }
3578  if(!strcmp(arg_name, "pfsl3_max_num_used_basis")){
3579  pfsl3_max_num_used_basis = atoi(arg_val);
3580  return;
3581  }
3582  if(!strcmp(arg_name, "pfsl3_show_weights")){
3583  pfsl3_show_weights = atoi(arg_val);
3584  return;
3585  }
3586  if(!strcmp(arg_name, "pfsl3_show_templates")){
3587  pfsl3_show_templates = atoi(arg_val);
3588  return;
3589  }
3590  if(!strcmp(arg_name, "pfsl3_debug_mode")){
3591  pfsl3_debug_mode = atoi(arg_val);
3592  return;
3593  }
3594 
3596  if(!strcmp(arg_name, "gtrn_do_train")){
3597  gtrn_do_train = atoi(arg_val);
3598  return;
3599  }
3600  if(!strcmp(arg_name, "gtrn_gpu_id")){
3601  gtrn_gpu_id = atoi(arg_val);
3602  return;
3603  }
3604  if(!strcmp(arg_name, "gtrn_show_intermediate_output")){
3605  gtrn_show_intermediate_output = atoi(arg_val);
3606  return;
3607  }
3608  if(!strcmp(arg_name, "gtrn_model_file")){
3609  gtrn_model_file = std::string(arg_val);
3610  return;
3611  }
3612  if(!strcmp(arg_name, "gtrn_trained_file")){
3613  gtrn_trained_file = std::string(arg_val);
3614  return;
3615  }
3617  if(!strcmp(arg_name, "dft_res_to_l")){
3618  dft_res_to_l = atof32(arg_val);
3619  return;
3620  }
3621  if(!strcmp(arg_name, "dft_p_to_l")){
3622  dft_p_to_l = atof32(arg_val);
3623  return;
3624  }
3625  if(!strcmp(arg_name, "dft_max_iter")){
3626  dft_max_iter = atoi(arg_val);
3627  return;
3628  }
3629  if(!strcmp(arg_name, "dft_max_iter_single_level")){
3630  dft_max_iter_single_level = atoi(arg_val);
3631  return;
3632  }
3633  if(!strcmp(arg_name, "dft_pyramid_smoothing_variance")){
3634  dft_pyramid_smoothing_variance = atof32_arr(arg_val);
3635  return;
3636  }
3637  if(!strcmp(arg_name, "dft_presmoothing_variance")){
3638  dft_presmoothing_variance = atof32(arg_val);
3639  return;
3640  }
3641  if(!strcmp(arg_name, "dft_n_control_points_on_edge")){
3642  dft_n_control_points_on_edge = atoi(arg_val);
3643  return;
3644  }
3645  if(!strcmp(arg_name, "dft_b_adaptative_choice_of_points")){
3646  dft_b_adaptative_choice_of_points = atoi(arg_val);
3647  return;
3648  }
3649  if(!strcmp(arg_name, "dft_b_normalize_descriptors")){
3650  dft_b_normalize_descriptors = atoi(arg_val);
3651  return;
3652  }
3653  if(!strcmp(arg_name, "dft_optimization_type")){
3654  dft_optimization_type = atoi(arg_val);
3655  return;
3656  }
3657  // FRG
3658  if(!strcmp(arg_name, "frg_n_bins")){
3659  frg_n_bins = atoi(arg_val);
3660  return;
3661  }
3662  if(!strcmp(arg_name, "frg_search_margin")){
3663  frg_search_margin = atoi(arg_val);
3664  return;
3665  }
3666  if(!strcmp(arg_name, "frg_hist_cmp_metric")){
3667  frg_hist_cmp_metric = atoi(arg_val);
3668  return;
3669  }
3670  if(!strcmp(arg_name, "frg_resize_factor")){
3671  frg_resize_factor = atof(arg_val);
3672  return;
3673  }
3674  if(!strcmp(arg_name, "frg_show_window")){
3675  frg_show_window = atoi(arg_val);
3676  return;
3677  }
3679  if(!strcmp(arg_name, "dfm_nfmaps")){
3680  dfm_nfmaps = atoi(arg_val);
3681  return;
3682  }
3683  if(!strcmp(arg_name, "dfm_layer_name")){
3684  processStringParam(dfm_layer_name, arg_val);
3685  return;
3686  }
3687  if(!strcmp(arg_name, "dfm_vis")){
3688  dfm_vis = atoi(arg_val);
3689  return;
3690  }
3691  if(!strcmp(arg_name, "dfm_zncc")){
3692  dfm_zncc = atoi(arg_val);
3693  return;
3694  }
3695  if(!strcmp(arg_name, "dfm_model_f_name")){
3696  processStringParam(dfm_model_f_name, arg_val);
3697  return;
3698  }
3699  if(!strcmp(arg_name, "dfm_params_f_name")){
3700  processStringParam(dfm_params_f_name, arg_val);
3701  return;
3702  }
3703  if(!strcmp(arg_name, "dfm_mean_f_name")){
3704  processStringParam(dfm_mean_f_name, arg_val);
3705  return;
3706  }
3708  if(!strcmp(arg_name, "spi_type")){
3709  spi_type = atoi(arg_val);
3710  return;
3711  }
3712  if(!strcmp(arg_name, "spi_pix_diff_thresh")){
3713  spi_pix_diff_thresh = atof(arg_val);
3714  return;
3715  }
3716  if(!strcmp(arg_name, "spi_grad_thresh")){
3717  spi_grad_thresh = atof(arg_val);
3718  return;
3719  }
3720  if(!strcmp(arg_name, "spi_grad_use_union")){
3721  spi_grad_use_union = atoi(arg_val);
3722  return;
3723  }
3724  if(!strcmp(arg_name, "spi_gftt_max_corners")){
3725  spi_gftt_max_corners = atoi(arg_val);
3726  return;
3727  }
3728  if(!strcmp(arg_name, "spi_gftt_quality_level")){
3729  spi_gftt_quality_level = atof(arg_val);
3730  return;
3731  }
3732  if(!strcmp(arg_name, "spi_gftt_min_distance")){
3733  spi_gftt_min_distance = atof(arg_val);
3734  return;
3735  }
3736  if(!strcmp(arg_name, "spi_gftt_block_size")){
3737  spi_gftt_block_size = atoi(arg_val);
3738  return;
3739  }
3740  if(!strcmp(arg_name, "spi_gftt_use_harris_detector")){
3741  spi_gftt_use_harris_detector = atoi(arg_val);
3742  return;
3743  }
3744  if(!strcmp(arg_name, "spi_gftt_use_union")){
3745  spi_gftt_use_union = atoi(arg_val);
3746  return;
3747  }
3748  if(!strcmp(arg_name, "spi_gftt_k")){
3749  spi_gftt_k = atof(arg_val);
3750  return;
3751  }
3752  if(!strcmp(arg_name, "spi_gftt_neigh_offset")){
3753  spi_gftt_neigh_offset = atoi(arg_val);
3754  return;
3755  }
3757  if(!strcmp(arg_name, "extracted_frame_ids")){
3758  extracted_frame_ids = atoi_arr(arg_val);
3759  return;
3760  }
3761  if(!strcmp(arg_name, "extraction_id")){
3762  extraction_id = atoi(arg_val);
3763  return;
3764  }
3766  if(!strcmp(arg_name, "pca_n_eigenvec")){
3767  pca_n_eigenvec = atoi(arg_val);
3768  return;
3769  }
3770  if(!strcmp(arg_name, "pca_batchsize")){
3771  pca_batchsize = atoi(arg_val);
3772  return;
3773  }
3774  if(!strcmp(arg_name, "pca_f_factor")){
3775  pca_f_factor = atof32(arg_val);
3776  return;
3777  }
3778  if(!strcmp(arg_name, "pca_show_basis")){
3779  pca_show_basis = atoi(arg_val);
3780  return;
3781  }
3782 
3784  if(!strcmp(arg_name, "reg_ssm")){
3785  reg_ssm = std::string(arg_val);
3786  return;
3787  }
3788  if(!strcmp(arg_name, "reg_ilm")){
3789  reg_ilm = std::string(arg_val);
3790  return;
3791  }
3792  if(!strcmp(arg_name, "reg_track_border")){
3793  reg_track_border = atoi(arg_val);
3794  return;
3795  }
3796  if(!strcmp(arg_name, "reg_grayscale_img")){
3797  reg_grayscale_img = atoi(arg_val);
3798  return;
3799  }
3800  if(!strcmp(arg_name, "reg_show_output")){
3801  reg_show_output = atoi(arg_val);
3802  return;
3803  }
3804  if(!strcmp(arg_name, "reg_save_as_video")){
3805  reg_save_as_video = atoi(arg_val);
3806  return;
3807  }
3808  if(!strcmp(arg_name, "reg_video_fps")){
3809  reg_video_fps = atoi(arg_val);
3810  return;
3811  }
3812 
3814  if(!strcmp(arg_name, "syn_ssm")){
3815  syn_ssm = std::string(arg_val);
3816  return;
3817  }
3818  if(!strcmp(arg_name, "syn_ilm")){
3819  syn_ilm = std::string(arg_val);
3820  return;
3821  }
3822  if(!strcmp(arg_name, "syn_frame_id")){
3823  syn_frame_id = atoi(arg_val);
3824  return;
3825  }
3826  if(!strcmp(arg_name, "syn_grayscale_img")){
3827  syn_grayscale_img = atoi(arg_val);
3828  return;
3829  }
3830  if(!strcmp(arg_name, "syn_continuous_warping")){
3831  syn_continuous_warping = atoi(arg_val);
3832  return;
3833  }
3834  if(!strcmp(arg_name, "syn_ssm_sigma_ids")){
3835  syn_ssm_sigma_ids = atoi_arr(arg_val);
3836  return;
3837  }
3838  if(!strcmp(arg_name, "syn_ssm_mean_ids")){
3839  syn_ssm_mean_ids = atoi_arr(arg_val);
3840  return;
3841  }
3842  if(!strcmp(arg_name, "syn_am_sigma_ids")){
3843  syn_am_sigma_ids = atoi_arr(arg_val);
3844  return;
3845  }
3846  if(!strcmp(arg_name, "syn_am_mean_ids")){
3847  syn_am_mean_ids = atoi_arr(arg_val);
3848  return;
3849  }
3850  if(!strcmp(arg_name, "syn_pix_sigma")){
3851  syn_pix_sigma = atof(arg_val);
3852  return;
3853  }
3854  if(!strcmp(arg_name, "syn_am_on_obj")){
3855  syn_am_on_obj = atoi(arg_val);
3856  return;
3857  }
3858  if(!strcmp(arg_name, "syn_warp_entire_image")){
3859  syn_warp_entire_image = atoi(arg_val);
3860  return;
3861  }
3862  if(!strcmp(arg_name, "syn_background_type")){
3863  syn_background_type = atoi(arg_val);
3864  return;
3865  }
3866  if(!strcmp(arg_name, "syn_use_inv_warp")){
3867  syn_use_inv_warp = atoi(arg_val);
3868  return;
3869  }
3870  if(!strcmp(arg_name, "syn_out_suffix")){
3871  syn_out_suffix = std::string(arg_val);
3872  return;
3873  }
3874  if(!strcmp(arg_name, "syn_n_frames")){
3875  syn_n_frames = atoi(arg_val);
3876  return;
3877  }
3878  if(!strcmp(arg_name, "syn_add_noise")){
3879  syn_add_noise = atoi(arg_val);
3880  return;
3881  }
3882  if(!strcmp(arg_name, "syn_noise_mean")){
3883  syn_noise_mean = atof(arg_val);
3884  return;
3885  }
3886  if(!strcmp(arg_name, "syn_noise_sigma")){
3887  syn_noise_sigma = atof(arg_val);
3888  return;
3889  }
3890  if(!strcmp(arg_name, "syn_save_as_video")){
3891  syn_save_as_video = atoi(arg_val);
3892  return;
3893  }
3894  if(!strcmp(arg_name, "syn_video_fps")){
3895  syn_video_fps = atoi(arg_val);
3896  return;
3897  }
3898  if(!strcmp(arg_name, "syn_jpg_quality")){
3899  syn_jpg_quality = atoi(arg_val);
3900  return;
3901  }
3902  if(!strcmp(arg_name, "syn_show_output")){
3903  syn_show_output = atoi(arg_val);
3904  return;
3905  }
3907  if(!strcmp(arg_name, "mos_inv_tracking")){
3908  mos_inv_tracking = atoi(arg_val);
3909  return;
3910  }
3911  if(!strcmp(arg_name, "mos_use_norm_corners")){
3912  mos_use_norm_corners = atoi(arg_val);
3913  return;
3914  }
3915  if(!strcmp(arg_name, "mos_track_border")){
3916  mos_track_border = atoi(arg_val);
3917  return;
3918  }
3919  if(!strcmp(arg_name, "mos_border_width")){
3920  mos_border_width = atoi(arg_val);
3921  return;
3922  }
3923  if(!strcmp(arg_name, "mos_border_height")){
3924  mos_border_height = atoi(arg_val);
3925  return;
3926  }
3927  if(!strcmp(arg_name, "mos_init_offset_x")){
3928  mos_init_offset_x = atoi(arg_val);
3929  return;
3930  }
3931  if(!strcmp(arg_name, "mos_init_offset_y")){
3932  mos_init_offset_y = atoi(arg_val);
3933  return;
3934  }
3935  if(!strcmp(arg_name, "mos_disp_width")){
3936  mos_disp_width = atoi(arg_val);
3937  return;
3938  }
3939  if(!strcmp(arg_name, "mos_disp_height")){
3940  mos_disp_height = atoi(arg_val);
3941  return;
3942  }
3943  if(!strcmp(arg_name, "mos_show_grid")){
3944  mos_show_grid = atoi(arg_val);
3945  return;
3946  }
3947  if(!strcmp(arg_name, "mos_show_tracked_img")){
3948  mos_show_tracked_img = atoi(arg_val);
3949  return;
3950  }
3951  if(!strcmp(arg_name, "mos_show_patch")){
3952  mos_show_patch = atoi(arg_val);
3953  return;
3954  }
3955  if(!strcmp(arg_name, "mos_show_mask")){
3956  mos_show_mask = atoi(arg_val);
3957  return;
3958  }
3959  if(!strcmp(arg_name, "mos_use_write_mask")){
3960  mos_use_write_mask = atoi(arg_val);
3961  return;
3962  }
3963  if(!strcmp(arg_name, "mos_save_img")){
3964  mos_save_img = atoi(arg_val);
3965  return;
3966  }
3967  if(!strcmp(arg_name, "mos_out_fname")){
3968  mos_out_fname = std::string(arg_val);
3969  return;
3970  }
3971  if(!strcmp(arg_name, "mos_out_fmt")){
3972  mos_out_fmt = std::string(arg_val);
3973  return;
3974  }
3975  if(!strcmp(arg_name, "qr_input")){
3976  qr_input.push_back(std::string(arg_val));
3977  return;
3978  }
3979  if(!strcmp(arg_name, "qr_root_dir")){
3980  qr_root_dir = std::string(arg_val);
3981  return;
3982  }
3983  if(!strcmp(arg_name, "qr_detector_ssm")){
3984  qr_detector_ssm = std::string(arg_val);
3985  return;
3986  }
3987  if(!strcmp(arg_name, "qr_duplicate_min_dist")){
3988  qr_duplicate_min_dist = atof(arg_val);
3989  return;
3990  }
3991  if(!strcmp(arg_name, "qr_min_size")){
3992  qr_min_size = atof(arg_val);
3993  return;
3994  }
3995  if(!strcmp(arg_name, "qr_init_with_rect")){
3996  qr_init_with_rect = atoi(arg_val);
3997  return;
3998  }
3999  if(!strcmp(arg_name, "qr_n_markers")){
4000  qr_n_markers = atoi(arg_val);
4001  return;
4002  }
4003  if(!strcmp(arg_name, "py_visualize")){
4004  py_visualize = atoi(arg_val);
4005  return;
4006  }
4007  if(!strcmp(arg_name, "py_live_init")){
4008  py_live_init = atoi(arg_val);
4009  return;
4010  }
4011  if(!strcmp(arg_name, "mex_visualize")){
4012  mex_visualize = atoi(arg_val);
4013  return;
4014  }
4015  if(!strcmp(arg_name, "mex_live_init")){
4016  mex_live_init = atoi(arg_val);
4017  return;
4018  }
4019  }
4020 
4021  inline FILE* readTrackerParams(FILE * fid = nullptr, int print_args = 0){
4022  // reads parameters for a single tracker in a multi tracker setup
4023  // a blank line signals the end of the current tracker's parameters
4024  // a line starting with # is treated as comment and ignored
4025  if(!fid){
4026  if(!fs::is_directory(config_dir)) {
4027  return nullptr;
4028  }
4029  std::string fname = config_dir + "/multi.cfg";
4030  printf("Opening file: %s...\n", fname.c_str());
4031  if(!(fid = fopen(fname.c_str(), "r"))){
4032  printf("readTrackerParams :: Error: File could not be opened\n");
4033  return nullptr;
4034  }
4035  }
4036  char curr_line[500];
4037  char arg_name[500], arg_val[500];
4038  while(!feof(fid)){
4039  fgets(curr_line, 500, fid);
4040  strtok(curr_line, "\n");
4041  strtok(curr_line, "\r");
4042  // ignore comments
4043  if(curr_line[0] == '#')
4044  continue;
4045  // empty line signals the end of current tracker's parameters
4046  if(strlen(curr_line) <= 1)
4047  return fid;
4048  sscanf(curr_line, "%s%s", arg_name, arg_val);
4049  strtok(arg_name, "\n");
4050  strtok(arg_name, "\r");
4051  strtok(arg_val, "\n");
4052  strtok(arg_val, "\r");
4053  char *alpha_arg_name = arg_name;
4054  while(!isalpha(*alpha_arg_name)){ ++alpha_arg_name; }
4055  if(strlen(alpha_arg_name) == 0){ continue; }
4056  if(print_args)
4057  printf("arg_name: %s arg_val: %s\n", alpha_arg_name, arg_val);
4058  processAgrument(alpha_arg_name, arg_val);
4059  }
4060  fclose(fid);
4061  return nullptr;
4062  }
4063 
4064  inline bool parseArgumentPairs(char * argv[], int argc,
4065  int parse_type = 0, int print_args = 0){
4066  // parse_type = 0 means that each element of argv contains
4067  // an argument's name and its value separated by a space
4068  // parse_type = 1 means that consecutive elements of argv contain
4069  // the name and value of each argument
4070  if(argc <= 0){ return true; }
4071 
4072  if(parse_type && argc % 2 == 0){
4073  printf("Command line arguments must be specified in pairs\n");
4074  return false;
4075  }
4076  //printf("Parsing %d argument pairs with argv=%d...\n", argc, argv);
4077  int max_arg = parse_type ? argc / 2 + 1 : argc;
4078  if(print_args){
4079  printf("argc: %d max_arg: %d\n", argc, max_arg);
4080  }
4081  for(int arg_id = 1; arg_id < max_arg; arg_id++){
4082  char arg_name[500], arg_val[500];
4083  //printf("i=%d\n", i);
4084  if(parse_type){
4085  sscanf(argv[2 * arg_id - 1], "%s", arg_name);
4086  sscanf(argv[2 * arg_id], "%s", arg_val);
4087  } else{
4088  sscanf(argv[arg_id], "%s%s", arg_name, arg_val);
4089  }
4090  strtok(arg_name, "\n");
4091  strtok(arg_name, "\r");
4092  strtok(arg_val, "\n");
4093  strtok(arg_val, "\r");
4094  // discard all numbers and special characters from the start of the argument name
4095  char *alpha_arg_name = arg_name;
4096  //printf("arg_name: %s\n", arg_name);
4097  vector<char> arg_prefix;
4098  while(!isalpha(*alpha_arg_name)){
4099  arg_prefix.push_back(*alpha_arg_name);
4100  ++alpha_arg_name;
4101  }
4102  if(strlen(alpha_arg_name) == 0){ continue; }
4103  if(print_args){
4104  printf("arg_name: %s arg_val: %s\n", alpha_arg_name, arg_val);
4105  }
4106  processAgrument(alpha_arg_name, arg_val, arg_prefix.data());
4107  }
4108  return true;
4109  }
4110 
4111  inline std::string getSyntheticSeqName(){
4112  if(syn_out_suffix.empty()){
4113  syn_out_suffix = cv::format("warped_%s_s%d", syn_ssm.c_str(), syn_ssm_sigma_ids[0]);
4114  if(syn_ilm != "0"){
4115  syn_out_suffix = cv::format("%s_%s_s%d", syn_out_suffix.c_str(),
4116  syn_ilm.c_str(), syn_am_sigma_ids[0]);
4117  }
4118  if(syn_add_noise){
4119  syn_out_suffix = cv::format("%s_gauss_%4.2f_%4.2f", syn_out_suffix.c_str(),
4120  syn_noise_mean, syn_noise_sigma);
4121  }
4122  }
4123  return cv::format("%s_%d_%s", seq_name.c_str(), syn_frame_id, syn_out_suffix.c_str());
4124  }
4125  inline bool postProcessParams(){
4126  if(mtf_res > 0){ resx = resy = mtf_res; }
4127  if(img_resize_factor <= 0){ img_resize_factor = 1; }
4128 
4129  if((img_source == SRC_IMG) || (img_source == SRC_DISK) || (img_source == SRC_VID)){
4130  if(actor_id >= 0){
4131  int n_actors = sizeof(actors) / sizeof(actors[0]);
4132  //printf("n_actors: %d\n", n_actors);
4133  if(actor_id >= n_actors){
4134  printf("Invalid actor id specified: %d\n", actor_id);
4135  return false;
4136  }
4137  actor = actors[actor_id];
4138 
4139  if(seq_id >= 0){
4140  int n_sources = combined_n_sequences[actor_id];
4141  if(seq_id >= n_sources){
4142  printf("Invalid source id %d specified for actor %s with %d sources\n",
4143  seq_id, actor.c_str(), n_sources);
4144  return false;
4145  }
4146  seq_name = combined_sequences[actor_id][seq_id];
4147  }
4148  if(actor == "Synthetic"){
4150  seq_name = getSyntheticSeqName();
4151  }
4152  if(seq_name.empty()){
4153  printf("Source name must be specified if source ID is invalid\n");
4154  return false;
4155  }
4156  seq_path = db_root_path + "/" + actor;
4157  } else{
4158  actor = "None";
4159  if(seq_path.empty()){ seq_path = "."; }
4160  seq_path = db_root_path + "/" + seq_path;
4161  }
4162  if(seq_fmt.empty()){
4163  seq_fmt = (img_source == SRC_IMG || img_source == SRC_DISK) ? IMG_FMT : VID_FMT;
4164  }
4165  } else {
4166  actor = "Live";
4167  seq_name = (img_source == SRC_USB_CAM) ? USB_DEV_NAME : FW_DEV_NAME;
4168  if(seq_path.empty()){
4169  seq_path = (img_source == SRC_USB_CAM) ? USB_DEV_PATH : FW_DEV_PATH;
4170  }
4171  if(seq_fmt.empty()){
4172  seq_fmt = (img_source == SRC_USB_CAM) ? USB_DEV_FMT : FW_DEV_FMT;
4173  }
4174  show_tracking_error = reinit_on_failure = read_obj_from_gt =
4175  read_obj_from_file = pause_after_frame = invert_seq = 0;
4176  }
4177  if(atoi(pre_proc_type.c_str()) < 0){
4179  input_buffer_size = 1;
4180  }
4181  return true;
4182  }
4183 // inline std::string getAbsolutePath(const std::string &file) {
4184 //#ifdef _WIN32
4185 // TCHAR abs_path[MAX_PATH];
4186 // GetFullPathName(file.c_str(), MAX_PATH, abs_path, NULL);
4187 // return std::string(abs_path);
4188 //#else
4189 // char abs_path[MAX_ABS_PATH];
4190 // realpath(file.c_str(), abs_path);
4191 // return std::string(abs_path);
4192 //#endif
4193 // //return fs::absolute(config_dir.c_str());
4194 // }
4195  inline bool readParams(int cmd_argc, char* cmd_argv[]){
4197  bool custom_cfg = false;
4198  if(cmd_argc > 2 && !strcmp(cmd_argv[1], "config_dir")){
4199  config_dir = std::string(cmd_argv[2]);
4200  cmd_argv += 2;
4201  cmd_argc -= 2;
4202  custom_cfg = true;
4203  }
4204  if(!fs::is_directory(config_dir)){
4205  if(custom_cfg) {
4206  std::cout << "Configuration folder: " <<
4207  config_dir << " does not exist\n";
4208  }
4209  } else {
4210  if(custom_cfg) {
4211  std::cout << "Reading configuration files from: " <<
4212  config_dir << "\n";
4213  }
4214  std::vector<char*> fargv;
4216  int fargc = readParams(fargv, (config_dir + "/mtf.cfg").c_str());
4217  if(fargc){
4218  if(!parseArgumentPairs(fargv.data(), fargc)){
4219  printf("Error in parsing mtf.cfg\n");
4220  return false;
4221  }
4222  fargv.clear();
4223  }
4225  fargc = readParams(fargv, (config_dir + "/modules.cfg").c_str());
4226  if(fargc){
4227  if(!parseArgumentPairs(fargv.data(), fargc)){
4228  printf("Error in parsing modules.cfg\n");
4229  return false;
4230  }
4231  fargv.clear();
4232  }
4234  fargc = readParams(fargv, (config_dir + "/feat.cfg").c_str());
4235  if(fargc){
4236  if(!parseArgumentPairs(fargv.data(), fargc)){
4237  printf("Error in parsing feat.cfg\n");
4238  return false;
4239  }
4240  fargv.clear();
4241  }
4243  fargc = readParams(fargv, (config_dir + "/examples.cfg").c_str());
4244  if(fargc){
4245  if(!parseArgumentPairs(fargv.data(), fargc)){
4246  printf("Error in parsing examples.cfg\n");
4247  return false;
4248  }
4249  fargv.clear();
4250  }
4252  fargc = readParams(fargv, (config_dir + "/sigma.cfg").c_str());
4253  if(fargc){
4254  if(!parseArgumentPairs(fargv.data(), fargc)){
4255  printf("Error in parsing sigma.cfg\n");
4256  return false;
4257  }
4258  fargv.clear();
4259  }
4261  fargc = readParams(fargv, (config_dir + "/thirdparty.cfg").c_str());
4262  if(fargc){
4263  if(!parseArgumentPairs(fargv.data(), fargc)){
4264  printf("Error in parsing thirdparty.cfg\n");
4265  return false;
4266  }
4267  fargv.clear();
4268  }
4269  }
4271  if(cmd_argc > 0 && !parseArgumentPairs(cmd_argv, cmd_argc, 1, 0)){
4272  printf("Error in parsing command line arguments\n");
4273  return false;
4274  }
4275  if(!postProcessParams()){
4276  printf("Error in post processing params\n");
4277  return false;
4278  }
4279  return true;
4280  }
4281  inline bool readParams(const char* param_str){
4282  if(!param_str) {
4283  return true;
4284  }
4285  std::vector<char*> fargv;
4286  fargv.push_back(nullptr);
4287  std::string _param_str = std::string(param_str);
4288  std::istringstream iss(_param_str);
4289  do{
4290  string subs;
4291  iss >> subs;
4292  if(subs.empty()){ continue; }
4293  //printf("subs: %s\n", subs.c_str());
4294  char *cstr = new char[subs.length() + 1];
4295  strcpy(cstr, subs.c_str());
4296  fargv.push_back(cstr);
4297  } while(iss);
4298  //fargv.pop_back();
4299  //printf("fargv.size(): %d\n", fargv.size());
4300  if(fargv.size() % 2 == 0){
4301  //printf("param_str: %s\n", param_str);
4302  std::cout << "Parameters must be provided in pairs\n";
4303  return false;
4304  }
4305  return readParams(fargv.size(), fargv.data());
4306  }
4307  inline void getSamplerParams(vectorvd &sigma, vectorvd &mean,
4308  const vectori &sigma_ids, const vectori &mean_ids,
4309  const char* name){
4310  //printf("ssm_sigma.size(): %ld\n", ssm_sigma.size());
4311  //for(int i = 0; i < ssm_sigma.size(); ++i){
4312  // for(vectord::const_iterator iter = ssm_sigma[i].begin(); iter != ssm_sigma[i].end(); ++iter){
4313  // printf("%f\t", *iter);
4314  // }
4315  // printf("\n");
4316  //}
4317  //printf("ssm_mean.size(): %ld\n", ssm_mean.size());
4318  //for(int i = 0; i < ssm_mean.size(); ++i){
4319  // for(vectord::const_iterator iter = ssm_mean[i].begin(); iter != ssm_mean[i].end(); ++iter){
4320  // printf("%f\t", *iter);
4321  // }
4322  // printf("\n");
4323  //}
4324  for(auto sigma_id : sigma_ids){
4325  if(sigma_id < 0 || static_cast<unsigned int>(sigma_id) >= ssm_sigma.size()){
4326  printf("Skipping invalid %s sigma ID: %d\n", name, sigma_id);
4327  continue;
4328  }
4329  sigma.push_back(ssm_sigma[sigma_id]);
4330  }
4331  for(auto mean_id : mean_ids){
4332  if(mean_id < 0 || static_cast<unsigned int>(mean_id) >= ssm_mean.size()){
4333  //printf("Skipping invalid %s SSM mean ID: %d\n", name, mean_id);
4334  continue;
4335  }
4336  mean.push_back(ssm_mean[mean_id]);
4337  }
4338  }
4339  inline void getAMSamplerParams(vectorvd &sigma, vectorvd &mean,
4340  const vectori &sigma_ids, const vectori &mean_ids,
4341  const char* name){
4342  for(auto sigma_id : sigma_ids){
4343  if(sigma_id < 0 || static_cast<unsigned int>(sigma_id) >= am_sigma.size()){
4344  printf("Skipping invalid %s sigma ID: %d\n", name, sigma_id);
4345  continue;
4346  }
4347  sigma.push_back(am_sigma[sigma_id]);
4348  }
4349  for(auto mean_id : mean_ids){
4350  if(mean_id < 0 || static_cast<unsigned int>(mean_id) >= am_mean.size()){
4351  continue;
4352  }
4353  mean.push_back(am_mean[mean_id]);
4354  }
4355  }
4356 
4357  inline void freeParams(){}
4358  }
4359 }
4360 
4361 #endif
mtf
Definition: RegNetParams.h:32
Generated on Sun Jul 29 2018 10:45:27 for MTF by   doxygen 1.8.11