/**
* Part of the floodfill ??
*/
static int fill_line(XImage *image, int x, int y, int width, unsigned int area_color, unsigned int fill_color, int minx, int maxx, dir_type direction)
{
register int left, right, i;
XPutPixel(image, x, y, fill_color);
for( left=x-1; (XGetPixel(image, left, y) == area_color) && (left >= 0);left--)
{
XPutPixel(image, left, y, fill_color);
}
left++;
for (right = x+1; (XGetPixel(image, right, y) == area_color) && (right < width); right++)
{
XPutPixel(image, right, y, fill_color);
}
XDrawLine(dpy, drawable, fill_gc, left, y, right-1, y);
for (i = left; i < right; i++)
{
if (XGetPixel(image, i, y+direction) == area_color)
{
/* Last one because we know there is one other pixel */
i += fill_line(image, i, y+direction, width, area_color, fill_color, left, right, direction) + 1;
}
}
if (left < minx-1) /* Fill other dir */
{
for (i = left; i < minx-1; i++)
{
if (XGetPixel(image, i, y-direction) == area_color)
{
/* Last one because we know there is one other pixel */
i += fill_line(image, i, y-direction, width, area_color, fill_color, left, right, (direction==dir_down?dir_up:dir_down)) + 1;
}
}
}
if (right > maxx) /* Fill other dir */
{
for (i = maxx+1; i < right; i++)
{
if (XGetPixel(image, i, y-direction) == area_color)
{
/* Last one because we know there is one other pixel */
i += fill_line(image, i, y-direction, width, area_color, fill_color, left, right, (direction==dir_down?dir_up:dir_down)) + 1;
}
}
}
return(right-x);
}
void iupdrvImageGetData(void* handle, unsigned char* imgdata)
{
Pixmap pixmap = (Pixmap)handle;
int w, h, y, x, bpp;
XImage *xi;
if (!iupdrvImageGetInfo(handle, &w, &h, &bpp))
return;
if (bpp == 8)
return;
xi = XGetImage(iupmot_display, pixmap, 0, 0, w, h, ULONG_MAX, ZPixmap);
if (xi)
{
/* planes are packed and top-bottom in this imgdata */
int planesize = w*h;
unsigned char *line_data;
for (y = 0; y<h; y++)
{
line_data = imgdata + y * planesize;
for (x = 0; x<w; x++)
{
iupmotColorGetRGB(XGetPixel(xi, x, y), line_data + x, line_data + x + 1, line_data + x + 2);
}
}
XDestroyImage(xi);
}
}
static int compare_color2(x11window_t * x11win, uint32_t w, uint32_t h, bool isRed, bool isGreen, bool isBlue)
{
XImage * ximg = 0;
size_t pixels;
uint32_t x, y;
Window root = RootWindow(x11win->display->sys_display, screen_x11window(x11win));
Window windummy;
int32_t x2, y2;
XTranslateCoordinates(x11win->display->sys_display, x11win->sys_drawable, root, 0, 0, &x2, &y2, &windummy);
ximg = XGetImage(x11win->display->sys_display, root, x2, y2, w, h, (unsigned long)-1, ZPixmap);
for (pixels = 0, y = 0; y < h; ++y) {
for (x = 0; x < w; ++x) {
unsigned long rgbcolor = XGetPixel(ximg, (int)x, (int)y);
if (isRed == (0 != (rgbcolor & ximg->red_mask))
&& isGreen == (0 != (rgbcolor & ximg->green_mask))
&& isBlue == (0 != (rgbcolor & ximg->blue_mask))) {
++ pixels;
}
}
}
XDestroyImage(ximg);
return (pixels > ((uint64_t)x*y/2)) ? 0 : EINVAL;
}
void save(){
unsigned char **image; // image[HEIGHT][WIDTH]の形式です
int i, j, pixeldata;
XImage *ximage;
image = (unsigned char**)malloc(height * sizeof(unsigned char*)); // 以下３行は２次元配列を確保します
for (j = 0; j < height; j++)
image[j] = (unsigned char*)malloc(width * sizeof(unsigned char) * 3);
for (j = 0; j < height; j++) {
ximage = XGetImage(dis,history_pix[(next+MAX_HISTORY-1)%MAX_HISTORY],0,j,width,1,AllPlanes,ZPixmap);
for(i=0;i<width;i++){
pixeldata = XGetPixel(ximage,i,0);
image[j][3*i] = pixeldata>>16&0xff;
image[j][3*i+1] = pixeldata>>8&0xff;
image[j][3*i+2] = pixeldata&0xff;
}
//XPutImage(dis,canvas,hcopy_gc,ximage,0,j,0,j,width,1);
}
write_png("test2.png", image, width, height); // PNGファイルを作成します
for (j = 0; j < height; j++) free(image[j]); // 以下２行は２次元配列を解放します
free(image);
}
int
egl_probe_front_pixel_rgb(struct egl_state *state,
int x, int y, const float *expected)
{
XImage *ximage = XGetImage(state->dpy, state->win,
x, state->height - y - 1, 1, 1, AllPlanes, ZPixmap);
unsigned long pixel = XGetPixel(ximage, 0, 0);
uint8_t *probe = (uint8_t *)&pixel;
int pass = 1;
int i;
XDestroyImage(ximage);
/* NB: XGetPixel returns a normalized BGRA, byte per
* component, pixel format */
for(i = 0; i < 3; ++i) {
if (fabs(probe[2 - i]/255.0 - expected[i]) > piglit_tolerance[i]) {
pass = 0;
}
}
if (pass)
return 1;
printf("Front Buffer Probe at (%i,%i)\n", x, y);
printf(" Expected: %f %f %f %f\n", expected[0], expected[1], expected[2], expected[3]);
printf(" Observed: %f %f %f %f\n", probe[0]/255.0, probe[1]/255.0, probe[2]/255.0, probe[3]/255.0);
return 0;
}
int EZX_GetPixel (EZXW_p W, int x, int y)
{
XImage *xi;
xi = XGetImage (theDisplay,W->w,x,y,1,1,AllPlanes,XYPixmap);
return (XGetPixel ( xi,x,y ));
}
static int
mygetpixel (XImage * image, int pos, int y)
{
int width = image->width;
int i;
int sum = font_error;
int start = (pos * width + 4) / 8;
int end = ((pos + 1) * width + 4) / 8;
if (start == end)
{
if (start == image->width - 1)
start--;
else
end++;
}
for (i = start; i < end; i++)
sum += XGetPixel (image, i, y) != 0;
if (sum <= (end - start) / 2)
{
font_error = sum;
return 0;
}
else
font_error = -(end - start - sum);
return 1;
}
void updateColor(int sq, Display *disp, Window wind, int x, int y, int dx, int dy)
//sq :: 1 - 64.
{
XImage *i =
XGetImage(disp, wind, x, y, dx, dy, AllPlanes, XYPixmap);
int j;
int k;
unsigned long findColor();
unsigned long px;
unsigned long cl;
for (j = 0; j < 26; j++){
for(k = 0; k < 26; k++){
px = XGetPixel(i, 10 + 2*j, 10 + 2*k);
cl = findColor(px);
if(cl != 0){
colArr[sq] = cl;
XDestroyImage(i);
return;
}
}
}
XDestroyImage(i);
colArr[sq] = UNK;
return;
}
Global void
ConvertImage(XImage *image,
unsigned int width,
unsigned int height,
ColormapPtr src_cmap,
ColormapPtr dst_cmap)
{
int x, y;
card32 pixel;
if (image->depth == 1)
return;
if (src_cmap == NULL && dst_cmap == NULL)
return;
if (src_cmap == NULL) {
MoveImage(image, image, width, height, dst_cmap, Request);
return;
}
if (dst_cmap == NULL) {
MoveImage(image, image, width, height, src_cmap, Reply);
return;
}
for (x = 0; x < width; x++)
for (y = 0; y < height; y++) {
pixel = XGetPixel(image, x, y);
pixel = MapColorCell(pixel, src_cmap, Reply);
pixel = MapColorCell(pixel, dst_cmap, Request);
XPutPixel(image, x, y, pixel);
}
}
/*
* Generate OpenGL-compatible bitmap.
*/
static void
fill_bitmap(Display * dpy, Window win, GC gc,
unsigned int width, unsigned int height,
int x0, int y0, unsigned int c, GLubyte * bitmap)
{
XImage *image;
unsigned int x, y;
Pixmap pixmap;
XChar2b char2b;
pixmap = XCreatePixmap(dpy, win, 8 * width, height, 1);
XSetForeground(dpy, gc, 0);
XFillRectangle(dpy, pixmap, gc, 0, 0, 8 * width, height);
XSetForeground(dpy, gc, 1);
char2b.byte1 = (c >> 8) & 0xff;
char2b.byte2 = (c & 0xff);
XDrawString16(dpy, pixmap, gc, x0, y0, &char2b, 1);
image = XGetImage(dpy, pixmap, 0, 0, 8 * width, height, 1, XYPixmap);
if (image) {
/* Fill the bitmap (X11 and OpenGL are upside down wrt each other). */
for (y = 0; y < height; y++)
for (x = 0; x < 8 * width; x++)
if (XGetPixel(image, x, y))
bitmap[width * (height - y - 1) + x / 8] |=
(1 << (7 - (x % 8)));
XDestroyImage(image);
}
XFreePixmap(dpy, pixmap);
}
void iupdrvImageGetRawData(void* handle, unsigned char* imgdata)
{
Pixmap pixmap = (Pixmap)handle;
int w, h, y, x, bpp;
XImage *xi;
if (!iupdrvImageGetInfo(handle, &w, &h, &bpp))
return;
if (bpp==8)
return;
xi = XGetImage(iupmot_display, pixmap, 0, 0, w, h, ULONG_MAX, ZPixmap);
if (xi)
{
/* planes are separated in imgdata */
int planesize = w*h;
unsigned char *r = imgdata,
*g = imgdata+planesize,
*b = imgdata+2*planesize;
for (y=0; y<h; y++)
{
int lineoffset = (h-1 - y)*w; /* imgdata is bottom up */
for (x=0; x<w; x++)
{
iupmotColorGetRGB(XGetPixel(xi, x, y), r + lineoffset+x, g + lineoffset+x, b + lineoffset+x);
}
}
XDestroyImage(xi);
}
}
void
JXImage::Receive
(
JBroadcaster* sender,
const Message& message
)
{
if (sender == itsColormap && message.Is(JXColormap::kNewColormap) &&
itsDepth > 1 && (itsPixmap != None || itsImage != NULL))
{
const JXColormap::NewColormap* info =
dynamic_cast(const JXColormap::NewColormap*, &message);
assert( info != NULL );
ConvertToImage();
const JCoordinate width = GetWidth();
const JCoordinate height = GetHeight();
for (JCoordinate y=0; y<height; y++)
{
for (JCoordinate x=0; x<width; x++)
{
const unsigned long xPixel = XGetPixel(itsImage, x,y);
XPutPixel(itsImage, x,y, info->ConvertPixel(xPixel));
}
}
ConvertToDefaultState();
}
else
{
void dgauy_gaux_filter(float sigma){
int i,j,k,length_gaussian,length_deriv;
float gaussian[SIZE1],deriv_gaussian[SIZE1];
matrix dgauy, dgauy_gaux, total_resul, m;
float rmin,rmax,rng;
/* Fill in the image with background color */
for(i=0; i<IMAGE_WIDTH; i++)
for(j=0; j<IMAGE_HEIGHT; j++)
XPutPixel(theXImage_2,i,j,bg);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);
/* Associate the watch cursor with the main window */
XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor);
/* Flush the request buffer and wait for all events */
/* and errors to be processed by the server. */
XSync(XtDisplay(draw_1), False);
get_gaussian(sigma,gaussian,&length_gaussian);
get_derigaussian(sigma,deriv_gaussian,&length_deriv);
for(i=0;i<IMAGE_WIDTH;i++)
for(j=0;j<IMAGE_HEIGHT;j++)
m[i][j]= XGetPixel(theXImage_1,i,j);
/* Calculates convolution of the image with the derivative of a */
convo_vectory(m,deriv_gaussian,length_deriv,&rmax,&rmin,dgauy);
/*Calculate the smoothing of a Gaussian(y) in x direction */
convo_vectorx(dgauy,gaussian,length_gaussian,&rmax,&rmin,
dgauy_gaux);
rng=(rmax-rmin);
for(i=0;i<IMAGE_WIDTH;i++)
for(j=0;j<IMAGE_HEIGHT;j++)
total_resul[i][j]=sqrt(pow(dgauy_gaux[i][j],2));
for(i=0;i<IMAGE_WIDTH;i++)
for(j=0;j<IMAGE_HEIGHT;j++)
XPutPixel(theXImage_2,i,j,(unsigned long)
(((float)(total_resul[i][j]-rmin)/rng)*255.0));
/* Copy image into pixmap */
XPutImage(XtDisplay(draw_2), thePixmap_2,image_gc_2, theXImage_2,
0, 0, 0, 0, theXImage_2->width, theXImage_2->height);
/* Disassociate the watch cursor from the main window */
XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window));
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_2),XtWindow(draw_2),0,0,0,0,True);
}
// Get pixel color at coordinates x,y
void pixel_color (Display *display, int x, int y, XColor *color)
{
XImage *image;
image = XGetImage (display, DefaultRootWindow (display), x, y, 1, 1, AllPlanes, XYPixmap);
color->pixel = XGetPixel (image, 0, 0);
XFree (image);
XQueryColor (display, DefaultColormap(display, DefaultScreen (display)), color);
}
void start_merge(Widget w, XtPointer client_data,
XmSelectionBoxCallbackStruct *call_data)
{
short i,j,condition;
char *cond;
/* Get threshold value from user's selection */
XmStringGetLtoR(call_data->value, XmSTRING_DEFAULT_CHARSET, &cond);
condition = atoi(cond);
if (!(condition>=0 && condition<=512) ) {
XBell(XtDisplay(w),100);
return;
}
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);
/* Associate the watch cursor with the main window */
XDefineCursor(XtDisplay(draw_1), XtWindow(main_window), theCursor);
/* Flush the request buffer and wait for all events */
/* and errors to be processed by the server. */
XSync(XtDisplay(draw_1), False);
/* Free the memory used for giving room to the structure */
/* that represents the merged regions if any */
if (merged_region_list!=NULL) free_merge(&merged_region_list);
num_reg_after=0;
/* Compute merge procedure */
merged_region_list = merge(root,condition);
fprintf (stderr,"\n ------------- MERGE ------------\n");
fprintf (stderr," Standard deviation %i\n", condition);
fprintf (stderr," Number of regions %i\n", num_reg_after);
/* Fill in the image with background color */
for(i=0; i<IMAGE_WIDTH; i++)
for(j=0; j<IMAGE_HEIGHT; j++)
XPutPixel(theXImage_2,i,j,XGetPixel(theXImage_1,i,j));
display_contour(merged_region_list);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_1),0,0,0,0,True);
/* Disassociate the watch cursor from the main window */
XUndefineCursor(XtDisplay(draw_1), XtWindow(main_window));
/* Copy image into pixmap */
XPutImage(XtDisplay(draw_2), thePixmap_2, image_gc_2, theXImage_2,
0, 0, 0, 0, theXImage_2->width, theXImage_2->height);
/* Clear the drawing window so the image is displayed again */
XClearArea(XtDisplay(draw_1),XtWindow(draw_2),0,0,0,0,True);
}
/*******************************************************************
KF 6/14/90
write_pixmap_file(display, filename, pm, width, height)
and
write_pixmap_file_xy(display, filename, pm, x, y, width, height)
has been merged into one function.
INPUT: display dsp, screen s, file name fn to write the file in,
window id wid where pixmap is,
upper left corner x, y of original pixmap,
width and height of pixmap
OUTPUT: binary file with data
PURPOSE: write_pixmap_file gets the image structure of the input
pixmap, convert the image data with the permutation color
vector, writes the image structure out to filename.
Note that writing out a Z pixmap is 8x faster than XY pixmap.
This is because XY writes out each pixel value per plane, thus
number of bits; Z writes out each pixel, or 8 bits at a time.
The XY format may have been chosen for a reason -- I don't know.
********************************************************************/
void
write_pixmap_file(Display *dsp, int scr, char *fn,
Window wid, int x, int y, int width,int height)
{
XImage *xi;
FILE *file;
int *permVector;
int num;
int num_colors;
/* get color map and permutation vector */
if ((num_colors = makePermVector(dsp, scr,(unsigned long **)&permVector)) < 0) {
printf("num_colors < 0!!\n");
exit(-1);
}
/* reads image structure in ZPixmap format */
xi = XGetImage(dsp, wid, x, y, width, height, AllPlanes, ZPixmap);
file = fopen(fn, "wb");
if (file == NULL) {
perror("opening pixmap file for write");
exit(-1);
}
#define PUTW(a,b) putw(htonl(a),b)
PUTW(xi->width, file);
PUTW(xi->height, file);
PUTW(xi->xoffset, file);
PUTW(xi->format, file);
PUTW(xi->byte_order, file);
PUTW(xi->bitmap_unit, file);
PUTW(xi->bitmap_bit_order, file);
PUTW(xi->bitmap_pad, file);
PUTW(xi->depth, file);
PUTW(xi->bytes_per_line, file);
PUTW(xi->bits_per_pixel, file);
PUTW(xi->red_mask, file);
PUTW(xi->green_mask, file);
PUTW(xi->blue_mask, file);
num = xi->bytes_per_line * height; /* total number of pixels in pixmap */
/* store value from permutation */
{
int ii, jj;
for (ii = 0; ii < width; ii++)
for (jj = 0; jj < height; jj++) {
XPutPixel(xi, ii, jj, permVector[(int) XGetPixel(xi, ii, jj)]);
}
}
fwrite(xi->data, 1, num, file);
fclose(file);
}
static void Xvars_unstretch_subsample(XImage* dest,XImage* src) {
// Real simple, sample every other pixel in ever other row.
Pos destPos;
for (destPos.y = 0; destPos.y < dest->height; destPos.y++) {
for (destPos.x = 0; destPos.x < dest->width; destPos.x++) {
unsigned long pix = XGetPixel(src,destPos.x * 2,destPos.y * 2);
XPutPixel(dest,destPos.x,destPos.y,pix);
}
}
}
/* generate an XImage from the reflect algoritm submitted by
* Randy Zack <*****@*****.**>
* draw really got too big and ugly so I split it up
* it should be possible to use the from[][] to speed it up
* (once I figure out the algorithm used :)
*/
static void reflect_draw(struct state *st, int k)
{
int i, j;
int cx, cy;
int ly, lysq, lx, ny, dist, rsq = st->radius * st->radius;
cx = cy = st->radius;
if (st->xy_coo[k].ymove > 0)
cy += st->speed;
if (st->xy_coo[k].xmove > 0)
cx += st->speed;
for(i = 0 ; i < 2*st->radius+st->speed+2; i++) {
ly = i - cy;
lysq = ly * ly;
ny = st->xy_coo[k].y + i;
if (ny >= st->orig_map->height) ny = st->orig_map->height-1;
for(j = 0 ; j < 2*st->radius+st->speed+2 ; j++) {
lx = j - cx;
dist = lx * lx + lysq;
if (dist > rsq ||
ly < -st->radius || ly > st->radius ||
lx < -st->radius || lx > st->radius)
XPutPixel( st->buffer_map, j, i,
XGetPixel( st->orig_map, st->xy_coo[k].x + j, ny ));
else if (dist == 0)
XPutPixel( st->buffer_map, j, i, st->black_pixel );
else {
int x = st->xy_coo[k].x + cx + (lx * rsq / dist);
int y = st->xy_coo[k].y + cy + (ly * rsq / dist);
if (x < 0 || x >= st->xgwa.width ||
y < 0 || y >= st->xgwa.height)
XPutPixel( st->buffer_map, j, i, st->black_pixel );
else
XPutPixel( st->buffer_map, j, i,
XGetPixel( st->orig_map, x, y ));
}
}
}
XPutImage(st->dpy, st->window, st->gc, st->buffer_map, 0, 0, st->xy_coo[k].x, st->xy_coo[k].y,
2*st->radius+st->speed+2, 2*st->radius+st->speed+2);
}
void gui_Draw_Image(winlist_t *win, int x, int y, char **xpm_data)
{
XImage *image, *mask;
XpmAttributes attr;
Window w = win->window;
GC pgc = XCreateGC(gui->display, w, 0, NULL);
unsigned int px, py;
unsigned long mask_val, img_val;
bzero(&attr, sizeof(attr));
XpmCreateImageFromData(gui->display, xpm_data, &image, &mask, &attr);
if (mask)
{
for (py=0 ; py < attr.height ; py++)
{
for (px=0 ; px < attr.width ; px++)
{
mask_val = XGetPixel(mask, px, py);
/* 要顯示的點 */
if (mask_val)
{
img_val = XGetPixel(image, px, py);
XSetForeground(gui->display, pgc, img_val);
XDrawPoint(gui->display, w, pgc, px+x, py+y);
}
}
}
}
else
{
XPutImage(gui->display, w, DefaultGC(gui->display, gui->screen),
image, 0, 0, x, y, attr.width, attr.height);
}
XDestroyImage(image);
if (mask)
{
XDestroyImage(mask);
}
XpmFreeAttributes(&attr);
XFreeGC(gui->display, pgc);
}
QColor ColorPickerWidget::grabColor(const QPoint &p, bool destroyImage)
{
#ifdef Q_WS_X11
/*
we use the X11 API directly in this case as we are not getting back a valid
return from QPixmap::grabWindow in the case where the application is using
an argb visual
*/
if( !qApp->desktop()->geometry().contains( p ))
return QColor();
unsigned long xpixel;
if (m_image == NULL) {
Window root = RootWindow(QX11Info::display(), QX11Info::appScreen());
m_image = XGetImage(QX11Info::display(), root, p.x(), p.y(), 1, 1, -1, ZPixmap);
xpixel = XGetPixel(m_image, 0, 0);
} else {
xpixel = XGetPixel(m_image, p.x(), p.y());
}
if (destroyImage) {
XDestroyImage(m_image);
m_image = 0;
}
XColor xcol;
xcol.pixel = xpixel;
xcol.flags = DoRed | DoGreen | DoBlue;
XQueryColor(QX11Info::display(),
DefaultColormap(QX11Info::display(), QX11Info::appScreen()),
&xcol);
return QColor::fromRgbF(xcol.red / 65535.0, xcol.green / 65535.0, xcol.blue / 65535.0);
#else
Q_UNUSED(destroyImage)
if (m_image.isNull()) {
QWidget *desktop = QApplication::desktop();
QPixmap pm = QPixmap::grabWindow(desktop->winId(), p.x(), p.y(), 1, 1);
QImage i = pm.toImage();
return i.pixel(0, 0);
} else {
return m_image.pixel(p.x(), p.y());
}
#endif
}
void logofill() {
XImage *img = XGetImage(dpy, win, 0, 0, screen_width, screen_height, -1,
ZPixmap );
floodfill( img, xgr_pen.xpos, xgr_pen.ypos,
XGetPixel( img, xgr_pen.xpos, xgr_pen.ypos ),
color[(xgr_pen.color)+2].pixel );
XPutImage( dpy, win, draw_gc, img, 0, 0, 0, 0, screen_width,
screen_height );
XDestroyImage( img );
}
LLDSPEC color_t gdisp_lld_get_pixel_color(GDisplay *g) {
xPriv * priv = (xPriv *)g->priv;
XColor color;
XImage *img;
img = XGetImage (dis, priv->pix, g->p.x, g->p.y, 1, 1, AllPlanes, XYPixmap);
color.pixel = XGetPixel (img, 0, 0);
XFree(img);
XQueryColor(dis, cmap, &color);
return RGB2COLOR(color.red>>8, color.green>>8, color.blue>>8);
}
Global void
CopyImage(XImage *image,
XImage *new_image,
unsigned int width,
unsigned int height)
{
int x,y;
for (x=0; x < width; x++)
for (y=0; y < height; y++)
XPutPixel(new_image, x, y, XGetPixel(image, x, y));
}
color
x_picture_rep::internal_get_pixel (int x, int y) {
if (im == NULL)
im= XGetImage (the_gui->dpy, pm, 0, 0, w, h, AllPlanes, XYPixmap);
if (im != NULL) {
unsigned long c= XGetPixel (im, x, h-1-y);
int r= (c >> 16) & 0xff;
int g= (c >> 8 ) & 0xff;
int b= (c ) & 0xff;
if (r == 0x64 && g == 0x65 && b == 0x66) return 0x00ffffff;
return rgb_color (r, g, b, 255);
}
int
Block_Rotate(
XImage *src_image,
XImage *dst_image,
int rtype )
{
int i, j, width, height;
unsigned long n;
#ifdef DEBUG
if (debug)
stat_out("Entering Block_Rotate\n");
#endif
width = src_image->width;
height = src_image->height;
switch (rtype) {
case ROTATE_L : for (i=0; i<width; i++)
for (j=0; j<height; j++) {
n = XGetPixel(src_image, i, j);
XPutPixel(dst_image, j, (width-1)-i, n);
}
break;
case ROTATE_R : for (i=0; i<width; i++)
for (j=0; j<height; j++) {
n = XGetPixel(src_image, i, j);
XPutPixel(dst_image, (height-1)-j, i, n);
}
break;
} /* switch */
XFlush(dpy);
#ifdef DEBUG
if (debug)
stat_out("Leaving Block_Rotate\n");
#endif
return (True);
}
PetscErrorCode PetscDrawGetImage_X(PetscDraw draw,unsigned char palette[PETSC_DRAW_MAXCOLOR][3],unsigned int *out_w,unsigned int *out_h,unsigned char *out_pixels[])
{
PetscDraw_X *Xwin = (PetscDraw_X*)draw->data;
PetscMPIInt rank;
PetscErrorCode ierr;
PetscFunctionBegin;
if (out_w) *out_w = 0;
if (out_h) *out_h = 0;
if (out_pixels) *out_pixels = NULL;
ierr = MPI_Comm_rank(PetscObjectComm((PetscObject)draw),&rank);CHKERRQ(ierr);
/* make sure the X server processed requests from all processes */
ierr = PetscDrawCollectiveBegin(draw);CHKERRQ(ierr);
XSync(Xwin->disp,True);
ierr = PetscDrawCollectiveEnd(draw);CHKERRQ(ierr);
ierr = MPI_Barrier(PetscObjectComm((PetscObject)draw));CHKERRQ(ierr);
/* only the first process return image data */
ierr = PetscDrawCollectiveBegin(draw);CHKERRQ(ierr);
if (!rank) {
Window root;
XImage *ximage;
int pmap[PETSC_DRAW_MAXCOLOR];
unsigned char *pixels = NULL;
unsigned int w,h,dummy;
int x,y,p;
/* copy colormap palette to the caller */
ierr = PetscMemcpy(palette,Xwin->cpalette,sizeof(Xwin->cpalette));CHKERRQ(ierr);
/* get image out of the drawable */
XGetGeometry(Xwin->disp,PetscDrawXiDrawable(Xwin),&root,&x,&y,&w,&h,&dummy,&dummy);
ximage = XGetImage(Xwin->disp,PetscDrawXiDrawable(Xwin),0,0,w,h,AllPlanes,ZPixmap);
if (!ximage) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Cannot XGetImage()");
/* build indirect sort permutation (a.k.a argsort) of the color -> pixel mapping */
for (p=0; p<PETSC_DRAW_MAXCOLOR; p++) pmap[p] = p; /* identity permutation */
ierr = PetscArgSortPixVal(Xwin->cmapping,pmap,255);CHKERRQ(ierr);
/* extract pixel values out of the image and map them to color indices */
ierr = PetscMalloc1(w*h,&pixels);CHKERRQ(ierr);
for (p=0,y=0; y<(int)h; y++)
for (x=0; x<(int)w; x++) {
PetscDrawXiPixVal pix = XGetPixel(ximage,x,y);
pixels[p++] = (unsigned char)PetscDrawXiPixelToColor(Xwin,pmap,pix);
}
XDestroyImage(ximage);
*out_w = w;
*out_h = h;
*out_pixels = pixels;
}
ierr = PetscDrawCollectiveEnd(draw);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
void mouse_track_2(Widget w, XtPointer client_data, XEvent *event)
{
int mouse_x, mouse_y;
if (file_not_loaded) return;
/* Get actual co-ordinates of the mouse */
mouse_x = event->xmotion.x;
mouse_y = event->xmotion.y;
/* Refresh the actual co-ordinates of the mouse on the screen */
refresh_coord(mouse_x, mouse_y,
(int) XGetPixel(theXImage_2, mouse_x, mouse_y));
}
void get_pixel_color(Display *d, int x, int y, struct rgb_color *c, int radius) {
#if USE_XQUERYCOLOR
/* Cache color lookups */
#define CACHE_SIZE 16384
static unsigned long pixels[CACHE_SIZE] = {0};
static XColor colors[CACHE_SIZE] = {0};
static uint8_t cached[CACHE_SIZE] = {0};
XColor xc;
#else
/* we blindly assume that we have an array of rgb structs */
struct rgb_color *pic = (struct rgb_color *)img->data;
#endif
/* calculate average color */
long ix, iy;
unsigned long r = 0;
unsigned long g = 0;
unsigned long b = 0;
int n_pixels = 0;
for (ix=0; ix < img->width; ix++) {
if (ix+img_offset.x < x-radius || ix+img_offset.x > x+radius) continue;
for (iy=0; iy < img->height; iy++) {
if (iy+img_offset.y < y-radius || iy+img_offset.y > y+radius) continue;
#if USE_XQUERYCOLOR
unsigned long p = XGetPixel(img, ix, iy);
if (cached[p%CACHE_SIZE] && pixels[p%CACHE_SIZE] == p) {
xc = colors[p%CACHE_SIZE];
} else {
xc.pixel = p;
XQueryColor(d, DefaultColormap(d, DefaultScreen(d)), &xc);
pixels[p%CACHE_SIZE] = p;
colors[p%CACHE_SIZE] = xc;
cached[p%CACHE_SIZE] = 1;
}
r += xc.red>>8;
g += xc.green>>8;
b += xc.blue>>8;
#else
struct rgb_color *pixel = &pic[ix+iy*img->width];
r += pixel->red;
g += pixel->green;
b += pixel->blue;
#endif
n_pixels++;
}
}
c->red = (r/n_pixels);
c->green = (g/n_pixels);
c->blue = (b/n_pixels);
}
static void generic_draw(struct state *st, XImage *src, XImage *dest, int x, int y, int *distort_matrix)
{
int i, j;
for (i = 0; i < dest->width; i++)
for (j = 0; j < dest->height; j++)
if (st->from[i][j][0] + x >= 0 &&
st->from[i][j][0] + x < src->width &&
st->from[i][j][1] + y >= 0 &&
st->from[i][j][1] + y < src->height)
XPutPixel(dest, i, j,
XGetPixel(src,
st->from[i][j][0] + x,
st->from[i][j][1] + y));
}
value caml_gr_dump_image(value image)
{
int width, height, i, j;
XImage * idata, * imask;
value m = Val_unit;
Begin_roots2(image, m);
caml_gr_check_open();
width = Width_im(image);
height = Height_im(image);
m = alloc(height, 0);
for (i = 0; i < height; i++) {
value v = alloc(width, 0);
modify(&Field(m, i), v);
}
idata =
XGetImage(caml_gr_display, Data_im(image), 0, 0, width, height, (-1), ZPixmap);
for (i = 0; i < height; i++)
for (j = 0; j < width; j++)
Field(Field(m, i), j) = Val_int(caml_gr_rgb_pixel(XGetPixel(idata, j, i)));
XDestroyImage(idata);
if (Mask_im(image) != None) {
imask =
XGetImage(caml_gr_display, Mask_im(image), 0, 0, width, height, 1, ZPixmap);
for (i = 0; i < height; i++)
for (j = 0; j < width; j++)
if (XGetPixel(imask, j, i) == 0)
Field(Field(m, i), j) = Val_int(Transparent);
XDestroyImage(imask);
}
End_roots();
return m;
}