src/util/rmatrix.c

#ifndef lint
static const char RCSid[] = "$Id: rmatrix.c,v 2.51 2022/03/04 02:07:34 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"
#if !defined(_WIN32) && !defined(_WIN64)
#include <sys/mman.h>
#endif

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

#define array_size(rm)  (sizeof(double)*(rm)->nrows*(rm)->ncols*(rm)->ncomp)
#define mapped_size(rm) ((char *)(rm)->mtx + array_size(rm) - (char *)(rm)->mapped)

/* Initialize a RMATRIX struct but don't allocate array space */
RMATRIX *
rmx_new(int nr, int nc, int n)
{
        RMATRIX *dnew = (RMATRIX *)calloc(1, sizeof(RMATRIX));

        if (dnew) {
                dnew->dtype = DTdouble;
                dnew->nrows = nr;
                dnew->ncols = nc;
                dnew->ncomp = n;
        }
        return(dnew);
}

/* Prepare a RMATRIX for writing (allocate array if needed) */
int
rmx_prepare(RMATRIX *rm)
{
        if (!rm) return(0);
        if (rm->mtx)
                return(1);
        rm->mtx = (double *)malloc(array_size(rm));
        return(rm->mtx != NULL);
}

/* Call rmx_new() and rmx_prepare() */
RMATRIX *
rmx_alloc(int nr, int nc, int n)
{
        RMATRIX *dnew = rmx_new(nr, nc, n);

        if (dnew && !rmx_prepare(dnew)) {
                rmx_free(dnew);
                dnew = NULL;
        }
        return(dnew);
}

/* Free a RMATRIX array */
void
rmx_free(RMATRIX *rm)
{
        if (!rm) return;
        if (rm->info)
                free(rm->info);
#ifdef MAP_FILE
        if (rm->mapped)
                munmap(rm->mapped, mapped_size(rm));
        else
#endif
                free(rm->mtx);
        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)
{
        int     oldlen = 0;

        if (!rm || !info || !*info)
                return(0);
        if (!rm->info) {
                rm->info = (char *)malloc(strlen(info)+1);
                if (rm->info) rm->info[0] = '\0';
        } else {
                oldlen = strlen(rm->info);
                rm->info = (char *)realloc(rm->info,
                                oldlen+strlen(info)+1);
        }
        if (!rm->info)
                return(0);
        strcpy(rm->info+oldlen, 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)) {
                float   f = exposval(s);
                scalecolor(ip->cexp, f);
                return(0);
        }
        if (iscolcor(s)) {
                COLOR   ctmp;
                colcorval(ctmp, s);
                multcolor(ip->cexp, ctmp);
                return(0);
        }
        if (!formatval(fmt, s)) {
                rmx_addinfo(ip, s);
                return(0);
        }                       /* else check format */
        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;

        if (!rmx_prepare(rm))
                return(0);
        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);
        }
        if (!rmx_prepare(rm))
                return(0);
        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;
#ifdef MAP_FILE
        long    pos;            /* map memory to file if possible */
        if (!rm->swapin && array_size(rm) >= 1L<<20 &&
                        (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
                rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ|PROT_WRITE,
                                        MAP_PRIVATE, fileno(fp), 0);
                if (rm->mapped != MAP_FAILED) {
                        rm->mtx = (double *)rm->mapped + pos/sizeof(double);
                        return(1);
                }
                rm->mapped = NULL;
        }
#endif
        if (!rmx_prepare(rm))
                return(0);
        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);
        if (!rmx_prepare(rm))
                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         *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
        if (!(dnew = rmx_new(0,0,3))) {
                fclose(fp);
                return(NULL);
        }
        dnew->dtype = DTascii;                  /* assumed w/o FORMAT */
        dnew->cexp[0] = dnew->cexp[1] = dnew->cexp[2] = 1.f;
        if (getheader(fp, get_dminfo, dnew) < 0) {
                fclose(fp);
                return(NULL);
        }
        if ((dnew->nrows <= 0) | (dnew->ncols <= 0)) {
                if (!fscnresolu(&dnew->ncols, &dnew->nrows, fp)) {
                        fclose(fp);
                        return(NULL);
                }
                if ((dnew->dtype == DTrgbe) | (dnew->dtype == DTxyze) &&
                                dnew->ncomp != 3) {
                        fclose(fp);
                        return(NULL);
                }
        }
        switch (dnew->dtype) {
        case DTascii:
                SET_FILE_TEXT(fp);
                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;
                                                /* undo exposure? */
                if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) |
                                (dnew->cexp[2] != 1.f)) {
                        double  cmlt[3];
                        cmlt[0] = 1./dnew->cexp[0];
                        cmlt[1] = 1./dnew->cexp[1];
                        cmlt[2] = 1./dnew->cexp[2];
                        rmx_scale(dnew, cmlt);
                }
                dnew->swapin = 0;
                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;

        for (i = 0; i < rm->nrows; i++)
                if (putbinary(&rmx_lval(rm,i,0,0), sizeof(double)*rm->ncomp,
                                        rm->ncols, fp) != rm->ncols)
                        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)
{
        int     ok = 1;

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