print_X11.sc

/*									tab:8
 *
 * print_X11.sc - output images to X11
 *
 * 
 * "Copyright (c) 1994,1995 The Regents of the University of Maryland.
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software and its
 * documentation for any purpose, without fee, and without written agreement is
 * hereby granted, provided that the above copyright notice and the following
 * two paragraphs appear in all copies of this software.
 * 
 * IN NO EVENT SHALL THE UNIVERSITY OF MARYLAND BE LIABLE TO ANY PARTY FOR
 * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT
 * OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE UNIVERSITY OF
 * MARYLAND HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 * 
 * THE UNIVERSITY OF MARYLAND SPECIFICALLY DISCLAIMS ANY WARRANTIES,
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
 * AND FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND THE UNIVERSITY OF MARYLAND HAS NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS."
 *
 * Author: 		David A. Bader <dbader@umiacs.umd.edu>
 *                      Joseph F. Ja'Ja' <joseph@umiacs.umd.edu>
 *                      Institute for Advanced Computer Studies
 *                      Department of Electrical Engineering 
 *                      AV Williams Building
 *                      College Park, MD 20742
 *                      
 * Version:		1
 * Creation Date:	November 9, 1995
 * Filename:		print_X11.sc
 * History:
 */

#if X11

#include "print_X11.h"
#include "connComp_gen.h"
#include "radixsort.h"

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <math.h>

#define _WINDOWNAME "Image Window"
#define _ICONNAME   "ImageIcon"

#define MAXWINDOWS  10
#define _NCOLORSMAX 64

static Display    *_display;
static GC         _gc;
static int        _screen;
static unsigned long _fg, _bg;
static XSizeHints _hint;
static Visual     *_visual;
static unsigned int _depth;
static int        _borderwidth = 7;
static int        _initX = 0;
static char       *_windowname = _WINDOWNAME;
static char       *_iconname   = _ICONNAME;
static int        _NCOLORS = _NCOLORSMAX;
static Colormap   _cmap;
static XColor     _colors[_NCOLORSMAX];

static
void init_X(int width, int height) 
{
  char       _name[80];
  XColor     _exact_colors[_NCOLORSMAX];
  Status     _stat;
  int i;
  
  _display     = XOpenDisplay("");
  _screen      = DefaultScreen(_display);
  _bg          = WhitePixel(_display, _screen);
  _fg          = BlackPixel(_display, _screen);
  _hint.x      = 100;
  _hint.y      = 150;
  _hint.width  = width;
  _hint.height = height;
  _hint.flags  = PPosition | PSize;
  
  _gc          = XDefaultGC(_display, _screen); 
  
  XSetBackground(_display, _gc, _bg);
  XSetForeground(_display, _gc, _fg);
  
  _visual = XDefaultVisual(_display, _screen);
  _depth  = XDefaultDepth(_display, _screen);

  _cmap = XDefaultColormap(_display, 0); 

  for (i=0; i<_NCOLORS; i++) {
    sprintf(_name,"gray%d",i<<1);
    _stat = XAllocNamedColor(_display, _cmap,
			     _name,&_colors[i],
			     &_exact_colors[i]); 
    if (_stat == BadColor)
      printf("ERROR: allocating color %3d\n",i);
  }

  XInstallColormap(_display, _cmap);
  
  _initX       = 1;
}

static
unsigned long map_pixel(x)
     unsigned long x;
{
  return (_colors[x].pixel);
}

static
unsigned long dither_pixel(x)
     unsigned long x;
{
  double d;
  d = (double)x / 256.0;
  d *= (double)_NCOLORS;
  d = floor(d);
  
  return map_pixel((unsigned long)d);
}

