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.11 by greg, Tue Oct 3 09:11:43 1989 UTC vs.
Revision 2.1 by greg, Tue Nov 12 16:05:14 1991 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 */
# 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 139 | Line 145 | char  *argv[];
145                  }
146          }
147                                  /* get header */
148 <        getheader(fin, headline);
148 >        getheader(fin, headline, NULL);
149                                  /* get picture dimensions */
150 <        if (fgetresolu(&xmax, &ymax, fin) != (YMAJOR|YDECR))
150 >        if (wrongformat || fgetresolu(&xmax, &ymax, fin) != (YMAJOR|YDECR))
151                  quiterr("bad picture size");
152                                  /* set view parameters */
153 <        if (gotview)
154 <                if (setview(&ourview) != NULL)
149 <                        gotview = 0;
150 <
153 >        if (gotview && setview(&ourview) != NULL)
154 >                gotview = 0;
155          if ((scanline = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
156                  quiterr("out of memory");
157  
# Line 168 | Line 172 | char  *s;
172   {
173          static char  *altname[] = {"rview","rpict",VIEWSTR,NULL};
174          register char  **an;
175 +        char  fmt[32];
176  
177 <        if (!strncmp(s, "EXPOSURE=", 9))
178 <                exposure *= atof(s+9);
179 <        else
177 >        if (isexpos(s))
178 >                exposure *= exposval(s);
179 >        else if (isformat(s)) {
180 >                formatval(fmt, s);
181 >                wrongformat = strcmp(fmt, COLRFMT);
182 >        } else
183                  for (an = altname; *an != NULL; an++)
184                          if (!strncmp(*an, s, strlen(*an))) {
185 <                                if (sscanview(&ourview, s+strlen(*an)) == 0)
185 >                                if (sscanview(&ourview, s+strlen(*an)) > 0)
186                                          gotview++;
187                                  return;
188                          }
189   }
190  
191  
184 – char *
185 – sskip(s)                /* skip a word */
186 – register char  *s;
187 – {
188 –        while (isspace(*s)) s++;
189 –        while (*s && !isspace(*s)) s++;
190 –        return(s);
191 – }
192 –
193 –
192   init()                  /* get data and open window */
193   {
194          register int  i;
# Line 297 | Line 295 | getras()                               /* get raster file */
295          }
296          return;
297   memerr:
298 <        quit("out of memory");
298 >        quiterr("out of memory");
299   }
300  
301  
# Line 358 | Line 356 | XKeyEvent  *ekey;
356   {
357          char  buf[80];
358          COLOR  cval;
359 +        Color  cvx;
360          char  *cp;
361          int  n;
362          double  comp;
# Line 368 | Line 367 | XKeyEvent  *ekey;
367                  return(0);
368          switch (*cp) {                  /* interpret command */
369          case 'q':
370 <        case CTRL(D):                           /* quiterr */
370 >        case CTRL(D):                           /* quit */
371                  quit(0);
372          case '\n':
373          case '\r':
# Line 379 | Line 378 | XKeyEvent  *ekey;
378                  switch (*cp) {
379                  case '\n':
380                  case '\r':                              /* radiance */
381 <                        sprintf(buf, "%-3g", intens(cval)/exposure);
381 >                        sprintf(buf, "%.3f", intens(cval)/exposure);
382                          break;
383                  case 'l':                               /* luminance */
384 <                        sprintf(buf, "%-3gL", bright(cval)*683.0/exposure);
384 >                        sprintf(buf, "%.0fL", luminance(cval)/exposure);
385                          break;
386                  case 'c':                               /* color */
387                          comp = pow(2.0, (double)scale);
# Line 395 | Line 394 | XKeyEvent  *ekey;
394                  XText(wind, box.xmin, box.ymin, buf, strlen(buf),
395                                  fontid, BlackPixel, WhitePixel);
396                  return(0);
397 +        case 'i':                               /* identify (contour) */
398 +                if (ourras->pixels == NULL)
399 +                        return(-1);
400 +                n = ourras->data.bz[ekey->x-xoff+BZPixmapSize(xmax,ekey->y-yoff)];
401 +                n = ourras->pmap[n];
402 +                cvx.pixel = ourras->cdefs[n].pixel;
403 +                cvx.red = random() & 65535;
404 +                cvx.green = random() & 65535;
405 +                cvx.blue = random() & 65535;
406 +                XStoreColor(&cvx);
407 +                return(0);
408          case 'p':                               /* position */
409                  sprintf(buf, "(%d,%d)", ekey->x-xoff, ymax-1-ekey->y+yoff);
410                  XText(wind, ekey->x, ekey->y, buf, strlen(buf),
# Line 405 | Line 415 | XKeyEvent  *ekey;
415                          XFeep(0);
416                          return(-1);
417                  }
418 <                rayview(rorg, rdir, &ourview,
419 <                                ekey->x-xoff + .5, ymax-1-ekey->y+yoff + .5);
418 >                if (viewray(rorg, rdir, &ourview, (ekey->x-xoff+.5)/xmax,
419 >                                (ymax-1-ekey->y+yoff+.5)/ymax) < 0)
420 >                        return(-1);
421                  printf("%e %e %e ", rorg[0], rorg[1], rorg[2]);
422                  printf("%e %e %e\n", rdir[0], rdir[1], rdir[2]);
423                  fflush(stdout);
# Line 428 | Line 439 | XKeyEvent  *ekey;
439          /* fall through */
440          case CTRL(R):                           /* redraw */
441          case CTRL(L):
442 +                unmap_rcolors(ourras);
443                  XClear(wind);
444                  return(redraw(0, 0, width, height));
445          case ' ':                               /* clear */
# Line 538 | Line 550 | getmono()                      /* get monochrome data */
550   {
551          register unsigned short *dp;
552          register int    x, err;
553 <        int     y;
554 <        rgbpixel        *inline;
553 >        int     y, errp;
554 >        rgbpixel        *inl;
555          short   *cerr;
556  
557 <        if ((inline = (rgbpixel *)malloc(xmax*sizeof(rgbpixel))) == NULL
557 >        if ((inl = (rgbpixel *)malloc(xmax*sizeof(rgbpixel))) == NULL
558                          || (cerr = (short *)calloc(xmax,sizeof(short))) == NULL)
559 <                quit("out of memory in getmono");
559 >                quiterr("out of memory in getmono");
560          dp = ourras->data.m - 1;
561          for (y = 0; y < ymax; y++) {
562 <                picreadline3(y, inline);
562 >                picreadline3(y, inl);
563                  err = 0;
564                  for (x = 0; x < xmax; x++) {
565                          if (!(x&0xf))
566                                  *++dp = 0;
567 <                        err += rgb_bright(&inline[x]) + cerr[x];
567 >                        errp = err;
568 >                        err += rgb_bright(&inl[x]) + cerr[x];
569                          if (err > 127)
570                                  err -= 255;
571                          else
572                                  *dp |= 1<<(x&0xf);
573 <                        cerr[x] = err >>= 1;
573 >                        err /= 3;
574 >                        cerr[x] = err + errp;
575                  }
576          }
577 <        free((char *)inline);
577 >        free((char *)inl);
578          free((char *)cerr);
579   }
580  
# Line 601 | Line 615 | register XRASTER       *xr;
615   double  sf;
616   {
617          register int    i;
618 <        int     maxv;
618 >        long    maxv;
619  
620 +        if (xr->pixels == NULL)
621 +                return;
622 +
623          sf = pow(sf, 1.0/gamcor);
624 <        maxv = (1<<16) / sf;
624 >        maxv = 65535/sf;
625  
626          for (i = xr->ncolors; i--; ) {
627 <                xr->cdefs[i].red = xr->cdefs[i].red >= maxv ?
628 <                                (1<<16)-1 :
627 >                xr->cdefs[i].red = xr->cdefs[i].red > maxv ?
628 >                                65535 :
629                                  xr->cdefs[i].red * sf;
630 <                xr->cdefs[i].green = xr->cdefs[i].green >= maxv ?
631 <                                (1<<16)-1 :
630 >                xr->cdefs[i].green = xr->cdefs[i].green > maxv ?
631 >                                65535 :
632                                  xr->cdefs[i].green * sf;
633 <                xr->cdefs[i].blue = xr->cdefs[i].blue >= maxv ?
634 <                                (1<<16)-1 :
633 >                xr->cdefs[i].blue = xr->cdefs[i].blue > maxv ?
634 >                                65535 :
635                                  xr->cdefs[i].blue * sf;
636          }
637 <        if (xr->pixels != NULL)
621 <                XStoreColors(xr->ncolors, xr->cdefs);
637 >        XStoreColors(xr->ncolors, xr->cdefs);
638   }
639  
640  
# Line 629 | Line 645 | int  y;
645                  if (scanpos == NULL || scanpos[y] == -1)
646                          return(-1);
647                  if (fseek(fin, scanpos[y], 0) == -1)
648 <                        quit("fseek error");
648 >                        quiterr("fseek error");
649                  cury = y;
650          } else if (scanpos != NULL)
651                  scanpos[y] = ftell(fin);
# Line 646 | Line 662 | picreadline3(y, l3)                    /* read in 3-byte scanline */
662   int  y;
663   register rgbpixel  *l3;
664   {
665 <        register BYTE   *l4;
666 <        register int    shift, c;
651 <        int     i;
652 <
665 >        register int    i;
666 >                                                        /* read scanline */
667          if (getscan(y) < 0)
668                  quiterr("cannot seek for picreadline");
669                                                          /* convert scanline */
670 <        for (l4=scanline[0], i=xmax; i--; l4+=4, l3++) {
671 <                shift = l4[EXP] - COLXS + scale;
672 <                if (shift >= 8) {
673 <                        l3->r = l3->g = l3->b = 255;
674 <                } else if (shift <= -8) {
661 <                        l3->r = l3->g = l3->b = 0;
662 <                } else if (shift > 0) {
663 <                        c = l4[RED] << shift;
664 <                        l3->r = c > 255 ? 255 : c;
665 <                        c = l4[GRN] << shift;
666 <                        l3->g = c > 255 ? 255 : c;
667 <                        c = l4[BLU] << shift;
668 <                        l3->b = c > 255 ? 255 : c;
669 <                } else if (shift < 0) {
670 <                        l3->r = l4[RED] >> -shift;
671 <                        l3->g = l4[GRN] >> -shift;
672 <                        l3->b = l4[BLU] >> -shift;
673 <                } else {
674 <                        l3->r = l4[RED];
675 <                        l3->g = l4[GRN];
676 <                        l3->b = l4[BLU];
677 <                }
670 >        normcolrs(scanline, xmax, scale);
671 >        for (i = 0; i < xmax; i++) {
672 >                l3[i].r = scanline[i][RED];
673 >                l3[i].g = scanline[i][GRN];
674 >                l3[i].b = scanline[i][BLU];
675          }
676   }
677  
# Line 683 | Line 680 | picwriteline(y, l)             /* add 8-bit scanline to image */
680   int  y;
681   pixel  *l;
682   {
683 <        bcopy(l, ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
683 >        bcopy((char *)l, (char *)ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
684   }
685  
686  
# Line 694 | Line 691 | colormap  map;
691          register int  i, val;
692  
693          for (i = 0; i < 256; i++) {
694 <                val = pow(i/256.0, 1.0/gamcor) * 256.0;
694 >                val = pow((i+0.5)/256.0, 1.0/gamcor) * 256.0;
695                  map[0][i] = map[1][i] = map[2][i] = val;
696          }
697   }

Diff Legend

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