107 |
|
#endif |
108 |
|
|
109 |
|
|
110 |
+ |
fputresolu(ord, xres, yres, fp) /* put x and y resolution */ |
111 |
+ |
register int ord; |
112 |
+ |
int xres, yres; |
113 |
+ |
FILE *fp; |
114 |
+ |
{ |
115 |
+ |
if (ord&YMAJOR) |
116 |
+ |
fprintf(fp, "%cY %d %cX %d\n", |
117 |
+ |
ord&YDECR ? '-' : '+', yres, |
118 |
+ |
ord&XDECR ? '-' : '+', xres); |
119 |
+ |
else |
120 |
+ |
fprintf(fp, "%cX %d %cY %d\n", |
121 |
+ |
ord&XDECR ? '-' : '+', xres, |
122 |
+ |
ord&YDECR ? '-' : '+', yres); |
123 |
+ |
} |
124 |
+ |
|
125 |
+ |
|
126 |
+ |
fgetresolu(xrp, yrp, fp) /* get x and y resolution */ |
127 |
+ |
int *xrp, *yrp; |
128 |
+ |
FILE *fp; |
129 |
+ |
{ |
130 |
+ |
char buf[64], *xndx, *yndx; |
131 |
+ |
register char *cp; |
132 |
+ |
register int ord; |
133 |
+ |
|
134 |
+ |
if (fgets(buf, sizeof(buf), fp) == NULL) |
135 |
+ |
return(-1); |
136 |
+ |
xndx = yndx = NULL; |
137 |
+ |
for (cp = buf+1; *cp; cp++) |
138 |
+ |
if (*cp == 'X') |
139 |
+ |
xndx = cp; |
140 |
+ |
else if (*cp == 'Y') |
141 |
+ |
yndx = cp; |
142 |
+ |
if (xndx == NULL || yndx == NULL) |
143 |
+ |
return(-1); |
144 |
+ |
ord = 0; |
145 |
+ |
if (xndx > yndx) ord |= YMAJOR; |
146 |
+ |
if (xndx[-1] == '-') ord |= XDECR; |
147 |
+ |
if (yndx[-1] == '-') ord |= YDECR; |
148 |
+ |
if ((*xrp = atoi(xndx+1)) <= 0) |
149 |
+ |
return(-1); |
150 |
+ |
if ((*yrp = atoi(yndx+1)) <= 0) |
151 |
+ |
return(-1); |
152 |
+ |
return(ord); |
153 |
+ |
} |
154 |
+ |
|
155 |
+ |
|
156 |
|
fwritecolrs(scanline, len, fp) /* write out a colr scanline */ |
157 |
|
register COLR *scanline; |
158 |
|
int len; |
335 |
|
d = r > g ? r : g; |
336 |
|
if (b > d) d = b; |
337 |
|
|
338 |
< |
if (d <= 0.0) { |
338 |
> |
if (d <= 1e-32) { |
339 |
|
clr[RED] = clr[GRN] = clr[BLU] = 0; |
340 |
|
clr[EXP] = 0; |
341 |
|
return; |
354 |
|
register COLOR col; |
355 |
|
register COLR clr; |
356 |
|
{ |
357 |
< |
double ldexp(), f; |
357 |
> |
double f; |
358 |
|
|
359 |
|
if (clr[EXP] == 0) |
360 |
|
col[RED] = col[GRN] = col[BLU] = 0.0; |
367 |
|
} |
368 |
|
|
369 |
|
|
370 |
< |
#ifdef FREXP |
371 |
< |
double |
372 |
< |
frexp(x, ip) /* call it paranoia, I've seen the lib version */ |
373 |
< |
register double x; |
328 |
< |
int *ip; |
370 |
> |
normcolrs(scan, len, adjust) /* normalize a scanline of colrs */ |
371 |
> |
register COLR *scan; |
372 |
> |
int len; |
373 |
> |
int adjust; |
374 |
|
{ |
375 |
< |
int neg; |
376 |
< |
register int i; |
375 |
> |
register int c; |
376 |
> |
register int shift; |
377 |
|
|
378 |
< |
if (neg = (x < 0.0)) |
379 |
< |
x = -x; |
380 |
< |
else if (x == 0.0) { |
381 |
< |
*ip = 0; |
382 |
< |
return(0.0); |
378 |
> |
while (len-- > 0) { |
379 |
> |
shift = scan[0][EXP] + adjust - COLXS; |
380 |
> |
if (shift > 0) { |
381 |
> |
if (shift > 8) { |
382 |
> |
scan[0][RED] = |
383 |
> |
scan[0][GRN] = |
384 |
> |
scan[0][BLU] = 255; |
385 |
> |
} else { |
386 |
> |
shift--; |
387 |
> |
c = (scan[0][RED]<<1 | 1) << shift; |
388 |
> |
scan[0][RED] = c > 255 ? 255 : c; |
389 |
> |
c = (scan[0][GRN]<<1 | 1) << shift; |
390 |
> |
scan[0][GRN] = c > 255 ? 255 : c; |
391 |
> |
c = (scan[0][BLU]<<1 | 1) << shift; |
392 |
> |
scan[0][BLU] = c > 255 ? 255 : c; |
393 |
> |
} |
394 |
> |
} else if (shift < 0) { |
395 |
> |
if (shift < -8) { |
396 |
> |
scan[0][RED] = |
397 |
> |
scan[0][GRN] = |
398 |
> |
scan[0][BLU] = 0; |
399 |
> |
} else { |
400 |
> |
shift = -1-shift; |
401 |
> |
scan[0][RED] = ((scan[0][RED]>>shift)+1)>>1; |
402 |
> |
scan[0][GRN] = ((scan[0][GRN]>>shift)+1)>>1; |
403 |
> |
scan[0][BLU] = ((scan[0][BLU]>>shift)+1)>>1; |
404 |
> |
} |
405 |
> |
} |
406 |
> |
scan[0][EXP] = COLXS - adjust; |
407 |
> |
scan++; |
408 |
|
} |
339 |
– |
if (x < 0.5) |
340 |
– |
for (i = 0; x < 0.5; i--) |
341 |
– |
x *= 2.0; |
342 |
– |
else |
343 |
– |
for (i = 0; x >= 1.0; i++) |
344 |
– |
x /= 2.0; |
345 |
– |
*ip = i; |
346 |
– |
if (neg) |
347 |
– |
return(-x); |
348 |
– |
else |
349 |
– |
return(x); |
409 |
|
} |
410 |
< |
#endif |
410 |
> |
|
411 |
> |
|
412 |
> |
bigdiff(c1, c2, md) /* c1 delta c2 > md? */ |
413 |
> |
register COLOR c1, c2; |
414 |
> |
double md; |
415 |
> |
{ |
416 |
> |
register int i; |
417 |
> |
|
418 |
> |
for (i = 0; i < 3; i++) |
419 |
> |
if (colval(c1,i)-colval(c2,i) > md*colval(c2,i) || |
420 |
> |
colval(c2,i)-colval(c1,i) > md*colval(c1,i)) |
421 |
> |
return(1); |
422 |
> |
return(0); |
423 |
> |
} |