void create_X_window(_w, image, width, height) 
     Window *_w;
     unsigned char *image;
     int width, height;
{
  char       *data;
  XImage     *_image;
  int        i,j;
  XSetWindowAttributes _xswa;

  if (!_initX) 
      init_X(width, height);

  *_w = XCreateSimpleWindow(_display, DefaultRootWindow(_display),
			    _hint.x, _hint.y, 
			    _hint.width, _hint.height, 
			    _borderwidth, _fg, _bg);
  
  XSetStandardProperties(_display, *_w, _windowname, _iconname, None,
			 NULL, 0, &_hint);
  
  _xswa.backing_store = Always;
  XChangeWindowAttributes(_display, *_w, CWBackingStore, &_xswa);
  
  XMapRaised  (_display, *_w);
  
  data    = (char*)malloc(width*height*sizeof(char));
  
  _image  = XCreateImage(_display, _visual, _depth, ZPixmap,
			 0, data, width, height, 0, width*sizeof(char));
  
  for (i=0 ; i<height ; i++) 
    for (j=0 ; j<width ; j++) 
#if 1
	XPutPixel(_image, j, i, 
		  dither_pixel((unsigned long)image[i*width + j]));
#else
	XPutPixel(_image, j, i, map_pixel(i>>3));
#endif

  XClearWindow(_display, *_w); 
  
  XPutImage(_display, *_w, _gc, _image, 0, 0, 0, 0, width, height); 

}

void destroy_X_window(_w)
     Window *_w;
{
  XDestroyWindow(_display, *_w);
}

void destroy_X()
{
  XUninstallColormap(_display, _cmap);
  XFreeColormap(_display, _cmap);
  XCloseDisplay(_display);
}

void print_x11_im(char *desc, char *outfilename,
		    int v, int w, int q, int r, int k,
		    int image[v][w]::[q][r])
{
    register int
	i, ii, j, jj, p;
    Window     *_win;
    unsigned char *imageX;

    _win = (Window *)malloc(sizeof(Window));

    imageX = (unsigned char *)malloc(v*w*q*r*sizeof(unsigned char));

    p = 0;
    for (i=0 ; i<v ; i++) 
	for (ii=0 ; ii < q ; ii++) 
	    for (j=0 ; j<w ; j++) 
		for (jj=0 ; jj < r ; jj++) 
		    imageX[p++] = (unsigned char)image[i][j][ii][jj];

    _windowname = outfilename;
    _iconname   = outfilename;
    create_X_window(_win, imageX, w*r, v*q);
}

void print_x11_cc_orig(char *desc, char *outfilename,
		    int v, int w, int q, int r, int k,
		    int image[v][w]::[q][r])
{
    register int
	i, ii, j, jj, p;

    register double val;
    Window     *_win;
    unsigned char *imageX;

    _win = (Window *)malloc(sizeof(Window));

    imageX = (unsigned char *)malloc(v*w*q*r*sizeof(unsigned char));

    p = 0;

    for (i=0 ; i<v ; i++) 
	for (ii=0 ; ii < q ; ii++)  
	    for (j=0 ; j<w ; j++)
		for (jj=0 ; jj < r ; jj++) {
		    val = ((double)image[i][j][ii][jj]) /
			((double)(v*w*q*r) + 1.0);
		    val *= 255.0;
		    val = floor(val);
		    imageX[p++] = (unsigned char)((int)val);
		}

    _windowname = outfilename;
    _iconname   = outfilename;
    create_X_window(_win, imageX, w*r, v*q);
}

void print_x11_cc(char *desc, char *outfilename,
		    int v, int w, int q, int r, int k,
		    int image[v][w]::[q][r])
{
    register int
	i, ii, j, jj, p;

    register double val;
    Window     *_win;
    unsigned char *imageX;

    _win = (Window *)malloc(sizeof(Window));

    imageX = (unsigned char *)malloc(v*w*q*r*sizeof(unsigned char));

    p = 0;

/* Instead of linear mapping of labels to [0..255], use
   255 (sin (1E+7 * x) + 1.0) / 2 */

    for (i=0 ; i<v ; i++) 
	for (ii=0 ; ii < q ; ii++) 
	    for (j=0 ; j<w ; j++)
		for (jj=0 ; jj < r ; jj++) {
		    val = sin(12345678900.0*(double)image[i][j][ii][jj]) + 1.0;
		    val *= (255.0 / 2.0);
		    val = floor(val);
		    imageX[p++] = (unsigned char)((int)val);
		}

    _windowname = outfilename;
    _iconname   = outfilename;
    create_X_window(_win, imageX, w*r, v*q);
}

