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

Comparing ray/src/px/oki20c.c (file contents):
Revision 1.6 by greg, Fri Oct 20 16:44:34 1989 UTC vs.
Revision 2.15 by schorsch, Mon Nov 10 12:28:56 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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   *  oki20c.c - program to dump pixel file to OkiMate 20 color printer.
9 – *
10 – *     6/10/87
6   */
7  
8   #include  <stdio.h>
9 + #include  <time.h>
10  
11 + #include  "platform.h"
12 + #include  "rtprocess.h"
13   #include  "color.h"
14 + #include  "resolu.h"
15  
16 + #define  NROWS          1440            /* 10" at 144 dpi */
17 + #define  NCOLS          960             /* 8" at 120 dpi */
18  
19 < #define  NROWS          1440            /* 10" at 144 dpi */
19 < #define  NCOLS          960             /* 8" at 120 dpi */
19 > #define  ASPECT         (120./144.)     /* pixel aspect ratio */
20  
21 + #define  FILTER         "pfilt -1 -x %d -y %d -p %f",NCOLS,NROWS,ASPECT
22 + #define  FILTER_F       "pfilt -1 -x %d -y %d -p %f \"%s\"",NCOLS,NROWS,ASPECT
23 +
24   /*
25 < *  Subtractive primaries are ordered:  Yellow, Magenta, Cyan.
25 > *  Subtractive primaries are ordered:  Yellow, Magenta, Cyan.
26   */
27  
28 < #define  sub_add(sub)   (2-(sub))       /* map subtractive to additive pri. */
28 > #define  sub_add(sub)   (2-(sub))       /* map subtractive to additive pri. */
29  
30 + long  lpat[NCOLS][3];
31  
32 + int  dofilter = 0;              /* filter through pfilt first? */
33 +
34 +
35   main(argc, argv)
36   int  argc;
37   char  *argv[];
38   {
39          int  i, status = 0;
40 <        
40 >        SET_DEFAULT_BINARY();
41 >        SET_FILE_BINARY(stdin);
42 >        SET_FILE_BINARY(stdout);
43 >        if (argc > 1 && !strcmp(argv[1], "-p")) {
44 >                dofilter++;
45 >                argv++; argc--;
46 >        }
47          if (argc < 2)
48                  status = printp(NULL) == -1;
49          else
# Line 43 | Line 56 | char  *argv[];
56   printp(fname)                           /* print a picture */
57   char  *fname;
58   {
59 +        char  buf[PATH_MAX];
60          FILE  *input;
61          int  xres, yres;
62          COLR  scanline[NCOLS];
63          int  i;
64  
65 <        if (fname == NULL) {
65 >        if (dofilter) {
66 >                if (fname == NULL) {
67 >                        sprintf(buf, FILTER);
68 >                        fname = "<stdin>";
69 >                } else
70 >                        sprintf(buf, FILTER_F, fname);
71 >                if ((input = popen(buf, "r")) == NULL) {
72 >                        fprintf(stderr, "Cannot execute: %s\n", buf);
73 >                        return(-1);
74 >                }
75 >        } else if (fname == NULL) {
76                  input = stdin;
77                  fname = "<stdin>";
78          } else if ((input = fopen(fname, "r")) == NULL) {
# Line 56 | Line 80 | char  *fname;
80                  return(-1);
81          }
82                                  /* discard header */
83 <        getheader(input, NULL);
83 >        if (checkheader(input, COLRFMT, NULL) < 0) {
84 >                fprintf(stderr, "%s: not a Radiance picture\n", fname);
85 >                return(-1);
86 >        }
87                                  /* get picture dimensions */
88 <        if (fgetresolu(&xres, &yres, input) != (YMAJOR|YDECR)) {
88 >        if (fgetresolu(&xres, &yres, input) < 0) {
89                  fprintf(stderr, "%s: bad picture size\n", fname);
90                  return(-1);
91          }
92 <        if (xres > NCOLS || yres > NROWS) {
92 >        if (xres > NCOLS) {
93                  fprintf(stderr, "%s: resolution mismatch\n", fname);
94                  return(-1);
95          }
# Line 74 | Line 101 | char  *fname;
101                          fprintf(stderr, "%s: read error (y=%d)\n", fname, i);
102                          return(-1);
103                  }
104 <                normscan(scanline, xres);
104 >                normcolrs(scanline, xres, 0);
105                  plotscan(scanline, xres, i);
106          }
107                                  /* advance page */
108          putchar('\f');
109          
110 <        fclose(input);
110 >        if (dofilter)
111 >                pclose(input);
112 >        else
113 >                fclose(input);
114  
115          return(0);
116   }
117  
118  
89 – normscan(scan, len)                     /* normalize a scanline */
90 – register COLR  scan[];
91 – int  len;
92 – {
93 –        register int  i;
94 –
95 –        for (i = 0; i < len; i++)
96 –                colr_norm(scan[i], scan[i]);
97 – }
98 –
99 –
119   plotscan(scan, len, y)                  /* plot a scanline */
120   COLR  scan[];
121   int  len;
122   int  y;
123   {
105 –        static long  pat[NCOLS][3];
124          int  bpos;
125          register long  c;
126          register int  i, j;
127  
128 <        if (bpos = y % 23) {
128 >        if ( (bpos = y % 23) ) {
129  
130                  for (j = 0; j < 3; j++)
131                          for (i = 0; i < len; i++)
132 <                                pat[i][j] |= (long)colbit(scan[i],i,j) << bpos;
132 >                                lpat[i][j] |= (long)colbit(scan[i],i,j) << bpos;
133 >                return;
134 >        }
135 >        fputs("\033\031", stdout);
136  
137 <        } else {
138 <
139 <                fputs("\033\031", stdout);
140 <
141 <                for (j = 0; j < 3; j++) {
142 <                        fputs("\033%O", stdout);
143 <                        putchar(len & 255);
144 <                        putchar(len >> 8);
145 <                        for (i = 0; i < len; i++) {
125 <                                c = pat[i][j] | colbit(scan[i],i,j);
126 <                                                        /* repeat this row */
127 <                                pat[i][j] = (c & 1) << 23;
128 <                                putchar(c>>16);
129 <                                putchar(c>>8 & 255);
130 <                                putchar(c & 255);
131 <                        }
132 <                        putchar('\r');
137 >        for (j = 0; j < 3; j++) {
138 >                i = (NCOLS + len)/2;            /* center image */
139 >                fputs("\033%O", stdout);
140 >                putchar(i & 255);
141 >                putchar(i >> 8);
142 >                while (i-- > len) {
143 >                        putchar(0);
144 >                        putchar(0);
145 >                        putchar(0);
146                  }
147 <                putchar('\n');
147 >                for (i = 0; i < len; i++) {
148 >                        c = lpat[i][j] | colbit(scan[i],i,j);
149 >                        putchar((int)(c>>16));
150 >                        putchar((int)(c>>8 & 255));
151 >                        putchar((int)(c & 255));
152 >                        if (y)                  /* repeat this row */
153 >                                lpat[i][j] = (c & 1) << 23;
154 >                        else                    /* or clear for next image */
155 >                                lpat[i][j] = 0L;
156 >                }
157 >                putchar('\r');
158          }
159 +        putchar('\n');
160 +        fflush(stdout);
161   }
162  
163  
# Line 143 | Line 168 | int  s;
168   {
169          static int  cerr[NCOLS][3];
170          static int  err[3];
171 <        int  b;
171 >        int  b, errp;
172          register int  a, ison;
173  
174          a = sub_add(s);                 /* use additive primary */
175          b = col[a];
176 +        errp = err[a];
177          err[a] += b + cerr[x][a];
178          ison = err[a] < 128;
179          if (!ison) err[a] -= 256;
180 <        cerr[x][a] = err[a] /= 2;
180 >        err[a] /= 3;
181 >        cerr[x][a] = err[a] + errp;
182          return(ison);
183   }

Diff Legend

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