src/util/rmatrix.c

#ifndef lint
static const char RCSid[] = "$Id: rmatrix.c,v 2.5 2014/08/01 23:37:24 greg Exp $";
#endif
/*
 * General matrix operations.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "resolu.h"
#include "rmatrix.h"

static char     rmx_mismatch_warn[] = "WARNING: data type mismatch\n";

/* Allocate a nr x nc matrix with n components */
RMATRIX *
rmx_alloc(int nr, int nc, int n)
{
        RMATRIX *dnew;

        if ((nr <= 0) | (nc <= 0) | (n <= 0))
                return(NULL);
        dnew = (RMATRIX *)malloc(sizeof(RMATRIX)-sizeof(dnew->mtx) +
                                        sizeof(dnew->mtx[0])*(n*nr*nc));
        if (dnew == NULL)
                return(NULL);
        dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
        dnew->dtype = DTdouble;
        dnew->info = NULL;
        return(dnew);
}

/* Free a RMATRIX array */
void
rmx_free(RMATRIX *rm)
{
        if (!rm) return;
        if (rm->info)
                free(rm->info);
        free(rm);
}

/* Resolve data type based on two input types (returns 0 for mismatch) */
int
rmx_newtype(int dtyp1, int dtyp2)
{
        if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) && dtyp1 != dtyp2)
                return(0);
        if (dtyp1 < dtyp2)
                return(dtyp1);
        return(dtyp2);
}

/* Append header information associated with matrix data */
int
rmx_addinfo(RMATRIX *rm, const char *info)
{
        if (!info || !*info)
                return(0);
        if (!rm->info)
                rm->info = (char *)malloc(strlen(info)+1);
        else
                rm->info = (char *)realloc(rm->info,
                                strlen(rm->info)+strlen(info)+1);
        if (!rm->info)
                return(0);
        strcat(rm->info, info);
        return(1);
}

static int
get_dminfo(char *s, void *p)
{
        RMATRIX *ip = (RMATRIX *)p;
        char    fmt[64];
        int     i;

        if (headidval(fmt, s))
                return(0);
        if (!strncmp(s, "NCOMP=", 6)) {
                ip->ncomp = atoi(s+6);
                return(0);
        }
        if (!strncmp(s, "NROWS=", 6)) {
                ip->nrows = atoi(s+6);
                return(0);
        }
        if (!strncmp(s, "NCOLS=", 6)) {
                ip->ncols = atoi(s+6);
                return(0);
        }
        if (!formatval(fmt, s)) {
                rmx_addinfo(ip, s);
                return(0);
        }
        for (i = 1; i < DTend; i++)
                if (!strcmp(fmt, cm_fmt_id[i])) {
                        ip->dtype = i;
                        return(0);
                }
        return(-1);
}

static int
rmx_load_ascii(RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
#ifdef _WIN32
        _setmode(fileno(fp), _O_TEXT);
#endif
        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++)
                for (k = 0; k < rm->ncomp; k++)
                    if (fscanf(fp, "%lf", &rmx_lval(rm,i,j,k)) != 1)
                        return(0);
        return(1);
}

static int
rmx_load_float(RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
        float   val[100];

        if (rm->ncomp > 100) {
                fputs("Unsupported # components in rmx_load_float()\n", stderr);
                exit(1);
        }
        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++) {
                if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
                    return(0);
                for (k = rm->ncomp; k--; )
                     rmx_lval(rm,i,j,k) = val[k];
            }
        return(1);
}

static int
rmx_load_double(RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
        double  val[100];

        if (rm->ncomp > 100) {
                fputs("Unsupported # components in rmx_load_double()\n", stderr);
                exit(1);
        }
        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++) {
                if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
                    return(0);
                for (k = rm->ncomp; k--; )
                     rmx_lval(rm,i,j,k) = val[k];
            }
        return(1);
}

static int
rmx_load_rgbe(RMATRIX *rm, FILE *fp)
{
        COLOR   *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
        int     i, j;

        if (scan == NULL)
                return(0);
        for (i = 0; i < rm->nrows; i++) {
            if (freadscan(scan, rm->ncols, fp) < 0) {
                free(scan);
                return(0);
            }
            for (j = rm->ncols; j--; ) {
                rmx_lval(rm,i,j,0) = colval(scan[j],RED);
                rmx_lval(rm,i,j,1) = colval(scan[j],GRN);
                rmx_lval(rm,i,j,2) = colval(scan[j],BLU);
            }
        }
        free(scan);
        return(1);
}

