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.96 by greg, Thu Apr 17 23:30:16 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 1008 | Line 995 | rmx_transform(const RMATRIX *msrc, int n, const double
995          return(dnew);
996   }
997  
1011 – /* Convert a color matrix to newly allocated RMATRIX buffer */
1012 – RMATRIX *
1013 – rmx_from_cmatrix(const CMATRIX *cm)
1014 – {
1015 –        RMATRIX *dnew;
1016 –
1017 –        if (!cm)
1018 –                return(NULL);
1019 –        dnew = rmx_alloc(cm->nrows, cm->ncols, 3);
1020 –        if (!dnew)
1021 –                return(NULL);
1022 –
1023 –        dnew->dtype = sizeof(COLORV)==sizeof(float) ?
1024 –                        DTfloat : DTdouble;
1025 –
1026 –        if (sizeof(COLORV) == sizeof(rmx_dtype)) {
1027 –                memcpy(dnew->mtx, cm->cmem, rmx_array_size(dnew));
1028 –        } else {
1029 –                int     i, j;
1030 –                for (i = dnew->nrows; i--; )
1031 –                    for (j = dnew->ncols; j--; ) {
1032 –                        const COLORV    *cv = cm_lval(cm,i,j);
1033 –                        rmx_dtype       *dp = rmx_lval(dnew,i,j);
1034 –                        dp[0] = cv[0];
1035 –                        dp[1] = cv[1];
1036 –                        dp[2] = cv[2];
1037 –                    }
1038 –        }
1039 –        return(dnew);
1040 – }
1041 –
1042 – /* Convert general matrix to newly allocated CMATRIX buffer */
1043 – CMATRIX *
1044 – cm_from_rmatrix(const RMATRIX *rm)
1045 – {
1046 –        CMATRIX *cnew;
1047 –
1048 –        if (!rm || !rm->mtx | (rm->ncomp == 2) | (rm->ncomp > MAXCOMP))
1049 –                return(NULL);
1050 –        cnew = cm_alloc(rm->nrows, rm->ncols);
1051 –        if (!cnew)
1052 –                return(NULL);
1053 –        if ((sizeof(COLORV) == sizeof(rmx_dtype)) & (rm->ncomp == 3)) {
1054 –                memcpy(cnew->cmem, rm->mtx, rmx_array_size(rm));
1055 –        } else {
1056 –                int     i, j;
1057 –                for (i = cnew->nrows; i--; )
1058 –                    for (j = cnew->ncols; j--; ) {
1059 –                        const rmx_dtype *dp = rmx_val(rm,i,j);
1060 –                        COLORV          *cv = cm_lval(cnew,i,j);
1061 –                        switch (rm->ncomp) {
1062 –                        case 3:
1063 –                            setcolor(cv, dp[0], dp[1], dp[2]);
1064 –                            break;
1065 –                        case 1:
1066 –                            setcolor(cv, dp[0], dp[0], dp[0]);
1067 –                            break;
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 = rm->ncomp;
1075 –                                while (k--) scol[k] = dp[k];
1076 –                                scolor2color(cv, scol, rm->ncomp, rm->wlpart);
1077 –                            }
1078 –                            break;
1079 –                        }
1080 –                    }
1081 –        }
1082 –        return(cnew);
1083 – }

Diff Legend

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