| 11 |
|
#include "standard.h" |
| 12 |
|
#include "cmatrix.h" |
| 13 |
|
#include "platform.h" |
| 14 |
+ |
#include "resolu.h" |
| 15 |
|
|
| 16 |
+ |
const char *cm_fmt_id[] = { |
| 17 |
+ |
"unknown", "ascii", "float", "double", |
| 18 |
+ |
COLRFMT, CIEFMT |
| 19 |
+ |
}; |
| 20 |
+ |
|
| 21 |
+ |
const int cm_elem_size[] = { |
| 22 |
+ |
0, 0, 3*sizeof(float), 3*sizeof(double), 4, 4 |
| 23 |
+ |
}; |
| 24 |
+ |
|
| 25 |
|
/* Allocate a color coefficient matrix */ |
| 26 |
|
CMATRIX * |
| 27 |
|
cm_alloc(int nrows, int ncols) |
| 31 |
|
if ((nrows <= 0) | (ncols <= 0)) |
| 32 |
|
error(USER, "attempt to create empty matrix"); |
| 33 |
|
cm = (CMATRIX *)malloc(sizeof(CMATRIX) + |
| 34 |
< |
3*sizeof(COLORV)*(nrows*ncols - 1)); |
| 34 |
> |
sizeof(COLOR)*(nrows*ncols - 1)); |
| 35 |
|
if (cm == NULL) |
| 36 |
|
error(SYSTEM, "out of memory in cm_alloc()"); |
| 37 |
|
cm->nrows = nrows; |
| 50 |
|
return(NULL); |
| 51 |
|
} |
| 52 |
|
cm = (CMATRIX *)realloc(cm, sizeof(CMATRIX) + |
| 53 |
< |
3*sizeof(COLORV)*(nrows*cm->ncols - 1)); |
| 53 |
> |
sizeof(COLOR)*(nrows*cm->ncols - 1)); |
| 54 |
|
if (cm == NULL) |
| 55 |
|
error(SYSTEM, "out of memory in cm_resize()"); |
| 56 |
|
cm->nrows = nrows; |
| 61 |
|
getDT(char *s, void *p) |
| 62 |
|
{ |
| 63 |
|
char fmt[32]; |
| 64 |
+ |
int i; |
| 65 |
|
|
| 66 |
< |
if (formatval(fmt, s)) { |
| 67 |
< |
if (!strcmp(fmt, "ascii")) |
| 68 |
< |
*((int *)p) = DTascii; |
| 69 |
< |
else if (!strcmp(fmt, "float")) |
| 70 |
< |
*((int *)p) = DTfloat; |
| 60 |
< |
else if (!strcmp(fmt, "double")) |
| 61 |
< |
*((int *)p) = DTdouble; |
| 62 |
< |
else if (!strcmp(fmt, COLRFMT)) |
| 63 |
< |
*((int *)p) = DTrgbe; |
| 64 |
< |
else if (!strcmp(fmt, CIEFMT)) |
| 65 |
< |
*((int *)p) = DTxyze; |
| 66 |
< |
} |
| 66 |
> |
if (!formatval(fmt, s)) |
| 67 |
> |
return(0); |
| 68 |
> |
for (i = 1; i < DTend; i++) |
| 69 |
> |
if (!strcmp(fmt, cm_fmt_id[i])) |
| 70 |
> |
*((int *)p) = i; |
| 71 |
|
return(0); |
| 72 |
|
} |
| 73 |
|
|
| 169 |
|
break; |
| 170 |
|
} |
| 171 |
|
} else { /* read binary file */ |
| 172 |
< |
if (sizeof(COLORV) == (dtype==DTfloat ? sizeof(float) : |
| 169 |
< |
sizeof(double))) { |
| 172 |
> |
if (sizeof(COLOR) == cm_elem_size[dtype]) { |
| 173 |
|
int nread = 0; |
| 174 |
|
do { /* read all we can */ |
| 175 |
|
nread += fread(cm->cmem + 3*nread, |
| 176 |
< |
3*sizeof(COLORV), |
| 176 |
> |
sizeof(COLOR), |
| 177 |
|
cm->nrows*cm->ncols - nread, |
| 178 |
|
fp); |
| 179 |
|
if (nrows <= 0) { /* unknown length */ |
| 315 |
|
for (dr = 0; dr < cmr->nrows; dr++) |
| 316 |
|
for (dc = 0; dc < cmr->ncols; dc++) { |
| 317 |
|
COLORV *dp = cm_lval(cmr,dr,dc); |
| 318 |
+ |
double res[3]; |
| 319 |
|
dp[0] = dp[1] = dp[2] = 0; |
| 320 |
|
if (rowcheck != NULL && !rowcheck[dr]) |
| 321 |
|
continue; |
| 322 |
|
if (colcheck != NULL && !colcheck[dc]) |
| 323 |
|
continue; |
| 324 |
+ |
res[0] = res[1] = res[2] = 0; |
| 325 |
|
for (i = 0; i < cm1->ncols; i++) { |
| 326 |
|
const COLORV *cp1 = cm_lval(cm1,dr,i); |
| 327 |
|
const COLORV *cp2 = cm_lval(cm2,i,dc); |
| 328 |
< |
dp[0] += cp1[0] * cp2[0]; |
| 329 |
< |
dp[1] += cp1[1] * cp2[1]; |
| 330 |
< |
dp[2] += cp1[2] * cp2[2]; |
| 328 |
> |
res[0] += cp1[0] * cp2[0]; |
| 329 |
> |
res[1] += cp1[1] * cp2[1]; |
| 330 |
> |
res[2] += cp1[2] * cp2[2]; |
| 331 |
|
} |
| 332 |
+ |
copycolor(dp, res); |
| 333 |
|
} |
| 334 |
|
if (rowcheck != NULL) free(rowcheck); |
| 335 |
|
if (colcheck != NULL) free(colcheck); |
| 336 |
|
return(cmr); |
| 337 |
|
} |
| 338 |
|
|
| 339 |
< |
/* print out matrix as ASCII text -- no header */ |
| 340 |
< |
void |
| 341 |
< |
cm_print(const CMATRIX *cm, FILE *fp) |
| 339 |
> |
/* write out matrix to file (precede by resolution string if picture) */ |
| 340 |
> |
int |
| 341 |
> |
cm_write(const CMATRIX *cm, int dtype, FILE *fp) |
| 342 |
|
{ |
| 343 |
< |
int r, c; |
| 344 |
< |
const COLORV *mp = cm->cmem; |
| 345 |
< |
|
| 346 |
< |
for (r = 0; r < cm->nrows; r++) { |
| 347 |
< |
for (c = 0; c < cm->ncols; c++, mp += 3) |
| 348 |
< |
fprintf(fp, "\t%.6e %.6e %.6e", mp[0], mp[1], mp[2]); |
| 349 |
< |
fputc('\n', fp); |
| 343 |
> |
static const char tabEOL[2] = {'\t','\n'}; |
| 344 |
> |
const COLORV *mp = cm->cmem; |
| 345 |
> |
int r, c; |
| 346 |
> |
|
| 347 |
> |
switch (dtype) { |
| 348 |
> |
case DTascii: |
| 349 |
> |
for (r = 0; r < cm->nrows; r++) |
| 350 |
> |
for (c = 0; c < cm->ncols; c++, mp += 3) |
| 351 |
> |
fprintf(fp, "%.6e %.6e %.6e%c", |
| 352 |
> |
mp[0], mp[1], mp[2], |
| 353 |
> |
tabEOL[c >= cm->ncols-1]); |
| 354 |
> |
break; |
| 355 |
> |
case DTfloat: |
| 356 |
> |
case DTdouble: |
| 357 |
> |
if (sizeof(COLOR) == cm_elem_size[dtype]) { |
| 358 |
> |
r = cm->ncols*cm->nrows; |
| 359 |
> |
while (r > 0) { |
| 360 |
> |
c = fwrite(mp, sizeof(COLOR), r, fp); |
| 361 |
> |
if (c <= 0) |
| 362 |
> |
return(0); |
| 363 |
> |
mp += 3*c; |
| 364 |
> |
r -= c; |
| 365 |
> |
} |
| 366 |
> |
} else if (dtype == DTdouble) { |
| 367 |
> |
double dc[3]; |
| 368 |
> |
r = cm->ncols*cm->nrows; |
| 369 |
> |
while (r--) { |
| 370 |
> |
copycolor(dc, mp); |
| 371 |
> |
if (fwrite(dc, sizeof(double), 3, fp) != 3) |
| 372 |
> |
return(0); |
| 373 |
> |
mp += 3; |
| 374 |
> |
} |
| 375 |
> |
} else /* dtype == DTfloat */ { |
| 376 |
> |
float fc[3]; |
| 377 |
> |
r = cm->ncols*cm->nrows; |
| 378 |
> |
while (r--) { |
| 379 |
> |
copycolor(fc, mp); |
| 380 |
> |
if (fwrite(fc, sizeof(float), 3, fp) != 3) |
| 381 |
> |
return(0); |
| 382 |
> |
mp += 3; |
| 383 |
> |
} |
| 384 |
> |
} |
| 385 |
> |
break; |
| 386 |
> |
case DTrgbe: |
| 387 |
> |
case DTxyze: |
| 388 |
> |
fprtresolu(cm->ncols, cm->nrows, fp); |
| 389 |
> |
for (r = 0; r < cm->nrows; r++, mp += 3*cm->ncols) |
| 390 |
> |
if (fwritescan((COLOR *)mp, cm->ncols, fp) < 0) |
| 391 |
> |
return(0); |
| 392 |
> |
break; |
| 393 |
> |
default: |
| 394 |
> |
fputs("Unsupported data type in cm_write()!\n", stderr); |
| 395 |
> |
return(0); |
| 396 |
|
} |
| 397 |
+ |
return(fflush(fp) == 0); |
| 398 |
|
} |
