ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/px/ximage.c
(Generate patch)

Comparing ray/src/px/ximage.c (file contents):
Revision 1.4 by greg, Tue Apr 18 11:07:12 1989 UTC vs.
Revision 2.5 by greg, Wed Jun 24 09:17:43 1992 UTC

# Line 23 | Line 23 | static char SCCSid[] = "$SunId$ LBL";
23  
24   #include  "color.h"
25  
26 + #include  "resolu.h"
27 +
28   #include  "xraster.h"
29  
30   #include  "view.h"
31  
32   #include  "pic.h"
33  
34 + #include  "random.h"
35 +
36   #define  controlshift(e)        (((XButtonEvent *)(e))->detail & (ShiftMask|ControlMask))
37  
38   #define  FONTNAME       "9x15"          /* text font we'll use */
39  
40 < #define  CTRL(c)        ('c'-'@')
40 > #define  CTRL(c)        ((c)-'@')
41  
42   #define  BORWIDTH       5               /* border width */
43   #define  BARHEIGHT      25              /* menu bar size */
44  
45 < double  gamcor = 2.0;                   /* gamma correction */
45 > double  gamcor = 2.2;                   /* gamma correction */
46  
47   XRASTER  *ourras = NULL;                /* our stored raster image */
48  
# Line 56 | Line 60 | int  scale = 0;                                /* scalefactor; power of two */
60   int  xoff = 0;                          /* x image offset */
61   int  yoff = 0;                          /* y image offset */
62  
63 < VIEW  ourview = STDVIEW(0);             /* image view parameters */
63 > VIEW  ourview = STDVIEW;                /* image view parameters */
64   int  gotview = 0;                       /* got parameters from file */
65  
66   COLR  *scanline;                        /* scan line buffer */
# Line 70 | Line 74 | int  cury = 0;                         /* current scan location */
74  
75   double  exposure = 1.0;                 /* exposure compensation used */
76  
77 + int  wrongformat = 0;                   /* input in another format */
78 +
79   struct {
80          int  xmin, ymin, xsiz, ysiz;
81   }  box = {0, 0, 0, 0};                  /* current box */
# Line 84 | Line 90 | extern long  ftell();
90  
91   extern char  *malloc(), *calloc();
92  
93 < extern double  atof(), pow(), log();
93 > extern double  pow(), log();
94  
95  
96   main(argc, argv)
97   int  argc;
98   char  *argv[];
99   {
100 +        extern char  *getenv();
101 +        char  *gv;
102          int  headline();
103          int  i;
104          
105          progname = argv[0];
106 +        if ((gv = getenv("GAMMA")) != NULL)
107 +                gamcor = atof(gv);
108  
109          for (i = 1; i < argc; i++)
110                  if (argv[i][0] == '-')
# Line 137 | Line 147 | char  *argv[];
147                          sprintf(errmsg, "can't open file \"%s\"", fname);
148                          quiterr(errmsg);
149                  }
150 <        } else
141 <                goto userr;
142 <
150 >        }
151                                  /* get header */
152 <        getheader(fin, headline);
152 >        getheader(fin, headline, NULL);
153                                  /* get picture dimensions */
154 <        if (fscanf(fin, "-Y %d +X %d\n", &ymax, &xmax) != 2)
154 >        if (wrongformat || fgetresolu(&xmax, &ymax, fin) != (YMAJOR|YDECR))
155                  quiterr("bad picture size");
156                                  /* set view parameters */
157 <        if (gotview) {
158 <                ourview.hresolu = xmax;
151 <                ourview.vresolu = ymax;
152 <                if (setview(&ourview) != NULL)
153 <                        gotview = 0;
154 <        }
157 >        if (gotview && setview(&ourview) != NULL)
158 >                gotview = 0;
159          if ((scanline = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
160                  quiterr("out of memory");
161  
# Line 170 | Line 174 | userr:
174   headline(s)             /* get relevant info from header */
175   char  *s;
176   {
177 <        static char  *altname[] = {"rview","rpict",VIEWSTR,NULL};
174 <        register char  **an;
177 >        char  fmt[32];
178  
179 <        if (!strncmp(s, "EXPOSURE=", 9))
180 <                exposure *= atof(s+9);
181 <        else
182 <                for (an = altname; *an != NULL; an++)
183 <                        if (!strncmp(*an, s, strlen(*an))) {
184 <                                if (sscanview(&ourview, s+strlen(*an)) == 0)
185 <                                        gotview++;
183 <                                return;
184 <                        }
179 >        if (isexpos(s))
180 >                exposure *= exposval(s);
181 >        else if (isformat(s)) {
182 >                formatval(fmt, s);
183 >                wrongformat = strcmp(fmt, COLRFMT);
184 >        } else if (isview(s) && sscanview(&ourview, s) > 0)
185 >                gotview++;
186   }
187  
188  
188 – char *
189 – sskip(s)                /* skip a word */
190 – register char  *s;
191 – {
192 –        while (isspace(*s)) s++;
193 –        while (*s && !isspace(*s)) s++;
194 –        return(s);
195 – }
196 –
197 –
189   init()                  /* get data and open window */
190   {
191          register int  i;
# Line 301 | Line 292 | getras()                               /* get raster file */
292          }
293          return;
294   memerr:
295 <        quit("out of memory");
295 >        quiterr("out of memory");
296   }
297  
298  
# Line 347 | Line 338 | redraw(x, y, w, h)                     /* redraw section of window */
338   int  x, y;
339   int  w, h;
340   {
341 <        if (map_rcolors(ourras) == NULL) {
341 >        if (ourras->ncolors && map_rcolors(ourras) == NULL) {
342                  fprintf(stderr, "%s: cannot allocate colors\n", progname);
343                  return(-1);
344          }
# Line 362 | Line 353 | XKeyEvent  *ekey;
353   {
354          char  buf[80];
355          COLOR  cval;
356 +        Color  cvx;
357          char  *cp;
358          int  n;
359          double  comp;
# Line 372 | Line 364 | XKeyEvent  *ekey;
364                  return(0);
365          switch (*cp) {                  /* interpret command */
366          case 'q':
367 <        case CTRL(D):                           /* quiterr */
367 >        case CTRL('D'):                         /* quit */
368                  quit(0);
369          case '\n':
370          case '\r':
# Line 383 | Line 375 | XKeyEvent  *ekey;
375                  switch (*cp) {
376                  case '\n':
377                  case '\r':                              /* radiance */
378 <                        sprintf(buf, "%-3g", intens(cval)/exposure);
378 >                        sprintf(buf, "%.3f", intens(cval)/exposure);
379                          break;
380                  case 'l':                               /* luminance */
381 <                        sprintf(buf, "%-3gL", bright(cval)*683.0/exposure);
381 >                        sprintf(buf, "%.0fL", luminance(cval)/exposure);
382                          break;
383                  case 'c':                               /* color */
384                          comp = pow(2.0, (double)scale);
# Line 399 | Line 391 | XKeyEvent  *ekey;
391                  XText(wind, box.xmin, box.ymin, buf, strlen(buf),
392                                  fontid, BlackPixel, WhitePixel);
393                  return(0);
394 +        case 'i':                               /* identify (contour) */
395 +                if (ourras->pixels == NULL)
396 +                        return(-1);
397 +                n = ourras->data.bz[ekey->x-xoff+BZPixmapSize(xmax,ekey->y-yoff)];
398 +                n = ourras->pmap[n];
399 +                cvx.pixel = ourras->cdefs[n].pixel;
400 +                cvx.red = random() & 65535;
401 +                cvx.green = random() & 65535;
402 +                cvx.blue = random() & 65535;
403 +                XStoreColor(&cvx);
404 +                return(0);
405          case 'p':                               /* position */
406                  sprintf(buf, "(%d,%d)", ekey->x-xoff, ymax-1-ekey->y+yoff);
407                  XText(wind, ekey->x, ekey->y, buf, strlen(buf),
# Line 409 | Line 412 | XKeyEvent  *ekey;
412                          XFeep(0);
413                          return(-1);
414                  }
415 <                rayview(rorg, rdir, &ourview,
416 <                                ekey->x-xoff + .5, ymax-1-ekey->y+yoff + .5);
415 >                if (viewray(rorg, rdir, &ourview, (ekey->x-xoff+.5)/xmax,
416 >                                (ymax-1-ekey->y+yoff+.5)/ymax) < 0)
417 >                        return(-1);
418                  printf("%e %e %e ", rorg[0], rorg[1], rorg[2]);
419                  printf("%e %e %e\n", rdir[0], rdir[1], rdir[2]);
420                  fflush(stdout);
# Line 419 | Line 423 | XKeyEvent  *ekey;
423                  if (avgbox(cval) == -1)
424                          return(-1);
425                  n = log(.5/bright(cval))/.69315 - scale;        /* truncate */
426 <                if (n == 0) {
423 <                        XFeep(0);
426 >                if (n == 0)
427                          return(0);
425 –                }
428                  scale_rcolors(ourras, pow(2.0, (double)n));
429                  scale += n;
430                  sprintf(buf, "%+d", scale);
# Line 432 | Line 434 | XKeyEvent  *ekey;
434                  free_raster(ourras);
435                  getras();
436          /* fall through */
437 <        case CTRL(R):                           /* redraw */
437 >        case CTRL('R'):                         /* redraw */
438 >        case CTRL('L'):
439 >                unmap_rcolors(ourras);
440                  XClear(wind);
441                  return(redraw(0, 0, width, height));
442          case ' ':                               /* clear */
# Line 543 | Line 547 | getmono()                      /* get monochrome data */
547   {
548          register unsigned short *dp;
549          register int    x, err;
550 <        int     y;
551 <        rgbpixel        *inline;
550 >        int     y, errp;
551 >        rgbpixel        *inl;
552          short   *cerr;
553  
554 <        if ((inline = (rgbpixel *)malloc(xmax*sizeof(rgbpixel))) == NULL
554 >        if ((inl = (rgbpixel *)malloc(xmax*sizeof(rgbpixel))) == NULL
555                          || (cerr = (short *)calloc(xmax,sizeof(short))) == NULL)
556 <                quit("out of memory in getmono");
556 >                quiterr("out of memory in getmono");
557          dp = ourras->data.m - 1;
558          for (y = 0; y < ymax; y++) {
559 <                picreadline3(y, inline);
559 >                picreadline3(y, inl);
560                  err = 0;
561                  for (x = 0; x < xmax; x++) {
562                          if (!(x&0xf))
563                                  *++dp = 0;
564 <                        err += rgb_bright(&inline[x]) + cerr[x];
564 >                        errp = err;
565 >                        err += rgb_bright(&inl[x]) + cerr[x];
566                          if (err > 127)
567                                  err -= 255;
568                          else
569                                  *dp |= 1<<(x&0xf);
570 <                        cerr[x] = err >>= 1;
570 >                        err /= 3;
571 >                        cerr[x] = err + errp;
572                  }
573          }
574 <        free((char *)inline);
574 >        free((char *)inl);
575          free((char *)cerr);
576   }
577  
# Line 606 | Line 612 | register XRASTER       *xr;
612   double  sf;
613   {
614          register int    i;
615 <        int     maxv;
615 >        long    maxv;
616  
617 +        if (xr->pixels == NULL)
618 +                return;
619 +
620          sf = pow(sf, 1.0/gamcor);
621 <        maxv = (1<<16) / sf;
621 >        maxv = 65535/sf;
622  
623          for (i = xr->ncolors; i--; ) {
624 <                xr->cdefs[i].red = xr->cdefs[i].red >= maxv ?
625 <                                (1<<16)-1 :
624 >                xr->cdefs[i].red = xr->cdefs[i].red > maxv ?
625 >                                65535 :
626                                  xr->cdefs[i].red * sf;
627 <                xr->cdefs[i].green = xr->cdefs[i].green >= maxv ?
628 <                                (1<<16)-1 :
627 >                xr->cdefs[i].green = xr->cdefs[i].green > maxv ?
628 >                                65535 :
629                                  xr->cdefs[i].green * sf;
630 <                xr->cdefs[i].blue = xr->cdefs[i].blue >= maxv ?
631 <                                (1<<16)-1 :
630 >                xr->cdefs[i].blue = xr->cdefs[i].blue > maxv ?
631 >                                65535 :
632                                  xr->cdefs[i].blue * sf;
633          }
634 <        if (xr->pixels != NULL)
626 <                XStoreColors(xr->ncolors, xr->cdefs);
634 >        XStoreColors(xr->ncolors, xr->cdefs);
635   }
636  
637  
# Line 634 | Line 642 | int  y;
642                  if (scanpos == NULL || scanpos[y] == -1)
643                          return(-1);
644                  if (fseek(fin, scanpos[y], 0) == -1)
645 <                        quit("fseek error");
645 >                        quiterr("fseek error");
646                  cury = y;
647          } else if (scanpos != NULL)
648                  scanpos[y] = ftell(fin);
# Line 651 | Line 659 | picreadline3(y, l3)                    /* read in 3-byte scanline */
659   int  y;
660   register rgbpixel  *l3;
661   {
662 <        register BYTE   *l4;
663 <        register int    shift, c;
656 <        int     i;
657 <
662 >        register int    i;
663 >                                                        /* read scanline */
664          if (getscan(y) < 0)
665                  quiterr("cannot seek for picreadline");
666                                                          /* convert scanline */
667 <        for (l4=scanline[0], i=xmax; i--; l4+=4, l3++) {
668 <                shift = l4[EXP] - COLXS + scale;
669 <                if (shift >= 8) {
670 <                        l3->r = l3->g = l3->b = 255;
671 <                } else if (shift <= -8) {
666 <                        l3->r = l3->g = l3->b = 0;
667 <                } else if (shift > 0) {
668 <                        c = l4[RED] << shift;
669 <                        l3->r = c > 255 ? 255 : c;
670 <                        c = l4[GRN] << shift;
671 <                        l3->g = c > 255 ? 255 : c;
672 <                        c = l4[BLU] << shift;
673 <                        l3->b = c > 255 ? 255 : c;
674 <                } else if (shift < 0) {
675 <                        l3->r = l4[RED] >> -shift;
676 <                        l3->g = l4[GRN] >> -shift;
677 <                        l3->b = l4[BLU] >> -shift;
678 <                } else {
679 <                        l3->r = l4[RED];
680 <                        l3->g = l4[GRN];
681 <                        l3->b = l4[BLU];
682 <                }
667 >        normcolrs(scanline, xmax, scale);
668 >        for (i = 0; i < xmax; i++) {
669 >                l3[i].r = scanline[i][RED];
670 >                l3[i].g = scanline[i][GRN];
671 >                l3[i].b = scanline[i][BLU];
672          }
673   }
674  
# Line 688 | Line 677 | picwriteline(y, l)             /* add 8-bit scanline to image */
677   int  y;
678   pixel  *l;
679   {
680 <        bcopy(l, ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
680 >        bcopy((char *)l, (char *)ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
681   }
682  
683  
684 < picreadcm(map)                  /* do gamcor correction */
684 > picreadcm(map)                  /* do gamma correction */
685   colormap  map;
686   {
687          extern double  pow();
688          register int  i, val;
689  
690          for (i = 0; i < 256; i++) {
691 <                val = pow(i/256.0, 1.0/gamcor) * 256.0;
691 >                val = pow((i+0.5)/256.0, 1.0/gamcor) * 256.0;
692                  map[0][i] = map[1][i] = map[2][i] = val;
693          }
694   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines