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

Comparing ray/src/px/psign.c (file contents):
Revision 2.4 by greg, Tue Jun 16 15:34:47 1992 UTC vs.
Revision 2.12 by greg, Tue Sep 8 10:35:08 1992 UTC

# Line 1 | Line 1
1 < /* Copyright (c) 1991 Regents of the University of California */
1 > /* Copyright (c) 1992 Regents of the University of California */
2  
3   #ifndef lint
4   static char SCCSid[] = "$SunId$ LBL";
# Line 16 | Line 16 | static char SCCSid[] = "$SunId$ LBL";
16  
17   #include  "font.h"
18  
19 < #define  SSS                    2       /* super-sample size */
19 > #include  "paths.h"
20  
21 < #define  MAXLINE                512     /* longest allowable line */
22 <
23 < #ifndef  DEFPATH
24 < #define  DEFPATH                ":/usr/local/lib/ray"
21 > #ifndef  SSS
22 > #define  SSS                    3       /* super-sample size */
23   #endif
26 – #ifndef  ULIBVAR
27 – #define  ULIBVAR                "RAYPATH"
28 – #endif
24  
25 + #define  MAXLINE                512     /* longest allowable line */
26 +
27   char  *fontfile = "helvet.fnt";         /* our font file */
28  
29 < COLR  bgcolr = WHTCOLR;                 /* background color */
30 < COLR  fgcolr = BLKCOLR;                 /* foreground color */
29 > COLOR  bgcolor = WHTCOLOR;              /* background color */
30 > COLOR  fgcolor = BLKCOLOR;              /* foreground color */
31  
32   int  direct = 'r';                      /* direction (right, up, left, down) */
33  
34 < int  cheight = 32;                      /* character height */
34 > int  cheight = 32*SSS;                  /* character height */
35   double  aspect = 1.67;                  /* height/width character aspect */
36 + double  spacing = 0.0;                  /* character spacing */
37   int  cwidth;                            /* computed character width */
38  
39   unsigned char  *ourbitmap;              /* our output bitmap */
# Line 62 | Line 60 | LINE  *ourtext;                                /* our text */
60   int  nlines, maxline;                   /* text dimensions */
61   int  maxwidth;                          /* maximum line width (dvi) */
62  
65 – extern char  *getenv();
66 – extern char  *malloc(), *calloc();
63  
68 –
64   main(argc, argv)
65   int  argc;
66   char  *argv[];
# Line 77 | Line 72 | char  *argv[];
72                  case 'c':                       /* color */
73                          switch (argv[an][2]) {
74                          case 'f':                       /* foreground */
75 <                                setcolr(fgcolr, atof(argv[an+1]),
75 >                                setcolor(fgcolor, atof(argv[an+1]),
76                                                  atof(argv[an+2]),
77                                                  atof(argv[an+3]));
78                                  an += 3;
79                                  break;
80                          case 'b':                       /* background */
81 <                                setcolr(bgcolr, atof(argv[an+1]),
81 >                                setcolor(bgcolor, atof(argv[an+1]),
82                                                  atof(argv[an+2]),
83                                                  atof(argv[an+3]));
84                                  an += 3;
# Line 107 | Line 102 | char  *argv[];
102                                  goto unkopt;
103                          }
104                          break;
105 +                case 'x':                       /* x resolution */
106 +                        xsiz = atoi(argv[++an])*SSS;
107 +                        break;
108 +                case 'y':
109 +                        ysiz = atoi(argv[++an])*SSS;
110 +                        break;
111                  case 'h':                       /* height of characters */
112 <                        cheight = atoi(argv[++an]);
112 >                        cheight = atoi(argv[++an])*SSS;
113                          break;
114                  case 'a':                       /* aspect ratio */
115                          aspect = atof(argv[++an]);
116                          break;
117 +                case 's':                       /* spacing */
118 +                        spacing = atof(argv[++an]);
119 +                        break;
120                  default:;
121   unkopt:
122                          fprintf(stderr, "%s: unknown option: %s\n",
# Line 146 | Line 150 | unkopt:
150  
151   makemap()                       /* create the bit map */
152   {
153 <        cwidth = cheight/aspect + 0.5;
153 >        double  pictaspect;
154 >        
155          if (direct == 'r' || direct == 'l') {
156 <                xsiz = maxline*cwidth;
157 <                ysiz = nlines*cheight;
156 >                if (xsiz <= 0) {
157 >                        cwidth = cheight/aspect + 0.5;
158 >                        xsiz = (long)maxwidth*cwidth >> 8;
159 >                        ysiz = nlines*cheight;
160 >                } else if (aspect > FTINY) {
161 >                        if (ysiz <= 0)
162 >                                ysiz = cheight*nlines;
163 >                        pictaspect = 256*nlines*aspect/maxwidth;
164 >                        if (pictaspect*xsiz < ysiz)
165 >                                ysiz = pictaspect*xsiz + 0.5;
166 >                        else
167 >                                xsiz = ysiz/pictaspect + 0.5;
168 >                        cheight = ysiz/nlines;
169 >                        cwidth = cheight/aspect + 0.5;
170 >                } else {
171 >                        if (ysiz <= 0)
172 >                                ysiz = cheight*nlines;
173 >                        pictaspect = (double)ysiz/xsiz;
174 >                        aspect = pictaspect*maxwidth/(256*nlines);
175 >                        cheight = ysiz/nlines;
176 >                        cwidth = cheight/aspect + 0.5;
177 >                }
178          } else {                        /* reverse orientation */
179 <                xsiz = nlines*cheight;
180 <                ysiz = maxline*cwidth;
179 >                if (ysiz <= 0) {
180 >                        cwidth = cheight/aspect + 0.5;
181 >                        xsiz = nlines*cheight;
182 >                        ysiz = (long)maxwidth*cwidth >> 8;
183 >                } else if (aspect > FTINY) {
184 >                        if (xsiz <= 0)
185 >                                xsiz = cheight*nlines;
186 >                        pictaspect = maxwidth/(256*nlines*aspect);
187 >                        if (pictaspect*xsiz < ysiz)
188 >                                ysiz = pictaspect*xsiz + 0.5;
189 >                        else
190 >                                xsiz = ysiz/pictaspect + 0.5;
191 >                        cheight = xsiz/nlines;
192 >                        cwidth = cheight/aspect + 0.5;
193 >                } else {
194 >                        if (xsiz <= 0)
195 >                                xsiz = cheight*nlines;
196 >                        pictaspect = (double)ysiz/xsiz;
197 >                        aspect = maxwidth/(256*nlines*pictaspect);
198 >                        cheight = xsiz/nlines;
199 >                        cwidth = cheight/aspect + 0.5;
200 >                }
201          }
202 +        if (xsiz % SSS)
203 +                xsiz += SSS - xsiz%SSS;
204 +        if (ysiz % SSS)
205 +                ysiz += SSS - ysiz%SSS;
206          xdim = (xsiz+7)/8;
207 <        ourbitmap = (BYTE *)calloc(ysiz, xdim);
208 <        if (ourbitmap == NULL) {
209 <                fprintf(stderr, "out of memory in makemap\n");
210 <                exit(1);
162 <        }
207 >        ourbitmap = (BYTE *)bmalloc(ysiz*xdim);
208 >        if (ourbitmap == NULL)
209 >                error(SYSTEM, "Out of memory in makemap");
210 >        bzero((char *)ourbitmap, ysiz*xdim);
211   }
212  
213  
# Line 187 | Line 235 | FILE  *fp;
235                          maxline = len;
236                  strncpy(curl->s, buf, len);
237                  curl->s[len] = '\0';
238 < len = uniftext(curl->sp, curl->s, ourfont);
238 >                if (spacing < -1./256.)
239 >                        len = squeeztext(curl->sp, curl->s, ourfont,
240 >                                        (int)(spacing*-256.0));
241 >                else if (spacing > 1./256.)
242 >                        len = proptext(curl->sp, curl->s, ourfont,
243 >                                        (int)(spacing*256.0), 3);
244 >                else
245 >                        len = uniftext(curl->sp, curl->s, ourfont);
246                  if (len > maxwidth)
247                          maxwidth = len;
248                  curl->next = ourtext;
# Line 196 | Line 251 | len = uniftext(curl->sp, curl->s, ourfont);
251          }
252          return;
253   memerr:
254 <        fprintf(stderr, "out of memory in gettext\n");
200 <        exit(1);
254 >        error(SYSTEM, "Out of memory in gettext");
255   }
256  
257  
# Line 224 | Line 278 | char  *av[];
278          ourtext->sp = (short *)malloc(sizeof(short)*(maxline+1));
279          if (ourtext->sp == NULL)
280                  goto memerr;
281 < maxwidth = uniftext(ourtext->sp, ourtext->s, ourfont);
281 >        if (spacing < 0.0)
282 >                maxwidth = squeeztext(ourtext->sp, ourtext->s, ourfont,
283 >                                (int)(spacing*-256.0));
284 >        else if (spacing > 0.0)
285 >                maxwidth = proptext(ourtext->sp, ourtext->s, ourfont,
286 >                                (int)(spacing*256.0), 3);
287 >        else
288 >                maxwidth = uniftext(ourtext->sp, ourtext->s, ourfont);
289          nlines = 1;
290          return;
291   memerr:
292 <        fprintf(stderr, "out of memory in arg_text\n");
232 <        exit(1);
292 >        error(SYSTEM, "Out of memory in arg_text");
293   }
294  
295  
# Line 339 | Line 399 | int  run, rise;
399   writemap(fp)                    /* write out bitmap */
400   FILE  *fp;
401   {
402 +        COLR  pixval[SSS*SSS+1];        /* possible pixel values */
403 +        COLOR  ctmp0, ctmp1;
404 +        double  d;
405          COLR  *scanout;
406 <        int  y;
407 <        register int  x;
406 >        int  x, y;
407 >        register int  i, j;
408 >        int  cnt;
409          register int  inglyph;
410  
411 <        fprintf(fp, "-Y %d +X %d\n", ysiz, xsiz);
411 >        fprintf(fp, "-Y %d +X %d\n", ysiz/SSS, xsiz/SSS);
412  
413 <        scanout = (COLR *)malloc(xsiz*sizeof(COLR));
414 <        if (scanout == NULL) {
415 <                fprintf(stderr, "out of memory in writemap\n");
416 <                exit(1);
413 >        scanout = (COLR *)malloc(xsiz/SSS*sizeof(COLR));
414 >        if (scanout == NULL)
415 >                error(SYSTEM, "Out of memory in writemap");
416 >        for (i = 0; i <= SSS*SSS; i++) {        /* compute possible values */
417 >                copycolor(ctmp0, fgcolor);
418 >                d = (double)i/(SSS*SSS);
419 >                scalecolor(ctmp0, d);
420 >                copycolor(ctmp1, bgcolor);
421 >                d = 1.0 - d;
422 >                scalecolor(ctmp1, d);
423 >                addcolor(ctmp0, ctmp1);
424 >                setcolr(pixval[i], colval(ctmp0,RED),
425 >                                colval(ctmp0,GRN), colval(ctmp0,BLU));
426          }
427 <        for (y = ysiz-1; y >= 0; y--) {
427 >        for (y = ysiz/SSS-1; y >= 0; y--) {
428                  inglyph = 0;
429 <                for (x = 0; x < xsiz; x++) {
430 <                        if (tstbit(x, y))
431 <                                inglyph ^= 1;
432 <                        if (inglyph)
433 <                                copycolr(scanout[x], fgcolr);
434 <                        else
435 <                                copycolr(scanout[x], bgcolr);
429 >                for (x = 0; x < xsiz/SSS; x++) {
430 >                        cnt = 0;
431 >                        for (j = 0; j < SSS; j++)
432 >                                for (i = 0; i < SSS; i++) {
433 >                                        if (tstbit(x*SSS+i, y*SSS+j))
434 >                                                inglyph ^= 1<<j;
435 >                                        if (inglyph & 1<<j)
436 >                                                cnt++;
437 >                                }
438 >                        copycolr(scanout[x], pixval[cnt]);
439                  }
440 <                if (fwritecolrs(scanout, xsiz, fp) < 0) {
440 >                if (fwritecolrs(scanout, xsiz/SSS, fp) < 0) {
441                          fprintf(stderr, "write error in writemap\n");
442                          exit(1);
443                  }

Diff Legend

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