#include "image.h"
|
#include "utils.h"
|
#include <stdio.h>
|
|
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} };
|
|
float get_color(int c, int x, int max)
|
{
|
float ratio = ((float)x/max)*5;
|
int i = floor(ratio);
|
int j = ceil(ratio);
|
ratio -= i;
|
float r = (1-ratio) * colors[i][c] + ratio*colors[j][c];
|
//printf("%f\n", r);
|
return r;
|
}
|
|
void draw_box(image a, int x1, int y1, int x2, int y2, float r, float g, float b)
|
{
|
normalize_image(a);
|
int i;
|
if(x1 < 0) x1 = 0;
|
if(x1 >= a.w) x1 = a.w-1;
|
if(x2 < 0) x2 = 0;
|
if(x2 >= a.w) x2 = a.w-1;
|
|
if(y1 < 0) y1 = 0;
|
if(y1 >= a.h) y1 = a.h-1;
|
if(y2 < 0) y2 = 0;
|
if(y2 >= a.h) y2 = a.h-1;
|
|
for(i = x1; i < x2; ++i){
|
a.data[i + y1*a.w + 0*a.w*a.h] = b;
|
a.data[i + y2*a.w + 0*a.w*a.h] = b;
|
|
a.data[i + y1*a.w + 1*a.w*a.h] = g;
|
a.data[i + y2*a.w + 1*a.w*a.h] = g;
|
|
a.data[i + y1*a.w + 2*a.w*a.h] = r;
|
a.data[i + y2*a.w + 2*a.w*a.h] = r;
|
}
|
for(i = y1; i < y2; ++i){
|
a.data[x1 + i*a.w + 0*a.w*a.h] = b;
|
a.data[x2 + i*a.w + 0*a.w*a.h] = b;
|
|
a.data[x1 + i*a.w + 1*a.w*a.h] = g;
|
a.data[x2 + i*a.w + 1*a.w*a.h] = g;
|
|
a.data[x1 + i*a.w + 2*a.w*a.h] = r;
|
a.data[x2 + i*a.w + 2*a.w*a.h] = r;
|
}
|
}
|
|
void flip_image(image a)
|
{
|
int i,j,k;
|
for(k = 0; k < a.c; ++k){
|
for(i = 0; i < a.h; ++i){
|
for(j = 0; j < a.w/2; ++j){
|
int index = j + a.w*(i + a.h*(k));
|
int flip = (a.w - j - 1) + a.w*(i + a.h*(k));
|
float swap = a.data[flip];
|
a.data[flip] = a.data[index];
|
a.data[index] = swap;
|
}
|
}
|
}
|
}
|
|
image image_distance(image a, image b)
|
{
|
int i,j;
|
image dist = make_image(a.w, a.h, 1);
|
for(i = 0; i < a.c; ++i){
|
for(j = 0; j < a.h*a.w; ++j){
|
dist.data[j] += pow(a.data[i*a.h*a.w+j]-b.data[i*a.h*a.w+j],2);
|
}
|
}
|
for(j = 0; j < a.h*a.w; ++j){
|
dist.data[j] = sqrt(dist.data[j]);
|
}
|
return dist;
|
}
|
|
void embed_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);
|
set_pixel(dest, dx+x, dy+y, k, val);
|
}
|
}
|
}
|
}
|
|
image collapse_image_layers(image source, int border)
|
{
|
int h = source.h;
|
h = (h+border)*source.c - border;
|
image dest = make_image(source.w, h, 1);
|
int i;
|
for(i = 0; i < source.c; ++i){
|
image layer = get_image_layer(source, i);
|
int h_offset = i*(source.h+border);
|
embed_image(layer, dest, 0, h_offset);
|
free_image(layer);
|
}
|
return dest;
|
}
|
|
void normalize_image(image p)
|
{
|
float *min = calloc(p.c, sizeof(float));
|
float *max = calloc(p.c, sizeof(float));
|
int i,j;
|
for(i = 0; i < p.c; ++i) min[i] = max[i] = p.data[i*p.h*p.w];
|
|
for(j = 0; j < p.c; ++j){
|
for(i = 0; i < p.h*p.w; ++i){
|
float v = p.data[i+j*p.h*p.w];
|
if(v < min[j]) min[j] = v;
|
if(v > max[j]) max[j] = v;
|
}
|
}
|
for(i = 0; i < p.c; ++i){
|
if(max[i] - min[i] < .000000001){
|
min[i] = 0;
|
max[i] = 1;
|
}
|
}
|
for(j = 0; j < p.c; ++j){
|
for(i = 0; i < p.w*p.h; ++i){
|
p.data[i+j*p.h*p.w] = (p.data[i+j*p.h*p.w] - min[j])/(max[j]-min[j]);
|
}
|
}
|
free(min);
|
free(max);
|
}
|
|
image copy_image(image p)
|
{
|
image copy = p;
|
copy.data = calloc(p.h*p.w*p.c, sizeof(float));
|
memcpy(copy.data, p.data, p.h*p.w*p.c*sizeof(float));
|
return copy;
|
}
|
|
|
void show_image(image p, char *name)
|
{
|
int x,y,k;
|
image copy = copy_image(p);
|
normalize_image(copy);
|
|
char buff[256];
|
//sprintf(buff, "%s (%d)", name, windows);
|
sprintf(buff, "%s", name);
|
|
IplImage *disp = cvCreateImage(cvSize(p.w,p.h), IPL_DEPTH_8U, p.c);
|
int step = disp->widthStep;
|
cvNamedWindow(buff, CV_WINDOW_AUTOSIZE);
|
//cvMoveWindow(buff, 100*(windows%10) + 200*(windows/10), 100*(windows%10));
|
++windows;
|
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);
|
}
|
}
|
}
|
free_image(copy);
|
if(disp->height < 500 || disp->width < 500 || disp->height > 1000){
|
int w = 500;
|
int h = w*p.h/p.w;
|
if(h > 1000){
|
h = 1000;
|
w = h*p.w/p.h;
|
}
|
IplImage *buffer = disp;
|
disp = cvCreateImage(cvSize(w, h), buffer->depth, buffer->nChannels);
|
cvResize(buffer, disp, CV_INTER_NN);
|
cvReleaseImage(&buffer);
|
}
|
cvShowImage(buff, disp);
|
cvReleaseImage(&disp);
|
}
|
|
void save_image(image p, char *name)
|
{
|
int x,y,k;
|
image copy = copy_image(p);
|
normalize_image(copy);
|
|
char buff[256];
|
//sprintf(buff, "%s (%d)", name, windows);
|
sprintf(buff, "%s.png", 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);
|
}
|
}
|
}
|
free_image(copy);
|
cvSaveImage(buff, disp,0);
|
cvReleaseImage(&disp);
|
}
|
|
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);
|
}
|
|
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 float_to_image(int w, int h, int c, float *data)
|
{
|
image out = make_empty_image(w,h,c);
|
out.data = data;
|
return out;
|
}
|
|
void rotate_image(image m)
|
{
|
int i,j;
|
for(j = 0; j < m.c; ++j){
|
for(i = 0; i < m.h*m.w/2; ++i){
|
float swap = m.data[j*m.h*m.w + i];
|
m.data[j*m.h*m.w + i] = m.data[j*m.h*m.w + (m.h*m.w-1 - i)];
|
m.data[j*m.h*m.w + (m.h*m.w-1 - i)] = swap;
|
}
|
}
|
}
|
|
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 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];
|
}
|
}
|
}
|
return out;
|
}
|
|
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 = 128;
|
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;
|
}
|
|
float billinear_interpolate(image im, float x, float y, int c)
|
{
|
int ix = (int) x;
|
int iy = (int) y;
|
|
float dx = x - ix;
|
float dy = y - iy;
|
|
float val = (1-dy) * (1-dx) * get_pixel_extend(im, ix, iy, c) +
|
dy * (1-dx) * get_pixel_extend(im, ix, iy+1, c) +
|
(1-dy) * dx * get_pixel_extend(im, ix+1, iy, c) +
|
dy * dx * get_pixel_extend(im, ix+1, iy+1, c);
|
return val;
|
}
|
|
// #wikipedia
|
image resize_image(image im, int w, int h)
|
{
|
image resized = make_image(w, h, im.c);
|
int r, c, k;
|
float w_scale = (float)(im.w - 1) / (w - 1);
|
float h_scale = (float)(im.h - 1) / (h - 1);
|
for(k = 0; k < im.c; ++k){
|
for(r = 0; r < h; ++r){
|
for(c = 0; c < w; ++c){
|
float sx = c*w_scale;
|
float sy = r*h_scale;
|
float val = billinear_interpolate(im, sx, sy, k);
|
set_pixel(resized, c, r, k, val);
|
}
|
}
|
}
|
return resized;
|
}
|
|
void test_resize(char *filename)
|
{
|
image im = load_image(filename, 0,0);
|
image small = resize_image(im, 65, 63);
|
image big = resize_image(im, 513, 512);
|
image crop = crop_image(im, 50, 10, 100, 100);
|
image crop2 = crop_image(im, -30, -50, 291, 400);
|
show_image(im, "original");
|
show_image(small, "smaller");
|
show_image(big, "bigger");
|
show_image(crop, "crop");
|
show_image(crop2, "crop2");
|
cvWaitKey(0);
|
}
|
|
image load_image_color(char *filename, int w, int h)
|
{
|
IplImage* src = 0;
|
if( (src = cvLoadImage(filename, 1)) == 0 )
|
{
|
printf("Cannot load file image %s\n", filename);
|
exit(0);
|
}
|
image out = ipl_to_image(src);
|
if((h && w) && (h != out.h || w != out.w)){
|
image resized = resize_image(out, w, h);
|
free_image(out);
|
out = resized;
|
}
|
cvReleaseImage(&src);
|
return out;
|
}
|
|
image load_image(char *filename, int w, int h)
|
{
|
IplImage* src = 0;
|
if( (src = cvLoadImage(filename,-1)) == 0 )
|
{
|
printf("Cannot load file image %s\n", filename);
|
exit(0);
|
}
|
image out = ipl_to_image(src);
|
if((h && w) && (h != out.h || w != out.w)){
|
image resized = resize_image(out, w, h);
|
free_image(out);
|
out = resized;
|
}
|
cvReleaseImage(&src);
|
return out;
|
}
|
|
image get_image_layer(image m, int l)
|
{
|
image out = make_image(m.w, m.h, 1);
|
int i;
|
for(i = 0; i < m.h*m.w; ++i){
|
out.data[i] = m.data[i+l*m.h*m.w];
|
}
|
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 print_image(image m)
|
{
|
int i, j, k;
|
for(i =0 ; i < m.c; ++i){
|
for(j =0 ; j < m.h; ++j){
|
for(k = 0; k < m.w; ++k){
|
printf("%.2lf, ", m.data[i*m.h*m.w + j*m.w + k]);
|
if(k > 30) break;
|
}
|
printf("\n");
|
if(j > 30) break;
|
}
|
printf("\n");
|
}
|
printf("\n");
|
}
|
|
image collapse_images_vert(image *ims, int n)
|
{
|
int color = 1;
|
int border = 1;
|
int h,w,c;
|
w = ims[0].w;
|
h = (ims[0].h + border) * n - border;
|
c = ims[0].c;
|
if(c != 3 || !color){
|
w = (w+border)*c - border;
|
c = 1;
|
}
|
|
image filters = make_image(w, h, c);
|
int i,j;
|
for(i = 0; i < n; ++i){
|
int h_offset = i*(ims[0].h+border);
|
image copy = copy_image(ims[i]);
|
//normalize_image(copy);
|
if(c == 3 && color){
|
embed_image(copy, filters, 0, h_offset);
|
}
|
else{
|
for(j = 0; j < copy.c; ++j){
|
int w_offset = j*(ims[0].w+border);
|
image layer = get_image_layer(copy, j);
|
embed_image(layer, filters, w_offset, h_offset);
|
free_image(layer);
|
}
|
}
|
free_image(copy);
|
}
|
return filters;
|
}
|
|
image collapse_images_horz(image *ims, int n)
|
{
|
int color = 1;
|
int border = 1;
|
int h,w,c;
|
int size = ims[0].h;
|
h = size;
|
w = (ims[0].w + border) * n - border;
|
c = ims[0].c;
|
if(c != 3 || !color){
|
h = (h+border)*c - border;
|
c = 1;
|
}
|
|
image filters = make_image(w, h, c);
|
int i,j;
|
for(i = 0; i < n; ++i){
|
int w_offset = i*(size+border);
|
image copy = copy_image(ims[i]);
|
//normalize_image(copy);
|
if(c == 3 && color){
|
embed_image(copy, filters, w_offset, 0);
|
}
|
else{
|
for(j = 0; j < copy.c; ++j){
|
int h_offset = j*(size+border);
|
image layer = get_image_layer(copy, j);
|
embed_image(layer, filters, w_offset, h_offset);
|
free_image(layer);
|
}
|
}
|
free_image(copy);
|
}
|
return filters;
|
}
|
|
void show_images(image *ims, int n, char *window)
|
{
|
image m = collapse_images_vert(ims, n);
|
save_image(m, window);
|
show_image(m, window);
|
free_image(m);
|
}
|
|
void free_image(image m)
|
{
|
free(m.data);
|
}
|
