blame | history | patch | commit | commitdiff | ignore whitespace
AlexeyAB
2018-03-30 23cb35e6c8eae8b59fab161036ae3f417a55c8db 
 src/data.c


@@ -29,7 +29,7 @@


    int i;


    pthread_mutex_lock(&mutex);


    for(i = 0; i < n; ++i){


        int index = rand()%m;


        int index = random_gen()%m;


        indexes[i] = index;


        random_paths[i] = paths[index];


        if(i == 0) printf("%s\n", paths[index]);


@@ -44,10 +44,12 @@


    char **random_paths = calloc(n, sizeof(char*));


    int i;


    pthread_mutex_lock(&mutex);


    for(i = 0; i < n; ++i){


        int index = rand()%m;


   //printf("n = %d \n", n);


    for(i = 0; i < n; ++i){		


        int index = random_gen() % m;


        random_paths[i] = paths[index];


        if(i == 0) printf("%s\n", paths[index]);


        //if(i == 0) printf("%s\n", paths[index]);


      //printf("grp: %s\n", paths[index]);


    }


    pthread_mutex_unlock(&mutex);


    return random_paths;


@@ -58,7 +60,8 @@


    char **replace_paths = calloc(n, sizeof(char*));


    int i;


    for(i = 0; i < n; ++i){


        char *replaced = find_replace(paths[i], find, replace);


        char replaced[4096];


        find_replace(paths[i], find, replace, replaced);


        replace_paths[i] = copy_string(replaced);


    }


    return replace_paths;


@@ -112,7 +115,7 @@


    for(i = 0; i < n; ++i){


        image im = load_image_color(paths[i], 0, 0);


        image crop = random_augment_image(im, angle, aspect, min, max, size);


        int flip = rand()%2;


        int flip = random_gen()%2;


        if (flip) flip_image(crop);


        random_distort_image(crop, hue, saturation, exposure);




@@ -160,7 +163,7 @@


    int i;


    for(i = 0; i < n; ++i){


        box_label swap = b[i];


        int index = rand()%n;


        int index = random_gen()%n;


        b[i] = b[index];


        b[index] = swap;


    }


@@ -170,6 +173,13 @@


{


    int i;


    for(i = 0; i < n; ++i){


        if(boxes[i].x == 0 && boxes[i].y == 0) {


            boxes[i].x = 999999;


            boxes[i].y = 999999;


            boxes[i].w = 999999;


            boxes[i].h = 999999;


            continue;


        }


        boxes[i].left   = boxes[i].left  * sx - dx;


        boxes[i].right  = boxes[i].right * sx - dx;


        boxes[i].top    = boxes[i].top   * sy - dy;


@@ -198,12 +208,13 @@




void fill_truth_swag(char *path, float *truth, int classes, int flip, float dx, float dy, float sx, float sy)


{


    char *labelpath = find_replace(path, "images", "labels");


    labelpath = find_replace(labelpath, "JPEGImages", "labels");


    char labelpath[4096];


    find_replace(path, "images", "labels", labelpath);


    find_replace(labelpath, "JPEGImages", "labels", labelpath);


    find_replace(labelpath, ".jpg", ".txt", labelpath);


    find_replace(labelpath, ".JPG", ".txt", labelpath);


    find_replace(labelpath, ".JPEG", ".txt", labelpath);




    labelpath = find_replace(labelpath, ".jpg", ".txt");


    labelpath = find_replace(labelpath, ".JPG", ".txt");


    labelpath = find_replace(labelpath, ".JPEG", ".txt");


    int count = 0;


    box_label *boxes = read_boxes(labelpath, &count);


    randomize_boxes(boxes, count);


@@ -235,13 +246,14 @@




void fill_truth_region(char *path, float *truth, int classes, int num_boxes, int flip, float dx, float dy, float sx, float sy)


{


    char *labelpath = find_replace(path, "images", "labels");


    labelpath = find_replace(labelpath, "JPEGImages", "labels");


    char labelpath[4096];


    find_replace(path, "images", "labels", labelpath);


    find_replace(labelpath, "JPEGImages", "labels", labelpath);




    labelpath = find_replace(labelpath, ".jpg", ".txt");


    labelpath = find_replace(labelpath, ".png", ".txt");


    labelpath = find_replace(labelpath, ".JPG", ".txt");


    labelpath = find_replace(labelpath, ".JPEG", ".txt");


    find_replace(labelpath, ".jpg", ".txt", labelpath);


    find_replace(labelpath, ".png", ".txt", labelpath);


    find_replace(labelpath, ".JPG", ".txt", labelpath);


    find_replace(labelpath, ".JPEG", ".txt", labelpath);


    int count = 0;


    box_label *boxes = read_boxes(labelpath, &count);


    randomize_boxes(boxes, count);


@@ -257,7 +269,7 @@


        h =  boxes[i].h;


        id = boxes[i].id;




        if (w < .01 || h < .01) continue;


        if (w < .001 || h < .001) continue;




        int col = (int)(x*num_boxes);


        int row = (int)(y*num_boxes);


@@ -280,23 +292,35 @@


    free(boxes);


}




void fill_truth_detection(char *path, int num_boxes, float *truth, int classes, int flip, float dx, float dy, float sx, float sy)


void fill_truth_detection(char *path, int num_boxes, float *truth, int classes, int flip, float dx, float dy, float sx, float sy, 


   int small_object, int net_w, int net_h)


{


    char *labelpath = find_replace(path, "images", "labels");


    labelpath = find_replace(labelpath, "JPEGImages", "labels");


    char labelpath[4096];


    find_replace(path, "images", "labels", labelpath);


    find_replace(labelpath, "JPEGImages", "labels", labelpath);




    labelpath = find_replace(labelpath, ".jpg", ".txt");


    labelpath = find_replace(labelpath, ".png", ".txt");


    labelpath = find_replace(labelpath, ".JPG", ".txt");


    labelpath = find_replace(labelpath, ".JPEG", ".txt");


    find_replace(labelpath, "raw", "labels", labelpath);


    find_replace(labelpath, ".jpg", ".txt", labelpath);


    find_replace(labelpath, ".png", ".txt", labelpath);


    find_replace(labelpath, ".JPG", ".txt", labelpath);


    find_replace(labelpath, ".JPEG", ".txt", labelpath);


    int count = 0;


   int i;


    box_label *boxes = read_boxes(labelpath, &count);


   if (small_object == 1) {


      float lowest_w = 1.F / net_w;


      float lowest_h = 1.F / net_h;


      printf(" lowest_w = %f, lowest_h = %f \n", lowest_w, lowest_h);


      for (i = 0; i < count; ++i) {


         if (boxes[i].w < lowest_w) boxes[i].w = lowest_w;


         if (boxes[i].h < lowest_h) boxes[i].h = lowest_h;


      }


   }


    randomize_boxes(boxes, count);


    correct_boxes(boxes, count, dx, dy, sx, sy, flip);


    if(count > num_boxes) count = num_boxes;


    float x,y,w,h;


    int id;


    int i;




    for (i = 0; i < count; ++i) {


        x =  boxes[i].x;


@@ -305,7 +329,8 @@


        h =  boxes[i].h;


        id = boxes[i].id;




        if (w < .01 || h < .01) continue;


      // not detect small objects


      if ((w < 0.001F || h < 0.001F)) continue;




        truth[i*5+0] = x;


        truth[i*5+1] = y;


@@ -384,12 +409,47 @@


    if(count != 1) printf("Too many or too few labels: %d, %s\n", count, path);


}




matrix load_labels_paths(char **paths, int n, char **labels, int k)


void fill_hierarchy(float *truth, int k, tree *hierarchy)


{


    int j;


    for(j = 0; j < k; ++j){


        if(truth[j]){


            int parent = hierarchy->parent[j];


            while(parent >= 0){


                truth[parent] = 1;


                parent = hierarchy->parent[parent];


            }


        }


    }


    int i;


    int count = 0;


    for(j = 0; j < hierarchy->groups; ++j){


        //printf("%d\n", count);


        int mask = 1;


        for(i = 0; i < hierarchy->group_size[j]; ++i){


            if(truth[count + i]){


                mask = 0;


                break;


            }


        }


        if (mask) {


            for(i = 0; i < hierarchy->group_size[j]; ++i){


                truth[count + i] = SECRET_NUM;


            }


        }


        count += hierarchy->group_size[j];


    }


}




matrix load_labels_paths(char **paths, int n, char **labels, int k, tree *hierarchy)


{


    matrix y = make_matrix(n, k);


    int i;


    for(i = 0; i < n && labels; ++i){


        fill_truth(paths[i], labels, k, y.vals[i]);


        if(hierarchy){


            fill_hierarchy(y.vals[i], k, hierarchy);


        }


    }


    return y;


}


@@ -400,11 +460,12 @@


    int i;


    int count = 0;


    for(i = 0; i < n; ++i){


        char *label = find_replace(paths[i], "imgs", "labels");


        label = find_replace(label, "_iconl.jpeg", ".txt");


        char label[4096];


        find_replace(paths[i], "imgs", "labels", label);


        find_replace(label, "_iconl.jpeg", ".txt", label);


        FILE *file = fopen(label, "r");


        if(!file){


            label = find_replace(label, "labels", "labels2");


            find_replace(label, "labels", "labels2", label);


            file = fopen(label, "r");


            if(!file) continue;


        }


@@ -474,7 +535,7 @@


        float sx = (float)swidth  / ow;


        float sy = (float)sheight / oh;




        int flip = rand()%2;


        int flip = random_gen()%2;


        image cropped = crop_image(orig, pleft, ptop, swidth, sheight);




        float dx = ((float)pleft/ow)/sx;


@@ -518,22 +579,24 @@


        int id;


        float iou;




        char *imlabel1 = find_replace(paths[i*2],   "imgs", "labels");


        imlabel1 = find_replace(imlabel1, "jpg", "txt");


        char imlabel1[4096];


        char imlabel2[4096];


        find_replace(paths[i*2],   "imgs", "labels", imlabel1);


        find_replace(imlabel1, "jpg", "txt", imlabel1);


        FILE *fp1 = fopen(imlabel1, "r");




        while(fscanf(fp1, "%d %f", &id, &iou) == 2){


            if (d.y.vals[i][2*id] < iou) d.y.vals[i][2*id] = iou;


        }




        char *imlabel2 = find_replace(paths[i*2+1], "imgs", "labels");


        imlabel2 = find_replace(imlabel2, "jpg", "txt");


        find_replace(paths[i*2+1], "imgs", "labels", imlabel2);


        find_replace(imlabel2, "jpg", "txt", imlabel2);


        FILE *fp2 = fopen(imlabel2, "r");




        while(fscanf(fp2, "%d %f", &id, &iou) == 2){


            if (d.y.vals[i][2*id + 1] < iou) d.y.vals[i][2*id + 1] = iou;


        }


        




        for (j = 0; j < classes; ++j){


            if (d.y.vals[i][2*j] > .5 &&  d.y.vals[i][2*j+1] < .5){


                d.y.vals[i][2*j] = 1;


@@ -558,9 +621,9 @@




data load_data_swag(char **paths, int n, int classes, float jitter)


{


    int index = rand()%n;


    int index = random_gen()%n;


    char *random_path = paths[index];


    




    image orig = load_image_color(random_path, 0, 0);


    int h = orig.h;


    int w = orig.w;


@@ -591,7 +654,7 @@


    float sx = (float)swidth  / w;


    float sy = (float)sheight / h;




    int flip = rand()%2;


    int flip = random_gen()%2;


    image cropped = crop_image(orig, pleft, ptop, swidth, sheight);




    float dx = ((float)pleft/w)/sx;


@@ -609,7 +672,18 @@


    return d;


}




data load_data_detection(int n, char **paths, int m, int w, int h, int boxes, int classes, float jitter, float hue, float saturation, float exposure)


#ifdef OPENCV


#include "opencv2/highgui/highgui_c.h"


#include "opencv2/imgproc/imgproc_c.h"


#include "opencv2/core/version.hpp"


#ifndef CV_VERSION_EPOCH


#include "opencv2/videoio/videoio_c.h"


#include "opencv2/imgcodecs/imgcodecs_c.h"


#endif




#include "http_stream.h"




data load_data_detection(int n, char **paths, int m, int w, int h, int boxes, int classes, float jitter, float hue, float saturation, float exposure, int small_object)


{


    char **random_paths = get_random_paths(paths, n, m);


    int i;


@@ -622,18 +696,30 @@




    d.y = make_matrix(n, 5*boxes);


    for(i = 0; i < n; ++i){


        image orig = load_image_color(random_paths[i], 0, 0);


      const char *filename = random_paths[i];




        int oh = orig.h;


        int ow = orig.w;


      int flag = 1;


      IplImage *src;


      if ((src = cvLoadImage(filename, flag)) == 0)


      {


         fprintf(stderr, "Cannot load image \"%s\"\n", filename);


         char buff[256];


         sprintf(buff, "echo %s >> bad.list", filename);


         system(buff);


         continue;


         //exit(0);


      }




      int oh = src->height;


      int ow = src->width;




        int dw = (ow*jitter);


        int dh = (oh*jitter);




        int pleft  = rand_uniform(-dw, dw);


        int pright = rand_uniform(-dw, dw);


        int ptop   = rand_uniform(-dh, dh);


        int pbot   = rand_uniform(-dh, dh);


        int pleft  = rand_uniform_strong(-dw, dw);


        int pright = rand_uniform_strong(-dw, dw);


        int ptop   = rand_uniform_strong(-dh, dh);


        int pbot   = rand_uniform_strong(-dh, dh);




        int swidth =  ow - pleft - pright;


        int sheight = oh - ptop - pbot;


@@ -641,30 +727,86 @@


        float sx = (float)swidth  / ow;


        float sy = (float)sheight / oh;




        int flip = rand()%2;


        image cropped = crop_image(orig, pleft, ptop, swidth, sheight);


        int flip = random_gen()%2;




        float dx = ((float)pleft/ow)/sx;


        float dy = ((float)ptop /oh)/sy;




        image sized = resize_image(cropped, w, h);


        if(flip) flip_image(sized);


        random_distort_image(sized, hue, saturation, exposure);


        d.X.vals[i] = sized.data;


      float dhue = rand_uniform_strong(-hue, hue);


      float dsat = rand_scale(saturation);


      float dexp = rand_scale(exposure);




        fill_truth_detection(random_paths[i], boxes, d.y.vals[i], classes, flip, dx, dy, 1./sx, 1./sy);


      image ai = image_data_augmentation(src, w, h, pleft, ptop, swidth, sheight, flip, jitter, dhue, dsat, dexp);


      d.X.vals[i] = ai.data;


		


      //show_image(ai, "aug");


      //cvWaitKey(0);




        free_image(orig);


        free_image(cropped);


        fill_truth_detection(filename, boxes, d.y.vals[i], classes, flip, dx, dy, 1./sx, 1./sy, small_object, w, h);




      cvReleaseImage(&src);


    }


    free(random_paths);


    return d;


}


#else // OPENCV


data load_data_detection(int n, char **paths, int m, int w, int h, int boxes, int classes, float jitter, float hue, float saturation, float exposure, int small_object)


{


   char **random_paths = get_random_paths(paths, n, m);


   int i;


   data d = { 0 };


   d.shallow = 0;




   d.X.rows = n;


   d.X.vals = calloc(d.X.rows, sizeof(float*));


   d.X.cols = h*w * 3;




   d.y = make_matrix(n, 5 * boxes);


   for (i = 0; i < n; ++i) {


      image orig = load_image_color(random_paths[i], 0, 0);




      int oh = orig.h;


      int ow = orig.w;




      int dw = (ow*jitter);


      int dh = (oh*jitter);




      int pleft = rand_uniform_strong(-dw, dw);


      int pright = rand_uniform_strong(-dw, dw);


      int ptop = rand_uniform_strong(-dh, dh);


      int pbot = rand_uniform_strong(-dh, dh);




      int swidth = ow - pleft - pright;


      int sheight = oh - ptop - pbot;




      float sx = (float)swidth / ow;


      float sy = (float)sheight / oh;




      int flip = random_gen() % 2;


      image cropped = crop_image(orig, pleft, ptop, swidth, sheight);




      float dx = ((float)pleft / ow) / sx;


      float dy = ((float)ptop / oh) / sy;




      image sized = resize_image(cropped, w, h);


      if (flip) flip_image(sized);


      random_distort_image(sized, hue, saturation, exposure);


      d.X.vals[i] = sized.data;




      fill_truth_detection(random_paths[i], boxes, d.y.vals[i], classes, flip, dx, dy, 1. / sx, 1. / sy, small_object, w, h);




      free_image(orig);


      free_image(cropped);


   }


   free(random_paths);


   return d;


}


#endif   // OPENCV




void *load_thread(void *ptr)


{


    //printf("Loading data: %d\n", rand());


   //srand(time(0));


    //printf("Loading data: %d\n", random_gen());


    load_args a = *(struct load_args*)ptr;


    if(a.exposure == 0) a.exposure = 1;


    if(a.saturation == 0) a.saturation = 1;


@@ -673,7 +815,7 @@


    if (a.type == OLD_CLASSIFICATION_DATA){


        *a.d = load_data_old(a.paths, a.n, a.m, a.labels, a.classes, a.w, a.h);


    } else if (a.type == CLASSIFICATION_DATA){


        *a.d = load_data_augment(a.paths, a.n, a.m, a.labels, a.classes, a.min, a.max, a.size, a.angle, a.aspect, a.hue, a.saturation, a.exposure);


        *a.d = load_data_augment(a.paths, a.n, a.m, a.labels, a.classes, a.hierarchy, a.min, a.max, a.size, a.angle, a.aspect, a.hue, a.saturation, a.exposure);


    } else if (a.type == SUPER_DATA){


        *a.d = load_data_super(a.paths, a.n, a.m, a.w, a.h, a.scale);


    } else if (a.type == WRITING_DATA){


@@ -681,7 +823,7 @@


    } else if (a.type == REGION_DATA){


        *a.d = load_data_region(a.n, a.paths, a.m, a.w, a.h, a.num_boxes, a.classes, a.jitter, a.hue, a.saturation, a.exposure);


    } else if (a.type == DETECTION_DATA){


        *a.d = load_data_detection(a.n, a.paths, a.m, a.w, a.h, a.num_boxes, a.classes, a.jitter, a.hue, a.saturation, a.exposure);


        *a.d = load_data_detection(a.n, a.paths, a.m, a.w, a.h, a.num_boxes, a.classes, a.jitter, a.hue, a.saturation, a.exposure, a.small_object);


    } else if (a.type == SWAG_DATA){


        *a.d = load_data_swag(a.paths, a.n, a.classes, a.jitter);


    } else if (a.type == COMPARE_DATA){


@@ -689,6 +831,9 @@


    } else if (a.type == IMAGE_DATA){


        *(a.im) = load_image_color(a.path, 0, 0);


        *(a.resized) = resize_image(*(a.im), a.w, a.h);


   }else if (a.type == LETTERBOX_DATA) {


      *(a.im) = load_image_color(a.path, 0, 0);


      *(a.resized) = letterbox_image(*(a.im), a.w, a.h);


    } else if (a.type == TAG_DATA){


        *a.d = load_data_tag(a.paths, a.n, a.m, a.classes, a.min, a.max, a.size, a.angle, a.aspect, a.hue, a.saturation, a.exposure);


    }


@@ -707,8 +852,10 @@




void *load_threads(void *ptr)


{


   //srand(time(0));


    int i;


    load_args args = *(load_args *)ptr;


    if (args.threads == 0) args.threads = 1;


    data *out = args.d;


    int total = args.n;


    free(ptr);


@@ -763,24 +910,24 @@


    data d = {0};


    d.shallow = 0;


    d.X = load_image_paths(paths, n, w, h);


    d.y = load_labels_paths(paths, n, labels, k);


    d.y = load_labels_paths(paths, n, labels, k, 0);


    if(m) free(paths);


    return d;


}




/*


data load_data_study(char **paths, int n, int m, char **labels, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)


{


    data d = {0};


    d.indexes = calloc(n, sizeof(int));


    if(m) paths = get_random_paths_indexes(paths, n, m, d.indexes);


    d.shallow = 0;


    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure);


    d.y = load_labels_paths(paths, n, labels, k);


    if(m) free(paths);


    return d;


}


*/


   data load_data_study(char **paths, int n, int m, char **labels, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)


   {


   data d = {0};


   d.indexes = calloc(n, sizeof(int));


   if(m) paths = get_random_paths_indexes(paths, n, m, d.indexes);


   d.shallow = 0;


   d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure);


   d.y = load_labels_paths(paths, n, labels, k);


   if(m) free(paths);


   return d;


   }


 */




data load_data_super(char **paths, int n, int m, int w, int h, int scale)


{


@@ -800,7 +947,7 @@


    for(i = 0; i < n; ++i){


        image im = load_image_color(paths[i], 0, 0);


        image crop = random_crop_image(im, w*scale, h*scale);


        int flip = rand()%2;


        int flip = random_gen()%2;


        if (flip) flip_image(crop);


        image resize = resize_image(crop, w, h);


        d.X.vals[i] = resize.data;


@@ -812,13 +959,13 @@


    return d;


}




data load_data_augment(char **paths, int n, int m, char **labels, int k, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)


data load_data_augment(char **paths, int n, int m, char **labels, int k, tree *hierarchy, int min, int max, int size, float angle, float aspect, float hue, float saturation, float exposure)


{


    if(m) paths = get_random_paths(paths, n, m);


    data d = {0};


    d.shallow = 0;


    d.X = load_image_augment_paths(paths, n, min, max, size, angle, aspect, hue, saturation, exposure);


    d.y = load_labels_paths(paths, n, labels, k);


    d.y = load_labels_paths(paths, n, labels, k, hierarchy);


    if(m) free(paths);


    return d;


}


@@ -905,8 +1052,8 @@


    for(i = 0; i < 10000; ++i){


        unsigned char bytes[3073];


        fread(bytes, 1, 3073, fp);


        int class = bytes[0];


        y.vals[i][class] = 1;


        int class_id = bytes[0];


        y.vals[i][class_id] = 1;


        for(j = 0; j < X.cols; ++j){


            X.vals[i][j] = (double)bytes[j+1];


        }


@@ -922,7 +1069,7 @@


{


    int j;


    for(j = 0; j < n; ++j){


        int index = rand()%d.X.rows;


        int index = random_gen()%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));


    }


@@ -969,8 +1116,8 @@


        for(i = 0; i < 10000; ++i){


            unsigned char bytes[3073];


            fread(bytes, 1, 3073, fp);


            int class = bytes[0];


            y.vals[i+b*10000][class] = 1;


            int class_id = bytes[0];


            y.vals[i+b*10000][class_id] = 1;


            for(j = 0; j < X.cols; ++j){


                X.vals[i+b*10000][j] = (double)bytes[j+1];


            }


@@ -1035,7 +1182,7 @@


{


    int i;


    for(i = d.X.rows-1; i > 0; --i){


        int index = rand()%i;


        int index = random_gen()%i;


        float *swap = d.X.vals[index];


        d.X.vals[index] = d.X.vals[i];


        d.X.vals[i] = swap;


@@ -1099,7 +1246,7 @@




    int i;


    for(i = 0; i < num; ++i){


        int index = rand()%d.X.rows;


        int index = random_gen()%d.X.rows;


        r.X.vals[i] = d.X.vals[index];


        r.y.vals[i] = d.y.vals[index];


    }