int main(void)
{
vbx_timestamp_t time_start, time_stop;
double scalar_time, vbx_time, vbx_time_masked;
int i, j, k, l, m, n;
int errors = 0;
vbx_test_init();
vbx_mxp_print_params();
pixel *input, *scalar_input, *vbx_input, *vbx_input_masked;
uint16_t *scalar_short;
input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_input = (pixel *)vbx_remap_cached(input, IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_short = (uint16_t *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(uint16_t));
vbx_input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
vbx_input_masked = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
#if UNIT
unsigned char *vbx_img8;
unsigned short *img, *vbx_img;
unsigned int *iImg, *vbx_iImg;
unsigned int *iiImg, *vbx_iiImg;
img = (unsigned short*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_img = (unsigned short*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_img8 = (unsigned char*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned char));
iImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
iiImg = (unsigned int*)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
vbx_iiImg = (unsigned int*)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned int));
#endif//UNIT
printf("Resolution = %dx%d\n", IMAGE_WIDTH, IMAGE_HEIGHT);
printf("Initializing data\n");
vbx_timestamp_start();
for(l = 0; l < 1; l++){
char *src;
char *sdst;
char *vdst;
char *mdst;
if(l == 0){
load_lenna(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_lenna(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nLenna\n");
src = "lenna";
sdst = "s_lenna";
vdst = "v_lenna";
mdst = "m_lenna";
}else if(l == 1){
load_ms(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_ms(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nMicrosoft\n");
src = "ms";
sdst = "s_ms";
vdst = "v_ms";
mdst = "m_ms";
}else if(l == 2){
load_blank(input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT);
load_blank(vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("\nblank\n");
src = "blank";
sdst = "s_blank";
vdst = "v_blank";
mdst = "m_blank";
}
#if UNIT
int window = 20;
int log=0;
while(((window/3)>>log) >= 2) log++;
errors += compare_scalar_rgb2luma_to_vbw_rgb2luma16(img, vbx_img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, MAX_PRINT_ERRORS);
vbw_rgb2luma8(vbx_img8, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH);
int s;
#if LUT_CI
#if DOUBLE_LUT
printf("Testing double lut\n");
printf("Assign lbp double lut\n");
assign_lbp_lut_ci2();
int prev = errors;
printf("Cascade check\n");
/* errors += cascade_check_2w(face_lbp, face_lbp_max_stage, 256); */
/* errors += cascade_check_2h(face_lbp, face_lbp_max_stage, 256); */
errors += cascade_check_2b(face_lbp, face_lbp_max_stage, 256);
if (errors) {
printf("errors %d\n", errors-prev);
}
#else
assign_lbp_lut_ci();
printf("Testing cascade\n");
int prev = errors;
printf("lut check\n");
#if 0
#if 0
errors += lut_check(256, 0, 0, 0);
if (errors) {
printf("errors %d\n", errors-prev);
}
#elif 1
int print_errors = 0;
vbx_mxp_t *this_mxp = VBX_GET_THIS_MXP();
int vci_lanes = this_mxp->vcustom0_lanes;
int num_features = cascade_max_feature();
int input_length = 10;
int lut_length = num_features*vci_lanes;
int lut_iterations = 15;
#if 1
lut_length = input_length = 128;
lut_iterations = 13;
print_errors = 0;
errors += lut_check2(input_length, lut_length, lut_iterations, print_errors);
if (errors) {
printf("errors %d\n", errors-prev);
}
#elif 1
input_length = 64;
lut_length = input_length;
lut_iterations = 13;
print_errors = 1;
errors += lut_check2(input_length, lut_length, lut_iterations, print_errors);
if (errors) {
printf("errors %d\n", errors-prev);
}
#else
for(s = 2; s < 100; s=s+10){
errors += lut_check2(s, lut_length, lut_iterations, print_errors);
if (errors - prev > 0) {
printf("%d\terrors %d\n", s, errors-prev);
} else {
printf("%d\n", s);
}
prev = errors;
}
#endif
#else
for(s = 0; s < 2000; s=s+100){
errors += lut_check(s, 0, 0, 0);
if (errors - prev > 0) {
printf("%d\terrors %d\n", s, errors-prev);
} else {
printf("%d\n", s);
}
prev = errors;
}
#endif
#elif 1
#else
printf("check cascade\n");
prev = errors;
errors += cascade_check(face_lbp, face_lbp_max_stage, 256);
if (errors) {
printf("errors %d\n", errors-prev);
}
printf("Testing LBP LUT CI\n");
prev = errors;
for(s = 0; s < face_lbp_max_stage; s++){
errors += compare_vbx_lut_to_vbx_lut_ci(s, MAX_PRINT_ERRORS);
}
if (errors) {
printf("errors %d\n", errors-prev);
prev = errors;
}
#endif
#endif
#endif
#if 0
printf("Printing grey scale img\n");
printf("grey = [");
for (j = 0; j < IMAGE_HEIGHT; j++) {
printf("[");
for (i = 0; i < IMAGE_WIDTH; i++) {
printf("%d, ", vbx_img8[j*IMAGE_WIDTH+i]);
}
printf("],\n");
}
printf("]\n");
#endif
#if LBP_CI
printf("Testing LBP Pattern CI\n");
errors += compare_LBPRestrictedCI_to_test_scalar_patterns(vbx_img, vbx_img8, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
#if BLIP
printf("Testing BLIP\n");
for(s = 1; s < 10; s++){
errors += compare_scalar_BLIP2_to_vector_BLIP(img, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS, s);
}
#endif
#if 0
errors += compare_LBPRestrictedSums_to_test_scalar_sums_byte(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestrictedSums2_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_ScalarLBPRestrictedSums_to_test_scalar_sums_half(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_ScalarLBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestrictedPatterns2_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPRestricted_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* overflow issues -- using bytes changes lbp pattern */
errors += compare_LBPRestrictedPatterns_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* requires SKIP_INTEGRALS 0 */
errors += compare_gen_integrals_to_vector_get_img(img, iImg, iiImg, vbx_img, vbx_iImg, vbx_iiImg, vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
/* redundant test, compare to test_scalar_patterns instead */
errors += compare_ScalarLBPRestrictedPatterns_to_SATBinaryPattern(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_SATBinaryPattern_to_test_scalar_patterns(vbx_img, log, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
errors += compare_LBPPassStage_to_restricted(vbx_img, log, face_lbp[0], window, IMAGE_WIDTH, IMAGE_HEIGHT, MAX_PRINT_ERRORS);
#endif
#else // UNIT
#if PRINT
print_python_pixel(scalar_input, src, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
time_start = vbx_timestamp();
scalar_rgb2luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH);
scalar_face_detect_luma(scalar_short, input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, sdst);
time_stop = vbx_timestamp();
scalar_time = vbx_print_scalar_time(time_start, time_stop);
#if PRINT
print_python_pixel(scalar_input, sdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 0, vdst);
time_stop = vbx_timestamp();
vbx_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input, vdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
printf("\nVector Masked");
time_start = vbx_timestamp();
vector_face_detect((pixel *)vbx_input_masked, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_WIDTH, 1, mdst);
time_stop = vbx_timestamp();
vbx_time_masked = vbx_print_vector_time(time_start, time_stop, scalar_time);
#if PRINT
print_python_pixel(vbx_input_masked, mdst, IMAGE_WIDTH, IMAGE_HEIGHT);
#endif
/* errors += match_array_pixel(input, vbx_input, "vector", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0); */
/* errors += match_array_pixel(input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0); */
errors += match_array_pixel(vbx_input, vbx_input_masked, "masked", IMAGE_WIDTH, IMAGE_HEIGHT, 0, MAX_PRINT_ERRORS, 0);
#endif // UNIT
}
VBX_TEST_END(errors);
return errors;
}
int main(void)
{
pixel *input;
pixel *scalar_input;
#if USE_LUMA
unsigned char *vbx_luma;
#endif
unsigned short *scalar_luma;
pixel *vbx_output;
pixel *scalar_output;
vbx_timestamp_t time_start, time_stop;
double scalar_time, vbx_time;
int x, y;
int errors = 0;
vbx_test_init();
vbx_mxp_print_params();
input = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_input = (pixel *)vbx_remap_cached(input, IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
#if USE_LUMA
vbx_luma = (unsigned char *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned char));
#endif
scalar_luma = (unsigned short *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(unsigned short));
vbx_output = (pixel *)vbx_shared_malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
scalar_output = (pixel *)malloc(IMAGE_WIDTH*IMAGE_HEIGHT*sizeof(pixel));
printf("\nInitializing data\n");
printf("Resolution = %dx%d\n", IMAGE_WIDTH, IMAGE_HEIGHT);
init_matrix(input, IMAGE_WIDTH, IMAGE_HEIGHT);
printf("Starting Sobel 3x3 edge-detection test\n");
#if USE_LUMA
scalar_rgb2luma(scalar_luma, scalar_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
vbx_timestamp_start();
time_start = vbx_timestamp();
#if !USE_LUMA
scalar_rgb2luma(scalar_luma, scalar_input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
scalar_sobel_argb32_3x3(scalar_output, scalar_luma, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
time_stop = vbx_timestamp();
scalar_time = vbx_print_scalar_time(time_start, time_stop);
#if USE_LUMA
vbw_rgb2luma8(vbx_luma, (unsigned *)input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH);
#endif
vbx_timestamp_start();
time_start = vbx_timestamp();
#if USE_LUMA
vbw_sobel_luma8_3x3((unsigned *)vbx_output, vbx_luma, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
#else
vbw_sobel_argb32_3x3((unsigned *)vbx_output, (unsigned *)input, IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_PITCH, RENORM_AMOUNT);
#endif
time_stop = vbx_timestamp();
vbx_time = vbx_print_vector_time(time_start, time_stop, scalar_time);
for (y = 0; y < IMAGE_HEIGHT; y++) {
for (x = 0; x < IMAGE_WIDTH; x++) {
#if USE_LUMA
if (scalar_luma[y*IMAGE_WIDTH+x] != vbx_luma[y*IMAGE_WIDTH+x]) {
if (errors < MAX_PRINT_ERRORS) {
printf("Y Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_luma[y*IMAGE_WIDTH+x], vbx_luma[y*IMAGE_WIDTH+x]);
}
errors++;
}
#endif
if (scalar_output[y*IMAGE_WIDTH+x].r != vbx_output[y*IMAGE_WIDTH+x].r) {
if (errors < MAX_PRINT_ERRORS) {
printf("R Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].r, vbx_output[y*IMAGE_WIDTH+x].r);
}
errors++;
}
if (scalar_output[y*IMAGE_WIDTH+x].g != vbx_output[y*IMAGE_WIDTH+x].g) {
if (errors < MAX_PRINT_ERRORS) {
printf("G Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].g, vbx_output[y*IMAGE_WIDTH+x].g);
}
errors++;
}
if (scalar_output[y*IMAGE_WIDTH+x].b != vbx_output[y*IMAGE_WIDTH+x].b) {
if (errors < MAX_PRINT_ERRORS) {
printf("B Error at %d, %d: Expected = %02X, got = %02X\n",
y, x, scalar_output[y*IMAGE_WIDTH+x].b, vbx_output[y*IMAGE_WIDTH+x].b);
}
errors++;
}
}
}
VBX_TEST_END(errors);
return errors;
}