retina_svl_custom_elaboration.c

Go to the documentation of this file.

 
#include "../common/common.h"
 
sb_t_err create_retina_project_file(SB_HANDLE* retina);
 
sb_t_err set_samples(SB_HANDLE retina);
 
sb_t_err execute_svl(void);
 
sb_t_err detection(void);
 
typedef struct 
{
    long long last_time_ms;
}retina_svl_user_data;
 
#define SCALE 0.7f
 
static sb_t_err svl_pre_elaboration(const SB_HANDLE image_info, void* const user_data, const char* const image_file, int image_index, sb_t_svl_pre_elaboration* const pe)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_lut_point* ptr = NULL;
    sb_t_image* image = NULL;
    if (!user_data || !image_file || !pe)
    {
        printf("NULL pointer\n");
        return SB_ERR_NULL_POINTER;
    }
 
    memset(pe, 0, sizeof(*pe));
 
    //how to access user data
    //retina_svl_user_data* ud = NULL;
    //ud = (retina_svl_user_data*)user_data;
 
    // Load image.
    CHECK_FN_GOTO(sb_image_load(&image, image_file))
    CHECK_FN_GOTO(sb_image_create(&pe->image, (int)(image->width * SCALE), (int)(image->height * SCALE), image->format))
    // Image elaboration.
    CHECK_FN_GOTO(sb_image_resize(image, sb_rect(0, 0, image->width, image->height), SCALE, 1, pe->image))
 
    // Create the roi.
    CHECK_FN_GOTO(sb_roi_create(&pe->roi, pe->image->width, pe->image->height))
    // set a rectangular roi.
    CHECK_FN_GOTO(sb_roi_set_rect(pe->roi, 255, sb_rect(10, 10, pe->image->width - 10, pe->image->height - 10), 0))
    
    // Create the lut to warp the point coordinates from the rescaled image to the original one.
    CHECK_FN_GOTO(sb_lut_create(&pe->warped2ori, pe->image->width, pe->image->height))
    CHECK_FN_GOTO(sb_lut_get_ptr(pe->warped2ori, &ptr))
    for (int y = 0; y < pe->image->height; ++y)
    {
        sb_t_lut_point* raw = ptr + pe->image->width * y;
        for (int x = 0; x < pe->image->width; ++x)
        {
            raw[x].y = (int)lrintf(y / SCALE);
            if (raw[x].y >= image->height)
                raw[x].y = image->height - 1;
 
            raw[x].x = (int)lrintf(x / SCALE);
            if (raw[x].x >= image->width)
                raw[x].x = image->width - 1;
        }
    }
 
FnExit:
    sb_image_destroy(&image);
    if (err)
    {
        sb_image_destroy(&pe->image);
        sb_roi_destroy(&pe->roi);
        sb_lut_destroy(&pe->warped2ori);
    }
    return(err);
}
 
static sb_t_err svl_progress(void* user_data, const sb_t_svl_res* const res, int force)
{
    retina_svl_user_data *ud = (retina_svl_user_data*)user_data;
    
    if (ud->last_time_ms < res->time_ms || force)
    {
        ud->last_time_ms = res->time_ms + 500;
        printf("\rsvl_progress[%d]  time=%lldms, tp=%d, fp=%d, fn=%d, goodness=%f        ", force, res->time_ms, res->global.tp, res->global.fp, res->global.fn, res->global.goodness);
    }
    sb_svl_destroy_res(&res);
    return(SB_ERR_NONE);
}
 
sb_t_err svl_callback_command(void* const user_data, const sb_t_svl_res* const res, sb_t_svl_command* const command, const char * const msg)
{
    printf("SVL CALLBACK ACTION: stop_reason=%d, msg=%s\n", res->stop_reason, msg);
    *command = SB_SVL_COMMAND_CONTINUE;
    return SB_ERR_NONE;
}
 
int main(void)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_info* sb_info = NULL;
    SB_HANDLE project = NULL;
 
    printf("Initialize the SqueezeBrains library\n");
    CHECK_FN_GOTO(sb_init("../sb.lic"))
 
    // Print library version.
    CHECK_FN_GOTO(sb_get_info(&sb_info, 0))
    printf("sb ver. %s, compiled on %s %s\n", sb_info->version_str, sb_info->compile_date, sb_info->compile_time);
 
    printf("wait for license...\n");
    CHECK_FN_GOTO(wait_license())
 
    
 
    
    CHECK_FN_GOTO(create_retina_project_file(&project))
 
    
    CHECK_FN_GOTO(set_samples(project))
 
    
    CHECK_FN_GOTO(execute_svl())
 
    
    CHECK_FN_GOTO(detection())
 
