ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/x11image.c
Revision: 2.75
Committed: Tue Aug 16 18:09:53 2011 UTC (12 years, 7 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad4R2P2, rad5R0, rad5R1, rad4R2, rad4R1, rad4R2P1
Changes since 2.74: +2 -2 lines
Log Message:
Minor fixes

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: x11image.c,v 2.74 2011/05/20 02:06:39 greg Exp $";
3 #endif
4 /*
5 * x11image.c - driver for X-windows
6 *
7 * 3/1/90
8 */
9
10 /*
11 * Modified for X11
12 *
13 * January 1990
14 *
15 * Anat Grynberg and Greg Ward
16 */
17
18
19 #include "standard.h"
20
21 #include <string.h>
22 #include <signal.h>
23 #include <unistd.h>
24 #include <sys/types.h>
25 #include <sys/wait.h>
26 #include <X11/Xlib.h>
27 #include <X11/cursorfont.h>
28 #include <X11/Xutil.h>
29 #include <X11/Xatom.h>
30
31 #include "color.h"
32 #include "tonemap.h"
33 #include "clrtab.h"
34 #include "view.h"
35 #include "x11raster.h"
36 #include "random.h"
37
38 #define FONTNAME "8x13" /* text font we'll use */
39
40 #define CTRL(c) ((c)-'@')
41
42 #define BORWIDTH 5 /* border width */
43
44 #define ICONSIZ (8*10) /* maximum icon dimension (even 8) */
45
46 #define FIXWEIGHT 20 /* weight to add for fixation points */
47
48 #define ourscreen DefaultScreen(thedisplay)
49 #define ourroot RootWindow(thedisplay,ourscreen)
50
51 #define revline(x0,y0,x1,y1) XDrawLine(thedisplay,wind,revgc,x0,y0,x1,y1)
52
53 #define redraw(x,y,w,h) patch_raster(wind,(x)-xoff,(y)-yoff,x,y,w,h,ourras)
54
55 double gamcor = 2.2; /* gamma correction */
56 char *gamstr = NULL; /* gamma value override */
57
58 int dither = 1; /* dither colors? */
59 int fast = 0; /* keep picture in Pixmap? */
60
61 char *dispname = NULL; /* our display name */
62
63 Window wind = 0; /* our output window */
64 unsigned long ourblack=0, ourwhite=1; /* black and white for this visual */
65 int maxcolors = 0; /* maximum colors */
66 int greyscale = 0; /* in grey */
67
68 int scale = 0; /* scalefactor; power of two */
69
70 int xoff = 0; /* x image offset */
71 int yoff = 0; /* y image offset */
72
73 int parent = 0; /* number of children, -1 if child */
74 int sequential = 0; /* display images in sequence */
75
76 char *tout = "od"; /* output of 't' command */
77 int tinterv = 0; /* interval between mouse reports */
78
79 int tmflags = TM_F_LINEAR; /* tone mapping flags */
80
81 VIEW ourview = STDVIEW; /* image view parameters */
82 int gotview = 0; /* got parameters from file */
83
84 COLR *scanline; /* scan line buffer */
85 TMbright *lscan; /* encoded luminance scanline */
86 uby8 *cscan; /* encoded chroma scanline */
87 uby8 *pscan; /* compute pixel scanline */
88
89 RESOLU inpres; /* input resolution and ordering */
90 int xmax, ymax; /* picture dimensions */
91 int width, height; /* window size */
92 char *fname = NULL; /* input file name */
93 FILE *fin = NULL; /* input file */
94 long *scanpos = NULL; /* scan line positions in file */
95 int cury = 0; /* current scan location */
96
97 double exposure = 1.0; /* exposure compensation used */
98
99 int wrongformat = 0; /* input in another format? */
100
101 TMstruct *tmGlobal; /* base tone-mapping */
102 TMstruct *tmCurrent; /* curren tone-mapping */
103
104 GC ourgc; /* standard graphics context */
105 GC revgc; /* graphics context with GXinvert */
106
107 int *ourrank; /* our visual class ranking */
108 XVisualInfo ourvis; /* our visual */
109 XRASTER *ourras; /* our stored image */
110 unsigned char *ourdata; /* our image data */
111
112 struct {
113 int xmin, ymin, xsiz, ysiz;
114 } bbox = {0, 0, 0, 0}; /* current bbox */
115
116 char *geometry = NULL; /* geometry specification */
117
118 char icondata[ICONSIZ*ICONSIZ/8]; /* icon bitmap data */
119 int iconwidth = 0, iconheight = 0;
120
121 char *progname;
122
123 char errmsg[128];
124
125 uby8 clrtab[256][3]; /* global color map */
126
127
128 Display *thedisplay;
129 Atom closedownAtom, wmProtocolsAtom;
130
131 int sigrecv;
132
133 void onsig(int i) { sigrecv++; }
134
135 typedef void doboxf_t(COLR *scn, int n, void *);
136
137 static gethfunc headline;
138 static void init(int argc, char **argv);
139 static void quiterr(char *err);
140 static int viscmp(XVisualInfo *v1, XVisualInfo *v2);
141 static void getbestvis(void);
142 static void getras(void);
143 static void getevent(void);
144 static int traceray(int xpos, int ypos);
145 static int docom(XKeyPressedEvent *ekey);
146 static void moveimage(XButtonPressedEvent *ebut);
147 static void getbox(XButtonPressedEvent *ebut);
148 static void trackrays(XButtonPressedEvent *ebut);
149 static void revbox(int x0, int y0, int x1, int y1);
150 static doboxf_t colavg;
151 static doboxf_t addfix;
152 static int avgbox(COLOR cavg);
153 static int dobox(doboxf_t *f, void *p);
154 static void make_tonemap(void);
155 static void tmap_colrs(COLR *scn, int len);
156 static void getmono(void);
157 static void add2icon(int y, COLR *scan);
158 static void getfull(void);
159 static void getgrey(void);
160 static void getmapped(void);
161 static void scale_rcolors(XRASTER *xr, double sf);
162 static int getscan(int y);
163
164
165 int
166 main(int argc, char *argv[])
167 {
168 int i;
169 int pid;
170
171 progname = argv[0];
172 fin = stdin;
173
174 for (i = 1; i < argc; i++)
175 if (argv[i][0] == '-')
176 switch (argv[i][1]) {
177 case 'c': /* number of colors */
178 maxcolors = atoi(argv[++i]);
179 break;
180 case 'b': /* greyscale only */
181 greyscale = !greyscale;
182 break;
183 case 'm': /* monochrome */
184 greyscale = 1;
185 maxcolors = 2;
186 break;
187 case 'd': /* display or dither */
188 if (argv[i][2] == 'i')
189 dispname = argv[++i];
190 else
191 dither = !dither;
192 break;
193 case 'f': /* save pixmap */
194 fast = !fast;
195 break;
196 case 's': /* one at a time */
197 sequential = !sequential;
198 break;
199 case 'o': /* 't' output */
200 tout = argv[i]+2;
201 break;
202 case 't': /* msec interval */
203 tinterv = atoi(argv[++i]);
204 break;
205 case 'e': /* exposure comp. */
206 i++;
207 if (argv[i][0] == 'a') {
208 tmflags = TM_F_CAMERA;
209 break;
210 }
211 if (argv[i][0] == 'h') {
212 tmflags = TM_F_HUMAN;
213 break;
214 }
215 if (argv[i][0] != '+' && argv[i][0] != '-')
216 goto userr;
217 scale = atoi(argv[i]);
218 break;
219 case 'g': /* gamma comp. */
220 if (argv[i][2] == 'e')
221 geometry = argv[++i];
222 else
223 gamstr = argv[++i];
224 break;
225 default:
226 goto userr;
227 }
228 else if (argv[i][0] == '=')
229 geometry = argv[i];
230 else
231 break;
232
233 if (i > argc)
234 goto userr;
235 while (i < argc-1) {
236 sigrecv = 0;
237 signal(SIGCONT, onsig);
238 if ((pid=fork()) == 0) { /* a child for each picture */
239 parent = -1;
240 break;
241 }
242 if (pid < 0)
243 quiterr("fork failed");
244 parent++;
245 while (!sigrecv)
246 pause(); /* wait for wake-up call */
247 i++;
248 }
249 if (i < argc) { /* open picture file */
250 fname = argv[i];
251 fin = fopen(fname, "r");
252 if (fin == NULL)
253 quiterr("cannot open picture file");
254 }
255 /* get header */
256 getheader(fin, headline, NULL);
257 /* get picture dimensions */
258 if (wrongformat || !fgetsresolu(&inpres, fin))
259 quiterr("bad picture format");
260 xmax = scanlen(&inpres);
261 ymax = numscans(&inpres);
262 /* set view parameters */
263 if (gotview && setview(&ourview) != NULL)
264 gotview = 0;
265 if ((scanline = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
266 quiterr("out of memory");
267
268 init(argc, argv); /* get file and open window */
269
270 for ( ; ; )
271 getevent(); /* main loop */
272 userr:
273 fprintf(stderr,
274 "Usage: %s [-di disp][[-ge] spec][-b][-m][-d][-f][-c nclrs][-e spec][-g gamcor][-s][-ospec][-t intvl] hdr ..\n",
275 progname);
276 exit(1);
277 }
278
279
280 static int
281 headline( /* get relevant info from header */
282 char *s,
283 void *p
284 )
285 {
286 char fmt[32];
287
288 if (isexpos(s))
289 exposure *= exposval(s);
290 else if (formatval(fmt, s))
291 wrongformat = strcmp(fmt, COLRFMT);
292 else if (isview(s) && sscanview(&ourview, s) > 0)
293 gotview++;
294 return(0);
295 }
296
297
298 static void
299 init( /* get data and open window */
300 int argc,
301 char **argv
302 )
303 {
304 XSetWindowAttributes ourwinattr;
305 XClassHint xclshints;
306 XWMHints xwmhints;
307 XSizeHints xszhints;
308 XTextProperty windowName, iconName;
309 XGCValues xgcv;
310 char *name;
311 register int i;
312
313 if (fname != NULL) {
314 scanpos = (long *)malloc(ymax*sizeof(long));
315 if (scanpos == NULL)
316 quiterr("out of memory");
317 for (i = 0; i < ymax; i++)
318 scanpos[i] = -1;
319 name = fname;
320 } else
321 name = progname;
322 /* remove directory prefix from name */
323 for (i = strlen(name); i-- > 0; )
324 if (name[i] == '/')
325 break;
326 name += i+1;
327 if ((thedisplay = XOpenDisplay(dispname)) == NULL)
328 quiterr("cannot open display");
329 /* set gamma value */
330 if (gamstr == NULL) /* get it from the X server */
331 gamstr = XGetDefault(thedisplay, "radiance", "gamma");
332 if (gamstr == NULL) /* get it from the environment */
333 gamstr = getenv("DISPLAY_GAMMA");
334 if (gamstr != NULL)
335 gamcor = atof(gamstr);
336 /* get best visual for default screen */
337 getbestvis();
338 /* store image */
339 getras();
340 /* get size and position */
341 xszhints.flags = 0;
342 xszhints.width = xmax; xszhints.height = ymax;
343 if (geometry != NULL) {
344 i = XParseGeometry(geometry, &xszhints.x, &xszhints.y,
345 (unsigned *)&xszhints.width,
346 (unsigned *)&xszhints.height);
347 if ((i&(WidthValue|HeightValue)) == (WidthValue|HeightValue))
348 xszhints.flags |= USSize;
349 else
350 xszhints.flags |= PSize;
351 if ((i&(XValue|YValue)) == (XValue|YValue)) {
352 xszhints.flags |= USPosition;
353 if (i & XNegative)
354 xszhints.x += DisplayWidth(thedisplay,
355 ourscreen)-1-xszhints.width-2*BORWIDTH;
356 if (i & YNegative)
357 xszhints.y += DisplayHeight(thedisplay,
358 ourscreen)-1-xszhints.height-2*BORWIDTH;
359 }
360 }
361 /* open window */
362 i = CWEventMask|CWCursor|CWBackPixel|CWBorderPixel;
363 ourwinattr.border_pixel = ourwhite;
364 ourwinattr.background_pixel = ourblack;
365 if (ourvis.visual != DefaultVisual(thedisplay,ourscreen)) {
366 ourwinattr.colormap = newcmap(thedisplay, ourscreen, ourvis.visual);
367 i |= CWColormap;
368 }
369 ourwinattr.event_mask = ExposureMask|KeyPressMask|ButtonPressMask|
370 ButtonReleaseMask|ButtonMotionMask|StructureNotifyMask;
371 ourwinattr.cursor = XCreateFontCursor(thedisplay, XC_diamond_cross);
372 wind = XCreateWindow(thedisplay, ourroot, xszhints.x, xszhints.y,
373 xszhints.width, xszhints.height, BORWIDTH,
374 ourvis.depth, InputOutput, ourvis.visual,
375 i, &ourwinattr);
376 if (wind == 0)
377 quiterr("cannot create window");
378 width = xmax;
379 height = ymax;
380 /* prepare graphics drawing context */
381 if ((xgcv.font = XLoadFont(thedisplay, FONTNAME)) == 0)
382 quiterr("cannot get font");
383 xgcv.foreground = ourblack;
384 xgcv.background = ourwhite;
385 ourgc = XCreateGC(thedisplay, wind, GCForeground|GCBackground|
386 GCFont, &xgcv);
387 xgcv.function = GXinvert;
388 revgc = XCreateGC(thedisplay, wind, GCForeground|GCBackground|
389 GCFunction, &xgcv);
390
391 /* set up the window manager */
392 xwmhints.flags = InputHint|IconPixmapHint;
393 xwmhints.input = True;
394 xwmhints.icon_pixmap = XCreateBitmapFromData(thedisplay,
395 wind, icondata, iconwidth, iconheight);
396
397 windowName.encoding = iconName.encoding = XA_STRING;
398 windowName.format = iconName.format = 8;
399 windowName.value = (u_char *)name;
400 windowName.nitems = strlen((char *)windowName.value);
401 iconName.value = (u_char *)name;
402 iconName.nitems = strlen((char *)windowName.value);
403
404 xclshints.res_name = NULL;
405 xclshints.res_class = "Ximage";
406 XSetWMProperties(thedisplay, wind, &windowName, &iconName,
407 argv, argc, &xszhints, &xwmhints, &xclshints);
408 closedownAtom = XInternAtom(thedisplay, "WM_DELETE_WINDOW", False);
409 wmProtocolsAtom = XInternAtom(thedisplay, "WM_PROTOCOLS", False);
410 XSetWMProtocols(thedisplay, wind, &closedownAtom, 1);
411
412 XMapWindow(thedisplay, wind);
413 } /* end of init */
414
415
416 static void
417 quiterr( /* print message and exit */
418 char *err
419 )
420 {
421 register int es;
422 int cs;
423
424 if ( (es = (err != NULL)) )
425 fprintf(stderr, "%s: %s: %s\n", progname,
426 fname==NULL?"<stdin>":fname, err);
427 if (thedisplay != NULL)
428 XCloseDisplay(thedisplay);
429 if ((parent < 0) & (sigrecv == 0))
430 kill(getppid(), SIGCONT);
431 while (parent > 0 && wait(&cs) != -1) { /* wait for any children */
432 if (es == 0)
433 es = cs>>8 & 0xff;
434 parent--;
435 }
436 exit(es);
437 }
438
439
440 static int
441 viscmp( /* compare visual to see which is better, descending */
442 register XVisualInfo *v1,
443 register XVisualInfo *v2
444 )
445 {
446 int bad1 = 0, bad2 = 0;
447 register int *rp;
448
449 if (v1->class == v2->class) {
450 if ((v1->class == TrueColor) | (v1->class == DirectColor)) {
451 /* prefer 24-bit */
452 if ((v1->depth == 24) & (v2->depth > 24))
453 return(-1);
454 if ((v1->depth > 24) & (v2->depth == 24))
455 return(1);
456 /* go for maximum depth otherwise */
457 return(v2->depth - v1->depth);
458 }
459 /* don't be too greedy */
460 if ((maxcolors <= 1<<v1->depth) & (maxcolors <= 1<<v2->depth))
461 return(v1->depth - v2->depth);
462 return(v2->depth - v1->depth);
463 }
464 /* prefer Pseudo when < 15-bit */
465 if ((v1->class == TrueColor) | (v1->class == DirectColor) &&
466 v1->depth < 15)
467 bad1 = 1;
468 if ((v2->class == TrueColor) | (v2->class == DirectColor) &&
469 v2->depth < 15)
470 bad2 = -1;
471 if (bad1 | bad2)
472 return(bad1+bad2);
473 /* otherwise, use class ranking */
474 for (rp = ourrank; *rp != -1; rp++) {
475 if (v1->class == *rp)
476 return(-1);
477 if (v2->class == *rp)
478 return(1);
479 }
480 return(0);
481 }
482
483
484 static void
485 getbestvis(void) /* get the best visual for this screen */
486 {
487 #ifdef DEBUG
488 static char vistype[][12] = {
489 "StaticGray",
490 "GrayScale",
491 "StaticColor",
492 "PseudoColor",
493 "TrueColor",
494 "DirectColor"
495 };
496 #endif
497 static int rankings[3][6] = {
498 {TrueColor,DirectColor,PseudoColor,GrayScale,StaticGray,-1},
499 {PseudoColor,GrayScale,StaticGray,-1},
500 {PseudoColor,GrayScale,StaticGray,-1}
501 };
502 XVisualInfo *xvi;
503 int vismatched;
504 register int i, j;
505
506 if (greyscale) {
507 ourrank = rankings[2];
508 if (maxcolors < 2) maxcolors = 256;
509 } else if (maxcolors >= 2 && maxcolors <= 256)
510 ourrank = rankings[1];
511 else {
512 ourrank = rankings[0];
513 maxcolors = 256;
514 }
515 /* find best visual */
516 ourvis.screen = ourscreen;
517 xvi = XGetVisualInfo(thedisplay,VisualScreenMask,&ourvis,&vismatched);
518 if (xvi == NULL)
519 quiterr("no visuals for this screen!");
520 #ifdef DEBUG
521 fprintf(stderr, "Supported visuals:\n");
522 for (i = 0; i < vismatched; i++)
523 fprintf(stderr, "\ttype %s, depth %d\n",
524 vistype[xvi[i].class], xvi[i].depth);
525 #endif
526 for (i = 0, j = 1; j < vismatched; j++)
527 if (viscmp(&xvi[i],&xvi[j]) > 0)
528 i = j;
529 /* compare to least acceptable */
530 for (j = 0; ourrank[j++] != -1; )
531 ;
532 ourvis.class = ourrank[--j];
533 ourvis.depth = 1;
534 if (viscmp(&xvi[i],&ourvis) > 0)
535 quiterr("inadequate visuals on this screen");
536 /* OK, we'll use it */
537 ourvis = xvi[i];
538 #ifdef DEBUG
539 fprintf(stderr, "Selected visual type %s, depth %d\n",
540 vistype[ourvis.class], ourvis.depth);
541 #endif
542 /* make appropriate adjustments */
543 if (ourvis.class == GrayScale || ourvis.class == StaticGray)
544 greyscale = 1;
545 if (ourvis.depth <= 8 && ourvis.colormap_size < maxcolors)
546 maxcolors = ourvis.colormap_size;
547 if (ourvis.class == StaticGray) {
548 ourblack = 0;
549 ourwhite = 255;
550 } else if (ourvis.class == PseudoColor) {
551 ourblack = BlackPixel(thedisplay,ourscreen);
552 ourwhite = WhitePixel(thedisplay,ourscreen);
553 if ((ourblack|ourwhite) & ~255L) {
554 ourblack = 0;
555 ourwhite = 1;
556 }
557 if (maxcolors > 4)
558 maxcolors -= 2;
559 } else {
560 ourblack = 0;
561 ourwhite = ourvis.red_mask|ourvis.green_mask|ourvis.blue_mask;
562 }
563 XFree((char *)xvi);
564 }
565
566
567 static void
568 getras(void) /* get raster file */
569 {
570 if (maxcolors <= 2) { /* monochrome */
571 ourdata = (unsigned char *)malloc(ymax*((xmax+7)/8));
572 if (ourdata == NULL)
573 goto fail;
574 ourras = make_raster(thedisplay, &ourvis, 1, (char *)ourdata,
575 xmax, ymax, 8);
576 if (ourras == NULL)
577 goto fail;
578 getmono();
579 } else if ((ourvis.class == TrueColor) | (ourvis.class == DirectColor)) {
580 int datsiz = ourvis.depth>16 ? sizeof(int32) : sizeof(int16);
581 ourdata = (unsigned char *)malloc(datsiz*xmax*ymax);
582 if (ourdata == NULL)
583 goto fail;
584 ourras = make_raster(thedisplay, &ourvis, datsiz*8,
585 (char *)ourdata, xmax, ymax, datsiz*8);
586 if (ourras == NULL)
587 goto fail;
588 getfull();
589 } else {
590 ourdata = (unsigned char *)malloc(xmax*ymax);
591 if (ourdata == NULL)
592 goto fail;
593 ourras = make_raster(thedisplay, &ourvis, 8, (char *)ourdata,
594 xmax, ymax, 8);
595 if (ourras == NULL)
596 goto fail;
597 if (greyscale)
598 getgrey();
599 else
600 getmapped();
601 if (ourvis.class != StaticGray && !init_rcolors(ourras,clrtab))
602 goto fail;
603 }
604 return;
605 fail:
606 quiterr("could not create raster image");
607 }
608
609
610 static void
611 getevent(void) /* process the next event */
612 {
613 XEvent xev;
614
615 XNextEvent(thedisplay, &xev);
616 switch ((int)xev.type) {
617 case KeyPress:
618 docom(&xev.xkey);
619 break;
620 case ConfigureNotify:
621 width = xev.xconfigure.width;
622 height = xev.xconfigure.height;
623 break;
624 case MapNotify:
625 map_rcolors(ourras, wind);
626 if (fast)
627 make_rpixmap(ourras, wind);
628 if ((!sequential) & (parent < 0) & (sigrecv == 0)) {
629 kill(getppid(), SIGCONT);
630 sigrecv--;
631 }
632 break;
633 case UnmapNotify:
634 if (!fast)
635 unmap_rcolors(ourras);
636 break;
637 case Expose:
638 redraw(xev.xexpose.x, xev.xexpose.y,
639 xev.xexpose.width, xev.xexpose.height);
640 break;
641 case ButtonPress:
642 if (xev.xbutton.state & (ShiftMask|ControlMask))
643 moveimage(&xev.xbutton);
644 else
645 switch (xev.xbutton.button) {
646 case Button1:
647 getbox(&xev.xbutton);
648 break;
649 case Button2:
650 traceray(xev.xbutton.x, xev.xbutton.y);
651 break;
652 case Button3:
653 trackrays(&xev.xbutton);
654 break;
655 }
656 break;
657 case ClientMessage:
658 if ((xev.xclient.message_type == wmProtocolsAtom) &&
659 (xev.xclient.data.l[0] == closedownAtom))
660 quiterr(NULL);
661 break;
662 }
663 }
664
665
666 static int
667 traceray( /* print requested pixel data */
668 int xpos,
669 int ypos
670 )
671 {
672 RREAL hv[2];
673 FVECT rorg, rdir;
674 COLOR cval;
675 register char *cp;
676
677 bbox.xmin = xpos; bbox.xsiz = 1;
678 bbox.ymin = ypos; bbox.ysiz = 1;
679 avgbox(cval);
680 scalecolor(cval, 1./exposure);
681 pix2loc(hv, &inpres, xpos-xoff, ypos-yoff);
682 if (!gotview || viewray(rorg, rdir, &ourview, hv[0], hv[1]) < 0)
683 rorg[0] = rorg[1] = rorg[2] =
684 rdir[0] = rdir[1] = rdir[2] = 0.;
685
686 for (cp = tout; *cp; cp++) /* print what they asked for */
687 switch (*cp) {
688 case 'o': /* origin */
689 printf("%e %e %e ", rorg[0], rorg[1], rorg[2]);
690 break;
691 case 'd': /* direction */
692 printf("%e %e %e ", rdir[0], rdir[1], rdir[2]);
693 break;
694 case 'v': /* radiance value */
695 printf("%e %e %e ", colval(cval,RED),
696 colval(cval,GRN), colval(cval,BLU));
697 break;
698 case 'l': /* luminance */
699 printf("%e ", luminance(cval));
700 break;
701 case 'p': /* pixel position */
702 printf("%d %d ", (int)(hv[0]*inpres.xr),
703 (int)(hv[1]*inpres.yr));
704 break;
705 }
706 putchar('\n');
707 fflush(stdout);
708 return(0);
709 }
710
711
712 static int
713 docom( /* execute command */
714 XKeyPressedEvent *ekey
715 )
716 {
717 char buf[80];
718 COLOR cval;
719 XColor cvx;
720 int com, n;
721 double comp;
722 RREAL hv[2];
723
724 n = XLookupString(ekey, buf, sizeof(buf), NULL, NULL);
725 if (n == 0)
726 return(0);
727 com = buf[0];
728 switch (com) { /* interpret command */
729 case 'q':
730 case 'Q':
731 case CTRL('D'): /* quit */
732 quiterr(NULL);
733 case '\n':
734 case '\r':
735 case 'l':
736 case 'c': /* value */
737 if (!avgbox(cval))
738 return(-1);
739 switch (com) {
740 case '\n':
741 case '\r': /* radiance */
742 sprintf(buf, "%.3f", intens(cval)/exposure);
743 break;
744 case 'l': /* luminance */
745 sprintf(buf, "%.1fL", luminance(cval)/exposure);
746 break;
747 case 'c': /* color */
748 comp = pow(2.0, (double)scale);
749 sprintf(buf, "(%.2f,%.2f,%.2f)",
750 colval(cval,RED)*comp,
751 colval(cval,GRN)*comp,
752 colval(cval,BLU)*comp);
753 break;
754 }
755 XDrawImageString(thedisplay, wind, ourgc,
756 bbox.xmin, bbox.ymin+bbox.ysiz, buf, strlen(buf));
757 return(0);
758 case 'i': /* identify (contour) */
759 if (ourras->pixels == NULL)
760 return(-1);
761 n = ourdata[ekey->x-xoff+xmax*(ekey->y-yoff)];
762 n = ourras->pmap[n];
763 cvx.pixel = ourras->cdefs[n].pixel;
764 cvx.red = random() & 65535;
765 cvx.green = random() & 65535;
766 cvx.blue = random() & 65535;
767 cvx.flags = DoRed|DoGreen|DoBlue;
768 XStoreColor(thedisplay, ourras->cmap, &cvx);
769 return(0);
770 case 'p': /* position */
771 pix2loc(hv, &inpres, ekey->x-xoff, ekey->y-yoff);
772 sprintf(buf, "(%d,%d)", (int)(hv[0]*inpres.xr),
773 (int)(hv[1]*inpres.yr));
774 XDrawImageString(thedisplay, wind, ourgc, ekey->x, ekey->y,
775 buf, strlen(buf));
776 return(0);
777 case 't': /* trace */
778 return(traceray(ekey->x, ekey->y));
779 case 'a': /* auto exposure */
780 if (fname == NULL)
781 return(-1);
782 tmflags = TM_F_CAMERA;
783 strcpy(buf, "auto exposure...");
784 goto remap;
785 case 'h': /* human response */
786 if (fname == NULL)
787 return(-1);
788 tmflags = TM_F_HUMAN;
789 strcpy(buf, "human exposure...");
790 goto remap;
791 case '=': /* adjust exposure */
792 case '@': /* adaptation level */
793 if (!avgbox(cval))
794 return(-1);
795 comp = bright(cval);
796 if (comp < 1e-20) {
797 XBell(thedisplay, 0);
798 return(-1);
799 }
800 if (com == '@')
801 comp = 106./exposure/
802 pow(1.219+pow(comp*WHTEFFICACY/exposure,.4),2.5);
803 else
804 comp = .5/comp;
805 comp = log(comp)/.69315 - scale;
806 n = comp < 0 ? comp-.5 : comp+.5 ; /* round */
807 if (tmflags != TM_F_LINEAR)
808 tmflags = TM_F_LINEAR; /* turn off tone mapping */
809 else {
810 if (n == 0) /* else check if any change */
811 return(0);
812 scale_rcolors(ourras, pow(2.0, (double)n));
813 }
814 scale += n;
815 sprintf(buf, "%+d", scale);
816 remap:
817 XDrawImageString(thedisplay, wind, ourgc,
818 bbox.xmin, bbox.ymin+bbox.ysiz, buf, strlen(buf));
819 XFlush(thedisplay);
820 /* free(ourdata); This is done in XDestroyImage()! */
821 free_raster(ourras);
822 getras();
823 /* fall through */
824 case CTRL('R'): /* redraw */
825 case CTRL('L'):
826 unmap_rcolors(ourras);
827 XClearWindow(thedisplay, wind);
828 map_rcolors(ourras, wind);
829 if (fast)
830 make_rpixmap(ourras, wind);
831 redraw(0, 0, width, height);
832 return(0);
833 case 'f': /* turn on fast redraw */
834 fast = 1;
835 make_rpixmap(ourras, wind);
836 return(0);
837 case 'F': /* turn off fast redraw */
838 fast = 0;
839 free_rpixmap(ourras);
840 return(0);
841 case '0': /* recenter origin */
842 if ((xoff == 0) & (yoff == 0))
843 return(0);
844 xoff = yoff = 0;
845 XClearWindow(thedisplay, wind);
846 redraw(0, 0, width, height);
847 return(0);
848 case ' ': /* clear */
849 redraw(bbox.xmin, bbox.ymin, bbox.xsiz, bbox.ysiz);
850 return(0);
851 default:
852 XBell(thedisplay, 0);
853 return(-1);
854 }
855 }
856
857
858 static void
859 moveimage( /* shift the image */
860 XButtonPressedEvent *ebut
861 )
862 {
863 XEvent e;
864 int mxo, myo;
865
866 XMaskEvent(thedisplay, ButtonReleaseMask|ButtonMotionMask, &e);
867 while (e.type == MotionNotify) {
868 mxo = e.xmotion.x;
869 myo = e.xmotion.y;
870 revline(ebut->x, ebut->y, mxo, myo);
871 revbox(xoff+mxo-ebut->x, yoff+myo-ebut->y,
872 xoff+mxo-ebut->x+xmax, yoff+myo-ebut->y+ymax);
873 XMaskEvent(thedisplay,ButtonReleaseMask|ButtonMotionMask,&e);
874 revline(ebut->x, ebut->y, mxo, myo);
875 revbox(xoff+mxo-ebut->x, yoff+myo-ebut->y,
876 xoff+mxo-ebut->x+xmax, yoff+myo-ebut->y+ymax);
877 }
878 xoff += e.xbutton.x - ebut->x;
879 yoff += e.xbutton.y - ebut->y;
880 XClearWindow(thedisplay, wind);
881 redraw(0, 0, width, height);
882 }
883
884
885 static void
886 getbox( /* get new bbox */
887 XButtonPressedEvent *ebut
888 )
889 {
890 XEvent e;
891
892 XMaskEvent(thedisplay, ButtonReleaseMask|ButtonMotionMask, &e);
893 while (e.type == MotionNotify) {
894 revbox(ebut->x, ebut->y, bbox.xmin = e.xmotion.x, bbox.ymin = e.xmotion.y);
895 XMaskEvent(thedisplay,ButtonReleaseMask|ButtonMotionMask,&e);
896 revbox(ebut->x, ebut->y, bbox.xmin, bbox.ymin);
897 }
898 bbox.xmin = e.xbutton.x<0 ? 0 : (e.xbutton.x>=width ? width-1 : e.xbutton.x);
899 bbox.ymin = e.xbutton.y<0 ? 0 : (e.xbutton.y>=height ? height-1 : e.xbutton.y);
900 if (bbox.xmin > ebut->x) {
901 bbox.xsiz = bbox.xmin - ebut->x + 1;
902 bbox.xmin = ebut->x;
903 } else {
904 bbox.xsiz = ebut->x - bbox.xmin + 1;
905 }
906 if (bbox.ymin > ebut->y) {
907 bbox.ysiz = bbox.ymin - ebut->y + 1;
908 bbox.ymin = ebut->y;
909 } else {
910 bbox.ysiz = ebut->y - bbox.ymin + 1;
911 }
912 }
913
914
915 static void
916 trackrays( /* trace rays as mouse moves */
917 XButtonPressedEvent *ebut
918 )
919 {
920 XEvent e;
921 unsigned long lastrept;
922
923 traceray(ebut->x, ebut->y);
924 lastrept = ebut->time;
925 XMaskEvent(thedisplay, ButtonReleaseMask|ButtonMotionMask, &e);
926 while (e.type == MotionNotify) {
927 if (e.xmotion.time >= lastrept + tinterv) {
928 traceray(e.xmotion.x, e.xmotion.y);
929 lastrept = e.xmotion.time;
930 }
931 XMaskEvent(thedisplay,ButtonReleaseMask|ButtonMotionMask,&e);
932 }
933 }
934
935
936 static void
937 revbox( /* draw bbox with reversed lines */
938 int x0,
939 int y0,
940 int x1,
941 int y1
942 )
943 {
944 revline(x0, y0, x1, y0);
945 revline(x0, y1, x1, y1);
946 revline(x0, y0, x0, y1);
947 revline(x1, y0, x1, y1);
948 }
949
950
951 static void
952 colavg(
953 register COLR *scn,
954 register int n,
955 void *cavg
956 )
957 {
958 COLOR col;
959
960 while (n--) {
961 colr_color(col, *scn++);
962 addcolor((COLORV*)cavg, col);
963 }
964 }
965
966
967 static int
968 avgbox( /* average color over current bbox */
969 COLOR cavg
970 )
971 {
972 double d;
973 register int rval;
974
975 setcolor(cavg, 0., 0., 0.);
976 rval = dobox(colavg, (void *)cavg);
977 if (rval > 0) {
978 d = 1./rval;
979 scalecolor(cavg, d);
980 }
981 return(rval);
982 }
983
984
985 static int
986 dobox( /* run function over bbox */
987 //void (*f)(), /* function to call for each subscan */
988 doboxf_t *f, /* function to call for each subscan */
989 void *p /* pointer to private data */
990 )
991 {
992 int left, right, top, bottom;
993 int y;
994
995 left = bbox.xmin - xoff;
996 right = left + bbox.xsiz;
997 if (left < 0)
998 left = 0;
999 if (right > xmax)
1000 right = xmax;
1001 if (left >= right)
1002 return(0);
1003 top = bbox.ymin - yoff;
1004 bottom = top + bbox.ysiz;
1005 if (top < 0)
1006 top = 0;
1007 if (bottom > ymax)
1008 bottom = ymax;
1009 if (top >= bottom)
1010 return(0);
1011 for (y = top; y < bottom; y++) {
1012 if (getscan(y) == -1)
1013 return(-1);
1014 (*f)(scanline+left, right-left, p);
1015 }
1016 return((right-left)*(bottom-top));
1017 }
1018
1019
1020 static void
1021 addfix( /* add fixation points to histogram */
1022 COLR *scn,
1023 int n,
1024 void *p
1025 )
1026 {
1027 TMstruct * tms = (TMstruct *)p;
1028
1029 if (tmCvColrs(tms, lscan, TM_NOCHROM, scn, n))
1030 goto tmerr;
1031 if (tmAddHisto(tms, lscan, n, FIXWEIGHT))
1032 goto tmerr;
1033 return;
1034 tmerr:
1035 quiterr("tone mapping error");
1036 }
1037
1038
1039 static void
1040 make_tonemap(void) /* initialize tone mapping */
1041 {
1042 int flags, y;
1043
1044 if (tmflags != TM_F_LINEAR && fname == NULL) {
1045 fprintf(stderr, "%s: cannot adjust tone of standard input\n",
1046 progname);
1047 tmflags = TM_F_LINEAR;
1048 }
1049 if (tmflags == TM_F_LINEAR) { /* linear with clamping */
1050 setcolrcor(pow, 1.0/gamcor);
1051 return;
1052 }
1053 flags = tmflags; /* histogram adjustment */
1054 if (greyscale) flags |= TM_F_BW;
1055 if (tmGlobal != NULL) { /* reuse old histogram if one */
1056 tmDone(tmCurrent); tmCurrent = NULL;
1057 tmGlobal->flags = flags;
1058 } else { /* else initialize */
1059 if ((lscan = (TMbright *)malloc(xmax*sizeof(TMbright))) == NULL)
1060 goto memerr;
1061 if (greyscale) {
1062 cscan = TM_NOCHROM;
1063 if ((pscan = (uby8 *)malloc(sizeof(uby8)*xmax)) == NULL)
1064 goto memerr;
1065 } else if ((pscan=cscan = (uby8 *)malloc(3*sizeof(uby8)*xmax))
1066 == NULL)
1067 goto memerr;
1068 /* initialize tm library */
1069 tmGlobal = tmInit(flags, stdprims, gamcor);
1070 if (tmGlobal == NULL)
1071 goto memerr;
1072 if (tmSetSpace(tmGlobal, stdprims, WHTEFFICACY/exposure, NULL))
1073 goto tmerr;
1074 /* compute picture histogram */
1075 for (y = 0; y < ymax; y++) {
1076 getscan(y);
1077 if (tmCvColrs(tmGlobal, lscan, TM_NOCHROM,
1078 scanline, xmax))
1079 goto tmerr;
1080 if (tmAddHisto(tmGlobal, lscan, xmax, 1))
1081 goto tmerr;
1082 }
1083 }
1084 tmCurrent = tmDup(tmGlobal); /* add fixations to duplicate map */
1085 dobox(addfix, (void *)tmCurrent);
1086 /* (re)compute tone mapping */
1087 if (tmComputeMapping(tmCurrent, gamcor, 0., 0.))
1088 goto tmerr;
1089 return;
1090 memerr:
1091 quiterr("out of memory in make_tonemap");
1092 tmerr:
1093 quiterr("tone mapping error");
1094 }
1095
1096
1097 static void
1098 tmap_colrs( /* apply tone mapping to scanline */
1099 register COLR *scn,
1100 int len
1101 )
1102 {
1103 register uby8 *ps;
1104
1105 if (tmflags == TM_F_LINEAR) {
1106 if (scale)
1107 shiftcolrs(scn, len, scale);
1108 colrs_gambs(scn, len);
1109 return;
1110 }
1111 if (len > xmax)
1112 quiterr("code error 1 in tmap_colrs");
1113 if (tmCvColrs(tmCurrent, lscan, cscan, scn, len))
1114 goto tmerr;
1115 if (tmMapPixels(tmCurrent, pscan, lscan, cscan, len))
1116 goto tmerr;
1117 ps = pscan;
1118 if (greyscale)
1119 while (len--) {
1120 scn[0][RED] = scn[0][GRN] = scn[0][BLU] = *ps++;
1121 scn[0][EXP] = COLXS;
1122 scn++;
1123 }
1124 else
1125 while (len--) {
1126 scn[0][RED] = *ps++;
1127 scn[0][GRN] = *ps++;
1128 scn[0][BLU] = *ps++;
1129 scn[0][EXP] = COLXS;
1130 scn++;
1131 }
1132 return;
1133 tmerr:
1134 quiterr("tone mapping error");
1135 }
1136
1137
1138 static void
1139 getmono(void) /* get monochrome data */
1140 {
1141 register unsigned char *dp;
1142 register int x, err;
1143 int y, errp;
1144 short *cerr;
1145
1146 if ((cerr = (short *)calloc(xmax,sizeof(short))) == NULL)
1147 quiterr("out of memory in getmono");
1148 dp = ourdata - 1;
1149 for (y = 0; y < ymax; y++) {
1150 getscan(y);
1151 add2icon(y, scanline);
1152 normcolrs(scanline, xmax, scale);
1153 err = 0;
1154 for (x = 0; x < xmax; x++) {
1155 if (!(x&7))
1156 *++dp = 0;
1157 errp = err;
1158 err += normbright(scanline[x]) + cerr[x];
1159 if (err > 127)
1160 err -= 255;
1161 else
1162 *dp |= 1<<(7-(x&07));
1163 err /= 3;
1164 cerr[x] = err + errp;
1165 }
1166 }
1167 free((void *)cerr);
1168 }
1169
1170
1171 static void
1172 add2icon( /* add a scanline to our icon data */
1173 int y,
1174 COLR *scan
1175 )
1176 {
1177 static short cerr[ICONSIZ];
1178 static int ynext;
1179 static char *dp;
1180 COLR clr;
1181 register int err;
1182 register int x, ti;
1183 int errp;
1184
1185 if (iconheight == 0) { /* initialize */
1186 if (xmax <= ICONSIZ && ymax <= ICONSIZ) {
1187 iconwidth = xmax;
1188 iconheight = ymax;
1189 } else if (xmax > ymax) {
1190 iconwidth = ICONSIZ;
1191 iconheight = ICONSIZ*ymax/xmax;
1192 if (iconheight < 1)
1193 iconheight = 1;
1194 } else {
1195 iconwidth = ICONSIZ*xmax/ymax;
1196 if (iconwidth < 1)
1197 iconwidth = 1;
1198 iconheight = ICONSIZ;
1199 }
1200 ynext = 0;
1201 dp = icondata - 1;
1202 }
1203 if (y < ynext*ymax/iconheight) /* skip this one */
1204 return;
1205 err = 0;
1206 for (x = 0; x < iconwidth; x++) {
1207 if (!(x&7))
1208 *++dp = 0;
1209 errp = err;
1210 ti = x*xmax/iconwidth;
1211 copycolr(clr, scan[ti]);
1212 normcolrs(&clr, 1, scale);
1213 err += normbright(clr) + cerr[x];
1214 if (err > 127)
1215 err -= 255;
1216 else
1217 *dp |= 1<<(x&07);
1218 err /= 3;
1219 cerr[x] = err + errp;
1220 }
1221 ynext++;
1222 }
1223
1224
1225 static void
1226 getfull(void) /* get full (24-bit) data */
1227 {
1228 int y;
1229 register uint32 *dp;
1230 register uint16 *dph;
1231 register int x;
1232 /* initialize tone mapping */
1233 make_tonemap();
1234 /* read and convert file */
1235 dp = (uint32 *)ourdata;
1236 dph = (uint16 *)ourdata;
1237 for (y = 0; y < ymax; y++) {
1238 getscan(y);
1239 add2icon(y, scanline);
1240 tmap_colrs(scanline, xmax);
1241 switch (ourras->image->blue_mask) {
1242 case 0xff: /* 24-bit RGB */
1243 for (x = 0; x < xmax; x++)
1244 *dp++ = (uint32)scanline[x][RED] << 16 |
1245 (uint32)scanline[x][GRN] << 8 |
1246 (uint32)scanline[x][BLU] ;
1247 break;
1248 case 0xff0000: /* 24-bit BGR */
1249 for (x = 0; x < xmax; x++)
1250 *dp++ = (uint32)scanline[x][RED] |
1251 (uint32)scanline[x][GRN] << 8 |
1252 (uint32)scanline[x][BLU] << 16 ;
1253 break;
1254 #if 0
1255 case 0x1f: /* 15-bit RGB */
1256 for (x = 0; x < xmax; x++)
1257 *dph++ = (scanline[x][RED] << 7 & 0x7c00) |
1258 (scanline[x][GRN] << 2 & 0x3e0) |
1259 (unsigned)scanline[x][BLU] >> 3 ;
1260 break;
1261 case 0x7c00: /* 15-bit BGR */
1262 for (x = 0; x < xmax; x++)
1263 *dph++ = (unsigned)scanline[x][RED] >> 3 |
1264 (scanline[x][GRN] << 2 & 0x3e0) |
1265 (scanline[x][BLU] << 7 & 0x7c00) ;
1266 break;
1267 #endif
1268 default: /* unknown */
1269 if (ourvis.depth > 16)
1270 for (x = 0; x < xmax; x++) {
1271 *dp = ourras->image->red_mask &
1272 ourras->image->red_mask*scanline[x][RED]/255;
1273 *dp |= ourras->image->green_mask &
1274 ourras->image->green_mask*scanline[x][GRN]/255;
1275 *dp++ |= ourras->image->blue_mask &
1276 ourras->image->blue_mask*scanline[x][BLU]/255;
1277 }
1278 else
1279 for (x = 0; x < xmax; x++) {
1280 *dph = ourras->image->red_mask &
1281 ourras->image->red_mask*scanline[x][RED]/255;
1282 *dph |= ourras->image->green_mask &
1283 ourras->image->green_mask*scanline[x][GRN]/255;
1284 *dph++ |= ourras->image->blue_mask &
1285 ourras->image->blue_mask*scanline[x][BLU]/255;
1286 }
1287 break;
1288 }
1289 }
1290 }
1291
1292
1293 static void
1294 getgrey(void) /* get greyscale data */
1295 {
1296 int y;
1297 register unsigned char *dp;
1298 register int x;
1299 /* initialize tone mapping */
1300 make_tonemap();
1301 /* read and convert file */
1302 dp = ourdata;
1303 for (y = 0; y < ymax; y++) {
1304 getscan(y);
1305 add2icon(y, scanline);
1306 tmap_colrs(scanline, xmax);
1307 if (maxcolors < 256)
1308 for (x = 0; x < xmax; x++)
1309 *dp++ = ((int32)scanline[x][GRN] *
1310 maxcolors + maxcolors/2) >> 8;
1311 else
1312 for (x = 0; x < xmax; x++)
1313 *dp++ = scanline[x][GRN];
1314 }
1315 for (x = 0; x < maxcolors; x++)
1316 clrtab[x][RED] = clrtab[x][GRN] =
1317 clrtab[x][BLU] = ((int32)x*256 + 128)/maxcolors;
1318 }
1319
1320
1321 static void
1322 getmapped(void) /* get color-mapped data */
1323 {
1324 int y;
1325 /* make sure we can do it first */
1326 if (fname == NULL)
1327 quiterr("cannot map colors from standard input");
1328 /* initialize tone mapping */
1329 make_tonemap();
1330 /* make histogram */
1331 if (new_histo((int32)xmax*ymax) == -1)
1332 quiterr("cannot initialize histogram");
1333 for (y = 0; y < ymax; y++) {
1334 if (getscan(y) < 0)
1335 break;
1336 add2icon(y, scanline);
1337 tmap_colrs(scanline, xmax);
1338 cnt_colrs(scanline, xmax);
1339 }
1340 /* map pixels */
1341 if (!new_clrtab(maxcolors))
1342 quiterr("cannot create color map");
1343 for (y = 0; y < ymax; y++) {
1344 getscan(y);
1345 tmap_colrs(scanline, xmax);
1346 if (dither)
1347 dith_colrs(ourdata+y*xmax, scanline, xmax);
1348 else
1349 map_colrs(ourdata+y*xmax, scanline, xmax);
1350 }
1351 }
1352
1353
1354 static void
1355 scale_rcolors( /* scale color map */
1356 register XRASTER *xr,
1357 double sf
1358 )
1359 {
1360 register int i;
1361 long maxv;
1362
1363 if (xr->pixels == NULL)
1364 return;
1365
1366 sf = pow(sf, 1.0/gamcor);
1367 maxv = 65535/sf;
1368
1369 for (i = xr->ncolors; i--; ) {
1370 xr->cdefs[i].red = xr->cdefs[i].red > maxv ?
1371 65535 :
1372 xr->cdefs[i].red * sf;
1373 xr->cdefs[i].green = xr->cdefs[i].green > maxv ?
1374 65535 :
1375 xr->cdefs[i].green * sf;
1376 xr->cdefs[i].blue = xr->cdefs[i].blue > maxv ?
1377 65535 :
1378 xr->cdefs[i].blue * sf;
1379 }
1380 XStoreColors(thedisplay, xr->cmap, xr->cdefs, xr->ncolors);
1381 }
1382
1383
1384 static int
1385 getscan(
1386 int y
1387 )
1388 {
1389 static int trunced = -1; /* truncated file? */
1390 skipit:
1391 if (trunced >= 0 && y >= trunced) {
1392 memset(scanline, '\0', xmax*sizeof(COLR));
1393 return(-1);
1394 }
1395 if (y != cury) {
1396 if (scanpos == NULL || scanpos[y] == -1)
1397 return(-1);
1398 if (fseek(fin, scanpos[y], 0) == -1)
1399 quiterr("fseek error");
1400 cury = y;
1401 } else if (scanpos != NULL && scanpos[y] == -1)
1402 scanpos[y] = ftell(fin);
1403
1404 if (freadcolrs(scanline, xmax, fin) < 0) {
1405 fprintf(stderr, "%s: %s: unfinished picture\n",
1406 progname, fname==NULL?"<stdin>":fname);
1407 trunced = y;
1408 goto skipit;
1409 }
1410 cury++;
1411 return(0);
1412 }