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.10 by greg, Sun Aug 25 17:24:48 2024 UTC vs.
Revision 2.14 by greg, Fri Jan 24 19:08:01 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 414 | Line 418 | RpictSimulManager::RenderRect(const int x0, const int
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          }
429 <        if (FlushQueue() < 0)           // make sure we got everyone
429 >        if (FlushQueue() < 0)           // compute stragglers
430                  return false;
424 –        x = y = 0;
425 –        if (doneMap.Find(&x, &y, false)) {
426 –                sprintf(errmsg, "missed %.4f%% of pixels in rectangle\n",
427 –                                100. - 100.*doneMap.SumTotal() /
428 –                                        doneMap.Width() / doneMap.Height());
429 –                error(WARNING, errmsg);
430 –        }
431          if ((prCB != NULL) & (barPix == NULL))
432                  (*prCB)(100.);
433          return true;
# Line 580 | Line 580 | RpictSimulManager::RenderBelow(int ytop, const int vst
580                                                  1., double(ytop)/GetHeight()))
581                  ptvw.type = 0;
582                                                  // update spectral sampling
583 <        if (setspectrsamp(CNDX, WLPART) <= 0) {
583 >        int     rv = setspectrsamp(CNDX, WLPART);
584 >        if (rv < 0) {
585                  error(USER, "unsupported spectral sampling");
586                  return false;
587          }
588 +        if (!rv & (RDTcolorT(dt) != RDTscolor) & (RDTcolorT(dt) != RDTscolr))
589 +                error(WARNING, "spectral range incompatible with color output");
590          COLORV **       parr = NULL;            // set up tiny source drawing
591          float **        zarr = NULL;
592          if (!ptvw.type && directvis && dblur <= FTINY) {
# Line 681 | Line 684 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
684                          error(INTERNAL, "writing picture to a command not supported");
685                          return RDTnone;
686                  }
687 <                fd = open(pfname, O_WRONLY|O_CREAT|O_EXCL, 0666);
687 >                fd = open(pfname, O_RDWR|O_CREAT|O_EXCL, 0666);
688          }
689          if (fd < 0) {
690                  if ((frameNo <= 0) | (errno != EEXIST)) {
# Line 692 | Line 695 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
695          }
696          if (fd == 1)
697                  pdfp[0] = stdout;
698 <        else if (!(pdfp[0] = fdopen(fd, "w")))
698 >        else if (!(pdfp[0] = fdopen(fd, "w+")))
699                  error(SYSTEM, "failure calling fdopen()");
700          SET_FILE_BINARY(pdfp[0]);               // write picture header
701          if ((pdfp[0] != stdout) | (frameNo <= 1)) {
702                  newheader("RADIANCE", pdfp[0]);
703 <                fputs(GetHeader(), pdfp[0]);
703 >                fputs(GetHeadStr(), pdfp[0]);
704          }
705          fputs(VIEWSTR, pdfp[0]); fprintview(&vw, pdfp[0]); fputc('\n', pdfp[0]);
706          if (frameNo > 0)
# Line 757 | Line 760 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
760                  if (dfname[0] == '!')
761                          pdfp[1] = popen(dfname+1, "w");
762                  else
763 <                        pdfp[1] = fopen(dfname, "w");
763 >                        pdfp[1] = fopen(dfname, "w+");
764                  if (!pdfp[1]) {
765                          sprintf(errmsg, "cannot open depth output '%s'", dfname);
766                          error(SYSTEM, errmsg);
# Line 769 | Line 772 | RpictSimulManager::NewOutput(FILE *pdfp[2], const char
772          }
773          if (RDTdepthT(dt) == RDTdshort) {       // write header for 16-bit depth?
774                  newheader("RADIANCE", pdfp[1]);
775 <                fputs(GetHeader(), pdfp[1]);
775 >                fputs(GetHeadStr(), pdfp[1]);
776                  fputs(VIEWSTR, pdfp[1]); fprintview(&vw, pdfp[1]); fputc('\n', pdfp[1]);
777                  fputs(DEPTHSTR, pdfp[1]); fputs(dunit, pdfp[1]); fputc('\n', pdfp[1]);
778                  fputformat(DEPTH16FMT, pdfp[1]);
# Line 812 | Line 815 | RpictSimulManager::RenderFrame(const char *pfname, Ren
815          if (!RenderBelow(GetHeight(), vstep, pdfp[0], dt, pdfp[1])) {
816                  fclose(pdfp[0]);
817                  if (pdfp[1]) (dfname[0] == '!') ? pclose(pdfp[1]) : fclose(pdfp[1]);
815 –                Cleanup();
818                  return RDTnone;
819          }
820          NewBar();                               // clean up and return
# Line 999 | Line 1001 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1001                  pdfp[0] = NULL;
1002                  return RDTnone;
1003          }
1004 +        if (hinfo.gotview) {                    // header view overrides
1005 +                pvw = vw;
1006 +                vw = hinfo.vw;
1007 +        }
1008          if (!dfname)                            // no depth file?
1009                  return dt;
1010  
# Line 1018 | Line 1024 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1024          }
1025          SET_FILE_BINARY(pdfp[1]);
1026          int     n, len = strlen(HDRSTR);
1027 <        char    buf[32];                // sniff for 16-bit header
1027 >        char    buf[32];                        // sniff for 16-bit header
1028          if (getbinary(buf, 1, len+1, pdfp[1]) < len+1) {
1029                  sprintf(errmsg, "empty depth file '%s'", dfname);
1030                  error(SYSTEM, errmsg);
# Line 1028 | Line 1034 | RpictSimulManager::ReopenOutput(FILE *pdfp[2], const c
1034          }
1035          for (n = 0; n < len; n++)
1036                  if (buf[n] != HDRSTR[n])
1037 <                        break;          // not a Radiance header
1037 >                        break;                  // not a Radiance header
1038          rewind(pdfp[1]);
1039          if ((n < len) | !isprint(buf[len]))
1040                  return RDTnewDT(dt, RDTdfloat);
1041  
1042 <        HeaderInfo      dinfo;          // thinking it's 16-bit encoded
1042 >        HeaderInfo      dinfo;                  // thinking it's 16-bit encoded
1043          if (getheader(pdfp[1], head_check, &dinfo) < 0)
1044                  sprintf(errmsg, "bad header in encoded depth file '%s'",
1045                                  dfname);
# Line 1072 | Line 1078 | RpictSimulManager::ResumeFrame(const char *pfname, con
1078          case RDTxyze:
1079                  break;
1080          case RDTscolr:
1081 <                bytesPer = hinfo.ncomp + 1;     // XXX assumes no compression
1081 >                bytesPer = NCSAMP + 1;  // XXX assumes no compression
1082                  break;
1083          case RDTrgb:
1084          case RDTxyz:
1085                  bytesPer = sizeof(float)*3;
1086                  break;
1087          case RDTscolor:
1088 <                bytesPer = sizeof(float)*hinfo.ncomp;
1088 >                bytesPer = sizeof(float)*NCSAMP;
1089                  break;
1090          default:
1091 <                sprintf(errmsg, "unknown format (%s) for '%s'", hinfo.fmt, pfname);
1091 >                sprintf(errmsg, "unknown format for '%s'", pfname);
1092                  error(USER, errmsg);
1093                  fclose(pdfp[0]);
1094                  if (pdfp[1]) fclose(pdfp[1]);
# Line 1096 | Line 1102 | RpictSimulManager::ResumeFrame(const char *pfname, con
1102                  if (pdfp[1]) fclose(pdfp[1]);
1103                  return RDTnone;
1104          }
1105 <        vw.type = 0;                            // set up new (unreferenced) frame
1100 <        frameNo = 0;
1105 >        frameNo = 0;                            // set up unreferenced frame
1106          int     hvdim[2] = {res.xr, res.yr};
1107          double  noAdj = 0;
1108 <        if (!NewFrame(hinfo.vw, hvdim, &noAdj) ||
1108 >        if (!NewFrame(vw, hvdim, &noAdj) ||
1109                          (hvdim[0] != res.xr) | (hvdim[1] != res.yr)) {
1110                  error(CONSISTENCY, "unexpected resolution change in ResumeFrame()");
1111                  fclose(pdfp[0]);
# Line 1178 | Line 1183 | RpictSimulManager::ResumeFrame(const char *pfname, con
1183          if (!RenderBelow(GetHeight()-doneScans, vstep, pdfp[0], dt, pdfp[1])) {
1184                  fclose(pdfp[0]);
1185                  if (pdfp[1]) fclose(pdfp[1]);
1181 –                Cleanup();
1186                  return RDTnone;
1187          }
1188          NewBar();                               // close up and return success

Diff Legend

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