FnExit:
    sb_project_destroy(&project);
    sb_destroy_info(&sb_info);
 
    printf("Release SqueezeBrains library\n");
    sb_release();
 
    printf("Press ENTER to terminate\n");
    getchar();
    return (int)err;
}
 
sb_t_err create_retina_project_file(SB_HANDLE* retina)
{
    sb_t_err err = SB_ERR_NONE;
    sb_t_par* retina_par = NULL;
 
    // Erase the project file to begin from zero
    remove("../images/wheels." SB_SOLUTION_EXT);
 
    CHECK_FN_GOTO(sb_project_create(retina, "wheels", SB_PROJECT_TYPE_RETINA))
    CHECK_FN_GOTO(sb_project_get_par((*retina), &retina_par))
    CHECK_FN_GOTO(sb_par_add_model(retina_par, "W"))
    retina_par->models.model[0].obj_size = sb_size(((int)(136 * SCALE) + 7) & 0xFFFFFFF8, ((int)(128 * SCALE) + 7) & 0xFFFFFFF8);
    retina_par->models.model[0].obj_min_distance = sb_size((int)(100 * SCALE), (int)(128 * SCALE));
    retina_par->models.model[0].obj_stride_coarse = sb_size(8, 8);
    retina_par->models.model[0].obj_stride_fine = sb_size(4, 4);
    retina_par->models.model[0].perturbations.size = 1;
    retina_par->models.model[0].perturbations.perturbation[0].flip_vertical = 1;
    retina_par->models.model[0].perturbations.perturbation[0].num_synthetic_samples = 1;
    CHECK_FN_GOTO(sb_project_set_par((*retina), retina_par))
    CHECK_FN_GOTO(sb_project_save((*retina), "../images/wheels." SB_SOLUTION_EXT, SB_PROJECT_MODE_DETECTION_AND_SVL))
 
FnExit: 
    sb_par_destroy(&retina_par);
    return err;
}
 
sb_t_err set_samples(SB_HANDLE retina)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE retina_image = NULL;
    sb_t_sample sample;
 
    // Set the parameters common to all sample
    memset(&sample, 0, sizeof(sample));
    sample.type = SB_OBJ_TEST;
    sample.classify_mode = SB_SAMPLE_REQUIRED;
    sample.scale = 1.0f;
    strcpy(sample.model_name, "W");
    // samples of the first image
    CHECK_FN_GOTO(sb_image_info_load(&retina_image, "../images/001.ppm", retina))
    // Reset the image info
    CHECK_FN_GOTO(sb_image_info_reset(retina_image))
    CHECK_FN_GOTO(sb_image_info_set_notes(retina_image, "The first image"))
    CHECK_FN_GOTO(sb_image_info_set_type(retina_image, SB_IMAGE_INFO_TYPE_SVL))
    sample.centre = sb_point(79, 141);
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)))
    CHECK_FN_GOTO(sb_image_info_add_sample(retina_image, &sample))
    sample.centre = sb_point(234, 139);
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)))
    CHECK_FN_GOTO(sb_image_info_add_sample(retina_image, &sample))
    sample.centre = sb_point(537, 146);
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)))
    CHECK_FN_GOTO(sb_image_info_add_sample(retina_image, &sample))
    CHECK_FN_GOTO(sb_image_info_save(retina_image))
    CHECK_FN_GOTO(sb_image_info_destroy(&retina_image))
 
    // samples of the second image
    CHECK_FN_GOTO(sb_image_info_load(&retina_image, "../images/002.ppm", retina))
    // Reset the image info
    CHECK_FN_GOTO(sb_image_info_reset(retina_image))
    CHECK_FN_GOTO(sb_image_info_set_notes(retina_image, "The second image"))
    CHECK_FN_GOTO(sb_image_info_set_type(retina_image, SB_IMAGE_INFO_TYPE_SVL))
    sample.centre = sb_point(333, 143);
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)))
    CHECK_FN_GOTO(sb_image_info_add_sample(retina_image, &sample))
    CHECK_FN_GOTO(sb_image_info_save(retina_image))
    CHECK_FN_GOTO(sb_image_info_destroy(&retina_image))
 
    // samples of the third image
    CHECK_FN_GOTO(sb_image_info_load(&retina_image, "../images/002.ppm", retina))
    // Reset the image info
    CHECK_FN_GOTO(sb_image_info_reset(retina_image))
    CHECK_FN_GOTO(sb_image_info_set_notes(retina_image, "The third image"))
    CHECK_FN_GOTO(sb_image_info_set_type(retina_image, SB_IMAGE_INFO_TYPE_SVL))
    sample.centre = sb_point(511, 136);
    CHECK_FN_GOTO(sb_get_uuid(sample.uuid, sizeof(sample.uuid)))
    CHECK_FN_GOTO(sb_image_info_add_sample(retina_image, &sample))
    CHECK_FN_GOTO(sb_image_info_save(retina_image))
    CHECK_FN_GOTO(sb_image_info_destroy(&retina_image))
 
