src/util/rmatrix.c

#ifndef lint
static const char RCSid[] = "$Id: rmatrix.c,v 2.31 2019/08/12 04:12:57 greg Exp $";
#endif
/*
 * General matrix operations.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <errno.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[MAXFMTLEN];
        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;

        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++)
                if (getbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
                    return(0);
        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>";
                SET_FILE_BINARY(stdin);
        } else if (inspec[0] == '!') {
                if ((fp = popen(inspec+1, "r")) == NULL)
                        return(NULL);
                SET_FILE_BINARY(stdin);
        } 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:
                SET_FILE_TEXT(stdin);
                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)
{
        const char      *fmt = (rm->dtype == DTfloat) ? " %.7e" :
                        (rm->dtype == DTrgbe) | (rm->dtype == DTxyze) ? " %.3e" :
                                " %.15e" ;
        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, fmt, 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;

        for (i = 0; i < rm->nrows; i++)
            for (j = 0; j < rm->ncols; j++)
                if (putbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
                        return(0);
        return(1);
}

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

        if (scan == NULL)
                return(0);
        for (i = 0; i < rm->nrows; i++) {
            for (j = rm->ncols; j--; )
                setcolr(scan[j],        rmx_lval(rm,i,j,0),
                                        rmx_lval(rm,i,j,1),
                                        rmx_lval(rm,i,j,2)      );
            if (fwritecolrs(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);
        if ((rm->nrows == 1) | (rm->ncols == 1)) {
                dnew = rmx_copy(rm);
                if (dnew == NULL)
                        return(NULL);
                dnew->nrows = rm->ncols;
                dnew->ncols = rm->nrows;
                return(dnew);
        }
        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);
}

/* Element-wise multiplication (or division) of m2 into m1 */
int
rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide)
{
        int     zeroDivides = 0;
        int     i, j, k;

        if ((m1 == NULL) | (m2 == NULL) ||
                        (m1->ncols != m2->ncols) | (m1->nrows != m2->nrows))
                return(0);
        if ((m2->ncomp > 1) & (m2->ncomp != m1->ncomp))
                return(0);
        i = rmx_newtype(m1->dtype, m2->dtype);
        if (i)
                m1->dtype = i;
        else
                rmx_addinfo(m1, rmx_mismatch_warn);
        for (i = m1->nrows; i--; )
            for (j = m1->ncols; j--; )
                if (divide) {
                    double      d;
                    if (m2->ncomp == 1) {
                        d = rmx_lval(m2,i,j,0);
                        if (d == 0) {
                            ++zeroDivides;
                            for (k = m1->ncomp; k--; )
                                rmx_lval(m1,i,j,k) = 0;
                        } else {
                            d = 1./d;
                            for (k = m1->ncomp; k--; )
                                rmx_lval(m1,i,j,k) *= d;
                        }
                    } else
                        for (k = m1->ncomp; k--; ) {
                            d = rmx_lval(m2,i,j,k);
                            if (d == 0) {
                                ++zeroDivides;
                                rmx_lval(m1,i,j,k) = 0;
                            } else
                                rmx_lval(m1,i,j,k) /= d;
                        }
                } else {
                    if (m2->ncomp == 1) {
                        const double    d = rmx_lval(m2,i,j,0);
                        for (k = m1->ncomp; k--; )
                            rmx_lval(m1,i,j,k) *= d;
                    } else
                        for (k = m1->ncomp; k--; )
                            rmx_lval(m1,i,j,k) *= rmx_lval(m2,i,j,k);
                }
        if (zeroDivides) {
                fputs("Divide by zero in rmx_elemult()\n", stderr);
                errno = ERANGE;
        }
        return(1);
}

/* 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];

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