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

Comparing src/util/rmatrix.c (file contents):
Revision 2.50 by greg, Fri Mar 4 01:27:12 2022 UTC vs.
Revision 2.59 by greg, Sat Jul 1 15:25:26 2023 UTC

# Line 32 | Line 32 | rmx_new(int nr, int nc, int n)
32                  dnew->nrows = nr;
33                  dnew->ncols = nc;
34                  dnew->ncomp = n;
35 +                setcolor(dnew->cexp, 1.f, 1.f, 1.f);
36          }
37          return(dnew);
38   }
# Line 118 | Line 119 | get_dminfo(char *s, void *p)
119          char    fmt[MAXFMTLEN];
120          int     i;
121  
122 <        if (headidval(fmt, s))
122 >        if (headidval(NULL, s))
123                  return(0);
124          if (!strncmp(s, "NCOMP=", 6)) {
125                  ip->ncomp = atoi(s+6);
# Line 137 | Line 138 | get_dminfo(char *s, void *p)
138                  return(0);
139          }
140          if (isexpos(s)) {
141 <                double  d = exposval(s);
142 <                scalecolor(ip->cexp, d);
141 >                float   f = exposval(s);
142 >                scalecolor(ip->cexp, f);
143                  return(0);
144          }
145          if (iscolcor(s)) {
# Line 167 | Line 168 | rmx_load_ascii(RMATRIX *rm, FILE *fp)
168          if (!rmx_prepare(rm))
169                  return(0);
170          for (i = 0; i < rm->nrows; i++)
171 <            for (j = 0; j < rm->ncols; j++)
171 >            for (j = 0; j < rm->ncols; j++) {
172 >                double  *dp = rmx_lval(rm,i,j);
173                  for (k = 0; k < rm->ncomp; k++)
174 <                    if (fscanf(fp, "%lf", &rmx_lval(rm,i,j,k)) != 1)
174 >                    if (fscanf(fp, "%lf", &dp[k]) != 1)
175                          return(0);
176 +            }
177          return(1);
178   }
179  
# Line 188 | Line 191 | rmx_load_float(RMATRIX *rm, FILE *fp)
191                  return(0);
192          for (i = 0; i < rm->nrows; i++)
193              for (j = 0; j < rm->ncols; j++) {
194 +                double  *dp = rmx_lval(rm,i,j);
195                  if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
196                      return(0);
197                  if (rm->swapin)
198                      swap32((char *)val, rm->ncomp);
199                  for (k = rm->ncomp; k--; )
200 <                     rmx_lval(rm,i,j,k) = val[k];
200 >                     dp[k] = val[k];
201              }
202          return(1);
203   }
# Line 203 | Line 207 | rmx_load_double(RMATRIX *rm, FILE *fp)
207   {
208          int     i;
209   #ifdef MAP_FILE
210 <        long    pos;            /* map memory to file if possible */
211 <        if (!rm->swapin && (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
210 >        long    pos;            /* map memory for file > 1MB if possible */
211 >        if (!rm->swapin && array_size(rm) >= 1L<<20 &&
212 >                        (pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
213                  rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ|PROT_WRITE,
214                                          MAP_PRIVATE, fileno(fp), 0);
215                  if (rm->mapped != MAP_FAILED) {
216                          rm->mtx = (double *)rm->mapped + pos/sizeof(double);
217                          return(1);
218 <                }
218 >                }               /* else fall back on reading into memory */
219                  rm->mapped = NULL;
220          }
221   #endif
222          if (!rmx_prepare(rm))
223                  return(0);
224          for (i = 0; i < rm->nrows; i++) {
225 <                if (getbinary(&rmx_lval(rm,i,0,0), sizeof(double)*rm->ncomp,
225 >                if (getbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp,
226                                          rm->ncols, fp) != rm->ncols)
227                          return(0);
228                  if (rm->swapin)
229 <                        swap64((char *)&rmx_lval(rm,i,0,0), rm->ncols*rm->ncomp);
229 >                        swap64((char *)rmx_lval(rm,i,0), rm->ncols*rm->ncomp);
230          }
231          return(1);
232   }
# Line 237 | Line 242 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
242          if (!rmx_prepare(rm))
243                  return(0);
244          for (i = 0; i < rm->nrows; i++) {
245 +            double      *dp = rmx_lval(rm,i,0);
246              if (freadscan(scan, rm->ncols, fp) < 0) {
247                  free(scan);
248                  return(0);
249              }
250 <            for (j = rm->ncols; j--; ) {
251 <                rmx_lval(rm,i,j,0) = colval(scan[j],RED);
252 <                rmx_lval(rm,i,j,1) = colval(scan[j],GRN);
253 <                rmx_lval(rm,i,j,2) = colval(scan[j],BLU);
250 >            for (j = 0; j < rm->ncols; j++, dp += 3) {
251 >                dp[0] = colval(scan[j],RED);
252 >                dp[1] = colval(scan[j],GRN);
253 >                dp[2] = colval(scan[j],BLU);
254              }
255          }
256          free(scan);
# Line 296 | Line 302 | rmx_load(const char *inspec, RMPref rmp)
302                  return(NULL);
303          }
304          dnew->dtype = DTascii;                  /* assumed w/o FORMAT */
299 –        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);
# Line 333 | Line 338 | rmx_load(const char *inspec, RMPref rmp)
338          case DTxyze:
339                  if (!rmx_load_rgbe(dnew, fp))
340                          goto loaderr;
336 –                                                /* undo exposure? */
337 –                if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) |
338 –                                (dnew->cexp[2] != 1.f)) {
339 –                        double  cmlt[3];
340 –                        cmlt[0] = 1./dnew->cexp[0];
341 –                        cmlt[1] = 1./dnew->cexp[1];
342 –                        cmlt[2] = 1./dnew->cexp[2];
343 –                        rmx_scale(dnew, cmlt);
344 –                }
345 –                dnew->swapin = 0;
341                  break;
342          default:
343                  goto loaderr;
# Line 357 | Line 352 | rmx_load(const char *inspec, RMPref rmp)
352          else
353                  funlockfile(fp);
354   #endif
355 +                                                /* undo exposure? */
356 +        if (dnew->ncomp == 3 && (dnew->cexp[0] != 1.f) |
357 +                        (dnew->cexp[1] != 1.f) | (dnew->cexp[2] != 1.f)) {
358 +                double  cmlt[3];
359 +                cmlt[0] = 1./dnew->cexp[0];
360 +                cmlt[1] = 1./dnew->cexp[1];
361 +                cmlt[2] = 1./dnew->cexp[2];
362 +                rmx_scale(dnew, cmlt);
363 +                setcolor(dnew->cexp, 1.f, 1.f, 1.f);
364 +        }
365          return(dnew);
366   loaderr:                                        /* should report error? */
367          if (inspec[0] == '!')
# Line 377 | 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 398 | 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 409 | 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 427 | 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 >                if (rm->ncomp == 1)
440 >                        setcolr(scan[j], dp[0], dp[0], dp[0]);
441 >                else
442 >                        setcolr(scan[j], dp[0], dp[1], dp[2]);
443 >            }
444              if (fwritecolrs(scan, rm->ncols, fp) < 0) {
445                  free(scan);
446                  return(0);
# Line 461 | Line 471 | findCIEprims(const char *info)
471   int
472   rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
473   {
464 –        RMATRIX *mydm = NULL;
474          int     ok = 1;
475  
476 <        if (!rm | !fp)
476 >        if (!rm | !fp || !rm->mtx)
477                  return(0);
478   #ifdef getc_unlocked
479          flockfile(fp);
# Line 479 | Line 488 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
488                  dtype = DTxyze;
489          else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
490                  dtype = DTrgbe;
491 +        if (rm->ncomp == 3) {                   /* write exposure? */
492 +                if ((rm->cexp[RED] != rm->cexp[GRN]) |
493 +                                (rm->cexp[GRN] != rm->cexp[BLU]))
494 +                        fputcolcor(rm->cexp, fp);
495 +                else if (rm->cexp[GRN] != 1.f)
496 +                        fputexpos(rm->cexp[GRN], fp);
497 +        }
498          if ((dtype != DTrgbe) & (dtype != DTxyze)) {
499                  fprintf(fp, "NROWS=%d\n", rm->nrows);
500                  fprintf(fp, "NCOLS=%d\n", rm->ncols);
501                  fprintf(fp, "NCOMP=%d\n", rm->ncomp);
502 <        } else if (rm->ncomp != 3) {            /* wrong # components? */
503 <                double  cmtx[3];
488 <                if (rm->ncomp != 1)             /* only convert grayscale */
489 <                        return(0);
490 <                cmtx[0] = cmtx[1] = cmtx[2] = 1;
491 <                mydm = rmx_transform(rm, 3, cmtx);
492 <                if (!mydm)
493 <                        return(0);
494 <                rm = mydm;
495 <        }
502 >        } else if ((rm->ncomp != 3) & (rm->ncomp != 1))
503 >                return(0);                      /* wrong # components */
504          if ((dtype == DTfloat) | (dtype == DTdouble))
505                  fputendian(fp);                 /* important to record */
506          fputformat(cm_fmt_id[dtype], fp);
# Line 519 | Line 527 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
527   #ifdef getc_unlocked
528          funlockfile(fp);
529   #endif
522 –        if (mydm)
523 –                rmx_free(mydm);
530          return(ok);
531   }
532  
# Line 533 | 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 553 | 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,
557 <                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 563 | Line 570 | RMATRIX *
570   rmx_transpose(const RMATRIX *rm)
571   {
572          RMATRIX *dnew;
573 <        int     i, j, k;
573 >        int     i, j;
574  
575          if (!rm)
576                  return(0);
# Line 583 | Line 590 | rmx_transpose(const RMATRIX *rm)
590                  rmx_addinfo(dnew, "Transposed rows and columns\n");
591          }
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);
593 >        for (j = dnew->ncols; j--; )
594 >            for (i = dnew->nrows; i--; )
595 >                memcpy(rmx_lval(dnew,i,j), rmx_lval(rm,j,i),
596 >                                sizeof(double)*dnew->ncomp);
597          return(dnew);
598   }
599  
# Line 610 | 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 639 | 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 700 | 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 717 | 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 747 | Line 758 | rmx_transform(const RMATRIX *msrc, int n, const double
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 773 | 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 787 | 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