/* Load matrix from supported file type */
RMATRIX *
rmx_load(const char *fname)
{
        FILE            *fp = stdin;
        RMATRIX         dinfo;
        RMATRIX         *dnew;

        if (fname == NULL) {                    /* reading from stdin? */
                fname = "<stdin>";
        } else {
                const char      *sp = fname;    /* check suffix */
                while (*sp)
                        ++sp;
                while (sp > fname && sp[-1] != '.')
                        --sp;
                if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
                        CMATRIX *cm = cm_loadBTDF((char *)fname);
                        if (cm == NULL)
                                return(NULL);
                        dnew = rmx_from_cmatrix(cm);
                        cm_free(cm);
                        return(dnew);
                }
                                                /* else open it ourselves */
                if ((fp = fopen(fname, "rb")) == NULL)
                        return(NULL);
        }
#ifdef getc_unlocked
        flockfile(fp);
#endif
        dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0;
        dinfo.dtype = DTascii;                  /* assumed w/o FORMAT */
        dinfo.info = NULL;
        if (getheader(fp, get_dminfo, &dinfo) < 0) {
                fclose(fp);
                return(NULL);
        }
        if ((dinfo.nrows <= 0) | (dinfo.ncols <= 0)) {
                if (!fscnresolu(&dinfo.ncols, &dinfo.nrows, fp)) {
                        fclose(fp);
                        return(NULL);
                }
                if (dinfo.ncomp <= 0)
                        dinfo.ncomp = 3;
                else if ((dinfo.dtype == DTrgbe) | (dinfo.dtype == DTxyze) &&
                                dinfo.ncomp != 3) {
                        fclose(fp);
                        return(NULL);
                }
        }
        dnew = rmx_alloc(dinfo.nrows, dinfo.ncols, dinfo.ncomp);
        if (dnew == NULL) {
                fclose(fp);
                return(NULL);
        }
        dnew->info = dinfo.info;
        switch (dinfo.dtype) {
        case DTascii:
                if (!rmx_load_ascii(dnew, fp))
                        goto loaderr;
                break;
        case DTfloat:
                if (!rmx_load_float(dnew, fp))
                        goto loaderr;
                dnew->dtype = DTfloat;
                break;
        case DTdouble:
                if (!rmx_load_double(dnew, fp))
                        goto loaderr;
                dnew->dtype = DTdouble;
                break;
        case DTrgbe:
        case DTxyze:
                if (!rmx_load_rgbe(dnew, fp))
                        goto loaderr;
                dnew->dtype = dinfo.dtype;
                break;
        default:
                goto loaderr;
        }
        if (fp != stdin)
                fclose(fp);
        return(dnew);
loaderr:                                        /* should report error? */
        fclose(fp);
        rmx_free(dnew);
        return(NULL);
}

static int
rmx_write_ascii(const RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
#ifdef _WIN32
        _setmode(fileno(fp), _O_TEXT);
#endif
        for (i = 0; i < rm->nrows; i++) {
            for (j = 0; j < rm->ncols; j++) {
                for (k = 0; k < rm->ncomp; k++)
                    fprintf(fp, " %.15e", rmx_lval(rm,i,j,k));
                fputc('\t', fp);
            }
            fputc('\n', fp);
        }
        return(1);
}

static int
rmx_write_float(const RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
        float   val[100];

        if (rm->ncomp > 100) {
                fputs("Unsupported # components in rmx_write_float()\n", stderr);
                exit(1);
        }
        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++) {
                for (k = rm->ncomp; k--; )
                    val[k] = (float)rmx_lval(rm,i,j,k);
                if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
                        return(0);
            }
        return(1);
}

static int
rmx_write_double(const RMATRIX *rm, FILE *fp)
{
        int     i, j, k;
        double  val[100];

        if (rm->ncomp > 100) {
                fputs("Unsupported # components in rmx_write_double()\n", stderr);
                exit(1);
        }
        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++) {
                for (k = rm->ncomp; k--; )
                    val[k] = rmx_lval(rm,i,j,k);
                if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
                        return(0);
            }
        return(1);
}