static int binArrSearch(int * searchList, int min_idx, int max_idx, int target) 
{
    register int mid_idx;

    mid_idx = min_idx + (max_idx - min_idx) / 2;
    if (max_idx < min_idx)
	return(-1);
    else if (target < searchList[mid_idx])
	return binArrSearch(searchList, min_idx,     mid_idx - 1, target);
    else if (target > searchList[mid_idx])
	return binArrSearch(searchList, mid_idx + 1, max_idx    , target);
    else
	return mid_idx;
}

static inline int lookup_label(int * intArr, int arrSize, int label)
{
    return ( binArrSearch(intArr, 0, arrSize-1, label) );
}

int print_x11_real_color(char *desc, char *outfilename,
			   int v, int w, int q, int r, int k,
			   int maxLabel,
			   int Labels[v][w]::[q][r], 
			   int X[v][w]::[q][r])
{

    register int
	i, j, ii, jj,
	idx, get_proc;

    int n, minL, maxL,
	l, t, rows, steps, p;

    int RVAL = 1<<10;    /* Number of buckets per loop */
    
    int (*locLabel)[r],
	(*locX)[r],
	(*locRealIm)[r];

    int RealIm[v][w]::[q][r];
    
    intpair_t
	RColor[PROCS]::[RVAL],
	Xpose[PROCS]::[RVAL],
	*locRColor,
	*locXpose;

    Window     *_win;
    unsigned char *imageX;

    on_one {
	_win = (Window *)malloc(sizeof(Window));

	imageX = (unsigned char *)malloc(v*w*q*r*sizeof(unsigned char));
    }

    ii   = mapRow(v,w,MYPROC);
    jj   = mapCol(v,w,MYPROC);
    
    locX = tolocal(X[ii][jj]);
    locLabel = tolocal(Labels[ii][jj]);
    locRealIm = tolocal(RealIm[ii][jj]);
    locRColor = tolocal(RColor[MYPROC]);
    locXpose = tolocal(Xpose[MYPROC]);

    l=0;
    n = v*w*q*r;
    rows = DIVPROCS(RVAL);
    steps = maxLabel / RVAL;
    if (steps*RVAL != maxLabel)
	steps++;

    barrier();

    for (t=0 ; t<steps ; t++) {
	for (i=0 ; i<RVAL ; i++) {
	    locRColor[i].a = 0;
	    locRColor[i].b = 0;
	}
	minL = t*RVAL;
	maxL = (t+1)*RVAL;

	for (i=0 ; i < q ; i++) 
	    for (j=0 ; j < r ; j++) 
		if ((locLabel[i][j] >= minL)&&(locLabel[i][j] < maxL)) {
		    idx = locLabel[i][j] % RVAL;
		    locRColor[idx].a++;
		    locRColor[idx].b += locX[i][j];
		}

	barrier();
	
	for (i=0 ; i<PROCS ; i++) {
	    /* Stagger prefetches using MYPROC */
	    get_proc = (MYPROC + i) % PROCS;
	    bulk_read(&locXpose[rows*get_proc],
		      &(RColor[get_proc][rows*MYPROC]),
		      rows*sizeof(intpair_t));
	    barrier();
	}

	for (i=0 ; i<rows ; i++)
	    for (j=1 ; j<PROCS ; j++) {
		locXpose[j*rows + i].a += locXpose[(j-1)*rows + i].a;
		locXpose[j*rows + i].b += locXpose[(j-1)*rows + i].b;
	    }

	barrier();

	for (i=0 ; i<rows ; i++)
	    if (locXpose[(PROCS-1)*rows + i].a > 0)
		locRColor[(MYPROC*rows) + i].a =
		    locXpose[(PROCS-1)*rows + i].b /
		    locXpose[(PROCS-1)*rows + i].a;
	    else
		locRColor[(MYPROC*rows) + i].a = 0;

	barrier();

	for (i=1 ; i<PROCS ; i++) {
	    /* Stagger prefetches using MYPROC */
	    get_proc = (MYPROC + i) % PROCS;
	    bulk_read(&locRColor[rows*get_proc],
		      &(RColor[get_proc][rows*get_proc]),
		      rows*sizeof(intpair_t));
	    barrier();
	}

	on_one
	    for (i=0; i<RVAL ; i++)
		if (locRColor[i].a > 0)
		    l++;

	/* Color output */
	for (i=0 ; i < q ; i++) 
	    for (j=0 ; j < r ; j++) 
		if ((locLabel[i][j] >= minL)&&(locLabel[i][j] < maxL)) {
		    idx = locLabel[i][j] % RVAL;
		    locRealIm[i][j] = locRColor[idx].a;
		}
    }

    barrier();

    on_one {
	p = 0;
	for (i=0 ; i<v ; i++) 
	    for (ii=0 ; ii < q ; ii++) 
		for (j=0 ; j<w ; j++)
		    for (jj=0 ; jj < r ; jj++)
			imageX[p++] = (unsigned char)RealIm[i][j][ii][jj];

	_windowname = outfilename;
	_iconname   = outfilename;
	create_X_window(_win, imageX, w*r, v*q);

    }

    barrier();
    return(1);
}

