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.82 by greg, Thu Jun 6 17:01:05 2024 UTC vs.
Revision 2.88 by greg, Fri Apr 4 02:53:03 2025 UTC

#	Line 16 | Line 16 | static const char RCSid[] = "$Id$";
16		#include <sys/mman.h>
17		#endif
18
19	+	#ifndef MAXCOMP
20	+	#define MAXCOMP         MAXCSAMP        /* #components we support */
21	+	#endif
22	+
23		static const char       rmx_mismatch_warn[] = "WARNING: data type mismatch\n";
24
25		/* Initialize a RMATRIX struct but don't allocate array space */
#	Line 46 | Line 50 | int
50		rmx_prepare(RMATRIX *rm)
51		{
52		if (!rm) return(0);
53	<	if (rm->mtx)
53	>	if (rm->mtx)                    /* assume it's right size */
54		return(1);
55		if ((rm->nrows <= 0) | (rm->ncols <= 0) | (rm->ncomp <= 0))
56		return(0);
#	Line 61 | Line 65 | rmx_alloc(int nr, int nc, int n)
65		{
66		RMATRIX *dnew = rmx_new(nr, nc, n);
67
68	<	if (dnew && !rmx_prepare(dnew)) {
68	>	if (!rmx_prepare(dnew)) {
69		rmx_free(dnew);
70	<	dnew = NULL;
70	>	return(NULL);
71		}
72		return(dnew);
73		}
#	Line 116 | Line 120 | rmx_newtype(int dtyp1, int dtyp2)
120		int
121		rmx_addinfo(RMATRIX *rm, const char *info)
122		{
123	<	int     oldlen = 0;
123	>	size_t  oldlen = 0;
124
125		if (!rm || !info || !*info)
126		return(0);
127		if (!rm->info) {
128		rm->info = (char *)malloc(strlen(info)+1);
125	–	if (rm->info) rm->info[0] = '\0';
129		} else {
130		oldlen = strlen(rm->info);
131		rm->info = (char *)realloc(rm->info,
#	Line 141 | Line 144 | get_dminfo(char *s, void *p)
144		char    fmt[MAXFMTLEN];
145		int     i;
146
147	<	if (headidval(NULL, s))
147	>	if (isheadid(s))
148		return(0);
149		if (isncomp(s)) {
150		ip->ncomp = ncompval(s);
151	<	return(0);
151	>	return(ip->ncomp - 1);
152		}
153		if (!strncmp(s, "NROWS=", 6)) {
154		ip->nrows = atoi(s+6);
155	<	return(0);
155	>	return(ip->nrows - 1);
156		}
157		if (!strncmp(s, "NCOLS=", 6)) {
158		ip->ncols = atoi(s+6);
159	<	return(0);
159	>	return(ip->ncols - 1);
160		}
161		if ((i = isbigendian(s)) >= 0) {
162		if (nativebigendian() != i)
#	Line 165 | Line 168 | get_dminfo(char *s, void *p)
168		if (isexpos(s)) {
169		float   f = exposval(s);
170		scalecolor(ip->cexp, f);
171	<	return(0);
171	>	return(f > .0 ? 0 : -1);
172		}
173		if (iscolcor(s)) {
174		COLOR   ctmp;
175	<	colcorval(ctmp, s);
175	>	if (!colcorval(ctmp, s)) return(-1);
176		multcolor(ip->cexp, ctmp);
177		return(0);
178		}
179	<	if (iswlsplit(s)) {
180	<	wlsplitval(ip->wlpart, s);
181	<	return(0);
179	<	}
179	>	if (iswlsplit(s))
180	>	return(wlsplitval(ip->wlpart, s) - 1);
181	>
182		if (!formatval(fmt, s)) {
183		rmx_addinfo(ip, s);
184		return(0);
#	Line 186 | Line 188 | get_dminfo(char *s, void *p)
188		ip->dtype = i;
189		return(0);
190		}
191	<	return(-1);
191	>	return(-1);             /* bad format */
192		}
193
194		static int
#	Line 205 | Line 207 | static int
207		rmx_load_float(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
208		{
209		int     j, k;
210	<	float   val[100];
210	>	float   val[MAXCOMP];
211
212	<	if (rm->ncomp > 100) {
212	>	if (rm->ncomp > MAXCOMP) {
213		fputs("Unsupported # components in rmx_load_float()\n", stderr);
214		exit(1);
215		}
#	Line 258 | Line 260 | rmx_load_rgbe(rmx_dtype *drp, const RMATRIX *rm, FILE
260		static int
261		rmx_load_spec(rmx_dtype *drp, const RMATRIX *rm, FILE *fp)
262		{
263	<	uby8    *scan;
264	<	SCOLOR  scol;
263	>	COLRV   *scan;
264	>	COLORV  scol[MAXCOMP];
265		int     j, k;
266
267	<	if ((rm->ncomp < 3) | (rm->ncomp > MAXCSAMP))
267	>	if ((rm->ncomp < 3) | (rm->ncomp > MAXCOMP))
268		return(0);
269	<	scan = (uby8 *)tempbuffer((rm->ncomp+1)*rm->ncols);
269	>	scan = (COLRV *)tempbuffer((rm->ncomp+1)*rm->ncols);
270		if (!scan)
271		return(0);
272		if (freadscolrs(scan, rm->ncomp, rm->ncols, fp) < 0)
#	Line 293 | Line 295 | rmx_load_header(RMATRIX *rm, FILE *fp)
295		}
296		rm->dtype = DTascii;                    /* assumed w/o FORMAT */
297		if (getheader(fp, get_dminfo, rm) < 0) {
298	<	fputs("Unrecognized matrix format\n", stderr);
298	>	fputs("Bad matrix header\n", stderr);
299		return(0);
300		}
301		if ((rm->dtype == DTrgbe) | (rm->dtype == DTxyze) &&
#	Line 380 | Line 382 | rmx_load(const char *inspec, RMPref rmp)
382		fp = stdin;
383		else if (inspec[0] == '!')
384		fp = popen(inspec+1, "r");
385	<	else {
386	<	const char      *sp = inspec;   /* check suffix */
387	<	while (*sp)
386	<	++sp;
387	<	while (sp > inspec && sp[-1] != '.')
388	<	--sp;
389	<	if (!strcasecmp(sp, "XML")) {   /* assume it's a BSDF */
385	>	else {                                  /* check suffix */
386	>	const char      *sp = strrchr(inspec, '.');
387	>	if (sp > inspec && !strcasecmp(sp+1, "XML")) {  /* BSDF? */
388		CMATRIX *cm = rmp==RMPnone ? (CMATRIX *)NULL :
389		rmp==RMPtrans ? cm_loadBTDF(inspec) :
390		cm_loadBRDF(inspec, rmp==RMPreflB) ;
#	Line 434 | Line 432 | rmx_load(const char *inspec, RMPref rmp)
432		/* undo exposure? */
433		if ((dnew->cexp[0] != 1.f) |
434		(dnew->cexp[1] != 1.f) | (dnew->cexp[2] != 1.f)) {
435	<	double  cmlt[MAXCSAMP];
435	>	double  cmlt[MAXCOMP];
436		int     i;
437	<	if (dnew->ncomp > MAXCSAMP) {
437	>	if (dnew->ncomp > MAXCOMP) {
438		fprintf(stderr, "Excess spectral components in: %s\n",
439		inspec);
440		rmx_free(dnew);
#	Line 500 | Line 498 | rmx_write_rgbe(const rmx_dtype *dp, int nc, int len, F
498		static int
499		rmx_write_spec(const rmx_dtype *dp, int nc, int len, FILE *fp)
500		{
501	<	uby8    *scan;
502	<	SCOLOR  scol;
501	>	COLRV   *scan;
502	>	COLORV  scol[MAXCOMP];
503		int     j, k;
504
505	<	if (nc < 3) return(0);
506	<	scan = (uby8 *)tempbuffer((nc+1)*len);
505	>	if ((nc < 3) | (nc > MAXCOMP)) return(0);
506	>	scan = (COLRV *)tempbuffer((nc+1)*len);
507		if (!scan) return(0);
508		for (j = 0; j < len; j++, dp += nc) {
509		for (k = nc; k--; )
#	Line 682 | Line 680 | rmx_copy(const RMATRIX *rm)
680		int
681		rmx_transfer_data(RMATRIX *rdst, RMATRIX *rsrc, int dometa)
682		{
683	<	if (!rdst | !rsrc || (rdst->nrows != rsrc->nrows) |
686	<	(rdst->ncols != rsrc->ncols) |
687	<	(rdst->ncomp != rsrc->ncomp))
683	>	if (!rdst | !rsrc)
684		return(0);
689	–
685		if (dometa) {           /* transfer everything? */
686		rmx_reset(rdst);
687		*rdst = *rsrc;
688		rsrc->info = NULL; rsrc->mapped = NULL; rsrc->mtx = NULL;
689		return(1);
690		}
691	<	#ifdef MAP_FILE                 /* just matrix data -- leave metadata */
691	>	/* just matrix data -- leave metadata */
692	>	if ((rdst->nrows != rsrc->nrows) |
693	>	(rdst->ncols != rsrc->ncols) |
694	>	(rdst->ncomp != rsrc->ncomp))
695	>	return(0);
696	>	#ifdef MAP_FILE
697		if (rdst->mapped)
698		munmap(rdst->mapped, rmx_mapped_size(rdst));
699		else
700		#endif
701	<	if (rdst->pflags & RMF_FREEMEM)
701	>	if (rdst->pflags & RMF_FREEMEM) {
702		free(rdst->mtx);
703	+	rdst->pflags &= ~RMF_FREEMEM;
704	+	}
705		rdst->mapped = rsrc->mapped;
706		rdst->mtx = rsrc->mtx;
707	<	if (rsrc->pflags & RMF_FREEMEM)
706	<	rdst->pflags |= RMF_FREEMEM;
707	<	else
708	<	rdst->pflags &= ~RMF_FREEMEM;
707	>	rdst->pflags |= rsrc->pflags & RMF_FREEMEM;
708		rsrc->mapped = NULL; rsrc->mtx = NULL;
709		return(1);
710		}
711
712	<	/* Allocate and assign transposed matrix */
713	<	RMATRIX *
714	<	rmx_transpose(const RMATRIX *rm)
712	>	/* Transpose the given matrix */
713	>	int
714	>	rmx_transpose(RMATRIX *rm)
715		{
716	<	RMATRIX *dnew;
716	>	RMATRIX dnew;
717		int     i, j;
718
719	<	if (!rm || !rm->mtx)
719	>	if (!rm || !rm->mtx | (rm->ncomp > MAXCOMP))
720		return(0);
721	<	if ((rm->nrows == 1) | (rm->ncols == 1)) {
722	<	dnew = rmx_copy(rm);
723	<	if (!dnew)
724	<	return(NULL);
725	<	dnew->nrows = rm->ncols;
726	<	dnew->ncols = rm->nrows;
727	<	return(dnew);
721	>	if (rm->info)
722	>	rmx_addinfo(rm, "Transposed rows and columns\n");
723	>	if ((rm->nrows == 1) | (rm->ncols == 1)) { /* vector? */
724	>	j = rm->ncols;
725	>	rm->ncols = rm->nrows;
726	>	rm->nrows = j;
727	>	return(1);
728		}
729	<	dnew = rmx_alloc(rm->ncols, rm->nrows, rm->ncomp);
730	<	if (!dnew)
731	<	return(NULL);
732	<	if (rm->info) {
733	<	rmx_addinfo(dnew, rm->info);
734	<	rmx_addinfo(dnew, "Transposed rows and columns\n");
729	>	if (rm->nrows == rm->ncols) {   /* square matrix case */
730	>	rmx_dtype       val[MAXCOMP];
731	>	for (j = rm->ncols; j--; )
732	>	for (i = rm->nrows; i--; ) {
733	>	if (i == j) continue;
734	>	memcpy(val, rmx_val(rm,i,j),
735	>	sizeof(rmx_dtype)*rm->ncomp);
736	>	memcpy(rmx_lval(rm,i,j), rmx_val(rm,j,i),
737	>	sizeof(rmx_dtype)*rm->ncomp);
738	>	memcpy(rmx_val(rm,j,i), val,
739	>	sizeof(rmx_dtype)*rm->ncomp);
740	>	}
741	>	return(1);
742		}
743	<	dnew->dtype = rm->dtype;
744	<	copycolor(dnew->cexp, rm->cexp);
745	<	memcpy(dnew->wlpart, rm->wlpart, sizeof(dnew->wlpart));
746	<	for (j = dnew->ncols; j--; )
747	<	for (i = dnew->nrows; i--; )
748	<	memcpy(rmx_lval(dnew,i,j), rmx_val(rm,j,i),
749	<	sizeof(rmx_dtype)*dnew->ncomp);
750	<	return(dnew);
743	>	memset(&dnew, 0, sizeof(dnew));
744	>	dnew.ncols = rm->nrows; dnew.nrows = rm->ncols;
745	>	dnew.ncomp = rm->ncomp;
746	>	if (!rmx_prepare(&dnew))
747	>	return(0);
748	>	rmx_addinfo(&dnew, rm->info);
749	>	dnew.dtype = rm->dtype;
750	>	copycolor(dnew.cexp, rm->cexp);
751	>	memcpy(dnew.wlpart, rm->wlpart, sizeof(dnew.wlpart));
752	>	for (j = dnew.ncols; j--; )
753	>	for (i = dnew.nrows; i--; )
754	>	memcpy(rmx_lval(&dnew,i,j), rmx_val(rm,j,i),
755	>	sizeof(rmx_dtype)*dnew.ncomp);
756	>	/* and reassign result */
757	>	return(rmx_transfer_data(rm, &dnew, 1));
758		}
759
760		/* Multiply (concatenate) two matrices and allocate the result */
#	Line 951 | Line 964 | cm_from_rmatrix(const RMATRIX *rm)
964		int     i, j;
965		CMATRIX *cnew;
966
967	<	if (!rm || !rm->mtx | (rm->ncomp == 2))
967	>	if (!rm || !rm->mtx | (rm->ncomp == 2) | (rm->ncomp > MAXCOMP))
968		return(NULL);
969		cnew = cm_alloc(rm->nrows, rm->ncols);
970		if (!cnew)
#	Line 968 | Line 981 | cm_from_rmatrix(const RMATRIX *rm)
981		setcolor(cv, dp[0], dp[0], dp[0]);
982		break;
983		default: {
984	<	SCOLOR  scol;
984	>	COLORV  scol[MAXCOMP];
985		int     k;
986		for (k = rm->ncomp; k--; )
987		scol[k] = dp[k];

Diff Legend

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