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

Comparing ray/src/rt/RcontribSimulManager.cpp (file contents):
Revision 2.3 by greg, Wed Oct 30 01:38:21 2024 UTC vs.
Revision 2.8 by greg, Thu Nov 7 18:07:43 2024 UTC

# Line 24 | Line 24 | extern const char      HDRSTR[];
24   extern const char       BIGEND[];
25   extern const char       FMTSTR[];
26  
27 – int     contrib = 0;                    // computing contributions?
28 –
29 – int     xres = 0;                       // horizontal (scan) size
30 – int     yres = 0;                       // vertical resolution
31 –
27   // new/exclusive, overwrite if exists, or recover data
28   int     RSDOflags[] = {RDSwrite|RDSexcl|RDSextend, RDSwrite|RDSextend,
29                                  RDSread|RDSwrite};
# Line 40 | Line 35 | static const char      ROWZEROSTR[] = "NROWS=00000000000000
35   struct RcontribMod {
36          RcontribOutput *        opl;            // pointer to first output channel
37          char *                  params;         // parameters string
38 <        EPNODE *                binv;           // bin expression
38 >        EPNODE *                binv;           // bin expression (NULL if 1 bin)
39          int                     nbins;          // bin count this modifier
40          int                     coffset;        // column offset in bytes
41          DCOLORV                 cbin[1];        // bin accumulator (extends struct)
# Line 68 | Line 63 | defDataShare(const char *name, RCOutputOp op, size_t s
63   RcontribMod *
64   NewRcMod(const char *prms, const char *binexpr, int ncbins)
65   {
71 –        if (ncbins <= 0) return NULL;
66          if (!prms) prms = "";
67 <        if (!binexpr | (ncbins == 1))
68 <                binexpr = "0";
69 <
67 >        if (!binexpr & (ncbins > 1)) {
68 >                error(USER, "missing bin expression");
69 >                return NULL;
70 >        }
71 >        if (ncbins <= 1) {              // shouldn't have bin expression?
72 >                if (binexpr && strcmp(binexpr, "0"))
73 >                        error(WARNING, "ignoring non-zero expression for single bin");
74 >                prms = "";
75 >                binexpr = NULL;
76 >                ncbins = 1;
77 >        }
78          RcontribMod *   mp = (RcontribMod *)ecalloc(1, sizeof(RcontribMod) +
79                                                  sizeof(DCOLORV)*(NCSAMP*ncbins-1) +
80                                                  strlen(prms)+1);
81  
82          mp->params = strcpy((char *)(mp->cbin + ncbins*NCSAMP), prms);
83 <        mp->binv = eparse(const_cast<char *>(binexpr));
83 >        if (binexpr) {
84 >                mp->binv = eparse(const_cast<char *>(binexpr));
85 >                CHECK(mp->binv->type==NUM, WARNING, "constant bin expression");
86 >        }
87          mp->nbins = ncbins;
88          return mp;
89   }
# Line 88 | Line 93 | void
93   FreeRcMod(void *p)
94   {
95          if (!p) return;
96 <        epfree((*(RcontribMod *)p).binv, true);
96 >        EPNODE *        bep = (*(RcontribMod *)p).binv;
97 >        if (bep) epfree(bep, true);
98          efree(p);
99   }
100  
# Line 135 | Line 141 | RcontribSimulManager::RctCall(RAY *r, void *cd)
141          if (!mp)
142                  return 0;               // not in our modifier list
143  
144 <        worldfunc(RCCONTEXT, r);        // compute bin #
145 <        set_eparams(mp->params);
146 <        double          bval = evalue(mp->binv);
147 <        if (bval <= -.5)
148 <                return 0;       // silently ignore negative bin index
149 <        DCOLORV *       dvp = (*mp)[int(bval + .5)];
144 >        int                     bi = 0; // get bin index
145 >        if (mp->binv) {
146 >                worldfunc(RCCONTEXT, r);
147 >                set_eparams(mp->params);
148 >                double          bval = evalue(mp->binv);
149 >                if (bval <= -.5)
150 >                        return 0;       // silently ignore negative bin index
151 >                bi = int(bval + .5);
152 >        }
153 >        DCOLORV *       dvp = (*mp)[bi];
154          if (!dvp) {
155 <                sprintf(errmsg, "bad bin number for '%s' (%.1f ignored)", mname, bval);
155 >                sprintf(errmsg, "bad bin number for '%s' (%d ignored)", mname, bi);
156                  error(WARNING, errmsg);
157                  return 0;
158          }
159          SCOLOR          contr;
160          raycontrib(contr, r, PRIMARY);          // compute coefficient
161 <        if (contrib)
161 >        if (rcp->HasFlag(RCcontrib))
162                  smultscolor(contr, r->rcol);    // -> value contribution
163          for (int i = 0; i < NCSAMP; i++)
164                  *dvp++ += contr[i];             // accumulate color/spectrum
# Line 178 | Line 188 | bool
188   RcontribSimulManager::AddModifier(const char *modn, const char *outspec,
189                                  const char *prms, const char *binval, int bincnt)
190   {
191 <        if (!modn | !outspec | (bincnt <= 0) || !*modn | !*outspec) {
191 >        if (!modn | !outspec || !*modn | !*outspec) {
192                  error(WARNING, "ignoring bad call to AddModifier()");
193                  return false;
194          }
195          if (!nChan) {                           // initial call?
196 +                if ((xres < 0) | (yres <= 0)) {
197 +                        error(USER, "xres, yres must be set before first modifier");
198 +                        return false;
199 +                }
200                  if (!SetDataFormat(dtyp))
201                          return false;
202                  nChan = NCSAMP;
203          } else if (nChan != NCSAMP) {
204 <                error(INTERNAL, "number of spectral channels must be fixed");
204 >                error(USER, "number of spectral channels must be fixed");
205                  return false;
206          }
207          if (Ready()) {
# Line 210 | Line 224 | RcontribSimulManager::AddModifier(const char *modn, co
224          const int       binndx = hasFormat(outspec, "diouxX");
225          int             bin0 = 0;
226          char            fnbuf[512];
227 <        if (!modndx | (modndx > binndx))
227 >        if (!modndx || (binndx > 0) & (modndx > binndx))
228                  sprintf(fnbuf, outspec, bin0, modn);
229          else
230                  sprintf(fnbuf, outspec, modn, bin0);
# Line 239 | Line 253 | RcontribSimulManager::AddModifier(const char *modn, co
253          mp->opl = op;                   // first (maybe only) output channel
254          if (modndx)                     // remember modifier if part of name
255                  op->omod = lp->key;
256 <        if (binndx > 0) {               // append output image/bin list
256 >        if (binndx) {                   // append output image/bin list
257                  op->rowBytes += dsiz;
258                  op->obin = bin0;
259                  for (bincnt = 1; bincnt < mp->nbins; bincnt++) {
260 <                        if (!modndx | (modndx > binndx))
260 >                        if (!modndx || (binndx > 0) &  (modndx > binndx))
261                                  sprintf(fnbuf, outspec, bin0+bincnt, modn);
262                          else
263                                  sprintf(fnbuf, outspec, modn, bin0+bincnt);
# Line 262 | Line 276 | RcontribSimulManager::AddModifier(const char *modn, co
276                          op->rowBytes += dsiz;
277                  }
278          } else                          // else send all results to this channel
279 <                op->rowBytes += bincnt*dsiz;
279 >                op->rowBytes += mp->nbins*dsiz;
280          return true;
281   }
282  
# Line 289 | Line 303 | RcontribSimulManager::AddModFile(const char *modfn, co
303          return true;
304   }
305  
306 + // call-back to check if modifier has been loaded
307 + static int
308 + checkModExists(const LUENT *lp, void *p)
309 + {
310 +        if (modifier(lp->key) != OVOID)
311 +                return 1;
312 +
313 +        sprintf(errmsg, "tracked modifier '%s' not found in main scene", lp->key);
314 +        error(WARNING, errmsg);
315 +        return 0;
316 + }
317 +
318   // Prepare output channels and return # completed rows
319   int
320   RcontribSimulManager::PrepOutput()
# Line 297 | Line 323 | RcontribSimulManager::PrepOutput()
323                  error(INTERNAL, "PrepOutput() called before octree & modifiers assigned");
324                  return -1;
325          }
326 +        if (!cdsF) {
327 +                error(INTERNAL, "missing RdataShare constructor call (*cdsF)");
328 +                return -1;
329 +        }
330 +        if (lu_doall(&modLUT, checkModExists, NULL) < 0)
331 +                return -1;
332 +
333          int     remWarnings = 20;
334          for (RcontribOutput *op = outList; op; op = op->next) {
335                  if (op->rData) {
# Line 358 | Line 391 | RcontribOutput::NewHeader(const RcontribSimulManager *
391          strcpy(hdr+begData, ROWZEROSTR);
392          rowCountPos = begData+LNROWSTR;
393          begData += sizeof(ROWZEROSTR)-1;
394 <        if (!xres | (rowBytes > esiz)) {
394 >        if (!rcp->xres | (rowBytes > esiz)) {
395                  sprintf(hdr+begData, "NCOLS=%d\n", int(rowBytes/esiz));
396                  begData += strlen(hdr+begData);
397          }
# Line 396 | Line 429 | RcontribOutput::NewHeader(const RcontribSimulManager *
429                          hdr[begData++] = ' ';
430          hdr[begData++] = '\n';          // EOL for data format
431          hdr[begData++] = '\n';          // end of nominal header
432 <        if ((xres > 0) & (rowBytes == esiz)) {  // tack on resolution string?
433 <                sprintf(hdr+begData, PIXSTDFMT, yres, xres);
432 >        if ((rcp->xres > 0) & (rowBytes == esiz)) {     // tack on resolution string?
433 >                sprintf(hdr+begData, PIXSTDFMT, rcp->yres, rcp->xres);
434                  begData += strlen(hdr+begData);
435          }
436          return rData->ReleaseMemory(hdr, RDSwrite);
# Line 451 | Line 484 | RcontribOutput::CheckHeader(const RcontribSimulManager
484          }
485                                                  // check #columns
486          if (((cp = findArgs(hdr, "NCOLS=", begData)) && atoi(cp)*esiz != rowBytes) ||
487 <                        !xres | (rowBytes > esiz)) {
487 >                        !rcp->xres | (rowBytes > esiz)) {
488                  sprintf(errmsg, "expected NCOLS=%d in '%s'",
489                                  int(rowBytes/esiz), GetName());
490                  error(USER, errmsg);
# Line 466 | Line 499 | RcontribOutput::CheckHeader(const RcontribSimulManager
499          rowCountPos = cp - hdr;
500          int     rlast = atoi(cp);
501          begData++;                              // advance past closing EOL
502 <        if ((xres > 0) & (rowBytes == esiz)) {  // check/skip resolution string?
502 >        if ((rcp->xres > 0) & (rowBytes == esiz)) {     // check/skip resolution string?
503                  char    rbuf[64];
504 <                sprintf(rbuf, PIXSTDFMT, yres, xres);
504 >                sprintf(rbuf, PIXSTDFMT, rcp->yres, rcp->xres);
505                  int     rlen = strlen(rbuf);
506                  if (strncmp(rbuf, hdr+begData, rlen)) {
507                          sprintf(errmsg, "bad resolution string in '%s'", GetName());
# Line 766 | Line 799 | RcontribSimulManager::SetThreadCount(int nt)
799                  return 0;
800          }
801          if (nt < 0)
802 <                return nkids;
802 >                return NThreads();
803          if (!nt) nt = GetNCores();
804          int     status = 0;
805          if (nt == 1)
# Line 779 | Line 812 | RcontribSimulManager::SetThreadCount(int nt)
812                  sprintf(errmsg, "non-zero (%d) status from child", status);
813                  error(WARNING, errmsg);
814          }
815 <        return nkids;
815 >        return NThreads();
816   }

Diff Legend

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