int main (int argc, char **argv) { RsvgDimensionData dimensions; RsvgHandle *logo_handle; cairo_surface_t *surface; GError *error = NULL; cairo_t *cr; cairo_status_t status; char *input, *size, *output; GString *layer; char *layer_name; int h, w; g_type_init (); input = argv[1]; size = argv[2]; layer = g_string_new (argv[3]); g_string_ascii_down (layer); g_string_prepend_c (layer, '#'); output = argv[4]; if (sscanf (size, "%dx%d", &w, &h) != 2) { g_warning ("Couldn't parse size '%s'", size); return 1; } logo_handle = rsvg_handle_new_from_file (input, &error); if (!logo_handle) { g_warning ("Couldn't open '%s': %s", input, error->message); g_error_free (error); return 1; } surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h); cr = cairo_create (surface); rsvg_handle_get_dimensions (logo_handle, &dimensions); cairo_scale (cr, (double) w / dimensions.width, (double) h / dimensions.height); layer_name = g_string_free (layer, FALSE); rsvg_handle_render_cairo_sub (logo_handle, cr, "#background"); // rsvg_handle_render_cairo_sub (logo_handle, cr, "#base"); rsvg_handle_render_cairo_sub (logo_handle, cr, layer_name); status = cairo_surface_write_to_png (surface, output); if (status != CAIRO_STATUS_SUCCESS) { g_warning ("Couldn't write output '%s': %s", output, cairo_status_to_string (status)); return 1; } g_free (layer_name); cairo_destroy (cr); return 0; }
BitmapPtr SVG::internalRenderElement(const SVGElementPtr& pElement, const glm::vec2& renderSize, const glm::vec2& size) { glm::vec2 pos = pElement->getPos(); glm::vec2 scale(renderSize.x/size.x, renderSize.y/size.y); IntPoint boundingBox = IntPoint(renderSize) + IntPoint(int(scale.x+0.5), int(scale.y+0.5)); BitmapPtr pBmp(new Bitmap(boundingBox, B8G8R8A8)); FilterFill<Pixel32>(Pixel32(0,0,0,0)).applyInPlace(pBmp); cairo_surface_t* pSurface; cairo_t* pCairo; pSurface = cairo_image_surface_create_for_data(pBmp->getPixels(), CAIRO_FORMAT_ARGB32, boundingBox.x, boundingBox.y, pBmp->getStride()); pCairo = cairo_create(pSurface); cairo_scale(pCairo, scale.x, scale.y); cairo_translate(pCairo, -pos.x, -pos.y); rsvg_handle_render_cairo_sub(m_pRSVG, pCairo, pElement->getUnescapedID().c_str()); FilterUnmultiplyAlpha().applyInPlace(pBmp); cairo_surface_destroy(pSurface); cairo_destroy(pCairo); if (!BitmapLoader::get()->isBlueFirst()) { FilterFlipRGB().applyInPlace(pBmp); } return pBmp; }
static void process_rsvg(struct neg_loop_vars *loop, const char *fname) { int i, j; struct neg_rsvg *rsvg; rsvg = neg_rsvg_open(fname); // {{{ TODO shoudl go into neg_set_defaults() or some such if (!loop->conf->out.width) loop->conf->out.width = rsvg->size.width; if (!loop->conf->out.height) loop->conf->out.height = rsvg->size.height; // }}} printf("input %u x %u (%s)\n", rsvg->size.width, rsvg->size.height, fname); printf("output %u x %u (%s)\n", (unsigned)loop->conf->out.width, (unsigned)loop->conf->out.height, loop->conf->out.name); if (! loop->ctx) loop->ctx = loop->rndr->init(loop->conf); for (i = rsvg->layer_count-1; i>=0; i--) { struct neg_layer *lyr = &rsvg->layers[i]; cairo_t *c; if (lyr->flags & NEG_LAYER_HIDDEN) continue; c = loop->rndr->slide_start(loop->ctx); printf(" * %s : ", lyr->name); if (!c) errx(1, "Could not create cairo"); cairo_scale(c, loop->conf->out.width/rsvg->size.width, loop->conf->out.height/rsvg->size.height); for(j=0; j<lyr->order->count; j++) { unsigned order = lyr->order->array[j]; struct neg_layer *ord = &rsvg->layers[order]; char id[strlen(ord->id)+2]; printf("%s, ", ord->name); id[0] = '#'; strcpy(id+1, ord->id); rsvg_handle_render_cairo_sub(rsvg->handle, c, id); } printf("\n"); if (! loop->rndr->slide_end(loop->ctx)) errx(1, "error writing out %s slide", loop->rndr->name); } neg_rsvg_close(rsvg); }
/** * rsvg_handle_get_pixbuf_sub: * @handle: An #RsvgHandle * @id: The id of an element inside the SVG, or %NULL to render the whole SVG. For * example, if you have a layer called "layer1" that you wish to render, pass * "##layer1" as the id. * * Returns the pixbuf loaded by #handle. The pixbuf returned will be reffed, so * the caller of this function must assume that ref. If insufficient data has * been read to create the pixbuf, or an error occurred in loading, then %NULL * will be returned. Note that the pixbuf may not be complete until * @rsvg_handle_close has been called. * * Returns: the pixbuf loaded by #handle, or %NULL. * * Since: 2.14 **/ GdkPixbuf * rsvg_handle_get_pixbuf_sub (RsvgHandle * handle, const char *id) { RsvgDimensionData dimensions; GdkPixbuf *output = NULL; guint8 *pixels; cairo_surface_t *surface; cairo_t *cr; int rowstride; g_return_val_if_fail (handle != NULL, NULL); if (!handle->priv->finished) return NULL; rsvg_handle_get_dimensions (handle, &dimensions); if (!(dimensions.width && dimensions.height)) return NULL; rowstride = dimensions.width * 4; pixels = g_try_malloc0 (dimensions.width * dimensions.height * 4UL); if (!pixels) return NULL; surface = cairo_image_surface_create_for_data (pixels, CAIRO_FORMAT_ARGB32, dimensions.width, dimensions.height, rowstride); cr = cairo_create (surface); cairo_surface_destroy (surface); if (rsvg_handle_render_cairo_sub (handle, cr, id)) { rsvg_cairo_to_pixbuf (pixels, rowstride, dimensions.height); output = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8, dimensions.width, dimensions.height, rowstride, (GdkPixbufDestroyNotify) rsvg_pixmap_destroy, NULL); } else { g_free (pixels); output = NULL; } cairo_destroy (cr); return output; }
static void ar_card_theme_kde_paint_card (ArCardTheme *card_theme, cairo_t *cr, int card_id) { ArCardThemePreimage *preimage_card_theme = (ArCardThemePreimage *) card_theme; ArCardThemeKDE *theme = (ArCardThemeKDE *) card_theme; ArSvg *svg = preimage_card_theme->cards_svg; char node[32]; cairo_rectangle_t *card_extents; cairo_matrix_t matrix; cairo_font_options_t *font_options; if (G_UNLIKELY (card_id == AR_CARD_SLOT)) { ar_svg_render_cairo (preimage_card_theme->slot_preimage, cr, preimage_card_theme->card_size.width, preimage_card_theme->card_size.height); return; } if (theme->legacy) ar_card_get_legacy_node_by_id_snprintf (node, sizeof (node), card_id); else ar_card_get_node_by_id_snprintf (node, sizeof (node), card_id); card_extents = ar_card_theme_kde_get_card_extents (theme, card_id, node); if (!card_extents) return; cairo_save (cr); font_options = ar_svg_get_font_options (svg); if (font_options) { cairo_set_antialias (cr, cairo_font_options_get_antialias (font_options)); cairo_set_font_options (cr, font_options); } cairo_matrix_init_identity (&matrix); cairo_matrix_scale (&matrix, preimage_card_theme->card_size.width / card_extents->width, preimage_card_theme->card_size.height / card_extents->height); cairo_matrix_translate (&matrix, -card_extents->x, -card_extents->y); cairo_set_matrix (cr, &matrix); rsvg_handle_render_cairo_sub (RSVG_HANDLE (svg), cr, node); cairo_restore (cr); }
static VALUE rb_rsvg_handle_render_cairo(int argc, VALUE *argv, VALUE self) { VALUE cr, id; rb_scan_args(argc, argv, "11", &cr, &id); if (NIL_P(id)) { rsvg_handle_render_cairo( _SELF(self), RVAL2CRCONTEXT(cr)); } else { rsvg_handle_render_cairo_sub( _SELF(self), RVAL2CRCONTEXT(cr), (const char *)RVAL2CSTR(id)); } return Qnil; }
cv::Mat JobFileSvg::loadSlice(int layer){ cv::Mat ret; //clear cairo context m_cairoMutex.lock(); cairo_set_source_rgb (m_pCairo, 0, 0, 0); cairo_paint (m_pCairo); std::ostringstream id; id << "#layer" << layer;//filter with group name printf("(JobFile) Extract layer %s from svg\n",id.str().c_str() ); rsvg_handle_render_cairo_sub(m_pRsvgHandle, m_pCairo, id.str().c_str() ); ret = cv::Mat( cairo_image_surface_get_height(m_pSurface), cairo_image_surface_get_width(m_pSurface), CV_8UC4, (void*) cairo_image_surface_get_data(m_pSurface) ); m_cairoMutex.unlock(); //convert to grayscale image //ret.convertTo( ret, CV_8UC1 ); //convert to grayscale image with alpha channel //ret.convertTo( ret, CV_8UC2 ); /* Remove interpolation B9Creator beta software approach to * get black-white-image (see crushbitmap.cpp ) * if(c.red()<32 && c.blue()<32 && c.green()<32) return false; */ cv::threshold(ret, ret, 31, 255, cv::THRESH_BINARY); //use red values as mask (assume white/black image) #ifdef FLIP_COLORS int from_to[] = { 0,0, 1,1, 2,2, 2,3 }; #else int from_to[] = { 0,0, 1,1, 2,2, 0,3 }; #endif cv::mixChannels( &ret, 1, &ret, 1, from_to, 4 ); return ret; }
static cairo_rectangle_t * ar_card_theme_kde_get_card_extents (ArCardThemeKDE *theme, int card_id, const char *node) { ArSvg *svg; cairo_rectangle_t *card_extents; cairo_rectangle_t rect; cairo_surface_t *surface; cairo_t *cr; card_extents = &theme->card_extents[card_id]; /* Is it initalised yet? */ if (card_extents->width != 0. && card_extents->height != 0.) return card_extents; svg = ((ArCardThemePreimage *) theme)->cards_svg; surface = cairo_recording_surface_create (CAIRO_CONTENT_ALPHA, NULL); cr = cairo_create (surface); cairo_set_tolerance (cr, 1.); ar_profilestart ("getting ink extents for node %s", node); rsvg_handle_render_cairo_sub (RSVG_HANDLE (svg), cr, node); ar_profileend ("getting ink extents for node %s", node); cairo_destroy (cr); cairo_recording_surface_ink_extents (surface, &rect.x, &rect.y, &rect.width, &rect.height); cairo_surface_destroy (surface); ar_debug_print (AR_DEBUG_CARD_THEME, "card %s %.3f x%.3f at (%.3f | %.3f)\n", node, card_extents->width, card_extents->height, card_extents->x, card_extents->y); *card_extents = rect; /* Sanity check; necessary? */ if (rect.width == 0. || rect.height == 0.) return NULL; return card_extents; }
/** * rsvg_handle_get_pixbuf_sub: * @handle: An #RsvgHandle * @id: The id of an element inside the SVG, or %NULL to render the whole SVG. For * example, if you have a layer called "layer1" that you wish to render, pass * "##layer1" as the id. * * Returns the pixbuf loaded by #handle. The pixbuf returned will be reffed, so * the caller of this function must assume that ref. If insufficient data has * been read to create the pixbuf, or an error occurred in loading, then %NULL * will be returned. Note that the pixbuf may not be complete until * @rsvg_handle_close has been called. * * Returns: the pixbuf loaded by #handle, or %NULL. * * Since: 2.14 **/ GdkPixbuf * rsvg_handle_get_pixbuf_sub (RsvgHandle * handle, const char *id) { RsvgDimensionData dimensions; GdkPixbuf *output = NULL; cairo_surface_t *surface; cairo_t *cr; g_return_val_if_fail (handle != NULL, NULL); if (!handle->priv->finished) return NULL; rsvg_handle_get_dimensions (handle, &dimensions); if (!(dimensions.width && dimensions.height)) return NULL; surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32, dimensions.width, dimensions.height); if (cairo_surface_status (surface) != CAIRO_STATUS_SUCCESS) { cairo_surface_destroy (surface); return NULL; } cr = cairo_create (surface); if (!rsvg_handle_render_cairo_sub (handle, cr, id)) { cairo_destroy (cr); cairo_surface_destroy (surface); return NULL; } cairo_destroy (cr); output = rsvg_cairo_surface_to_pixbuf (surface); cairo_surface_destroy (surface); return output; }
/** * rsvg_handle_render_cairo: * @handle: A RsvgHandle * @cr: A Cairo renderer * * Draws a SVG to a Cairo surface * * Returns: %TRUE if drawing succeeded. * Since: 2.14 */ gboolean rsvg_handle_render_cairo (RsvgHandle * handle, cairo_t * cr) { return rsvg_handle_render_cairo_sub (handle, cr, NULL); }
/* * Draws global image with fill color onto a pixmap with the given * resolution and returns it. * */ xcb_pixmap_t draw_image(uint32_t *resolution) { xcb_pixmap_t bg_pixmap = XCB_NONE; RsvgDimensionData svg_dimensions; rsvg_handle_get_dimensions(svg, &svg_dimensions); int indicator_x_physical = ceil(scaling_factor() * svg_dimensions.width); int indicator_y_physical = ceil(scaling_factor() * svg_dimensions.height); if (!vistype) vistype = get_root_visual_type(screen); bg_pixmap = create_bg_pixmap(conn, screen, resolution, color); /* Initialize cairo: Create one in-memory surface to render the unlock * indicator on, create one XCB surface to actually draw (one or more, * depending on the amount of screens) unlock indicators on. */ cairo_surface_t *output = cairo_image_surface_create(CAIRO_FORMAT_ARGB32, indicator_x_physical, indicator_y_physical); cairo_t *ctx = cairo_create(output); cairo_surface_t *xcb_output = cairo_xcb_surface_create(conn, bg_pixmap, vistype, resolution[0], resolution[1]); cairo_t *xcb_ctx = cairo_create(xcb_output); if (img) { if (!tile) { cairo_set_source_surface(xcb_ctx, img, 0, 0); cairo_paint(xcb_ctx); } else { /* create a pattern and fill a rectangle as big as the screen */ cairo_pattern_t *pattern; pattern = cairo_pattern_create_for_surface(img); cairo_set_source(xcb_ctx, pattern); cairo_pattern_set_extend(pattern, CAIRO_EXTEND_REPEAT); cairo_rectangle(xcb_ctx, 0, 0, resolution[0], resolution[1]); cairo_fill(xcb_ctx); cairo_pattern_destroy(pattern); } } else { char strgroups[3][3] = {{color[0], color[1], '\0'}, {color[2], color[3], '\0'}, {color[4], color[5], '\0'}}; uint32_t rgb16[3] = {(strtol(strgroups[0], NULL, 16)), (strtol(strgroups[1], NULL, 16)), (strtol(strgroups[2], NULL, 16))}; cairo_set_source_rgb(xcb_ctx, rgb16[0] / 255.0, rgb16[1] / 255.0, rgb16[2] / 255.0); cairo_rectangle(xcb_ctx, 0, 0, resolution[0], resolution[1]); cairo_fill(xcb_ctx); } if (unlock_state >= STATE_KEY_PRESSED && unlock_indicator) { cairo_scale(ctx, scaling_factor(), scaling_factor()); rsvg_handle_render_cairo_sub(svg, ctx, "#bg"); /* Use the appropriate color for the different PAM states * (currently verifying, wrong password, or default) */ if (!(unlock_state == STATE_KEY_ACTIVE || unlock_state == STATE_BACKSPACE_ACTIVE) || !remove_background) { switch (pam_state) { case STATE_PAM_VERIFY: rsvg_handle_render_cairo_sub(svg, ctx, "#verify"); break; case STATE_PAM_WRONG: rsvg_handle_render_cairo_sub(svg, ctx, "#fail"); break; default: rsvg_handle_render_cairo_sub(svg, ctx, "#idle"); break; } } /* After the user pressed any valid key or the backspace key, we * highlight a random part of the unlock indicator to confirm this * keypress. */ if (unlock_state == STATE_KEY_ACTIVE || unlock_state == STATE_BACKSPACE_ACTIVE) { if(++current_frame >= anim_layer_count) current_frame = 0; if (unlock_state == STATE_KEY_ACTIVE) { if(!sequential_animation) current_frame = rand() % anim_layer_count; char anim_id[9]; snprintf(anim_id, sizeof(anim_id), "#anim%02d", current_frame); rsvg_handle_render_cairo_sub(svg, ctx, anim_id); } else { rsvg_handle_render_cairo_sub(svg, ctx, "#backspace"); } } rsvg_handle_render_cairo_sub(svg, ctx, "#fg"); } if (xr_screens > 0) { /* Composite the unlock indicator in the middle of each screen. */ for (int screen = 0; screen < xr_screens; screen++) { int x = (xr_resolutions[screen].x + ((xr_resolutions[screen].width / 2) - (indicator_x_physical / 2))); int y = (xr_resolutions[screen].y + ((xr_resolutions[screen].height / 2) - (indicator_y_physical / 2))); cairo_set_source_surface(xcb_ctx, output, x, y); cairo_rectangle(xcb_ctx, x, y, indicator_x_physical, indicator_y_physical); cairo_fill(xcb_ctx); } } else { /* We have no information about the screen sizes/positions, so we just * place the unlock indicator in the middle of the X root window and * hope for the best. */ int x = (last_resolution[0] / 2) - (indicator_x_physical / 2); int y = (last_resolution[1] / 2) - (indicator_y_physical / 2); cairo_set_source_surface(xcb_ctx, output, x, y); cairo_rectangle(xcb_ctx, x, y, indicator_x_physical, indicator_y_physical); cairo_fill(xcb_ctx); } cairo_surface_destroy(xcb_output); cairo_surface_destroy(output); cairo_destroy(ctx); cairo_destroy(xcb_ctx); return bg_pixmap; }