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; }