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.90 by greg, Fri Apr 4 22:47:56 2025 UTC vs.
Revision 2.99 by greg, Tue Apr 22 04:45:25 2025 UTC

# 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 758 | Line 745 | rmx_transfer_data(RMATRIX *rdst, RMATRIX *rsrc, int do
745   int
746   rmx_transpose(RMATRIX *rm)
747   {
748 <        RMATRIX dnew;
749 <        int     i, j;
748 >        uby8            *bmap;
749 >        rmx_dtype       val[MAXCOMP];
750 >        RMATRIX         dold;
751 >        int             i, j;
752  
753          if (!rm || !rm->mtx | (rm->ncomp > MAXCOMP))
754                  return(0);
# Line 772 | Line 761 | rmx_transpose(RMATRIX *rm)
761                  return(1);
762          }
763          if (rm->nrows == rm->ncols) {   /* square matrix case */
764 <                rmx_dtype       val[MAXCOMP];
765 <                for (j = rm->ncols; j--; )
766 <                    for (i = rm->nrows; i--; ) {
767 <                        if (i == j) continue;
779 <                        memcpy(val, rmx_val(rm,i,j),
764 >             for (i = rm->nrows; i--; )
765 >                for (j = rm->ncols; j--; ) {
766 >                    if (i == j) continue;
767 >                    memcpy(val, rmx_val(rm,i,j),
768                                  sizeof(rmx_dtype)*rm->ncomp);
769 <                        memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
769 >                    memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
770                                  sizeof(rmx_dtype)*rm->ncomp);
771 <                        memcpy(rmx_val(rm,j,i), val,
771 >                    memcpy(rmx_val(rm,j,i), val,
772                                  sizeof(rmx_dtype)*rm->ncomp);
773 <                    }
773 >                }
774                  return(1);
775          }
776 <        memset(&dnew, 0, sizeof(dnew));
777 <        dnew.ncols = rm->nrows; dnew.nrows = rm->ncols;
778 <        dnew.ncomp = rm->ncomp;
779 <        if (!rmx_prepare(&dnew))
776 > #define bmbyte(r,c)     bmap[((r)*rm->ncols+(c))>>3]
777 > #define bmbit(r,c)      (1 << ((r)*rm->ncols+(c) & 7))
778 > #define bmop(r,c, op)   (bmbyte(r,c) op bmbit(r,c))
779 > #define bmtest(r,c)     bmop(r,c,&)
780 > #define bmset(r,c)      bmop(r,c,|=)
781 >                                        /* loop completion bitmap */
782 >        bmap = (uby8 *)calloc(((size_t)rm->nrows*rm->ncols+7)>>3, 1);
783 >        if (!bmap)
784                  return(0);
785 <        rmx_addinfo(&dnew, rm->info);
786 <        dnew.dtype = rm->dtype;
787 <        copycolor(dnew.cexp, rm->cexp);
788 <        memcpy(dnew.wlpart, rm->wlpart, sizeof(dnew.wlpart));
789 <        for (j = dnew.ncols; j--; )
790 <            for (i = dnew.nrows; i--; )
791 <                memcpy(rmx_lval(&dnew,i,j), rmx_val(rm,j,i),
792 <                                sizeof(rmx_dtype)*dnew.ncomp);
793 <                                        /* and reassign result */
794 <        return(rmx_transfer_data(rm, &dnew, 1));
785 >        dold = *rm;
786 >        rm->ncols = dold.nrows; rm->nrows = dold.ncols;
787 >        for (i = rm->nrows; i--; )      /* try every starting point */
788 >            for (j = rm->ncols; j--; ) {
789 >                int     i0, j0;
790 >                int     i1 = i;
791 >                size_t  j1 = j;
792 >                if (bmtest(i, j))
793 >                        continue;       /* traversed loop earlier */
794 >                memcpy(val, rmx_val(rm,i,j),
795 >                        sizeof(rmx_dtype)*rm->ncomp);
796 >                for ( ; ; ) {           /* new transpose loop */
797 >                    const rmx_dtype     *ds;
798 >                    i0 = i1; j0 = j1;
799 >                    ds = rmx_val(&dold, j0, i0);
800 >                    j1 = (ds - dold.mtx)/dold.ncomp;
801 >                    i1 = j1 / rm->ncols;
802 >                    j1 -= (size_t)i1*rm->ncols;
803 >                    bmset(i1, j1);      /* mark as done */
804 >                    if ((i1 == i) & (j1 == j))
805 >                        break;          /* back at start */
806 >                    memcpy(rmx_lval(rm,i0,j0), ds,
807 >                                sizeof(rmx_dtype)*rm->ncomp);
808 >                }                       /* complete the loop */
809 >                memcpy(rmx_lval(rm,i0,j0), val,
810 >                        sizeof(rmx_dtype)*rm->ncomp);
811 >            }
812 >        free(bmap);                     /* all done! */
813 >        return(1);
814 > #undef  bmbyte
815 > #undef  bmbit
816 > #undef  bmop
817 > #undef  bmtest
818 > #undef  bmset
819   }
820  
821   /* Multiply (concatenate) two matrices and allocate the result */
# Line 979 | Line 995 | rmx_transform(const RMATRIX *msrc, int n, const double
995          return(dnew);
996   }
997  
982 – /* Convert a color matrix to newly allocated RMATRIX buffer */
983 – RMATRIX *
984 – rmx_from_cmatrix(const CMATRIX *cm)
985 – {
986 –        RMATRIX *dnew;
987 –
988 –        if (!cm)
989 –                return(NULL);
990 –        dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
991 –        if (!dnew)
992 –                return(NULL);
993 –
994 –        dnew->dtype = sizeof(COLORV)==sizeof(float) ?
995 –                        DTfloat : DTdouble;
996 –
997 –        if (sizeof(COLORV) == sizeof(rmx_dtype)) {
998 –                memcpy(dnew->mtx, cm->cmem, rmx_array_size(dnew));
999 –        } else {
1000 –                int     i, j;
1001 –                for (i = dnew->nrows; i--; )
1002 –                    for (j = dnew->ncols; j--; ) {
1003 –                        const COLORV    *cv = cm_lval(cm,i,j);
1004 –                        rmx_dtype       *dp = rmx_lval(dnew,i,j);
1005 –                        dp[0] = cv[0];
1006 –                        dp[1] = cv[1];
1007 –                        dp[2] = cv[2];
1008 –                    }
1009 –        }
1010 –        return(dnew);
1011 – }
1012 –
1013 – /* Convert general matrix to newly allocated CMATRIX buffer */
1014 – CMATRIX *
1015 – cm_from_rmatrix(const RMATRIX *rm)
1016 – {
1017 –        CMATRIX *cnew;
1018 –
1019 –        if (!rm || !rm->mtx | (rm->ncomp == 2) | (rm->ncomp > MAXCOMP))
1020 –                return(NULL);
1021 –        cnew = cm_alloc(rm->nrows, rm->ncols);
1022 –        if (!cnew)
1023 –                return(NULL);
1024 –        if ((sizeof(COLORV) == sizeof(rmx_dtype)) & (rm->ncomp == 3)) {
1025 –                memcpy(cnew->cmem, rm->mtx, rmx_array_size(rm));
1026 –        } else {
1027 –                int     i, j;
1028 –                for (i = cnew->nrows; i--; )
1029 –                    for (j = cnew->ncols; j--; ) {
1030 –                        const rmx_dtype *dp = rmx_val(rm,i,j);
1031 –                        COLORV          *cv = cm_lval(cnew,i,j);
1032 –                        switch (rm->ncomp) {
1033 –                        case 3:
1034 –                            setcolor(cv, dp[0], dp[1], dp[2]);
1035 –                            break;
1036 –                        case 1:
1037 –                            setcolor(cv, dp[0], dp[0], dp[0]);
1038 –                            break;
1039 –                        default: {
1040 –                                COLORV  scol[MAXCOMP];
1041 –                                int     k;
1042 –                                for (k = rm->ncomp; k--; )
1043 –                                        scol[k] = dp[k];
1044 –                                scolor2color(cv, scol, rm->ncomp, rm->wlpart);
1045 –                            } break;
1046 –                        }
1047 –                    }
1048 –        }
1049 –        return(cnew);
1050 – }

Diff Legend

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