[ViewVC] Diff of: radiance/ray/src/util/rmatrix.c

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.61 by greg, Mon Nov 27 22:04:45 2023 UTC vs.
Revision 2.81 by greg, Thu Jun 6 16:46:31 2024 UTC

#	Line 18 \| Line 18 \| static const char RCSid[] = "$Id$";
18
19		static const char rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
20
21	–	#define array_size(rm) (sizeof(double)(rm)->nrows(rm)->ncols*(rm)->ncomp)
22	–	#define mapped_size(rm) ((char )(rm)->mtx + array_size(rm) - (char )(rm)->mapped)
23	–
21		/* Initialize a RMATRIX struct but don't allocate array space */
22		RMATRIX *
23		rmx_new(int nr, int nc, int n)
#	Line 31 \| Line 28 \| rmx_new(int nr, int nc, int n)
28		return(NULL);
29
30		dnew = (RMATRIX *)calloc(1, sizeof(RMATRIX));
31	<	if (dnew) {
32	<	dnew->dtype = DTdouble;
33	<	dnew->nrows = nr;
34	<	dnew->ncols = nc;
35	<	dnew->ncomp = n;
36	<	setcolor(dnew->cexp, 1.f, 1.f, 1.f);
37	<	memcpy(dnew->wlpart, WLPART, sizeof(dnew->wlpart));
38	<	}
31	>	if (!dnew)
32	>	return(NULL);
33	>
34	>	dnew->dtype = DTrmx_native;
35	>	dnew->nrows = nr;
36	>	dnew->ncols = nc;
37	>	dnew->ncomp = n;
38	>	setcolor(dnew->cexp, 1.f, 1.f, 1.f);
39	>	memcpy(dnew->wlpart, WLPART, sizeof(dnew->wlpart));
40	>
41		return(dnew);
42		}
43
#	Line 51 \| Line 50 \| *rmx_prepare(RMATRIX rm)**
50		return(1);
51		if ((rm->nrows <= 0) \| (rm->ncols <= 0) \| (rm->ncomp <= 0))
52		return(0);
53	<	rm->mtx = (double *)malloc(array_size(rm));
53	>	rm->mtx = (double *)malloc(rmx_array_size(rm));
54	>	rm->pflags \|= RMF_FREEMEM;
55		return(rm->mtx != NULL);
56		}
57
#	Line 68 \| Line 68 \| rmx_alloc(int nr, int nc, int n)
68		return(dnew);
69		}
70
71	<	/* Free a RMATRIX array */
71	>	/* Clear state by freeing info and matrix data */
72		void
73	<	rmx_free(RMATRIX *rm)
73	>	rmx_reset(RMATRIX *rm)
74		{
75		if (!rm) return;
76	<	if (rm->info)
76	>	if (rm->info) {
77		free(rm->info);
78	+	rm->info = NULL;
79	+	}
80		#ifdef MAP_FILE
81	<	if (rm->mapped)
82	<	munmap(rm->mapped, mapped_size(rm));
83	<	else
81	>	if (rm->mapped) {
82	>	munmap(rm->mapped, rmx_mapped_size(rm));
83	>	rm->mapped = NULL;
84	>	} else
85		#endif
86	+	if (rm->pflags & RMF_FREEMEM) {
87		free(rm->mtx);
88	+	rm->pflags &= ~RMF_FREEMEM;
89	+	}
90	+	rm->mtx = NULL;
91	+	}
92	+
93	+	/* Free an RMATRIX struct and data */
94	+	void
95	+	rmx_free(RMATRIX *rm)
96	+	{
97	+	if (!rm) return;
98	+	rmx_reset(rm);
99		free(rm);
100		}
101
#	Line 141 \| Line 156 \| *get_dminfo(char s, void p)*
156		return(0);
157		}
158		if ((i = isbigendian(s)) >= 0) {
159	<	ip->swapin = (nativebigendian() != i);
159	>	if (nativebigendian() != i)
160	>	ip->pflags \|= RMF_SWAPIN;
161	>	else
162	>	ip->pflags &= ~RMF_SWAPIN;
163		return(0);
164		}
165		if (isexpos(s)) {
#	Line 172 \| Line 190 \| *get_dminfo(char s, void p)*
190		}
191
192		static int
193	<	rmx_load_ascii(RMATRIX rm, FILE fp)
193	>	rmx_load_ascii(double drp, const RMATRIX rm, FILE *fp)
194		{
195	<	int i, j, k;
195	>	int j, k;
196
197	<	if (!rmx_prepare(rm))
198	<	return(0);
199	<	for (i = 0; i < rm->nrows; i++)
200	<	for (j = 0; j < rm->ncols; j++) {
183	<	double *dp = rmx_lval(rm,i,j);
184	<	for (k = 0; k < rm->ncomp; k++)
185	<	if (fscanf(fp, "%lf", &dp[k]) != 1)
186	<	return(0);
187	<	}
197	>	for (j = 0; j < rm->ncols; j++)
198	>	for (k = rm->ncomp; k-- > 0; )
199	>	if (fscanf(fp, "%lf", drp++) != 1)
200	>	return(0);
201		return(1);
202		}
203
204		static int
205	<	rmx_load_float(RMATRIX rm, FILE fp)
205	>	rmx_load_float(double drp, const RMATRIX rm, FILE *fp)
206		{
207	<	int i, j, k;
207	>	int j, k;
208		float val[100];
209
210		if (rm->ncomp > 100) {
211		fputs("Unsupported # components in rmx_load_float()\n", stderr);
212		exit(1);
213		}
214	<	if (!rmx_prepare(rm))
202	<	return(0);
203	<	for (i = 0; i < rm->nrows; i++)
204	<	for (j = 0; j < rm->ncols; j++) {
205	<	double *dp = rmx_lval(rm,i,j);
214	>	for (j = 0; j < rm->ncols; j++) {
215		if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
216	<	return(0);
217	<	if (rm->swapin)
218	<	swap32((char *)val, rm->ncomp);
219	<	for (k = rm->ncomp; k--; )
220	<	dp[k] = val[k];
221	<	}
216	>	return(0);
217	>	if (rm->pflags & RMF_SWAPIN)
218	>	swap32((char *)val, rm->ncomp);
219	>	for (k = 0; k < rm->ncomp; k++)
220	>	*drp++ = val[k];
221	>	}
222		return(1);
223		}
224
225		static int
226	<	rmx_load_double(RMATRIX rm, FILE fp)
226	>	rmx_load_double(double drp, const RMATRIX rm, FILE *fp)
227		{
228	<	int i;
220	<	#ifdef MAP_FILE
221	<	long pos; /* map memory for file > 1MB if possible */
222	<	if (!rm->swapin && array_size(rm) >= 1L<<20 &&
223	<	(pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
224	<	rm->mapped = mmap(NULL, array_size(rm)+pos, PROT_READ\|PROT_WRITE,
225	<	MAP_PRIVATE, fileno(fp), 0);
226	<	if (rm->mapped != MAP_FAILED) {
227	<	rm->mtx = (double *)rm->mapped + pos/sizeof(double);
228	<	return(1);
229	<	} /* else fall back on reading into memory */
230	<	rm->mapped = NULL;
231	<	}
232	<	#endif
233	<	if (!rmx_prepare(rm))
228	>	if (DTrmx_native != DTdouble)
229		return(0);
230	<	for (i = 0; i < rm->nrows; i++) {
231	<	if (getbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp,
232	<	rm->ncols, fp) != rm->ncols)
233	<	return(0);
239	<	if (rm->swapin)
240	<	swap64((char )rmx_lval(rm,i,0), rm->ncolsrm->ncomp);
241	<	}
230	>	if (getbinary(drp, sizeof(drp)rm->ncomp, rm->ncols, fp) != rm->ncols)
231	>	return(0);
232	>	if (rm->pflags & RMF_SWAPIN)
233	>	swap64((char )drp, rm->ncolsrm->ncomp);
234		return(1);
235		}
236
237		static int
238	<	rmx_load_rgbe(RMATRIX rm, FILE fp)
238	>	rmx_load_rgbe(double drp, const RMATRIX rm, FILE *fp)
239		{
240	<	COLOR scan = (COLOR )malloc(sizeof(COLOR)*rm->ncols);
241	<	int i, j;
240	>	COLR *scan;
241	>	COLOR col;
242	>	int j;
243
244	+	if (rm->ncomp != 3)
245	+	return(0);
246	+	scan = (COLR )tempbuffer(sizeof(COLR)rm->ncols);
247		if (!scan)
248		return(0);
249	<	if (!rmx_prepare(rm)) {
254	<	free(scan);
249	>	if (freadcolrs(scan, rm->ncols, fp) < 0)
250		return(0);
251	+	for (j = 0; j < rm->ncols; j++) {
252	+	colr_color(col, scan[j]);
253	+	*drp++ = colval(col,RED);
254	+	*drp++ = colval(col,GRN);
255	+	*drp++ = colval(col,BLU);
256		}
257	–	for (i = 0; i < rm->nrows; i++) {
258	–	double *dp = rmx_lval(rm,i,0);
259	–	if (freadscan(scan, rm->ncols, fp) < 0) {
260	–	free(scan);
261	–	return(0);
262	–	}
263	–	for (j = 0; j < rm->ncols; j++, dp += 3) {
264	–	dp[0] = colval(scan[j],RED);
265	–	dp[1] = colval(scan[j],GRN);
266	–	dp[2] = colval(scan[j],BLU);
267	–	}
268	–	}
269	–	free(scan);
257		return(1);
258		}
259
260		static int
261	<	rmx_load_spec(RMATRIX rm, FILE fp)
261	>	rmx_load_spec(double drp, const RMATRIX rm, FILE *fp)
262		{
263		uby8 *scan;
264		SCOLOR scol;
265	<	int i, j, k;
265	>	int j, k;
266
267	<	if (rm->ncomp < 3)
267	>	if ((rm->ncomp < 3) \| (rm->ncomp > MAXCSAMP))
268		return(0);
269	<	scan = (uby8 )malloc((rm->ncomp+1)rm->ncols);
269	>	scan = (uby8 )tempbuffer((rm->ncomp+1)rm->ncols);
270		if (!scan)
271		return(0);
272	<	if (!rmx_prepare(rm)) {
286	<	free(scan);
272	>	if (freadscolrs(scan, rm->ncomp, rm->ncols, fp) < 0)
273		return(0);
274	+	for (j = 0; j < rm->ncols; j++) {
275	+	scolr2scolor(scol, scan+j*(rm->ncomp+1), rm->ncomp);
276	+	for (k = 0; k < rm->ncomp; k++)
277	+	*drp++ = scol[k];
278		}
279	<	for (i = 0; i < rm->nrows; i++) {
280	<	double *dp = rmx_lval(rm,i,0);
281	<	if (freadscolrs(scan, rm->ncomp, rm->ncols, fp) < 0) {
282	<	free(scan);
279	>	return(1);
280	>	}
281	>
282	>	/* Read matrix header from input stream (cannot be XML) */
283	>	int
284	>	rmx_load_header(RMATRIX rm, FILE fp)
285	>	{
286	>	if (!rm \| !fp)
287		return(0);
288	<	}
289	<	for (j = 0; j < rm->ncols; j++) {
290	<	scolr2scolor(scol, scan+j*(rm->ncomp+1), rm->ncomp);
291	<	for (k = 0; k < rm->ncomp; k++)
292	<	*dp++ = scol[k];
293	<	}
288	>	rmx_reset(rm); /* clear state */
289	>	if (rm->nrows \| rm->ncols \| !rm->dtype) {
290	>	rm->nrows = rm->ncols = 0;
291	>	rm->ncomp = 3;
292	>	setcolor(rm->cexp, 1.f, 1.f, 1.f);
293	>	memcpy(rm->wlpart, WLPART, sizeof(rm->wlpart));
294	>	rm->pflags = 0;
295		}
296	<	free(scan);
296	>	rm->dtype = DTascii; /* assumed w/o FORMAT */
297	>	if (getheader(fp, get_dminfo, rm) < 0) {
298	>	fputs("Unrecognized matrix format\n", stderr);
299	>	return(0);
300	>	}
301	>	if ((rm->dtype == DTrgbe) \| (rm->dtype == DTxyze) &&
302	>	rm->ncomp != 3)
303	>	return(0);
304	>	if (rm->ncols <= 0 && /* resolution string? */
305	>	!fscnresolu(&rm->ncols, &rm->nrows, fp))
306	>	return(0);
307	>	if (rm->dtype == DTascii) /* set file type (WINDOWS) */
308	>	SET_FILE_TEXT(fp);
309	>	else
310	>	SET_FILE_BINARY(fp);
311		return(1);
312		}
313
314	+	/* Load next row as double (cannot be XML) */
315	+	int
316	+	rmx_load_row(double drp, const RMATRIX rm, FILE *fp)
317	+	{
318	+	switch (rm->dtype) {
319	+	case DTascii:
320	+	return(rmx_load_ascii(drp, rm, fp));
321	+	case DTfloat:
322	+	return(rmx_load_float(drp, rm, fp));
323	+	case DTdouble:
324	+	return(rmx_load_double(drp, rm, fp));
325	+	case DTrgbe:
326	+	case DTxyze:
327	+	return(rmx_load_rgbe(drp, rm, fp));
328	+	case DTspec:
329	+	return(rmx_load_spec(drp, rm, fp));
330	+	default:
331	+	fputs("Unsupported data type in rmx_load_row()\n", stderr);
332	+	}
333	+	return(0);
334	+	}
335	+
336	+	/* Allocate & load post-header data from stream given type set in rm->dtype */
337	+	int
338	+	rmx_load_data(RMATRIX rm, FILE fp)
339	+	{
340	+	int i;
341	+	#ifdef MAP_FILE
342	+	long pos; /* map memory for file > 1MB if possible */
343	+	if ((rm->dtype == DTrmx_native) & !(rm->pflags & RMF_SWAPIN) &
344	+	(rmx_array_size(rm) >= 1L<<20) &&
345	+	(pos = ftell(fp)) >= 0 && !(pos % sizeof(double))) {
346	+	rm->mapped = mmap(NULL, rmx_array_size(rm)+pos, PROT_READ\|PROT_WRITE,
347	+	MAP_PRIVATE, fileno(fp), 0);
348	+	if (rm->mapped != MAP_FAILED) {
349	+	if (rm->pflags & RMF_FREEMEM)
350	+	free(rm->mtx);
351	+	rm->mtx = (double *)rm->mapped + pos/sizeof(double);
352	+	rm->pflags &= ~RMF_FREEMEM;
353	+	return(1);
354	+	} /* else fall back on reading into memory */
355	+	rm->mapped = NULL;
356	+	}
357	+	#endif
358	+	if (!rmx_prepare(rm)) { /* need in-core matrix array */
359	+	fprintf(stderr, "Cannot allocate %g MByte matrix array\n",
360	+	(1./(1L<<20))*(double)rmx_array_size(rm));
361	+	return(0);
362	+	}
363	+	for (i = 0; i < rm->nrows; i++)
364	+	if (!rmx_load_row(rmx_lval(rm,i,0), rm, fp))
365	+	return(0);
366	+	return(1);
367	+	}
368	+
369		/* Load matrix from supported file type */
370		RMATRIX *
371		rmx_load(const char *inspec, RMPref rmp)
372		{
373		FILE *fp;
374		RMATRIX *dnew;
375	+	int ok;
376
377		if (!inspec)
378		inspec = stdin_name;
379		else if (!*inspec)
380		return(NULL);
381	<	if (inspec == stdin_name) { /* reading from stdin? */
381	>	if (inspec == stdin_name) /* reading from stdin? */
382		fp = stdin;
383	<	} else if (inspec[0] == '!') {
384	<	if (!(fp = popen(inspec+1, "r")))
385	<	return(NULL);
321	<	} else {
383	>	else if (inspec[0] == '!')
384	>	fp = popen(inspec+1, "r");
385	>	else {
386		const char sp = inspec; / check suffix */
387		while (*sp)
388		++sp;
389		while (sp > inspec && sp[-1] != '.')
390		--sp;
391		if (!strcasecmp(sp, "XML")) { /* assume it's a BSDF */
392	<	CMATRIX *cm = rmp==RMPtrans ? cm_loadBTDF(inspec) :
392	>	CMATRIX cm = rmp==RMPnone ? (CMATRIX )NULL :
393	>	rmp==RMPtrans ? cm_loadBTDF(inspec) :
394		cm_loadBRDF(inspec, rmp==RMPreflB) ;
395		if (!cm)
396		return(NULL);
397		dnew = rmx_from_cmatrix(cm);
398		cm_free(cm);
399		dnew->dtype = DTascii;
400	<	return(dnew);
401	<	}
402	<	/* else open it ourselves */
338	<	if (!(fp = fopen(inspec, "r")))
339	<	return(NULL);
400	>	return(dnew); /* return here */
401	>	} /* else open it ourselves */
402	>	fp = fopen(inspec, "r");
403		}
404	<	SET_FILE_BINARY(fp);
404	>	if (!fp) {
405	>	fprintf(stderr, "Cannot open for reading: %s\n", inspec);
406	>	return(NULL);
407	>	}
408		#ifdef getc_unlocked
409		flockfile(fp);
410		#endif
411	<	if (!(dnew = rmx_new(0,0,3))) {
412	<	fclose(fp);
411	>	SET_FILE_BINARY(fp); /* load header info */
412	>	if (!rmx_load_header(dnew = rmx_new(0,0,3), fp)) {
413	>	fprintf(stderr, "Bad header in: %s\n", inspec);
414	>	if (inspec[0] == '!') pclose(fp);
415	>	else fclose(fp);
416	>	rmx_free(dnew);
417		return(NULL);
418		}
419	<	dnew->dtype = DTascii; /* assumed w/o FORMAT */
420	<	if (getheader(fp, get_dminfo, dnew) < 0) {
421	<	fclose(fp);
352	<	return(NULL);
353	<	}
354	<	if ((dnew->nrows <= 0) \| (dnew->ncols <= 0)) {
355	<	if (!fscnresolu(&dnew->ncols, &dnew->nrows, fp)) {
356	<	fclose(fp);
357	<	return(NULL);
358	<	}
359	<	if ((dnew->dtype == DTrgbe) \| (dnew->dtype == DTxyze) &&
360	<	dnew->ncomp != 3) {
361	<	fclose(fp);
362	<	return(NULL);
363	<	}
364	<	}
365	<	switch (dnew->dtype) {
366	<	case DTascii:
367	<	SET_FILE_TEXT(fp);
368	<	if (!rmx_load_ascii(dnew, fp))
369	<	goto loaderr;
370	<	dnew->dtype = DTascii; /* should leave double? */
371	<	break;
372	<	case DTfloat:
373	<	if (!rmx_load_float(dnew, fp))
374	<	goto loaderr;
375	<	dnew->dtype = DTfloat;
376	<	break;
377	<	case DTdouble:
378	<	if (!rmx_load_double(dnew, fp))
379	<	goto loaderr;
380	<	dnew->dtype = DTdouble;
381	<	break;
382	<	case DTrgbe:
383	<	case DTxyze:
384	<	if (!rmx_load_rgbe(dnew, fp))
385	<	goto loaderr;
386	<	break;
387	<	case DTspec:
388	<	if (!rmx_load_spec(dnew, fp))
389	<	goto loaderr;
390	<	break;
391	<	default:
392	<	goto loaderr;
393	<	}
394	<	if (fp != stdin) {
419	>	ok = rmx_load_data(dnew, fp); /* allocate & load data */
420	>
421	>	if (fp != stdin) { /* close input stream */
422		if (inspec[0] == '!')
423		pclose(fp);
424		else
#	Line 401 \| Line 428 \| *rmx_load(const char inspec, RMPref rmp)**
428		else
429		funlockfile(fp);
430		#endif
431	+	if (!ok) { /* load failure? */
432	+	fprintf(stderr, "Error loading data from: %s\n", inspec);
433	+	rmx_free(dnew);
434	+	return(NULL);
435	+	}
436		/* undo exposure? */
437		if ((dnew->cexp[0] != 1.f) \|
438		(dnew->cexp[1] != 1.f) \| (dnew->cexp[2] != 1.f)) {
439		double cmlt[MAXCSAMP];
440		int i;
441	+	if (dnew->ncomp > MAXCSAMP) {
442	+	fprintf(stderr, "Excess spectral components in: %s\n",
443	+	inspec);
444	+	rmx_free(dnew);
445	+	return(NULL);
446	+	}
447		cmlt[0] = 1./dnew->cexp[0];
448		cmlt[1] = 1./dnew->cexp[1];
449		cmlt[2] = 1./dnew->cexp[2];
412	–	if (dnew->ncomp > MAXCSAMP)
413	–	goto loaderr;
450		for (i = dnew->ncomp; i-- > 3; )
451	<	cmlt[i] = cmlt[1];
451	>	cmlt[i] = cmlt[1]; /* XXX hack! */
452		rmx_scale(dnew, cmlt);
453		setcolor(dnew->cexp, 1.f, 1.f, 1.f);
454		}
455		return(dnew);
420	–	loaderr: /* should report error? */
421	–	if (inspec[0] == '!')
422	–	pclose(fp);
423	–	else
424	–	fclose(fp);
425	–	rmx_free(dnew);
426	–	return(NULL);
456		}
457
458		static int
459	<	rmx_write_ascii(const RMATRIX rm, FILE fp)
459	>	rmx_write_ascii(const double dp, int nc, int len, FILE fp)
460		{
461	<	const char *fmt = (rm->dtype == DTfloat) ? " %.7e" :
462	<	(rm->dtype == DTrgbe) \| (rm->dtype == DTxyze) \|
463	<	(rm->dtype == DTspec) ? " %.3e" : " %.15e" ;
464	<	int i, j, k;
436	<
437	<	for (i = 0; i < rm->nrows; i++) {
438	<	for (j = 0; j < rm->ncols; j++) {
439	<	const double *dp = rmx_lval(rm,i,j);
440	<	for (k = 0; k < rm->ncomp; k++)
441	<	fprintf(fp, fmt, dp[k]);
461	>	while (len-- > 0) {
462	>	int k = nc;
463	>	while (k-- > 0)
464	>	fprintf(fp, " %.7e", *dp++);
465		fputc('\t', fp);
443	–	}
444	–	fputc('\n', fp);
466		}
467	<	return(1);
467	>	return(fputc('\n', fp) != EOF);
468		}
469
470		static int
471	<	rmx_write_float(const RMATRIX rm, FILE fp)
471	>	rmx_write_float(const double dp, int len, FILE fp)
472		{
473	<	int i, j, k;
453	<	float val[100];
473	>	float val;
474
475	<	if (rm->ncomp > 100) {
476	<	fputs("Unsupported # components in rmx_write_float()\n", stderr);
477	<	exit(1);
458	<	}
459	<	for (i = 0; i < rm->nrows; i++)
460	<	for (j = 0; j < rm->ncols; j++) {
461	<	const double *dp = rmx_lval(rm,i,j);
462	<	for (k = rm->ncomp; k--; )
463	<	val[k] = (float)dp[k];
464	<	if (putbinary(val, sizeof(float), rm->ncomp, fp) != rm->ncomp)
475	>	while (len--) {
476	>	val = *dp++;
477	>	if (putbinary(&val, sizeof(float), 1, fp) != 1)
478		return(0);
479	<	}
479	>	}
480		return(1);
481		}
482
483		static int
484	<	rmx_write_double(const RMATRIX rm, FILE fp)
484	>	rmx_write_rgbe(const double dp, int nc, int len, FILE fp)
485		{
486	<	int i;
486	>	COLR *scan;
487	>	int j;
488
489	<	for (i = 0; i < rm->nrows; i++)
490	<	if (putbinary(rmx_lval(rm,i,0), sizeof(double)*rm->ncomp,
491	<	rm->ncols, fp) != rm->ncols)
478	<	return(0);
479	<	return(1);
480	<	}
489	>	if ((nc != 1) & (nc != 3)) return(0);
490	>	scan = (COLR )tempbuffer(sizeof(COLR)len);
491	>	if (!scan) return(0);
492
493	<	static int
494	<	rmx_write_rgbe(const RMATRIX rm, FILE fp)
484	<	{
485	<	COLR scan = (COLR )malloc(sizeof(COLR)*rm->ncols);
486	<	int i, j;
487	<
488	<	if (!scan)
489	<	return(0);
490	<	for (i = 0; i < rm->nrows; i++) {
491	<	for (j = rm->ncols; j--; ) {
492	<	const double *dp = rmx_lval(rm,i,j);
493	<	if (rm->ncomp == 1)
493	>	for (j = 0; j < len; j++, dp += nc)
494	>	if (nc == 1)
495		setcolr(scan[j], dp[0], dp[0], dp[0]);
496		else
497		setcolr(scan[j], dp[0], dp[1], dp[2]);
498	<	}
499	<	if (fwritecolrs(scan, rm->ncols, fp) < 0) {
499	<	free(scan);
500	<	return(0);
501	<	}
502	<	}
503	<	free(scan);
504	<	return(1);
498	>
499	>	return(fwritecolrs(scan, len, fp) >= 0);
500		}
501
502		static int
503	<	rmx_write_spec(const RMATRIX rm, FILE fp)
503	>	rmx_write_spec(const double dp, int nc, int len, FILE fp)
504		{
505	<	uby8 scan = (uby8 )malloc((rm->ncomp+1)*rm->ncols);
511	<	int ok = 1;
505	>	uby8 *scan;
506		SCOLOR scol;
507	<	int i, j, k;
507	>	int j, k;
508
509	<	if (!scan)
510	<	return(0);
511	<	for (i = 0; i < rm->nrows; i++) {
512	<	for (j = rm->ncols; j--; ) {
513	<	const double *dp = rmx_lval(rm,i,j);
520	<	for (k = rm->ncomp; k--; )
509	>	if (nc < 3) return(0);
510	>	scan = (uby8 )tempbuffer((nc+1)len);
511	>	if (!scan) return(0);
512	>	for (j = 0; j < len; j++, dp += nc) {
513	>	for (k = nc; k--; )
514		scol[k] = dp[k];
515	<	scolor2scolr(scan+j*(rm->ncomp+1), scol, rm->ncomp);
523	<	}
524	<	if (fwritescolrs(scan, rm->ncomp, rm->ncols, fp) < 0) {
525	<	ok = 0;
526	<	break;
527	<	}
515	>	scolor2scolr(scan+j*(nc+1), scol, nc);
516		}
517	<	free(scan);
530	<	return(ok);
517	>	return(fwritescolrs(scan, nc, len, fp) >= 0);
518		}
519
520		/* Check if CIE XYZ primaries were specified */
#	Line 547 \| Line 534 \| *findCIEprims(const char info)**
534		(prims[BLU][CIEX] < .01) & (prims[BLU][CIEY] < .01));
535		}
536
537	<	/* Write matrix to file type indicated by dtype */
537	>	/* Finish writing header data with resolution and format, returning type used */
538		int
539	<	rmx_write(const RMATRIX rm, int dtype, FILE fp)
539	>	rmx_write_header(const RMATRIX rm, int dtype, FILE fp)
540		{
541	<	int ok = 1;
555	<
556	<	if (!rm \| !fp \|\| !rm->mtx)
541	>	if (!rm \| !fp \|\| rm->ncols <= 0)
542		return(0);
558	–	#ifdef getc_unlocked
559	–	flockfile(fp);
560	–	#endif
561	–	/* complete header */
543		if (rm->info)
544		fputs(rm->info, fp);
545		if (dtype == DTfromHeader)
#	Line 568 \| Line 549 \| *rmx_write(const RMATRIX rm, int dtype, FILE fp)*
549		dtype = DTxyze;
550		else if ((dtype == DTxyze) & (rm->dtype == DTrgbe))
551		dtype = DTrgbe;
552	+	if ((dtype < DTspec) & (rm->ncomp > 3))
553	+	dtype = DTspec;
554	+	else if ((dtype == DTspec) & (rm->ncomp <= 3))
555	+	return(0);
556	+
557	+	if (dtype == DTascii) /* set file type (WINDOWS) */
558	+	SET_FILE_TEXT(fp);
559	+	else
560	+	SET_FILE_BINARY(fp);
561		/* write exposure? */
562		if (rm->ncomp == 3 && (rm->cexp[RED] != rm->cexp[GRN]) \|
563		(rm->cexp[GRN] != rm->cexp[BLU]))
564		fputcolcor(rm->cexp, fp);
565		else if (rm->cexp[GRN] != 1.f)
566		fputexpos(rm->cexp[GRN], fp);
567	<	if ((dtype != DTrgbe) & (dtype != DTxyze)) {
568	<	if (dtype == DTspec) {
569	<	if (rm->ncomp < 3)
580	<	return(0); /* bad # components */
581	<	fputwlsplit(rm->wlpart, fp);
582	<	} else {
567	>	/* matrix size? */
568	>	if ((dtype > DTspec) \| (rm->nrows <= 0)) {
569	>	if (rm->nrows > 0)
570		fprintf(fp, "NROWS=%d\n", rm->nrows);
571	<	fprintf(fp, "NCOLS=%d\n", rm->ncols);
572	<	}
571	>	fprintf(fp, "NCOLS=%d\n", rm->ncols);
572	>	}
573	>	if (dtype >= DTspec) { /* # components & split? */
574		fputncomp(rm->ncomp, fp);
575	+	if (rm->ncomp > 3 &&
576	+	memcmp(rm->wlpart, WLPART, sizeof(WLPART)))
577	+	fputwlsplit(rm->wlpart, fp);
578		} else if ((rm->ncomp != 3) & (rm->ncomp != 1))
579		return(0); /* wrong # components */
580		if ((dtype == DTfloat) \| (dtype == DTdouble))
581		fputendian(fp); /* important to record */
582		fputformat(cm_fmt_id[dtype], fp);
583	<	fputc('\n', fp);
584	<	switch (dtype) { /* write data */
583	>	fputc('\n', fp); /* end of header */
584	>	if ((dtype <= DTspec) & (rm->nrows > 0))
585	>	fprtresolu(rm->ncols, rm->nrows, fp);
586	>	return(dtype);
587	>	}
588	>
589	>	/* Write out matrix data (usually by row) */
590	>	int
591	>	rmx_write_data(const double dp, int nc, int len, int dtype, FILE fp)
592	>	{
593	>	switch (dtype) {
594		case DTascii:
595	<	ok = rmx_write_ascii(rm, fp);
596	<	break;
595	>	return(rmx_write_ascii(dp, nc, len, fp));
596		case DTfloat:
597	<	ok = rmx_write_float(rm, fp);
598	<	break;
599	<	case DTdouble:
601	<	ok = rmx_write_double(rm, fp);
602	<	break;
597	>	return(rmx_write_float(dp, nc*len, fp));
598	>	case DTrmx_native:
599	>	return(putbinary(dp, sizeof(dp)nc, len, fp) == len);
600		case DTrgbe:
601		case DTxyze:
602	<	fprtresolu(rm->ncols, rm->nrows, fp);
606	<	ok = rmx_write_rgbe(rm, fp);
607	<	break;
602	>	return(rmx_write_rgbe(dp, nc, len, fp));
603		case DTspec:
604	<	fprtresolu(rm->ncols, rm->nrows, fp);
610	<	ok = rmx_write_spec(rm, fp);
611	<	break;
612	<	default:
613	<	return(0);
604	>	return(rmx_write_spec(dp, nc, len, fp));
605		}
606	<	ok &= (fflush(fp) == 0);
606	>	return(0);
607	>	}
608	>
609	>	/* Write matrix using file format indicated by dtype */
610	>	int
611	>	rmx_write(const RMATRIX rm, int dtype, FILE fp)
612	>	{
613	>	int ok = 0;
614	>	int i;
615	>	/* complete header */
616	>	dtype = rmx_write_header(rm, dtype, fp);
617	>	if (dtype <= 0)
618	>	return(0);
619		#ifdef getc_unlocked
620	+	flockfile(fp);
621	+	#endif
622	+	if (dtype == DTrmx_native) /* write all at once? */
623	+	ok = rmx_write_data(rm->mtx, rm->ncomp,
624	+	rm->nrows*rm->ncols, dtype, fp);
625	+	else /* else row by row */
626	+	for (i = 0; i < rm->nrows; i++) {
627	+	ok = rmx_write_data(rmx_val(rm,i,0), rm->ncomp,
628	+	rm->ncols, dtype, fp);
629	+	if (!ok) break;
630	+	}
631	+
632	+	if (ok) ok = (fflush(fp) == 0);
633	+	#ifdef getc_unlocked
634		funlockfile(fp);
635		#endif
636	+	if (!ok) fputs("Error writing matrix\n", stderr);
637		return(ok);
638		}
639
#	Line 628 \| Line 646 \| rmx_identity(const int dim, const int n)
646
647		if (!rid)
648		return(NULL);
649	<	memset(rid->mtx, 0, array_size(rid));
649	>	memset(rid->mtx, 0, rmx_array_size(rid));
650		for (i = dim; i--; ) {
651		double *dp = rmx_lval(rid,i,i);
652		for (k = n; k--; )
#	Line 637 \| Line 655 \| rmx_identity(const int dim, const int n)
655		return(rid);
656		}
657
658	<	/* Duplicate the given matrix */
658	>	/* Duplicate the given matrix (may be unallocated) */
659		RMATRIX *
660		rmx_copy(const RMATRIX *rm)
661		{
#	Line 645 \| Line 663 \| *rmx_copy(const RMATRIX rm)**
663
664		if (!rm)
665		return(NULL);
666	<	dnew = rmx_alloc(rm->nrows, rm->ncols, rm->ncomp);
666	>	dnew = rmx_new(rm->nrows, rm->ncols, rm->ncomp);
667		if (!dnew)
668		return(NULL);
669	+	if (rm->mtx) {
670	+	if (!rmx_prepare(dnew)) {
671	+	rmx_free(dnew);
672	+	return(NULL);
673	+	}
674	+	memcpy(dnew->mtx, rm->mtx, rmx_array_size(dnew));
675	+	}
676		rmx_addinfo(dnew, rm->info);
677		dnew->dtype = rm->dtype;
678		copycolor(dnew->cexp, rm->cexp);
679		memcpy(dnew->wlpart, rm->wlpart, sizeof(dnew->wlpart));
655	–	memcpy(dnew->mtx, rm->mtx, array_size(dnew));
680		return(dnew);
681		}
682
683	+	/* Replace data in first matrix with data from second */
684	+	int
685	+	rmx_transfer_data(RMATRIX rdst, RMATRIX rsrc, int dometa)
686	+	{
687	+	if (!rdst \| !rsrc \|\| (rdst->nrows != rsrc->nrows) \|
688	+	(rdst->ncols != rsrc->ncols) \|
689	+	(rdst->ncomp != rsrc->ncomp))
690	+	return(0);
691	+
692	+	if (dometa) { /* transfer everything? */
693	+	rmx_reset(rdst);
694	+	rdst = rsrc;
695	+	rsrc->info = NULL; rsrc->mapped = NULL; rsrc->mtx = NULL;
696	+	return(1);
697	+	}
698	+	#ifdef MAP_FILE /* just matrix data -- leave metadata */
699	+	if (rdst->mapped)
700	+	munmap(rdst->mapped, rmx_mapped_size(rdst));
701	+	else
702	+	#endif
703	+	if (rdst->pflags & RMF_FREEMEM)
704	+	free(rdst->mtx);
705	+	rdst->mapped = rsrc->mapped;
706	+	rdst->mtx = rsrc->mtx;
707	+	if (rsrc->pflags & RMF_FREEMEM)
708	+	rdst->pflags \|= RMF_FREEMEM;
709	+	else
710	+	rdst->pflags &= ~RMF_FREEMEM;
711	+	rsrc->mapped = NULL; rsrc->mtx = NULL;
712	+	return(1);
713	+	}
714	+
715		/* Allocate and assign transposed matrix */
716		RMATRIX *
717		rmx_transpose(const RMATRIX *rm)
#	Line 663 \| Line 719 \| *rmx_transpose(const RMATRIX rm)**
719		RMATRIX *dnew;
720		int i, j;
721
722	<	if (!rm)
722	>	if (!rm \|\| !rm->mtx)
723		return(0);
724		if ((rm->nrows == 1) \| (rm->ncols == 1)) {
725		dnew = rmx_copy(rm);
#	Line 685 \| Line 741 \| *rmx_transpose(const RMATRIX rm)**
741		memcpy(dnew->wlpart, rm->wlpart, sizeof(dnew->wlpart));
742		for (j = dnew->ncols; j--; )
743		for (i = dnew->nrows; i--; )
744	<	memcpy(rmx_lval(dnew,i,j), rmx_lval(rm,j,i),
744	>	memcpy(rmx_lval(dnew,i,j), rmx_val(rm,j,i),
745		sizeof(double)*dnew->ncomp);
746		return(dnew);
747		}
#	Line 697 \| Line 753 \| *rmx_multiply(const RMATRIX m1, const RMATRIX m2)*
753		RMATRIX *mres;
754		int i, j, k, h;
755
756	<	if (!m1 \| !m2 \|\| (m1->ncomp != m2->ncomp) \| (m1->ncols != m2->nrows))
756	>	if (!m1 \| !m2 \|\| !m1->mtx \| !m2->mtx \|
757	>	(m1->ncomp != m2->ncomp) \| (m1->ncols != m2->nrows))
758		return(NULL);
759		mres = rmx_alloc(m1->nrows, m2->ncols, m1->ncomp);
760		if (!mres)
#	Line 712 \| Line 769 \| *rmx_multiply(const RMATRIX m1, const RMATRIX m2)*
769		for (k = mres->ncomp; k--; ) {
770		double d = 0;
771		for (h = m1->ncols; h--; )
772	<	d += rmx_lval(m1,i,h)[k] * rmx_lval(m2,h,j)[k];
772	>	d += rmx_val(m1,i,h)[k] * rmx_val(m2,h,j)[k];
773		rmx_lval(mres,i,j)[k] = d;
774		}
775		return(mres);
#	Line 725 \| Line 782 \| *rmx_elemult(RMATRIX m1, const RMATRIX m2, int divide*
782		int zeroDivides = 0;
783		int i, j, k;
784
785	<	if (!m1 \| !m2 \|\| (m1->ncols != m2->ncols) \| (m1->nrows != m2->nrows))
785	>	if (!m1 \| !m2 \|\| !m1->mtx \| !m2->mtx \|
786	>	(m1->ncols != m2->ncols) \| (m1->nrows != m2->nrows))
787		return(0);
788		if ((m2->ncomp > 1) & (m2->ncomp != m1->ncomp))
789		return(0);
#	Line 739 \| Line 797 \| *rmx_elemult(RMATRIX m1, const RMATRIX m2, int divide*
797		if (divide) {
798		double d;
799		if (m2->ncomp == 1) {
800	<	d = rmx_lval(m2,i,j)[0];
800	>	d = rmx_val(m2,i,j)[0];
801		if (d == 0) {
802		++zeroDivides;
803		for (k = m1->ncomp; k--; )
#	Line 751 \| Line 809 \| *rmx_elemult(RMATRIX m1, const RMATRIX m2, int divide*
809		}
810		} else
811		for (k = m1->ncomp; k--; ) {
812	<	d = rmx_lval(m2,i,j)[k];
812	>	d = rmx_val(m2,i,j)[k];
813		if (d == 0) {
814		++zeroDivides;
815		rmx_lval(m1,i,j)[k] = 0;
#	Line 760 \| Line 818 \| *rmx_elemult(RMATRIX m1, const RMATRIX m2, int divide*
818		}
819		} else {
820		if (m2->ncomp == 1) {
821	<	const double d = rmx_lval(m2,i,j)[0];
821	>	const double d = rmx_val(m2,i,j)[0];
822		for (k = m1->ncomp; k--; )
823		rmx_lval(m1,i,j)[k] *= d;
824		} else
825		for (k = m1->ncomp; k--; )
826	<	rmx_lval(m1,i,j)[k] *= rmx_lval(m2,i,j)[k];
826	>	rmx_lval(m1,i,j)[k] *= rmx_val(m2,i,j)[k];
827		}
828		if (zeroDivides) {
829		rmx_addinfo(m1, "WARNING: zero divide(s) corrupted results\n");
#	Line 781 \| Line 839 \| *rmx_sum(RMATRIX msum, const RMATRIX madd, const doub*
839		double *mysf = NULL;
840		int i, j, k;
841
842	<	if (!msum \| !madd \|\|
842	>	if (!msum \| !madd \|\| !msum->mtx \| !madd->mtx \|
843		(msum->nrows != madd->nrows) \|
844		(msum->ncols != madd->ncols) \|
845		(msum->ncomp != madd->ncomp))
#	Line 801 \| Line 859 \| *rmx_sum(RMATRIX msum, const RMATRIX madd, const doub*
859		rmx_addinfo(msum, rmx_mismatch_warn);
860		for (i = msum->nrows; i--; )
861		for (j = msum->ncols; j--; ) {
862	<	const double *da = rmx_lval(madd,i,j);
862	>	const double *da = rmx_val(madd,i,j);
863		double *ds = rmx_lval(msum,i,j);
864		for (k = msum->ncomp; k--; )
865		ds[k] += sf[k] * da[k];
#	Line 817 \| Line 875 \| *rmx_scale(RMATRIX rm, const double sf[])**
875		{
876		int i, j, k;
877
878	<	if (!rm \| !sf)
878	>	if (!rm \| !sf \|\| !rm->mtx)
879		return(0);
880		for (i = rm->nrows; i--; )
881		for (j = rm->ncols; j--; ) {
#	Line 838 \| Line 896 \| *rmx_transform(const RMATRIX msrc, int n, const double**
896		int i, j, ks, kd;
897		RMATRIX *dnew;
898
899	<	if (!msrc \| (n <= 0) \| !cmat)
899	>	if (!msrc \| (n <= 0) \| !cmat \|\| !msrc->mtx)
900		return(NULL);
901		dnew = rmx_alloc(msrc->nrows, msrc->ncols, n);
902		if (!dnew)
#	Line 853 \| Line 911 \| *rmx_transform(const RMATRIX msrc, int n, const double**
911		dnew->dtype = msrc->dtype;
912		for (i = dnew->nrows; i--; )
913		for (j = dnew->ncols; j--; ) {
914	<	const double *ds = rmx_lval(msrc,i,j);
914	>	const double *ds = rmx_val(msrc,i,j);
915		for (kd = dnew->ncomp; kd--; ) {
916		double d = 0;
917		for (ks = msrc->ncomp; ks--; )
#	Line 902 \| Line 960 \| *cm_from_rmatrix(const RMATRIX rm)**
960		return(NULL);
961		for (i = cnew->nrows; i--; )
962		for (j = cnew->ncols; j--; ) {
963	<	const double *dp = rmx_lval(rm,i,j);
963	>	const double *dp = rmx_val(rm,i,j);
964		COLORV *cv = cm_lval(cnew,i,j);
965		switch (rm->ncomp) {
966		case 3:

Diff Legend

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

Comparing ray/src/util/rmatrix.c (file contents): Revision 2.61 by greg, Mon Nov 27 22:04:45 2023 UTC vs. Revision 2.81 by greg, Thu Jun 6 16:46:31 2024 UTC

Diff Legend

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.61 by greg, Mon Nov 27 22:04:45 2023 UTC vs.
Revision 2.81 by greg, Thu Jun 6 16:46:31 2024 UTC