FnExit:
    sb_image_info_destroy(&retina_image);
    return err;
}
 
sb_t_err execute_svl(void)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE svl = NULL;
    sb_t_svl_res* svl_res = NULL;
    sb_t_par* par = NULL;
    retina_svl_user_data user_data;
    sb_t_solution_info* solution = NULL;
 
    CHECK_FN_GOTO(sb_solution_get_info("../images/wheels." SB_SOLUTION_EXT, &solution));
    CHECK_FN_GOTO(sb_project_load(&svl, "../images/wheels." SB_SOLUTION_EXT, solution->projects.info[solution->current_project].uuid, SB_PROJECT_MODE_DETECTION_AND_SVL))
    CHECK_FN_GOTO(sb_svl_reset(svl))
    CHECK_FN_GOTO(sb_project_get_par(svl, &par))
    memset(&user_data, 0, sizeof(user_data));
    strcpy(par->svl.image_ext, SB_IMAGE_FILE_EXTENSIONS);
    strcpy(par->svl.project_path, "../images/");
    par->svl.sl.goodness_target = 0.8f;
    par->svl.fp_pre_elaboration = svl_pre_elaboration;
    par->svl.fp_command = svl_callback_command;
    par->svl.fp_progress = svl_progress;
    par->svl.user_data = &user_data;
    CHECK_FN_GOTO(sb_project_set_par(svl, par))
    CHECK_FN_GOTO(sb_svl_run(svl))
    printf("\n");
    CHECK_FN_GOTO(sb_svl_get_res(svl, &svl_res))
    printf("goodness=%f\n", svl_res->global.goodness);
    printf("time=%1.3fs\n", svl_res->time_ms / 1000.0f);
    CHECK_FN_GOTO(sb_project_save(svl, NULL, SB_PROJECT_MODE_DETECTION_AND_SVL))
 
FnExit:
    sb_svl_destroy_res(&svl_res);
    sb_par_destroy(&par);
    sb_project_destroy(&svl);
    sb_solution_destroy_info(&solution);
    return err;
}
 
sb_t_err detection(void)
{
    sb_t_err err = SB_ERR_NONE;
    SB_HANDLE retina = NULL;
    sb_t_image* image = NULL;
    sb_t_image* image_resized = NULL;
    sb_t_res* res = NULL;
    sb_t_roi* roi = NULL;
    sb_t_solution_info* solution = NULL;
 
    CHECK_FN_GOTO(sb_solution_get_info("../images/wheels." SB_SOLUTION_EXT, &solution));
    CHECK_FN_GOTO(sb_project_load(&retina, "../images/wheels." SB_SOLUTION_EXT, solution->projects.info[solution->current_project].uuid, SB_PROJECT_MODE_DETECTION_ONLY))
    for (int i = 1; i <= 3; i++)
    {
        char name[256];
        snprintf(name, sizeof(name) - 1, "../images/%03d.ppm", i);
        CHECK_FN_GOTO(sb_image_load(&image, name))
        CHECK_FN_GOTO(sb_image_create(&image_resized, (int)(image->width*SCALE), (int)(image->height*SCALE), image->format))
        CHECK_FN_GOTO(sb_image_resize(image, sb_rect(0, 0, image->width, image->height), SCALE, 1, image_resized))
        CHECK_FN_GOTO(sb_image_destroy(&image))
        CHECK_FN_GOTO(sb_roi_create(&roi, image_resized->width, image_resized->height))
        // Set a rectangular roi equal to image dimensions.
        CHECK_FN_GOTO(sb_roi_set_rect(roi, 255, sb_rect(0, 0, image_resized->width, image_resized->height), 0))
        CHECK_FN_GOTO(sb_project_detection(retina, image_resized, roi, NULL, NULL))
        CHECK_FN_GOTO(sb_project_get_res(retina, &res, 0))
        // Print the results
        printf("image: %s\n", name);
        for (int j = 0; j < res->samples.size; ++j)
            printf("%d) centre=(%d,%d), weight=%f\n", j, res->samples.sample[j].centre.x, res->samples.sample[j].centre.y, res->samples.sample[j].weight);
        // Destroy the handles.
        CHECK_FN_GOTO(sb_image_destroy(&image_resized))
        CHECK_FN_GOTO(sb_roi_destroy(&roi))
        CHECK_FN_GOTO(sb_res_destroy(&res))
    }
FnExit:
    sb_image_destroy(&image);
    sb_image_destroy(&image_resized);
    sb_project_destroy(&retina);
    sb_solution_destroy_info(&solution);
    return err;
}