int print_x11_real_color_on_one(char *desc, char *outfilename,
		    int v, int w, int q, int r, int k,
		    int Labels[v][w]::[q][r], 
		    int X[v][w]::[q][r])
{
    register int
	i, ii, j, jj,
	idx, count;
    int n, l, num, p;
    int* mapLabel;
    int* mapColor;
    
    edge_t *colorArr;

    register double sum;

    Window     *_win;
    unsigned char *imageX;

    _win = (Window *)malloc(sizeof(Window));

    imageX = (unsigned char *)malloc(v*w*q*r*sizeof(unsigned char));

    n = v*w*q*r;

    if ((colorArr = (edge_t *)malloc(n*sizeof(edge_t)))==NULL)
	fprintf(stderr,"ERROR: cannot malloc colorArr\n");
    if ((mapColor = (int *)malloc(n*sizeof(int)))==NULL)
	fprintf(stderr,"ERROR: cannot malloc mapColor\n");
    if ((mapLabel = (int *)malloc(n*sizeof(int)))==NULL)
	fprintf(stderr,"ERROR: cannot malloc mapLabel\n");

    idx = 0;

    for (i=0 ; i<v ; i++) 
	for (ii=0 ; ii < q ; ii++) 
	    for (j=0 ; j<w ; j++)
		for (jj=0 ; jj < r ; jj++) {
		    colorArr[idx].a := Labels[i][j][ii][jj];
		    colorArr[idx].b := X[i][j][ii][jj];
		    idx++;
		}

    sync();

    fastsort_edge(colorArr, idx);

    l = 0;
    count = 0;
    sum = 0.0;

    for (i=0 ; i<idx-1 ; i++) {
	count++;
	sum += (double)colorArr[i].b;
	if (colorArr[i].a != colorArr[i+1].a) {
	    mapLabel[l] = colorArr[i].a;
	    mapColor[l] = (int)floor(sum / (double)count);
#if 0
	    fprintf(stdout,"(%5d) Mapping Label %4d to color %3d\n",
		    l,mapLabel[l], mapColor[l]);
#endif
	    l++;
	    count = 0;
	    sum = 0.0;
	}
    }

    count++;
    sum += colorArr[idx-1].b;
    mapLabel[l] = colorArr[idx-1].a;
    mapColor[l] = (int)floor(sum / (double)count);
    l++;

    p = 0;
    for (i=0 ; i<v ; i++) 
	for (ii=0 ; ii < q ; ii++) 
	    for (j=0 ; j<w ; j++)
		for (jj=0 ; jj < r ; jj++) {
		    num = lookup_label(mapLabel,l,Labels[i][j][ii][jj]);
		    imageX[p++] = (unsigned char)mapColor[num];
		}

    _windowname = outfilename;
    _iconname   = outfilename;
    create_X_window(_win, imageX, w*r, v*q);
    
    free(mapLabel);
    free(mapColor);
    free(colorArr);

    return(l);
}


#endif