ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/rt/RpictSimulManager.cpp
(Generate patch)

Comparing ray/src/rt/RpictSimulManager.cpp (file contents):
Revision 2.9 by greg, Sun Aug 25 03:13:07 2024 UTC vs.
Revision 2.13 by greg, Fri Jan 10 19:09:12 2025 UTC

# Line 105 | Line 105 | RpictSimulManager::NewFrame(const VIEW &v, int xydim[2
105  
106          if (!xydim) return false;
107          if (!ap) ap = &pasp;
108 <        pvw = vw;                       // save previous view for motion blur
109 <        vw = v;
108 >        if (&v == &vw) {
109 >                pvw.type = 0;
110 >        } else {
111 >                pvw = vw;               // save previous view for motion blur
112 >                vw = v;
113 >        }
114          const char *    verr = setview(&vw);
115          if (verr) {
116                  error(WARNING, verr);
# Line 236 | Line 240 | RpictSimulManager::ComputePixel(int x, int y)
240  
241   // Check if neighbor differences are below pixel sampling threshold
242   bool
243 < RpictSimulManager::BelowSampThresh(int x, int y, const int noff[4][2]) const
243 > RpictSimulManager::BelowSampThresh(const int x, const int y, const int noff[4][2]) const
244   {
245          SCOLOR  pval[4];
246          float   dist[4];
247          int     i, j;
248  
249          for (i = 4; i--; ) {            // get pixels from tile store
250 <                int     px = x + noff[i][0];
251 <                int     py = y + noff[i][1];
250 >                const int       px = x + noff[i][0];
251 >                const int       py = y + noff[i][1];
252                  if (!doneMap.Check(px, py) ||
253                                  !pacc.GetPixel(px, py, pval[i], &dist[i]))
254                          return false;
255          }
256 <        const bool      spectr = (pacc.NC() > 3);
257 <        for (i = 4; --i; )              // do pairwise comparisons
258 <            for (j = i; j--; ) {
259 <                if (pacc.DepthType() &&
256 <                                (dist[i] - dist[j] > maxdiff*dist[j]) |
256 >                                        // do pairwise comparisons
257 >        for (i = (pacc.DepthType() != RDTnone)*4; --i > 0; )
258 >            for (j = i; j--; )
259 >                if ((dist[i] - dist[j] > maxdiff*dist[j]) |
260                                  (dist[j] - dist[i] > maxdiff*dist[i]))
261                          return false;
262 <                if (spectr ? sbigsdiff(pval[i], pval[j], maxdiff) :
263 <                                bigdiff(pval[i], pval[j], maxdiff))
262 >        if (pacc.NC() > 3) {
263 >            for (i = 4; --i; )
264 >                for (j = i; j--; )
265 >                    if (sbigsdiff(pval[i], pval[j], maxdiff))
266                          return false;
267 <            }
268 <        return true;                    // linear interpolation OK
267 >        } else {
268 >            for (i = 4; --i; )
269 >                for (j = i; j--; )
270 >                    if (bigdiff(pval[i], pval[j], maxdiff))
271 >                        return false;
272 >        }
273 >        return true;
274   }
275  
276   // Fill an interior square patch with interpolated values
# Line 391 | Line 401 | RpictSimulManager::RenderRect(const int x0, const int
401                          for (x = y = 0; sampMap.Find(&x, &y); x++)
402                                  if (BelowSampThresh(x, y, noff))
403                                          sampMap.Reset(x, y);
394 – #if 0
395 – XXX Need to fix directions for spreading!!
404                                          // spread sampling to neighbors...
405                          const ABitMap2  origSampMap = sampMap;
406                          for (x = 4; x--; ) {
407                                  ABitMap2        stamp = origSampMap;
408 <                                stamp.Shift(noff[x][0], noff[x][1]);
408 >                                stamp.Shift(noff[x][0] + noff[(x+1)&3][0],
409 >                                                noff[x][1] + noff[(x+1)&3][1]);
410                                  sampMap |= stamp;
411                          }               // ...but don't resample what's done
412                          sampMap -= doneSamples;
404 – #endif
413                                          // interpolate smooth regions
414                          fillMap -= sampMap;
415 +                        fillMap -= doneSamples;
416                          for (x = y = 0; fillMap.Find(&x, &y); x++)
417                                  FillSquare(x, y, noff);
418                          doneSamples |= doneMap;
419                  }                       // compute required ray samples
420                  for (x = y = 0; sampMap.Find(&x, &y); x++)
421 <                        if (!ComputePixel(x, y))
421 >                        if (!ComputePixel(x, y)) {
422 >                                sprintf(errmsg, "ComputePixel(%d,%d) failed", x, y);
423 >                                error(WARNING, errmsg);
424                                  return false;
425 +                        }
426                  doneSamples |= sampMap; // samples now done or at least queued
427                  sp2 -= layer++ & 1;     // next denser sampling
428          }
# Line 418 | Line 430 | XXX Need to fix directions for spreading!!
430                  return false;
431          x = y = 0;
432          if (doneMap.Find(&x, &y, false)) {
433 <                sprintf(errmsg, "missed %ld tile pixels, e.g. (%d,%d)",
434 <                                (long)doneMap.Width()*doneMap.Height() -
435 <                                        doneMap.SumTotal(), x, y);
433 >                sprintf(errmsg, "missed %.4f%% of pixels in rectangle\n",
434 >                                100. - 100.*doneMap.SumTotal() /
435 >                                        doneMap.Width() / doneMap.Height());
436                  error(WARNING, errmsg);
437          }
438          if ((prCB != NULL) & (barPix == NULL))
# Line 447 | Line 459 | RpictSimulManager::RenderTile(COLORV *rp, int ystride,
459          else if (prims)
460                  pacc.SetColorSpace(RDTrgb, prims);
461  
462 <        int     x0=0, y0=0;
451 <        if (tile) {
452 <                x0 = -tile[0]*TWidth();
453 <                y0 = -tile[1]*THeight();
454 <        }
455 <        return SetTile(tile) && RenderRect(x0, y0);
462 >        return SetTile(tile) && RenderRect();
463   }
464  
465   // Same but store as common-exponent COLR or SCOLR
# Line 469 | Line 476 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
476          else if (prims)
477                  pacc.SetColorSpace(RDTrgbe, prims);
478  
479 <        int     x0=0, y0=0;
473 <        if (tile) {
474 <                x0 = -tile[0]*TWidth();
475 <                y0 = -tile[1]*THeight();
476 <        }
477 <        return SetTile(tile) && RenderRect(x0, y0);
479 >        return SetTile(tile) && RenderRect();
480   }
481  
482   // Same but also use 16-bit encoded depth buffer
# Line 491 | Line 493 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
493          else if (prims)
494                  pacc.SetColorSpace(RDTrgbe, prims);
495  
496 <        int     x0=0, y0=0;
495 <        if (tile) {
496 <                x0 = -tile[0]*TWidth();
497 <                y0 = -tile[1]*THeight();
498 <        }
499 <        return SetTile(tile) && RenderRect(x0, y0);
496 >        return SetTile(tile) && RenderRect();
497   }
498  
499   // Back to float color with 16-bit depth
# Line 513 | Line 510 | RpictSimulManager::RenderTile(COLORV *rp, int ystride,
510          else if (prims)
511                  pacc.SetColorSpace(RDTrgb, prims);
512  
513 <        int     x0=0, y0=0;
517 <        if (tile) {
518 <                x0 = -tile[0]*TWidth();
519 <                y0 = -tile[1]*THeight();
520 <        }
521 <        return SetTile(tile) && RenderRect(x0, y0);
513 >        return SetTile(tile) && RenderRect();
514   }
515  
516   // Allocate a new render bar
# Line 595 | Line 587 | RpictSimulManager::RenderBelow(int ytop, const int vst
587                                                  1., double(ytop)/GetHeight()))
588                  ptvw.type = 0;
589                                                  // update spectral sampling
590 <        if (setspectrsamp(CNDX, WLPART) <= 0) {
590 >        int     rv = setspectrsamp(CNDX, WLPART);
591 >        if (rv < 0) {
592                  error(USER, "unsupported spectral sampling");
593                  return false;
594          }
595 +        if (!rv & (RDTcolorT(dt) != RDTscolor) & (RDTcolorT(dt) != RDTscolr))
596 +                error(WARNING, "spectral range incompatible with color output");
597          COLORV **       parr = NULL;            // set up tiny source drawing
598          float **        zarr = NULL;
599          if (!ptvw.type && directvis && dblur <= FTINY) {
# Line 696 | Line 691 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
691                          error(INTERNAL, "writing picture to a command not supported");
692                          return RDTnone;
693                  }
694 <                fd = open(pfname, O_WRONLY|O_CREAT|O_EXCL, 0666);
694 >                fd = open(pfname, O_RDWR|O_CREAT|O_EXCL, 0666);
695          }
696          if (fd < 0) {
697                  if ((frameNo <= 0) | (errno != EEXIST)) {
# Line 707 | Line 702 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
702          }
703          if (fd == 1)
704                  pdfp[0] = stdout;
705 <        else if (!(pdfp[0] = fdopen(fd, "w")))
705 >        else if (!(pdfp[0] = fdopen(fd, "w+")))
706                  error(SYSTEM, "failure calling fdopen()");
707          SET_FILE_BINARY(pdfp[0]);               // write picture header
708          if ((pdfp[0] != stdout) | (frameNo <= 1)) {
709                  newheader("RADIANCE", pdfp[0]);
710 <                fputs(GetHeader(), pdfp[0]);
710 >                fputs(GetHeadStr(), pdfp[0]);
711          }
712          fputs(VIEWSTR, pdfp[0]); fprintview(&vw, pdfp[0]); fputc('\n', pdfp[0]);
713          if (frameNo > 0)
# Line 772 | Line 767 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
767                  if (dfname[0] == '!')
768                          pdfp[1] = popen(dfname+1, "w");
769                  else
770 <                        pdfp[1] = fopen(dfname, "w");
770 >                        pdfp[1] = fopen(dfname, "w+");
771                  if (!pdfp[1]) {
772                          sprintf(errmsg, "cannot open depth output '%s'", dfname);
773                          error(SYSTEM, errmsg);
# Line 784 | Line 779 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
779          }
780          if (RDTdepthT(dt) == RDTdshort) {       // write header for 16-bit depth?
781                  newheader("RADIANCE", pdfp[1]);
782 <                fputs(GetHeader(), pdfp[1]);
782 >                fputs(GetHeadStr(), pdfp[1]);
783                  fputs(VIEWSTR, pdfp[1]); fprintview(&vw, pdfp[1]); fputc('\n', pdfp[1]);
784                  fputs(DEPTHSTR, pdfp[1]); fputs(dunit, pdfp[1]); fputc('\n', pdfp[1]);
785                  fputformat(DEPTH16FMT, pdfp[1]);
# Line 820 | Line 815 | RpictSimulManager::RenderFrame(const char *pfname, Ren
815          if (RDTdepthT(dt) == RDTdshort)
816                  fprtresolu(GetWidth(), GetHeight(), pdfp[1]);
817  
818 <        const int       bheight = (psample > 1) ? int(4*psample+.99) : 8;
818 >        const int       bheight = (psample > 1) ? int(8*psample+.99) : 16;
819          const int       vstep = bheight >> (psample > 1);
820  
821          NewBar(bheight);                        // render frame if we can
822          if (!RenderBelow(GetHeight(), vstep, pdfp[0], dt, pdfp[1])) {
823                  fclose(pdfp[0]);
824                  if (pdfp[1]) (dfname[0] == '!') ? pclose(pdfp[1]) : fclose(pdfp[1]);
830 –                Cleanup();
825                  return RDTnone;
826          }
827          NewBar();                               // clean up and return
# Line 1014 | Line 1008 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1008                  pdfp[0] = NULL;
1009                  return RDTnone;
1010          }
1011 +        if (hinfo.gotview) {                    // header view overrides
1012 +                pvw = vw;
1013 +                vw = hinfo.vw;
1014 +        }
1015          if (!dfname)                            // no depth file?
1016                  return dt;
1017  
# Line 1033 | Line 1031 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1031          }
1032          SET_FILE_BINARY(pdfp[1]);
1033          int     n, len = strlen(HDRSTR);
1034 <        char    buf[32];                // sniff for 16-bit header
1034 >        char    buf[32];                        // sniff for 16-bit header
1035          if (getbinary(buf, 1, len+1, pdfp[1]) < len+1) {
1036                  sprintf(errmsg, "empty depth file '%s'", dfname);
1037                  error(SYSTEM, errmsg);
# Line 1043 | Line 1041 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1041          }
1042          for (n = 0; n < len; n++)
1043                  if (buf[n] != HDRSTR[n])
1044 <                        break;          // not a Radiance header
1044 >                        break;                  // not a Radiance header
1045          rewind(pdfp[1]);
1046          if ((n < len) | !isprint(buf[len]))
1047                  return RDTnewDT(dt, RDTdfloat);
1048  
1049 <        HeaderInfo      dinfo;          // thinking it's 16-bit encoded
1049 >        HeaderInfo      dinfo;                  // thinking it's 16-bit encoded
1050          if (getheader(pdfp[1], head_check, &dinfo) < 0)
1051                  sprintf(errmsg, "bad header in encoded depth file '%s'",
1052                                  dfname);
# Line 1087 | Line 1085 | RpictSimulManager::ResumeFrame(const char *pfname, con
1085          case RDTxyze:
1086                  break;
1087          case RDTscolr:
1088 <                bytesPer = hinfo.ncomp + 1;     // XXX assumes no compression
1088 >                bytesPer = NCSAMP + 1;  // XXX assumes no compression
1089                  break;
1090          case RDTrgb:
1091          case RDTxyz:
1092                  bytesPer = sizeof(float)*3;
1093                  break;
1094          case RDTscolor:
1095 <                bytesPer = sizeof(float)*hinfo.ncomp;
1095 >                bytesPer = sizeof(float)*NCSAMP;
1096                  break;
1097          default:
1098 <                sprintf(errmsg, "unknown format (%s) for '%s'", hinfo.fmt, pfname);
1098 >                sprintf(errmsg, "unknown format for '%s'", pfname);
1099                  error(USER, errmsg);
1100                  fclose(pdfp[0]);
1101                  if (pdfp[1]) fclose(pdfp[1]);
# Line 1111 | Line 1109 | RpictSimulManager::ResumeFrame(const char *pfname, con
1109                  if (pdfp[1]) fclose(pdfp[1]);
1110                  return RDTnone;
1111          }
1112 <        vw.type = 0;                            // set up new (unreferenced) frame
1115 <        frameNo = 0;
1112 >        frameNo = 0;                            // set up unreferenced frame
1113          int     hvdim[2] = {res.xr, res.yr};
1114          double  noAdj = 0;
1115 <        if (!NewFrame(hinfo.vw, hvdim, &noAdj) ||
1115 >        if (!NewFrame(vw, hvdim, &noAdj) ||
1116                          (hvdim[0] != res.xr) | (hvdim[1] != res.yr)) {
1117                  error(CONSISTENCY, "unexpected resolution change in ResumeFrame()");
1118                  fclose(pdfp[0]);
# Line 1183 | Line 1180 | RpictSimulManager::ResumeFrame(const char *pfname, con
1180                  fclose(pdfp[0]); fclose(pdfp[1]);
1181                  return RDTnone;
1182          }
1183 <        int     bheight = (psample > 1) ? int(4*psample+.99) : 8;
1183 >        int     bheight = (psample > 1) ? int(8*psample+.99) : 16;
1184          if (bheight > GetHeight()-doneScans)
1185                  bheight = GetHeight()-doneScans;
1186          int     vstep =  bheight >> (psample > 1);
# Line 1193 | Line 1190 | RpictSimulManager::ResumeFrame(const char *pfname, con
1190          if (!RenderBelow(GetHeight()-doneScans, vstep, pdfp[0], dt, pdfp[1])) {
1191                  fclose(pdfp[0]);
1192                  if (pdfp[1]) fclose(pdfp[1]);
1196 –                Cleanup();
1193                  return RDTnone;
1194          }
1195          NewBar();                               // close up and return success

Diff Legend

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