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 | 1187 +++++++++++++++++++++++++++++++++++++++++++++++++++--------
1 files changed, 1,024 insertions(+), 163 deletions(-)
diff --git a/src/image.c b/src/image.c
index 60ccfb8..14105c7 100644
--- a/src/image.c
+++ b/src/image.c
@@ -1,19 +1,27 @@
#include "image.h"
#include "utils.h"
#include "blas.h"
+#include "cuda.h"
#include <stdio.h>
#include <math.h>
-#ifdef OPENCV
-#include "opencv2/highgui/highgui_c.h"
-#include "opencv2/imgproc/imgproc_c.h"
-#endif
-
#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#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} };
@@ -29,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)
@@ -106,21 +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;
- printf("%s: %.2f\n", names[class], prob);
- int offset = class*17 % classes;
- float red = get_color(0,offset,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(2,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;
@@ -135,13 +414,292 @@
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);
+ int n, m;
+ int c;
+ for(c = 0; c < im.c; ++c){
+ for(n = 0; n < im.w-1; ++n){
+ for(m = n + 1; m < im.w; ++m){
+ float swap = im.data[m + im.w*(n + im.h*c)];
+ im.data[m + im.w*(n + im.h*c)] = im.data[n + im.w*(m + im.h*c)];
+ im.data[n + im.w*(m + im.h*c)] = swap;
+ }
+ }
+ }
+}
+
+void rotate_image_cw(image im, int times)
+{
+ assert(im.w == im.h);
+ times = (times + 400) % 4;
+ int i, x, y, c;
+ int n = im.w;
+ for(i = 0; i < times; ++i){
+ for(c = 0; c < im.c; ++c){
+ for(x = 0; x < n/2; ++x){
+ for(y = 0; y < (n-1)/2 + 1; ++y){
+ float temp = im.data[y + im.w*(x + im.h*c)];
+ im.data[y + im.w*(x + im.h*c)] = im.data[n-1-x + im.w*(y + im.h*c)];
+ im.data[n-1-x + im.w*(y + im.h*c)] = im.data[n-1-y + im.w*(n-1-x + im.h*c)];
+ im.data[n-1-y + im.w*(n-1-x + im.h*c)] = im.data[x + im.w*(n-1-y + im.h*c)];
+ im.data[x + im.w*(n-1-y + im.h*c)] = temp;
+ }
+ }
+ }
+ }
+}
void flip_image(image a)
{
@@ -213,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;
@@ -285,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){
@@ -298,8 +875,23 @@
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)
@@ -312,28 +904,84 @@
#endif
}
-void save_image(image im, const char *name)
+#ifdef OPENCV
+
+image ipl_to_image(IplImage* src)
{
- 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]);
+ 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.;
+ }
}
}
- 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);
+ return out;
}
-#ifdef OPENCV
-void save_image_jpg(image p, char *name)
+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);
- rgbgr_image(copy);
+ if(p.c == 3) rgbgr_image(copy);
int x,y,k;
char buff[256];
@@ -354,6 +1002,33 @@
}
#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
+ save_image_jpg(im, name);
+#else
+ save_image_png(im, name);
+#endif
+}
+
+
void show_image_layers(image p, char *name)
{
int i;
@@ -408,6 +1083,26 @@
return out;
}
+
+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;
+}
+
image rotate_image(image im, float rad)
{
int x, y, c;
@@ -449,6 +1144,8 @@
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);
}
@@ -459,6 +1156,179 @@
return cropped;
}
+int best_3d_shift_r(image a, image b, int min, int max)
+{
+ if(min == max) return min;
+ int mid = floor((min + max) / 2.);
+ image c1 = crop_image(b, 0, mid, b.w, b.h);
+ image c2 = crop_image(b, 0, mid+1, b.w, b.h);
+ float d1 = dist_array(c1.data, a.data, a.w*a.h*a.c, 10);
+ float d2 = dist_array(c2.data, a.data, a.w*a.h*a.c, 10);
+ free_image(c1);
+ free_image(c2);
+ if(d1 < d2) return best_3d_shift_r(a, b, min, mid);
+ else return best_3d_shift_r(a, b, mid+1, max);
+}
+
+int best_3d_shift(image a, image b, int min, int max)
+{
+ int i;
+ int best = 0;
+ float best_distance = FLT_MAX;
+ for(i = min; i <= max; i += 2){
+ image c = crop_image(b, 0, i, b.w, b.h);
+ float d = dist_array(c.data, a.data, a.w*a.h*a.c, 100);
+ if(d < best_distance){
+ best_distance = d;
+ best = i;
+ }
+ printf("%d %f\n", i, d);
+ free_image(c);
+ }
+ return best;
+}
+
+void composite_3d(char *f1, char *f2, char *out, int delta)
+{
+ if(!out) out = "out";
+ image a = load_image(f1, 0,0,0);
+ image b = load_image(f2, 0,0,0);
+ int shift = best_3d_shift_r(a, b, -a.h/100, a.h/100);
+
+ image c1 = crop_image(b, 10, shift, b.w, b.h);
+ float d1 = dist_array(c1.data, a.data, a.w*a.h*a.c, 100);
+ 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 && 0){
+ image swap = a;
+ a = b;
+ b = swap;
+ shift = -shift;
+ printf("swapped, %d\n", shift);
+ }
+ else{
+ printf("%d\n", shift);
+ }
+
+ 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];
+ }
+#ifdef OPENCV
+ save_image_jpg(c, out);
+#else
+ save_image(c, out);
+#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;
+ int h = im.h;
+ if(w < h){
+ h = (h * min) / w;
+ w = min;
+ } else {
+ w = (w * min) / h;
+ h = min;
+ }
+ if(w == im.w && h == im.h) return im;
+ image resized = resize_image(im, w, h);
+ return resized;
+}
+
+image random_crop_image(image im, int w, int h)
+{
+ 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;
+}
+
+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;
+}
+
float three_way_max(float a, float b, float c)
{
return (a > b) ? ( (a > c) ? a : c) : ( (b > c) ? b : c) ;
@@ -487,7 +1357,7 @@
v = max;
if(max == 0){
s = 0;
- h = -1;
+ h = 0;
}else{
s = delta/max;
if(r == max){
@@ -498,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);
@@ -515,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) {
@@ -602,6 +1473,29 @@
}
}
+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);
+ int i;
+ for(i = 0; i < im.w * im.h * im.c; ++i){
+ if(c.data[i] > .5) c.data[i] = 1;
+ else c.data[i] = 0;
+ }
+ return c;
+}
+
void saturate_image(image im, float sat)
{
rgb_to_hsv(im);
@@ -610,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);
@@ -618,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);
@@ -627,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);
@@ -703,7 +1616,6 @@
return resized;
}
-#include "cuda.h"
void test_resize(char *filename)
{
@@ -712,93 +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);
-
- #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(im, "Original");
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 )
- {
- printf("Cannot load image \"%s\"\n", filename);
- exit(0);
- }
- image out = ipl_to_image(src);
- cvReleaseImage(&src);
- rgbgr_image(out);
- return out;
-}
-
-#endif
-
image load_image_stb(char *filename, int channels)
{
@@ -827,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)){
@@ -855,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;
@@ -964,6 +1817,14 @@
return filters;
}
+void show_image_normalized(image im, const char *name)
+{
+ image c = copy_image(im);
+ normalize_image(c);
+ show_image(c, name);
+ free_image(c);
+}
+
void show_images(image *ims, int n, char *window)
{
image m = collapse_images_vert(ims, n);
@@ -977,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