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 1.23 by greg, Fri Jan 26 08:17:43 1990 UTC

# Line 29 | Line 29 | static char SCCSid[] = "$SunId$ LBL";
29  
30   #include  "pic.h"
31  
32 + #include  "random.h"
33 +
34   #define  controlshift(e)        (((XButtonEvent *)(e))->detail & (ShiftMask|ControlMask))
35  
36   #define  FONTNAME       "9x15"          /* text font we'll use */
# Line 56 | Line 58 | int  scale = 0;                                /* scalefactor; power of two */
58   int  xoff = 0;                          /* x image offset */
59   int  yoff = 0;                          /* y image offset */
60  
61 < VIEW  ourview = STDVIEW(0);             /* image view parameters */
61 > VIEW  ourview = STDVIEW;                /* image view parameters */
62   int  gotview = 0;                       /* got parameters from file */
63  
64   COLR  *scanline;                        /* scan line buffer */
# Line 144 | Line 146 | char  *argv[];
146          if (fgetresolu(&xmax, &ymax, fin) != (YMAJOR|YDECR))
147                  quiterr("bad picture size");
148                                  /* set view parameters */
149 <        if (gotview)
150 <                if (setview(&ourview) != NULL)
149 <                        gotview = 0;
150 <
149 >        if (gotview && setview(&ourview) != NULL)
150 >                gotview = 0;
151          if ((scanline = (COLR *)malloc(xmax*sizeof(COLR))) == NULL)
152                  quiterr("out of memory");
153  
# Line 169 | Line 169 | char  *s;
169          static char  *altname[] = {"rview","rpict",VIEWSTR,NULL};
170          register char  **an;
171  
172 <        if (!strncmp(s, "EXPOSURE=", 9))
173 <                exposure *= atof(s+9);
172 >        if (isexpos(s))
173 >                exposure *= exposval(s);
174          else
175                  for (an = altname; *an != NULL; an++)
176                          if (!strncmp(*an, s, strlen(*an))) {
177 <                                if (sscanview(&ourview, s+strlen(*an)) == 0)
177 >                                if (sscanview(&ourview, s+strlen(*an)) > 0)
178                                          gotview++;
179                                  return;
180                          }
181   }
182  
183  
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 –
184   init()                  /* get data and open window */
185   {
186          register int  i;
# Line 358 | Line 348 | XKeyEvent  *ekey;
348   {
349          char  buf[80];
350          COLOR  cval;
351 +        Color  cvx;
352          char  *cp;
353          int  n;
354          double  comp;
# Line 368 | Line 359 | XKeyEvent  *ekey;
359                  return(0);
360          switch (*cp) {                  /* interpret command */
361          case 'q':
362 <        case CTRL(D):                           /* quiterr */
362 >        case CTRL(D):                           /* quit */
363                  quit(0);
364          case '\n':
365          case '\r':
# Line 379 | Line 370 | XKeyEvent  *ekey;
370                  switch (*cp) {
371                  case '\n':
372                  case '\r':                              /* radiance */
373 <                        sprintf(buf, "%-3g", intens(cval)/exposure);
373 >                        sprintf(buf, "%.3f", intens(cval)/exposure);
374                          break;
375                  case 'l':                               /* luminance */
376 <                        sprintf(buf, "%-3gL", bright(cval)*683.0/exposure);
376 >                        sprintf(buf, "%.0fn", bright(cval)*683.0/exposure);
377                          break;
378                  case 'c':                               /* color */
379                          comp = pow(2.0, (double)scale);
# Line 395 | Line 386 | XKeyEvent  *ekey;
386                  XText(wind, box.xmin, box.ymin, buf, strlen(buf),
387                                  fontid, BlackPixel, WhitePixel);
388                  return(0);
389 +        case 'i':                               /* identify (contour) */
390 +                if (ourras->pixels == NULL)
391 +                        return(-1);
392 +                n = ourras->data.bz[ekey->x-xoff+BZPixmapSize(xmax,ekey->y-yoff)];
393 +                n = ourras->pmap[n];
394 +                cvx.pixel = ourras->cdefs[n].pixel;
395 +                cvx.red = random() & 65535;
396 +                cvx.green = random() & 65535;
397 +                cvx.blue = random() & 65535;
398 +                XStoreColor(&cvx);
399 +                return(0);
400          case 'p':                               /* position */
401                  sprintf(buf, "(%d,%d)", ekey->x-xoff, ymax-1-ekey->y+yoff);
402                  XText(wind, ekey->x, ekey->y, buf, strlen(buf),
# Line 405 | Line 407 | XKeyEvent  *ekey;
407                          XFeep(0);
408                          return(-1);
409                  }
410 <                rayview(rorg, rdir, &ourview,
411 <                                ekey->x-xoff + .5, ymax-1-ekey->y+yoff + .5);
410 >                viewray(rorg, rdir, &ourview, (ekey->x-xoff+.5)/xmax,
411 >                                (ymax-1-ekey->y+yoff+.5)/ymax);
412                  printf("%e %e %e ", rorg[0], rorg[1], rorg[2]);
413                  printf("%e %e %e\n", rdir[0], rdir[1], rdir[2]);
414                  fflush(stdout);
# Line 428 | Line 430 | XKeyEvent  *ekey;
430          /* fall through */
431          case CTRL(R):                           /* redraw */
432          case CTRL(L):
433 +                unmap_rcolors(ourras);
434                  XClear(wind);
435                  return(redraw(0, 0, width, height));
436          case ' ':                               /* clear */
# Line 601 | Line 604 | register XRASTER       *xr;
604   double  sf;
605   {
606          register int    i;
607 <        int     maxv;
607 >        long    maxv;
608  
609 +        if (xr->pixels == NULL)
610 +                return;
611 +
612          sf = pow(sf, 1.0/gamcor);
613 <        maxv = (1<<16) / sf;
613 >        maxv = 65535/sf;
614  
615          for (i = xr->ncolors; i--; ) {
616 <                xr->cdefs[i].red = xr->cdefs[i].red >= maxv ?
617 <                                (1<<16)-1 :
616 >                xr->cdefs[i].red = xr->cdefs[i].red > maxv ?
617 >                                65535 :
618                                  xr->cdefs[i].red * sf;
619 <                xr->cdefs[i].green = xr->cdefs[i].green >= maxv ?
620 <                                (1<<16)-1 :
619 >                xr->cdefs[i].green = xr->cdefs[i].green > maxv ?
620 >                                65535 :
621                                  xr->cdefs[i].green * sf;
622 <                xr->cdefs[i].blue = xr->cdefs[i].blue >= maxv ?
623 <                                (1<<16)-1 :
622 >                xr->cdefs[i].blue = xr->cdefs[i].blue > maxv ?
623 >                                65535 :
624                                  xr->cdefs[i].blue * sf;
625          }
626 <        if (xr->pixels != NULL)
621 <                XStoreColors(xr->ncolors, xr->cdefs);
626 >        XStoreColors(xr->ncolors, xr->cdefs);
627   }
628  
629  
# Line 646 | Line 651 | picreadline3(y, l3)                    /* read in 3-byte scanline */
651   int  y;
652   register rgbpixel  *l3;
653   {
654 <        register BYTE   *l4;
655 <        register int    shift, c;
651 <        int     i;
652 <
654 >        register int    i;
655 >                                                        /* read scanline */
656          if (getscan(y) < 0)
657                  quiterr("cannot seek for picreadline");
658                                                          /* convert scanline */
659 <        for (l4=scanline[0], i=xmax; i--; l4+=4, l3++) {
660 <                shift = l4[EXP] - COLXS + scale;
661 <                if (shift >= 8) {
662 <                        l3->r = l3->g = l3->b = 255;
663 <                } 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 <                }
659 >        normcolrs(scanline, xmax, scale);
660 >        for (i = 0; i < xmax; i++) {
661 >                l3[i].r = scanline[i][RED];
662 >                l3[i].g = scanline[i][GRN];
663 >                l3[i].b = scanline[i][BLU];
664          }
665   }
666  
# Line 683 | Line 669 | picwriteline(y, l)             /* add 8-bit scanline to image */
669   int  y;
670   pixel  *l;
671   {
672 <        bcopy(l, ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
672 >        bcopy((char *)l, (char *)ourras->data.bz+BZPixmapSize(xmax,y), BZPixmapSize(xmax,1));
673   }
674  
675  

Diff Legend

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