int main (int argc, char ** argv) {
s_rand (42);
image * from = init_to_value (make_image (HORZ, VERT), 0.0f);
image * to = init_to_value (make_image (HORZ, VERT), 0.0f);
TicTocTimer clock = tic();
for (size_t i = 0; i < PERF_REPS; ++i)
add (to, from, 42.0);
printf("Elapsed time %f seconds.\n",toc(&clock));
free_image (from);
free_image (to);
return 0;
}
static void
test_composite (const composite_info_t *info)
{
pixman_image_t *src = make_image (&info->src);
pixman_image_t *dest = make_image (&info->dest);
pixman_image_composite (PIXMAN_OP_SRC, src, NULL, dest,
info->src_x, info->src_y,
0, 0,
info->dest_x, info->dest_y,
info->width, info->height);
}
void test_resize(char *filename)
{
image im = load_image(filename, 0,0, 3);
float mag = mag_array(im.data, im.w*im.h*im.c);
printf("L2 Norm: %f\n", mag);
image gray = grayscale_image(im);
image sat2 = copy_image(im);
saturate_image(sat2, 2);
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(gray, "Gray");
show_image(sat2, "Saturation-2");
show_image(sat5, "Saturation-.5");
show_image(exp2, "Exposure-2");
show_image(exp5, "Exposure-.5");
#ifdef OPENCV
cvWaitKey(0);
#endif
}
void onDraw(SkCanvas* canvas) override {
GrContext* context = canvas->getGrContext();
sk_sp<SkImage> bottomLImg = make_image(context, kImgSize, kBottomLeft_GrSurfaceOrigin);
sk_sp<SkImage> topLImg = make_image(context, kImgSize, kTopLeft_GrSurfaceOrigin);
if (!bottomLImg || !topLImg) {
return;
}
int bigOffset = 2 * kPad + kImgSize;
this->draw(canvas, bottomLImg, SkIPoint::Make(kPad, kPad), 1);
this->draw(canvas, topLImg, SkIPoint::Make(bigOffset, kPad), 1);
this->draw(canvas, bottomLImg, SkIPoint::Make(kPad, bigOffset), 7);
this->draw(canvas, topLImg, SkIPoint::Make(bigOffset, bigOffset), 7);
}
void onDraw(SkCanvas* canvas) override {
sk_sp<SkImage> image0(make_image(canvas));
const ImageFilterFactory factories[] = {
IFCCast([]{ return SkBlurImageFilter::Make(8, 8, nullptr); }),
IFCCast([]{ return SkDilateImageFilter::Make(8, 8, nullptr); }),
IFCCast([]{ return SkErodeImageFilter::Make(8, 8, nullptr); }),
IFCCast([]{ return SkOffsetImageFilter::Make(8, 8, nullptr); }),
};
const SkMatrix matrices[] = {
SkMatrix::MakeScale(SK_ScalarHalf, SK_ScalarHalf),
SkMatrix::MakeScale(2, 2),
SkMatrix::MakeTrans(10, 10)
};
const SkScalar spacer = image0->width() * 3.0f / 2;
canvas->translate(40, 40);
for (auto&& factory : factories) {
sk_sp<SkImageFilter> filter(factory());
canvas->save();
show_image(canvas, image0.get(), filter);
for (const auto& matrix : matrices) {
sk_sp<SkImageFilter> localFilter(filter->makeWithLocalMatrix(matrix));
canvas->translate(spacer, 0);
show_image(canvas, image0.get(), std::move(localFilter));
}
canvas->restore();
canvas->translate(0, spacer);
}
}
void onDraw(SkCanvas* canvas) override {
if (NULL == fBitmap.pixelRef()) {
fImage.reset(make_image(canvas, &fCenter));
image_to_bitmap(fImage, &fBitmap);
}
// amount of bm that should not be stretched (unless we have to)
const SkScalar fixed = SkIntToScalar(fBitmap.width() - fCenter.width());
const SkTSize<SkScalar> size[] = {
{ fixed * 4 / 5, fixed * 4 / 5 }, // shrink in both axes
{ fixed * 4 / 5, fixed * 4 }, // shrink in X
{ fixed * 4, fixed * 4 / 5 }, // shrink in Y
{ fixed * 4, fixed * 4 }
};
canvas->drawBitmap(fBitmap, 10, 10, NULL);
SkScalar x = SkIntToScalar(100);
SkScalar y = SkIntToScalar(100);
SkPaint paint;
paint.setFilterQuality(kLow_SkFilterQuality);
for (int iy = 0; iy < 2; ++iy) {
for (int ix = 0; ix < 2; ++ix) {
int i = ix * 2 + iy;
SkRect r = SkRect::MakeXYWH(x + ix * fixed, y + iy * fixed,
size[i].width(), size[i].height());
canvas->drawBitmapNine(fBitmap, fCenter, r, &paint);
canvas->drawImageNine(fImage, fCenter, r.makeOffset(360, 0), &paint);
}
}
}
void BugzillaLink::on_attribute_read(const std::string & attributeName)
{
gnote::DynamicNoteTag::on_attribute_read(attributeName);
if (attributeName == URI_ATTRIBUTE_NAME) {
make_image();
}
}
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;
}
GtkWidget *tool_button(GtkWidget *bar, GdkDrawable *drawable,
char **xpm, const char *tooltip,
gboolean (*cb)(GtkWidget *widget, GdkEventButton *event, gpointer data),
gpointer data)
{
GtkWidget *image, *evbox;
GtkToolItem *item;
/*
* gtk_radio_tool_button_new_from_widget is *huge*. We try to do things
* in a
* more compact way.
*/
evbox = gtk_event_box_new();
if (xpm) {
image = make_image(drawable, xpm, tooltip);
gtk_container_add(GTK_CONTAINER(evbox), image);
}
g_signal_connect(G_OBJECT(evbox), "button_press_event",
G_CALLBACK(cb), data);
item = gtk_tool_item_new();
gtk_container_add(GTK_CONTAINER(item), evbox);
gtk_container_set_border_width(GTK_CONTAINER(item), 0);
gtk_toolbar_insert(GTK_TOOLBAR(bar), item, -1);
return evbox;
}
EncodeView() {
fBitmapCount = SK_ARRAY_COUNT(gColorTypes);
fBitmaps = new SkBitmap[fBitmapCount];
fEncodedPNGs = new SkAutoDataUnref[fBitmapCount];
fEncodedJPEGs = new SkAutoDataUnref[fBitmapCount];
for (int i = 0; i < fBitmapCount; i++) {
make_image(&fBitmaps[i], gColorTypes[i], i);
for (size_t j = 0; j < SK_ARRAY_COUNT(gTypes); j++) {
SkAutoTDelete<SkImageEncoder> codec(
SkImageEncoder::Create(gTypes[j]));
if (NULL == codec.get()) {
SkDebugf("[%s:%d] failed to encode %s%s\n",
__FILE__, __LINE__,gConfigLabels[i], gExt[j]);
continue;
}
SkAutoDataUnref data(codec->encodeData(fBitmaps[i], 100));
if (NULL == data.get()) {
SkDebugf("[%s:%d] failed to encode %s%s\n",
__FILE__, __LINE__,gConfigLabels[i], gExt[j]);
continue;
}
if (SkImageEncoder::kJPEG_Type == gTypes[j]) {
fEncodedJPEGs[i].reset(data.detach());
} else if (SkImageEncoder::kPNG_Type == gTypes[j]) {
fEncodedPNGs[i].reset(data.detach());
}
}
}
this->setBGColor(0xFFDDDDDD);
}
void bg_image_input(Fl_Input *w, void *d)
{
changed=true;
Fl_String val(w->value());
filename = fl_file_expand(val);
if(mini_wpaper) { delete mini_wpaper; mini_wpaper=0; }
if(mini_image) { delete mini_image; mini_image=0; }
Fl_Image *im = Fl_Image::read(filename);
if(im) {
im->system_convert();
float scalew = (float)mini_image_box->w()/(float)desktop->w();
float scaleh = (float)mini_image_box->h()/(float)desktop->h();
mini_image = im->scale(int(im->width()*scalew), int(im->height()*scaleh));
delete im;
}
if(mini_image) {
mini_wpaper = make_image(color, mini_image,
mini_image_box->w(), mini_image_box->h(),
mode, opacity);
mini_image_box->image(mini_wpaper);
} else {
mini_image_box->image(0);
}
image_input->value(filename);
image_input->redraw();
mini_image_box->redraw();
}
image_t *grid_to_image(grid_t *grid) {
if (grid == NULL)
return NULL;
double max;
int i, j;
int w = grid->pw;
int h = grid->ph;
image_t *img = make_image(grid->width, grid->height, 3 * w);
ERR_NOMEM(img);
/* convert double values to char */
grid_max(grid, &max);
int interval = get_color_interval((float) max);
float interval_inv = get_color_interval_inv((float) max);
for (j = 0; j < h; j++) {
png_byte *row = img->rows[j];
for (i = 0; i < w; i++) {
int index = IX2(i,j,w);
int offset = i * 3;
struct rgb c;
value_color(&c, grid->dbl[index], interval, interval_inv);
row[offset + 0] = c.r;
row[offset + 1] = c.g;
row[offset + 2] = c.b;
}
}
error:
return img;
}
void Desktop::update_bg()
{
Fl_Renderer::system_init();
if (wpaper) {
delete wpaper;
wpaper=0;
}
Fl_Config globalConfig(fl_find_config_file("ede.conf", 0), true, false);
globalConfig.set_section("Desktop");
globalConfig.read("Color", bg_color, (Fl_Color)fl_darker(FL_BLUE));
globalConfig.read("Opacity", bg_opacity, 255);
globalConfig.read("Mode", bg_mode, 0);
globalConfig.read("Use", bg_use, 1);
Fl_Image *im=0;
if(!globalConfig.read("Wallpaper", bg_filename, 0)) {
if(bg_use) {
im = Fl_Image::read(bg_filename, 0);
if (im) im->system_convert();
}
} else {
bg_filename.clear();
}
if(im) {
wpaper = make_image(bg_color, im, Fl::w(), Fl::h(), bg_mode, bg_opacity);
delete im;
}
redraw();
}
void mkimg(char *cfgfile, char *weightfile, int h, int w, int num, char *prefix)
{
network *net = load_network(cfgfile, weightfile, 0);
image *ims = get_weights(net->layers[0]);
int n = net->layers[0].n;
int z;
for(z = 0; z < num; ++z){
image im = make_image(h, w, 3);
fill_image(im, .5);
int i;
for(i = 0; i < 100; ++i){
image r = copy_image(ims[rand()%n]);
rotate_image_cw(r, rand()%4);
random_distort_image(r, 1, 1.5, 1.5);
int dx = rand()%(w-r.w);
int dy = rand()%(h-r.h);
ghost_image(r, im, dx, dy);
free_image(r);
}
char buff[256];
sprintf(buff, "%s/gen_%d", prefix, z);
save_image(im, buff);
free_image(im);
}
free_network(net);
}
/* Initialises texturing, lighting, display lists, and everything else
associated with the model. */
void
myinit(void)
{
GLfloat mat_specular[] = {1.0, 1.0, 1.0, 1.0};
GLfloat mat_shininess[] = {50.0};
GLfloat light_position1[] = {1.0, 1.0, 1.0, 0.0};
GLfloat light_position2[] = {-1.0, 1.0, 1.0, 0.0};
glClearColor(0.0, 0.0, 0.0, 0.0);
obj = gluNewQuadric();
make_table();
make_image();
/* Set up Texturing */
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glTexImage2D(GL_TEXTURE_2D, 0, 3, IMAGE_WIDTH,
IMAGE_HEIGHT, 0, GL_RGB, GL_UNSIGNED_BYTE,
image);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
/* Set up Lighting */
glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
glLightfv(GL_LIGHT0, GL_POSITION, light_position1);
glLightfv(GL_LIGHT1, GL_POSITION, light_position2);
/* Initial render mode is with full shading and LIGHT 0
enabled. */
glEnable(GL_LIGHTING);
glEnable(GL_LIGHT0);
glDepthFunc(GL_LEQUAL);
glEnable(GL_DEPTH_TEST);
glDisable(GL_ALPHA_TEST);
glColorMaterial(GL_FRONT_AND_BACK, GL_DIFFUSE);
glEnable(GL_COLOR_MATERIAL);
glShadeModel(GL_SMOOTH);
/* Initialise display lists */
glNewList(list_piston_shaded, GL_COMPILE);
draw_piston();
glEndList();
glNewList(list_flywheel_shaded, GL_COMPILE);
draw_flywheel();
glEndList();
gluQuadricTexture(obj, GL_TRUE);
glNewList(list_piston_texture, GL_COMPILE);
draw_piston();
glEndList();
glNewList(list_flywheel_texture, GL_COMPILE);
draw_flywheel();
glEndList();
gluQuadricTexture(obj, GL_FALSE);
}
static pixman_image_t *
create_image (pixman_format_code_t format, pixman_format_code_t alpha_format,
int alpha_origin_x, int alpha_origin_y)
{
pixman_image_t *image = make_image (format);
if (alpha_format != PIXMAN_null)
{
pixman_image_t *alpha = make_image (alpha_format);
pixman_image_set_alpha_map (image, alpha,
alpha_origin_x, alpha_origin_y);
pixman_image_unref (alpha);
}
return image;
}
void inter_dcgan(char *cfgfile, char *weightfile)
{
network *net = load_network(cfgfile, weightfile, 0);
set_batch_network(net, 1);
srand(2222222);
clock_t time;
char buff[256];
char *input = buff;
int i, imlayer = 0;
for (i = 0; i < net->n; ++i) {
if (net->layers[i].out_c == 3) {
imlayer = i;
printf("%d\n", i);
break;
}
}
image start = random_unit_vector_image(net->w, net->h, net->c);
image end = random_unit_vector_image(net->w, net->h, net->c);
image im = make_image(net->w, net->h, net->c);
image orig = copy_image(start);
int c = 0;
int count = 0;
int max_count = 15;
while(1){
++c;
if(count == max_count){
count = 0;
free_image(start);
start = end;
end = random_unit_vector_image(net->w, net->h, net->c);
if(c > 300){
end = orig;
}
if(c>300 + max_count) return;
}
++count;
slerp(start.data, end.data, (float)count / max_count, im.w*im.h*im.c, im.data);
float *X = im.data;
time=clock();
network_predict(net, X);
image out = get_network_image_layer(net, imlayer);
//yuv_to_rgb(out);
normalize_image(out);
printf("%s: Predicted in %f seconds.\n", input, sec(clock()-time));
//char buff[256];
sprintf(buff, "out%05d", c);
save_image(out, "out");
save_image(out, buff);
show_image(out, "out", 0);
}
}
image_t* trim_staff(image_t *img){
/* simple function to trim excess
space from left and right edges of staff
adds two pixels of padding to each side
Var Declaration*/
uint16_t height,width;
projection_t* proj_onto_x;
projection_t* proj_onto_y;
uint16_t last_l,last_r,last_t,last_b;
uint16_t trsh;
uint16_t i,j;
image_t* new_img;
/*End Var Declaration*/
height=img->height;
width=img->width;
proj_onto_x = project(img, 1);
last_l = 0;
last_r = width-1;
trsh = height/50;/*was float*/
for (i=1;i<(width+1)/3;i++){/*maybe (width+1)/3-1*/
if (proj_onto_x->data[i] < trsh)
last_l = i;
if (proj_onto_x->data[width-i] < trsh)
last_r = width-i;
}
delete_flex_array(proj_onto_x);
proj_onto_y = project(img, 2);
last_t = 0;
last_b = height-1;
trsh = width /200;/*was float*/
for (i=1;i<(height+1)/3;i++){
if (proj_onto_y->data[i] < trsh)
last_t = i;
if (proj_onto_y->data[height-i] < trsh)
last_b = height-i;
}
/*crop:*/
new_img=make_image(last_b+5-last_t,last_r+5-last_l);
for (i=0;i<last_b+5-last_t;i++){
for (j=0;j<last_r+5-last_l;j++){
if (i<2 ||j<2 ||(i>last_b+1-last_t) ||(j>last_r+1-last_l)){
setPixel(new_img,i,j,0);
}
else {
setPixel(new_img,i,j,getPixel(img,last_t+i-2,last_l+j-2));
}
}
}
delete_image(img);
return(new_img);
}
image threshold_image(image im, float thresh)
{
int i;
image t = make_image(im.w, im.h, im.c);
for(i = 0; i < im.w*im.h*im.c; ++i){
t.data[i] = im.data[i]>thresh ? 1 : 0;
}
return t;
}
void desktop_properties(Fl_Widget *, void *arg)
{
if(!shown) {
make_desktop_properties();
shown = true;
}
mode = desktop->bg_mode;
color = desktop->bg_color;
opacity = desktop->bg_opacity;
use = desktop->bg_use;
filename = desktop->bg_filename;
if(bg_prop_window->visible()) {
bg_prop_window->show();
return;
}
if(mini_image) { delete mini_image; mini_image=0; }
if(mini_wpaper){ delete mini_wpaper; mini_wpaper=0;}
color_button->selection_color(color);
mini_image_box->color(color);
opacity_slider->value(opacity);
mode_choice->value(mode);
use_button->value(use);
image_input->value(filename);
if(!desktop->bg_filename.empty())
{
Fl_Image *im = Fl_Image::read(desktop->bg_filename);
if(im) {
im->system_convert();
float scalew = (float)mini_image_box->w()/(float)desktop->w();
float scaleh = (float)mini_image_box->h()/(float)desktop->h();
mini_image = im->scale(int(im->width()*scalew), int(im->height()*scaleh));
delete im;
}
}
if(mini_image) {
mini_wpaper = make_image(color, mini_image,
mini_image_box->w(), mini_image_box->h(),
mode, opacity);
mini_image_box->image(mini_wpaper);
} else
mini_image_box->image(0);
if(use)
bg_image_group->activate();
else {
bg_image_group->deactivate();
mini_image_box->image(0);
}
bg_prop_window->show();
}
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;
}
int main(int argc, char* argv[])
{
if (argc == 1)
{
printf("Default input/output files are used!\n");
return make_image(DEFAULT_IN_FILE, DEFAULT_OUT_FILE);
}
else if (argc == 3)
{
return make_image(argv[1], argv[2]);
}
else
{
printf("Error: Unsupported input parameter!\n");
printf("usage: %s [<input_file>] [<output_file>]\n", argv[0]);
return 1;
}
}
void compute_sift_keypoints(float *input, keypointslist& keys, int width, int height, siftPar &par)
{
flimage image;
/// Make zoom of image if necessary
float octSize = 1.0f;
if (par.DoubleImSize){
//printf("... compute_sift_keypoints :: applying zoom\n");
image = alloc_image<float>(2*width, 2*height);
apply_zoom(input,image.data,2.0,par.order,width,height);
octSize *= 0.5f;
} else
image = alloc_image( make_image(input,width,height) );
/// Apply initial smoothing to input image to raise its smoothing to par.InitSigma.
/// We assume image from camera has smoothing of sigma = 0.5, which becomes sigma = 1.0 if image has been doubled.
/// increase = sqrt(Init^2 - Current^2)
float curSigma=0.5f;
if (par.DoubleImSize) curSigma *= 2.0f;
if (par.InitSigma > curSigma ) {
if (DEBUG) printf("Convolving initial image to achieve std: %f \n", par.InitSigma);
float sigma = (float)sqrt(par.InitSigma*par.InitSigma -
curSigma*curSigma);
gaussian_convolution(image.data, image.data, image.w, image.h, sigma);
}
/// Convolve by par.InitSigma at each step inside OctaveKeypoints by steps of
/// Subsample of factor 2 while reasonable image size
/// Keep reducing image by factors of 2 until one dimension is
/// smaller than minimum size at which a feature could be detected.
int minsize = 2 * par.BorderDist + 2;
//printf("... compute_sift_keypoints :: maximum number of scales : %d\n", par.OctaveMax);
for(int i=(par.DoubleImSize?-1:0);
i<=par.OctaveMax && image.w>minsize && image.h>minsize;
i++) {
if(DEBUG) printf("Calling OctaveKeypoints \n");
OctaveKeypoints(image, octSize, keys,par);
// image is blurred inside OctaveKeypoints and therefore can be sampled
flimage aux = alloc_image<float>(image.w/2, image.h/2);
if(DEBUG) printf("Sampling initial image \n");
sample(image.data, aux.data, 2.0f, image.w, image.h);
free(image.data);
image = aux;
octSize *= 2.0f;
}
free(image.data);
/* printf("sift:: %d keypoints\n", keys.size());
printf("sift:: plus non correctly localized: %d \n", par.noncorrectlylocalized);*/
}
/**
* Serves a PNG file of the hash.
*/
void route_image(evhtp_request_t *req, void *arg) {
// redisReply *reply;
evhtp_uri_t *uri = req->uri;
int side = 128;
char *hash = "";
char *res = uri->path->full;
int ind = 0;
res = strtok((char *) res, "/");
while (res != NULL) {
if (ind == 0) {
if (strlen(res) == 32) {
hash = res;
} else if (strcmp(res, "avatar") == 0) {
ind--;
} else {
route_400(req);
return;
}
}
if (ind == 1) {
side = atoi(res);
if (side == 0) {
side = defsize;
} else if (side < minsize) {
side = minsize;
} else if (side > maxsize) {
side = maxsize;
}
}
res = strtok(NULL, "/");
ind++;
}
char *etag = malloc(sizeof(char) * 1024);
sprintf(etag, "\"%s-%d\"", hash, side);
evhtp_kv_t *etagin = evhtp_headers_find_header(req->headers_in, "If-None-Match");
if(etagin && strcmp(etag, etagin->val) == 0) {
free(etag);
evhtp_send_reply(req, 304);
return;
}
make_image(hash, req->buffer_out, side);
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Content-Type", "image/png", 0, 0));
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("Cache-Control", "public", 0, 0));
evhtp_headers_add_header(req->headers_out,
evhtp_header_new("ETag", etag, 0, 1));
free(etag);
evhtp_send_reply(req, 200);
}
image resize_image(image im, int w, int h)
{
image resized = make_image(w, h, im.c);
image part = make_image(w, im.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 < im.h; ++r){
for(c = 0; c < w; ++c){
float val = 0;
if(c == w-1 || im.w == 1){
val = get_pixel(im, im.w-1, r, k);
} else {
float sx = c*w_scale;
int ix = (int) sx;
float dx = sx - ix;
val = (1 - dx) * get_pixel(im, ix, r, k) + dx * get_pixel(im, ix+1, r, k);
}
set_pixel(part, c, r, k, val);
}
}
}
for(k = 0; k < im.c; ++k){
for(r = 0; r < h; ++r){
float sy = r*h_scale;
int iy = (int) sy;
float dy = sy - iy;
for(c = 0; c < w; ++c){
float val = (1-dy) * get_pixel(part, c, iy, k);
set_pixel(resized, c, r, k, val);
}
if(r == h-1 || im.h == 1) continue;
for(c = 0; c < w; ++c){
float val = dy * get_pixel(part, c, iy+1, k);
add_pixel(resized, c, r, k, val);
}
}
}
free_image(part);
return resized;
}
image random_unit_vector_image(int w, int h, int c)
{
image im = make_image(w, h, c);
int i;
for(i = 0; i < im.w*im.h*im.c; ++i){
im.data[i] = rand_normal();
}
float mag = mag_array(im.data, im.w*im.h*im.c);
scale_array(im.data, im.w*im.h*im.c, 1./mag);
return im;
}
static void
do_texture_setup(void)
{
GLuint tex;
GLenum target = target_for_sampler[sampler];
pixels = malloc(components * sizeof(unsigned char) * texture_width * texture_height);
expected = malloc(4 * sizeof(float) * texture_width * texture_height);
glGenTextures(1, &tex);
glBindTexture(target, tex);
make_image(components, channel_to_fill());
make_expected();
switch(sampler) {
case SAMPLER_2D:
case SAMPLER_2DRECT:
upload_2d(target, pixels);
break;
case SAMPLER_2DARRAY:
upload_3d(target, NULL);
upload_array_slice(target, 1, pixels);
break;
case SAMPLER_CUBE:
/* legacy cubes are weird. the only sane way to specify the whole
* thing at once is using glTexStorage, and we'd rather not rely on
* ARB_texture_storage just for that. */
upload_2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_X, NULL);
upload_2d(GL_TEXTURE_CUBE_MAP_POSITIVE_X, NULL);
upload_2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, NULL);
upload_2d(GL_TEXTURE_CUBE_MAP_POSITIVE_Y, NULL);
upload_2d(GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, NULL);
upload_2d(GL_TEXTURE_CUBE_MAP_POSITIVE_Z, pixels);
break;
case SAMPLER_CUBEARRAY:
upload_3d(target, NULL);
upload_array_slice(target, 10, pixels);
break;
}
glTexParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
if (comptype == SHADOW_T) {
glTexParameteri(target_for_sampler[sampler], GL_TEXTURE_COMPARE_MODE,
GL_COMPARE_R_TO_TEXTURE);
glTexParameteri(target_for_sampler[sampler], GL_TEXTURE_COMPARE_FUNC,
GL_LESS);
}
glTexParameteri(target_for_sampler[sampler], GL_TEXTURE_WRAP_S, address_mode);
glTexParameteri(target_for_sampler[sampler], GL_TEXTURE_WRAP_T, address_mode);
glTexParameteri(target_for_sampler[sampler], GL_TEXTURE_WRAP_R, address_mode);
}
// Test that SkImage encoding observes custom pixel serializers.
DEF_TEST(Image_Encode_Serializer, reporter) {
MockSerializer serializer([]() -> SkData* { return SkData::NewWithCString(kSerializedData); });
const SkIRect ir = SkIRect::MakeXYWH(5, 5, 10, 10);
SkAutoTUnref<SkImage> image(make_image(nullptr, 20, 20, ir));
SkAutoTUnref<SkData> encoded(image->encode(&serializer));
SkAutoTUnref<SkData> reference(SkData::NewWithCString(kSerializedData));
REPORTER_ASSERT(reporter, serializer.didEncode());
REPORTER_ASSERT(reporter, encoded);
REPORTER_ASSERT(reporter, encoded->size() > 0);
REPORTER_ASSERT(reporter, encoded->equals(reference));
}
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;
}
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;
}
