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.3 by greg, Sun Aug 18 17:24:48 2024 UTC vs.
Revision 2.15 by greg, Sat Jan 25 04:57:27 2025 UTC

#	Line 9 | Line 9 | static const char RCSid[] = "$Id$";
9		*  Created by Greg Ward on 07/11/2024.
10		*/
11
12	+	#define DEBUG   1       // XXX temporary!
13	+
14		#include <ctype.h>
15		#include "platform.h"
16		#include "RpictSimulManager.h"
#	Line 103 | 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 196 | Line 202 | RpictSimulManager::SetTile(const int ti[2])
202		bool
203		RpictSimulManager::ComputePixel(int x, int y)
204		{
205	<	static const SCOLOR     scBlack = {0};
205	>	DCHECK(doneMap.OffBitMap(x,y),
206	>	CONSISTENCY, "illegal pixel index in ComputPixel()");
207		int     i;
208		FVECT   rodir[2];
209		double  hpos = (x+pixjitter())/TWidth();
210		double  vpos = (y+pixjitter())/THeight();
211		double  dlim = viewray(rodir[0], rodir[1], &tvw, hpos, vpos);
212		if (dlim < -FTINY) {    // off view?
213	<	pacc.SetPixel(x, y, scBlack);
213	>	pacc.SetPixel(x, y, scblack);
214		doneMap.Set(x, y);
215		return true;
216		}
#	Line 233 | 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() &&
253	<	(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 268 | Line 281 | RpictSimulManager::FillSquare(const int x, const int y
281		float   dist[4];
282		int     i, j;
283		// assumes 4 corners are valid!
284	<	for (i = 4; i--; )
284	>	for (i = 4; i--; ) {
285	>	DCHECK(!doneMap.Check(x+noff[i][0], y+noff[i][1]),
286	>	CONSISTENCY, "inclusion of bad pixel in FillSquare()");
287		pacc.GetPixel(x+noff[i][0], y+noff[i][1], pval[i], &dist[i]);
288	<
288	>	}
289		i = abs(noff[1][0]-noff[0][0]);
290		j = abs(noff[1][1]-noff[0][1]); // i==j for diamond fill
291		const int       slen =  (i > j) ? i : j;
#	Line 328 | Line 343 | RpictSimulManager::FillSquare(const int x, const int y
343
344		// helper function to set up quincunx sampling
345		static void
346	<	SetQuincunx(ABitMap2 *bmp2, int noff[4][2], const int spc, const bool odd)
346	>	SetQuincunx(ABitMap2 *bmp2, int noff[4][2], const int spc, bool odd, int x0, int y)
347		{
348	<	for (int y = 0; y < bmp2->Height(); y += spc>>1)
334	<	for (int x = (odd^(y&1))*(spc>>1); x < bmp2->Width(); x += spc)
335	<	bmp2->Set(x, y);
336	<	// order neighbors CCW
337	<	if (odd) {
348	>	if (odd) {                      // order neighbors CCW
349		noff[0][0] = spc>>1; noff[0][1] = 0;
350		noff[1][0] = 0; noff[1][1] = spc>>1;
351		noff[2][0] = -(spc>>1); noff[2][1] = 0;
#	Line 345 | Line 356 | SetQuincunx(ABitMap2 *bmp2, int noff[4][2], const int
356		noff[2][0] = -(spc>>1); noff[2][1] = -(spc>>1);
357		noff[3][0] = spc>>1; noff[3][1] = -(spc>>1);
358		}
359	+	int     nsteps;                 // non-negative range
360	+	if (x0 < -(spc>>1)) {
361	+	nsteps = (spc-1 - x0 - (spc>>1))/spc;
362	+	x0 += nsteps*spc;
363	+	}
364	+	if (y < 0) {                    // get past y==0
365	+	nsteps = ((spc>>1)-1 - y)/(spc>>1);
366	+	y += nsteps*(spc>>1);
367	+	odd ^= nsteps&1;
368	+	}
369	+	while (y < bmp2->Height()) {
370	+	for (int x = x0 + odd*(spc>>1); x < bmp2->Width(); x += spc)
371	+	bmp2->Set(x, y);
372	+	y += spc>>1;
373	+	odd = !odd;
374	+	}
375		}
376
377		// Render (or finish rendering) current tile
378		bool
379	<	RpictSimulManager::RenderRect()
379	>	RpictSimulManager::RenderRect(const int x0, const int y0)
380		{
381		if (!tvw.type || !Ready()) {
382		error(INTERNAL, "need octree and view for RenderRect()");
#	Line 359 | Line 386 | RpictSimulManager::RenderRect()
386		int             sp2 = ceil(log2((TWidth()>THeight() ? TWidth() : THeight()) - 1.));
387		int             layer = 0;
388		int             x, y;
362	–	// fprintf(stderr, "Rendering %dx%d tile with psample=%d, maxdiff=%.3f ...\n",
363	–	// TWidth(), THeight(), psample, maxdiff);
389		while (sp2 > 0) {
390		ABitMap2        sampMap(TWidth(), THeight());
391		int             noff[4][2];
392		if ((prCB != NULL) & (barPix == NULL))
393		(*prCB)(100.*doneMap.SumTotal()/doneMap.Width()/doneMap.Height());
394	<	SetQuincunx(&sampMap, noff, 1<<sp2, layer&1);
394	>	SetQuincunx(&sampMap, noff, 1<<sp2, layer&1, x0, y0);
395		sampMap -= doneSamples; // avoid resampling pixels
396		// Are we into adaptive sampling realm?
397		if (noff[0][0]*noff[0][0] + noff[0][1]*noff[0][1] < psample*psample) {
#	Line 380 | Line 405 | RpictSimulManager::RenderRect()
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;
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
397	–	// fprintf(stderr, "Sampled %ld pixels at (sp2,layer)=(%d,%d)\n",
398	–	// (long)sampMap.SumTotal(), sp2, layer);
399	–	// fprintf(stderr, "\t%ld pixels (%.3f%%) completed (+%ld in process)\n",
400	–	// (long)doneMap.SumTotal(), 100.*doneMap.SumTotal()/doneMap.Width()/doneMap.Height(),
401	–	// (long)(doneSamples.SumTotal()-doneMap.SumTotal()));
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;
406	–	x = y = 0;
407	–	if (doneMap.Find(&x, &y, false)) {
408	–	sprintf(errmsg, "missed %ld tile pixels, e.g. (%d,%d)",
409	–	(long)doneMap.Width()*doneMap.Height() -
410	–	doneMap.SumTotal(), x, y);
411	–	error(WARNING, errmsg);
412	–	}
431		if ((prCB != NULL) & (barPix == NULL))
432		(*prCB)(100.);
433		return true;
#	Line 433 | Line 451 | RpictSimulManager::RenderTile(COLORV *rp, int ystride,
451		pacc.SetColorSpace(RDTxyz);
452		else if (prims)
453		pacc.SetColorSpace(RDTrgb, prims);
454	<
454	>
455		return SetTile(tile) && RenderRect();
456		}
457
#	Line 471 | Line 489 | RpictSimulManager::RenderTile(COLRV *bp, int ystride,
489		return SetTile(tile) && RenderRect();
490		}
491
492	+	// Back to float color with 16-bit depth
493	+	bool
494	+	RpictSimulManager::RenderTile(COLORV *rp, int ystride, short *dp, const int *tile)
495	+	{
496	+	if (!rp | (GetWidth() <= 0) | (GetHeight() <= 0) | !vw.type)
497	+	return false;
498	+	if (!ystride)                   // contiguous rows?
499	+	ystride = TWidth();
500	+	pacc.Init(rp, ystride, dp);
501	+	if (prims == xyzprims)
502	+	pacc.SetColorSpace(RDTxyz);
503	+	else if (prims)
504	+	pacc.SetColorSpace(RDTrgb, prims);
505	+
506	+	return SetTile(tile) && RenderRect();
507	+	}
508	+
509		// Allocate a new render bar
510		void
511		RpictSimulManager::NewBar(int ht)
#	Line 520 | Line 555 | RpictSimulManager::LowerBar(int v, int ytop)
555		sizeof(COLORV)*NC*TWidth()*(THeight()-v));
556		memmove(barDepth, barDepth + TWidth()*v,
557		sizeof(float)*TWidth()*(THeight()-v));
558	<	if (ytop < THeight()) {                 // mark what we won't do as finished
558	>	if (ytop < THeight())                   // mark what we won't do as finished
559		doneMap.ClearRect(0, 0, TWidth(), THeight()-ytop, true);
525	–	memset(barPix, 0, sizeof(COLORV)*NC*TWidth()*(THeight()-ytop));
526	–	memset(barDepth, 0, sizeof(float)*TWidth()*(THeight()-ytop));
527	–	}
560		return true;
561		}
562
#	Line 547 | Line 579 | RpictSimulManager::RenderBelow(int ytop, const int vst
579		cropview(&ptvw, 0., double(ytop-THeight())/GetHeight(),
580		1., double(ytop)/GetHeight()))
581		ptvw.type = 0;
582	<	// set up spectral sampling
583	<	if (setspectrsamp(CNDX, WLPART) <= 0) {
582	>	// update spectral sampling
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) {
592	>	if (!ptvw.type && directvis && (dblur <= FTINY) & (mblur <= FTINY)) {
593		parr = new COLORV * [THeight()];
594		zarr = new float * [THeight()];
595		for (int n = THeight(); n-- > 0; ) {
#	Line 566 | Line 601 | RpictSimulManager::RenderBelow(int ytop, const int vst
601		}
602		int             lastOut = ytop;         // render down frame
603		while (ytop > 0) {
569	–	// fprintf(stderr, "At y=%d, source drawing %s...\n", ytop, parr ? "ON" : "OFF");
604		if (prCB)
605		(*prCB)(100.*(GetHeight()-ytop)/GetHeight());
606	<	if (!RenderRect())              // render this bar
606	>	if (!RenderRect(0, THeight()-ytop))     // render this bar
607		return false;
608	<	int     nlines = lastOut - ytop + THeight();
608	>	int     nlines = lastOut - ytop + vstep;
609		if (nlines > ytop)
610		nlines = ytop;
611		else if (parr)                  // drawing sources?
#	Line 628 | Line 662 | RpictSimulManager::RenderBelow(int ytop, const int vst
662		return true;
663		}
664
665	<	/*
632	<	* Render and write a frame to the named file
633	<	* Include any header lines set prior to call
634	<	* Picture file must not already exist
635	<	* Write pixels to stdout if !pfname
636	<	* Write depth to a command if dfname[0]=='!'
637	<	*/
665	>	// Open new output picture file (and optional depth file)
666		RenderDataType
667	<	RpictSimulManager::RenderFrame(const char *pfname, RenderDataType dt, const char *dfname)
667	>	RpictSimulManager::NewOutput(FILE *pdfp[2], const char *pfname,
668	>	RenderDataType dt, const char *dfname)
669		{
670	<	int     fd = 1;
642	<	FILE *  pfp = NULL;
643	<	FILE *  dfp = NULL;
644	<
670	>	pdfp[0] = pdfp[1] = NULL;
671		if (!RDTcolorT(dt))
672	<	error(INTERNAL, "botched color output type in RenderFrame()");
672	>	error(INTERNAL, "missing color output type in NewOutput()");
673		if (NCSAMP == 3) {
674		if (RDTcolorT(dt) == RDTscolr)
675		dt = RDTnewCT(dt, prims==xyzprims ? RDTxyze : RDTrgbe);
#	Line 651 | Line 677 | RpictSimulManager::RenderFrame(const char *pfname, Ren
677		dt = RDTnewCT(dt, prims==xyzprims ? RDTxyz : RDTrgb);
678		}
679		if (!RDTdepthT(dt) ^ !dfname)
680	<	error(INTERNAL, "depth output requires file name and type in RenderFrame()");
680	>	error(INTERNAL, "depth output requires file name and type in NewOutput()");
681	>	int     fd = 1;
682		if (pfname) {                           // open picture output file
683		if (pfname[0] == '!') {
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)) {
691		sprintf(errmsg, "cannot open picture file '%s'", pfname);
692		error(SYSTEM, errmsg);
693		}
694	<	return RDTnone;                 // expected in parallel sequence
694	>	return RDTnone;                 // may be expected in sequence run
695		}
696		if (fd == 1)
697	<	pfp = stdout;
698	<	else if (!(pfp = fdopen(fd, "w")))
697	>	pdfp[0] = stdout;
698	>	else if (!(pdfp[0] = fdopen(fd, "w+")))
699		error(SYSTEM, "failure calling fdopen()");
700	<	SET_FILE_BINARY(pfp);                   // write picture header
701	<	if ((pfp != stdout) | (frameNo <= 1)) {
702	<	newheader("RADIANCE", pfp);
703	<	fputs(GetHeader(), pfp);
700	>	SET_FILE_BINARY(pdfp[0]);               // write picture header
701	>	if ((pdfp[0] != stdout) | (frameNo <= 1)) {
702	>	newheader("RADIANCE", pdfp[0]);
703	>	fputs(GetHeadStr(), pdfp[0]);
704		}
705	<	fputs(VIEWSTR, pfp); fprintview(&vw, pfp); fputc('\n', pfp);
705	>	fputs(VIEWSTR, pdfp[0]); fprintview(&vw, pdfp[0]); fputc('\n', pdfp[0]);
706		if (frameNo > 0)
707	<	fprintf(pfp, "FRAME=%d\n", frameNo);
707	>	fprintf(pdfp[0], "FRAME=%d\n", frameNo);
708		double  pasp = viewaspect(&vw) * GetWidth() / GetHeight();
709		if ((0.99 > pasp) | (pasp > 1.01))
710	<	fputaspect(pasp, pfp);
711	<	fputnow(pfp);
710	>	fputaspect(pasp, pdfp[0]);
711	>	fputnow(pdfp[0]);
712		switch (RDTcolorT(dt)) {                // set primaries and picture format
713		case RDTrgbe:
714		if (!prims | (prims == xyzprims)) prims = stdprims;
715	<	fputprims(prims, pfp);
716	<	fputformat(COLRFMT, pfp);
715	>	fputprims(prims, pdfp[0]);
716	>	fputformat(COLRFMT, pdfp[0]);
717		break;
718		case RDTxyze:
719		prims = xyzprims;
720	<	fputformat(CIEFMT, pfp);
720	>	fputformat(CIEFMT, pdfp[0]);
721		break;
722		case RDTscolr:
723		prims = NULL;
724	<	fputwlsplit(WLPART, pfp);
725	<	fputncomp(NCSAMP, pfp);
726	<	fputformat(SPECFMT, pfp);
724	>	fputwlsplit(WLPART, pdfp[0]);
725	>	fputncomp(NCSAMP, pdfp[0]);
726	>	fputformat(SPECFMT, pdfp[0]);
727		break;
728		case RDTrgb:
729		if (!prims | (prims == xyzprims)) prims = stdprims;
730	<	fputprims(prims, pfp);
731	<	fputncomp(3, pfp);
732	<	fputendian(pfp);
733	<	fputformat("float", pfp);
730	>	fputprims(prims, pdfp[0]);
731	>	fputncomp(3, pdfp[0]);
732	>	fputendian(pdfp[0]);
733	>	fputformat("float", pdfp[0]);
734		break;
735		case RDTxyz:
736		prims = xyzprims;
737	<	fputprims(prims, pfp);
738	<	fputncomp(3, pfp);
739	<	fputendian(pfp);
740	<	fputformat("float", pfp);
737	>	fputprims(prims, pdfp[0]);
738	>	fputncomp(3, pdfp[0]);
739	>	fputendian(pdfp[0]);
740	>	fputformat("float", pdfp[0]);
741		break;
742		case RDTscolor:
743		prims = NULL;
744	<	fputwlsplit(WLPART, pfp);
745	<	fputncomp(NCSAMP, pfp);
746	<	fputendian(pfp);
747	<	fputformat("float", pfp);
744	>	fputwlsplit(WLPART, pdfp[0]);
745	>	fputncomp(NCSAMP, pdfp[0]);
746	>	fputendian(pdfp[0]);
747	>	fputformat("float", pdfp[0]);
748		break;
749	<	default:;
749	>	default:;       // pro forma - caught this above
750		}
751	<	fputc('\n', pfp);                       // end picture header
752	<	fprtresolu(GetWidth(), GetHeight(), pfp);
753	<	if (dfname) {
751	>	fputc('\n', pdfp[0]);                   // flush picture header
752	>	if (fflush(pdfp[0]) == EOF) {
753	>	sprintf(errmsg, "cannot write header to picture '%s'", pfname);
754	>	error(SYSTEM, errmsg);
755	>	fclose(pdfp[0]);
756	>	pdfp[0] = NULL;
757	>	return RDTnone;
758	>	}
759	>	if (dfname) {                           // open depth output
760		if (dfname[0] == '!')
761	<	dfp = popen(dfname+1, "w");
761	>	pdfp[1] = popen(dfname+1, "w");
762		else
763	<	dfp = fopen(dfname, "w");
764	<	if (!dfp) {
763	>	pdfp[1] = fopen(dfname, "w+");
764	>	if (!pdfp[1]) {
765		sprintf(errmsg, "cannot open depth output '%s'", dfname);
766		error(SYSTEM, errmsg);
767	+	fclose(pdfp[0]);
768	+	pdfp[0] = NULL;
769		return RDTnone;
770		}
771	<	SET_FILE_BINARY(dfp);
771	>	SET_FILE_BINARY(pdfp[1]);
772		}
773		if (RDTdepthT(dt) == RDTdshort) {       // write header for 16-bit depth?
774	<	newheader("RADIANCE", dfp);
775	<	fputs(GetHeader(), dfp);
776	<	fputs(VIEWSTR, dfp); fprintview(&vw, dfp); fputc('\n', dfp);
777	<	fputs(DEPTHSTR, dfp); fputs(dunit, dfp); fputc('\n', dfp);
778	<	fputformat(DEPTH16FMT, dfp);
779	<	fputc('\n', dfp);               // end-of-info
780	<	fprtresolu(GetWidth(), GetHeight(), dfp);
774	>	newheader("RADIANCE", 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]);
779	>	fputc('\n', pdfp[1]);           // end-of-info
780	>	if (fflush(pdfp[1]) == EOF) {
781	>	sprintf(errmsg, "cannot write header to '%s'", dfname);
782	>	error(SYSTEM, errmsg);
783	>	fclose(pdfp[0]); fclose(pdfp[1]);
784	>	pdfp[0] = pdfp[1] = NULL;
785	>	return RDTnone;
786	>	}
787		}
788	<	const int       bheight = (psample > 1) ? int(2*psample+.99) : 4;
789	<	const int       vstep =  bheight >> (psample > 1);
788	>	return dt;                              // ready to roll
789	>	}
790
791	+	/*
792	+	* Render and write a frame to the named file
793	+	* Include any header lines set prior to call
794	+	* Picture file must not exist
795	+	* Write pixels to stdout if !pfname
796	+	* Write depth to a command if dfname[0]=='!'
797	+	*/
798	+	RenderDataType
799	+	RpictSimulManager::RenderFrame(const char *pfname, RenderDataType dt, const char *dfname)
800	+	{
801	+	FILE    *pdfp[2];
802	+	// prepare output file(s)
803	+	dt = NewOutput(pdfp, pfname, dt, dfname);
804	+	if (dt == RDTnone)
805	+	return RDTnone;
806	+	// add resolution string(s)
807	+	fprtresolu(GetWidth(), GetHeight(), pdfp[0]);
808	+	if (RDTdepthT(dt) == RDTdshort)
809	+	fprtresolu(GetWidth(), GetHeight(), pdfp[1]);
810	+
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, pfp, dt, dfp)) {
816	<	fclose(pfp);
817	<	if (dfp) (dfname[0] == '!') ? pclose(dfp) : fclose(dfp);
754	<	Cleanup();
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]);
818		return RDTnone;
819		}
820		NewBar();                               // clean up and return
821	<	if (pfp != stdout)
822	<	fclose(pfp);
823	<	if (dfp) {
821	>	if (pdfp[0] != stdout)
822	>	fclose(pdfp[0]);
823	>	if (pdfp[1]) {
824		if (dfname[0] == '!') {
825	<	int     status = pclose(dfp);
825	>	int     status = pclose(pdfp[1]);
826		if (status) {
827		sprintf(errmsg, "depth output (%s) error status: %d",
828		dfname, status);
#	Line 767 | Line 830 | RpictSimulManager::RenderFrame(const char *pfname, Ren
830		return RDTnone;
831		}
832		} else
833	<	fclose(dfp);
833	>	fclose(pdfp[1]);
834		}
835		return dt;
836		}
837
838		// passed struct for header line callback
839	<	struct HeaderInfo {
839	>	static struct HeaderInfo {
840		char            fmt[MAXFMTLEN];
841		char            depth_unit[32];
842		int             ncomp;
#	Line 794 | Line 857 | struct HeaderInfo {
857		gotview = false;
858		endianMatch = true;
859		}
860	<	};
860	>	}       hinfo;          // XXX single copy to hold custom primitives
861
862		// helper function checks header line and records req. info.
863		static int
#	Line 836 | Line 899 | head_check(char *s, void *p)
899		return 0;
900		}
901
902	<	// Resume partially finished rendering
840	<	// Picture file must exist
902	>	// Reopen output file(s), leaving pointers at end of (each) header
903		RenderDataType
904	<	RpictSimulManager::ResumeFrame(const char *pfname, const char *dfname)
904	>	RpictSimulManager::ReopenOutput(FILE *pdfp[2], const char *pfname, const char *dfname)
905		{
906	<	if (!pfname || pfname[0] == '!')
845	<	return RDTnone;
906	>	extern const char       HDRSTR[];
907
908	+	if (!pfname || pfname[0] == '!') {
909	+	pdfp[0] = pdfp[1] = NULL;
910	+	return RDTnone;
911	+	}
912		RenderDataType  dt = RDTnone;
913	<	FILE *          dfp = NULL;
914	<	FILE *          pfp = fopen(pfname, "r+");
915	<	if (!pfp) {
913	>	pdfp[1] = NULL;
914	>	pdfp[0] = fopen(pfname, "r+");
915	>	if (!pdfp[0]) {
916		sprintf(errmsg, "cannot reopen output picture '%s'", pfname);
917		error(SYSTEM, errmsg);
918		return RDTnone;
919		}
920	<	SET_FILE_BINARY(pfp);
921	<	HeaderInfo      hinfo;          // read header information & dimensions
922	<	RESOLU          res;
923	<	if (getheader(pfp, head_check, &hinfo) < 0) {
859	<	fclose(pfp);
920	>	SET_FILE_BINARY(pdfp[0]);       // read header information
921	>	if (getheader(pdfp[0], head_check, &hinfo) < 0) {
922	>	fclose(pdfp[0]);
923	>	pdfp[0] = NULL;
924		return RDTnone;
925		}
862	–	if (!fgetsresolu(&res, pfp) || res.rt != PIXSTANDARD) {
863	–	sprintf(errmsg, "missing/bad resolution for '%s'", pfname);
864	–	error(USER, errmsg);
865	–	fclose(pfp);
866	–	return RDTnone;
867	–	}
926		if (!hinfo.gotview) {
927		sprintf(errmsg, "missing view for '%s'", pfname);
928		error(USER, errmsg);
929	<	fclose(pfp);
929	>	fclose(pdfp[0]);
930	>	pdfp[0] = NULL;
931		return RDTnone;
932		}
933		if (hinfo.ncomp < 3) {
934		sprintf(errmsg, "bad # components (%d) in '%s'", hinfo.ncomp, pfname);
935		error(USER, errmsg);
936	<	fclose(pfp);
936	>	fclose(pdfp[0]);
937	>	pdfp[0] = NULL;
938		return RDTnone;
939		}
940	<	int     bytesPer = 0;           // complicated part to set rendering/output space
940	>	// set rendering/output space
941		if (!strcmp(hinfo.fmt, COLRFMT)) {
942	<	prims = hinfo.prims;
942	>	prims = hinfo.prims;    // XXX static array
943		int     n = 8*hinfo.gotprims;
944		while (n--)
945		if (!FABSEQ(hinfo.prims[0][n], stdprims[0][n]))
#	Line 895 | Line 955 | RpictSimulManager::ResumeFrame(const char *pfname, con
955		sprintf(errmsg, "incompatible sample count (%d) in '%s'",
956		hinfo.ncomp, pfname);
957		error(USER, errmsg);
958	<	fclose(pfp);
958	>	fclose(pdfp[0]);
959	>	pdfp[0] = NULL;
960		return RDTnone;
961		}
962	<	NCSAMP = hinfo.ncomp;   // overrides global setting
962	>	NCSAMP = hinfo.ncomp;           // overrides global setting
963		prims = NULL;
964		dt = RDTnewCT(dt, RDTscolr);
904	–	bytesPer = hinfo.ncomp + 1;     // XXX assumes no compression
965		} else if (!strcmp(hinfo.fmt, "float")) {
966		if (!hinfo.endianMatch) {
967		sprintf(errmsg, "incompatible byte ordering in '%s'", pfname);
968		error(USER, errmsg);
969	<	fclose(pfp);
969	>	fclose(pdfp[0]);
970	>	pdfp[0] = NULL;
971		return RDTnone;
972		}
973		if (hinfo.ncomp == 3) {
974	<	prims = hinfo.prims;            // custom primaries?
974	>	prims = hinfo.prims;    // custom primaries?
975		int     n = 8*hinfo.gotprims;
976		while (n--)
977		if (!FABSEQ(hinfo.prims[0][n], stdprims[0][n]))
978		break;
979	<	if (n < 0)                      // standard primaries?
979	>	if (n < 0)              // standard primaries?
980		prims = stdprims;
981		else if (hinfo.gotprims) {      // or check if XYZ
982		for (n = 8; n--; )
#	Line 933 | Line 994 | RpictSimulManager::ResumeFrame(const char *pfname, con
994		prims = NULL;
995		dt = RDTnewCT(dt, RDTscolor);
996		}
936	–	bytesPer = sizeof(float)*hinfo.ncomp;
997		} else {
998		sprintf(errmsg, "unknown format (%s) for '%s'", hinfo.fmt, pfname);
999		error(USER, errmsg);
1000	<	fclose(pfp);
1000	>	fclose(pdfp[0]);
1001	>	pdfp[0] = NULL;
1002		return RDTnone;
1003		}
1004	<	vw.type = 0;                            // set up new (unreferenced) frame
1005	<	frameNo = 0;
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	>
1011	>	if (dfname[0] == '!') {
1012	>	error(USER, "depth data cannot be reloaded from command");
1013	>	fclose(pdfp[0]);
1014	>	pdfp[0] = NULL;
1015	>	return RDTnone;
1016	>	}
1017	>	pdfp[1] = fopen(dfname, "r+");
1018	>	if (!pdfp[1]) {
1019	>	sprintf(errmsg, "cannot reopen depth file '%s'", dfname);
1020	>	error(SYSTEM, errmsg);
1021	>	fclose(pdfp[0]);
1022	>	pdfp[0] = NULL;
1023	>	return RDTnone;
1024	>	}
1025	>	SET_FILE_BINARY(pdfp[1]);
1026	>	int     n, len = strlen(HDRSTR);
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);
1031	>	fclose(pdfp[0]); fclose(pdfp[1]);
1032	>	pdfp[0] = pdfp[1] = NULL;
1033	>	return RDTnone;
1034	>	}
1035	>	for (n = 0; n < len; n++)
1036	>	if (buf[n] != HDRSTR[n])
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
1043	>	if (getheader(pdfp[1], head_check, &dinfo) < 0)
1044	>	sprintf(errmsg, "bad header in encoded depth file '%s'",
1045	>	dfname);
1046	>	else if (strcmp(dinfo.fmt, DEPTH16FMT))
1047	>	sprintf(errmsg, "wrong format (%s) for depth file '%s'",
1048	>	dinfo.fmt, dfname);
1049	>	else if (!SetReferenceDepth(dinfo.depth_unit))
1050	>	sprintf(errmsg, "bad/missing reference depth (%s) in '%s'",
1051	>	dinfo.depth_unit, dfname);
1052	>	else
1053	>	errmsg[0] = '\0';
1054	>
1055	>	if (errmsg[0]) {
1056	>	error(USER, errmsg);
1057	>	fclose(pdfp[1]); fclose(pdfp[0]);
1058	>	pdfp[0] = pdfp[1] = NULL;
1059	>	return RDTnone;
1060	>	}
1061	>	return RDTnewDT(dt, RDTdshort);
1062	>	}
1063	>
1064	>	// Resume partially finished rendering
1065	>	// Picture file must exist
1066	>	RenderDataType
1067	>	RpictSimulManager::ResumeFrame(const char *pfname, const char *dfname)
1068	>	{
1069	>	FILE            *pdfp[2];
1070	>
1071	>	RenderDataType  dt = ReopenOutput(pdfp, pfname, dfname);
1072	>	if (dt == RDTnone)
1073	>	return RDTnone;
1074	>
1075	>	int     bytesPer = 0;           // figure out how far we got...
1076	>	switch (RDTcolorT(dt)) {
1077	>	case RDTrgbe:
1078	>	case RDTxyze:
1079	>	break;
1080	>	case RDTscolr:
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)*NCSAMP;
1089	>	break;
1090	>	default:
1091	>	sprintf(errmsg, "unknown format for '%s'", pfname);
1092	>	error(USER, errmsg);
1093	>	fclose(pdfp[0]);
1094	>	if (pdfp[1]) fclose(pdfp[1]);
1095	>	return RDTnone;
1096	>	}
1097	>	RESOLU  res;
1098	>	if (!fgetsresolu(&res, pdfp[0]) || res.rt != PIXSTANDARD) {
1099	>	sprintf(errmsg, "missing/bad resolution for '%s'", pfname);
1100	>	error(USER, errmsg);
1101	>	fclose(pdfp[0]);
1102	>	if (pdfp[1]) fclose(pdfp[1]);
1103	>	return RDTnone;
1104	>	}
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	<	fclose(pfp);
1110	>	error(CONSISTENCY, "unexpected resolution change in ResumeFrame()");
1111	>	fclose(pdfp[0]);
1112	>	if (pdfp[1]) fclose(pdfp[1]);
1113		return RDTnone;
1114		}
1115	<	long    dataStart = ftell(pfp);         // picture starting point
1115	>	long    dataStart = ftell(pdfp[0]);     // picture starting point
1116		if (dataStart < 0) {
1117		sprintf(errmsg, "cannot seek on '%s'", pfname);
1118		error(SYSTEM, errmsg);
1119	<	fclose(pfp);
1119	>	fclose(pdfp[0]);
1120	>	if (pdfp[1]) fclose(pdfp[1]);
1121		return RDTnone;
1122		}
1123		long    doneScans = 0;
1124		if (bytesPer) {                         // fixed-width records?
1125	<	fseek(pfp, 0, SEEK_END);
1126	<	long    dataEnd = ftell(pfp);
1125	>	fseek(pdfp[0], 0, SEEK_END);
1126	>	long    dataEnd = ftell(pdfp[0]);
1127		doneScans = (dataEnd - dataStart)/(bytesPer*GetWidth());
1128		if (dataEnd-dataStart > bytesPer*GetWidth()*doneScans)
1129	<	fseek(pfp, dataStart + bytesPer*GetWidth()*doneScans, SEEK_SET);
1129	>	fseek(pdfp[0], dataStart + bytesPer*GetWidth()*doneScans, SEEK_SET);
1130		} else {                                // else get compressed scanlines
1131		COLR *  scan = (COLR *)tempbuffer(sizeof(COLR)*GetWidth());
1132	<	while (freadcolrs(scan, GetWidth(), pfp) >= 0)
1132	>	while (freadcolrs(scan, GetWidth(), pdfp[0]) >= 0)
1133		++doneScans;
1134	<	if (!feof(pfp)) {
1134	>	if (!feof(pdfp[0])) {
1135		sprintf(errmsg, "error reading compressed scanline from '%s'", pfname);
1136		error(USER, errmsg);
1137	<	fclose(pfp);
1137	>	fclose(pdfp[0]);
1138	>	if (pdfp[1]) fclose(pdfp[1]);
1139		return RDTnone;
1140		}
1141		}
1142		if (doneScans >= GetHeight()) {         // nothing left to do?
1143		sprintf(errmsg, "output file '%s' is already complete", pfname);
1144		error(WARNING, errmsg);
1145	<	fclose(pfp);
1145	>	fclose(pdfp[0]);
1146	>	if (pdfp[1]) fclose(pdfp[1]);
1147		return dt;
1148		}
1149		if (!doneScans) {
1150		sprintf(errmsg, "restarting empty frame '%s'", pfname);
1151		error(WARNING, errmsg);
1152		}
1153	<	if (dfname) {                           // append depth file, too?
1154	<	if (dfname[0] == '!') {
1155	<	error(USER, "depth data cannot be reloaded from command");
1156	<	fclose(pfp);
1153	>	long    toSkip = 0;
1154	>	switch (RDTdepthT(dt)) {                // append depth file, too?
1155	>	case RDTdfloat:
1156	>	toSkip = sizeof(float)*GetWidth()*doneScans;
1157	>	break;
1158	>	case RDTdshort:
1159	>	if (!fgetsresolu(&res, pdfp[1]) || (res.rt != PIXSTANDARD) |
1160	>	(res.xr != GetWidth()) | (res.yr != GetHeight())) {
1161	>	sprintf(errmsg, "missing/bad resolution for '%s'", dfname);
1162	>	error(USER, errmsg);
1163	>	fclose(pdfp[0]); fclose(pdfp[0]);
1164		return RDTnone;
1165		}
1166	<	dfp = fopen(dfname, "a");
1167	<	if (!dfp) {
1168	<	sprintf(errmsg, "cannot reopen depth file '%s'", dfname);
1169	<	error(SYSTEM, errmsg);
1170	<	fclose(pfp);
1171	<	return RDTnone;
1172	<	}
1173	<	SET_FILE_BINARY(dfp);
1174	<	const long      dflen = ftell(dfp);
1002	<	if (dflen != sizeof(float)*GetWidth()*doneScans) {
1003	<	fclose(dfp);
1004	<	dfp = fopen(dfname, "r+");
1005	<	if (!dfp) return RDTnone;       // WTH?
1006	<	SET_FILE_BINARY(dfp);
1007	<	}
1008	<	if (dflen < sizeof(float)*GetWidth()*doneScans) {
1009	<	HeaderInfo      dinfo;
1010	<	if (getheader(dfp, head_check, &dinfo) < 0)
1011	<	sprintf(errmsg, "bad header in encoded depth file '%s'",
1012	<	dfname);
1013	<	else if (strcmp(dinfo.fmt, DEPTH16FMT))
1014	<	sprintf(errmsg, "wrong format (%s) for depth file '%s'",
1015	<	dinfo.fmt, dfname);
1016	<	else if (!SetReferenceDepth(dinfo.depth_unit))
1017	<	sprintf(errmsg, "bad/missing reference depth (%s) in '%s'",
1018	<	dinfo.depth_unit, dfname);
1019	<	else if (!fscnresolu(hvdim, hvdim+1, dfp) ||
1020	<	(hvdim[0] != GetWidth()) | (hvdim[1] != GetHeight()))
1021	<	sprintf(errmsg, "bad/mismatched resolution in '%s'",
1022	<	dfname);
1023	<	else
1024	<	errmsg[0] = '\0';
1025	<
1026	<	if (errmsg[0]) {
1027	<	error(USER, errmsg);
1028	<	fclose(dfp);
1029	<	fclose(pfp);
1030	<	return RDTnone;
1031	<	}
1032	<	const long      dStart = ftell(dfp);
1033	<	if (dflen-dStart < 2*GetWidth()*doneScans) {
1034	<	sprintf(errmsg, "missing %ld depths in '%s'",
1035	<	(long)GetWidth()*doneScans - (dflen-dStart)/2,
1036	<	dfname);
1037	<	error(WARNING, errmsg);
1038	<	}
1039	<	fseek(dfp, dStart + 2*GetWidth()*doneScans, SEEK_SET);
1040	<	dt = RDTnewDT(dt, RDTdshort);
1041	<	} else {
1042	<	if (dflen > sizeof(float)*GetWidth()*doneScans)
1043	<	fseek(dfp, sizeof(float)*GetWidth()*doneScans, SEEK_SET);
1044	<	dt = RDTnewDT(dt, RDTdfloat);
1045	<	}
1166	>	toSkip = 2L*GetWidth()*doneScans;
1167	>	break;
1168	>	default:;
1169	>	}                                       // fseek() needed for output
1170	>	if (pdfp[1] && fseek(pdfp[1], toSkip, SEEK_CUR) < 0) {
1171	>	sprintf(errmsg, "cannot seek on depth file '%s'", dfname);
1172	>	error(SYSTEM, errmsg);
1173	>	fclose(pdfp[0]); fclose(pdfp[1]);
1174	>	return RDTnone;
1175		}
1176	<	int     bheight = (psample > 1) ? int(2*psample+.99) : 4;
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);
1180		vstep += !vstep;
1181
1182		NewBar(bheight);                        // render remainder if we can
1183	<	if (!RenderBelow(GetHeight()-doneScans, vstep, pfp, dt, dfp)) {
1184	<	fclose(pfp);
1185	<	if (dfp) fclose(dfp);
1057	<	Cleanup();
1183	>	if (!RenderBelow(GetHeight()-doneScans, vstep, pdfp[0], dt, pdfp[1])) {
1184	>	fclose(pdfp[0]);
1185	>	if (pdfp[1]) fclose(pdfp[1]);
1186		return RDTnone;
1187		}
1188		NewBar();                               // close up and return success
1189	<	fclose(pfp);
1190	<	if (dfp) fclose(dfp);
1189	>	fclose(pdfp[0]);
1190	>	if (pdfp[1]) fclose(pdfp[1]);
1191		return dt;
1192		}

Diff Legend

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