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.10 by greg, Tue Jul 7 18:24:34 1992 UTC vs.
Revision 2.27 by greg, Fri May 20 02:06:39 2011 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1992 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  "standard.h"
10 > #include  "copyright.h"
11  
12 < #include  "color.h"
12 > #include  <string.h>
13  
14 + #include  "platform.h"
15 + #include  "standard.h"
16 + #include  "resolu.h"
17 + #include  "color.h"
18   #include  "font.h"
19  
20 < #ifndef  SSS
21 < #define  SSS                    3       /* super-sample size */
20 > #ifndef  SSS
21 > #define  SSS                    3       /* super-sample size */
22   #endif
23  
24 < #define  MAXLINE                512     /* longest allowable line */
24 > #define  MAXLINE                512     /* longest allowable line */
25  
25 – #ifndef  DEFPATH
26 – #define  DEFPATH                ":/usr/local/lib/ray"
27 – #endif
28 – #ifndef  ULIBVAR
29 – #define  ULIBVAR                "RAYPATH"
30 – #endif
31 –
26   char  *fontfile = "helvet.fnt";         /* our font file */
27  
28   COLOR  bgcolor = WHTCOLOR;              /* background color */
# Line 37 | Line 31 | COLOR  fgcolor = BLKCOLOR;             /* foreground color */
31   int  direct = 'r';                      /* direction (right, up, left, down) */
32  
33   int  cheight = 32*SSS;                  /* character height */
34 < double  aspect = 1.67;                  /* height/width character aspect */
35 < double  spacing = 0.0;                  /* character spacing */
34 > double  aspect = 1.67;                  /* height/width character aspect */
35 > double  spacing = 0.0;                  /* character spacing */
36   int  cwidth;                            /* computed character width */
37  
38   unsigned char  *ourbitmap;              /* our output bitmap */
39   int  xsiz, ysiz;                        /* bitmap dimensions */
40   int  xdim;                              /* size of horizontal scan (bytes) */
41  
42 < #define  bitop(x,y,op)          (ourbitmap[(y)*xdim+((x)>>3)] op (1<<((x)&7)))
43 < #define  tstbit(x,y)            bitop(x,y,&)
44 < #define  setbit(x,y)            bitop(x,y,|=)
45 < #define  clrbit(x,y)            bitop(x,y,&=~)
46 < #define  tglbit(x,y)            bitop(x,y,^=)
42 >                                /* conflicting def's in param.h */
43 > #undef  tstbit
44 > #undef  setbit
45 > #undef  clrbit
46 > #undef  tglbit
47  
48 + #define  bitop(x,y,op)          (ourbitmap[(y)*xdim+((x)>>3)] op (1<<((x)&7)))
49 + #define  tstbit(x,y)            bitop(x,y,&)
50 + #define  setbit(x,y)            bitop(x,y,|=)
51 + #define  clrbit(x,y)            bitop(x,y,&=~)
52 + #define  tglbit(x,y)            bitop(x,y,^=)
53 +
54   FONT  *ourfont;                         /* our font */
55  
56 – char  *libpath;                         /* library search path */
57 –
56   typedef struct line {
57          char  *s;               /* line w/o LF */
58          short  *sp;             /* character spacing */
# Line 65 | Line 63 | LINE  *ourtext;                                /* our text */
63   int  nlines, maxline;                   /* text dimensions */
64   int  maxwidth;                          /* maximum line width (dvi) */
65  
66 < extern char  *getenv();
66 > static void makemap(void);
67 > static void get_text(FILE  *fp);
68 > static void arg_text(int  ac, char  *av[]);
69 > static void maptext(void);
70 > static void mapglyph(GLYPH  *gl, int  tx0, int  ty0);
71 > static void mapcoord(int  p[2], int  tx, int  ty);
72 > static void mapedge(int  x, int  y, int  run, int  rise);
73 > static void writemap(FILE  *fp);
74  
75  
76 < main(argc, argv)
77 < int  argc;
78 < char  *argv[];
76 > int
77 > main(
78 >        int  argc,
79 >        char  *argv[]
80 > )
81   {
82          int  an;
83 <
83 >        SET_FILE_BINARY(stdout);
84          for (an = 1; an < argc && argv[an][0] == '-'; an++)
85                  switch (argv[an][1]) {
86                  case 'c':                       /* color */
# Line 117 | Line 124 | char  *argv[];
124                          break;
125                  case 'h':                       /* height of characters */
126                          cheight = atoi(argv[++an])*SSS;
120 –                        xsiz = xsiz = 0;
127                          break;
128                  case 'a':                       /* aspect ratio */
129                          aspect = atof(argv[++an]);
# Line 132 | Line 138 | unkopt:
138                          exit(1);
139                  }
140                                          /* load font file */
135 –        if ((libpath = getenv(ULIBVAR)) == NULL)
136 –                libpath = DEFPATH;
141          ourfont = getfont(fontfile);
142                                          /* get text */
143          if (an == argc)
144 <                gettext(stdin);
144 >                get_text(stdin);
145          else
146                  arg_text(argc-an, argv+an);
147  
# Line 146 | Line 150 | unkopt:
150                                          /* convert text to bitmap */
151          maptext();
152                                          /* print header */
153 +        newheader("RADIANCE", stdout);
154          printargs(argc, argv, stdout);
155          fputformat(COLRFMT, stdout);
156          putchar('\n');
# Line 156 | Line 161 | unkopt:
161   }
162  
163  
164 < makemap()                       /* create the bit map */
164 > static void
165 > makemap(void)                   /* create the bit map */
166   {
167 <        double  pictaspect;
167 >        double  pictaspect;
168          
169          if (direct == 'r' || direct == 'l') {
170 <                if (xsiz == 0 || ysiz == 0) {
170 >                if (xsiz <= 0) {
171                          cwidth = cheight/aspect + 0.5;
172                          xsiz = (long)maxwidth*cwidth >> 8;
173                          ysiz = nlines*cheight;
174                  } else if (aspect > FTINY) {
175 +                        if (ysiz <= 0)
176 +                                ysiz = cheight*nlines;
177                          pictaspect = 256*nlines*aspect/maxwidth;
178                          if (pictaspect*xsiz < ysiz)
179                                  ysiz = pictaspect*xsiz + 0.5;
180                          else
181                                  xsiz = ysiz/pictaspect + 0.5;
182                          cheight = ysiz/nlines;
183 <                        cwidth = cheight/aspect + 0.5;
183 >                        cwidth = cheight/aspect;
184                  } else {
185 +                        if (ysiz <= 0)
186 +                                ysiz = cheight*nlines;
187                          pictaspect = (double)ysiz/xsiz;
188                          aspect = pictaspect*maxwidth/(256*nlines);
189                          cheight = ysiz/nlines;
190 <                        cwidth = cheight/aspect + 0.5;
190 >                        cwidth = cheight/aspect;
191                  }
192          } else {                        /* reverse orientation */
193 <                if (xsiz == 0 || ysiz == 0) {
193 >                if (ysiz <= 0) {
194                          cwidth = cheight/aspect + 0.5;
195                          xsiz = nlines*cheight;
196                          ysiz = (long)maxwidth*cwidth >> 8;
197                  } else if (aspect > FTINY) {
198 +                        if (xsiz <= 0)
199 +                                xsiz = cheight*nlines;
200                          pictaspect = maxwidth/(256*nlines*aspect);
201                          if (pictaspect*xsiz < ysiz)
202                                  ysiz = pictaspect*xsiz + 0.5;
203                          else
204                                  xsiz = ysiz/pictaspect + 0.5;
205                          cheight = xsiz/nlines;
206 <                        cwidth = cheight/aspect + 0.5;
206 >                        cwidth = cheight/aspect;
207                  } else {
208 +                        if (xsiz <= 0)
209 +                                xsiz = cheight*nlines;
210                          pictaspect = (double)ysiz/xsiz;
211                          aspect = maxwidth/(256*nlines*pictaspect);
212                          cheight = xsiz/nlines;
213 <                        cwidth = cheight/aspect + 0.5;
213 >                        cwidth = cheight/aspect;
214                  }
215          }
216          if (xsiz % SSS)
# Line 204 | Line 218 | makemap()                      /* create the bit map */
218          if (ysiz % SSS)
219                  ysiz += SSS - ysiz%SSS;
220          xdim = (xsiz+7)/8;
221 <        ourbitmap = (BYTE *)bmalloc(ysiz*xdim);
221 >        ourbitmap = (uby8 *)bmalloc(ysiz*xdim);
222          if (ourbitmap == NULL)
223                  error(SYSTEM, "Out of memory in makemap");
224 <        bzero((char *)ourbitmap, ysiz*xdim);
224 >        memset((char *)ourbitmap, '\0', ysiz*xdim);
225   }
226  
227  
228 < gettext(fp)                     /* get text from a file */
229 < FILE  *fp;
228 > static void
229 > get_text(                       /* get text from a file */
230 >        FILE  *fp
231 > )
232   {
217 –        char  *fgets();
233          char  buf[MAXLINE];
234          register LINE  *curl;
235          int  len;
# Line 227 | Line 242 | FILE  *fp;
242                  if (curl == NULL)
243                          goto memerr;
244                  len = strlen(buf);
245 <                curl->s = malloc(len);
245 >                curl->s = (char *)malloc(len);
246                  curl->sp = (short *)malloc(sizeof(short)*len--);
247 <                if (curl->s == NULL | curl->sp == NULL)
247 >                if ((curl->s == NULL) | (curl->sp == NULL))
248                          goto memerr;
249                  if (len > maxline)
250                          maxline = len;
# Line 237 | Line 252 | FILE  *fp;
252                  curl->s[len] = '\0';
253                  if (spacing < -1./256.)
254                          len = squeeztext(curl->sp, curl->s, ourfont,
255 <                                        (int)(spacing*-256.0));
255 >                                        (int)(spacing*-256.));
256                  else if (spacing > 1./256.)
257                          len = proptext(curl->sp, curl->s, ourfont,
258 <                                        (int)(spacing*256.0), 3);
258 >                                        (int)(spacing*256.), 3);
259                  else
260                          len = uniftext(curl->sp, curl->s, ourfont);
261                  if (len > maxwidth)
# Line 251 | Line 266 | FILE  *fp;
266          }
267          return;
268   memerr:
269 <        error(SYSTEM, "Out of memory in gettext");
269 >        error(SYSTEM, "Out of memory in get_text");
270   }
271  
272  
273 < arg_text(ac, av)                        /* get text from arguments */
274 < int  ac;
275 < char  *av[];
273 > static void
274 > arg_text(                       /* get text from arguments */
275 >        int  ac,
276 >        char  *av[]
277 > )
278   {
279          register char  *cp;
280  
281          ourtext = (LINE *)malloc(sizeof(LINE));
282          if (ourtext == NULL)
283                  goto memerr;
284 <        ourtext->s = malloc(MAXLINE);
284 >        ourtext->s = (char *)malloc(MAXLINE);
285          if (ourtext->s == NULL)
286                  goto memerr;
287          for (cp = ourtext->s; ac-- > 0; av++) {
# Line 278 | Line 295 | char  *av[];
295          ourtext->sp = (short *)malloc(sizeof(short)*(maxline+1));
296          if (ourtext->sp == NULL)
297                  goto memerr;
298 <        if (spacing < 0.0)
298 >        if (spacing < -1./256.)
299                  maxwidth = squeeztext(ourtext->sp, ourtext->s, ourfont,
300 <                                (int)(spacing*-256.0));
301 <        else if (spacing > 0.0)
300 >                                (int)(spacing*-256.));
301 >        else if (spacing > 1./256.)
302                  maxwidth = proptext(ourtext->sp, ourtext->s, ourfont,
303 <                                (int)(spacing*256.0), 3);
303 >                                (int)(spacing*256.), 3);
304          else
305                  maxwidth = uniftext(ourtext->sp, ourtext->s, ourfont);
306          nlines = 1;
# Line 293 | Line 310 | memerr:
310   }
311  
312  
313 < maptext()                       /* map our text */
313 > static void
314 > maptext(void)                   /* map our text */
315   {
316          register LINE  *curl;
317          int  l, len;
# Line 309 | Line 327 | maptext()                      /* map our text */
327   }
328  
329  
330 < mapglyph(gl, tx0, ty0)          /* convert a glyph */
331 < GLYPH  *gl;
332 < int  tx0, ty0;
330 > static void
331 > mapglyph(               /* convert a glyph */
332 >        GLYPH  *gl,
333 >        int  tx0,
334 >        int  ty0
335 > )
336   {
337          int  n;
338          register GORD  *gp;
# Line 332 | Line 353 | int  tx0, ty0;
353   }
354  
355  
356 < mapcoord(p, tx, ty)             /* map text to picture coordinates */
357 < int  p[2], tx, ty;
356 > static void
357 > mapcoord(               /* map text to picture coordinates */
358 >        int  p[2],
359 >        int  tx,
360 >        int  ty
361 > )
362   {
363          tx = (long)tx*cwidth >> 8;
364          ty = (long)ty*cheight >> 8;
# Line 359 | Line 384 | int  p[2], tx, ty;
384   }
385  
386  
387 < mapedge(x, y, run, rise)                /* map an edge */
388 < register int  x, y;
389 < int  run, rise;
387 > static void
388 > mapedge(                /* map an edge */
389 >        register int  x,
390 >        register int  y,
391 >        int  run,
392 >        int  rise
393 > )
394   {
395          int  xstep;
396          int  rise2, run2;
# Line 396 | Line 425 | int  run, rise;
425   }
426  
427  
428 < writemap(fp)                    /* write out bitmap */
429 < FILE  *fp;
428 > static void
429 > writemap(                       /* write out bitmap */
430 >        FILE  *fp
431 > )
432   {
433          COLR  pixval[SSS*SSS+1];        /* possible pixel values */
434          COLOR  ctmp0, ctmp1;
435 <        double  d;
435 >        double  d;
436          COLR  *scanout;
437          int  x, y;
438          register int  i, j;
# Line 442 | Line 473 | FILE  *fp;
473                          exit(1);
474                  }
475          }
476 <        free((char *)scanout);
476 >        free((void *)scanout);
477   }

Diff Legend

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