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.92 by greg, Wed Apr 16 21:54:15 2025 UTC vs.
Revision 2.101 by greg, Mon Aug 11 22:31:33 2025 UTC

# Line 20 | Line 20 | static const char      rmx_mismatch_warn[] = "WARNING: data
20  
21   /* Initialize a RMATRIX struct but don't allocate array space */
22   RMATRIX *
23 < rmx_new(int nr, int nc, int n)
23 > rmx_new(int nr, int nc, int ncomp)
24   {
25          RMATRIX *dnew;
26  
27 <        if (n <= 0)
27 >        if (ncomp <= 0)
28                  return(NULL);
29  
30          dnew = (RMATRIX *)calloc(1, sizeof(RMATRIX));
# Line 34 | Line 34 | rmx_new(int nr, int nc, int n)
34          dnew->dtype = DTrmx_native;
35          dnew->nrows = nr;
36          dnew->ncols = nc;
37 <        dnew->ncomp = n;
37 >        dnew->ncomp = ncomp;
38          setcolor(dnew->cexp, 1.f, 1.f, 1.f);
39          memcpy(dnew->wlpart, WLPART, sizeof(dnew->wlpart));
40  
# Line 57 | Line 57 | rmx_prepare(RMATRIX *rm)
57  
58   /* Call rmx_new() and rmx_prepare() */
59   RMATRIX *
60 < rmx_alloc(int nr, int nc, int n)
60 > rmx_alloc(int nr, int nc, int ncomp)
61   {
62 <        RMATRIX *dnew = rmx_new(nr, nc, n);
62 >        RMATRIX *dnew = rmx_new(nr, nc, ncomp);
63  
64          if (!rmx_prepare(dnew)) {
65                  rmx_free(dnew);
# Line 389 | Line 389 | rmx_load_data(RMATRIX *rm, FILE *fp)
389  
390   /* Load matrix from supported file type */
391   RMATRIX *
392 < rmx_load(const char *inspec, RMPref rmp)
392 > rmx_load(const char *inspec)
393   {
394          FILE            *fp;
395          RMATRIX         *dnew;
# Line 403 | Line 403 | rmx_load(const char *inspec, RMPref rmp)
403                  fp = stdin;
404          else if (inspec[0] == '!')
405                  fp = popen(inspec+1, "r");
406 <        else {                                  /* check suffix */
407 <                const char      *sp = strrchr(inspec, '.');
408 <                if (sp > inspec && !strcasecmp(sp+1, "XML")) {  /* BSDF? */
409 <                        CMATRIX *cm = rmp==RMPnone ? (CMATRIX *)NULL :
410 <                                        rmp==RMPtrans ? cm_loadBTDF(inspec) :
411 <                                        cm_loadBRDF(inspec, rmp==RMPreflB) ;
412 <                        if (!cm)
413 <                                return(NULL);
414 <                        dnew = rmx_from_cmatrix(cm);
415 <                        cm_free(cm);
416 <                        dnew->dtype = DTascii;
417 <                        return(dnew);           /* return here */
418 <                }                               /* else open it ourselves */
406 >        else
407                  fp = fopen(inspec, "r");
420 –        }
408          if (!fp) {
409                  fprintf(stderr, "Cannot open for reading: %s\n", inspec);
410                  return(NULL);
# Line 437 | Line 424 | rmx_load(const char *inspec, RMPref rmp)
424  
425          if (fp != stdin) {                      /* close input stream */
426                  if (inspec[0] == '!')
427 <                        pclose(fp);
427 >                        ok &= pclose(fp)==0;
428                  else
429                          fclose(fp);
430          }
# Line 501 | Line 488 | rmx_write_double(const rmx_dtype *dp, int len, FILE *f
488   #endif
489  
490   static int
491 < rmx_write_ascii(const rmx_dtype *dp, int nc, int len, FILE *fp)
491 > rmx_write_ascii(const rmx_dtype *dp, int ncomp, int len, FILE *fp)
492   {
493          while (len-- > 0) {
494 <                int     k = nc;
494 >                int     k = ncomp;
495                  while (k-- > 0)
496                          fprintf(fp, " %.7e", *dp++);
497                  fputc('\t', fp);
# Line 513 | Line 500 | rmx_write_ascii(const rmx_dtype *dp, int nc, int len,
500   }
501  
502   static int
503 < rmx_write_rgbe(const rmx_dtype *dp, int nc, int len, FILE *fp)
503 > rmx_write_rgbe(const rmx_dtype *dp, int ncomp, int len, FILE *fp)
504   {
505          COLR    *scan;
506          int     j;
507  
508 <        if ((nc != 1) & (nc != 3)) return(0);
508 >        if ((ncomp != 1) & (ncomp != 3)) return(0);
509          scan = (COLR *)tempbuffer(sizeof(COLR)*len);
510          if (!scan) return(0);
511  
512 <        for (j = 0; j < len; j++, dp += nc)
513 <                if (nc == 1)
512 >        for (j = 0; j < len; j++, dp += ncomp)
513 >                if (ncomp == 1)
514                          setcolr(scan[j], dp[0], dp[0], dp[0]);
515                  else
516                          setcolr(scan[j], dp[0], dp[1], dp[2]);
# Line 532 | Line 519 | rmx_write_rgbe(const rmx_dtype *dp, int nc, int len, F
519   }
520  
521   static int
522 < rmx_write_spec(const rmx_dtype *dp, int nc, int len, FILE *fp)
522 > rmx_write_spec(const rmx_dtype *dp, int ncomp, int len, FILE *fp)
523   {
524          COLRV   *scan;
525          COLORV  scol[MAXCOMP];
526          int     j, k;
527  
528 <        if ((nc < 3) | (nc > MAXCOMP)) return(0);
529 <        scan = (COLRV *)tempbuffer((nc+1)*len);
528 >        if ((ncomp < 3) | (ncomp > MAXCOMP)) return(0);
529 >        scan = (COLRV *)tempbuffer((ncomp+1)*len);
530          if (!scan) return(0);
531 <        for (j = 0; j < len; j++, dp += nc) {
532 <                for (k = nc; k--; )
531 >        for (j = 0; j < len; j++, dp += ncomp) {
532 >                for (k = ncomp; k--; )
533                          scol[k] = dp[k];
534 <                scolor2scolr(scan+j*(nc+1), scol, nc);
534 >                scolor2scolr(scan+j*(ncomp+1), scol, ncomp);
535          }
536 <        return(fwritescolrs(scan, nc, len, fp) >= 0);
536 >        return(fwritescolrs(scan, ncomp, len, fp) >= 0);
537   }
538  
539   /* Check if CIE XYZ primaries were specified */
# Line 624 | Line 611 | rmx_write_header(const RMATRIX *rm, int dtype, FILE *f
611  
612   /* Write out matrix data (usually by row) */
613   int
614 < rmx_write_data(const rmx_dtype *dp, int nc, int len, int dtype, FILE *fp)
614 > rmx_write_data(const rmx_dtype *dp, int ncomp, int len, int dtype, FILE *fp)
615   {
616          switch (dtype) {
617   #if DTrmx_native==DTdouble
618          case DTfloat:
619 <                return(rmx_write_float(dp, nc*len, fp));
619 >                return(rmx_write_float(dp, ncomp*len, fp));
620   #else
621          case DTdouble:
622 <                return(rmx_write_double(dp, nc*len, fp));
622 >                return(rmx_write_double(dp, ncomp*len, fp));
623   #endif
624          case DTrmx_native:
625 <                return(putbinary(dp, sizeof(*dp)*nc, len, fp) == len);
625 >                return(putbinary(dp, sizeof(*dp)*ncomp, len, fp) == len);
626          case DTascii:
627 <                return(rmx_write_ascii(dp, nc, len, fp));
627 >                return(rmx_write_ascii(dp, ncomp, len, fp));
628          case DTrgbe:
629          case DTxyze:
630 <                return(rmx_write_rgbe(dp, nc, len, fp));
630 >                return(rmx_write_rgbe(dp, ncomp, len, fp));
631          case DTspec:
632 <                return(rmx_write_spec(dp, nc, len, fp));
632 >                return(rmx_write_spec(dp, ncomp, len, fp));
633          }
634          return(0);
635   }
# Line 758 | Line 745 | rmx_transfer_data(RMATRIX *rdst, RMATRIX *rsrc, int do
745   int
746   rmx_transpose(RMATRIX *rm)
747   {
761 – #define bmbyte(r,c)     bmap[((r)*rm->ncols+(c))>>3]
762 – #define bmbit(r,c)      (1 << ((r)*rm->ncols+(c) & 7))
763 – #define bmop(r,c, op)   (bmbyte(r,c) op bmbit(r,c))
764 – #define bmtest(r,c)     bmop(r,c,&)
765 – #define bmset(r,c)      bmop(r,c,|=)
766 – #define bmtestandset(r,c)       (!bmtest(r,c) && bmset(r,c))
748          uby8            *bmap;
749          rmx_dtype       val[MAXCOMP];
750          RMATRIX         dold;
# Line 780 | Line 761 | rmx_transpose(RMATRIX *rm)
761                  return(1);
762          }
763          if (rm->nrows == rm->ncols) {   /* square matrix case */
764 <             for (i = rm->nrows; i--; )
765 <                for (j = rm->ncols; j--; ) {
785 <                    if (i == j) continue;
764 >             for (i = rm->nrows; --i > 0; )
765 >                for (j = i; j-- > 0; ) {
766                      memcpy(val, rmx_val(rm,i,j),
767                                  sizeof(rmx_dtype)*rm->ncomp);
768                      memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
769                                  sizeof(rmx_dtype)*rm->ncomp);
770 <                    memcpy(rmx_val(rm,j,i), val,
770 >                    memcpy(rmx_lval(rm,j,i), val,
771                                  sizeof(rmx_dtype)*rm->ncomp);
772                  }
773 <                return(1);
773 >            return(1);
774          }
775 <                                        /* clear completion bitmap */
775 > #define bmbyte(r,c)     bmap[((r)*rm->ncols+(c))>>3]
776 > #define bmbit(r,c)      (1 << ((r)*rm->ncols+(c) & 7))
777 > #define bmop(r,c, op)   (bmbyte(r,c) op bmbit(r,c))
778 > #define bmtest(r,c)     bmop(r,c,&)
779 > #define bmset(r,c)      bmop(r,c,|=)
780 >                                        /* loop completion bitmap */
781          bmap = (uby8 *)calloc(((size_t)rm->nrows*rm->ncols+7)>>3, 1);
782          if (!bmap)
783                  return(0);
784          dold = *rm;
785          rm->ncols = dold.nrows; rm->nrows = dold.ncols;
786 <        for (i = rm->nrows; i--; )
786 >        for (i = rm->nrows; i--; )      /* try every starting point */
787              for (j = rm->ncols; j--; ) {
788 <                int     i0, j0, i1 = i, j1 = j;
789 <                if (!bmtestandset(i,j)) continue;
788 >                int     i0, j0;
789 >                int     i1 = i;
790 >                size_t  j1 = j;
791 >                if (bmtest(i, j))
792 >                        continue;       /* traversed loop earlier */
793                  memcpy(val, rmx_val(rm,i,j),
794                          sizeof(rmx_dtype)*rm->ncomp);
795 <                for ( ; ; ) {           /* value transpose loop */
796 <                    const rmx_dtype     *src;
795 >                for ( ; ; ) {           /* new transpose loop */
796 >                    const rmx_dtype     *ds;
797                      i0 = i1; j0 = j1;
798 <                    src = rmx_val(&dold, j0, i0);
799 <                    i1 = (src - dold.mtx)/(dold.ncomp*rm->ncols);
800 <                    j1 = (src - dold.mtx)/dold.ncomp % rm->ncols;
801 <                    if (!bmtestandset(i1,j1)) break;
802 <                    memcpy(rmx_lval(rm,i0,j0), src,
798 >                    ds = rmx_val(&dold, j0, i0);
799 >                    j1 = (ds - dold.mtx)/dold.ncomp;
800 >                    i1 = j1 / rm->ncols;
801 >                    j1 -= (size_t)i1*rm->ncols;
802 >                    bmset(i1, j1);      /* mark as done */
803 >                    if ((i1 == i) & (j1 == j))
804 >                        break;          /* back at start */
805 >                    memcpy(rmx_lval(rm,i0,j0), ds,
806                                  sizeof(rmx_dtype)*rm->ncomp);
807 <                }
817 <                                        /* close the loop */
807 >                }                       /* complete the loop */
808                  memcpy(rmx_lval(rm,i0,j0), val,
809                          sizeof(rmx_dtype)*rm->ncomp);
810              }
# Line 825 | Line 815 | rmx_transpose(RMATRIX *rm)
815   #undef  bmop
816   #undef  bmtest
817   #undef  bmset
828 – #undef  bmtestandset
818   }
819  
820   /* Multiply (concatenate) two matrices and allocate the result */
# Line 1005 | Line 994 | rmx_transform(const RMATRIX *msrc, int n, const double
994          return(dnew);
995   }
996  
1008 – /* Convert a color matrix to newly allocated RMATRIX buffer */
1009 – RMATRIX *
1010 – rmx_from_cmatrix(const CMATRIX *cm)
1011 – {
1012 –        RMATRIX *dnew;
1013 –
1014 –        if (!cm)
1015 –                return(NULL);
1016 –        dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
1017 –        if (!dnew)
1018 –                return(NULL);
1019 –
1020 –        dnew->dtype = sizeof(COLORV)==sizeof(float) ?
1021 –                        DTfloat : DTdouble;
1022 –
1023 –        if (sizeof(COLORV) == sizeof(rmx_dtype)) {
1024 –                memcpy(dnew->mtx, cm->cmem, rmx_array_size(dnew));
1025 –        } else {
1026 –                int     i, j;
1027 –                for (i = dnew->nrows; i--; )
1028 –                    for (j = dnew->ncols; j--; ) {
1029 –                        const COLORV    *cv = cm_lval(cm,i,j);
1030 –                        rmx_dtype       *dp = rmx_lval(dnew,i,j);
1031 –                        dp[0] = cv[0];
1032 –                        dp[1] = cv[1];
1033 –                        dp[2] = cv[2];
1034 –                    }
1035 –        }
1036 –        return(dnew);
1037 – }
1038 –
1039 – /* Convert general matrix to newly allocated CMATRIX buffer */
1040 – CMATRIX *
1041 – cm_from_rmatrix(const RMATRIX *rm)
1042 – {
1043 –        CMATRIX *cnew;
1044 –
1045 –        if (!rm || !rm->mtx | (rm->ncomp == 2) | (rm->ncomp > MAXCOMP))
1046 –                return(NULL);
1047 –        cnew = cm_alloc(rm->nrows, rm->ncols);
1048 –        if (!cnew)
1049 –                return(NULL);
1050 –        if ((sizeof(COLORV) == sizeof(rmx_dtype)) & (rm->ncomp == 3)) {
1051 –                memcpy(cnew->cmem, rm->mtx, rmx_array_size(rm));
1052 –        } else {
1053 –                int     i, j;
1054 –                for (i = cnew->nrows; i--; )
1055 –                    for (j = cnew->ncols; j--; ) {
1056 –                        const rmx_dtype *dp = rmx_val(rm,i,j);
1057 –                        COLORV          *cv = cm_lval(cnew,i,j);
1058 –                        switch (rm->ncomp) {
1059 –                        case 3:
1060 –                            setcolor(cv, dp[0], dp[1], dp[2]);
1061 –                            break;
1062 –                        case 1:
1063 –                            setcolor(cv, dp[0], dp[0], dp[0]);
1064 –                            break;
1065 –                        default:
1066 –                            if (sizeof(COLORV) == sizeof(rmx_dtype)) {
1067 –                                scolor2color(cv, (const COLORV *)dp,
1068 –                                                rm->ncomp, rm->wlpart);
1069 –                            } else {
1070 –                                COLORV  scol[MAXCOMP];
1071 –                                int     k = rm->ncomp;
1072 –                                while (k--) scol[k] = dp[k];
1073 –                                scolor2color(cv, scol, rm->ncomp, rm->wlpart);
1074 –                            }
1075 –                            break;
1076 –                        }
1077 –                    }
1078 –        }
1079 –        return(cnew);
1080 – }

Diff Legend

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