static int
rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
{
        COLOR   *scan = (COLOR *)malloc(sizeof(COLOR)*rm->ncols);
        int     i, j;

        if (scan == NULL)
                return(0);
        for (i = 0; i < rm->nrows; i++) {
            for (j = rm->ncols; j--; )
                setcolor(scan[j],       rmx_lval(rm,i,j,0),
                                        rmx_lval(rm,i,j,1),
                                        rmx_lval(rm,i,j,2)      );
            if (fwritescan(scan, rm->ncols, fp) < 0) {
                free(scan);
                return(0);
            }
        }
        free(scan);
        return(1);
}

/* Write matrix to file type indicated by dtype */
long
rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
{
        RMATRIX *mydm = NULL;
        int     ok = 1;

        if ((rm == NULL) | (fp == NULL))
                return(0);
                                                /* complete header */
        if (rm->info)
                fputs(rm->info, fp);
        if (dtype == DTfromHeader)
                dtype = rm->dtype;
        else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
                dtype = DTxyze;
        else if ((dtype = DTxyze) & (rm->dtype == DTrgbe))
                dtype = DTrgbe;
        if ((dtype != DTrgbe) & (dtype != DTxyze)) {
                fprintf(fp, "NROWS=%d\n", rm->nrows);
                fprintf(fp, "NCOLS=%d\n", rm->ncols);
                fprintf(fp, "NCOMP=%d\n", rm->ncomp);
        } else if (rm->ncomp != 3) {            /* wrong # components? */
                double  cmtx[3];
                if (rm->ncomp != 1)             /* only convert grayscale */
                        return(0);
                cmtx[0] = cmtx[1] = cmtx[2] = 1;
                mydm = rmx_transform(rm, 3, cmtx);
                if (mydm == NULL)
                        return(0);
                rm = mydm;
        }
        fputformat((char *)cm_fmt_id[dtype], fp);
        fputc('\n', fp);
        switch (dtype) {                        /* write data */
        case DTascii:
                ok = rmx_write_ascii(rm, fp);
                break;
        case DTfloat:
                ok = rmx_write_float(rm, fp);
                break;
        case DTdouble:
                ok = rmx_write_double(rm, fp);
                break;
        case DTrgbe:
        case DTxyze:
                fprtresolu(rm->ncols, rm->nrows, fp);
                ok = rmx_write_rgbe(rm, fp);
                break;
        default:
                return(0);
        }
        ok &= (fflush(fp) == 0);
        rmx_free(mydm);
        return(ftell(fp) * ok);         /* return # bytes written */
}

/* Allocate and assign square identity matrix with n components */
RMATRIX *
rmx_identity(const int dim, const int n)
{
        RMATRIX *rid = rmx_alloc(dim, dim, n);
        int     i;

        if (rid == NULL)
                return(NULL);
        memset(rid->mtx, 0, sizeof(rid->mtx[0])*dim*dim);
        for (i = dim; i--; )
                rmx_lval(rid,i,i,0) = 1;
        for (i = n; --i; )
                memcpy(rid->mtx+i*(dim*dim), rid->mtx,
                                sizeof(rid->mtx[0])*dim*dim);
        return(rid);
}

/* Duplicate the given matrix */
RMATRIX *
rmx_copy(const RMATRIX *rm)
{
        RMATRIX *dnew;

        if (rm == NULL)
                return(NULL);
        dnew = rmx_alloc(rm->nrows, rm->ncols, rm->ncomp);
        if (dnew == NULL)
                return(NULL);
        rmx_addinfo(dnew, rm->info);
        dnew->dtype = rm->dtype;
        memcpy(dnew->mtx, rm->mtx,
                sizeof(rm->mtx[0])*rm->ncomp*rm->nrows*rm->ncols);
        return(dnew);
}

/* Allocate and assign transposed matrix */
RMATRIX *
rmx_transpose(const RMATRIX *rm)
{
        RMATRIX *dnew;
        int     i, j, k;

        if (rm == NULL)
                return(0);
        dnew = rmx_alloc(rm->ncols, rm->nrows, rm->ncomp);
        if (dnew == NULL)
                return(NULL);
        if (rm->info) {
                rmx_addinfo(dnew, rm->info);
                rmx_addinfo(dnew, "Transposed rows and columns\n");
        }
        dnew->dtype = rm->dtype;
        for (i = dnew->nrows; i--; )
            for (j = dnew->ncols; j--; )
                for (k = dnew->ncomp; k--; )
                        rmx_lval(dnew,i,j,k) = rmx_lval(rm,j,i,k);
        return(dnew);
}

