| Ticket Name: CCS/TDA2: unresolved symbol vcop_median3x3_char_cn, first referenced in ./vcop_median3x3_tb.obj | |
| Query Text: | |
| Part Number: TDA2 Tool/software: Code Composer Studio SDK_VISION_03_02_00_00\ti_components\algorithms\eve_sw_01_18_00_00\kernels\imgsiglib\vcop_median3x3\inc have vcop_median3x3_uchar_cn and vcop_median3x3_char_cn funcs i am building this sample (SDK_VISION_03_02_00_00\ti_components\algorithms\eve_sw_01_18_00_00\kernels\imgsiglib\vcop_median3x3 ) have this unresolved symbol vcop_median3x3_char_cn, first referenced in ./vcop_median3x3_tb.obj Problem THANKS! | |
| Responses: | |
| Hello, I apologize but it seems like the file vcop_median3x3_cn.c is missing from the release. Please create a directory src_C at the same level as src_kernelC and add the attached file to it. regards, Victor vcop_median3x3_cn.c /* | |
| * module : EVE SW | |
| * | |
| * module description : Software for EVE core targeted for imaging and vision | |
| * applications | |
| * | |
| * Copyright (C) 2009-2017 Texas Instruments Incorporated - http://www.ti.com/ | |
| * ALL RIGHTS RESERVED | |
| * | |
| */ | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <assert.h> | |
| #include <math.h> | |
| #include "vcop_median3x3_cn.h" | |
| #define MAX(a, b) (a > b ? a : b) | |
| #define MIN(a, b) (a < b ? a : b) | |
| void vcop_median3x3_uchar_cn | |
| ( | |
| unsigned char *in, | |
| unsigned char *out, | |
| unsigned char *scratch1, | |
| unsigned char *scratch2, | |
| int w_input, | |
| int w_out, | |
| int w_compute, | |
| int h_compute | |
| ) | |
| { | |
| int i, j, m, n, k; | |
| int c2l, c2m, c2h; | |
| int in0, in1; | |
| int tmp; | |
| int min_of_max, max_of_min; | |
| int min_in, max_in, med_in, med_max, med_max_nxt; | |
| int min, med, max; | |
| int scratch_w = w_compute + 0; | |
| /*-----------------------------------------------------------------------*/ | |
| /* Initialize the output to zeros at the beginning. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( i = 0; i < (int) h_compute * 3; i++) // lpend3 | |
| { | |
| for (j = 0; j < scratch_w; j++ ) //lpend4 | |
| { | |
| scratch1[( i * scratch_w) + j ] = 0; | |
| } | |
| } | |
| for ( i = 0; i < w_compute; i++ ) | |
| for ( j = 0; j < h_compute; j++ ) | |
| out[j * w_compute + i ] = 0; | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the first loop where sets of three consecutive rows are */ | |
| /* re ordered as min, med and max rows. Thus, the output of this loop */ | |
| /* has a height of 3x that of the input array. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( j = 0; j < (int) w_compute; j++) // lpend3 | |
| { | |
| /*-------------------------------------------------------------------*/ | |
| /* Initialize the columns to get started. */ | |
| /*-------------------------------------------------------------------*/ | |
| c2l = c2m = c2h = 0; | |
| in0 = in1 = 0; | |
| m = 0; | |
| for (i = 0; i < (int) h_compute; i++ ) //lpend4 | |
| { | |
| /*-----------------------------------------------------------*/ | |
| /* Read in the latest column. */ | |
| /*-----------------------------------------------------------*/ | |
| c2l = in0; | |
| c2m = in1; | |
| c2h = in[( ( i + 0 ) * (w_input + 0) ) + j ]; | |
| #ifdef __PRINT__ | |
| printf("column values read in are:\n %x, %x, %x\n", c2l, c2m, c2h); | |
| #endif | |
| /*-----------------------------------------------------------*/ | |
| /* Sort the latest column into low, middle and high values. */ | |
| /*-----------------------------------------------------------*/ | |
| in0 = c2m; | |
| in1 = c2h; | |
| if ( c2l > c2h ) { tmp = c2l; c2l = c2h; c2h = tmp; } | |
| if ( c2l > c2m ) { tmp = c2l; c2l = c2m; c2m = tmp; } | |
| if ( c2m > c2h ) { tmp = c2m; c2m = c2h; c2h = tmp; } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| m = (i * 3); | |
| scratch1[( (m + 0) * scratch_w) + j] = c2l; | |
| scratch1[( (m + 1) * scratch_w) + j] = c2m; | |
| scratch1[( (m + 2) * scratch_w) + j] = c2h; | |
| } | |
| } | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the second loop where the max_of_min, min_of_max and */ | |
| /* med_of_med values are evaluated in the horizontal direction taking */ | |
| /* three consecutive values at a time and moving the pointer by one each */ | |
| /* time in the horizontal direction. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( i = 0; i < (int) (h_compute * 3); i+=3) // lpend3 | |
| { | |
| for (j = 0; j < (int) scratch_w; j++ ) //lpend4 | |
| { | |
| med_max = 0; | |
| med_max_nxt = 0; | |
| min_of_max = 255; | |
| max_of_min = 0; | |
| for ( k = 0; k < 3; k++) | |
| { | |
| /*----------------------------------------------------------*/ | |
| /* Read in the latest column and copy previous values as */ | |
| /* current values. */ | |
| /*----------------------------------------------------------*/ | |
| min_in = scratch1[( ( i + 6 + 0 ) * scratch_w) + j + k]; | |
| med_in = scratch1[( ( i + 6 + 1 ) * scratch_w) + j + k]; | |
| max_in = scratch1[( ( i + 6 + 2 ) * scratch_w) + j + k]; | |
| /*-----------------------------------------------------------*/ | |
| /* Obtain the min_of_max, max_of_min and median of median */ | |
| /* values, taking three at a time. */ | |
| /*-----------------------------------------------------------*/ | |
| max_of_min = MAX(max_of_min, min_in); | |
| min_of_max = MIN(min_of_max, max_in); | |
| if (med_in > med_max) { tmp = med_max; med_max = med_in; med_in = tmp; } | |
| if (med_in > med_max_nxt) { tmp = med_max_nxt; med_max_nxt = med_in; med_in = tmp; } | |
| } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| scratch2[( (i + 0) * scratch_w) + j] = max_of_min; | |
| scratch2[( (i + 1) * scratch_w) + j] = med_max_nxt; | |
| scratch2[( (i + 2) * scratch_w) + j] = min_of_max; | |
| } | |
| } | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the third loop where the true median is computed from the */ | |
| /* previous result by taking the max_of_min, med_of_med and min_of_max */ | |
| /* values in the vertical order. The resultant array has the same height */ | |
| /* as that of the input. */ | |
| /*-----------------------------------------------------------------------*/ | |
| n = 0; | |
| for ( i = 0; i < (int) h_compute * 3; i+=3) // lpend1 | |
| { | |
| for (j = 0; j < (int) w_compute; j++) //lpend2 | |
| { | |
| /*----------------------------------------------------------*/ | |
| /* Read in the latest column. */ | |
| /*----------------------------------------------------------*/ | |
| min = scratch2[( ( i + 0 ) * scratch_w) + j]; | |
| med = scratch2[( ( i + 1 ) * scratch_w) + j]; | |
| max = scratch2[( ( i + 2 ) * scratch_w) + j]; | |
| /*-----------------------------------------------------------*/ | |
| /* Sort the latest column into low, middle and high values. */ | |
| /*-----------------------------------------------------------*/ | |
| if ( min > max ) { tmp = min; min = max; max = tmp; } | |
| if ( min > med ) { tmp = min; min = med; med = tmp; } | |
| if ( med > max ) { tmp = med; med = max; max = tmp; } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| n = (int) (i/3); | |
| out[( n * w_compute) + j] = med; | |
| } | |
| } | |
| return; | |
| } | |
| void vcop_median3x3_char_cn | |
| ( | |
| signed char *in, | |
| signed char *out, | |
| signed char *scratch1, | |
| signed char *scratch2, | |
| int w_input, | |
| int w_out, | |
| int w_compute, | |
| int h_compute | |
| ) | |
| { | |
| int i, j, m, n, k; | |
| int c2l, c2m, c2h; | |
| int in0, in1; | |
| int tmp; | |
| int min_of_max, max_of_min; | |
| int min_in, max_in, med_in, med_max, med_max_nxt; | |
| int min, med, max; | |
| int scratch_w = w_compute + 0; | |
| /*-----------------------------------------------------------------------*/ | |
| /* Initialize the output to zeros at the beginning. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( i = 0; i < (int) h_compute * 3; i++) // lpend3 | |
| { | |
| for (j = 0; j < scratch_w; j++ ) //lpend4 | |
| { | |
| scratch1[( i * scratch_w) + j ] = 0; | |
| } | |
| } | |
| for ( i = 0; i < w_compute; i++ ) | |
| for ( j = 0; j < h_compute; j++ ) | |
| out[j * w_compute + i ] = 0; | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the first loop where sets of three consecutive rows are */ | |
| /* re ordered as min, med and max rows. Thus, the output of this loop */ | |
| /* has a height of 3x that of the input array. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( j = 0; j < (int) w_compute; j++) // lpend3 | |
| { | |
| /*-------------------------------------------------------------------*/ | |
| /* Initialize the columns to get started. */ | |
| /*-------------------------------------------------------------------*/ | |
| c2l = c2m = c2h = 0; | |
| in0 = in1 = 0; | |
| m = 0; | |
| for (i = 0; i < (int) h_compute; i++ ) //lpend4 | |
| { | |
| /*-----------------------------------------------------------*/ | |
| /* Read in the latest column. */ | |
| /*-----------------------------------------------------------*/ | |
| c2l = in0; | |
| c2m = in1; | |
| c2h = in[( i * w_input ) + j ]; | |
| #ifdef __PRINT__ | |
| printf("column values read in are:\n %x, %x, %x\n", c2l, c2m, c2h); | |
| #endif | |
| /*-----------------------------------------------------------*/ | |
| /* Sort the latest column into low, middle and high values. */ | |
| /*-----------------------------------------------------------*/ | |
| in0 = c2m; | |
| in1 = c2h; | |
| if ( c2l > c2h ) { tmp = c2l; c2l = c2h; c2h = tmp; } | |
| if ( c2l > c2m ) { tmp = c2l; c2l = c2m; c2m = tmp; } | |
| if ( c2m > c2h ) { tmp = c2m; c2m = c2h; c2h = tmp; } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| m = (i * 3); | |
| scratch1[( (m + 0) * scratch_w) + j] = c2l; | |
| scratch1[( (m + 1) * scratch_w) + j] = c2m; | |
| scratch1[( (m + 2) * scratch_w) + j] = c2h; | |
| } | |
| } | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the second loop where the max_of_min, min_of_max and */ | |
| /* med_of_med values are evaluated in the horizontal direction taking */ | |
| /* three consecutive values at a time and moving the pointer by one each */ | |
| /* time in the horizontal direction. */ | |
| /*-----------------------------------------------------------------------*/ | |
| for ( i = 0; i < (int) (h_compute * 3); i+=3) // lpend3 | |
| { | |
| for (j = 0; j < (int) scratch_w; j++ ) //lpend4 | |
| { | |
| med_max = -128; | |
| med_max_nxt = -128; | |
| min_of_max = 127; | |
| max_of_min = -128; | |
| for ( k = 0; k < 3; k++) | |
| { | |
| /*----------------------------------------------------------*/ | |
| /* Read in the latest column and copy previous values as */ | |
| /* current values. */ | |
| /*----------------------------------------------------------*/ | |
| min_in = scratch1[( ( i + 6 + 0 ) * scratch_w) + j + k]; | |
| med_in = scratch1[( ( i + 6 + 1 ) * scratch_w) + j + k]; | |
| max_in = scratch1[( ( i + 6 + 2 ) * scratch_w) + j + k]; | |
| /*-----------------------------------------------------------*/ | |
| /* Obtain the min_of_max, max_of_min and median of median */ | |
| /* values, taking three at a time. */ | |
| /*-----------------------------------------------------------*/ | |
| max_of_min = MAX(max_of_min, min_in); | |
| min_of_max = MIN(min_of_max, max_in); | |
| if (med_in > med_max) { tmp = med_max; med_max = med_in; med_in = tmp; } | |
| if (med_in > med_max_nxt) { tmp = med_max_nxt; med_max_nxt = med_in; med_in = tmp; } | |
| } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| scratch2[( (i + 0) * scratch_w) + j] = max_of_min; | |
| scratch2[( (i + 1) * scratch_w) + j] = med_max_nxt; | |
| scratch2[( (i + 2) * scratch_w) + j] = min_of_max; | |
| } | |
| } | |
| /*-----------------------------------------------------------------------*/ | |
| /* This is the third loop where the true median is computed from the */ | |
| /* previous result by taking the max_of_min, med_of_med and min_of_max */ | |
| /* values in the vertical order. The resultant array has the same height */ | |
| /* as that of the input. */ | |
| /*-----------------------------------------------------------------------*/ | |
| n = 0; | |
| for ( i = 0; i < (int) h_compute * 3; i+=3) // lpend1 | |
| { | |
| for (j = 0; j < (int) w_compute; j++) //lpend2 | |
| { | |
| /*----------------------------------------------------------*/ | |
| /* Read in the latest column. */ | |
| /*----------------------------------------------------------*/ | |
| min = scratch2[( ( i + 0 ) * scratch_w) + j]; | |
| med = scratch2[( ( i + 1 ) * scratch_w) + j]; | |
| max = scratch2[( ( i + 2 ) * scratch_w) + j]; | |
| /*-----------------------------------------------------------*/ | |
| /* Sort the latest column into low, middle and high values. */ | |
| /*-----------------------------------------------------------*/ | |
| if ( min > max ) { tmp = min; min = max; max = tmp; } | |
| if ( min > med ) { tmp = min; min = med; med = tmp; } | |
| if ( med > max ) { tmp = med; med = max; max = tmp; } | |
| /*-----------------------------------------------------------*/ | |
| /* Write the values out. */ | |
| /*-----------------------------------------------------------*/ | |
| n = (int) (i/3); | |
| out[( n * w_compute) + j] = med; | |
| } | |
| } | |
| return; | |
| } | |
| Hi Victor thanks! but i think samples in SDK_VISION_03_04_00_00\ti_components\algorithms\eve_sw_01_19_00_00 all miss the .c file . can you share them at a site we can download if need. shuai | |
| Shuai, You already asked a similar question in another thread and we have already mentioned that we don't release natural C. Please refer the following thread to see our answer https://e2e.ti.com/support/arm/automotive_processors/f/1021/p/723811/2670469#2670469 Regards, Anshu | |