ViewVC Help

View File | Revision Log | Show Annotations | Download File | Root Listing

root/Development/ray/src/rt/RpictSimulManager.cpp

Comparing ray/src/rt/RpictSimulManager.cpp (file contents):
Revision 2.9 by greg, Sun Aug 25 03:13:07 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 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		}
429	<	if (FlushQueue() < 0)           // make sure we got everyone
429	>	if (FlushQueue() < 0)           // compute stragglers
430		return false;
419	–	x = y = 0;
420	–	if (doneMap.Find(&x, &y, false)) {
421	–	sprintf(errmsg, "missed %ld tile pixels, e.g. (%d,%d)",
422	–	(long)doneMap.Width()*doneMap.Height() -
423	–	doneMap.SumTotal(), x, y);
424	–	error(WARNING, errmsg);
425	–	}
431		if ((prCB != NULL) & (barPix == NULL))
432		(*prCB)(100.);
433		return true;
#	Line 447 | Line 452 | RpictSimulManager::RenderTile(COLORV *rp, int ystride,
452		else if (prims)
453		pacc.SetColorSpace(RDTrgb, prims);
454
455	<	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);
455	>	return SetTile(tile) && RenderRect();
456		}
457
458		// Same but store as common-exponent COLR or SCOLR
#	Line 469 | Line 469 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
469		else if (prims)
470		pacc.SetColorSpace(RDTrgbe, prims);
471
472	<	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);
472	>	return SetTile(tile) && RenderRect();
473		}
474
475		// Same but also use 16-bit encoded depth buffer
#	Line 491 | Line 486 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
486		else if (prims)
487		pacc.SetColorSpace(RDTrgbe, prims);
488
489	<	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);
489	>	return SetTile(tile) && RenderRect();
490		}
491
492		// Back to float color with 16-bit depth
#	Line 513 | Line 503 | RpictSimulManager::RenderTile(COLORV *rp, int ystride,
503		else if (prims)
504		pacc.SetColorSpace(RDTrgb, prims);
505
506	<	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);
506	>	return SetTile(tile) && RenderRect();
507		}
508
509		// Allocate a new render bar
#	Line 595 | 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 696 | 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 707 | 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 772 | 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 784 | 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 820 | Line 808 | RpictSimulManager::RenderFrame(const char *pfname, Ren
808		if (RDTdepthT(dt) == RDTdshort)
809		fprtresolu(GetWidth(), GetHeight(), pdfp[1]);
810
811	<	const int       bheight = (psample > 1) ? int(4*psample+.99) : 8;
811	>	const int       bheight = (psample > 1) ? int(8*psample+.99) : 16;
812		const int       vstep = bheight >> (psample > 1);
813
814		NewBar(bheight);                        // render frame if we can
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]);
830	–	Cleanup();
818		return RDTnone;
819		}
820		NewBar();                               // clean up and return
#	Line 1014 | 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 1033 | 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 1043 | 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 1087 | 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 1111 | 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
1115	<	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 1183 | Line 1173 | RpictSimulManager::ResumeFrame(const char *pfname, con
1173		fclose(pdfp[0]); fclose(pdfp[1]);
1174		return RDTnone;
1175		}
1176	<	int     bheight = (psample > 1) ? int(4*psample+.99) : 8;
1176	>	int     bheight = (psample > 1) ? int(8*psample+.99) : 16;
1177		if (bheight > GetHeight()-doneScans)
1178		bheight = GetHeight()-doneScans;
1179		int     vstep =  bheight >> (psample > 1);
#	Line 1193 | 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]);
1196	–	Cleanup();
1186		return RDTnone;
1187		}
1188		NewBar();                               // close up and return success

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines (old)
>	Changed lines (new)