From bc5c98e0df72b18a9f4a3d80edef48bd26932c4f Mon Sep 17 00:00:00 2001 From: Patrick Roth Date: Mon, 28 Jun 2021 10:43:54 +0200 Subject: file description header update --- CMakeLists.txt | 6 +++--- alg_ccm.h | 6 ++---- alg_debayer_bilinear.h | 6 ++---- alg_gamma.h | 4 +--- alg_interpolate_mono_scalar.h | 4 +--- alg_interpolate_rgb_scalar.h | 4 +--- alg_rgb_to_yuv.h | 4 +--- alg_yuv_to_rgb.h | 4 +--- camera_calib.c | 4 +--- color.c | 4 +--- color.h | 4 +--- color_pipe_private.h | 4 +--- cpu_feature.c | 4 +--- cpu_feature.h | 6 ++---- debayer.c | 6 ++---- filter.c | 4 +--- filter.h | 6 ++---- gamma_corr.c | 4 +--- sharpening.c | 4 +--- white_balance.c | 6 ++---- 20 files changed, 28 insertions(+), 66 deletions(-) diff --git a/CMakeLists.txt b/CMakeLists.txt index a8eee6b..d5e82c6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -17,8 +17,8 @@ set(CMAKE_INCLUDE_CURRENT_DIR ON) # library version definition set(VERSION_MAJOR 1) -set(VERSION_MINOR 0) -set(VERSION_RELEASE 2) +set(VERSION_MINOR 1) +set(VERSION_RELEASE 0) set(VERSION_STR "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_RELEASE}") # pass macros to preprocessor @@ -59,4 +59,4 @@ add_custom_command( COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_BINARY_DIR}/$* ${CMAKE_CURRENT_BINARY_DIR}/libo3000_imgpipe-${VERSION_STR}/MinGW${CC_ARCH} COMMAND ${CMAKE_COMMAND} -E tar "cfv" "libo3000_imgpipe-${VERSION_STR}-${CC_ARCH}bit.zip" --format=zip libo3000_imgpipe-${VERSION_STR} COMMAND ${CMAKE_COMMAND} -E remove_directory libo3000_imgpipe-${VERSION_STR} -) \ No newline at end of file +) diff --git a/alg_ccm.h b/alg_ccm.h index 24d37bc..0bc4ac2 100644 --- a/alg_ccm.h +++ b/alg_ccm.h @@ -2,9 +2,7 @@ * @file alg_ccm.h * @brief color correction algorithm definition * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-26 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -85,4 +83,4 @@ } } -} \ No newline at end of file +} diff --git a/alg_debayer_bilinear.h b/alg_debayer_bilinear.h index 45c8a8d..829d615 100644 --- a/alg_debayer_bilinear.h +++ b/alg_debayer_bilinear.h @@ -2,9 +2,7 @@ * @file alg_debayer_bilinear.h * @brief bilinear demosaicing algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -268,4 +266,4 @@ img_rgb[index_rgb+2] = blue; -} \ No newline at end of file +} diff --git a/alg_gamma.h b/alg_gamma.h index 2f9a7ae..b9a1f10 100644 --- a/alg_gamma.h +++ b/alg_gamma.h @@ -2,9 +2,7 @@ * @file alg_gamma.h * @brief gamma correction algorithm definition * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-09-08 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/alg_interpolate_mono_scalar.h b/alg_interpolate_mono_scalar.h index 9adda8b..25c6d50 100644 --- a/alg_interpolate_mono_scalar.h +++ b/alg_interpolate_mono_scalar.h @@ -2,9 +2,7 @@ * @file alg_interpolate_mono_scalar.h * @brief Monochrome pixel interpolation (scalar code) * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-11-09 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/alg_interpolate_rgb_scalar.h b/alg_interpolate_rgb_scalar.h index aa17c54..3728e17 100644 --- a/alg_interpolate_rgb_scalar.h +++ b/alg_interpolate_rgb_scalar.h @@ -2,9 +2,7 @@ * @file alg_interpolate_rgb_scalar.h * @brief RGB pixel interpolation (scalar code) * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-11-09 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/alg_rgb_to_yuv.h b/alg_rgb_to_yuv.h index f75df6a..851a328 100644 --- a/alg_rgb_to_yuv.h +++ b/alg_rgb_to_yuv.h @@ -2,9 +2,7 @@ * @file alg_rgb_to_yuv.h * @brief color space conversion definitions * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/alg_yuv_to_rgb.h b/alg_yuv_to_rgb.h index c608a6d..e7885f0 100644 --- a/alg_yuv_to_rgb.h +++ b/alg_yuv_to_rgb.h @@ -2,9 +2,7 @@ * @file alg_yuv_to_rgb.h * @brief color space conversion definitions * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-27 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/camera_calib.c b/camera_calib.c index 804c40d..4b03a12 100644 --- a/camera_calib.c +++ b/camera_calib.c @@ -2,9 +2,7 @@ * @file camera_calib.c * @brief camera calibration algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/color.c b/color.c index 4802083..b1670df 100644 --- a/color.c +++ b/color.c @@ -2,9 +2,7 @@ * @file color_space.c * @brief color space conversion utilities * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/color.h b/color.h index 73bff58..a5c1a88 100644 --- a/color.h +++ b/color.h @@ -2,9 +2,7 @@ * @file color.h * @brief color utility function definition * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/color_pipe_private.h b/color_pipe_private.h index bf412fe..f5a48f8 100644 --- a/color_pipe_private.h +++ b/color_pipe_private.h @@ -2,9 +2,7 @@ * @file color_pipe_private.c * @brief Color Processing Pipeline definitions for internal use only * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/cpu_feature.c b/cpu_feature.c index 62080a5..e709366 100644 --- a/cpu_feature.c +++ b/cpu_feature.c @@ -2,9 +2,7 @@ * @file cpu_feature.c * @brief CPU feature detection (CPU ID) * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-11-12 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/cpu_feature.h b/cpu_feature.h index 11b5008..bdd4d48 100644 --- a/cpu_feature.h +++ b/cpu_feature.h @@ -2,9 +2,7 @@ * @file cpu_feature.h * @brief CPU feature detection definitions (CPU ID) * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-11-12 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -45,4 +43,4 @@ enum cpu_feature_t { int cpu_feature_support(enum cpu_feature_t type); int cpu_feature_init(void); -#endif // _CPU_FEATURE_H \ No newline at end of file +#endif // _CPU_FEATURE_H diff --git a/debayer.c b/debayer.c index 1733496..984f928 100644 --- a/debayer.c +++ b/debayer.c @@ -2,9 +2,7 @@ * @file debayer.c * @brief demosaicing algorithms * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -240,4 +238,4 @@ int debayer(struct debayer_data_t *debayer_data) { ret = -1; } return ret; -} \ No newline at end of file +} diff --git a/filter.c b/filter.c index 6c8d51a..91b5376 100644 --- a/filter.c +++ b/filter.c @@ -2,9 +2,7 @@ * @file filter.c * @brief various filtering algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-28 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/filter.h b/filter.h index 5b70294..7299ceb 100644 --- a/filter.h +++ b/filter.h @@ -2,9 +2,7 @@ * @file filter.h * @brief various filtering algorithm definitions * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-28 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -49,4 +47,4 @@ void filter_binary_3s16(int8_t *img_bin, const int16_t *img_in, const int height #endif -#endif // _FILTER_H \ No newline at end of file +#endif // _FILTER_H diff --git a/gamma_corr.c b/gamma_corr.c index 2a85b1e..7b344c1 100644 --- a/gamma_corr.c +++ b/gamma_corr.c @@ -2,9 +2,7 @@ * @file gamma_corr.c * @brief gamma correction algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-09-08 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/sharpening.c b/sharpening.c index d997b73..4b114c6 100644 --- a/sharpening.c +++ b/sharpening.c @@ -2,9 +2,7 @@ * @file sharp.c * @brief sharpening algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-27 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * diff --git a/white_balance.c b/white_balance.c index 0040fb9..fd66f8a 100644 --- a/white_balance.c +++ b/white_balance.c @@ -2,9 +2,7 @@ * @file white_balance.c * @brief white balance algorithm * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-08-20 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -282,4 +280,4 @@ int white_balance(struct awb_data_t *awb_data) { // printf("XXX u_avg = %.4f, v_avg = %.4f, red = %.4f, blue = %.4f, bit_channel = %d\n", u_avg, v_avg, awb_data->gain_red, awb_data->gain_blue, bit_channel); return 0; -} \ No newline at end of file +} -- cgit v1.2.1 From aaa7ff32f4af51dffb5cee42eed96828abfd1484 Mon Sep 17 00:00:00 2001 From: Patrick Roth Date: Tue, 29 Jun 2021 14:20:32 +0200 Subject: working copy algorithm not working and has checked --- camera_calib.c | 12 +- color_pipe.c | 116 +++++++++++++++++-- color_pipe.h | 98 +++++++++++----- color_pipe_private.h | 2 + trapcorr.c | 314 +++++++++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 497 insertions(+), 45 deletions(-) create mode 100644 trapcorr.c diff --git a/camera_calib.c b/camera_calib.c index 4b03a12..b55f954 100644 --- a/camera_calib.c +++ b/camera_calib.c @@ -488,7 +488,7 @@ static void init_undistort_map_scalar(struct cam_calib_data_t *data) { float dist_radial, dist_tang_x, dist_tang_y, dist_x, dist_y; float _x, _y, _y_sq, _x_sq, r_sq; float x_corr, y_corr; - struct lense_undistort_coord_t *map; + struct coord_t *map; const int scale_fact = (1 << (data->calib_map_scale_fact)); float x_resolution_scaling, y_resolution_scaling; // camera_matrix needs to be scaled depending on the camera resolution @@ -541,8 +541,8 @@ static void init_undistort_map_scalar(struct cam_calib_data_t *data) { x_corr = fx*dist_x + cx - fov_x_start; y_corr = fy*dist_y + cy - fov_y_start; - map->coord_x = (int)roundf(x_corr*scale_fact); - map->coord_y = (int)roundf(y_corr*scale_fact); + map->x = (int)roundf(x_corr*scale_fact); + map->y = (int)roundf(y_corr*scale_fact); map++; } } @@ -700,7 +700,7 @@ static void calib_scalar(struct cam_calib_data_t *data) { int x_corr, y_corr; void *img_calib, *img_uncalib; int bit_channel; - struct lense_undistort_coord_t *map; + struct coord_t *map; const int scale_fact = data->calib_map_scale_fact; const int is_color = data->is_color; @@ -718,8 +718,8 @@ static void calib_scalar(struct cam_calib_data_t *data) { for(v = fov_y_start; v <= fov_y_end; v++) { for(u = fov_x_start; u <= fov_x_end; u++) { - x_corr = map->coord_x; - y_corr = map->coord_y; + x_corr = map->x; + y_corr = map->y; map++; if(bit_channel <= 8) { diff --git a/color_pipe.c b/color_pipe.c index 0b77c61..648e259 100644 --- a/color_pipe.c +++ b/color_pipe.c @@ -2,9 +2,7 @@ * @file main.cpp * @brief Color Image Processing Pipeline with O-3000 USB camera * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2015-02-10 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -365,12 +363,12 @@ static void set_default_value(struct color_pipe_t *pipe) { pipe->debayer_data.alg_new = pipe->debayer_data.alg; pipe->awb_data.enable = 0; - pipe->awb_data.gray_threshold = 0.3; + pipe->awb_data.gray_threshold = 0.3f; pipe->awb_data.gray_threshold_new = pipe->awb_data.gray_threshold; - pipe->awb_data.ctrl_k = 0.01; + pipe->awb_data.ctrl_k = 0.01f; pipe->awb_data.ctrl_k_new = pipe->awb_data.ctrl_k; - pipe->awb_data.gain_red = 1.0; - pipe->awb_data.gain_blue = 1.0; + pipe->awb_data.gain_red = 1.0f; + pipe->awb_data.gain_blue = 1.0f; pipe->cam_calib_data.enable = 0; pipe->cam_calib_data.lense = O3000_LS_F2_8; @@ -385,16 +383,23 @@ static void set_default_value(struct color_pipe_t *pipe) { memcpy(pipe->color_calib_data.a, ccm_presets[pipe->color_calib_data.ccm], sizeof(pipe->color_calib_data.a)); pipe->sharp_data.enable = 0; - pipe->sharp_data.sharp_factor = 5.0; + pipe->sharp_data.sharp_factor = 5.0f; pipe->sharp_data.sharp_factor_new = pipe->sharp_data.sharp_factor; pipe->sharp_data.sharp_alg = SHARP_ALG_LOCAL; pipe->sharp_data.sharp_alg_new = pipe->sharp_data.sharp_alg; - pipe->sharp_data.local_sens = 94.0; + pipe->sharp_data.local_sens = 94.0f; pipe->sharp_data.local_sens_new = pipe->sharp_data.local_sens_new; pipe->gamma_data.enable = 0; - pipe->gamma_data.gamma = 1.2; + pipe->gamma_data.gamma = 1.2f; pipe->gamma_data.gamma_new = pipe->gamma_data.gamma; + + pipe->trapcorr_data.enable = 0; + pipe->trapcorr_data.map_init = 0; + pipe->trapcorr_data.wv = 1.0f; + pipe->trapcorr_data.wh = 1.0f; + pipe->trapcorr_data.wv_new = pipe->trapcorr_data.wv; + pipe->trapcorr_data.wh_new = pipe->trapcorr_data.wh; } @@ -458,7 +463,7 @@ void __stdcall color_pipe_process(struct color_pipe_t *__restrict__ color_pipe, #ifdef DEBUG_PROC_TIME uint64_t ts_start = get_ts(); - uint64_t ts_debayer, ts_awb, ts_calib, ts_ccm, ts_sharp, ts_gamma; + uint64_t ts_debayer, ts_awb, ts_calib, ts_ccm, ts_sharp, ts_gamma, ts_trapcorr; #endif // DEBUG_PROC_TIME /* @@ -675,6 +680,41 @@ void __stdcall color_pipe_process(struct color_pipe_t *__restrict__ color_pipe, #endif // DEBUG_PROC_TIME + /* + * Pipeline stage: Isosceles trapezoid correction + */ + if(color_pipe->trapcorr_data.enable) { + + // auto-reinit perspective correction map if image format, resolution or weights have changed + if( color_pipe->trapcorr_data.bit_channel != bit_channel || + color_pipe->trapcorr_data.width != width || + color_pipe->trapcorr_data.height != height || + color_pipe->trapcorr_data.wv != color_pipe->trapcorr_data.wv_new || + color_pipe->trapcorr_data.wh != color_pipe->trapcorr_data.wh_new) { + + color_pipe->trapcorr_data.map_init = 0; + } + + // apply user parameter (double buffered) + color_pipe->trapcorr_data.wv = color_pipe->trapcorr_data.wv_new; + color_pipe->trapcorr_data.wh = color_pipe->trapcorr_data.wh_new; + + color_pipe->trapcorr_data.img_in = img_out; + color_pipe->trapcorr_data.is_color = is_color; + color_pipe->trapcorr_data.bit_channel = bit_channel; + color_pipe->trapcorr_data.width = width; + color_pipe->trapcorr_data.height = height; + + trapcorr(&(color_pipe->trapcorr_data)); + + img_out = color_pipe->trapcorr_data.img_out; + } +#ifdef DEBUG_PROC_TIME + ts_trapcorr = get_ts(); +#endif // DEBUG_PROC_TIME + + + /* * Return processed image depending on active pipeline stages. */ @@ -692,6 +732,7 @@ void __stdcall color_pipe_process(struct color_pipe_t *__restrict__ color_pipe, printf(" color correction: %lld msec\n", ts_ccm - ts_calib); printf(" sharpening: %lld msec\n", ts_sharp - ts_ccm); printf(" gamma: %lld msec\n", ts_gamma - ts_sharp); + printf(" trapeze correction: %lld msec\n", ts_trapcorr - ts_sharp); #endif // DEBUG_PROC_TIME } @@ -833,6 +874,42 @@ void __stdcall color_pipe_stageconf_gamma(struct color_pipe_t *color_pipe, int e } +/** + * Pipeline stage configuration: Isosceles Trapeze Correction + * + * The vertical and horizontal correction weight are positive + * numbers starting from 0. A weight of 1.0 means no correction. A weight lesser than + * 1.0 means the upper trapeze line is shorter than the lower trapeze line. + * Therfore a weight greater than 1.0 means the upper trapeze line is longer than + * the lower line. + * + * @param color_pipe Pointer to pipeline context + * @param enable not 0: enable, 0: disable + * @param wv vertical weight + * @param wh horizontal weight + */ +void __stdcall color_pipe_stageconf_trapcorr(struct color_pipe_t *color_pipe, int enable, float wv, float wh) { + // paranoia + if(color_pipe == NULL) { + printf("%s: Pipeline pointer is NULL!\n", __func__); + return; + } + + // range check + if(wv < 0.0f) { + wv = 0.0f; + } + if(wh < 0.0f) { + wh = 0.0f; + } + + color_pipe->trapcorr_data.enable = enable; + color_pipe->trapcorr_data.wv_new = wv; + color_pipe->trapcorr_data.wh_new = wh; + color_pipe->trapcorr_data.map_init = 0; +} + + /** * Open color image processing pipeline. * This function allocates memory for various pipe algorithm. The pipeline is set up for a maximum possible image size defined @@ -927,7 +1004,7 @@ int __stdcall color_pipe_open(struct color_pipe_t **color_pipe, const int max_im goto _pipe_open_abort; } data->cam_calib_data.calib_map = do_aligned_alloc(ALIGNMENT_SIZE, - sizeof(struct lense_undistort_coord_t)*max_img_height*max_img_width, + sizeof(struct coord_t)*max_img_height*max_img_width, __func__, __LINE__-1); if(data->cam_calib_data.calib_map == NULL) { goto _pipe_open_abort; @@ -977,6 +1054,19 @@ int __stdcall color_pipe_open(struct color_pipe_t **color_pipe, const int max_im goto _pipe_open_abort; } + // allocate memory for isosceles trapeze correction algorithm + data->trapcorr_data.img_out = do_aligned_alloc(ALIGNMENT_SIZE, max_img_size, __func__, __LINE__-1); + if(data->trapcorr_data.img_out == NULL) { + goto _pipe_open_abort; + } + data->trapcorr_data.map = do_aligned_alloc(ALIGNMENT_SIZE, + sizeof(struct coord_t)*max_img_height*max_img_width, + __func__, __LINE__-1); + if(data->trapcorr_data.map == NULL) { + goto _pipe_open_abort; + } + + // set suitable and valid defaults set_default_value(data); *color_pipe = data; @@ -1022,6 +1112,8 @@ int __stdcall color_pipe_close(struct color_pipe_t *data) { do_aligned_free(data->sharp_data.sharp_mask); do_aligned_free(data->gamma_data.img_gamma); do_aligned_free(data->gamma_data.gamma_table); + do_aligned_free(data->trapcorr_data.img_out); + do_aligned_free(data->trapcorr_data.map); // free various image buffers free(data); diff --git a/color_pipe.h b/color_pipe.h index 2833d0f..b4c50da 100644 --- a/color_pipe.h +++ b/color_pipe.h @@ -2,9 +2,7 @@ * @file color_pipe.h * @brief Color Processing Pipeline Definitions * @author Patrick Roth - roth@stettbacher.ch -* @version 1.0 -* @date 2016-03-01 -* @copyright 2012-2016 Stettbacher Signal Processing AG +* @copyright Stettbacher Signal Processing AG * * @remarks * @@ -35,6 +33,15 @@ #include +/** + * Coordinate definition. + */ +struct coord_t { + int x; ///< x-coordinate of calibrated pixel + int y; ///< y-coordinate of calibrated pixel +}; + + /** * demosaicing algorithm definition */ @@ -55,7 +62,7 @@ struct debayer_data_t { enum enumDataFormat_t format; ///< data format of input image enum enumBayerPattern_t start_pattern; ///< first pixel starts with this bayer pattern enum bayer_alg_t alg; ///< debayer algorithm type - enum bayer_alg_t alg_new; ///< this debayer algorithm type is changed by API call (use double buffering concept) + enum bayer_alg_t alg_new; ///< this debayer algorithm type is changed by API call (use double buffering) }; @@ -71,9 +78,9 @@ struct awb_data_t { int width; ///< image width in number of pixels int16_t *img_yuv; ///< Image buffer holding YUV image. This buffer must be allocated externly. float gray_threshold; ///< gray value threshold - float gray_threshold_new; ///< this gray value threshold is changed by API call (use double buffering concept) + float gray_threshold_new; ///< this gray value threshold is changed by API call (use double buffering) float ctrl_k; ///< controller gain - float ctrl_k_new; ///< this controller gain is changed by API call (use double buffering concept) + float ctrl_k_new; ///< this controller gain is changed by API call (use double buffering) float gain_red; ///< red color gain float gain_blue; ///< blue color gain }; @@ -130,19 +137,6 @@ enum o3000_lenses_t { }; -/** - * Lense undistortion coordinate definition. - * This coordinate pair defines the undistorted pixel location. - * - * NOTE The pixel location may lay between a pixel pair. Therefore this coordinates are - * scaled by a defined factor defined at @ref cam_calib_data_t. - */ -struct lense_undistort_coord_t { - int coord_x; ///< x-coordinate of calibrated pixel - int coord_y; ///< y-coordinate of calibrated pixel -}; - - /** * camera calibration structure * @@ -164,10 +158,23 @@ struct cam_calib_data_t { struct dist_coeff_t dist_coeff; ///< distortion coefficients struct camera_matrix_t camera_matrix; ///< camera matrix enum o3000_lenses_t lense; ///< lense type - enum o3000_lenses_t lense_new; ///< lense type is changed by API call (use double buffering concept) + enum o3000_lenses_t lense_new; ///< lense type is changed by API call (use double buffering) int undistort_map_init; ///< flag indicating if lens undistortion map is initialized - struct lense_undistort_coord_t *calib_map; ///< Lense undistortion map. This buffer must be allocated externly. - int calib_map_scale_fact; ///< Bit shifts applied on undistortion map. + + /** + * Lense undistortion map. + * A coordinate pair defines the undistorted pixel location. It may be shifted (see @ref calib_map_scale_fact). + * + * This buffer must be allocated externly. + */ + struct coord_t *calib_map; + + /** + * Bit shift applied on undistortion map @ref calib_map. + * The pixel location may lay between a pixel pair. Therefore the coordinates defined at the undistortion map + * @ref calib_map are (scaled) shifted by this factor. + */ + int calib_map_scale_fact; }; @@ -218,7 +225,7 @@ struct color_calib_data_t { int height; ///< image height in number of pixels float a[3][3]; ///< 3x3 color correction matrix enum ccm_preset_t ccm; ///< color correction matrix type loaded - enum ccm_preset_t ccm_new; ///< this color correction matrix type is changed by API call (use double buffering concept) + enum ccm_preset_t ccm_new; ///< this color correction matrix type is changed by API call (use double buffering) }; @@ -244,11 +251,11 @@ struct sharp_data_t { int height; ///< image height in number of pixels int16_t *img_yuv; ///< YUV image buffer. This buffer must be allocated externly. float sharp_factor; ///< Sharpening factor: As higher as stronger sharpening is done. - float sharp_factor_new; ///< this sharpening factor is changed by API call (use double buffering concept) + float sharp_factor_new; ///< this sharpening factor is changed by API call (use double buffering) enum sharp_alg_t sharp_alg; ///< sharpening algorithm type - enum sharp_alg_t sharp_alg_new; ///< this algorithm type is changed by API call (use double buffering concept) + enum sharp_alg_t sharp_alg_new; ///< this algorithm type is changed by API call (use double buffering) float local_sens; ///< Sensitivity setting of local sharpening algorithm in per cent. 100 % means everything is sharpened like the global algorithm does - float local_sens_new; ///< this sensitivity setting is changed by API call (use double buffering concept) + float local_sens_new; ///< this sensitivity setting is changed by API call (use double buffering) int16_t *img_yuv_sharp; ///< YUV image buffer holding sharpened Y-channel. This buffer must be allocated externly. int16_t *img_sobel; ///< Sobel image in YUV color space used by local sharpening algorithm. This buffer must be allocated externly. int16_t *img_gauss; ///< Gaussian low-pass filtered image in YUV color space used by local sharpening algorithm. This buffer must be allocated externly. @@ -268,13 +275,48 @@ struct gamma_data_t { int width; ///< image width in number of pixels int height; ///< image height in number of pixels float gamma; ///< gamma coefficient - float gamma_new; ///< this gamma coefficient is changed by API call (use double buffering concept) + float gamma_new; ///< this gamma coefficient is changed by API call (use double buffering) int gamma_table_bitdepth; ///< gamma table is initialized with this bit-depth float gamma_table_init; ///< gamma table is initialized with this coefficient int *gamma_table; ///< Lookup table containg gamma corrected value. This buffer must be allocated externly. }; +/** + * Isosceles trapezoid correction definition + */ +struct trapcorr_data_t { + int enable; ///< flag to enable this algorithm + void *img_out; ///< Isosceles corrected output image. This buffer must be allocated externly. + void *img_in; ///< Input image. + int is_color; ///< Not 0 if it's a color image + int bit_channel; ///< Bits per color channel. + int width; ///< image width in number of pixels + int height; ///< image height in number of pixels + float wv; ///< vertical correction weight in per cent (NOTE not implemented yet!) + float wh; ///< horizontal correction weight in per cent + float wv_new; ///< this vertical correction weight in per cent is changed by API call (use double buffering) (NOTE not implemented yet!) + float wh_new; ///< this horizontal correction weight in per cent is changed by API call (use double buffering) + + int map_init; ///< flag indicating perspective correction map is initialized + + /** + * perspective correction map + * A coordinate pair defines the pixel location to be corrected. It may be shifted (see @ref map_scale_fact). + * + * This buffer must be allocated externly. + */ + struct coord_t *map; + + /** + * Bit shift applied on correction map @ref map. + * The pixel location may lay between a pixel pair. Therefore the coordinates defined at the correction map + * @ref map are (scaled) shifted by this factor. + */ + int map_scale_fact; +}; + + /** * Color pipe definition structure holding all memory data from different pipeline * stages. This structure and image buffers are allocated dynamically. @@ -293,6 +335,7 @@ struct color_pipe_t { struct color_calib_data_t color_calib_data; ///< color calibration data used for color corretion struct sharp_data_t sharp_data; ///< image sharpening data struct gamma_data_t gamma_data; ///< gamma correction data + struct trapcorr_data_t trapcorr_data; ///< isosceles trapezoid correction data }; @@ -312,6 +355,7 @@ void __stdcall color_pipe_stageconf_cam_calib(struct color_pipe_t *color_pipe, i void __stdcall color_pipe_stageconf_color_calib(struct color_pipe_t *color_pipe, int enable, enum ccm_preset_t ccm_preset); void __stdcall color_pipe_stageconf_sharp(struct color_pipe_t *color_pipe, int enable, float factor, enum sharp_alg_t alg, float sens); void __stdcall color_pipe_stageconf_gamma(struct color_pipe_t *color_pipe, int enable, float gamma); +void __stdcall color_pipe_stageconf_trapcorr(struct color_pipe_t *color_pipe, int enable, float wv, float wh); #if defined(__cplusplus) || defined(c_plusplus) } // extern "C" diff --git a/color_pipe_private.h b/color_pipe_private.h index f5a48f8..b2954ac 100644 --- a/color_pipe_private.h +++ b/color_pipe_private.h @@ -47,6 +47,8 @@ int sharpening(struct sharp_data_t *sharp_data); int gamma_corr(struct gamma_data_t *gamma_data); +int trapcorr(struct trapcorr_data_t *trapcorr_data); + #if defined(__cplusplus) || defined(c_plusplus) } // extern "C" #endif diff --git a/trapcorr.c b/trapcorr.c new file mode 100644 index 0000000..3ace25f --- /dev/null +++ b/trapcorr.c @@ -0,0 +1,314 @@ +/** +* @file trapcorr.c +* @brief isosceles trapeze correction algorithm +* @author Patrick Roth - roth@stettbacher.ch +* @copyright Stettbacher Signal Processing AG +* +* @remarks +* +* 
+* This library is free software; you can redistribute it and/or
+* modify it under the terms of the GNU Lesser General Public
+* License as published by the Free Software Foundation; either
+* version 2.1 of the License, or (at your option) any later version.
+*
+* This library is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+* Lesser General Public License for more details.
+*
+* You should have received a copy of the GNU Lesser General Public
+* License along with this library; if not, write to the Free Software
+* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+*
+* +*/ + +#include +#include +#include + +#include "color_pipe_private.h" + + + +/** + * Pixel value interpolation of RGB image (8 bit per color channel). + * If a pixel coordinate with a fraction part is of interest, do interpolate the correct value from their neighbor's pixel. + * + * E. g. the pixel coordinate x/y = 1.8/2.3 gives the following weights: + * +------+------+ + * | | | + * | 14% | 56% | 14% = 20%*70%, 56% = 80%*70% + * | | | + * +------+------+ + * | | | + * | 6% | 24% | 6% = 20%*30%, 24% = 80%*30% + * | | | + * +------+------+ + * + * The weights are applied to the neighors and the resulting pixel value is saved at the given location. + * + * NOTE + * The input and output image must have the same pixel size. + * + * @param img_out On return: image with interpolated values + * @param x saved interpolated pixel value at this x-coordinate + * @param y saved interpolated pixel value at this y-coordinate + * @param height image height of input and output image in number of pixels + * @param width image width of input and output image in number of pixels + * @param img_in input image to interpolate pixel values + * @param coord_x x-coordinate to interpolate + * @param coord_y y-coordinate to interpolate + * @param scale_fact coordinates are scaled by this factor + */ +static void interpolate_rgb8_scalar(uint8_t *img_out, const int x, const int y, const int height, const int width, + const uint8_t *img_in, const int coord_x, const int coord_y, const int scale_fact) +#include "alg_interpolate_rgb_scalar.h" + + +/** + * Pixel value interpolation of RGB image (16 bit per color channel). + * If a pixel coordinate with a fraction part is of interest, do interpolate the correct value from their neighbor's pixel. + * + * E. g. the pixel coordinate x/y = 1.8/2.3 gives the following weights: + * +------+------+ + * | | | + * | 14% | 56% | 14% = 20%*70%, 56% = 80%*70% + * | | | + * +------+------+ + * | | | + * | 6% | 24% | 6% = 20%*30%, 24% = 80%*30% + * | | | + * +------+------+ + * + * The weights are applied to the neighors and the resulting pixel value is saved at the given location. + * + * NOTE + * The input and output image must have the same pixel size. + * + * @param img_out On return: image with interpolated values + * @param x saved interpolated pixel value at this x-coordinate + * @param y saved interpolated pixel value at this y-coordinate + * @param height image height of input and output image in number of pixels + * @param width image width of input and output image in number of pixels + * @param img_in input image to interpolate pixel values + * @param coord_x x-coordinate to interpolate + * @param coord_y y-coordinate to interpolate + * @param scale_fact coordinates are scaled by this factor + */ +static void interpolate_rgb16_scalar(uint16_t *img_out, const int x, const int y, const int height, const int width, + const uint16_t *img_in, const int coord_x, const int coord_y, const int scale_fact) +#include "alg_interpolate_rgb_scalar.h" + + +/** + * Pixel value interpolation of monochrome image (8 bit per pixel). + * If a pixel coordinate with a fraction part is of interest, do interpolate the correct value from their neighbor's pixel. + * + * E. g. the pixel coordinate x/y = 1.8/2.3 gives the following weights: + * +------+------+ + * | | | + * | 14% | 56% | 14% = 20%*70%, 56% = 80%*70% + * | | | + * +------+------+ + * | | | + * | 6% | 24% | 6% = 20%*30%, 24% = 80%*30% + * | | | + * +------+------+ + * + * The weights are applied to the neighors and the resulting pixel value is saved at the given location. + * + * NOTE + * The input and output image must have the same pixel size. + * + * @param img_out On return: image with interpolated values + * @param x saved interpolated pixel value at this x-coordinate + * @param y saved interpolated pixel value at this y-coordinate + * @param height image height of input and output image in number of pixels + * @param width image width of input and output image in number of pixels + * @param img_in input image to interpolate pixel values + * @param coord_x x-coordinate to interpolate + * @param coord_y y-coordinate to interpolate + * @param scale_fact coordinates are scaled by this factor + */ +static void interpolate_mono8_scalar(uint8_t *img_out, const int x, const int y, const int height, const int width, + const uint8_t *img_in, const int coord_x, const int coord_y, const int scale_fact) +#include "alg_interpolate_mono_scalar.h" + + +/** + * Pixel value interpolation of monochrome image (16 bit per pixel). + * If a pixel coordinate with a fraction part is of interest, do interpolate the correct value from their neighbor's pixel. + * + * E. g. the pixel coordinate x/y = 1.8/2.3 gives the following weights: + * +------+------+ + * | | | + * | 14% | 56% | 14% = 20%*70%, 56% = 80%*70% + * | | | + * +------+------+ + * | | | + * | 6% | 24% | 6% = 20%*30%, 24% = 80%*30% + * | | | + * +------+------+ + * + * The weights are applied to the neighors and the resulting pixel value is saved at the given location. + * + * NOTE + * The input and output image must have the same pixel size. + * + * @param img_out On return: image with interpolated values + * @param x saved interpolated pixel value at this x-coordinate + * @param y saved interpolated pixel value at this y-coordinate + * @param height image height of input and output image in number of pixels + * @param width image width of input and output image in number of pixels + * @param img_in input image to interpolate pixel values + * @param coord_x x-coordinate to interpolate + * @param coord_y y-coordinate to interpolate + * @param scale_fact coordinates are scaled by this factor + */ +static void interpolate_mono16_scalar(uint16_t *img_out, const int x, const int y, const int height, const int width, + const uint16_t *img_in, const int coord_x, const int coord_y, const int scale_fact) +#include "alg_interpolate_mono_scalar.h" + + +/** + * Apply iosceles trapez correction. + * + * @param data correction data + */ +static void correct(struct trapcorr_data_t *data) { + int x, y, x_corr, y_corr; + const int width = data->width; + const int height = data->height; + int bit_channel = data->bit_channel; + struct coord_t *map = data->map; + void *img_calib = data->img_out; + void *img_uncalib = data->img_in; + const int scale_fact = data->map_scale_fact; + const int is_color = data->is_color; + + + for(y = 0; y < height; y++) { + for(x = 0; x < width; x++) { + x_corr = map->x; + y_corr = map->y; + map++; + + if(bit_channel <= 8) { + if(is_color) { + interpolate_rgb8_scalar(img_calib, x, y, height, width, img_uncalib, x_corr, y_corr, scale_fact); + } + else { + interpolate_mono8_scalar(img_calib, x, y, height, width, img_uncalib, x_corr, y_corr, scale_fact); + } + } + else if(bit_channel <= 16) { + if(is_color) { + interpolate_rgb16_scalar(img_calib, x, y, height, width, img_uncalib, x_corr, y_corr, scale_fact); + } + else { + interpolate_mono16_scalar(img_calib, x, y, height, width, img_uncalib, x_corr, y_corr, scale_fact); + } + } + } + } +} + + +/** + * Initialze perspective correction map. + * + * @param data required correction data + */ +static void init_map(struct trapcorr_data_t *data) { + + int x, y; + struct coord_t *map = data->map; + const int scale_fact = (1 << (data->map_scale_fact)); + const int width = data->width; + const int height = data->height; + const float p = data->wh * (width/2.0f); + float p_i, row_scale, x_corr, y_corr; + int x_start, x_end; + + +// printf("XXX P = %f\n", p); + + /* + * horizontal correction + */ + if((width%2) == 0) { + // even width + x_start = (-1)*width/2; + x_end = width/2-1; + } + else { + // odd width + x_start = (-1)*(width-1)/2; + x_end = (width-1)/2; + } + +// printf("XXX x_start = %d, x_end = %d, %d x %d\n", x_start, x_end, width, height); + + for(y = 0; y < height; y++) { + + p_i = ((width/2.0f - p) / height) * y + p; + row_scale = 2.0f * p_i / width; + + // we don't correct vertically + y_corr = y; + + for(x = x_start; x <= x_end; x++) { + x_corr = x/row_scale; + +// if(x > -325 && x < -315 && y < 2) { +// printf("%d/%d: p_i = %f, row_scale = %f, x_corr = %f\n", y, x, p_i, row_scale, x_corr); +// } + + // trapeze is horizontally symmetrically centered --> shift right + x_corr -= x_start; + +// if(x > -325 && x < -315 && y < 2) { +// printf(" ----> x_corr (shift)= %f\n", x_corr); +// } + + // range check + if(x_corr < 0.0f) { + x_corr = 0.0f; + } + else if(x_corr > (width-1.0f)) { + x_corr = width-1.0f; + } + + // apply scaling factor + map->x = (int)roundf(x_corr*scale_fact); + map->y = (int)roundf(y_corr*scale_fact); + map++; + } + } +} + + +/** + * Apply iosceles trapez correction to given image type. + * + * @param trapcorr_data required data for trapez correction + * @return 0 on success otherwise -1 + */ +int trapcorr(struct trapcorr_data_t *trapcorr_data) { + + /* + * Create perspective correction map if needed. + */ + if(trapcorr_data->map_init == 0) { + trapcorr_data->map_scale_fact = 9; // scale by 9 means 2^9 = 512 + init_map(trapcorr_data); + trapcorr_data->map_init = 1; + printf("XXXXX map initialized!\n"); + } + + // apply perspective correction + correct(trapcorr_data); + return 0; +} -- cgit v1.2.1 From 39529749bd4df513541bf259795ee6698f4fd679 Mon Sep 17 00:00:00 2001 From: Patrick Roth Date: Thu, 1 Jul 2021 10:54:34 +0200 Subject: change weights to -100.0...+100.0 per cent The upper and lower horizontal trapeze line will change. The vertical weight is not implemented now! --- color_pipe.c | 32 +++++++++++++++++++------------- color_pipe.h | 8 ++++---- trapcorr.c | 55 +++++++++++++++++++++++++++++-------------------------- 3 files changed, 52 insertions(+), 43 deletions(-) diff --git a/color_pipe.c b/color_pipe.c index 648e259..b0a9ddf 100644 --- a/color_pipe.c +++ b/color_pipe.c @@ -396,8 +396,8 @@ static void set_default_value(struct color_pipe_t *pipe) { pipe->trapcorr_data.enable = 0; pipe->trapcorr_data.map_init = 0; - pipe->trapcorr_data.wv = 1.0f; - pipe->trapcorr_data.wh = 1.0f; + pipe->trapcorr_data.wv = 0.0f; + pipe->trapcorr_data.wh = 0.0f; pipe->trapcorr_data.wv_new = pipe->trapcorr_data.wv; pipe->trapcorr_data.wh_new = pipe->trapcorr_data.wh; } @@ -877,16 +877,15 @@ void __stdcall color_pipe_stageconf_gamma(struct color_pipe_t *color_pipe, int e /** * Pipeline stage configuration: Isosceles Trapeze Correction * - * The vertical and horizontal correction weight are positive - * numbers starting from 0. A weight of 1.0 means no correction. A weight lesser than - * 1.0 means the upper trapeze line is shorter than the lower trapeze line. - * Therfore a weight greater than 1.0 means the upper trapeze line is longer than - * the lower line. + * The vertical and horizontal correction weight are per cent values ranging + * from -100.0 % to +100.0 %. A positive weight means that the upper horizontal trapeze + * is fixed and won't shrink while a negative value means the opposite lower line won't change. + * A weight of zero means not correction. * * @param color_pipe Pointer to pipeline context * @param enable not 0: enable, 0: disable - * @param wv vertical weight - * @param wh horizontal weight + * @param wv vertical weight (range: -100.0 to +100.0) + * @param wh horizontal weight (range: -100.0 to +100.0) */ void __stdcall color_pipe_stageconf_trapcorr(struct color_pipe_t *color_pipe, int enable, float wv, float wh) { // paranoia @@ -896,11 +895,18 @@ void __stdcall color_pipe_stageconf_trapcorr(struct color_pipe_t *color_pipe, in } // range check - if(wv < 0.0f) { - wv = 0.0f; + if(wv < -100.0f) { + wv = -100.0f; } - if(wh < 0.0f) { - wh = 0.0f; + else if(wv > 100.0) { + wv = 100.0f; + } + + if(wh < -100.0f) { + wh = -100.0f; + } + else if(wh > 100.0) { + wh = 100.0f; } color_pipe->trapcorr_data.enable = enable; diff --git a/color_pipe.h b/color_pipe.h index b4c50da..9b52f23 100644 --- a/color_pipe.h +++ b/color_pipe.h @@ -293,10 +293,10 @@ struct trapcorr_data_t { int bit_channel; ///< Bits per color channel. int width; ///< image width in number of pixels int height; ///< image height in number of pixels - float wv; ///< vertical correction weight in per cent (NOTE not implemented yet!) - float wh; ///< horizontal correction weight in per cent - float wv_new; ///< this vertical correction weight in per cent is changed by API call (use double buffering) (NOTE not implemented yet!) - float wh_new; ///< this horizontal correction weight in per cent is changed by API call (use double buffering) + float wv; ///< vertical correction weight in per cent (range: -100.0 to +100.0) (NOTE not implemented yet!) + float wh; ///< horizontal correction weight in per cent (range: -100.0 to +100.0) + float wv_new; ///< double buffered vertical correction weight + float wh_new; ///< double buffered horizontal correction weight int map_init; ///< flag indicating perspective correction map is initialized diff --git a/trapcorr.c b/trapcorr.c index 3ace25f..aef2411 100644 --- a/trapcorr.c +++ b/trapcorr.c @@ -188,7 +188,6 @@ static void correct(struct trapcorr_data_t *data) { const int scale_fact = data->map_scale_fact; const int is_color = data->is_color; - for(y = 0; y < height; y++) { for(x = 0; x < width; x++) { x_corr = map->x; @@ -228,15 +227,32 @@ static void init_map(struct trapcorr_data_t *data) { const int scale_fact = (1 << (data->map_scale_fact)); const int width = data->width; const int height = data->height; - const float p = data->wh * (width/2.0f); - float p_i, row_scale, x_corr, y_corr; + float p, p_i, row_scale, x_corr, y_corr; int x_start, x_end; + int shrink_upper; + // convert -100.0...+100.0 ---> 0.0...2.0 + const float fact = data->wh/100.0f+1.0f; -// printf("XXX P = %f\n", p); + /* + * Checking whether we shrink upper or lower horizontal + * trapeze line. + */ + if(data->wh <= 1.0f) { + // upper line shrinks + shrink_upper = 1; + p = fact * (width/2.0f); + } + else { + // lower line shrinks + shrink_upper = 0; + p = (2.0f - fact) * (width/2.0f); + } /* - * horizontal correction + * We'll loop through image with y-axis symmetrically centered. + * So the image is horizontally shifted to left. Do calculate + * the start and end values on x-axis. */ if((width%2) == 0) { // even width @@ -249,11 +265,15 @@ static void init_map(struct trapcorr_data_t *data) { x_end = (width-1)/2; } -// printf("XXX x_start = %d, x_end = %d, %d x %d\n", x_start, x_end, width, height); - + // loop through image for(y = 0; y < height; y++) { - - p_i = ((width/2.0f - p) / height) * y + p; + if(shrink_upper) { + p_i = ((width/2.0f - p) / height) * y + p; + } + else { + p_i = (-1.0f*((width/2.0f - p) / height)) * y + width/2.0f; + } + row_scale = 2.0f * p_i / width; // we don't correct vertically @@ -262,25 +282,9 @@ static void init_map(struct trapcorr_data_t *data) { for(x = x_start; x <= x_end; x++) { x_corr = x/row_scale; -// if(x > -325 && x < -315 && y < 2) { -// printf("%d/%d: p_i = %f, row_scale = %f, x_corr = %f\n", y, x, p_i, row_scale, x_corr); -// } - // trapeze is horizontally symmetrically centered --> shift right x_corr -= x_start; -// if(x > -325 && x < -315 && y < 2) { -// printf(" ----> x_corr (shift)= %f\n", x_corr); -// } - - // range check - if(x_corr < 0.0f) { - x_corr = 0.0f; - } - else if(x_corr > (width-1.0f)) { - x_corr = width-1.0f; - } - // apply scaling factor map->x = (int)roundf(x_corr*scale_fact); map->y = (int)roundf(y_corr*scale_fact); @@ -305,7 +309,6 @@ int trapcorr(struct trapcorr_data_t *trapcorr_data) { trapcorr_data->map_scale_fact = 9; // scale by 9 means 2^9 = 512 init_map(trapcorr_data); trapcorr_data->map_init = 1; - printf("XXXXX map initialized!\n"); } // apply perspective correction -- cgit v1.2.1