/* Multiply (concatenate) two matrices and allocate the result */
RMATRIX *
rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
{
        RMATRIX *mres;
        int     i, j, k, h;

        if ((m1 == NULL) | (m2 == NULL) ||
                        (m1->ncomp != m2->ncomp) | (m1->ncols != m2->nrows))
                return(NULL);
        mres = rmx_alloc(m1->nrows, m2->ncols, m1->ncomp);
        if (mres == NULL)
                return(NULL);
        i = rmx_newtype(m1->dtype, m2->dtype);
        if (i)
                mres->dtype = i;
        else
                rmx_addinfo(mres, rmx_mismatch_warn);
        for (i = mres->nrows; i--; )
            for (j = mres->ncols; j--; )
                for (h = m1->ncols; h--; ) {
                    long double d = 0;
                    for (k = mres->ncomp; k--; )
                        d += (long double)rmx_lval(m1,i,h,k) *
                                (long double)rmx_lval(m2,h,j,k);
                    rmx_lval(mres,i,j,k) = (double)d;
                }
        return(mres);
}

/* Sum second matrix into first, applying scale factor beforehand */
int
rmx_sum(RMATRIX *msum, const RMATRIX *madd, const double sf[])
{
        double  *mysf = NULL;
        int     i, j, k;

        if ((msum == NULL) | (madd == NULL) ||
                        (msum->nrows != madd->nrows) |
                        (msum->ncols != madd->ncols) |
                        (msum->ncomp != madd->ncomp))
                return(0);
        if (sf == NULL) {
                mysf = (double *)malloc(sizeof(double)*msum->ncomp);
                if (mysf == NULL)
                        return(0);
                for (k = msum->ncomp; k--; )
                        mysf[k] = 1;
                sf = mysf;
        }
        i = rmx_newtype(msum->dtype, madd->dtype);
        if (i)
                msum->dtype = i;
        else
                rmx_addinfo(msum, rmx_mismatch_warn);
        for (i = msum->nrows; i--; )
            for (j = msum->ncols; j--; )
                for (k = msum->ncomp; k--; )
                     rmx_lval(msum,i,j,k) += sf[k] * rmx_lval(madd,i,j,k);

        free(mysf);
        return(1);
}

/* Scale the given matrix by the indicated scalar component vector */
int
rmx_scale(RMATRIX *rm, const double sf[])
{
        int     i, j, k;

        if ((rm == NULL) | (sf == NULL))
                return(0);
        for (i = rm->nrows; i--; )
            for (j = rm->ncols; j--; )
                for (k = rm->ncomp; k--; )
                    rmx_lval(rm,i,j,k) *= sf[k];

        return(1);
}

/* Allocate new matrix and apply component transformation */
RMATRIX *
rmx_transform(const RMATRIX *msrc, int n, const double cmat[])
{
        int     i, j, ks, kd;
        RMATRIX *dnew;

        if ((msrc == NULL) | (n <= 0) | (cmat == NULL))
                return(NULL);
        dnew = rmx_alloc(msrc->nrows, msrc->ncols, n);
        if (dnew == NULL)
                return(NULL);
        dnew->dtype = msrc->dtype;
        for (i = dnew->nrows; i--; )
            for (j = dnew->ncols; j--; )
                for (kd = dnew->ncomp; kd--; ) {
                    double      d = 0;
                    for (ks = msrc->ncomp; ks--; )
                        d += cmat[kd*msrc->ncomp + ks] * rmx_lval(msrc,i,j,ks);
                    rmx_lval(dnew,i,j,kd) = d;
                }
        return(dnew);
}

/* Convert a color matrix to newly allocated RMATRIX buffer */
RMATRIX *
rmx_from_cmatrix(const CMATRIX *cm)
{
        int     i, j;
        RMATRIX *dnew;

        if (cm == NULL)
                return(NULL);
        dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
        if (dnew == NULL)
                return(NULL);
        dnew->dtype = DTfloat;
        for (i = dnew->nrows; i--; )
            for (j = dnew->ncols; j--; ) {
                const COLORV    *cv = cm_lval(cm,i,j);
                rmx_lval(dnew,i,j,0) = cv[0];
                rmx_lval(dnew,i,j,1) = cv[1];
                rmx_lval(dnew,i,j,2) = cv[2];
            }
        return(dnew);
}

/* Convert general matrix to newly allocated CMATRIX buffer */
CMATRIX *
cm_from_rmatrix(const RMATRIX *rm)
{
        int     i, j;
        CMATRIX *cnew;

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