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.53 by greg, Sat Mar 5 01:45:21 2022 UTC vs.
Revision 2.58 by greg, Thu May 18 23:55:10 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 206 | 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 */
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,
# Line 214 | Line 215 | rmx_load_double(RMATRIX *rm, FILE *fp)
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
# Line 241 | 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,j);
245 >            double      *dp = rmx_lval(rm,i,0);
246              if (freadscan(scan, rm->ncols, fp) < 0) {
247                  free(scan);
248                  return(0);
# Line 301 | Line 302 | rmx_load(const char *inspec, RMPref rmp)
302                  return(NULL);
303          }
304          dnew->dtype = DTascii;                  /* assumed w/o FORMAT */
304 –        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 338 | Line 338 | rmx_load(const char *inspec, RMPref rmp)
338          case DTxyze:
339                  if (!rmx_load_rgbe(dnew, fp))
340                          goto loaderr;
341 –                                                /* undo exposure? */
342 –                if ((dnew->cexp[0] != 1.f) | (dnew->cexp[1] != 1.f) |
343 –                                (dnew->cexp[2] != 1.f)) {
344 –                        double  cmlt[3];
345 –                        cmlt[0] = 1./dnew->cexp[0];
346 –                        cmlt[1] = 1./dnew->cexp[1];
347 –                        cmlt[2] = 1./dnew->cexp[2];
348 –                        rmx_scale(dnew, cmlt);
349 –                }
350 –                dnew->swapin = 0;
341                  break;
342          default:
343                  goto loaderr;
# Line 362 | 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 436 | Line 436 | rmx_write_rgbe(const RMATRIX *rm, FILE *fp)
436          for (i = 0; i < rm->nrows; i++) {
437              for (j = rm->ncols; j--; ) {
438                  const double    *dp = rmx_lval(rm,i,j);
439 <                setcolr(scan[j], dp[0], dp[1], dp[2]);
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);
# Line 485 | 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 <                CMATRIX *cm;                    /* convert & write */
494 <                if (rm->ncomp != 1)             /* only convert grayscale */
495 <                        return(0);
496 <                if (!(cm = cm_from_rmatrix(rm)))
497 <                        return(0);
498 <                fputformat(cm_fmt_id[dtype], fp);
499 <                fputc('\n', fp);
500 <                ok = cm_write(cm, dtype, fp);
501 <                cm_free(cm);
502 <                return(ok);
503 <        }
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 570 | 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 590 | 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 <                memcpy(rmx_lval(dnew,i,j), rmx_lval(rm,i,j),
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   }

Diff Legend

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