level adjustment for images

Joseph Redmon

2015-04-15 d97331b88ff3d50035b1e22c9d0eb671b61227e3

 src/data.c

@@ -6,6 +6,8 @@
#include <stdlib.h>
#include <string.h>

unsigned int data_seed;

struct load_args{
    char **paths;
    int n;
@@ -40,14 +42,14 @@
    char **random_paths = calloc(n, sizeof(char*));
    int i;
    for(i = 0; i < n; ++i){
        int index = rand()%m;
        int index = rand_r(&data_seed)%m;
        random_paths[i] = paths[index];
        if(i == 0) printf("%s\n", paths[index]);
    }
    return random_paths;
}

matrix load_image_paths(char **paths, int n, int h, int w)
matrix load_image_paths(char **paths, int n, int w, int h)
{
    int i;
    matrix X;
@@ -56,7 +58,7 @@
    X.cols = 0;

    for(i = 0; i < n; ++i){
        image im = load_image_color(paths[i], h, w);
        image im = load_image_color(paths[i], w, h);
        X.vals[i] = im.data;
        X.cols = im.h*im.w*im.c;
    }
@@ -100,7 +102,7 @@
    int i;
    for(i = 0; i < n; ++i){
        box swap = b[i];
        int index = rand()%n;
        int index = rand_r(&data_seed)%n;
        b[i] = b[index];
        b[index] = swap;
    }
@@ -108,8 +110,9 @@

void fill_truth_detection(char *path, float *truth, int classes, int num_boxes, int flip, int background, float dx, float dy, float sx, float sy)
{
    char *labelpath = find_replace(path, "VOC2012/JPEGImages", "labels");
    char *labelpath = find_replace(path, "detection_images", "labels");
    labelpath = find_replace(labelpath, ".jpg", ".txt");
    labelpath = find_replace(labelpath, ".JPEG", ".txt");
    int count = 0;
    box *boxes = read_boxes(labelpath, &count);
    randomize_boxes(boxes, count);
@@ -206,12 +209,12 @@
    }
}

data load_data_captcha(char **paths, int n, int m, int k, int h, int w)
data load_data_captcha(char **paths, int n, int m, int k, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.X = load_image_paths(paths, n, w, h);
    d.y = make_matrix(n, k*NUMCHARS);
    int i;
    for(i = 0; i < n; ++i){
@@ -221,12 +224,12 @@
    return d;
}

data load_data_captcha_encode(char **paths, int n, int m, int h, int w)
data load_data_captcha_encode(char **paths, int n, int m, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.X = load_image_paths(paths, n, w, h);
    d.X.cols = 17100;
    d.y = d.X;
    if(m) free(paths);
@@ -257,21 +260,6 @@
    return y;
}

data load_data_image_pathfile(char *filename, char **labels, int k, int h, int w)
{
    list *plist = get_paths(filename);
    char **paths = (char **)list_to_array(plist);
    int n = plist->size;
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.y = load_labels_paths(paths, n, labels, k);
    free_list_contents(plist);
    free_list(plist);
    free(paths);
    return d;
}

char **get_labels(char *filename)
{
    list *plist = get_paths(filename);
@@ -291,10 +279,8 @@
    }
}

data load_data_detection_jitter_random(int n, char **paths, int m, int classes, int h, int w, int num_boxes, int background)
data load_data_detection_jitter_random(int n, char **paths, int m, int classes, int w, int h, int num_boxes, int background)
{
    //float minscale = 0.85;
    //float maxscale = 1.15;
    char **random_paths = get_random_paths(paths, n, m);
    int i;
    data d;
@@ -308,26 +294,43 @@
    d.y = make_matrix(n, k);
    for(i = 0; i < n; ++i){
        image orig = load_image_color(random_paths[i], 0, 0);
        float exposure = rand_uniform()+1;
        if(rand_uniform() > .5) exposure = 1/exposure;

        float saturation = rand_uniform()+1;
        if(rand_uniform() > .5) saturation = 1/saturation;

        int oh = orig.h;
        int ow = orig.w;
        int pleft  = (rand_uniform() * 64. - 32.);
        int pright = (rand_uniform() * 64. - 32.);
        int ptop   = (rand_uniform() * 64. - 32.);
        int pbot   = (rand_uniform() * 64. - 32.);

        int dw = ow/10;
        int dh = oh/10;

        int pleft  = (rand_uniform() * 2*dw - dw);
        int pright = (rand_uniform() * 2*dw - dw);
        int ptop   = (rand_uniform() * 2*dh - dh);
        int pbot   = (rand_uniform() * 2*dh - dh);

        int swidth =  ow - pleft - pright;
        int sheight = oh - ptop - pbot;

        float sx = (float)swidth  / ow;
        float sy = (float)sheight / oh;
        
        /*
        float angle = rand_uniform()*.1 - .05;
        image rot = rotate_image(orig, angle);
        free_image(orig);
        orig = rot;
        */

        int flip = rand()%2;
        image cropped = crop_image(orig, ptop, pleft, sheight, swidth);
        int flip = rand_r(&data_seed)%2;
        image cropped = crop_image(orig, pleft, ptop, swidth, sheight);
        float dx = ((float)pleft/ow)/sx;
        float dy = ((float)ptop /oh)/sy;

        free_image(orig);
        image sized = resize_image(cropped, h, w);
        image sized = resize_image(cropped, w, h);
        free_image(cropped);
        if(flip) flip_image(sized);
        d.X.vals[i] = sized.data;
@@ -340,16 +343,14 @@

void *load_detection_thread(void *ptr)
{
    printf("Loading data: %d\n", rand());
    printf("Loading data: %d\n", rand_r(&data_seed));
    struct load_args a = *(struct load_args*)ptr;
    *a.d = load_data_detection_jitter_random(a.n, a.paths, a.m, a.classes, a.h, a.w, a.num_boxes, a.background);
    translate_data_rows(*a.d, -128);
    scale_data_rows(*a.d, 1./128);
    *a.d = load_data_detection_jitter_random(a.n, a.paths, a.m, a.classes, a.w, a.h, a.num_boxes, a.background);
    free(ptr);
    return 0;
}

pthread_t load_data_detection_thread(int n, char **paths, int m, int classes, int h, int w, int nh, int nw, int background, data *d)
pthread_t load_data_detection_thread(int n, char **paths, int m, int classes, int w, int h, int nh, int nw, int background, data *d)
{
    pthread_t thread;
    struct load_args *args = calloc(1, sizeof(struct load_args));
@@ -370,12 +371,12 @@
    return thread;
}

data load_data(char **paths, int n, int m, char **labels, int k, int h, int w)
data load_data(char **paths, int n, int m, char **labels, int k, int w, int h)
{
    if(m) paths = get_random_paths(paths, n, m);
    data d;
    d.shallow = 0;
    d.X = load_image_paths(paths, n, h, w);
    d.X = load_image_paths(paths, n, w, h);
    d.y = load_labels_paths(paths, n, labels, k);
    if(m) free(paths);
    return d;
@@ -384,14 +385,12 @@
void *load_in_thread(void *ptr)
{
    struct load_args a = *(struct load_args*)ptr;
    *a.d = load_data(a.paths, a.n, a.m, a.labels, a.k, a.h, a.w);
    translate_data_rows(*a.d, -128);
    scale_data_rows(*a.d, 1./128);
    *a.d = load_data(a.paths, a.n, a.m, a.labels, a.k, a.w, a.h);
    free(ptr);
    return 0;
}

pthread_t load_data_thread(char **paths, int n, int m, char **labels, int k, int h, int w, data *d)
pthread_t load_data_thread(char **paths, int n, int m, char **labels, int k, int w, int h, data *d)
{
    pthread_t thread;
    struct load_args *args = calloc(1, sizeof(struct load_args));
@@ -447,7 +446,7 @@
            X.vals[i][j] = (double)bytes[j+1];
        }
    }
    translate_data_rows(d, -144);
    translate_data_rows(d, -128);
    scale_data_rows(d, 1./128);
    //normalize_data_rows(d);
    fclose(fp);
@@ -458,7 +457,7 @@
{
    int j;
    for(j = 0; j < n; ++j){
        int index = rand()%d.X.rows;
        int index = rand_r(&data_seed)%d.X.rows;
        memcpy(X+j*d.X.cols, d.X.vals[index], d.X.cols*sizeof(float));
        memcpy(y+j*d.y.cols, d.y.vals[index], d.y.cols*sizeof(float));
    }
@@ -503,7 +502,7 @@
        fclose(fp);
    }
    //normalize_data_rows(d);
    translate_data_rows(d, -144);
    translate_data_rows(d, -128);
    scale_data_rows(d, 1./128);
    return d;
}
@@ -512,7 +511,7 @@
{
    int i;
    for(i = d.X.rows-1; i > 0; --i){
        int index = rand()%i;
        int index = rand_r(&data_seed)%i;
        float *swap = d.X.vals[index];
        d.X.vals[index] = d.X.vals[i];
        d.X.vals[i] = swap;