src/util/rmatrix.c

#ifndef lint
static const char RCSid[] = "$Id: rmatrix.c,v 2.20 2016/03/06 01:13:18 schorsch Exp $";
#endif
/*
 * General matrix operations.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include "rtio.h"
#include "platform.h"
#include "resolu.h"
#include "paths.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) |
                        (dtyp2==DTxyze) | (dtyp2==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);
                if (rm->info) rm->info[0] = '\0';
        } 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;

        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 (getbinary(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 (getbinary(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 *inspec)
{
        FILE            *fp = stdin;
        RMATRIX         dinfo;
        RMATRIX         *dnew;

        if (inspec == NULL) {                   /* reading from stdin? */
                inspec = "<stdin>";
#if defined(_WIN32) || defined(_WIN64)
                _setmode(fileno(stdin), _O_BINARY);
#endif
        } else if (inspec[0] == '!') {
                if ((fp = popen(inspec+1, "r")) == NULL)
                        return(NULL);
#if defined(_WIN32) || defined(_WIN64)
                _setmode(fileno(fp), _O_BINARY);
#endif
        } else {
                const char      *sp = inspec;   /* check suffix */
                while (*sp)
                        ++sp;
                while (sp > inspec && sp[-1] != '.')
                        --sp;
                if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
                        CMATRIX *cm = cm_loadBTDF((char *)inspec);
                        if (cm == NULL)
                                return(NULL);
                        dnew = rmx_from_cmatrix(cm);
                        cm_free(cm);
                        dnew->dtype = DTascii;
                        return(dnew);
                }
                                                /* else open it ourselves */
                if ((fp = fopen(inspec, "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 defined(_WIN32) || defined(_WIN64)
                _setmode(fileno(fp), _O_TEXT);
#endif
                if (!rmx_load_ascii(dnew, fp))
                        goto loaderr;
                dnew->dtype = DTascii;          /* should leave double? */
                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) {
                if (inspec[0] == '!')
                        pclose(fp);
                else
                        fclose(fp);
        }
#ifdef getc_unlocked
        else
                funlockfile(fp);
#endif
        return(dnew);
loaderr:                                        /* should report error? */
        if (inspec[0] == '!')
                pclose(fp);
        else
                fclose(fp);
        rmx_free(dnew);
        return(NULL);
}

static int
rmx_write_ascii(const RMATRIX *rm, FILE *fp)
{
        int     i, j, k;

        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 (putbinary(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 (putbinary(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 */
int
rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
{
        RMATRIX *mydm = NULL;
        int     ok = 1;

        if ((rm == NULL) | (fp == NULL))
                return(0);
#ifdef getc_unlocked
        flockfile(fp);
#endif
                                                /* 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);
#ifdef getc_unlocked
        funlockfile(fp);
#endif
        rmx_free(mydm);
        return(ok);
}

/* 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, k;

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