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.94 by greg, Wed Apr 16 22:56:12 2025 UTC

# Line 758 | Line 758 | rmx_transfer_data(RMATRIX *rdst, RMATRIX *rsrc, int do
758   int
759   rmx_transpose(RMATRIX *rm)
760   {
761 <        RMATRIX dnew;
762 <        int     i, j;
761 >        uby8            *bmap;
762 >        rmx_dtype       val[MAXCOMP];
763 >        RMATRIX         dold;
764 >        int             i, j;
765  
766          if (!rm || !rm->mtx | (rm->ncomp > MAXCOMP))
767                  return(0);
# Line 772 | Line 774 | rmx_transpose(RMATRIX *rm)
774                  return(1);
775          }
776          if (rm->nrows == rm->ncols) {   /* square matrix case */
777 <                rmx_dtype       val[MAXCOMP];
778 <                for (j = rm->ncols; j--; )
779 <                    for (i = rm->nrows; i--; ) {
780 <                        if (i == j) continue;
779 <                        memcpy(val, rmx_val(rm,i,j),
777 >             for (i = rm->nrows; i--; )
778 >                for (j = rm->ncols; j--; ) {
779 >                    if (i == j) continue;
780 >                    memcpy(val, rmx_val(rm,i,j),
781                                  sizeof(rmx_dtype)*rm->ncomp);
782 <                        memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
782 >                    memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
783                                  sizeof(rmx_dtype)*rm->ncomp);
784 <                        memcpy(rmx_val(rm,j,i), val,
784 >                    memcpy(rmx_val(rm,j,i), val,
785                                  sizeof(rmx_dtype)*rm->ncomp);
786 <                    }
786 >                }
787                  return(1);
788          }
789 <        memset(&dnew, 0, sizeof(dnew));
790 <        dnew.ncols = rm->nrows; dnew.nrows = rm->ncols;
791 <        dnew.ncomp = rm->ncomp;
792 <        if (!rmx_prepare(&dnew))
789 > #define bmbyte(r,c)     bmap[((r)*rm->ncols+(c))>>3]
790 > #define bmbit(r,c)      (1 << ((r)*rm->ncols+(c) & 7))
791 > #define bmop(r,c, op)   (bmbyte(r,c) op bmbit(r,c))
792 > #define bmtest(r,c)     bmop(r,c,&)
793 > #define bmset(r,c)      bmop(r,c,|=)
794 > #define bmtestandset(r,c)       (!bmtest(r,c) && bmset(r,c))
795 >                                        /* create completion bitmap */
796 >        bmap = (uby8 *)calloc(((size_t)rm->nrows*rm->ncols+7)>>3, 1);
797 >        if (!bmap)
798                  return(0);
799 <        rmx_addinfo(&dnew, rm->info);
800 <        dnew.dtype = rm->dtype;
801 <        copycolor(dnew.cexp, rm->cexp);
802 <        memcpy(dnew.wlpart, rm->wlpart, sizeof(dnew.wlpart));
803 <        for (j = dnew.ncols; j--; )
804 <            for (i = dnew.nrows; i--; )
805 <                memcpy(rmx_lval(&dnew,i,j), rmx_val(rm,j,i),
806 <                                sizeof(rmx_dtype)*dnew.ncomp);
807 <                                        /* and reassign result */
808 <        return(rmx_transfer_data(rm, &dnew, 1));
799 >        dold = *rm;
800 >        rm->ncols = dold.nrows; rm->nrows = dold.ncols;
801 >        for (i = rm->nrows; i--; )
802 >            for (j = rm->ncols; j--; ) {
803 >                int     i0, j0;
804 >                int     i1 = i;
805 >                size_t  j1 = j;
806 >                if (!bmtestandset(i,j)) continue;
807 >                memcpy(val, rmx_val(rm,i,j),
808 >                        sizeof(rmx_dtype)*rm->ncomp);
809 >                for ( ; ; ) {           /* value transpose loop */
810 >                    const rmx_dtype     *ds;
811 >                    i0 = i1; j0 = (int)j1;
812 >                    ds = rmx_val(&dold, j0, i0);
813 >                    j1 = (ds - dold.mtx)/dold.ncomp;
814 >                    i1 = j1 / rm->ncols;
815 >                    j1 -= (size_t)i1*rm->ncols;
816 >                    if (!bmtestandset(i1,j1)) break;
817 >                    memcpy(rmx_lval(rm,i0,j0), ds,
818 >                                sizeof(rmx_dtype)*rm->ncomp);
819 >                }
820 >                                        /* close the loop */
821 >                memcpy(rmx_lval(rm,i0,j0), val,
822 >                        sizeof(rmx_dtype)*rm->ncomp);
823 >            }
824 >        free(bmap);                     /* all done! */
825 >        return(1);
826 > #undef  bmbyte
827 > #undef  bmbit
828 > #undef  bmop
829 > #undef  bmtest
830 > #undef  bmset
831 > #undef  bmtestandset
832   }
833  
834   /* Multiply (concatenate) two matrices and allocate the result */
# Line 1036 | Line 1065 | cm_from_rmatrix(const RMATRIX *rm)
1065                          case 1:
1066                              setcolor(cv, dp[0], dp[0], dp[0]);
1067                              break;
1068 <                        default: {
1068 >                        default:
1069 >                            if (sizeof(COLORV) == sizeof(rmx_dtype)) {
1070 >                                scolor2color(cv, (const COLORV *)dp,
1071 >                                                rm->ncomp, rm->wlpart);
1072 >                            } else {
1073                                  COLORV  scol[MAXCOMP];
1074 <                                int     k;
1075 <                                for (k = rm->ncomp; k--; )
1043 <                                        scol[k] = dp[k];
1074 >                                int     k = rm->ncomp;
1075 >                                while (k--) scol[k] = dp[k];
1076                                  scolor2color(cv, scol, rm->ncomp, rm->wlpart);
1077 <                            } break;
1077 >                            }
1078 >                            break;
1079                          }
1080                      }
1081          }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines