From 1b5afb45838e603fa6780762eb8cc59246dc2d81 Mon Sep 17 00:00:00 2001
From: IlyaOvodov <b@ovdv.ru>
Date: Tue, 08 May 2018 11:09:35 +0000
Subject: [PATCH] Output improvements for detector results: When printing detector results, output was done in random order, obfuscating results for interpreting. Now: 1. Text output includes coordinates of rects in (left,right,top,bottom in pixels) along with label and score 2. Text output is sorted by rect lefts to simplify finding appropriate rects on image 3. If several class probs are > thresh for some detection, the most probable is written first and coordinates for others are not repeated 4. Rects are imprinted in image in order by their best class prob, so most probable rects are always on top and not overlayed by less probable ones 5. Most probable label for rect is always written first Also: 6. Message about low GPU memory include required amount
---
src/image.c | 1303 +++++++++++++++++++++++++++++++++++++++++++++-------------
1 files changed, 999 insertions(+), 304 deletions(-)
diff --git a/src/image.c b/src/image.c
index 3bfa862..14105c7 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1,6 +1,7 @@
#include "image.h"
#include "utils.h"
#include "blas.h"
+#include "cuda.h"
#include <stdio.h>
#include <math.h>
@@ -9,6 +10,18 @@
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
+#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"
+#include "http_stream.h"
+#endif
+#include "http_stream.h"
+#endif
+
int windows = 0;
float colors[6][3] = { {1,0,1}, {0,0,1},{0,1,1},{0,1,0},{1,1,0},{1,0,0} };
@@ -24,24 +37,123 @@
return r;
}
+static float get_pixel(image m, int x, int y, int c)
+{
+ assert(x < m.w && y < m.h && c < m.c);
+ return m.data[c*m.h*m.w + y*m.w + x];
+}
+static float get_pixel_extend(image m, int x, int y, int c)
+{
+ if (x < 0 || x >= m.w || y < 0 || y >= m.h) return 0;
+ /*
+ if(x < 0) x = 0;
+ if(x >= m.w) x = m.w-1;
+ if(y < 0) y = 0;
+ if(y >= m.h) y = m.h-1;
+ */
+ if (c < 0 || c >= m.c) return 0;
+ return get_pixel(m, x, y, c);
+}
+static void set_pixel(image m, int x, int y, int c, float val)
+{
+ if (x < 0 || y < 0 || c < 0 || x >= m.w || y >= m.h || c >= m.c) return;
+ assert(x < m.w && y < m.h && c < m.c);
+ m.data[c*m.h*m.w + y*m.w + x] = val;
+}
+static void add_pixel(image m, int x, int y, int c, float val)
+{
+ assert(x < m.w && y < m.h && c < m.c);
+ m.data[c*m.h*m.w + y*m.w + x] += val;
+}
+
+void composite_image(image source, image dest, int dx, int dy)
+{
+ int x,y,k;
+ for(k = 0; k < source.c; ++k){
+ for(y = 0; y < source.h; ++y){
+ for(x = 0; x < source.w; ++x){
+ float val = get_pixel(source, x, y, k);
+ float val2 = get_pixel_extend(dest, dx+x, dy+y, k);
+ set_pixel(dest, dx+x, dy+y, k, val * val2);
+ }
+ }
+ }
+}
+
+image border_image(image a, int border)
+{
+ image b = make_image(a.w + 2*border, a.h + 2*border, a.c);
+ int x,y,k;
+ for(k = 0; k < b.c; ++k){
+ for(y = 0; y < b.h; ++y){
+ for(x = 0; x < b.w; ++x){
+ float val = get_pixel_extend(a, x - border, y - border, k);
+ if(x - border < 0 || x - border >= a.w || y - border < 0 || y - border >= a.h) val = 1;
+ set_pixel(b, x, y, k, val);
+ }
+ }
+ }
+ return b;
+}
+
+image tile_images(image a, image b, int dx)
+{
+ if(a.w == 0) return copy_image(b);
+ image c = make_image(a.w + b.w + dx, (a.h > b.h) ? a.h : b.h, (a.c > b.c) ? a.c : b.c);
+ fill_cpu(c.w*c.h*c.c, 1, c.data, 1);
+ embed_image(a, c, 0, 0);
+ composite_image(b, c, a.w + dx, 0);
+ return c;
+}
+
+image get_label(image **characters, char *string, int size)
+{
+ if(size > 7) size = 7;
+ image label = make_empty_image(0,0,0);
+ while(*string){
+ image l = characters[size][(int)*string];
+ image n = tile_images(label, l, -size - 1 + (size+1)/2);
+ free_image(label);
+ label = n;
+ ++string;
+ }
+ image b = border_image(label, label.h*.25);
+ free_image(label);
+ return b;
+}
+
+image get_label_v3(image **characters, char *string, int size)
+{
+ size = size / 10;
+ if (size > 7) size = 7;
+ image label = make_empty_image(0, 0, 0);
+ while (*string) {
+ image l = characters[size][(int)*string];
+ image n = tile_images(label, l, -size - 1 + (size + 1) / 2);
+ free_image(label);
+ label = n;
+ ++string;
+ }
+ image b = border_image(label, label.h*.25);
+ free_image(label);
+ return b;
+}
+
void draw_label(image a, int r, int c, image label, const float *rgb)
{
- float ratio = (float) label.w / label.h;
+ int w = label.w;
int h = label.h;
- int w = ratio * h;
- image rl = resize_image(label, w, h);
if (r - h >= 0) r = r - h;
int i, j, k;
for(j = 0; j < h && j + r < a.h; ++j){
for(i = 0; i < w && i + c < a.w; ++i){
for(k = 0; k < label.c; ++k){
- float val = get_pixel(rl, i, j, k);
+ float val = get_pixel(label, i, j, k);
set_pixel(a, i+c, j+r, k, rgb[k] * val);
}
}
}
- free_image(rl);
}
void draw_box(image a, int x1, int y1, int x2, int y2, float r, float g, float b)
@@ -101,22 +213,193 @@
}
}
-void draw_detections(image im, int num, float thresh, box *boxes, float **probs, char **names, image *labels, int classes)
+image **load_alphabet()
+{
+ int i, j;
+ const int nsize = 8;
+ image **alphabets = calloc(nsize, sizeof(image));
+ for(j = 0; j < nsize; ++j){
+ alphabets[j] = calloc(128, sizeof(image));
+ for(i = 32; i < 127; ++i){
+ char buff[256];
+ sprintf(buff, "data/labels/%d_%d.png", i, j);
+ alphabets[j][i] = load_image_color(buff, 0, 0);
+ }
+ }
+ return alphabets;
+}
+
+
+
+// Creates array of detections with prob > thresh and fills best_class for them
+detection_with_class* get_actual_detections(detection *dets, int dets_num, float thresh, int* selected_detections_num)
+{
+ int selected_num = 0;
+ detection_with_class* result_arr = calloc(dets_num, sizeof(detection_with_class));
+ for (int i = 0; i < dets_num; ++i) {
+ int best_class = -1;
+ float best_class_prob = thresh;
+ for (int j = 0; j < dets[i].classes; ++j) {
+ if (dets[i].prob[j] > best_class_prob ) {
+ best_class = j;
+ best_class_prob = dets[i].prob[j];
+ }
+ }
+ if (best_class >= 0) {
+ result_arr[selected_num].det = dets[i];
+ result_arr[selected_num].best_class = best_class;
+ ++selected_num;
+ }
+ }
+ if (selected_detections_num)
+ *selected_detections_num = selected_num;
+ return result_arr;
+}
+
+// compare to sort detection** by bbox.x
+int compare_by_lefts(const void *a_ptr, const void *b_ptr) {
+ const detection_with_class* a = (detection_with_class*)a_ptr;
+ const detection_with_class* b = (detection_with_class*)b_ptr;
+ const float delta = (a->det.bbox.x - a->det.bbox.w/2) - (b->det.bbox.x - b->det.bbox.w/2);
+ return delta < 0 ? -1 : delta > 0 ? 1 : 0;
+}
+
+// compare to sort detection** by best_class probability
+int compare_by_probs(const void *a_ptr, const void *b_ptr) {
+ const detection_with_class* a = (detection_with_class*)a_ptr;
+ const detection_with_class* b = (detection_with_class*)b_ptr;
+ float delta = a->det.prob[a->best_class] - b->det.prob[b->best_class];
+ return delta < 0 ? -1 : delta > 0 ? 1 : 0;
+}
+
+void draw_detections_v3(image im, detection *dets, int num, float thresh, char **names, image **alphabet, int classes, int ext_output)
+{
+ int selected_detections_num;
+ detection_with_class* selected_detections = get_actual_detections(dets, num, thresh, &selected_detections_num);
+
+ // text output
+ qsort(selected_detections, selected_detections_num, sizeof(*selected_detections), compare_by_lefts);
+ for (int i = 0; i < selected_detections_num; ++i) {
+ const int best_class = selected_detections[i].best_class;
+ printf("%s: %.0f%%", names[best_class], selected_detections[i].det.prob[best_class] * 100);
+ if (ext_output)
+ printf("\t(left: %.0f\ttop: %.0f\tw: %0.f\th: %0.f)\n",
+ (selected_detections[i].det.bbox.x - selected_detections[i].det.bbox.w / 2)*im.w,
+ (selected_detections[i].det.bbox.y - selected_detections[i].det.bbox.h / 2)*im.h,
+ selected_detections[i].det.bbox.w*im.w, selected_detections[i].det.bbox.h*im.h);
+ else
+ printf("\n");
+ for (int j = 0; j < classes; ++j) {
+ if (selected_detections[i].det.prob[j] > thresh && j != best_class) {
+ printf("%s: %.0f%%\n", names[j], selected_detections[i].det.prob[j] * 100);
+ }
+ }
+ }
+
+ // image output
+ qsort(selected_detections, selected_detections_num, sizeof(*selected_detections), compare_by_probs);
+ for (int i = 0; i < selected_detections_num; ++i) {
+ int width = im.h * .006;
+ if (width < 1)
+ width = 1;
+
+ /*
+ if(0){
+ width = pow(prob, 1./2.)*10+1;
+ alphabet = 0;
+ }
+ */
+
+ //printf("%d %s: %.0f%%\n", i, names[selected_detections[i].best_class], prob*100);
+ int offset = selected_detections[i].best_class * 123457 % classes;
+ float red = get_color(2, offset, classes);
+ float green = get_color(1, offset, classes);
+ float blue = get_color(0, offset, classes);
+ float rgb[3];
+
+ //width = prob*20+2;
+
+ rgb[0] = red;
+ rgb[1] = green;
+ rgb[2] = blue;
+ box b = selected_detections[i].det.bbox;
+ //printf("%f %f %f %f\n", b.x, b.y, b.w, b.h);
+
+ int left = (b.x - b.w / 2.)*im.w;
+ int right = (b.x + b.w / 2.)*im.w;
+ int top = (b.y - b.h / 2.)*im.h;
+ int bot = (b.y + b.h / 2.)*im.h;
+
+ if (left < 0) left = 0;
+ if (right > im.w - 1) right = im.w - 1;
+ if (top < 0) top = 0;
+ if (bot > im.h - 1) bot = im.h - 1;
+
+ //int b_x_center = (left + right) / 2;
+ //int b_y_center = (top + bot) / 2;
+ //int b_width = right - left;
+ //int b_height = bot - top;
+ //sprintf(labelstr, "%d x %d - w: %d, h: %d", b_x_center, b_y_center, b_width, b_height);
+
+ draw_box_width(im, left, top, right, bot, width, red, green, blue);
+ if (alphabet) {
+ char labelstr[4096] = { 0 };
+ strcat(labelstr, names[selected_detections[i].best_class]);
+ for (int j = 0; j < classes; ++j) {
+ if (selected_detections[i].det.prob[j] > thresh && j != selected_detections[i].best_class) {
+ strcat(labelstr, ", ");
+ strcat(labelstr, names[j]);
+ }
+ }
+ image label = get_label_v3(alphabet, labelstr, (im.h*.03));
+ draw_label(im, top + width, left, label, rgb);
+ free_image(label);
+ }
+ if (selected_detections[i].det.mask) {
+ image mask = float_to_image(14, 14, 1, selected_detections[i].det.mask);
+ image resized_mask = resize_image(mask, b.w*im.w, b.h*im.h);
+ image tmask = threshold_image(resized_mask, .5);
+ embed_image(tmask, im, left, top);
+ free_image(mask);
+ free_image(resized_mask);
+ free_image(tmask);
+ }
+ }
+ free(selected_detections);
+}
+
+void draw_detections(image im, int num, float thresh, box *boxes, float **probs, char **names, image **alphabet, int classes)
{
int i;
for(i = 0; i < num; ++i){
- int class = max_index(probs[i], classes);
- float prob = probs[i][class];
+ int class_id = max_index(probs[i], classes);
+ float prob = probs[i][class_id];
if(prob > thresh){
- int width = pow(prob, 1./2.)*10+1;
- width = 8;
- printf("%s: %.0f%%\n", names[class], prob*100);
- int offset = class*1 % classes;
+
+ //// for comparison with OpenCV version of DNN Darknet Yolo v2
+ //printf("\n %f, %f, %f, %f, ", boxes[i].x, boxes[i].y, boxes[i].w, boxes[i].h);
+ // int k;
+ //for (k = 0; k < classes; ++k) {
+ // printf("%f, ", probs[i][k]);
+ //}
+ //printf("\n");
+
+ int width = im.h * .012;
+
+ if(0){
+ width = pow(prob, 1./2.)*10+1;
+ alphabet = 0;
+ }
+
+ int offset = class_id*123457 % classes;
float red = get_color(2,offset,classes);
float green = get_color(1,offset,classes);
float blue = get_color(0,offset,classes);
float rgb[3];
+
+ //width = prob*20+2;
+
rgb[0] = red;
rgb[1] = green;
rgb[2] = blue;
@@ -131,13 +414,256 @@
if(right > im.w-1) right = im.w-1;
if(top < 0) top = 0;
if(bot > im.h-1) bot = im.h-1;
+ printf("%s: %.0f%%", names[class_id], prob * 100);
+
+ //printf(" - id: %d, x_center: %d, y_center: %d, width: %d, height: %d",
+ // class_id, (right + left) / 2, (bot - top) / 2, right - left, bot - top);
+ printf("\n");
draw_box_width(im, left, top, right, bot, width, red, green, blue);
- if (labels) draw_label(im, top + width, left, labels[class], rgb);
+ if (alphabet) {
+ image label = get_label(alphabet, names[class_id], (im.h*.03)/10);
+ draw_label(im, top + width, left, label, rgb);
+ }
}
}
}
+#ifdef OPENCV
+
+void draw_detections_cv_v3(IplImage* show_img, detection *dets, int num, float thresh, char **names, image **alphabet, int classes)
+{
+ int i, j;
+ if (!show_img) return;
+
+ for (i = 0; i < num; ++i) {
+ char labelstr[4096] = { 0 };
+ int class_id = -1;
+ for (j = 0; j < classes; ++j) {
+ if (dets[i].prob[j] > thresh) {
+ if (class_id < 0) {
+ strcat(labelstr, names[j]);
+ class_id = j;
+ }
+ else {
+ strcat(labelstr, ", ");
+ strcat(labelstr, names[j]);
+ }
+ printf("%s: %.0f%%\n", names[j], dets[i].prob[j] * 100);
+ }
+ }
+ if (class_id >= 0) {
+ int width = show_img->height * .006;
+
+ /*
+ if(0){
+ width = pow(prob, 1./2.)*10+1;
+ alphabet = 0;
+ }
+ */
+
+ //printf("%d %s: %.0f%%\n", i, names[class_id], prob*100);
+ int offset = class_id * 123457 % classes;
+ float red = get_color(2, offset, classes);
+ float green = get_color(1, offset, classes);
+ float blue = get_color(0, offset, classes);
+ float rgb[3];
+
+ //width = prob*20+2;
+
+ rgb[0] = red;
+ rgb[1] = green;
+ rgb[2] = blue;
+ box b = dets[i].bbox;
+ //printf("%f %f %f %f\n", b.x, b.y, b.w, b.h);
+
+ int left = (b.x - b.w / 2.)*show_img->width;
+ int right = (b.x + b.w / 2.)*show_img->width;
+ int top = (b.y - b.h / 2.)*show_img->height;
+ int bot = (b.y + b.h / 2.)*show_img->height;
+
+ if (left < 0) left = 0;
+ if (right > show_img->width - 1) right = show_img->width - 1;
+ if (top < 0) top = 0;
+ if (bot > show_img->height - 1) bot = show_img->height - 1;
+
+ //int b_x_center = (left + right) / 2;
+ //int b_y_center = (top + bot) / 2;
+ //int b_width = right - left;
+ //int b_height = bot - top;
+ //sprintf(labelstr, "%d x %d - w: %d, h: %d", b_x_center, b_y_center, b_width, b_height);
+
+ float const font_size = show_img->height / 1000.F;
+ CvPoint pt1, pt2, pt_text, pt_text_bg1, pt_text_bg2;
+ pt1.x = left;
+ pt1.y = top;
+ pt2.x = right;
+ pt2.y = bot;
+ pt_text.x = left;
+ pt_text.y = top - 12;
+ pt_text_bg1.x = left;
+ pt_text_bg1.y = top - (10 + 25 * font_size);
+ pt_text_bg2.x = right;
+ pt_text_bg2.y = top;
+ CvScalar color;
+ color.val[0] = red * 256;
+ color.val[1] = green * 256;
+ color.val[2] = blue * 256;
+
+ cvRectangle(show_img, pt1, pt2, color, width, 8, 0);
+ //printf("left=%d, right=%d, top=%d, bottom=%d, obj_id=%d, obj=%s \n", left, right, top, bot, class_id, names[class_id]);
+ cvRectangle(show_img, pt_text_bg1, pt_text_bg2, color, width, 8, 0);
+ cvRectangle(show_img, pt_text_bg1, pt_text_bg2, color, CV_FILLED, 8, 0); // filled
+ CvScalar black_color;
+ black_color.val[0] = 0;
+ CvFont font;
+ cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, font_size, font_size, 0, font_size * 3, 8);
+ cvPutText(show_img, labelstr, pt_text, &font, black_color);
+ }
+ }
+}
+
+void draw_detections_cv(IplImage* show_img, int num, float thresh, box *boxes, float **probs, char **names, image **alphabet, int classes)
+{
+ int i;
+
+ for (i = 0; i < num; ++i) {
+ int class_id = max_index(probs[i], classes);
+ float prob = probs[i][class_id];
+ if (prob > thresh) {
+
+ int width = show_img->height * .012;
+
+ if (0) {
+ width = pow(prob, 1. / 2.) * 10 + 1;
+ alphabet = 0;
+ }
+
+ printf("%s: %.0f%%\n", names[class_id], prob * 100);
+ int offset = class_id * 123457 % classes;
+ float red = get_color(2, offset, classes);
+ float green = get_color(1, offset, classes);
+ float blue = get_color(0, offset, classes);
+ float rgb[3];
+
+ //width = prob*20+2;
+
+ rgb[0] = red;
+ rgb[1] = green;
+ rgb[2] = blue;
+ box b = boxes[i];
+
+ int left = (b.x - b.w / 2.)*show_img->width;
+ int right = (b.x + b.w / 2.)*show_img->width;
+ int top = (b.y - b.h / 2.)*show_img->height;
+ int bot = (b.y + b.h / 2.)*show_img->height;
+
+ if (left < 0) left = 0;
+ if (right > show_img->width - 1) right = show_img->width - 1;
+ if (top < 0) top = 0;
+ if (bot > show_img->height - 1) bot = show_img->height - 1;
+
+ float const font_size = show_img->height / 1000.F;
+ CvPoint pt1, pt2, pt_text, pt_text_bg1, pt_text_bg2;
+ pt1.x = left;
+ pt1.y = top;
+ pt2.x = right;
+ pt2.y = bot;
+ pt_text.x = left;
+ pt_text.y = top - 12;
+ pt_text_bg1.x = left;
+ pt_text_bg1.y = top - (10+25*font_size);
+ pt_text_bg2.x = right;
+ pt_text_bg2.y = top;
+ CvScalar color;
+ color.val[0] = red * 256;
+ color.val[1] = green * 256;
+ color.val[2] = blue * 256;
+
+ cvRectangle(show_img, pt1, pt2, color, width, 8, 0);
+ //printf("left=%d, right=%d, top=%d, bottom=%d, obj_id=%d, obj=%s \n", left, right, top, bot, class_id, names[class_id]);
+ cvRectangle(show_img, pt_text_bg1, pt_text_bg2, color, width, 8, 0);
+ cvRectangle(show_img, pt_text_bg1, pt_text_bg2, color, CV_FILLED, 8, 0); // filled
+ CvScalar black_color;
+ black_color.val[0] = 0;
+ CvFont font;
+ cvInitFont(&font, CV_FONT_HERSHEY_SIMPLEX, font_size, font_size, 0, font_size * 3, 8);
+ cvPutText(show_img, names[class_id], pt_text, &font, black_color);
+ }
+ }
+}
+
+IplImage* draw_train_chart(float max_img_loss, int max_batches, int number_of_lines, int img_size)
+{
+ int img_offset = 50;
+ int draw_size = img_size - img_offset;
+ IplImage* img = cvCreateImage(cvSize(img_size, img_size), 8, 3);
+ cvSet(img, CV_RGB(255, 255, 255), 0);
+ CvPoint pt1, pt2, pt_text;
+ CvFont font;
+ cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 1, CV_AA);
+ char char_buff[100];
+ int i;
+ // vertical lines
+ pt1.x = img_offset; pt2.x = img_size, pt_text.x = 10;
+ for (i = 1; i <= number_of_lines; ++i) {
+ pt1.y = pt2.y = (float)i * draw_size / number_of_lines;
+ cvLine(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
+ if (i % 10 == 0) {
+ sprintf(char_buff, "%2.1f", max_img_loss*(number_of_lines - i) / number_of_lines);
+ pt_text.y = pt1.y + 5;
+ cvPutText(img, char_buff, pt_text, &font, CV_RGB(0, 0, 0));
+ cvLine(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
+ }
+ }
+ // horizontal lines
+ pt1.y = draw_size; pt2.y = 0, pt_text.y = draw_size + 15;
+ for (i = 0; i <= number_of_lines; ++i) {
+ pt1.x = pt2.x = img_offset + (float)i * draw_size / number_of_lines;
+ cvLine(img, pt1, pt2, CV_RGB(224, 224, 224), 1, 8, 0);
+ if (i % 10 == 0) {
+ sprintf(char_buff, "%d", max_batches * i / number_of_lines);
+ pt_text.x = pt1.x - 20;
+ cvPutText(img, char_buff, pt_text, &font, CV_RGB(0, 0, 0));
+ cvLine(img, pt1, pt2, CV_RGB(128, 128, 128), 1, 8, 0);
+ }
+ }
+ cvPutText(img, "Iteration number", cvPoint(draw_size / 2, img_size - 10), &font, CV_RGB(0, 0, 0));
+ cvPutText(img, "Press 's' to save: chart.jpg", cvPoint(5, img_size - 10), &font, CV_RGB(0, 0, 0));
+ printf(" If error occurs - run training with flag: -dont_show \n");
+ cvNamedWindow("average loss", CV_WINDOW_NORMAL);
+ cvMoveWindow("average loss", 0, 0);
+ cvResizeWindow("average loss", img_size, img_size);
+ cvShowImage("average loss", img);
+ cvWaitKey(20);
+ return img;
+}
+
+void draw_train_loss(IplImage* img, int img_size, float avg_loss, float max_img_loss, int current_batch, int max_batches)
+{
+ int img_offset = 50;
+ int draw_size = img_size - img_offset;
+ CvFont font;
+ cvInitFont(&font, CV_FONT_HERSHEY_COMPLEX_SMALL, 0.7, 0.7, 0, 1, CV_AA);
+ char char_buff[100];
+ CvPoint pt1, pt2;
+ pt1.x = img_offset + draw_size * (float)current_batch / max_batches;
+ pt1.y = draw_size * (1 - avg_loss / max_img_loss);
+ if (pt1.y < 0) pt1.y = 1;
+ cvCircle(img, pt1, 1, CV_RGB(0, 0, 255), CV_FILLED, 8, 0);
+
+ sprintf(char_buff, "current avg loss = %2.4f", avg_loss);
+ pt1.x = img_size / 2, pt1.y = 30;
+ pt2.x = pt1.x + 250, pt2.y = pt1.y + 20;
+ cvRectangle(img, pt1, pt2, CV_RGB(255, 255, 255), CV_FILLED, 8, 0);
+ pt1.y += 15;
+ cvPutText(img, char_buff, pt1, &font, CV_RGB(0, 0, 0));
+ cvShowImage("average loss", img);
+ int k = cvWaitKey(20);
+ if (k == 's' || current_batch == (max_batches-1)) cvSaveImage("chart.jpg", img, 0);
+}
+#endif // OPENCV
+
void transpose_image(image im)
{
assert(im.w == im.h);
@@ -245,6 +771,26 @@
void normalize_image(image p)
{
+ int i;
+ float min = 9999999;
+ float max = -999999;
+
+ for(i = 0; i < p.h*p.w*p.c; ++i){
+ float v = p.data[i];
+ if(v < min) min = v;
+ if(v > max) max = v;
+ }
+ if(max - min < .000000001){
+ min = 0;
+ max = 1;
+ }
+ for(i = 0; i < p.c*p.w*p.h; ++i){
+ p.data[i] = (p.data[i] - min)/(max-min);
+ }
+}
+
+void normalize_image2(image p)
+{
float *min = calloc(p.c, sizeof(float));
float *max = calloc(p.c, sizeof(float));
int i,j;
@@ -317,7 +863,6 @@
}
free_image(copy);
if(0){
- //if(disp->height < 448 || disp->width < 448 || disp->height > 1000){
int w = 448;
int h = w*p.h/p.w;
if(h > 1000){
@@ -330,179 +875,286 @@
cvReleaseImage(&buffer);
}
cvShowImage(buff, disp);
+
cvReleaseImage(&disp);
- }
+}
+
+
+void show_image_cv_ipl(IplImage *disp, const char *name)
+{
+ if (disp == NULL) return;
+ char buff[256];
+ //sprintf(buff, "%s (%d)", name, windows);
+ sprintf(buff, "%s", name);
+ cvNamedWindow(buff, CV_WINDOW_NORMAL);
+ //cvMoveWindow(buff, 100*(windows%10) + 200*(windows/10), 100*(windows%10));
+ ++windows;
+ cvShowImage(buff, disp);
+ //cvReleaseImage(&disp);
+}
#endif
- void show_image(image p, const char *name)
- {
+void show_image(image p, const char *name)
+{
#ifdef OPENCV
- show_image_cv(p, name);
+ show_image_cv(p, name);
#else
- fprintf(stderr, "Not compiled with OpenCV, saving to %s.png instead\n", name);
- save_image(p, name);
+ fprintf(stderr, "Not compiled with OpenCV, saving to %s.png instead\n", name);
+ save_image(p, name);
#endif
- }
-
- void save_image(image im, const char *name)
- {
- char buff[256];
- //sprintf(buff, "%s (%d)", name, windows);
- sprintf(buff, "%s.png", name);
- unsigned char *data = calloc(im.w*im.h*im.c, sizeof(char));
- int i,k;
- for(k = 0; k < im.c; ++k){
- for(i = 0; i < im.w*im.h; ++i){
- data[i*im.c+k] = (unsigned char) (255*im.data[i + k*im.w*im.h]);
- }
- }
- int success = stbi_write_png(buff, im.w, im.h, im.c, data, im.w*im.c);
- free(data);
- if(!success) fprintf(stderr, "Failed to write image %s\n", buff);
- }
+}
#ifdef OPENCV
- image get_image_from_stream(CvCapture *cap)
- {
- IplImage* src = cvQueryFrame(cap);
- if (!src) return make_empty_image(0,0,0);
- image im = ipl_to_image(src);
- rgbgr_image(im);
- return im;
+
+image ipl_to_image(IplImage* src)
+{
+ unsigned char *data = (unsigned char *)src->imageData;
+ int h = src->height;
+ int w = src->width;
+ int c = src->nChannels;
+ int step = src->widthStep;
+ image out = make_image(w, h, c);
+ int i, j, k, count=0;;
+
+ for(k= 0; k < c; ++k){
+ for(i = 0; i < h; ++i){
+ for(j = 0; j < w; ++j){
+ out.data[count++] = data[i*step + j*c + k]/255.;
+ }
+ }
}
+ return out;
+}
+
+image load_image_cv(char *filename, int channels)
+{
+ IplImage* src = 0;
+ int flag = -1;
+ if (channels == 0) flag = -1;
+ else if (channels == 1) flag = 0;
+ else if (channels == 3) flag = 1;
+ else {
+ fprintf(stderr, "OpenCV can't force load with %d channels\n", channels);
+ }
+
+ 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);
+ return make_image(10,10,3);
+ //exit(0);
+ }
+ image out = ipl_to_image(src);
+ cvReleaseImage(&src);
+ rgbgr_image(out);
+ return out;
+}
+
+image get_image_from_stream(CvCapture *cap)
+{
+ IplImage* src = cvQueryFrame(cap);
+ if (!src) return make_empty_image(0,0,0);
+ image im = ipl_to_image(src);
+ rgbgr_image(im);
+ return im;
+}
+
+image get_image_from_stream_resize(CvCapture *cap, int w, int h, IplImage** in_img, int use_webcam)
+{
+ IplImage* src;
+ if (use_webcam) src = get_webcam_frame(cap);
+ else src = cvQueryFrame(cap);
+
+ if (!src) return make_empty_image(0, 0, 0);
+ IplImage* new_img = cvCreateImage(cvSize(w, h), IPL_DEPTH_8U, 3);
+ *in_img = cvCreateImage(cvSize(src->width, src->height), IPL_DEPTH_8U, 3);
+ cvResize(src, *in_img, CV_INTER_LINEAR);
+ cvResize(src, new_img, CV_INTER_LINEAR);
+ image im = ipl_to_image(new_img);
+ cvReleaseImage(&new_img);
+ rgbgr_image(im);
+ return im;
+}
+
+void save_image_jpg(image p, const char *name)
+{
+ image copy = copy_image(p);
+ if(p.c == 3) rgbgr_image(copy);
+ int x,y,k;
+
+ char buff[256];
+ sprintf(buff, "%s.jpg", name);
+
+ IplImage *disp = cvCreateImage(cvSize(p.w,p.h), IPL_DEPTH_8U, p.c);
+ int step = disp->widthStep;
+ for(y = 0; y < p.h; ++y){
+ for(x = 0; x < p.w; ++x){
+ for(k= 0; k < p.c; ++k){
+ disp->imageData[y*step + x*p.c + k] = (unsigned char)(get_pixel(copy,x,y,k)*255);
+ }
+ }
+ }
+ cvSaveImage(buff, disp,0);
+ cvReleaseImage(&disp);
+ free_image(copy);
+}
#endif
+void save_image_png(image im, const char *name)
+{
+ char buff[256];
+ //sprintf(buff, "%s (%d)", name, windows);
+ sprintf(buff, "%s.png", name);
+ unsigned char *data = calloc(im.w*im.h*im.c, sizeof(char));
+ int i,k;
+ for(k = 0; k < im.c; ++k){
+ for(i = 0; i < im.w*im.h; ++i){
+ data[i*im.c+k] = (unsigned char) (255*im.data[i + k*im.w*im.h]);
+ }
+ }
+ int success = stbi_write_png(buff, im.w, im.h, im.c, data, im.w*im.c);
+ free(data);
+ if(!success) fprintf(stderr, "Failed to write image %s\n", buff);
+}
+
+void save_image(image im, const char *name)
+{
#ifdef OPENCV
- void save_image_jpg(image p, char *name)
- {
- image copy = copy_image(p);
- rgbgr_image(copy);
- int x,y,k;
-
- char buff[256];
- sprintf(buff, "%s.jpg", name);
-
- IplImage *disp = cvCreateImage(cvSize(p.w,p.h), IPL_DEPTH_8U, p.c);
- int step = disp->widthStep;
- for(y = 0; y < p.h; ++y){
- for(x = 0; x < p.w; ++x){
- for(k= 0; k < p.c; ++k){
- disp->imageData[y*step + x*p.c + k] = (unsigned char)(get_pixel(copy,x,y,k)*255);
- }
- }
- }
- cvSaveImage(buff, disp,0);
- cvReleaseImage(&disp);
- free_image(copy);
- }
+ save_image_jpg(im, name);
+#else
+ save_image_png(im, name);
#endif
+}
- void show_image_layers(image p, char *name)
- {
- int i;
- char buff[256];
- for(i = 0; i < p.c; ++i){
- sprintf(buff, "%s - Layer %d", name, i);
- image layer = get_image_layer(p, i);
- show_image(layer, buff);
- free_image(layer);
- }
+
+void show_image_layers(image p, char *name)
+{
+ int i;
+ char buff[256];
+ for(i = 0; i < p.c; ++i){
+ sprintf(buff, "%s - Layer %d", name, i);
+ image layer = get_image_layer(p, i);
+ show_image(layer, buff);
+ free_image(layer);
}
+}
- void show_image_collapsed(image p, char *name)
- {
- image c = collapse_image_layers(p, 1);
- show_image(c, name);
- free_image(c);
+void show_image_collapsed(image p, char *name)
+{
+ image c = collapse_image_layers(p, 1);
+ show_image(c, name);
+ free_image(c);
+}
+
+image make_empty_image(int w, int h, int c)
+{
+ image out;
+ out.data = 0;
+ out.h = h;
+ out.w = w;
+ out.c = c;
+ return out;
+}
+
+image make_image(int w, int h, int c)
+{
+ image out = make_empty_image(w,h,c);
+ out.data = calloc(h*w*c, sizeof(float));
+ return out;
+}
+
+image make_random_image(int w, int h, int c)
+{
+ image out = make_empty_image(w,h,c);
+ out.data = calloc(h*w*c, sizeof(float));
+ int i;
+ for(i = 0; i < w*h*c; ++i){
+ out.data[i] = (rand_normal() * .25) + .5;
}
+ return out;
+}
- image make_empty_image(int w, int h, int c)
- {
- image out;
- out.data = 0;
- out.h = h;
- out.w = w;
- out.c = c;
- return out;
- }
+image float_to_image(int w, int h, int c, float *data)
+{
+ image out = make_empty_image(w,h,c);
+ out.data = data;
+ return out;
+}
- image make_image(int w, int h, int c)
- {
- image out = make_empty_image(w,h,c);
- out.data = calloc(h*w*c, sizeof(float));
- return out;
- }
- image make_random_image(int w, int h, int c)
- {
- image out = make_empty_image(w,h,c);
- out.data = calloc(h*w*c, sizeof(float));
- int i;
- for(i = 0; i < w*h*c; ++i){
- out.data[i] = (rand_normal() * .25) + .5;
- }
- return out;
- }
-
- image float_to_image(int w, int h, int c, float *data)
- {
- image out = make_empty_image(w,h,c);
- out.data = data;
- return out;
- }
-
- image rotate_image(image im, float rad)
- {
- int x, y, c;
- float cx = im.w/2.;
- float cy = im.h/2.;
- image rot = make_image(im.w, im.h, im.c);
- for(c = 0; c < im.c; ++c){
- for(y = 0; y < im.h; ++y){
- for(x = 0; x < im.w; ++x){
- float rx = cos(rad)*(x-cx) - sin(rad)*(y-cy) + cx;
- float ry = sin(rad)*(x-cx) + cos(rad)*(y-cy) + cy;
- float val = bilinear_interpolate(im, rx, ry, c);
- set_pixel(rot, x, y, c, val);
- }
+image rotate_crop_image(image im, float rad, float s, int w, int h, float dx, float dy, float aspect)
+{
+ int x, y, c;
+ float cx = im.w/2.;
+ float cy = im.h/2.;
+ image rot = make_image(w, h, im.c);
+ for(c = 0; c < im.c; ++c){
+ for(y = 0; y < h; ++y){
+ for(x = 0; x < w; ++x){
+ float rx = cos(rad)*((x - w/2.)/s*aspect + dx/s*aspect) - sin(rad)*((y - h/2.)/s + dy/s) + cx;
+ float ry = sin(rad)*((x - w/2.)/s*aspect + dx/s*aspect) + cos(rad)*((y - h/2.)/s + dy/s) + cy;
+ float val = bilinear_interpolate(im, rx, ry, c);
+ set_pixel(rot, x, y, c, val);
}
}
- return rot;
}
+ return rot;
+}
- void translate_image(image m, float s)
- {
- int i;
- for(i = 0; i < m.h*m.w*m.c; ++i) m.data[i] += s;
- }
-
- void scale_image(image m, float s)
- {
- int i;
- for(i = 0; i < m.h*m.w*m.c; ++i) m.data[i] *= s;
- }
-
- image crop_image(image im, int dx, int dy, int w, int h)
- {
- image cropped = make_image(w, h, im.c);
- int i, j, k;
- for(k = 0; k < im.c; ++k){
- for(j = 0; j < h; ++j){
- for(i = 0; i < w; ++i){
- int r = j + dy;
- int c = i + dx;
- float val = 0;
- r = constrain_int(r, 0, im.h-1);
- c = constrain_int(c, 0, im.w-1);
- if (r >= 0 && r < im.h && c >= 0 && c < im.w) {
- val = get_pixel(im, c, r, k);
- }
- set_pixel(cropped, i, j, k, val);
- }
+image rotate_image(image im, float rad)
+{
+ int x, y, c;
+ float cx = im.w/2.;
+ float cy = im.h/2.;
+ image rot = make_image(im.w, im.h, im.c);
+ for(c = 0; c < im.c; ++c){
+ for(y = 0; y < im.h; ++y){
+ for(x = 0; x < im.w; ++x){
+ float rx = cos(rad)*(x-cx) - sin(rad)*(y-cy) + cx;
+ float ry = sin(rad)*(x-cx) + cos(rad)*(y-cy) + cy;
+ float val = bilinear_interpolate(im, rx, ry, c);
+ set_pixel(rot, x, y, c, val);
}
}
- return cropped;
}
+ return rot;
+}
+
+void translate_image(image m, float s)
+{
+ int i;
+ for(i = 0; i < m.h*m.w*m.c; ++i) m.data[i] += s;
+}
+
+void scale_image(image m, float s)
+{
+ int i;
+ for(i = 0; i < m.h*m.w*m.c; ++i) m.data[i] *= s;
+}
+
+image crop_image(image im, int dx, int dy, int w, int h)
+{
+ image cropped = make_image(w, h, im.c);
+ int i, j, k;
+ for(k = 0; k < im.c; ++k){
+ for(j = 0; j < h; ++j){
+ for(i = 0; i < w; ++i){
+ int r = j + dy;
+ int c = i + dx;
+ float val = 0;
+ r = constrain_int(r, 0, im.h-1);
+ c = constrain_int(c, 0, im.w-1);
+ if (r >= 0 && r < im.h && c >= 0 && c < im.w) {
+ val = get_pixel(im, c, r, k);
+ }
+ set_pixel(cropped, i, j, k, val);
+ }
+ }
+ }
+ return cropped;
+}
int best_3d_shift_r(image a, image b, int min, int max)
{
@@ -536,7 +1188,7 @@
return best;
}
-void composite_3d(char *f1, char *f2, char *out)
+void composite_3d(char *f1, char *f2, char *out, int delta)
{
if(!out) out = "out";
image a = load_image(f1, 0,0,0);
@@ -548,7 +1200,7 @@
image c2 = crop_image(b, -10, shift, b.w, b.h);
float d2 = dist_array(c2.data, a.data, a.w*a.h*a.c, 100);
- if(d2 < d1){
+ if(d2 < d1 && 0){
image swap = a;
a = b;
b = swap;
@@ -559,7 +1211,7 @@
printf("%d\n", shift);
}
- image c = crop_image(b, 0, shift, a.w, a.h);
+ image c = crop_image(b, delta, shift, a.w, a.h);
int i;
for(i = 0; i < c.w*c.h; ++i){
c.data[i] = a.data[i];
@@ -571,6 +1223,67 @@
#endif
}
+void fill_image(image m, float s)
+{
+ int i;
+ for (i = 0; i < m.h*m.w*m.c; ++i) m.data[i] = s;
+}
+
+void letterbox_image_into(image im, int w, int h, image boxed)
+{
+ int new_w = im.w;
+ int new_h = im.h;
+ if (((float)w / im.w) < ((float)h / im.h)) {
+ new_w = w;
+ new_h = (im.h * w) / im.w;
+ }
+ else {
+ new_h = h;
+ new_w = (im.w * h) / im.h;
+ }
+ image resized = resize_image(im, new_w, new_h);
+ embed_image(resized, boxed, (w - new_w) / 2, (h - new_h) / 2);
+ free_image(resized);
+}
+
+image letterbox_image(image im, int w, int h)
+{
+ int new_w = im.w;
+ int new_h = im.h;
+ if (((float)w / im.w) < ((float)h / im.h)) {
+ new_w = w;
+ new_h = (im.h * w) / im.w;
+ }
+ else {
+ new_h = h;
+ new_w = (im.w * h) / im.h;
+ }
+ image resized = resize_image(im, new_w, new_h);
+ image boxed = make_image(w, h, im.c);
+ fill_image(boxed, .5);
+ //int i;
+ //for(i = 0; i < boxed.w*boxed.h*boxed.c; ++i) boxed.data[i] = 0;
+ embed_image(resized, boxed, (w - new_w) / 2, (h - new_h) / 2);
+ free_image(resized);
+ return boxed;
+}
+
+image resize_max(image im, int max)
+{
+ int w = im.w;
+ int h = im.h;
+ if(w > h){
+ h = (h * max) / w;
+ w = max;
+ } else {
+ w = (w * max) / h;
+ h = max;
+ }
+ if(w == im.w && h == im.h) return im;
+ image resized = resize_image(im, w, h);
+ return resized;
+}
+
image resize_min(image im, int min)
{
int w = im.w;
@@ -587,15 +1300,32 @@
return resized;
}
-image random_crop_image(image im, int low, int high, int size)
+image random_crop_image(image im, int w, int h)
{
- int r = rand_int(low, high);
- image resized = resize_min(im, r);
- int dx = rand_int(0, resized.w - size);
- int dy = rand_int(0, resized.h - size);
- image crop = crop_image(resized, dx, dy, size, size);
+ int dx = rand_int(0, im.w - w);
+ int dy = rand_int(0, im.h - h);
+ image crop = crop_image(im, dx, dy, w, h);
+ return crop;
+}
- if(resized.data != im.data) free_image(resized);
+image random_augment_image(image im, float angle, float aspect, int low, int high, int size)
+{
+ aspect = rand_scale(aspect);
+ int r = rand_int(low, high);
+ int min = (im.h < im.w*aspect) ? im.h : im.w*aspect;
+ float scale = (float)r / min;
+
+ float rad = rand_uniform(-angle, angle) * TWO_PI / 360.;
+
+ float dx = (im.w*scale/aspect - size) / 2.;
+ float dy = (im.h*scale - size) / 2.;
+ if(dx < 0) dx = 0;
+ if(dy < 0) dy = 0;
+ dx = rand_uniform(-dx, dx);
+ dy = rand_uniform(-dy, dy);
+
+ image crop = rotate_crop_image(im, rad, scale, size, size, dx, dy, aspect);
+
return crop;
}
@@ -627,7 +1357,7 @@
v = max;
if(max == 0){
s = 0;
- h = -1;
+ h = 0;
}else{
s = delta/max;
if(r == max){
@@ -638,6 +1368,7 @@
h = 4 + (r - g) / delta;
}
if (h < 0) h += 6;
+ h = h/6.;
}
set_pixel(im, i, j, 0, h);
set_pixel(im, i, j, 1, s);
@@ -655,7 +1386,7 @@
float f, p, q, t;
for(j = 0; j < im.h; ++j){
for(i = 0; i < im.w; ++i){
- h = get_pixel(im, i , j, 0);
+ h = 6 * get_pixel(im, i , j, 0);
s = get_pixel(im, i , j, 1);
v = get_pixel(im, i , j, 2);
if (s == 0) {
@@ -742,6 +1473,18 @@
}
}
+void translate_image_channel(image im, int c, float v)
+{
+ int i, j;
+ for(j = 0; j < im.h; ++j){
+ for(i = 0; i < im.w; ++i){
+ float pix = get_pixel(im, i, j, c);
+ pix = pix+v;
+ set_pixel(im, i, j, c, pix);
+ }
+ }
+}
+
image binarize_image(image im)
{
image c = copy_image(im);
@@ -761,6 +1504,19 @@
constrain_image(im);
}
+void hue_image(image im, float hue)
+{
+ rgb_to_hsv(im);
+ int i;
+ for(i = 0; i < im.w*im.h; ++i){
+ im.data[i] = im.data[i] + hue;
+ if (im.data[i] > 1) im.data[i] -= 1;
+ if (im.data[i] < 0) im.data[i] += 1;
+ }
+ hsv_to_rgb(im);
+ constrain_image(im);
+}
+
void exposure_image(image im, float sat)
{
rgb_to_hsv(im);
@@ -769,6 +1525,29 @@
constrain_image(im);
}
+void distort_image(image im, float hue, float sat, float val)
+{
+ rgb_to_hsv(im);
+ scale_image_channel(im, 1, sat);
+ scale_image_channel(im, 2, val);
+ int i;
+ for(i = 0; i < im.w*im.h; ++i){
+ im.data[i] = im.data[i] + hue;
+ if (im.data[i] > 1) im.data[i] -= 1;
+ if (im.data[i] < 0) im.data[i] += 1;
+ }
+ hsv_to_rgb(im);
+ constrain_image(im);
+}
+
+void random_distort_image(image im, float hue, float saturation, float exposure)
+{
+ float dhue = rand_uniform_strong(-hue, hue);
+ float dsat = rand_scale(saturation);
+ float dexp = rand_scale(exposure);
+ distort_image(im, dhue, dsat, dexp);
+}
+
void saturate_exposure_image(image im, float sat, float exposure)
{
rgb_to_hsv(im);
@@ -778,23 +1557,6 @@
constrain_image(im);
}
-/*
- image saturate_image(image im, float sat)
- {
- image gray = grayscale_image(im);
- image blend = blend_image(im, gray, sat);
- free_image(gray);
- constrain_image(blend);
- return blend;
- }
-
- image brightness_image(image im, float b)
- {
- image bright = make_image(im.w, im.h, im.c);
- return bright;
- }
- */
-
float bilinear_interpolate(image im, float x, float y, int c)
{
int ix = (int) floorf(x);
@@ -854,7 +1616,6 @@
return resized;
}
-#include "cuda.h"
void test_resize(char *filename)
{
@@ -863,100 +1624,48 @@
printf("L2 Norm: %f\n", mag);
image gray = grayscale_image(im);
- image sat2 = copy_image(im);
- saturate_image(sat2, 2);
+ image c1 = copy_image(im);
+ image c2 = copy_image(im);
+ image c3 = copy_image(im);
+ image c4 = copy_image(im);
+ distort_image(c1, .1, 1.5, 1.5);
+ distort_image(c2, -.1, .66666, .66666);
+ distort_image(c3, .1, 1.5, .66666);
+ distort_image(c4, .1, .66666, 1.5);
- image sat5 = copy_image(im);
- saturate_image(sat5, .5);
-
- image exp2 = copy_image(im);
- exposure_image(exp2, 2);
-
- image exp5 = copy_image(im);
- exposure_image(exp5, .5);
-
- image bin = binarize_image(im);
-
-#ifdef GPU
- image r = resize_image(im, im.w, im.h);
- image black = make_image(im.w*2 + 3, im.h*2 + 3, 9);
- image black2 = make_image(im.w, im.h, 3);
-
- float *r_gpu = cuda_make_array(r.data, r.w*r.h*r.c);
- float *black_gpu = cuda_make_array(black.data, black.w*black.h*black.c);
- float *black2_gpu = cuda_make_array(black2.data, black2.w*black2.h*black2.c);
- shortcut_gpu(3, r.w, r.h, 1, r_gpu, black.w, black.h, 3, black_gpu);
- //flip_image(r);
- //shortcut_gpu(3, r.w, r.h, 1, r.data, black.w, black.h, 3, black.data);
-
- shortcut_gpu(3, black.w, black.h, 3, black_gpu, black2.w, black2.h, 1, black2_gpu);
- cuda_pull_array(black_gpu, black.data, black.w*black.h*black.c);
- cuda_pull_array(black2_gpu, black2.data, black2.w*black2.h*black2.c);
- show_image_layers(black, "Black");
- show_image(black2, "Recreate");
-#endif
show_image(im, "Original");
- show_image(bin, "Binary");
show_image(gray, "Gray");
- show_image(sat2, "Saturation-2");
- show_image(sat5, "Saturation-.5");
- show_image(exp2, "Exposure-2");
- show_image(exp5, "Exposure-.5");
+ show_image(c1, "C1");
+ show_image(c2, "C2");
+ show_image(c3, "C3");
+ show_image(c4, "C4");
#ifdef OPENCV
- cvWaitKey(0);
+ while(1){
+ image aug = random_augment_image(im, 0, .75, 320, 448, 320);
+ show_image(aug, "aug");
+ free_image(aug);
+
+
+ float exposure = 1.15;
+ float saturation = 1.15;
+ float hue = .05;
+
+ image c = copy_image(im);
+
+ float dexp = rand_scale(exposure);
+ float dsat = rand_scale(saturation);
+ float dhue = rand_uniform(-hue, hue);
+
+ distort_image(c, dhue, dsat, dexp);
+ show_image(c, "rand");
+ printf("%f %f %f\n", dhue, dsat, dexp);
+ free_image(c);
+ cvWaitKey(0);
+ }
#endif
}
-#ifdef OPENCV
-image ipl_to_image(IplImage* src)
-{
- unsigned char *data = (unsigned char *)src->imageData;
- int h = src->height;
- int w = src->width;
- int c = src->nChannels;
- int step = src->widthStep;
- image out = make_image(w, h, c);
- int i, j, k, count=0;;
-
- for(k= 0; k < c; ++k){
- for(i = 0; i < h; ++i){
- for(j = 0; j < w; ++j){
- out.data[count++] = data[i*step + j*c + k]/255.;
- }
- }
- }
- return out;
-}
-
-image load_image_cv(char *filename, int channels)
-{
- IplImage* src = 0;
- int flag = -1;
- if (channels == 0) flag = -1;
- else if (channels == 1) flag = 0;
- else if (channels == 3) flag = 1;
- else {
- fprintf(stderr, "OpenCV can't force load with %d channels\n", channels);
- }
-
- 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);
- return make_image(10,10,3);
- //exit(0);
- }
- image out = ipl_to_image(src);
- cvReleaseImage(&src);
- rgbgr_image(out);
- return out;
-}
-
-#endif
-
image load_image_stb(char *filename, int channels)
{
@@ -985,9 +1694,16 @@
image load_image(char *filename, int w, int h, int c)
{
#ifdef OPENCV
- image out = load_image_cv(filename, c);
+
+#ifndef CV_VERSION_EPOCH
+ //image out = load_image_stb(filename, c); // OpenCV 3.x
+ image out = load_image_cv(filename, c);
#else
- image out = load_image_stb(filename, c);
+ image out = load_image_cv(filename, c); // OpenCV 2.4.x
+#endif
+
+#else
+ image out = load_image_stb(filename, c); // without OpenCV
#endif
if((h && w) && (h != out.h || w != out.w)){
@@ -1013,27 +1729,6 @@
return out;
}
-float get_pixel(image m, int x, int y, int c)
-{
- assert(x < m.w && y < m.h && c < m.c);
- return m.data[c*m.h*m.w + y*m.w + x];
-}
-float get_pixel_extend(image m, int x, int y, int c)
-{
- if(x < 0 || x >= m.w || y < 0 || y >= m.h || c < 0 || c >= m.c) return 0;
- return get_pixel(m, x, y, c);
-}
-void set_pixel(image m, int x, int y, int c, float val)
-{
- assert(x < m.w && y < m.h && c < m.c);
- m.data[c*m.h*m.w + y*m.w + x] = val;
-}
-void add_pixel(image m, int x, int y, int c, float val)
-{
- assert(x < m.w && y < m.h && c < m.c);
- m.data[c*m.h*m.w + y*m.w + x] += val;
-}
-
void print_image(image m)
{
int i, j, k;
@@ -1143,14 +1838,14 @@
image sized = resize_image(m, w, h);
*/
normalize_image(m);
- image sized = resize_image(m, m.w, m.h);
- save_image(sized, window);
- show_image(sized, window);
- free_image(sized);
+ save_image(m, window);
+ show_image(m, window);
free_image(m);
}
void free_image(image m)
{
- free(m.data);
+ if(m.data){
+ free(m.data);
+ }
}
--
Gitblit v1.10.0