ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rmatrix.c
Revision: 2.9
Committed: Thu Aug 28 05:59:42 2014 UTC (9 years, 7 months ago) by greg
Content type: text/plain
Branch: MAIN
CVS Tags: rad4R2P1
Changes since 2.8: +2 -2 lines
Log Message:
Bug fix pointed out by Andy McNeil

File Contents

# User Rev Content
1 greg 2.1 #ifndef lint
2 greg 2.9 static const char RCSid[] = "$Id: rmatrix.c,v 2.8 2014/08/27 13:33:47 greg Exp $";
3 greg 2.1 #endif
4     /*
5     * General matrix operations.
6     */
7    
8     #include <stdio.h>
9     #include <stdlib.h>
10     #include <string.h>
11     #include <fcntl.h>
12     #include "resolu.h"
13     #include "rmatrix.h"
14    
15 greg 2.6 static char rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
16 greg 2.1
17     /* Allocate a nr x nc matrix with n components */
18     RMATRIX *
19     rmx_alloc(int nr, int nc, int n)
20     {
21     RMATRIX *dnew;
22    
23     if ((nr <= 0) | (nc <= 0) | (n <= 0))
24     return(NULL);
25     dnew = (RMATRIX *)malloc(sizeof(RMATRIX)-sizeof(dnew->mtx) +
26     sizeof(dnew->mtx[0])*(n*nr*nc));
27     if (dnew == NULL)
28     return(NULL);
29     dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
30 greg 2.6 dnew->dtype = DTdouble;
31 greg 2.5 dnew->info = NULL;
32 greg 2.1 return(dnew);
33     }
34    
35 greg 2.6 /* Free a RMATRIX array */
36     void
37     rmx_free(RMATRIX *rm)
38     {
39     if (!rm) return;
40     if (rm->info)
41     free(rm->info);
42     free(rm);
43     }
44    
45     /* Resolve data type based on two input types (returns 0 for mismatch) */
46     int
47     rmx_newtype(int dtyp1, int dtyp2)
48     {
49     if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) && dtyp1 != dtyp2)
50     return(0);
51     if (dtyp1 < dtyp2)
52     return(dtyp1);
53     return(dtyp2);
54     }
55    
56 greg 2.5 /* Append header information associated with matrix data */
57     int
58     rmx_addinfo(RMATRIX *rm, const char *info)
59     {
60     if (!info || !*info)
61     return(0);
62 greg 2.8 if (!rm->info) {
63 greg 2.5 rm->info = (char *)malloc(strlen(info)+1);
64 greg 2.8 if (rm->info) rm->info[0] = '\0';
65     } else
66 greg 2.5 rm->info = (char *)realloc(rm->info,
67     strlen(rm->info)+strlen(info)+1);
68     if (!rm->info)
69     return(0);
70     strcat(rm->info, info);
71     return(1);
72     }
73    
74 greg 2.1 static int
75     get_dminfo(char *s, void *p)
76     {
77 greg 2.6 RMATRIX *ip = (RMATRIX *)p;
78 greg 2.5 char fmt[64];
79 greg 2.1 int i;
80    
81 greg 2.6 if (headidval(fmt, s))
82     return(0);
83 greg 2.1 if (!strncmp(s, "NCOMP=", 6)) {
84     ip->ncomp = atoi(s+6);
85     return(0);
86     }
87     if (!strncmp(s, "NROWS=", 6)) {
88     ip->nrows = atoi(s+6);
89     return(0);
90     }
91     if (!strncmp(s, "NCOLS=", 6)) {
92     ip->ncols = atoi(s+6);
93     return(0);
94     }
95 greg 2.5 if (!formatval(fmt, s)) {
96 greg 2.6 rmx_addinfo(ip, s);
97 greg 2.1 return(0);
98 greg 2.5 }
99 greg 2.1 for (i = 1; i < DTend; i++)
100     if (!strcmp(fmt, cm_fmt_id[i])) {
101     ip->dtype = i;
102     return(0);
103     }
104     return(-1);
105     }
106    
107     static int
108     rmx_load_ascii(RMATRIX *rm, FILE *fp)
109     {
110     int i, j, k;
111     #ifdef _WIN32
112     _setmode(fileno(fp), _O_TEXT);
113     #endif
114     for (i = 0; i < rm->nrows; i++)
115     for (j = 0; j < rm->ncols; j++)
116     for (k = 0; k < rm->ncomp; k++)
117     if (fscanf(fp, "%lf", &rmx_lval(rm,i,j,k)) != 1)
118     return(0);
119     return(1);
120     }
121    
122     static int
123     rmx_load_float(RMATRIX *rm, FILE *fp)
124     {
125     int i, j, k;
126     float val[100];
127    
128     if (rm->ncomp > 100) {
129     fputs("Unsupported # components in rmx_load_float()\n", stderr);
130     exit(1);
131     }
132     for (i = 0; i < rm->nrows; i++)
133     for (j = 0; j < rm->ncols; j++) {
134     if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
135     return(0);
136     for (k = rm->ncomp; k--; )
137     rmx_lval(rm,i,j,k) = val[k];
138     }
139     return(1);
140     }
141    
142     static int
143     rmx_load_double(RMATRIX *rm, FILE *fp)
144     {
145     int i, j, k;
146     double val[100];
147    
148     if (rm->ncomp > 100) {
149     fputs("Unsupported # components in rmx_load_double()\n", stderr);
150     exit(1);
151     }
152     for (i = 0; i < rm->nrows; i++)
153     for (j = 0; j < rm->ncols; j++) {
154     if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
155     return(0);
156     for (k = rm->ncomp; k--; )
157     rmx_lval(rm,i,j,k) = val[k];
158     }
159     return(1);
160     }
161    
162     static int
163     rmx_load_rgbe(RMATRIX *rm, FILE *fp)
164     {
165     COLOR *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
166     int i, j;
167    
168     if (scan == NULL)
169     return(0);
170     for (i = 0; i < rm->nrows; i++) {
171     if (freadscan(scan, rm->ncols, fp) < 0) {
172     free(scan);
173     return(0);
174     }
175     for (j = rm->ncols; j--; ) {
176     rmx_lval(rm,i,j,0) = colval(scan[j],RED);
177     rmx_lval(rm,i,j,1) = colval(scan[j],GRN);
178     rmx_lval(rm,i,j,2) = colval(scan[j],BLU);
179     }
180     }
181     free(scan);
182     return(1);
183     }
184    
185     /* Load matrix from supported file type */
186     RMATRIX *
187     rmx_load(const char *fname)
188     {
189     FILE *fp = stdin;
190 greg 2.6 RMATRIX dinfo;
191 greg 2.1 RMATRIX *dnew;
192    
193     if (fname == NULL) { /* reading from stdin? */
194     fname = "<stdin>";
195 greg 2.7 #ifdef _WIN32
196     _setmode(fileno(stdin), _O_BINARY);
197     #endif
198 greg 2.1 } else {
199     const char *sp = fname; /* check suffix */
200     while (*sp)
201     ++sp;
202     while (sp > fname && sp[-1] != '.')
203     --sp;
204     if (!strcasecmp(sp, "XML")) { /* assume it's a BSDF */
205     CMATRIX *cm = cm_loadBTDF((char *)fname);
206     if (cm == NULL)
207     return(NULL);
208     dnew = rmx_from_cmatrix(cm);
209     cm_free(cm);
210     return(dnew);
211     }
212     /* else open it ourselves */
213     if ((fp = fopen(fname, "rb")) == NULL)
214     return(NULL);
215     }
216     #ifdef getc_unlocked
217     flockfile(fp);
218     #endif
219     dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0;
220 greg 2.6 dinfo.dtype = DTascii; /* assumed w/o FORMAT */
221     dinfo.info = NULL;
222 greg 2.3 if (getheader(fp, get_dminfo, &dinfo) < 0) {
223 greg 2.1 fclose(fp);
224     return(NULL);
225     }
226 greg 2.4 if ((dinfo.nrows <= 0) | (dinfo.ncols <= 0)) {
227 greg 2.1 if (!fscnresolu(&dinfo.ncols, &dinfo.nrows, fp)) {
228     fclose(fp);
229     return(NULL);
230     }
231 greg 2.4 if (dinfo.ncomp <= 0)
232     dinfo.ncomp = 3;
233     else if ((dinfo.dtype == DTrgbe) | (dinfo.dtype == DTxyze) &&
234     dinfo.ncomp != 3) {
235     fclose(fp);
236     return(NULL);
237     }
238 greg 2.1 }
239     dnew = rmx_alloc(dinfo.nrows, dinfo.ncols, dinfo.ncomp);
240     if (dnew == NULL) {
241     fclose(fp);
242     return(NULL);
243     }
244 greg 2.6 dnew->info = dinfo.info;
245 greg 2.1 switch (dinfo.dtype) {
246     case DTascii:
247     if (!rmx_load_ascii(dnew, fp))
248     goto loaderr;
249     break;
250     case DTfloat:
251     if (!rmx_load_float(dnew, fp))
252     goto loaderr;
253 greg 2.6 dnew->dtype = DTfloat;
254 greg 2.1 break;
255     case DTdouble:
256     if (!rmx_load_double(dnew, fp))
257     goto loaderr;
258 greg 2.6 dnew->dtype = DTdouble;
259 greg 2.1 break;
260     case DTrgbe:
261     case DTxyze:
262     if (!rmx_load_rgbe(dnew, fp))
263     goto loaderr;
264 greg 2.6 dnew->dtype = dinfo.dtype;
265 greg 2.1 break;
266     default:
267     goto loaderr;
268     }
269     if (fp != stdin)
270     fclose(fp);
271     return(dnew);
272     loaderr: /* should report error? */
273     fclose(fp);
274     rmx_free(dnew);
275     return(NULL);
276     }
277    
278     static int
279     rmx_write_ascii(const RMATRIX *rm, FILE *fp)
280     {
281     int i, j, k;
282     #ifdef _WIN32
283     _setmode(fileno(fp), _O_TEXT);
284     #endif
285     for (i = 0; i < rm->nrows; i++) {
286     for (j = 0; j < rm->ncols; j++) {
287     for (k = 0; k < rm->ncomp; k++)
288     fprintf(fp, " %.15e", rmx_lval(rm,i,j,k));
289     fputc('\t', fp);
290     }
291     fputc('\n', fp);
292     }
293     return(1);
294     }
295    
296     static int
297     rmx_write_float(const RMATRIX *rm, FILE *fp)
298     {
299     int i, j, k;
300     float val[100];
301    
302     if (rm->ncomp > 100) {
303     fputs("Unsupported # components in rmx_write_float()\n", stderr);
304     exit(1);
305     }
306     for (i = 0; i < rm->nrows; i++)
307     for (j = 0; j < rm->ncols; j++) {
308     for (k = rm->ncomp; k--; )
309     val[k] = (float)rmx_lval(rm,i,j,k);
310     if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
311     return(0);
312     }
313     return(1);
314     }
315    
316     static int
317     rmx_write_double(const RMATRIX *rm, FILE *fp)
318     {
319     int i, j, k;
320     double val[100];
321    
322     if (rm->ncomp > 100) {
323     fputs("Unsupported # components in rmx_write_double()\n", stderr);
324     exit(1);
325     }
326     for (i = 0; i < rm->nrows; i++)
327     for (j = 0; j < rm->ncols; j++) {
328     for (k = rm->ncomp; k--; )
329     val[k] = rmx_lval(rm,i,j,k);
330     if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
331     return(0);
332     }
333     return(1);
334     }
335    
336     static int
337     rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
338     {
339     COLOR *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
340     int i, j;
341    
342     if (scan == NULL)
343     return(0);
344     for (i = 0; i < rm->nrows; i++) {
345     for (j = rm->ncols; j--; )
346     setcolor(scan[j], rmx_lval(rm,i,j,0),
347     rmx_lval(rm,i,j,1),
348     rmx_lval(rm,i,j,2) );
349     if (fwritescan(scan, rm->ncols, fp) < 0) {
350     free(scan);
351     return(0);
352     }
353     }
354     free(scan);
355     return(1);
356     }
357    
358 greg 2.6 /* Write matrix to file type indicated by dtype */
359 greg 2.1 long
360     rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
361     {
362     RMATRIX *mydm = NULL;
363     int ok = 1;
364    
365     if ((rm == NULL) | (fp == NULL))
366     return(0);
367     /* complete header */
368 greg 2.5 if (rm->info)
369     fputs(rm->info, fp);
370 greg 2.6 if (dtype == DTfromHeader)
371     dtype = rm->dtype;
372     else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
373     dtype = DTxyze;
374 greg 2.9 else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
375 greg 2.6 dtype = DTrgbe;
376 greg 2.1 if ((dtype != DTrgbe) & (dtype != DTxyze)) {
377     fprintf(fp, "NROWS=%d\n", rm->nrows);
378     fprintf(fp, "NCOLS=%d\n", rm->ncols);
379     fprintf(fp, "NCOMP=%d\n", rm->ncomp);
380     } else if (rm->ncomp != 3) { /* wrong # components? */
381     double cmtx[3];
382     if (rm->ncomp != 1) /* only convert grayscale */
383     return(0);
384     cmtx[0] = cmtx[1] = cmtx[2] = 1;
385     mydm = rmx_transform(rm, 3, cmtx);
386     if (mydm == NULL)
387     return(0);
388     rm = mydm;
389     }
390     fputformat((char *)cm_fmt_id[dtype], fp);
391     fputc('\n', fp);
392     switch (dtype) { /* write data */
393     case DTascii:
394     ok = rmx_write_ascii(rm, fp);
395     break;
396     case DTfloat:
397     ok = rmx_write_float(rm, fp);
398     break;
399     case DTdouble:
400     ok = rmx_write_double(rm, fp);
401     break;
402     case DTrgbe:
403     case DTxyze:
404     fprtresolu(rm->ncols, rm->nrows, fp);
405     ok = rmx_write_rgbe(rm, fp);
406     break;
407     default:
408     return(0);
409     }
410     ok &= (fflush(fp) == 0);
411     rmx_free(mydm);
412     return(ftell(fp) * ok); /* return # bytes written */
413     }
414    
415     /* Allocate and assign square identity matrix with n components */
416     RMATRIX *
417     rmx_identity(const int dim, const int n)
418     {
419     RMATRIX *rid = rmx_alloc(dim, dim, n);
420     int i;
421    
422     if (rid == NULL)
423     return(NULL);
424     memset(rid->mtx, 0, sizeof(rid->mtx[0])*dim*dim);
425     for (i = dim; i--; )
426     rmx_lval(rid,i,i,0) = 1;
427     for (i = n; --i; )
428     memcpy(rid->mtx+i*(dim*dim), rid->mtx,
429     sizeof(rid->mtx[0])*dim*dim);
430     return(rid);
431     }
432    
433     /* Duplicate the given matrix */
434     RMATRIX *
435     rmx_copy(const RMATRIX *rm)
436     {
437     RMATRIX *dnew;
438    
439     if (rm == NULL)
440     return(NULL);
441     dnew = rmx_alloc(rm->nrows, rm->ncols, rm->ncomp);
442     if (dnew == NULL)
443     return(NULL);
444 greg 2.5 rmx_addinfo(dnew, rm->info);
445 greg 2.6 dnew->dtype = rm->dtype;
446 greg 2.1 memcpy(dnew->mtx, rm->mtx,
447     sizeof(rm->mtx[0])*rm->ncomp*rm->nrows*rm->ncols);
448     return(dnew);
449     }
450    
451 greg 2.2 /* Allocate and assign transposed matrix */
452     RMATRIX *
453     rmx_transpose(const RMATRIX *rm)
454 greg 2.1 {
455 greg 2.2 RMATRIX *dnew;
456 greg 2.1 int i, j, k;
457    
458     if (rm == NULL)
459     return(0);
460 greg 2.2 dnew = rmx_alloc(rm->ncols, rm->nrows, rm->ncomp);
461     if (dnew == NULL)
462     return(NULL);
463 greg 2.5 if (rm->info) {
464     rmx_addinfo(dnew, rm->info);
465     rmx_addinfo(dnew, "Transposed rows and columns\n");
466     }
467 greg 2.6 dnew->dtype = rm->dtype;
468 greg 2.2 for (i = dnew->nrows; i--; )
469     for (j = dnew->ncols; j--; )
470     for (k = dnew->ncomp; k--; )
471     rmx_lval(dnew,i,j,k) = rmx_lval(rm,j,i,k);
472     return(dnew);
473 greg 2.1 }
474    
475     /* Multiply (concatenate) two matrices and allocate the result */
476     RMATRIX *
477     rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
478     {
479     RMATRIX *mres;
480     int i, j, k, h;
481    
482     if ((m1 == NULL) | (m2 == NULL) ||
483     (m1->ncomp != m2->ncomp) | (m1->ncols != m2->nrows))
484     return(NULL);
485     mres = rmx_alloc(m1->nrows, m2->ncols, m1->ncomp);
486     if (mres == NULL)
487     return(NULL);
488 greg 2.6 i = rmx_newtype(m1->dtype, m2->dtype);
489     if (i)
490     mres->dtype = i;
491     else
492     rmx_addinfo(mres, rmx_mismatch_warn);
493 greg 2.1 for (i = mres->nrows; i--; )
494     for (j = mres->ncols; j--; )
495 greg 2.8 for (k = mres->ncomp; k--; ) {
496 greg 2.1 long double d = 0;
497 greg 2.8 for (h = m1->ncols; h--; )
498 greg 2.1 d += (long double)rmx_lval(m1,i,h,k) *
499     (long double)rmx_lval(m2,h,j,k);
500     rmx_lval(mres,i,j,k) = (double)d;
501     }
502     return(mres);
503     }
504    
505     /* Sum second matrix into first, applying scale factor beforehand */
506     int
507     rmx_sum(RMATRIX *msum, const RMATRIX *madd, const double sf[])
508     {
509     double *mysf = NULL;
510     int i, j, k;
511    
512     if ((msum == NULL) | (madd == NULL) ||
513     (msum->nrows != madd->nrows) |
514     (msum->ncols != madd->ncols) |
515     (msum->ncomp != madd->ncomp))
516     return(0);
517     if (sf == NULL) {
518     mysf = (double *)malloc(sizeof(double)*msum->ncomp);
519     if (mysf == NULL)
520     return(0);
521     for (k = msum->ncomp; k--; )
522     mysf[k] = 1;
523     sf = mysf;
524     }
525 greg 2.6 i = rmx_newtype(msum->dtype, madd->dtype);
526     if (i)
527     msum->dtype = i;
528     else
529     rmx_addinfo(msum, rmx_mismatch_warn);
530 greg 2.1 for (i = msum->nrows; i--; )
531     for (j = msum->ncols; j--; )
532     for (k = msum->ncomp; k--; )
533     rmx_lval(msum,i,j,k) += sf[k] * rmx_lval(madd,i,j,k);
534    
535     free(mysf);
536     return(1);
537     }
538    
539     /* Scale the given matrix by the indicated scalar component vector */
540     int
541     rmx_scale(RMATRIX *rm, const double sf[])
542     {
543     int i, j, k;
544    
545     if ((rm == NULL) | (sf == NULL))
546     return(0);
547     for (i = rm->nrows; i--; )
548     for (j = rm->ncols; j--; )
549     for (k = rm->ncomp; k--; )
550     rmx_lval(rm,i,j,k) *= sf[k];
551    
552     return(1);
553     }
554    
555     /* Allocate new matrix and apply component transformation */
556     RMATRIX *
557     rmx_transform(const RMATRIX *msrc, int n, const double cmat[])
558     {
559     int i, j, ks, kd;
560     RMATRIX *dnew;
561    
562     if ((msrc == NULL) | (n <= 0) | (cmat == NULL))
563     return(NULL);
564     dnew = rmx_alloc(msrc->nrows, msrc->ncols, n);
565     if (dnew == NULL)
566     return(NULL);
567 greg 2.6 dnew->dtype = msrc->dtype;
568 greg 2.1 for (i = dnew->nrows; i--; )
569     for (j = dnew->ncols; j--; )
570     for (kd = dnew->ncomp; kd--; ) {
571     double d = 0;
572     for (ks = msrc->ncomp; ks--; )
573     d += cmat[kd*msrc->ncomp + ks] * rmx_lval(msrc,i,j,ks);
574     rmx_lval(dnew,i,j,kd) = d;
575     }
576     return(dnew);
577     }
578    
579     /* Convert a color matrix to newly allocated RMATRIX buffer */
580     RMATRIX *
581     rmx_from_cmatrix(const CMATRIX *cm)
582     {
583     int i, j;
584     RMATRIX *dnew;
585    
586     if (cm == NULL)
587     return(NULL);
588     dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
589     if (dnew == NULL)
590     return(NULL);
591 greg 2.6 dnew->dtype = DTfloat;
592 greg 2.1 for (i = dnew->nrows; i--; )
593     for (j = dnew->ncols; j--; ) {
594     const COLORV *cv = cm_lval(cm,i,j);
595     rmx_lval(dnew,i,j,0) = cv[0];
596     rmx_lval(dnew,i,j,1) = cv[1];
597     rmx_lval(dnew,i,j,2) = cv[2];
598     }
599     return(dnew);
600     }
601    
602     /* Convert general matrix to newly allocated CMATRIX buffer */
603     CMATRIX *
604     cm_from_rmatrix(const RMATRIX *rm)
605     {
606     int i, j;
607     CMATRIX *cnew;
608    
609     if (rm == NULL || rm->ncomp != 3)
610     return(NULL);
611     cnew = cm_alloc(rm->nrows, rm->ncols);
612     if (cnew == NULL)
613     return(NULL);
614     for (i = cnew->nrows; i--; )
615     for (j = cnew->ncols; j--; ) {
616     COLORV *cv = cm_lval(cnew,i,j);
617     cv[0] = (COLORV)rmx_lval(rm,i,j,0);
618     cv[1] = (COLORV)rmx_lval(rm,i,j,1);
619     cv[2] = (COLORV)rmx_lval(rm,i,j,2);
620     }
621     return(cnew);
622     }