ViewVC Help

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

root/Development/ray/src/common/depthcodec.c

Comparing ray/src/common/depthcodec.c (file contents):
Revision 2.1 by greg, Fri Jul 26 16:18:06 2019 UTC vs.
Revision 2.6 by greg, Fri Jan 10 01:02:14 2020 UTC

#	Line 8 | Line 8 | static const char RCSid[] = "$Id$";
8		#include "copyright.h"
9
10		#include <stdlib.h>
11	–	#include <string.h>
11		#include <math.h>
12		#include <ctype.h>
13		#include "rtio.h"
#	Line 16 | Line 15 | static const char RCSid[] = "$Id$";
15		#include "depthcodec.h"
16
17
18	<	#if 0                   /* defined as macro in depthcodec.h */
18	>	#ifndef depth2code
19		/* Encode depth as 16-bit signed integer */
20		int
21		depth2code(double d, double dref)
#	Line 25 | Line 24 | depth2code(double d, double dref)
24		return -32768;
25
26		if (d > dref)
27	<	return (int)(32768 - 32768*dref/d) - 1;
27	>	return (int)(32768.001 - 32768.*dref/d) - 1;
28
29	<	return (int)(32767*d/dref - 32768);
29	>	return (int)(32767.*d/dref - 32768.);
30		}
31		#endif
32
33
34	+	#ifndef code2depth
35		/* Decode depth from 16-bit signed integer */
36		double
37		code2depth(int c, double dref)
#	Line 41 | Line 41 | code2depth(int c, double dref)
41
42		if (c >= 32767)
43		return FHUGE;
44	<
45	<	if (c < 0)
46	<	return dref*(32767.5 + c)*(1./32767.);
47	<
48	<	return dref*32768./(32766.5 - c);
44	>
45	>	if (c >= 0)
46	>	return dref*32768./(32766.5 - c);
47	>
48	>	return dref*(32767.5 + c)*(1./32767.);
49		}
50	+	#endif
51
52
53		/* Set codec defaults */
#	Line 70 | Line 71 | static int
71		headline(char *s, void *p)
72		{
73		DEPTHCODEC      *dcp = (DEPTHCODEC *)p;
74	+	int             rv;
75
76		if (formatval(dcp->inpfmt, s))  /* don't pass format */
77		return 0;
78	+
79	+	if ((rv = isbigendian(s)) >= 0) {
80	+	dcp->swapped = (nativebigendian() != rv);
81	+	return 0;
82	+	}
83		/* check for reference depth */
84		if (!strncmp(s, DEPTHSTR, LDEPTHSTR)) {
85		char    *cp;
#	Line 83 | Line 90 | headline(char *s, void *p)
90		*cp = '\0';
91		dcp->refdepth = atof(dcp->depth_unit);
92		if (dcp->refdepth <= .0) {
93	<	fputs(dcp->inpname, stderr);
94	<	fputs(": bad reference depth in input header\n", stderr);
93	>	if (dcp->hdrflags & HF_STDERR) {
94	>	fputs(dcp->inpname, stderr);
95	>	fputs(": bad reference depth in input header\n",
96	>	stderr);
97	>	}
98		return -1;
99		}
100	<	} else if (isview(s))           /* get view params */
100	>	} else if (!strncmp(s, "SAMP360=", 8))
101	>	dcp->gotview--;
102	>	else if (isview(s))             /* get view params */
103		dcp->gotview += (sscanview(&dcp->vw, s) > 0);
104		if (dcp->hdrflags & HF_HEADOUT)
105		fputs(s, stdout);       /* copy to standard output */
#	Line 101 | Line 113 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
113		{
114		if (dcp->hdrflags & HF_HEADIN &&
115		getheader(dcp->finp, headline, dcp) < 0) {
116	<	fputs(dcp->inpname, stderr);
117	<	fputs(": bad header\n", stderr);
118	<	return 1;
116	>	if (dcp->hdrflags & HF_STDERR) {
117	>	fputs(dcp->inpname, stderr);
118	>	fputs(": bad header\n", stderr);
119	>	}
120	>	return 0;
121		}
122	+	dcp->gotview *= (dcp->gotview > 0);
123		if (dcp->hdrflags & HF_HEADOUT) {       /* finish header */
124		if (!(dcp->hdrflags & HF_HEADIN))
125		newheader("RADIANCE", stdout);
#	Line 121 | Line 136 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
136		fputformat("ascii", stdout);
137		break;
138		case 'f':
139	+	fputendian(stdout);
140		fputformat("float", stdout);
141		break;
142		case 'd':
143	+	fputendian(stdout);
144		fputformat("double", stdout);
145		break;
146		}
#	Line 131 | Line 148 | process_dc_header(DEPTHCODEC *dcp, int ac, char *av[])
148		}
149		/* get/put resolution string */
150		if (dcp->hdrflags & HF_RESIN && !fgetsresolu(&dcp->res, dcp->finp)) {
151	<	fputs(dcp->inpname, stderr);
152	<	fputs(": bad resolution string\n", stderr);
153	<	return 1;
151	>	if (dcp->hdrflags & HF_STDERR) {
152	>	fputs(dcp->inpname, stderr);
153	>	fputs(": bad resolution string\n", stderr);
154	>	}
155	>	return 0;
156		}
157		if (dcp->hdrflags & HF_RESOUT)
158		fputsresolu(&dcp->res, stdout);
#	Line 148 | Line 167 | int
167		check_decode_depths(DEPTHCODEC *dcp)
168		{
169		if (dcp->hdrflags & HF_ENCODE) {
170	<	fputs(progname, stderr);
171	<	fputs(": wrong header mode for decode\n", stderr);
170	>	if (dcp->hdrflags & HF_STDERR) {
171	>	fputs(progname, stderr);
172	>	fputs(": wrong header mode for decode\n", stderr);
173	>	}
174		return 0;
175		}
176		if (dcp->inpfmt[0] && strcmp(dcp->inpfmt, DEPTH16FMT)) {
177	<	fputs(dcp->inpname, stderr);
178	<	fputs(": unexpected input format: ", stderr);
179	<	fputs(dcp->inpfmt, stderr);
180	<	fputc('\n', stderr);
177	>	if (dcp->hdrflags & HF_STDERR) {
178	>	fputs(dcp->inpname, stderr);
179	>	fputs(": unexpected input format: ", stderr);
180	>	fputs(dcp->inpfmt, stderr);
181	>	fputc('\n', stderr);
182	>	}
183		return 0;
184		}
185		return 1;
#	Line 172 | Line 195 | check_decode_worldpos(DEPTHCODEC *dcp)
195		if (!check_decode_depths(dcp))
196		return 0;
197		if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
198	<	fputs(progname, stderr);
199	<	fputs(": missing map resolution\n", stderr);
198	>	if (dcp->hdrflags & HF_STDERR) {
199	>	fputs(progname, stderr);
200	>	fputs(": missing map resolution\n", stderr);
201	>	}
202		return 0;
203		}
204		if (!dcp->gotview) {
205	<	fputs(dcp->inpname, stderr);
206	<	fputs(": missing view\n", stderr);
205	>	if (dcp->hdrflags & HF_STDERR) {
206	>	fputs(dcp->inpname, stderr);
207	>	fputs(": missing view\n", stderr);
208	>	}
209		return 0;
210		}
211		if ((err = setview(&dcp->vw)) != NULL) {
212	<	fputs(dcp->inpname, stderr);
213	<	fputs(": input view error: ", stderr);
214	<	fputs(err, stderr);
215	<	fputc('\n', stderr);
212	>	if (dcp->hdrflags & HF_STDERR) {
213	>	fputs(dcp->inpname, stderr);
214	>	fputs(": input view error: ", stderr);
215	>	fputs(err, stderr);
216	>	fputc('\n', stderr);
217	>	}
218		return 0;
219		}
220		return 1;
#	Line 196 | Line 225 | check_decode_worldpos(DEPTHCODEC *dcp)
225		double
226		decode_depth_next(DEPTHCODEC *dcp)
227		{
228	<	int     c = getint(2, dcp->finp);
228	>	int     c;
229
230	+	if (dcp->use_last) {
231	+	dcp->use_last = 0;
232	+	return code2depth(dcp->last_dc, dcp->refdepth);
233	+	}
234	+	c = getint(2, dcp->finp);
235	+
236		if (c == EOF && feof(dcp->finp))
237		return -1.;
238
239	+	dcp->last_dc = c;
240		dcp->curpos += 2;
241
242		return code2depth(c, dcp->refdepth);
#	Line 252 | Line 288 | seek_dc_pix(DEPTHCODEC *dcp, int x, int y)
288		long    seekpos;
289
290		if ((dcp->res.xr <= 0) | (dcp->res.yr <= 0)) {
291	<	fputs(progname, stderr);
292	<	fputs(": need map resolution to seek\n", stderr);
291	>	if (dcp->hdrflags & HF_STDERR) {
292	>	fputs(progname, stderr);
293	>	fputs(": need map resolution to seek\n", stderr);
294	>	}
295		return -1;
296		}
297		if ((x < 0) | (y < 0) ||
298		(x >= scanlen(&dcp->res)) | (y >= numscans(&dcp->res))) {
299	<	fputs(dcp->inpname, stderr);
300	<	fputs(": warning - pixel index off map\n", stderr);
299	>	if (dcp->hdrflags & HF_STDERR) {
300	>	fputs(dcp->inpname, stderr);
301	>	fputs(": warning - pixel index off map\n", stderr);
302	>	}
303		return 0;
304		}
305		seekpos = dcp->dstart + 2*((long)y*scanlen(&dcp->res) + x);
306
307	+	if (seekpos == dcp->curpos-2) {
308	+	dcp->use_last++;        /* avoids seek/read */
309	+	return 1;
310	+	}
311		if (seekpos != dcp->curpos &&
312		fseek(dcp->finp, seekpos, SEEK_SET) == EOF) {
313	<	fputs(dcp->inpname, stderr);
314	<	fputs(": seek error\n", stderr);
313	>	if (dcp->hdrflags & HF_STDERR) {
314	>	fputs(dcp->inpname, stderr);
315	>	fputs(": seek error\n", stderr);
316	>	}
317		return -1;
318		}
319		dcp->curpos = seekpos;

Diff Legend

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