ViewVC Help

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

root/Development/ray/src/util/rmatrix.c

Comparing ray/src/util/rmatrix.c (file contents):
Revision 2.10 by greg, Thu Sep 18 23:20:12 2014 UTC vs.
Revision 2.25 by greg, Mon Aug 28 15:59:46 2017 UTC

#	Line 9 | Line 9 | static const char RCSid[] = "$Id$";
9		#include <stdlib.h>
10		#include <string.h>
11		#include <fcntl.h>
12	+	#include <errno.h>
13	+	#include "rtio.h"
14	+	#include "platform.h"
15		#include "resolu.h"
16	+	#include "paths.h"
17		#include "rmatrix.h"
18
19		static char     rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
#	Line 46 | Line 50 | rmx_free(RMATRIX *rm)
50		int
51		rmx_newtype(int dtyp1, int dtyp2)
52		{
53	<	if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) && dtyp1 != dtyp2)
53	>	if ((dtyp1==DTxyze) | (dtyp1==DTrgbe) |
54	>	(dtyp2==DTxyze) | (dtyp2==DTrgbe)
55	>	&& dtyp1 != dtyp2)
56		return(0);
57		if (dtyp1 < dtyp2)
58		return(dtyp1);
#	Line 108 | Line 114 | static int
114		rmx_load_ascii(RMATRIX *rm, FILE *fp)
115		{
116		int     i, j, k;
117	<	#ifdef _WIN32
112	<	_setmode(fileno(fp), _O_TEXT);
113	<	#endif
117	>
118		for (i = 0; i < rm->nrows; i++)
119		for (j = 0; j < rm->ncols; j++)
120		for (k = 0; k < rm->ncomp; k++)
#	Line 131 | Line 135 | rmx_load_float(RMATRIX *rm, FILE *fp)
135		}
136		for (i = 0; i < rm->nrows; i++)
137		for (j = 0; j < rm->ncols; j++) {
138	<	if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
138	>	if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
139		return(0);
140		for (k = rm->ncomp; k--; )
141		rmx_lval(rm,i,j,k) = val[k];
#	Line 151 | Line 155 | rmx_load_double(RMATRIX *rm, FILE *fp)
155		}
156		for (i = 0; i < rm->nrows; i++)
157		for (j = 0; j < rm->ncols; j++) {
158	<	if (fread(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
158	>	if (getbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
159		return(0);
160		for (k = rm->ncomp; k--; )
161		rmx_lval(rm,i,j,k) = val[k];
#	Line 184 | Line 188 | rmx_load_rgbe(RMATRIX *rm, FILE *fp)
188
189		/* Load matrix from supported file type */
190		RMATRIX *
191	<	rmx_load(const char *fname)
191	>	rmx_load(const char *inspec)
192		{
193		FILE            *fp = stdin;
194		RMATRIX         dinfo;
195		RMATRIX         *dnew;
196
197	<	if (fname == NULL) {                    /* reading from stdin? */
198	<	fname = "<stdin>";
199	<	#ifdef _WIN32
200	<	_setmode(fileno(stdin), _O_BINARY);
201	<	#endif
197	>	if (inspec == NULL) {                   /* reading from stdin? */
198	>	inspec = "<stdin>";
199	>	SET_FILE_BINARY(stdin);
200	>	} else if (inspec[0] == '!') {
201	>	if ((fp = popen(inspec+1, "r")) == NULL)
202	>	return(NULL);
203	>	SET_FILE_BINARY(stdin);
204		} else {
205	<	const char      *sp = fname;    /* check suffix */
205	>	const char      *sp = inspec;   /* check suffix */
206		while (*sp)
207		++sp;
208	<	while (sp > fname && sp[-1] != '.')
208	>	while (sp > inspec && sp[-1] != '.')
209		--sp;
210		if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
211	<	CMATRIX *cm = cm_loadBTDF((char *)fname);
211	>	CMATRIX *cm = cm_loadBTDF((char *)inspec);
212		if (cm == NULL)
213		return(NULL);
214		dnew = rmx_from_cmatrix(cm);
215		cm_free(cm);
216	+	dnew->dtype = DTascii;
217		return(dnew);
218		}
219		/* else open it ourselves */
220	<	if ((fp = fopen(fname, "rb")) == NULL)
220	>	if ((fp = fopen(inspec, "rb")) == NULL)
221		return(NULL);
222		}
223		#ifdef getc_unlocked
#	Line 244 | Line 251 | rmx_load(const char *fname)
251		dnew->info = dinfo.info;
252		switch (dinfo.dtype) {
253		case DTascii:
254	+	SET_FILE_TEXT(stdin);
255		if (!rmx_load_ascii(dnew, fp))
256		goto loaderr;
257	+	dnew->dtype = DTascii;          /* should leave double? */
258		break;
259		case DTfloat:
260		if (!rmx_load_float(dnew, fp))
#	Line 266 | Line 275 | rmx_load(const char *fname)
275		default:
276		goto loaderr;
277		}
278	<	if (fp != stdin)
279	<	fclose(fp);
278	>	if (fp != stdin) {
279	>	if (inspec[0] == '!')
280	>	pclose(fp);
281	>	else
282	>	fclose(fp);
283	>	}
284	>	#ifdef getc_unlocked
285	>	else
286	>	funlockfile(fp);
287	>	#endif
288		return(dnew);
289		loaderr:                                        /* should report error? */
290	<	fclose(fp);
290	>	if (inspec[0] == '!')
291	>	pclose(fp);
292	>	else
293	>	fclose(fp);
294		rmx_free(dnew);
295		return(NULL);
296		}
#	Line 279 | Line 299 | static int
299		rmx_write_ascii(const RMATRIX *rm, FILE *fp)
300		{
301		int     i, j, k;
302	<	#ifdef _WIN32
283	<	_setmode(fileno(fp), _O_TEXT);
284	<	#endif
302	>
303		for (i = 0; i < rm->nrows; i++) {
304		for (j = 0; j < rm->ncols; j++) {
305		for (k = 0; k < rm->ncomp; k++)
#	Line 307 | Line 325 | rmx_write_float(const RMATRIX *rm, FILE *fp)
325		for (j = 0; j < rm->ncols; j++) {
326		for (k = rm->ncomp; k--; )
327		val[k] = (float)rmx_lval(rm,i,j,k);
328	<	if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
328	>	if (putbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
329		return(0);
330		}
331		return(1);
#	Line 327 | Line 345 | rmx_write_double(const RMATRIX *rm, FILE *fp)
345		for (j = 0; j < rm->ncols; j++) {
346		for (k = rm->ncomp; k--; )
347		val[k] = rmx_lval(rm,i,j,k);
348	<	if (fwrite(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
348	>	if (putbinary(val, sizeof(val[0]), rm->ncomp, fp) != rm->ncomp)
349		return(0);
350		}
351		return(1);
#	Line 364 | Line 382 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
382
383		if ((rm == NULL) | (fp == NULL))
384		return(0);
385	+	#ifdef getc_unlocked
386	+	flockfile(fp);
387	+	#endif
388		/* complete header */
389		if (rm->info)
390		fputs(rm->info, fp);
#	Line 408 | Line 429 | rmx_write(const RMATRIX *rm, int dtype, FILE *fp)
429		return(0);
430		}
431		ok &= (fflush(fp) == 0);
432	+	#ifdef getc_unlocked
433	+	funlockfile(fp);
434	+	#endif
435		rmx_free(mydm);
436		return(ok);
437		}
#	Line 417 | Line 441 | RMATRIX *
441		rmx_identity(const int dim, const int n)
442		{
443		RMATRIX *rid = rmx_alloc(dim, dim, n);
444	<	int     i;
444	>	int     i, k;
445
446		if (rid == NULL)
447		return(NULL);
448	<	memset(rid->mtx, 0, sizeof(rid->mtx[0])*dim*dim);
448	>	memset(rid->mtx, 0, sizeof(rid->mtx[0])*n*dim*dim);
449		for (i = dim; i--; )
450	<	rmx_lval(rid,i,i,0) = 1;
451	<	for (i = n; --i; )
428	<	memcpy(rid->mtx+i*(dim*dim), rid->mtx,
429	<	sizeof(rid->mtx[0])*dim*dim);
450	>	for (k = n; k--; )
451	>	rmx_lval(rid,i,i,k) = 1;
452		return(rid);
453		}
454
#	Line 495 | Line 517 | rmx_multiply(const RMATRIX *m1, const RMATRIX *m2)
517		for (k = mres->ncomp; k--; ) {
518		long double d = 0;
519		for (h = m1->ncols; h--; )
520	<	d += (long double)rmx_lval(m1,i,h,k) *
499	<	(long double)rmx_lval(m2,h,j,k);
520	>	d += rmx_lval(m1,i,h,k) * rmx_lval(m2,h,j,k);
521		rmx_lval(mres,i,j,k) = (double)d;
522		}
523		return(mres);
524	+	}
525	+
526	+	/* Element-wise multiplication (or division) of m2 into m1 */
527	+	int
528	+	rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide)
529	+	{
530	+	int     zeroDivides = 0;
531	+	int     i, j, k;
532	+
533	+	if ((m1 == NULL) | (m2 == NULL) ||
534	+	(m1->ncols != m2->ncols) | (m1->nrows != m2->nrows))
535	+	return(0);
536	+	if ((m2->ncomp > 1) & (m2->ncomp != m1->ncomp))
537	+	return(0);
538	+	i = rmx_newtype(m1->dtype, m2->dtype);
539	+	if (i)
540	+	m1->dtype = i;
541	+	else
542	+	rmx_addinfo(m1, rmx_mismatch_warn);
543	+	for (i = m1->nrows; i--; )
544	+	for (j = m1->ncols; j--; )
545	+	if (divide) {
546	+	double      d;
547	+	if (m2->ncomp == 1) {
548	+	d = rmx_lval(m2,i,j,0);
549	+	if (d == 0) {
550	+	++zeroDivides;
551	+	for (k = m1->ncomp; k--; )
552	+	rmx_lval(m1,i,j,k) = 0;
553	+	} else {
554	+	d = 1./d;
555	+	for (k = m1->ncomp; k--; )
556	+	rmx_lval(m1,i,j,k) *= d;
557	+	}
558	+	} else
559	+	for (k = m1->ncomp; k--; ) {
560	+	d = rmx_lval(m2,i,j,k);
561	+	if (d == 0) {
562	+	++zeroDivides;
563	+	rmx_lval(m1,i,j,k) = 0;
564	+	} else
565	+	rmx_lval(m1,i,j,k) /= d;
566	+	}
567	+	} else {
568	+	if (m2->ncomp == 1) {
569	+	const double    d = rmx_lval(m2,i,j,0);
570	+	for (k = m1->ncomp; k--; )
571	+	rmx_lval(m1,i,j,k) *= d;
572	+	} else
573	+	for (k = m1->ncomp; k--; )
574	+	rmx_lval(m1,i,j,k) *= rmx_lval(m2,i,j,k);
575	+	}
576	+	if (zeroDivides) {
577	+	fputs("Divide by zero in rmx_elemult()\n", stderr);
578	+	errno = ERANGE;
579	+	}
580	+	return(1);
581		}
582
583		/* Sum second matrix into first, applying scale factor beforehand */

Diff Legend

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