src/util/rmatrix.c

#ifndef lint
static const char RCSid[] = "$Id: rmatrix.c,v 2.47 2021/01/22 16:19:15 greg Exp $";
#endif
/*
 * General matrix operations.
 */

#include <stdlib.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)
                return(NULL);
        dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
        dnew->dtype = DTdouble;
        dnew->swapin = 0;
        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 (!rm || !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 ((i = isbigendian(s)) >= 0) {
                ip->swapin = (nativebigendian() != i);
                return(0);
        }
        if (isexpos(s)) {
                double  d = exposval(s);
                scalecolor(ip->mtx, d);
                return(0);
        }
        if (iscolcor(s)) {
                COLOR   ctmp;
                colcorval(ctmp, s);
                multcolor(ip->mtx, ctmp);
                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);
                if (rm->swapin)
                    swap32((char *)val, rm->ncomp);
                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;

        if ((char *)&rmx_lval(rm,1,0,0) - (char *)&rmx_lval(rm,0,0,0) !=
                                        sizeof(double)*rm->ncols*rm->ncomp) {
                fputs("Code error in rmx_load_double()\n", stderr);
                exit(1);
        }
        for (i = 0; i < rm->nrows; i++) {
                if (getbinary(&rmx_lval(rm,i,0,0), sizeof(double)*rm->ncomp,
                                        rm->ncols, fp) != rm->ncols)
                        return(0);
                if (rm->swapin)
                        swap64((char *)&rmx_lval(rm,i,0,0), rm->ncols*rm->ncomp);
        }
        return(1);
}

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

        if (!scan)
                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, RMPref rmp)
{
        FILE            *fp;
        RMATRIX         dinfo;
        RMATRIX         *dnew;

        if (!inspec)
                inspec = stdin_name;
        else if (!*inspec)
                return(NULL);
        if (inspec == stdin_name) {             /* reading from stdin? */
                fp = stdin;
        } else if (inspec[0] == '!') {
                if (!(fp = popen(inspec+1, "r")))
                        return(NULL);
        } 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 = rmp==RMPtrans ? cm_loadBTDF(inspec) :
                                        cm_loadBRDF(inspec, rmp==RMPreflB) ;
                        if (!cm)
                                return(NULL);
                        dnew = rmx_from_cmatrix(cm);
                        cm_free(cm);
                        dnew->dtype = DTascii;
                        return(dnew);
                }
                                                /* else open it ourselves */
                if (!(fp = fopen(inspec, "r")))
                        return(NULL);
        }
        SET_FILE_BINARY(fp);
#ifdef getc_unlocked
        flockfile(fp);
#endif
        dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0;
        dinfo.dtype = DTascii;                  /* assumed w/o FORMAT */
        dinfo.swapin = 0;
        dinfo.info = NULL;
        dinfo.mtx[0] = dinfo.mtx[1] = dinfo.mtx[2] = 1.;
        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) {
                fclose(fp);
                return(NULL);
        }
        dnew->info = dinfo.info;
        switch (dinfo.dtype) {
        case DTascii:
                SET_FILE_TEXT(fp);
                if (!rmx_load_ascii(dnew, fp))
                        goto loaderr;
                dnew->dtype = DTascii;          /* should leave double? */
                break;
        case DTfloat:
                dnew->swapin = dinfo.swapin;
                if (!rmx_load_float(dnew, fp))
                        goto loaderr;
                dnew->dtype = DTfloat;
                break;
        case DTdouble:
                dnew->swapin = dinfo.swapin;
                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;      /* undo exposure? */
                if ((dinfo.mtx[0] != 1.) | (dinfo.mtx[1] != 1.) |
                                (dinfo.mtx[2] != 1.)) {
                        dinfo.mtx[0] = 1./dinfo.mtx[0];
                        dinfo.mtx[1] = 1./dinfo.mtx[1];
                        dinfo.mtx[2] = 1./dinfo.mtx[2];
                        rmx_scale(dnew, dinfo.mtx);
                }
                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)
                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);
}

/* Check if CIE XYZ primaries were specified */
static int
findCIEprims(const char *info)
{
        RGBPRIMS        prims;

        if (!info)
                return(0);
        info = strstr(info, PRIMARYSTR);
        if (!info || !primsval(prims, info))
                return(0);

        return((prims[RED][CIEX] > .99) & (prims[RED][CIEY] < .01) &&
                        (prims[GRN][CIEX] < .01) & (prims[GRN][CIEY] > .99) &&
                        (prims[BLU][CIEX] < .01) & (prims[BLU][CIEY] < .01));
}

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