ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/cmatrix.c
Revision: 2.35
Committed: Wed Apr 27 01:31:56 2022 UTC (5 months, 1 week ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: HEAD
Changes since 2.34: +5 -3 lines
Log Message:
fix(dctimestep): Repaired automatic detection of number of input rows

File Contents

# Content
1 #ifndef lint
2 static const char RCSid[] = "$Id: cmatrix.c,v 2.34 2022/03/11 17:15:42 greg Exp $";
3 #endif
4 /*
5 * Color matrix routines.
6 *
7 * G. Ward
8 */
9
10 #include <ctype.h>
11 #include "platform.h"
12 #include "standard.h"
13 #include "cmatrix.h"
14 #include "platform.h"
15 #include "paths.h"
16 #include "resolu.h"
17
18 const char stdin_name[] = "<stdin>";
19
20 const char *cm_fmt_id[] = {
21 "unknown", COLRFMT, CIEFMT,
22 "float", "ascii", "double"
23 };
24
25 const int cm_elem_size[] = {
26 0, 4, 4, 3*sizeof(float), 0, 3*sizeof(double)
27 };
28
29 /* Allocate a color coefficient matrix */
30 CMATRIX *
31 cm_alloc(int nrows, int ncols)
32 {
33 CMATRIX *cm;
34
35 if ((nrows <= 0) | (ncols <= 0))
36 error(USER, "attempt to create empty matrix");
37 cm = (CMATRIX *)malloc(sizeof(CMATRIX) +
38 sizeof(COLOR)*((size_t)nrows*ncols - 1));
39 if (!cm)
40 error(SYSTEM, "out of memory in cm_alloc()");
41 cm->nrows = nrows;
42 cm->ncols = ncols;
43 return(cm);
44 }
45
46 static void
47 adjacent_ra_sizes(size_t bounds[2], size_t target)
48 {
49 bounds[0] = 0; bounds[1] = 2048;
50 while (bounds[1] < target) {
51 bounds[0] = bounds[1];
52 bounds[1] += bounds[1]>>1;
53 }
54 }
55
56 /* Resize color coefficient matrix */
57 CMATRIX *
58 cm_resize(CMATRIX *cm, int nrows)
59 {
60 size_t old_size, new_size, ra_bounds[2];
61
62 if (!cm)
63 return(NULL);
64 if (nrows == cm->nrows)
65 return(cm);
66 if (nrows <= 0) {
67 cm_free(cm);
68 return(NULL);
69 }
70 old_size = sizeof(CMATRIX) + sizeof(COLOR)*((size_t)cm->nrows*cm->ncols - 1);
71 adjacent_ra_sizes(ra_bounds, old_size);
72 new_size = sizeof(CMATRIX) + sizeof(COLOR)*((size_t)nrows*cm->ncols - 1);
73 if (nrows < cm->nrows ? new_size <= ra_bounds[0] :
74 new_size > ra_bounds[1]) {
75 adjacent_ra_sizes(ra_bounds, new_size);
76 cm = (CMATRIX *)realloc(cm, ra_bounds[1]);
77 if (!cm)
78 error(SYSTEM, "out of memory in cm_resize()");
79 }
80 cm->nrows = nrows;
81 return(cm);
82 }
83
84 typedef struct {
85 int dtype; /* data type */
86 int need2swap; /* need byte swap? */
87 int nrows, ncols; /* matrix size */
88 COLOR expos; /* exposure value */
89 char *err; /* error message */
90 } CMINFO; /* header info record */
91
92 static int
93 get_cminfo(char *s, void *p)
94 {
95 CMINFO *ip = (CMINFO *)p;
96 char fmt[MAXFMTLEN];
97 int i;
98
99 if (!strncmp(s, "NCOMP=", 6) && atoi(s+6) != 3) {
100 ip->err = "unexpected # components (must be 3)";
101 return(-1);
102 }
103 if (!strncmp(s, "NROWS=", 6)) {
104 ip->nrows = atoi(s+6);
105 return(0);
106 }
107 if (!strncmp(s, "NCOLS=", 6)) {
108 ip->ncols = atoi(s+6);
109 return(0);
110 }
111 if ((i = isbigendian(s)) >= 0) {
112 ip->need2swap = (nativebigendian() != i);
113 return(0);
114 }
115 if (isexpos(s)) {
116 double d = exposval(s);
117 scalecolor(ip->expos, d);
118 return(0);
119 }
120 if (iscolcor(s)) {
121 COLOR ctmp;
122 colcorval(ctmp, s);
123 multcolor(ip->expos, ctmp);
124 return(0);
125 }
126 if (!formatval(fmt, s))
127 return(0);
128 for (i = 1; i < DTend; i++)
129 if (!strcmp(fmt, cm_fmt_id[i]))
130 ip->dtype = i;
131 return(0);
132 }
133
134 /* Load header to obtain/check data type and number of columns */
135 char *
136 cm_getheader(int *dt, int *nr, int *nc, int *swp, COLOR scale, FILE *fp)
137 {
138 CMINFO cmi;
139 /* read header */
140 cmi.dtype = DTfromHeader;
141 cmi.need2swap = 0;
142 cmi.expos[0] = cmi.expos[1] = cmi.expos[2] = 1.f;
143 cmi.nrows = cmi.ncols = 0;
144 cmi.err = "unexpected EOF in header";
145 if (getheader(fp, get_cminfo, &cmi) < 0)
146 return(cmi.err);
147 if (dt) { /* get/check data type? */
148 if (cmi.dtype == DTfromHeader) {
149 if (*dt == DTfromHeader)
150 return("missing/unknown data format in header");
151 } else if (*dt == DTfromHeader)
152 *dt = cmi.dtype;
153 else if (*dt != cmi.dtype)
154 return("unexpected data format in header");
155 }
156 if (nr) { /* get/check #rows? */
157 if (*nr <= 0)
158 *nr = cmi.nrows;
159 else if ((cmi.nrows > 0) & (*nr != cmi.nrows))
160 return("unexpected row count in header");
161 }
162 if (nc) { /* get/check #columns? */
163 if (*nc <= 0)
164 *nc = cmi.ncols;
165 else if ((cmi.ncols > 0) & (*nc != cmi.ncols))
166 return("unexpected column count in header");
167 }
168 if (swp) /* get/check swap? */
169 *swp = cmi.need2swap;
170 if (scale) { /* transfer exposure comp. */
171 scale[0] = 1.f/cmi.expos[0];
172 scale[1] = 1.f/cmi.expos[1];
173 scale[2] = 1.f/cmi.expos[2];
174 }
175 return(NULL);
176 }
177
178 /* Allocate and load image data into matrix */
179 static CMATRIX *
180 cm_load_rgbe(FILE *fp, int nrows, int ncols, COLOR scale)
181 {
182 int doscale;
183 CMATRIX *cm;
184 COLORV *mp;
185 /* header already loaded */
186 cm = cm_alloc(nrows, ncols);
187 if (!cm)
188 return(NULL);
189 doscale = (scale[0] < .99) | (scale[0] > 1.01) |
190 (scale[1] < .99) | (scale[1] > 1.01) |
191 (scale[2] < .99) | (scale[2] > 1.01) ;
192 mp = cm->cmem;
193 while (nrows--) {
194 if (freadscan((COLOR *)mp, ncols, fp) < 0) {
195 error(USER, "error reading color picture as matrix");
196 cm_free(cm);
197 return(NULL);
198 }
199 if (doscale) {
200 int i = ncols;
201 while (i--) {
202 *mp++ *= scale[0];
203 *mp++ *= scale[1];
204 *mp++ *= scale[2];
205 }
206 } else
207 mp += 3*ncols;
208 } /* caller closes stream */
209 return(cm);
210 }
211
212 /* Allocate and load a matrix from the given input (or stdin if NULL) */
213 CMATRIX *
214 cm_load(const char *inspec, int nrows, int ncols, int dtype)
215 {
216 const int ROWINC = 2048;
217 int rowsOK = (dtype == DTascii) | (nrows > 0);
218 int swap = 0;
219 FILE *fp;
220 COLOR scale;
221 CMATRIX *cm;
222
223 if (!inspec)
224 inspec = stdin_name;
225 else if (!*inspec)
226 return(NULL);
227 if (inspec == stdin_name) { /* reading from stdin? */
228 fp = stdin;
229 } else if (inspec[0] == '!') {
230 fp = popen(inspec+1, "r");
231 if (!fp) {
232 sprintf(errmsg, "cannot start command '%s'", inspec);
233 error(SYSTEM, errmsg);
234 }
235 } else if (!(fp = fopen(inspec, "r"))) {
236 sprintf(errmsg, "cannot open file '%s'", inspec);
237 error(SYSTEM, errmsg);
238 }
239 #ifdef getc_unlocked
240 flockfile(fp);
241 #endif
242 if (dtype != DTascii)
243 SET_FILE_BINARY(fp); /* doesn't really work */
244 if (!dtype | !rowsOK | !ncols) { /* expecting header? */
245 char *err = cm_getheader(&dtype, &nrows, &ncols, &swap, scale, fp);
246 if (err)
247 error(USER, err);
248 rowsOK = (nrows > 0);
249 }
250 if (!rowsOK | !ncols && !fscnresolu(&ncols, &nrows, fp))
251 error(USER, "unspecified matrix size");
252 switch (dtype) {
253 case DTascii:
254 case DTfloat:
255 case DTdouble:
256 break;
257 case DTrgbe:
258 case DTxyze:
259 cm = cm_load_rgbe(fp, nrows, ncols, scale);
260 goto cleanup;
261 default:
262 error(USER, "unexpected data type in cm_load()");
263 }
264 if (nrows <= 0) { /* don't know length? */
265 int guessrows = 147; /* usually big enough */
266 if (cm_elem_size[dtype] && (fp != stdin) & (inspec[0] != '!')) {
267 long startpos = ftell(fp);
268 if (fseek(fp, 0L, SEEK_END) == 0) {
269 long rowsiz = (long)ncols*cm_elem_size[dtype];
270 long endpos = ftell(fp);
271
272 if ((endpos - startpos) % rowsiz) {
273 sprintf(errmsg,
274 "improper length for binary file '%s'",
275 inspec);
276 error(USER, errmsg);
277 }
278 guessrows = (endpos - startpos)/rowsiz;
279 if (fseek(fp, startpos, SEEK_SET) < 0) {
280 sprintf(errmsg,
281 "fseek() error on file '%s'",
282 inspec);
283 error(SYSTEM, errmsg);
284 }
285 nrows = guessrows; /* we're confident */
286 }
287 }
288 cm = cm_alloc(guessrows, ncols);
289 } else
290 cm = cm_alloc(nrows, ncols);
291 if (!cm) /* XXX never happens */
292 return(NULL);
293 if (dtype == DTascii) { /* read text file */
294 int maxrow = (nrows > 0 ? nrows : 32000);
295 int r, c;
296 for (r = 0; r < maxrow; r++) {
297 if (r >= cm->nrows) /* need more space? */
298 cm = cm_resize(cm, cm->nrows+ROWINC);
299 for (c = 0; c < ncols; c++) {
300 COLORV *cv = cm_lval(cm,r,c);
301 if (fscanf(fp, COLSPEC, cv, cv+1, cv+2) != 3) {
302 if ((nrows <= 0) & (r > 0) & !c) {
303 cm = cm_resize(cm, maxrow=r);
304 break;
305 } else
306 goto EOFerror;
307 }
308 }
309 }
310 while ((c = getc(fp)) != EOF)
311 if (!isspace(c)) {
312 sprintf(errmsg,
313 "unexpected data at end of ascii input '%s'",
314 inspec);
315 error(WARNING, errmsg);
316 break;
317 }
318 } else { /* read binary file */
319 if (sizeof(COLOR) == cm_elem_size[dtype]) {
320 size_t nread = 0;
321 do { /* read all we can */
322 nread += getbinary(cm->cmem + 3*nread,
323 sizeof(COLOR),
324 (size_t)cm->nrows*cm->ncols - nread,
325 fp);
326 if (nrows <= 0) { /* unknown length */
327 if (nread == (size_t)cm->nrows*cm->ncols)
328 /* need more space? */
329 cm = cm_resize(cm, cm->nrows+ROWINC);
330 else if (nread && !(nread % cm->ncols))
331 /* seem to be done */
332 cm = cm_resize(cm, nread/cm->ncols);
333 else /* ended mid-row */
334 goto EOFerror;
335 } else if (nread < (size_t)cm->nrows*cm->ncols)
336 goto EOFerror;
337 } while (nread < (size_t)cm->nrows*cm->ncols);
338
339 if (swap) {
340 if (sizeof(COLORV) == 4)
341 swap32((char *)cm->cmem,
342 3*(size_t)cm->nrows*cm->ncols);
343 else /* sizeof(COLORV) == 8 */
344 swap64((char *)cm->cmem,
345 3*(size_t)cm->nrows*cm->ncols);
346 }
347 } else if (dtype == DTdouble) {
348 double dc[3]; /* load from double */
349 COLORV *cvp = cm->cmem;
350 size_t n = (size_t)nrows*ncols;
351
352 if (n <= 0)
353 goto not_handled;
354 while (n--) {
355 if (getbinary(dc, sizeof(double), 3, fp) != 3)
356 goto EOFerror;
357 if (swap) swap64((char *)dc, 3);
358 copycolor(cvp, dc);
359 cvp += 3;
360 }
361 } else /* dtype == DTfloat */ {
362 float fc[3]; /* load from float */
363 COLORV *cvp = cm->cmem;
364 size_t n = (size_t)nrows*ncols;
365
366 if (n <= 0)
367 goto not_handled;
368 while (n--) {
369 if (getbinary(fc, sizeof(float), 3, fp) != 3)
370 goto EOFerror;
371 if (swap) swap32((char *)fc, 3);
372 copycolor(cvp, fc);
373 cvp += 3;
374 }
375 }
376 if (fgetc(fp) != EOF) {
377 sprintf(errmsg,
378 "unexpected data at end of binary input '%s'",
379 inspec);
380 error(WARNING, errmsg);
381 }
382 }
383 cleanup:
384 if (fp != stdin) {
385 if (inspec[0] != '!')
386 fclose(fp);
387 else if (pclose(fp)) {
388 sprintf(errmsg, "error running command '%s'", inspec);
389 error(WARNING, errmsg);
390 }
391 }
392 #ifdef getc_unlocked
393 else
394 funlockfile(fp);
395 #endif
396 return(cm);
397 EOFerror:
398 sprintf(errmsg, "unexpected EOF reading %s", inspec);
399 error(USER, errmsg);
400 return(NULL);
401 not_handled:
402 error(INTERNAL, "unhandled data size or length in cm_load()");
403 return(NULL); /* gratis return */
404 }
405
406 /* Extract a column vector from a matrix */
407 CMATRIX *
408 cm_column(const CMATRIX *cm, int c)
409 {
410 CMATRIX *cvr;
411 int dr;
412
413 if (!cm)
414 return(NULL);
415 if ((c < 0) | (c >= cm->ncols))
416 error(INTERNAL, "column requested outside matrix");
417 cvr = cm_alloc(cm->nrows, 1);
418 if (!cvr)
419 return(NULL);
420 for (dr = 0; dr < cm->nrows; dr++) {
421 const COLORV *sp = cm_lval(cm,dr,c);
422 COLORV *dp = cv_lval(cvr,dr);
423 dp[0] = sp[0];
424 dp[1] = sp[1];
425 dp[2] = sp[2];
426 }
427 return(cvr);
428 }
429
430 /* Multiply two matrices (or a matrix and a vector) and allocate the result */
431 CMATRIX *
432 cm_multiply(const CMATRIX *cm1, const CMATRIX *cm2)
433 {
434 char *rowcheck=NULL, *colcheck=NULL;
435 CMATRIX *cmr;
436 int dr, dc, i;
437
438 if (!cm1 | !cm2)
439 return(NULL);
440 if ((cm1->ncols <= 0) | (cm1->ncols != cm2->nrows))
441 error(INTERNAL, "matrix dimension mismatch in cm_multiply()");
442 cmr = cm_alloc(cm1->nrows, cm2->ncols);
443 if (!cmr)
444 return(NULL);
445 /* optimization: check for zero rows & cols */
446 if (((cm1->nrows > 5) | (cm2->ncols > 5)) & (cm1->ncols > 5)) {
447 static const COLOR czero;
448 rowcheck = (char *)calloc(cmr->nrows, 1);
449 for (dr = cm1->nrows*(rowcheck != NULL); dr--; )
450 for (dc = cm1->ncols; dc--; )
451 if (memcmp(cm_lval(cm1,dr,dc), czero, sizeof(COLOR))) {
452 rowcheck[dr] = 1;
453 break;
454 }
455 colcheck = (char *)calloc(cmr->ncols, 1);
456 for (dc = cm2->ncols*(colcheck != NULL); dc--; )
457 for (dr = cm2->nrows; dr--; )
458 if (memcmp(cm_lval(cm2,dr,dc), czero, sizeof(COLOR))) {
459 colcheck[dc] = 1;
460 break;
461 }
462 }
463 for (dr = 0; dr < cmr->nrows; dr++)
464 for (dc = 0; dc < cmr->ncols; dc++) {
465 COLORV *dp = cm_lval(cmr,dr,dc);
466 double res[3];
467 dp[0] = dp[1] = dp[2] = 0;
468 if (rowcheck && !rowcheck[dr])
469 continue;
470 if (colcheck && !colcheck[dc])
471 continue;
472 res[0] = res[1] = res[2] = 0;
473 for (i = 0; i < cm1->ncols; i++) {
474 const COLORV *cp1 = cm_lval(cm1,dr,i);
475 const COLORV *cp2 = cm_lval(cm2,i,dc);
476 res[0] += (double)cp1[0] * cp2[0];
477 res[1] += (double)cp1[1] * cp2[1];
478 res[2] += (double)cp1[2] * cp2[2];
479 }
480 copycolor(dp, res);
481 }
482 if (rowcheck) free(rowcheck);
483 if (colcheck) free(colcheck);
484 return(cmr);
485 }
486
487 /* write out matrix to file (precede by resolution string if picture) */
488 int
489 cm_write(const CMATRIX *cm, int dtype, FILE *fp)
490 {
491 static const char tabEOL[2] = {'\t','\n'};
492 const COLORV *mp;
493 int r, c;
494 size_t n, rv;
495
496 if (!cm)
497 return(0);
498 mp = cm->cmem;
499 switch (dtype) {
500 case DTascii:
501 for (r = 0; r < cm->nrows; r++)
502 for (c = 0; c < cm->ncols; c++, mp += 3)
503 fprintf(fp, "%.6e %.6e %.6e%c",
504 mp[0], mp[1], mp[2],
505 tabEOL[c >= cm->ncols-1]);
506 break;
507 case DTfloat:
508 case DTdouble:
509 if (sizeof(COLOR) == cm_elem_size[dtype]) {
510 n = (size_t)cm->ncols*cm->nrows;
511 while (n > 0) {
512 rv = fwrite(mp, sizeof(COLOR), n, fp);
513 if (rv <= 0)
514 return(0);
515 mp += 3*rv;
516 n -= rv;
517 }
518 } else if (dtype == DTdouble) {
519 double dc[3];
520 n = (size_t)cm->ncols*cm->nrows;
521 while (n--) {
522 copycolor(dc, mp);
523 if (putbinary(dc, sizeof(double), 3, fp) != 3)
524 return(0);
525 mp += 3;
526 }
527 } else /* dtype == DTfloat */ {
528 float fc[3];
529 n = (size_t)cm->ncols*cm->nrows;
530 while (n--) {
531 copycolor(fc, mp);
532 if (putbinary(fc, sizeof(float), 3, fp) != 3)
533 return(0);
534 mp += 3;
535 }
536 }
537 break;
538 case DTrgbe:
539 case DTxyze:
540 fprtresolu(cm->ncols, cm->nrows, fp);
541 for (r = 0; r < cm->nrows; r++, mp += 3*cm->ncols)
542 if (fwritescan((COLOR *)mp, cm->ncols, fp) < 0)
543 return(0);
544 break;
545 default:
546 fputs("Unsupported data type in cm_write()!\n", stderr);
547 return(0);
548 }
549 return(fflush(fp) == 0);
550 }