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.1 by greg, Tue Nov 12 16:04:19 1991 UTC vs.
Revision 2.24 by greg, Wed Oct 22 02:06:35 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1991 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  psign.c - produce picture from text.
6   *
7   *      7/1/87
8   */
9  
10 < #include  <stdio.h>
10 > #include  "copyright.h"
11  
12 + #include  <string.h>
13 +
14 + #include  "platform.h"
15 + #include  "standard.h"
16   #include  "color.h"
17 + #include  "font.h"
18  
19 < #define  MAXLINE                512     /* longest allowable line */
19 > #ifndef  SSS
20 > #define  SSS                    3       /* super-sample size */
21 > #endif
22  
23 + #define  MAXLINE                512     /* longest allowable line */
24 +
25   char  *fontfile = "helvet.fnt";         /* our font file */
26  
27 < COLR  bgcolr = WHTCOLR;                 /* background color */
28 < COLR  fgcolr = BLKCOLR;                 /* foreground color */
27 > COLOR  bgcolor = WHTCOLOR;              /* background color */
28 > COLOR  fgcolor = BLKCOLOR;              /* foreground color */
29  
30   int  direct = 'r';                      /* direction (right, up, left, down) */
31  
32 < int  cheight = 32;                      /* character height */
33 < double  aspect = 1.67;                  /* height/width character aspect */
32 > int  cheight = 32*SSS;                  /* character height */
33 > double  aspect = 1.67;                  /* height/width character aspect */
34 > double  spacing = 0.0;                  /* character spacing */
35   int  cwidth;                            /* computed character width */
36  
37   unsigned char  *ourbitmap;              /* our output bitmap */
38   int  xsiz, ysiz;                        /* bitmap dimensions */
39   int  xdim;                              /* size of horizontal scan (bytes) */
40  
41 < #define  bitop(x,y,op)          (ourbitmap[(y)*xdim+((x)>>3)] op (1<<((x)&7)))
42 < #define  tstbit(x,y)            bitop(x,y,&)
43 < #define  setbit(x,y)            bitop(x,y,|=)
44 < #define  clrbit(x,y)            bitop(x,y,&=~)
45 < #define  tglbit(x,y)            bitop(x,y,^=)
41 >                                /* conflicting def's in param.h */
42 > #undef  tstbit
43 > #undef  setbit
44 > #undef  clrbit
45 > #undef  tglbit
46  
47 < typedef unsigned char  GLYPH;
47 > #define  bitop(x,y,op)          (ourbitmap[(y)*xdim+((x)>>3)] op (1<<((x)&7)))
48 > #define  tstbit(x,y)            bitop(x,y,&)
49 > #define  setbit(x,y)            bitop(x,y,|=)
50 > #define  clrbit(x,y)            bitop(x,y,&=~)
51 > #define  tglbit(x,y)            bitop(x,y,^=)
52  
53 < GLYPH  *ourfont[128];                   /* our font */
53 > FONT  *ourfont;                         /* our font */
54  
55   typedef struct line {
56          char  *s;               /* line w/o LF */
57 +        short  *sp;             /* character spacing */
58          struct line  *next;     /* next line up */
59   } LINE;
60  
61   LINE  *ourtext;                         /* our text */
62   int  nlines, maxline;                   /* text dimensions */
63 + int  maxwidth;                          /* maximum line width (dvi) */
64  
52 – extern char  *malloc(), *calloc();
53 – extern FILE  *fropen();
65  
55 –
66   main(argc, argv)
67   int  argc;
68   char  *argv[];
69   {
60 –        double  atof();
70          int  an;
71 <
71 >        SET_FILE_BINARY(stdout);
72          for (an = 1; an < argc && argv[an][0] == '-'; an++)
73                  switch (argv[an][1]) {
74                  case 'c':                       /* color */
75                          switch (argv[an][2]) {
76                          case 'f':                       /* foreground */
77 <                                setcolr(fgcolr, atof(argv[an+1]),
77 >                                setcolor(fgcolor, atof(argv[an+1]),
78                                                  atof(argv[an+2]),
79                                                  atof(argv[an+3]));
80                                  an += 3;
81                                  break;
82                          case 'b':                       /* background */
83 <                                setcolr(bgcolr, atof(argv[an+1]),
83 >                                setcolor(bgcolor, atof(argv[an+1]),
84                                                  atof(argv[an+2]),
85                                                  atof(argv[an+3]));
86                                  an += 3;
# Line 95 | Line 104 | char  *argv[];
104                                  goto unkopt;
105                          }
106                          break;
107 +                case 'x':                       /* x resolution */
108 +                        xsiz = atoi(argv[++an])*SSS;
109 +                        break;
110 +                case 'y':
111 +                        ysiz = atoi(argv[++an])*SSS;
112 +                        break;
113                  case 'h':                       /* height of characters */
114 <                        cheight = atoi(argv[++an]);
114 >                        cheight = atoi(argv[++an])*SSS;
115                          break;
116                  case 'a':                       /* aspect ratio */
117                          aspect = atof(argv[++an]);
118                          break;
119 +                case 's':                       /* spacing */
120 +                        spacing = atof(argv[++an]);
121 +                        break;
122                  default:;
123   unkopt:
124                          fprintf(stderr, "%s: unknown option: %s\n",
125                                          argv[0], argv[an]);
126                          exit(1);
127                  }
128 +                                        /* load font file */
129 +        ourfont = getfont(fontfile);
130                                          /* get text */
131          if (an == argc)
132                  gettext(stdin);
# Line 115 | Line 135 | unkopt:
135  
136                                          /* create bit map */
137          makemap();
118 –                                        /* load font file */
119 –        loadfont();
138                                          /* convert text to bitmap */
139          maptext();
140                                          /* print header */
141 +        newheader("RADIANCE", stdout);
142          printargs(argc, argv, stdout);
143          fputformat(COLRFMT, stdout);
144          putchar('\n');
# Line 132 | Line 151 | unkopt:
151  
152   makemap()                       /* create the bit map */
153   {
154 <        cwidth = cheight/aspect + 0.5;
154 >        double  pictaspect;
155 >        
156          if (direct == 'r' || direct == 'l') {
157 <                xsiz = maxline*cwidth;
158 <                ysiz = nlines*cheight;
157 >                if (xsiz <= 0) {
158 >                        cwidth = cheight/aspect + 0.5;
159 >                        xsiz = (long)maxwidth*cwidth >> 8;
160 >                        ysiz = nlines*cheight;
161 >                } else if (aspect > FTINY) {
162 >                        if (ysiz <= 0)
163 >                                ysiz = cheight*nlines;
164 >                        pictaspect = 256*nlines*aspect/maxwidth;
165 >                        if (pictaspect*xsiz < ysiz)
166 >                                ysiz = pictaspect*xsiz + 0.5;
167 >                        else
168 >                                xsiz = ysiz/pictaspect + 0.5;
169 >                        cheight = ysiz/nlines;
170 >                        cwidth = cheight/aspect;
171 >                } else {
172 >                        if (ysiz <= 0)
173 >                                ysiz = cheight*nlines;
174 >                        pictaspect = (double)ysiz/xsiz;
175 >                        aspect = pictaspect*maxwidth/(256*nlines);
176 >                        cheight = ysiz/nlines;
177 >                        cwidth = cheight/aspect;
178 >                }
179          } else {                        /* reverse orientation */
180 <                xsiz = nlines*cheight;
181 <                ysiz = maxline*cwidth;
180 >                if (ysiz <= 0) {
181 >                        cwidth = cheight/aspect + 0.5;
182 >                        xsiz = nlines*cheight;
183 >                        ysiz = (long)maxwidth*cwidth >> 8;
184 >                } else if (aspect > FTINY) {
185 >                        if (xsiz <= 0)
186 >                                xsiz = cheight*nlines;
187 >                        pictaspect = maxwidth/(256*nlines*aspect);
188 >                        if (pictaspect*xsiz < ysiz)
189 >                                ysiz = pictaspect*xsiz + 0.5;
190 >                        else
191 >                                xsiz = ysiz/pictaspect + 0.5;
192 >                        cheight = xsiz/nlines;
193 >                        cwidth = cheight/aspect;
194 >                } else {
195 >                        if (xsiz <= 0)
196 >                                xsiz = cheight*nlines;
197 >                        pictaspect = (double)ysiz/xsiz;
198 >                        aspect = maxwidth/(256*nlines*pictaspect);
199 >                        cheight = xsiz/nlines;
200 >                        cwidth = cheight/aspect;
201 >                }
202          }
203 +        if (xsiz % SSS)
204 +                xsiz += SSS - xsiz%SSS;
205 +        if (ysiz % SSS)
206 +                ysiz += SSS - ysiz%SSS;
207          xdim = (xsiz+7)/8;
208 <        ourbitmap = (BYTE *)calloc(ysiz, xdim);
209 <        if (ourbitmap == NULL) {
210 <                fprintf(stderr, "out of memory in makemap\n");
211 <                exit(1);
148 <        }
208 >        ourbitmap = (BYTE *)bmalloc(ysiz*xdim);
209 >        if (ourbitmap == NULL)
210 >                error(SYSTEM, "Out of memory in makemap");
211 >        memset((char *)ourbitmap, '\0', ysiz*xdim);
212   }
213  
214  
152 – loadfont()                      /* load the font file */
153 – {
154 –        FILE  *fp;
155 –        char  *err;
156 –        int  gn, ngv, gv;
157 –        register GLYPH  *g;
158 –
159 –        if ((fp = fropen(fontfile)) == NULL) {
160 –                fprintf(stderr, "cannot find font file \"%s\"\n",
161 –                                fontfile);
162 –                exit(1);
163 –        }
164 –        while (fscanf(fp, "%d", &gn) == 1) {    /* get each glyph */
165 –                if (gn < 0 || gn > 127) {
166 –                        err = "illegal";
167 –                        goto fonterr;
168 –                }
169 –                if (ourfont[gn] != NULL) {
170 –                        err = "duplicate";
171 –                        goto fonterr;
172 –                }
173 –                if (fscanf(fp, "%d", &ngv) != 1 ||
174 –                                ngv < 0 || ngv > 255) {
175 –                        err = "bad # vertices for";
176 –                        goto fonterr;
177 –                }
178 –                g = (GLYPH *)malloc((2*ngv+1)*sizeof(GLYPH));
179 –                if (g == NULL)
180 –                        goto memerr;
181 –                ourfont[gn] = g;
182 –                *g++ = ngv;
183 –                ngv *= 2;
184 –                while (ngv--) {
185 –                        if (fscanf(fp, "%d", &gv) != 1 ||
186 –                                        gv < 0 || gv > 255) {
187 –                                err = "bad vertex for";
188 –                                goto fonterr;
189 –                        }
190 –                        *g++ = gv;
191 –                }
192 –        }
193 –        fclose(fp);
194 –        return;
195 – fonterr:
196 –        fprintf(stderr, "%s character (%d) in font file \"%s\"\n",
197 –                        err, gn, fontfile);
198 –        exit(1);
199 – memerr:
200 –        fprintf(stderr, "out of memory in loadfont\n");
201 –        exit(1);
202 – }
203 –
204 –
215   gettext(fp)                     /* get text from a file */
216   FILE  *fp;
217   {
208 –        char  *fgets();
218          char  buf[MAXLINE];
219          register LINE  *curl;
220          int  len;
221  
222          maxline = 0;
223 +        maxwidth = 0;
224          nlines = 0;
225          while (fgets(buf, MAXLINE, fp) != NULL) {
226                  curl = (LINE *)malloc(sizeof(LINE));
227                  if (curl == NULL)
228                          goto memerr;
229                  len = strlen(buf);
230 <                curl->s = malloc(len--);
231 <                if (curl->s == NULL)
230 >                curl->s = (char *)malloc(len);
231 >                curl->sp = (short *)malloc(sizeof(short)*len--);
232 >                if ((curl->s == NULL) | (curl->sp == NULL))
233                          goto memerr;
234 +                if (len > maxline)
235 +                        maxline = len;
236                  strncpy(curl->s, buf, len);
237                  curl->s[len] = '\0';
238 +                if (spacing < -1./256.)
239 +                        len = squeeztext(curl->sp, curl->s, ourfont,
240 +                                        (int)(spacing*-256.));
241 +                else if (spacing > 1./256.)
242 +                        len = proptext(curl->sp, curl->s, ourfont,
243 +                                        (int)(spacing*256.), 3);
244 +                else
245 +                        len = uniftext(curl->sp, curl->s, ourfont);
246 +                if (len > maxwidth)
247 +                        maxwidth = len;
248                  curl->next = ourtext;
249                  ourtext = curl;
227 –                if (len > maxline)
228 –                        maxline = len;
250                  nlines++;
251          }
252          return;
253   memerr:
254 <        fprintf(stderr, "out of memory in gettext\n");
234 <        exit(1);
254 >        error(SYSTEM, "Out of memory in gettext");
255   }
256  
257  
# Line 244 | Line 264 | char  *av[];
264          ourtext = (LINE *)malloc(sizeof(LINE));
265          if (ourtext == NULL)
266                  goto memerr;
267 <        ourtext->s = malloc(MAXLINE);
267 >        ourtext->s = (char *)malloc(MAXLINE);
268          if (ourtext->s == NULL)
269                  goto memerr;
270          for (cp = ourtext->s; ac-- > 0; av++) {
# Line 255 | Line 275 | char  *av[];
275          *--cp = '\0';
276          ourtext->next = NULL;
277          maxline = strlen(ourtext->s);
278 +        ourtext->sp = (short *)malloc(sizeof(short)*(maxline+1));
279 +        if (ourtext->sp == NULL)
280 +                goto memerr;
281 +        if (spacing < -1./256.)
282 +                maxwidth = squeeztext(ourtext->sp, ourtext->s, ourfont,
283 +                                (int)(spacing*-256.));
284 +        else if (spacing > 1./256.)
285 +                maxwidth = proptext(ourtext->sp, ourtext->s, ourfont,
286 +                                (int)(spacing*256.), 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");
262 <        exit(1);
292 >        error(SYSTEM, "Out of memory in arg_text");
293   }
294  
295  
296   maptext()                       /* map our text */
297   {
298          register LINE  *curl;
299 <        int  l;
300 <        register int  c;
299 >        int  l, len;
300 >        register int  i, c;
301  
302 <        for (l = 0, curl = ourtext; curl != NULL; l++, curl = curl->next)
303 <                for (c = strlen(curl->s)-1; c >= 0; c--)
304 <                        mapglyph(ourfont[curl->s[c]], c, l);
302 >        for (l = 0, curl = ourtext; curl != NULL; l += 256, curl = curl->next) {
303 >                len = strlen(curl->s); c = 0;
304 >                for (i = 0; i < len; i++) {
305 >                        c += curl->sp[i];
306 >                        mapglyph(ourfont->fg[curl->s[i]&0xff], c, l);
307 >                }
308 >        }
309   }
310  
311  
312   mapglyph(gl, tx0, ty0)          /* convert a glyph */
313 < register GLYPH  *gl;
313 > GLYPH  *gl;
314   int  tx0, ty0;
315   {
316          int  n;
317 +        register GORD  *gp;
318          int  p0[2], p1[2];
319  
320          if (gl == NULL)
321                  return;
322  
323 <        tx0 <<= 8; ty0 <<= 8;
324 <        n = *gl++;
325 <        mapcoord(p0, gl[2*n-2]+tx0, gl[2*n-1]+ty0);
323 >        n = gl->nverts;
324 >        gp = gvlist(gl);
325 >        mapcoord(p0, gp[2*n-2]+tx0, gp[2*n-1]+ty0);
326          while (n--) {
327 <                mapcoord(p1, gl[0]+tx0, gl[1]+ty0);
327 >                mapcoord(p1, gp[0]+tx0, gp[1]+ty0);
328                  mapedge(p0[0], p0[1], p1[0]-p0[0], p1[1]-p0[1]);
329                  p0[0] = p1[0]; p0[1] = p1[1];
330 <                gl += 2;
330 >                gp += 2;
331          }
332   }
333  
# Line 364 | 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                  }
444          }
445 <        free((char *)scanout);
445 >        free((void *)scanout);
446   }

Diff Legend

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