ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/util/rmatrix.c
(Generate patch)

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.35 by greg, Wed Aug 14 18:20:02 2019 UTC vs.
Revision 2.53 by greg, Sat Mar 5 01:45:21 2022 UTC

# Line 5 | Line 5 | static const char RCSid[] = "$Id$";
5   * General matrix operations.
6   */
7  
8 – #include <stdio.h>
8   #include <stdlib.h>
10 – #include <string.h>
11 – #include <fcntl.h>
9   #include <errno.h>
10   #include "rtio.h"
11   #include "platform.h"
12   #include "resolu.h"
13   #include "paths.h"
14   #include "rmatrix.h"
15 + #if !defined(_WIN32) && !defined(_WIN64)
16 + #include <sys/mman.h>
17 + #endif
18  
19   static char     rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
20  
21 < /* Allocate a nr x nc matrix with n components */
21 > #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   RMATRIX *
26 + 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   rmx_alloc(int nr, int nc, int n)
53   {
54 <        RMATRIX *dnew;
54 >        RMATRIX *dnew = rmx_new(nr, nc, n);
55  
56 <        if ((nr <= 0) | (nc <= 0) | (n <= 0))
57 <                return(NULL);
58 <        dnew = (RMATRIX *)malloc(sizeof(RMATRIX)-sizeof(dnew->mtx) +
59 <                                        sizeof(dnew->mtx[0])*(n*nr*nc));
31 <        if (!dnew)
32 <                return(NULL);
33 <        dnew->nrows = nr; dnew->ncols = nc; dnew->ncomp = n;
34 <        dnew->dtype = DTdouble;
35 <        dnew->info = NULL;
56 >        if (dnew && !rmx_prepare(dnew)) {
57 >                rmx_free(dnew);
58 >                dnew = NULL;
59 >        }
60          return(dnew);
61   }
62  
# Line 43 | Line 67 | rmx_free(RMATRIX *rm)
67          if (!rm) return;
68          if (rm->info)
69                  free(rm->info);
70 + #ifdef MAP_FILE
71 +        if (rm->mapped)
72 +                munmap(rm->mapped, mapped_size(rm));
73 +        else
74 + #endif
75 +                free(rm->mtx);
76          free(rm);
77   }
78  
# Line 63 | Line 93 | rmx_newtype(int dtyp1, int dtyp2)
93   int
94   rmx_addinfo(RMATRIX *rm, const char *info)
95   {
96 +        int     oldlen = 0;
97 +
98          if (!rm || !info || !*info)
99                  return(0);
100          if (!rm->info) {
101                  rm->info = (char *)malloc(strlen(info)+1);
102                  if (rm->info) rm->info[0] = '\0';
103 <        } else
103 >        } else {
104 >                oldlen = strlen(rm->info);
105                  rm->info = (char *)realloc(rm->info,
106 <                                strlen(rm->info)+strlen(info)+1);
106 >                                oldlen+strlen(info)+1);
107 >        }
108          if (!rm->info)
109                  return(0);
110 <        strcat(rm->info, info);
110 >        strcpy(rm->info+oldlen, info);
111          return(1);
112   }
113  
# Line 102 | Line 136 | get_dminfo(char *s, void *p)
136                  ip->swapin = (nativebigendian() != i);
137                  return(0);
138          }
139 +        if (isexpos(s)) {
140 +                float   f = exposval(s);
141 +                scalecolor(ip->cexp, f);
142 +                return(0);
143 +        }
144 +        if (iscolcor(s)) {
145 +                COLOR   ctmp;
146 +                colcorval(ctmp, s);
147 +                multcolor(ip->cexp, ctmp);
148 +                return(0);
149 +        }
150          if (!formatval(fmt, s)) {
151                  rmx_addinfo(ip, s);
152                  return(0);
153 <        }
153 >        }                       /* else check format */
154          for (i = 1; i < DTend; i++)
155                  if (!strcmp(fmt, cm_fmt_id[i])) {
156                          ip->dtype = i;
# Line 119 | Line 164 | rmx_load_ascii(RMATRIX *rm, FILE *fp)
164   {
165          int     i, j, k;
166  
167 +        if (!rmx_prepare(rm))
168 +                return(0);
169          for (i = 0; i < rm->nrows; i++)
170 <            for (j = 0; j < rm->ncols; j++)
170 >            for (j = 0; j < rm->ncols; j++) {
171 >                double  *dp = rmx_lval(rm,i,j);
172                  for (k = 0; k < rm->ncomp; k++)
173 <                    if (fscanf(fp, "%lf", &rmx_lval(rm,i,j,k)) != 1)
173 >                    if (fscanf(fp, "%lf", &dp[k]) != 1)
174                          return(0);
175 +            }
176          return(1);
177   }
178  
# Line 137 | Line 186 | rmx_load_float(RMATRIX *rm, FILE *fp)
186                  fputs("Unsupported # components in rmx_load_float()\n", stderr);
187                  exit(1);
188          }
189 +        if (!rmx_prepare(rm))
190 +                return(0);
191          for (i = 0; i < rm->nrows; i++)
192              for (j = 0; j < rm->ncols; j++) {
193 +                double  *dp = rmx_lval(rm,i,j);
194                  if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
195                      return(0);
196                  if (rm->swapin)
197                      swap32((char *)val, rm->ncomp);
198                  for (k = rm->ncomp; k--; )
199 <                     rmx_lval(rm,i,j,k) = val[k];
199 >                     dp[k] = val[k];
200              }
201          return(1);
202   }
# Line 152 | Line 204 | rmx_load_float(RMATRIX *rm, FILE *fp)
204   static int
205   rmx_load_double(RMATRIX *rm, FILE *fp)
206   {
207 <        int     i, j;
208 <
209 <        for (i = 0; i < rm->nrows; i++)
210 <            for (j = 0; j < rm->ncols; j++) {
211 <                if (getbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
212 <                    return(0);
207 >        int     i;
208 > #ifdef MAP_FILE
209 >        long    pos;            /* map memory to file if possible */
210 >        if (!rm->swapin && array_size(rm) >= 1L<<20 &&
211 >                        (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
212 >                rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ|PROT_WRITE,
213 >                                        MAP_PRIVATE, fileno(fp), 0);
214 >                if (rm->mapped != MAP_FAILED) {
215 >                        rm->mtx = (double *)rm->mapped + pos/sizeof(double);
216 >                        return(1);
217 >                }
218 >                rm->mapped = NULL;
219 >        }
220 > #endif
221 >        if (!rmx_prepare(rm))
222 >                return(0);
223 >        for (i = 0; i < rm->nrows; i++) {
224 >                if (getbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp,
225 >                                        rm->ncols, fp) != rm->ncols)
226 >                        return(0);
227                  if (rm->swapin)
228 <                    swap64((char *)&rmx_lval(rm,i,j,0), rm->ncomp);
229 <            }
228 >                        swap64((char *)rmx_lval(rm,i,0), rm->ncols*rm->ncomp);
229 >        }
230          return(1);
231   }
232  
# Line 172 | Line 238 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
238  
239          if (!scan)
240                  return(0);
241 +        if (!rmx_prepare(rm))
242 +                return(0);
243          for (i = 0; i < rm->nrows; i++) {
244 +            double      *dp = rmx_lval(rm,i,j);
245              if (freadscan(scan, rm->ncols, fp) < 0) {
246                  free(scan);
247                  return(0);
248              }
249 <            for (j = rm->ncols; j--; ) {
250 <                rmx_lval(rm,i,j,0) = colval(scan[j],RED);
251 <                rmx_lval(rm,i,j,1) = colval(scan[j],GRN);
252 <                rmx_lval(rm,i,j,2) = colval(scan[j],BLU);
249 >            for (j = 0; j < rm->ncols; j++, dp += 3) {
250 >                dp[0] = colval(scan[j],RED);
251 >                dp[1] = colval(scan[j],GRN);
252 >                dp[2] = colval(scan[j],BLU);
253              }
254          }
255          free(scan);
# Line 189 | Line 258 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
258  
259   /* Load matrix from supported file type */
260   RMATRIX *
261 < rmx_load(const char *inspec)
261 > rmx_load(const char *inspec, RMPref rmp)
262   {
263 <        FILE            *fp = stdin;
195 <        RMATRIX         dinfo;
263 >        FILE            *fp;
264          RMATRIX         *dnew;
265  
266 <        if (!inspec) {                          /* reading from stdin? */
267 <                inspec = "<stdin>";
268 <                SET_FILE_BINARY(stdin);
266 >        if (!inspec)
267 >                inspec = stdin_name;
268 >        else if (!*inspec)
269 >                return(NULL);
270 >        if (inspec == stdin_name) {             /* reading from stdin? */
271 >                fp = stdin;
272          } else if (inspec[0] == '!') {
273                  if (!(fp = popen(inspec+1, "r")))
274                          return(NULL);
204 –                SET_FILE_BINARY(stdin);
275          } else {
276                  const char      *sp = inspec;   /* check suffix */
277                  while (*sp)
# Line 209 | Line 279 | rmx_load(const char *inspec)
279                  while (sp > inspec && sp[-1] != '.')
280                          --sp;
281                  if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
282 <                        CMATRIX *cm = cm_loadBTDF((char *)inspec);
282 >                        CMATRIX *cm = rmp==RMPtrans ? cm_loadBTDF(inspec) :
283 >                                        cm_loadBRDF(inspec, rmp==RMPreflB) ;
284                          if (!cm)
285                                  return(NULL);
286                          dnew = rmx_from_cmatrix(cm);
# Line 218 | Line 289 | rmx_load(const char *inspec)
289                          return(dnew);
290                  }
291                                                  /* else open it ourselves */
292 <                if (!(fp = fopen(inspec, "rb")))
292 >                if (!(fp = fopen(inspec, "r")))
293                          return(NULL);
294          }
295 +        SET_FILE_BINARY(fp);
296   #ifdef getc_unlocked
297          flockfile(fp);
298   #endif
299 <        dinfo.nrows = dinfo.ncols = dinfo.ncomp = 0;
228 <        dinfo.dtype = DTascii;                  /* assumed w/o FORMAT */
229 <        dinfo.swapin = 0;
230 <        dinfo.info = NULL;
231 <        if (getheader(fp, get_dminfo, &dinfo) < 0) {
299 >        if (!(dnew = rmx_new(0,0,3))) {
300                  fclose(fp);
301                  return(NULL);
302          }
303 <        if ((dinfo.nrows <= 0) | (dinfo.ncols <= 0)) {
304 <                if (!fscnresolu(&dinfo.ncols, &dinfo.nrows, fp)) {
303 >        dnew->dtype = DTascii;                  /* assumed w/o FORMAT */
304 >        dnew->cexp[0] = dnew->cexp[1] = dnew->cexp[2] = 1.f;
305 >        if (getheader(fp, get_dminfo, dnew) < 0) {
306 >                fclose(fp);
307 >                return(NULL);
308 >        }
309 >        if ((dnew->nrows <= 0) | (dnew->ncols <= 0)) {
310 >                if (!fscnresolu(&dnew->ncols, &dnew->nrows, fp)) {
311                          fclose(fp);
312                          return(NULL);
313                  }
314 <                if (dinfo.ncomp <= 0)
315 <                        dinfo.ncomp = 3;
242 <                else if ((dinfo.dtype == DTrgbe) | (dinfo.dtype == DTxyze) &&
243 <                                dinfo.ncomp != 3) {
314 >                if ((dnew->dtype == DTrgbe) | (dnew->dtype == DTxyze) &&
315 >                                dnew->ncomp != 3) {
316                          fclose(fp);
317                          return(NULL);
318                  }
319          }
320 <        dnew = rmx_alloc(dinfo.nrows, dinfo.ncols, dinfo.ncomp);
249 <        if (!dnew) {
250 <                fclose(fp);
251 <                return(NULL);
252 <        }
253 <        dnew->info = dinfo.info;
254 <        switch (dinfo.dtype) {
320 >        switch (dnew->dtype) {
321          case DTascii:
322 <                SET_FILE_TEXT(stdin);
322 >                SET_FILE_TEXT(fp);
323                  if (!rmx_load_ascii(dnew, fp))
324                          goto loaderr;
325                  dnew->dtype = DTascii;          /* should leave double? */
326                  break;
327          case DTfloat:
262 –                dnew->swapin = dinfo.swapin;
328                  if (!rmx_load_float(dnew, fp))
329                          goto loaderr;
330                  dnew->dtype = DTfloat;
331                  break;
332          case DTdouble:
268 –                dnew->swapin = dinfo.swapin;
333                  if (!rmx_load_double(dnew, fp))
334                          goto loaderr;
335                  dnew->dtype = DTdouble;
# Line 274 | Line 338 | rmx_load(const char *inspec)
338          case DTxyze:
339                  if (!rmx_load_rgbe(dnew, fp))
340                          goto loaderr;
341 <                dnew->dtype = dinfo.dtype;
341 >                                                /* undo exposure? */
342 >                if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) |
343 >                                (dnew->cexp[2] != 1.f)) {
344 >                        double  cmlt[3];
345 >                        cmlt[0] = 1./dnew->cexp[0];
346 >                        cmlt[1] = 1./dnew->cexp[1];
347 >                        cmlt[2] = 1./dnew->cexp[2];
348 >                        rmx_scale(dnew, cmlt);
349 >                }
350 >                dnew->swapin = 0;
351                  break;
352          default:
353                  goto loaderr;
# Line 309 | Line 382 | rmx_write_ascii(const RMATRIX *rm, FILE *fp)
382  
383          for (i = 0; i < rm->nrows; i++) {
384              for (j = 0; j < rm->ncols; j++) {
385 +                const double    *dp = rmx_lval(rm,i,j);
386                  for (k = 0; k < rm->ncomp; k++)
387 <                    fprintf(fp, fmt, rmx_lval(rm,i,j,k));
387 >                    fprintf(fp, fmt, dp[k]);
388                  fputc('\t', fp);
389              }
390              fputc('\n', fp);
# Line 330 | Line 404 | rmx_write_float(const RMATRIX *rm, FILE *fp)
404          }
405          for (i = 0; i < rm->nrows; i++)
406              for (j = 0; j < rm->ncols; j++) {
407 +                const double    *dp = rmx_lval(rm,i,j);
408                  for (k = rm->ncomp; k--; )
409 <                    val[k] = (float)rmx_lval(rm,i,j,k);
410 <                if (putbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
409 >                    val[k] = (float)dp[k];
410 >                if (putbinary(val, sizeof(float), rm->ncomp, fp) != rm->ncomp)
411                          return(0);
412              }
413          return(1);
# Line 341 | Line 416 | rmx_write_float(const RMATRIX *rm, FILE *fp)
416   static int
417   rmx_write_double(const RMATRIX *rm, FILE *fp)
418   {
419 <        int     i, j;
419 >        int     i;
420  
421          for (i = 0; i < rm->nrows; i++)
422 <            for (j = 0; j < rm->ncols; j++)
423 <                if (putbinary(&rmx_lval(rm,i,j,0), sizeof(double), rm->ncomp, fp) != rm->ncomp)
422 >                if (putbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp,
423 >                                        rm->ncols, fp) != rm->ncols)
424                          return(0);
425          return(1);
426   }
# Line 359 | Line 434 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
434          if (!scan)
435                  return(0);
436          for (i = 0; i < rm->nrows; i++) {
437 <            for (j = rm->ncols; j--; )
438 <                setcolr(scan[j],        rmx_lval(rm,i,j,0),
439 <                                        rmx_lval(rm,i,j,1),
440 <                                        rmx_lval(rm,i,j,2)      );
437 >            for (j = rm->ncols; j--; ) {
438 >                const double    *dp = rmx_lval(rm,i,j);
439 >                setcolr(scan[j], dp[0], dp[1], dp[2]);
440 >            }
441              if (fwritecolrs(scan, rm->ncols, fp) < 0) {
442                  free(scan);
443                  return(0);
# Line 372 | Line 447 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
447          return(1);
448   }
449  
450 + /* Check if CIE XYZ primaries were specified */
451 + static int
452 + findCIEprims(const char *info)
453 + {
454 +        RGBPRIMS        prims;
455 +
456 +        if (!info)
457 +                return(0);
458 +        info = strstr(info, PRIMARYSTR);
459 +        if (!info || !primsval(prims, info))
460 +                return(0);
461 +
462 +        return((prims[RED][CIEX] > .99) & (prims[RED][CIEY] < .01) &&
463 +                        (prims[GRN][CIEX] < .01) & (prims[GRN][CIEY] > .99) &&
464 +                        (prims[BLU][CIEX] < .01) & (prims[BLU][CIEY] < .01));
465 + }
466 +
467   /* Write matrix to file type indicated by dtype */
468   int
469   rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
470   {
379 –        RMATRIX *mydm = NULL;
471          int     ok = 1;
472  
473 <        if (!rm | !fp)
473 >        if (!rm | !fp || !rm->mtx)
474                  return(0);
475   #ifdef getc_unlocked
476          flockfile(fp);
# Line 389 | Line 480 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
480                  fputs(rm->info, fp);
481          if (dtype == DTfromHeader)
482                  dtype = rm->dtype;
483 <        else if ((dtype == DTrgbe) & (rm->dtype == DTxyze))
483 >        else if (dtype == DTrgbe && (rm->dtype == DTxyze ||
484 >                                        findCIEprims(rm->info)))
485                  dtype = DTxyze;
486          else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
487                  dtype = DTrgbe;
# Line 398 | Line 490 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
490                  fprintf(fp, "NCOLS=%d\n", rm->ncols);
491                  fprintf(fp, "NCOMP=%d\n", rm->ncomp);
492          } else if (rm->ncomp != 3) {            /* wrong # components? */
493 <                double  cmtx[3];
493 >                CMATRIX *cm;                    /* convert & write */
494                  if (rm->ncomp != 1)             /* only convert grayscale */
495                          return(0);
496 <                cmtx[0] = cmtx[1] = cmtx[2] = 1;
405 <                mydm = rmx_transform(rm, 3, cmtx);
406 <                if (!mydm)
496 >                if (!(cm = cm_from_rmatrix(rm)))
497                          return(0);
498 <                rm = mydm;
498 >                fputformat(cm_fmt_id[dtype], fp);
499 >                fputc('\n', fp);
500 >                ok = cm_write(cm, dtype, fp);
501 >                cm_free(cm);
502 >                return(ok);
503          }
504          if ((dtype == DTfloat) | (dtype == DTdouble))
505                  fputendian(fp);                 /* important to record */
506 <        fputformat((char *)cm_fmt_id[dtype], fp);
506 >        fputformat(cm_fmt_id[dtype], fp);
507          fputc('\n', fp);
508          switch (dtype) {                        /* write data */
509          case DTascii:
# Line 433 | Line 527 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
527   #ifdef getc_unlocked
528          funlockfile(fp);
529   #endif
436 –        if (mydm)
437 –                rmx_free(mydm);
530          return(ok);
531   }
532  
# Line 447 | Line 539 | rmx_identity(const int dim, const int n)
539  
540          if (!rid)
541                  return(NULL);
542 <        memset(rid->mtx, 0, sizeof(rid->mtx[0])*n*dim*dim);
543 <        for (i = dim; i--; )
542 >        memset(rid->mtx, 0, array_size(rid));
543 >        for (i = dim; i--; ) {
544 >            double      *dp = rmx_lval(rid,i,i);
545              for (k = n; k--; )
546 <                rmx_lval(rid,i,i,k) = 1;
546 >                dp[k] = 1.;
547 >        }
548          return(rid);
549   }
550  
# Line 467 | Line 561 | rmx_copy(const RMATRIX *rm)
561                  return(NULL);
562          rmx_addinfo(dnew, rm->info);
563          dnew->dtype = rm->dtype;
564 <        memcpy(dnew->mtx, rm->mtx,
471 <                sizeof(rm->mtx[0])*rm->ncomp*rm->nrows*rm->ncols);
564 >        memcpy(dnew->mtx, rm->mtx, array_size(dnew));
565          return(dnew);
566   }
567  
# Line 499 | Line 592 | rmx_transpose(const RMATRIX *rm)
592          dnew->dtype = rm->dtype;
593          for (i = dnew->nrows; i--; )
594              for (j = dnew->ncols; j--; )
595 <                for (k = dnew->ncomp; k--; )
596 <                        rmx_lval(dnew,i,j,k) = rmx_lval(rm,j,i,k);
595 >                memcpy(rmx_lval(dnew,i,j), rmx_lval(rm,i,j),
596 >                                sizeof(double)*dnew->ncomp);
597          return(dnew);
598   }
599  
# Line 524 | Line 617 | rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
617          for (i = mres->nrows; i--; )
618              for (j = mres->ncols; j--; )
619                  for (k = mres->ncomp; k--; ) {
620 <                    long double d = 0;
620 >                    double      d = 0;
621                      for (h = m1->ncols; h--; )
622 <                        d += rmx_lval(m1,i,h,k) * rmx_lval(m2,h,j,k);
623 <                    rmx_lval(mres,i,j,k) = (double)d;
622 >                        d += rmx_lval(m1,i,h)[k] * rmx_lval(m2,h,j)[k];
623 >                    rmx_lval(mres,i,j)[k] = d;
624                  }
625          return(mres);
626   }
# Line 553 | Line 646 | rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide
646                  if (divide) {
647                      double      d;
648                      if (m2->ncomp == 1) {
649 <                        d = rmx_lval(m2,i,j,0);
649 >                        d = rmx_lval(m2,i,j)[0];
650                          if (d == 0) {
651                              ++zeroDivides;
652                              for (k = m1->ncomp; k--; )
653 <                                rmx_lval(m1,i,j,k) = 0;
653 >                                rmx_lval(m1,i,j)[k] = 0;
654                          } else {
655                              d = 1./d;
656                              for (k = m1->ncomp; k--; )
657 <                                rmx_lval(m1,i,j,k) *= d;
657 >                                rmx_lval(m1,i,j)[k] *= d;
658                          }
659                      } else
660                          for (k = m1->ncomp; k--; ) {
661 <                            d = rmx_lval(m2,i,j,k);
661 >                            d = rmx_lval(m2,i,j)[k];
662                              if (d == 0) {
663                                  ++zeroDivides;
664 <                                rmx_lval(m1,i,j,k) = 0;
664 >                                rmx_lval(m1,i,j)[k] = 0;
665                              } else
666 <                                rmx_lval(m1,i,j,k) /= d;
666 >                                rmx_lval(m1,i,j)[k] /= d;
667                          }
668                  } else {
669                      if (m2->ncomp == 1) {
670 <                        const double    d = rmx_lval(m2,i,j,0);
670 >                        const double    d = rmx_lval(m2,i,j)[0];
671                          for (k = m1->ncomp; k--; )
672 <                            rmx_lval(m1,i,j,k) *= d;
672 >                            rmx_lval(m1,i,j)[k] *= d;
673                      } else
674                          for (k = m1->ncomp; k--; )
675 <                            rmx_lval(m1,i,j,k) *= rmx_lval(m2,i,j,k);
675 >                            rmx_lval(m1,i,j)[k] *= rmx_lval(m2,i,j)[k];
676                  }
677          if (zeroDivides) {
678                  rmx_addinfo(m1, "WARNING: zero divide(s) corrupted results\n");
# Line 614 | Line 707 | rmx_sum(RMATRIX *msum, const RMATRIX *madd, const doub
707          else
708                  rmx_addinfo(msum, rmx_mismatch_warn);
709          for (i = msum->nrows; i--; )
710 <            for (j = msum->ncols; j--; )
710 >            for (j = msum->ncols; j--; ) {
711 >                const double    *da = rmx_lval(madd,i,j);
712 >                double          *ds = rmx_lval(msum,i,j);
713                  for (k = msum->ncomp; k--; )
714 <                     rmx_lval(msum,i,j,k) += sf[k] * rmx_lval(madd,i,j,k);
714 >                     ds[k] += sf[k] * da[k];
715 >            }
716          if (mysf)
717                  free(mysf);
718          return(1);
# Line 631 | Line 727 | rmx_scale(RMATRIX *rm, const double sf[])
727          if (!rm | !sf)
728                  return(0);
729          for (i = rm->nrows; i--; )
730 <            for (j = rm->ncols; j--; )
730 >            for (j = rm->ncols; j--; ) {
731 >                double  *dp = rmx_lval(rm,i,j);
732                  for (k = rm->ncomp; k--; )
733 <                    rmx_lval(rm,i,j,k) *= sf[k];
734 <
733 >                    dp[k] *= sf[k];
734 >            }
735          if (rm->info)
736                  rmx_addinfo(rm, "Applied scalar\n");
737          return(1);
# Line 654 | Line 751 | rmx_transform(const RMATRIX *msrc, int n, const double
751                  return(NULL);
752          if (msrc->info) {
753                  char    buf[128];
754 <                sprintf(buf, "Applied %dx%d matrix transform\n",
754 >                sprintf(buf, "Applied %dx%d component transform\n",
755                                  dnew->ncomp, msrc->ncomp);
756                  rmx_addinfo(dnew, msrc->info);
757                  rmx_addinfo(dnew, buf);
758          }
759          dnew->dtype = msrc->dtype;
760          for (i = dnew->nrows; i--; )
761 <            for (j = dnew->ncols; j--; )
761 >            for (j = dnew->ncols; j--; ) {
762 >                const double    *ds = rmx_lval(msrc,i,j);
763                  for (kd = dnew->ncomp; kd--; ) {
764                      double      d = 0;
765                      for (ks = msrc->ncomp; ks--; )
766 <                        d += cmat[kd*msrc->ncomp + ks] * rmx_lval(msrc,i,j,ks);
767 <                    rmx_lval(dnew,i,j,kd) = d;
766 >                        d += cmat[kd*msrc->ncomp + ks] * ds[ks];
767 >                    rmx_lval(dnew,i,j)[kd] = d;
768                  }
769 +            }
770          return(dnew);
771   }
772  
# Line 687 | Line 786 | rmx_from_cmatrix(const CMATRIX *cm)
786          for (i = dnew->nrows; i--; )
787              for (j = dnew->ncols; j--; ) {
788                  const COLORV    *cv = cm_lval(cm,i,j);
789 <                rmx_lval(dnew,i,j,0) = cv[0];
790 <                rmx_lval(dnew,i,j,1) = cv[1];
791 <                rmx_lval(dnew,i,j,2) = cv[2];
789 >                double          *dp = rmx_lval(dnew,i,j);
790 >                dp[0] = cv[0];
791 >                dp[1] = cv[1];
792 >                dp[2] = cv[2];
793              }
794          return(dnew);
795   }
# Line 701 | Line 801 | cm_from_rmatrix(const RMATRIX *rm)
801          int     i, j;
802          CMATRIX *cnew;
803  
804 <        if (!rm || rm->ncomp != 3)
804 >        if (!rm || !rm->mtx | ((rm->ncomp != 3) & (rm->ncomp != 1)))
805                  return(NULL);
806          cnew = cm_alloc(rm->nrows, rm->ncols);
807          if (!cnew)
808                  return(NULL);
809          for (i = cnew->nrows; i--; )
810              for (j = cnew->ncols; j--; ) {
811 <                COLORV  *cv = cm_lval(cnew,i,j);
812 <                cv[0] = (COLORV)rmx_lval(rm,i,j,0);
813 <                cv[1] = (COLORV)rmx_lval(rm,i,j,1);
814 <                cv[2] = (COLORV)rmx_lval(rm,i,j,2);
811 >                const double    *dp = rmx_lval(rm,i,j);
812 >                COLORV          *cv = cm_lval(cnew,i,j);
813 >                if (rm->ncomp == 1)
814 >                    setcolor(cv, dp[0], dp[0], dp[0]);
815 >                else
816 >                    setcolor(cv, dp[0], dp[1], dp[2]);
817              }
818          return(cnew);
819   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines