static void update_bg()
{
if (currootpmap != *rootpmap && *rootpmap != 0) {
currootpmap = *rootpmap;
imlib_context_set_drawable(currootpmap);
if (bg) {
imlib_context_set_image(bg);
imlib_free_image();
}
bg = imlib_create_image_from_drawable(0, bbx, bby, bbwidth, bbheight, 1);
Pixmap tile, mask;
imlib_context_set_display(bbdpy);
imlib_context_set_visual(bbvis);
imlib_context_set_drawable(bbwin);
imlib_context_set_image(bg);
Imlib_Image tmpbg = imlib_clone_image();
tile_image_blend(tmpbg, theme->tile_img, 0, bbwidth);
imlib_render_pixmaps_for_whole_image(&tile, &mask);
XSetWindowBackgroundPixmap(bbdpy, bbwin, tile);
imlib_free_pixmap_and_mask(tile);
imlib_free_image();
}
}
/* draw a white (background) border around image, overwriting image contents
* beneath border*/
Imlib_Image white_border(Imlib_Image *source_image, int bdwidth)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* coordinates of upper left corner of rectangles */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* assure border width has a legal value */
if(bdwidth > width/2) bdwidth = width/2;
if(bdwidth > height/2) bdwidth = height/2;
/* draw white (background) rectangle around new image */
for(x=0, y=0; x<bdwidth; x++, y++) {
imlib_context_set_image(new_image);
ssocr_set_color(BG);
imlib_image_draw_rectangle(x, y, width-2*x, height-2*y);
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
static inline PyObject *
ImageObject_clone_image(PyObject* self, PyObject *args)
{
imlib_context_set_image(((ImageObject *)self)->image);
Imlib_Image image = imlib_clone_image();
if(image){
return NULL;
}
return (PyObject *)ImageObject_New(image);
}
/* set pixels that have at least mask pixels around it set (including the
* examined pixel itself) to black (foreground), all other pixels to white
* (background) */
Imlib_Image set_pixels_filter(Imlib_Image *source_image, double thresh,
luminance_t lt, int mask)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y,i,j; /* iteration variables */
int set_pixel; /* should pixel be set or not? */
Imlib_Color color;
int lum; /* luminance value of pixel */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* check for every pixel if it should be set in filtered image */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
set_pixel=0;
for(i=x-1; i<=x+1; i++) {
for(j=y-1; j<=y+1; j++) {
if(i>=0 && i<width && j>=0 && j<height) { /* i,j inside image? */
imlib_image_query_pixel(i, j, &color);
lum = get_lum(&color, lt);
if(is_pixel_set(lum, thresh)) {
set_pixel++;
}
}
}
}
/* set pixel if at least mask pixels around it are set */
if(set_pixel >= mask) {
draw_fg_pixel(new_image, x, y);
} else {
draw_bg_pixel(new_image, x, y);
}
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
/* mirror image horizontally or vertically */
Imlib_Image mirror(Imlib_Image *source_image, mirror_t direction)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables / target coordinates */
Imlib_Color color_return; /* for imlib_query_pixel() */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* create mirrored image */
if(direction == HORIZONTAL) {
for(x = width-1; x>=0; x--) {
for(y = 0; y < height; y++) {
imlib_image_query_pixel(width - 1 - x, y, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green, color_return.blue, color_return.alpha);
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
}
} else if(direction == VERTICAL) {
for(x = 0; x < width; x++) {
for(y = height-1; y >= 0; y--) {
imlib_image_query_pixel(x, height - 1 - y, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green, color_return.blue, color_return.alpha);
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
/* rotate the image */
Imlib_Image rotate(Imlib_Image *source_image, double theta)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables / target coordinates */
int sx,sy; /* source coordinates */
Imlib_Color color_return; /* for imlib_query_pixel() */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* convert theta from degrees to radians */
theta = theta / 360 * 2.0 * M_PI;
/* create rotated image
* (some parts of the original image will be lost) */
for(x = 0; x < width; x++) {
for(y = 0; y < height; y++) {
sx = (x-width/2) * cos(theta) + (y-height/2) * sin(theta) + width/2;
sy = (y-height/2) * cos(theta) - (x-width/2) * sin(theta) + height/2;
if((sx >= 0) && (sx <= width) && (sy >= 0) && (sy <= height)) {
imlib_image_query_pixel(sx, sy, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green, color_return.blue, color_return.alpha);
} else {
imlib_context_set_image(new_image);
ssocr_set_color(BG);
}
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
/* shear the image
* the top line is unchanged
* the bottom line is moved offset pixels to the right
* the other lines are moved yPos*offset/(height-1) pixels to the right
* white pixels are inserted at the left side */
Imlib_Image shear(Imlib_Image *source_image, int offset)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
int shift; /* current shift-width */
Imlib_Color color_return; /* for imlib_query_pixel() */
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* move every line to the right */
for(y=1; y<height; y++) {
shift = y * offset / (height-1);
/* copy pixels */
for(x=width-1; x>=shift; x--) {
imlib_image_query_pixel(x-shift, y, &color_return);
imlib_context_set_image(new_image);
imlib_context_set_color(color_return.red, color_return.green,
color_return.blue, color_return.alpha);
imlib_image_draw_pixel(x,y,0);
imlib_context_set_image(*source_image);
}
/* fill with background */
for(x=0; x<shift; x++) {
draw_bg_pixel(new_image, x, y);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
/* ww and wh are the width and height of the rectangle used to find the
* threshold value */
Imlib_Image dynamic_threshold(Imlib_Image *source_image,double t,luminance_t lt,
int ww, int wh)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
Imlib_Color color;
int lum;
double thresh;
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* check for every pixel if it should be set in filtered image */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
imlib_image_query_pixel(x, y, &color);
lum = get_lum(&color, lt);
thresh = get_threshold(source_image, t/100.0, lt, x-ww/2, y-ww/2, ww, wh);
if(is_pixel_set(lum, thresh)) {
draw_fg_pixel(new_image, x, y);
} else {
draw_bg_pixel(new_image, x, y);
}
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
Imlib_Image opening(Imlib_Image *source_image,double thresh,luminance_t lt,int n)
{
int i;
Imlib_Image temp_image1, temp_image2;
/* erosion n times */
imlib_context_set_image(*source_image);
temp_image1 = temp_image2 = imlib_clone_image();
for(i=0; i<n; i++) {
temp_image2 = erosion(&temp_image1, thresh, lt);
imlib_context_set_image(temp_image1);
imlib_free_image();
temp_image1 = temp_image2;
}
/* dilation n times */
for(i=0; i<n; i++) {
temp_image2 = dilation(&temp_image1, thresh, lt);
imlib_context_set_image(temp_image1);
imlib_free_image();
temp_image1 = temp_image2;
}
return temp_image2;
}
Imlib_Image Get_Image_from_ImgArray(struct CamGrab_t* CG)
{
int localMostRecent;
if (CG->MostRecent < 0)
{ //create dummy image to display
CG->LastDisplayedImage = imlib_create_image(640, 480);
imlib_context_set_image(CG->LastDisplayedImage);
imlib_context_set_color(128, 128, 128, 255);
imlib_image_fill_rectangle(0, 0, 640, 480);
}
else
{ //grab threads have started receiving images from rover
pthread_mutex_lock(&CG->MostRecentLock);
localMostRecent = CG->MostRecent;
pthread_mutex_lock(&CG->ImgArrayLock[CG->MostRecent]);
pthread_mutex_unlock(&CG->MostRecentLock);
imlib_context_set_image(*CG->ImgArray[localMostRecent]);
CG->LastDisplayedImage = imlib_clone_image();
CG->LastDisplayed = localMostRecent;
pthread_mutex_unlock(&CG->ImgArrayLock[localMostRecent]);
}
return CG->LastDisplayedImage;
}
/* turn image to grayscale */
Imlib_Image grayscale(Imlib_Image *source_image, luminance_t lt)
{
Imlib_Image new_image; /* construct grayscale image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
Imlib_Color color; /* Imlib2 color structure */
int lum=0;
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* transform image to grayscale */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
imlib_context_set_image(*source_image);
imlib_image_query_pixel(x, y, &color);
imlib_context_set_image(new_image);
lum = clip(get_lum(&color, lt),0,255);
imlib_context_set_color(lum, lum, lum, color.alpha);
imlib_image_draw_pixel(x, y, 0);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
int
main(int argc, char **argv)
{
int w, h, x, y;
Imlib_Image im = NULL, im_bg = NULL;
XEvent ev;
const char *display_name = getenv("DISPLAY");
/**
* Initialization according to options
*/
printf("Initialising\n");
/**
* First tests to determine which rendering task to perform
*/
if (display_name == NULL)
display_name = ":0";
disp = XOpenDisplay(display_name);
if (disp == NULL)
{
fprintf(stderr, "Can't open display %s\n", display_name);
return 1;
}
vis = DefaultVisual(disp, DefaultScreen(disp));
depth = DefaultDepth(disp, DefaultScreen(disp));
cm = DefaultColormap(disp, DefaultScreen(disp));
win =
XCreateSimpleWindow(disp, DefaultRootWindow(disp), 0, 0, 100, 100, 0, 0,
0);
XSelectInput(disp, win,
ButtonPressMask | ButtonReleaseMask | ButtonMotionMask |
PointerMotionMask | ExposureMask);
XMapWindow(disp, win);
/**
* Start rendering
*/
printf("Rendering\n");
imlib_context_set_display(disp);
imlib_context_set_visual(vis);
imlib_context_set_colormap(cm);
imlib_context_set_drawable(win);
imlib_context_set_dither(1);
imlib_context_set_blend(0);
imlib_context_set_color_modifier(NULL);
im_bg = imlib_load_image(PACKAGE_DATA_DIR"/data/images/imlib2.png");
im = imlib_load_image(PACKAGE_DATA_DIR"/data/images/imlib2.png");
imlib_context_set_image(im_bg);
w = imlib_image_get_width();
h = imlib_image_get_height();
printf("Resizing Window to %d by %d\n", w, h);
XResizeWindow(disp, win, w, h);
XSync(disp, False);
x = -9999;
y = -9999;
while (1)
{
Imlib_Image *temp, *temp2;
do
{
XNextEvent(disp, &ev);
switch (ev.type)
{
case Expose:
break;
case ButtonRelease:
exit(0);
break;
case MotionNotify:
x = ev.xmotion.x;
y = ev.xmotion.y;
default:
break;
}
}
while (XPending(disp));
imlib_context_set_blend(0);
imlib_context_set_image(im_bg);
temp = imlib_clone_image();
imlib_context_set_image(temp);
/* imlib_blend_image_onto_image(im_bg, 0,
* 0, 0, w, h,
* 0, 0, w, h);
* first = 0; */
imlib_apply_filter
("bump_map_point(x=[],y=[],map="PACKAGE_DATA_DIR"/data/images/imlib2.png);", &x, &y);
temp2 = im_bg;
im_bg = temp;
imlib_context_set_image(im_bg);
imlib_render_image_on_drawable(0, 0);
im_bg = temp2;
imlib_context_set_image(temp);
imlib_free_image();
}
return 0;
}
/* draw background to root */
void
drawbg(void) {
int i, w, h, nx, ny, nh, nw, tmp;
double factor;
Pixmap pm;
Imlib_Image tmpimg, buffer;
pm = XCreatePixmap(dpy, root, sw, sh,
DefaultDepth(dpy, DefaultScreen(dpy)));
if(!(buffer = imlib_create_image(sw, sh)))
die("Error: Cannot allocate buffer.\n");
imlib_context_set_image(buffer);
imlib_image_fill_rectangle(0, 0, sw, sh);
imlib_context_set_blend(1);
for(i = 0; i < nmonitor; i++) {
imlib_context_set_image(images[i % nimage]);
w = imlib_image_get_width();
h = imlib_image_get_height();
if(!(tmpimg = imlib_clone_image()))
die("Error: Cannot clone image.\n");
imlib_context_set_image(tmpimg);
if(rotate && ((monitors[i].w > monitors[i].h && w < h) ||
(monitors[i].w < monitors[i].h && w > h))) {
imlib_image_orientate(1);
tmp = w;
w = h;
h = tmp;
}
imlib_context_set_image(buffer);
switch(mode) {
case ModeCenter:
nw = (monitors[i].w - w) / 2;
nh = (monitors[i].h - h) / 2;
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (monitors[i].h - nh) / 2;
break;
case ModeZoom:
nw = monitors[i].w;
nh = monitors[i].h;
if(w > h && (w / h > (monitors[i].w / monitors[i].h))) {
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (int)ceil(h * nx / w) / 2;
}
else {
ny = monitors[i].y + (monitors[i].h - nh) / 2;
nx = monitors[i].x + (int)ceil(w * ny / h) / 2;
}
break;
default: /* ModeScale */
factor = MAX((double)w / monitors[i].w,
(double)h / monitors[i].h);
nw = w / factor;
nh = h / factor;
nx = monitors[i].x + (monitors[i].w - nw) / 2;
ny = monitors[i].y + (monitors[i].h - nh) / 2;
}
imlib_blend_image_onto_image(tmpimg, 0, 0, 0, w, h,
nx, ny, nw, nh);
imlib_context_set_image(tmpimg);
imlib_free_image();
}
imlib_context_set_blend(0);
imlib_context_set_image(buffer);
imlib_context_set_drawable(root);
imlib_render_image_on_drawable(0, 0);
imlib_context_set_drawable(pm);
imlib_render_image_on_drawable(0, 0);
XSetWindowBackgroundPixmap(dpy, root, pm);
imlib_context_set_image(buffer);
imlib_free_image_and_decache();
XFreePixmap(dpy, pm);
}
/* gray stretching, i.e. lum<t1 => lum=0, lum>t2 => lum=100,
* else lum=((lum-t1)*MAXRGB)/(t2-t1) */
Imlib_Image gray_stretch(Imlib_Image *source_image, double t1, double t2,
luminance_t lt)
{
Imlib_Image new_image; /* construct filtered image here */
Imlib_Image current_image; /* save image pointer */
int height, width; /* image dimensions */
int x,y; /* iteration variables */
Imlib_Color color;
int lum; /* luminance value of pixel */
/* do nothing if t1>=t2 */
if(t1 >= t2) {
fprintf(stderr, "error: gray_stretch(): t1=%.2f >= t2=%.2f\n", t1, t2);
exit(99);
}
/* check if 0 < t1,t2 < MAXRGB */
if(t1 <= 0.0) {
fprintf(stderr, "error: gray_stretch(): t1=%.2f <= 0.0\n", t1);
exit(99);
}
if(t2 >= MAXRGB) {
fprintf(stderr, "error: gray_stretch(): t2=%.2f >= %d.0\n", t2, MAXRGB);
exit(99);
}
/* save pointer to current image */
current_image = imlib_context_get_image();
/* create a new image */
imlib_context_set_image(*source_image);
height = imlib_image_get_height();
width = imlib_image_get_width();
new_image = imlib_clone_image();
/* gray stretch image */
for(x=0; x<width; x++) {
for(y=0; y<height; y++) {
imlib_image_query_pixel(x, y, &color);
lum = get_lum(&color, lt);
imlib_context_set_image(new_image);
if(lum<=t1) {
imlib_context_set_color(0, 0, 0, color.alpha);
} else if(lum>=t2) {
imlib_context_set_color(MAXRGB, MAXRGB, MAXRGB, color.alpha);
} else {
imlib_context_set_color(clip(((lum-t1)*255)/(t2-t1),0,255),
clip(((lum-t1)*255)/(t2-t1),0,255),
clip(((lum-t1)*255)/(t2-t1),0,255),
color.alpha);
}
imlib_image_draw_pixel(x, y, 0);
imlib_context_set_image(*source_image);
}
}
/* restore image from before function call */
imlib_context_set_image(current_image);
/* return filtered image */
return new_image;
}
Imlib_Image gib_imlib_clone_image(Imlib_Image im)
{
imlib_context_set_image(im);
return imlib_clone_image();
}
void get_icon (Task *tsk)
{
Panel *panel = tsk->area.panel;
if (!panel->g_task.icon) return;
size_t i;
Imlib_Image img = NULL;
XWMHints *hints = 0;
gulong *data = 0;
int k;
for (k=0; k<TASK_STATE_COUNT; ++k) {
if (tsk->icon[k]) {
imlib_context_set_image(tsk->icon[k]);
imlib_free_image();
tsk->icon[k] = 0;
}
}
data = server_get_property (tsk->win, server.atom._NET_WM_ICON, XA_CARDINAL, (int*)&i);
if (data) {
// get ARGB icon
int w, h;
gulong *tmp_data;
tmp_data = get_best_icon (data, get_icon_count (data, i), i, &w, &h, panel->g_task.icon_size1);
#ifdef __x86_64__
DATA32 icon_data[w * h];
size_t length = w * h;
for (i = 0; i < length; ++i)
icon_data[i] = tmp_data[i];
img = imlib_create_image_using_copied_data (w, h, icon_data);
#else
img = imlib_create_image_using_data (w, h, (DATA32*)tmp_data);
#endif
}
else {
// get Pixmap icon
hints = XGetWMHints(server.dsp, tsk->win);
if (hints) {
if (hints->flags & IconPixmapHint && hints->icon_pixmap != 0) {
// get width, height and depth for the pixmap
Window root;
int icon_x, icon_y;
uint32_t border_width, bpp;
uint32_t w, h;
//printf(" get pixmap\n");
XGetGeometry(server.dsp, hints->icon_pixmap, &root, &icon_x, &icon_y, &w, &h, &border_width, &bpp);
imlib_context_set_drawable(hints->icon_pixmap);
img = imlib_create_image_from_drawable(hints->icon_mask, 0, 0, w, h, 0);
}
}
}
if (img == NULL) {
imlib_context_set_image(default_icon);
img = imlib_clone_image();
}
// transform icons
imlib_context_set_image(img);
imlib_image_set_has_alpha(1);
int w, h;
w = imlib_image_get_width();
h = imlib_image_get_height();
Imlib_Image orig_image = imlib_create_cropped_scaled_image(0, 0, w, h, panel->g_task.icon_size1, panel->g_task.icon_size1);
imlib_free_image();
imlib_context_set_image(orig_image);
tsk->icon_width = imlib_image_get_width();
tsk->icon_height = imlib_image_get_height();
for (k=0; k<TASK_STATE_COUNT; ++k) {
imlib_context_set_image(orig_image);
tsk->icon[k] = imlib_clone_image();
imlib_context_set_image(tsk->icon[k]);
DATA32 *data32;
if (panel->g_task.alpha[k] != 100 || panel->g_task.saturation[k] != 0 || panel->g_task.brightness[k] != 0) {
data32 = imlib_image_get_data();
adjust_asb(data32, tsk->icon_width, tsk->icon_height, panel->g_task.alpha[k], (float)panel->g_task.saturation[k]/100, (float)panel->g_task.brightness[k]/100);
imlib_image_put_back_data(data32);
}
}
imlib_context_set_image(orig_image);
imlib_free_image();
if (hints)
XFree(hints);
if (data)
XFree (data);
GPtrArray* task_group = task_get_tasks(tsk->win);
if (task_group) {
for (i=0; i<task_group->len; ++i) {
Task* tsk2 = g_ptr_array_index(task_group, i);
tsk2->icon_width = tsk->icon_width;
tsk2->icon_height = tsk->icon_height;
int k;
for (k=0; k<TASK_STATE_COUNT; ++k)
tsk2->icon[k] = tsk->icon[k];
set_task_redraw(tsk2);
}
}
}
