src/util/rmatrix.h

/* RCSid $Id: rmatrix.h,v 2.25 2025/04/04 01:48:25 greg Exp $ */
/*
 * Header file for general matrix routines.
 */

#ifndef _RAD_RMATRIX_H_
#define _RAD_RMATRIX_H_

#include "cmatrix.h"

#ifdef __cplusplus
extern "C" {
#endif

/* Preferred BSDF component:
        none, transmission, reflection front (normal side), reflection back */
typedef enum {RMPnone=-1, RMPtrans=0, RMPreflF, RMPreflB} RMPref;

/* RMATRIX flags (usually private):
        need to swap input, we should free memory */
#define RMF_SWAPIN      1
#define RMF_FREEMEM     2

#ifndef MAXCOMP
#define MAXCOMP         MAXCSAMP        /* #components we support */
#endif
                                        /* Set in-core data type */
#if !defined(DTrmx_native) || DTrmx_native==DTfloat
#define DTrmx_native    DTfloat
#define rmx_dtype       float
#define rmx_scanfmt     "%f"
#elif DTrmx_native==DTdouble
#define rmx_dtype       double
#define rmx_scanfmt     "%lf"
#endif

/* General [row][col][cmp] component matrix */
typedef struct {
        char            *info;
        void            *mapped;
        rmx_dtype       *mtx;
        COLOR           cexp;
        float           wlpart[4];
        int             nrows, ncols;
        short           ncomp;
        uby8            dtype;
        uby8            pflags;
} RMATRIX;

#define rmx_lval(rm,r,c)        ((rm)->mtx + (rm)->ncomp*((c)+(size_t)(rm)->ncols*(r)))
#define rmx_val                 rmx_lval

#define rmx_array_size(rm)      (sizeof(rmx_dtype)*(rm)->nrows*(rm)->ncols*(rm)->ncomp)
#define rmx_mapped_size(rm)     ((char *)(rm)->mtx + rmx_array_size(rm) - (char *)(rm)->mapped)

/* Initialize a RMATRIX struct but don't allocate array space */
extern RMATRIX  *rmx_new(int nr, int nc, int n);

/* Prepare a RMATRIX for writing (allocate array if needed) */
extern int      rmx_prepare(RMATRIX *rm);

/* Call rmx_new() and rmx_prepare() */
extern RMATRIX  *rmx_alloc(int nr, int nc, int n);

/* Clear state by freeing info and matrix data */
extern void     rmx_reset(RMATRIX *rm);

/* Free an RMATRIX struct and data */
extern void     rmx_free(RMATRIX *rm);

/* Resolve data type based on two input types (returns 0 for mismatch) */
extern int      rmx_newtype(int dtyp1, int dtyp2);

/* Read matrix header from input stream (cannot be XML) */
extern int      rmx_load_header(RMATRIX *rm, FILE *fp);

/* Load next row as rmx_dtype (cannot be XML) */
extern int      rmx_load_row(rmx_dtype *drp, const RMATRIX *rm, FILE *fp);

/* Allocate & load post-header data from stream given type set in rm->dtype */
extern int      rmx_load_data(RMATRIX *rm, FILE *fp);

/* Load matrix from supported file type (NULL for stdin, '!' with command) */
extern RMATRIX  *rmx_load(const char *inspec, RMPref rmp);

/* Append header information associated with matrix data */
extern int      rmx_addinfo(RMATRIX *rm, const char *info);

/* Finish writing header data with resolution and format, returning type used */
extern int      rmx_write_header(const RMATRIX *rm, int dtype, FILE *fp);

/* Write out matrix data (usually by row) */
extern int      rmx_write_data(const rmx_dtype *dp, int nc, int len,
                                int dtype, FILE *fp);

/* Write matrix using file format indicated by dtype */
extern int      rmx_write(const RMATRIX *rm, int dtype, FILE *fp);

/* Allocate and assign square identity matrix with n components */
extern RMATRIX  *rmx_identity(int dim, int n);

/* Duplicate the given matrix */
extern RMATRIX  *rmx_copy(const RMATRIX *rm);

/* Replace data in first matrix with data from second */
extern int      rmx_transfer_data(RMATRIX *rdst, RMATRIX *rsrc, int dometa);

/* Transpose the given matrix */
extern int      rmx_transpose(RMATRIX *rm);

/* Multiply (concatenate) two matrices and allocate the result */
extern RMATRIX  *rmx_multiply(const RMATRIX *m1, const RMATRIX *m2);

/* Element-wise multiplication (or division) of m2 into m1 */
extern int      rmx_elemult(RMATRIX *m1, const RMATRIX *m2, int divide);

/* Sum second matrix into first, applying scale factor beforehand */
extern int      rmx_sum(RMATRIX *msum, const RMATRIX *madd, const double sf[]);

/* Scale the given matrix by the indicated scalar component vector */
extern int      rmx_scale(RMATRIX *rm, const double sf[]);

/* Allocate new matrix and apply component transformation */
extern RMATRIX  *rmx_transform(const RMATRIX *msrc, int n, const double cmat[]);

/* Convert a color matrix to newly allocated RMATRIX buffer */
extern RMATRIX  *rmx_from_cmatrix(const CMATRIX *cm);

/* Convert general matrix to newly allocated CMATRIX buffer */
extern CMATRIX  *cm_from_rmatrix(const RMATRIX *rm);

#ifdef __cplusplus
}
#endif
#endif  /* _RAD_RMATRIX_H_ */
Revision:	2.26
Committed:	Fri Apr 4 18:06:48 2025 UTC (5 weeks, 1 day ago) by greg
Content type:	text/plain
Branch:	MAIN
Changes since 2.25:	+12 -2 lines
Log Message:	perf(rmtxop,rcomb): Switched default internal data type from double to float
#	User	Rev	Content
1	greg	2.26	/* RCSid $Id: rmatrix.h,v 2.25 2025/04/04 01:48:25 greg Exp $ */
2	greg	2.1	/*
3			* Header file for general matrix routines.
4			*/
5
6			#ifndef _RAD_RMATRIX_H_
7			#define _RAD_RMATRIX_H_
8
9			#include "cmatrix.h"
10
11			#ifdef __cplusplus
12			extern "C" {
13			#endif
14
15	greg	2.13	/* Preferred BSDF component:
16	greg	2.19	none, transmission, reflection front (normal side), reflection back */
17			typedef enum {RMPnone=-1, RMPtrans=0, RMPreflF, RMPreflB} RMPref;
18	greg	2.13
19	greg	2.23	/* RMATRIX flags (usually private):
20			need to swap input, we should free memory */
21	greg	2.21	#define RMF_SWAPIN 1
22	greg	2.23	#define RMF_FREEMEM 2
23	greg	2.21
24	greg	2.26	#ifndef MAXCOMP
25			#define MAXCOMP MAXCSAMP /* #components we support */
26			#endif
27			/* Set in-core data type */
28			#if !defined(DTrmx_native) \|\| DTrmx_native==DTfloat
29			#define DTrmx_native DTfloat
30			#define rmx_dtype float
31			#define rmx_scanfmt "%f"
32			#elif DTrmx_native==DTdouble
33	greg	2.24	#define rmx_dtype double
34	greg	2.26	#define rmx_scanfmt "%lf"
35			#endif
36	greg	2.22
37	greg	2.14	/* General [row][col][cmp] component matrix */
38	greg	2.1	typedef struct {
39	greg	2.24	char *info;
40			void *mapped;
41			rmx_dtype *mtx;
42			COLOR cexp;
43			float wlpart[4];
44			int nrows, ncols;
45			short ncomp;
46			uby8 dtype;
47			uby8 pflags;
48	greg	2.1	} RMATRIX;
49
50	greg	2.15	#define rmx_lval(rm,r,c) ((rm)->mtx + (rm)->ncomp((c)+(size_t)(rm)->ncols(r)))
51	greg	2.17	#define rmx_val rmx_lval
52	greg	2.1
53	greg	2.24	#define rmx_array_size(rm) (sizeof(rmx_dtype)(rm)->nrows(rm)->ncols*(rm)->ncomp)
54	greg	2.21	#define rmx_mapped_size(rm) ((char )(rm)->mtx + rmx_array_size(rm) - (char )(rm)->mapped)
55
56	greg	2.14	/* Initialize a RMATRIX struct but don't allocate array space */
57			extern RMATRIX *rmx_new(int nr, int nc, int n);
58
59			/* Prepare a RMATRIX for writing (allocate array if needed) */
60			extern int rmx_prepare(RMATRIX *rm);
61
62			/* Call rmx_new() and rmx_prepare() */
63	greg	2.1	extern RMATRIX *rmx_alloc(int nr, int nc, int n);
64
65	greg	2.19	/* Clear state by freeing info and matrix data */
66			extern void rmx_reset(RMATRIX *rm);
67
68			/* Free an RMATRIX struct and data */
69	greg	2.4	extern void rmx_free(RMATRIX *rm);
70
71			/* Resolve data type based on two input types (returns 0 for mismatch) */
72			extern int rmx_newtype(int dtyp1, int dtyp2);
73
74	greg	2.17	/* Read matrix header from input stream (cannot be XML) */
75			extern int rmx_load_header(RMATRIX rm, FILE fp);
76
77	greg	2.24	/* Load next row as rmx_dtype (cannot be XML) */
78			extern int rmx_load_row(rmx_dtype drp, const RMATRIX rm, FILE *fp);
79	greg	2.18
80	greg	2.17	/* Allocate & load post-header data from stream given type set in rm->dtype */
81			extern int rmx_load_data(RMATRIX rm, FILE fp);
82
83	greg	2.7	/* Load matrix from supported file type (NULL for stdin, '!' with command) */
84	greg	2.13	extern RMATRIX rmx_load(const char inspec, RMPref rmp);
85	greg	2.1
86	greg	2.3	/* Append header information associated with matrix data */
87			extern int rmx_addinfo(RMATRIX rm, const char info);
88
89	greg	2.19	/* Finish writing header data with resolution and format, returning type used */
90			extern int rmx_write_header(const RMATRIX rm, int dtype, FILE fp);
91
92			/* Write out matrix data (usually by row) */
93	greg	2.24	extern int rmx_write_data(const rmx_dtype *dp, int nc, int len,
94	greg	2.19	int dtype, FILE *fp);
95
96			/* Write matrix using file format indicated by dtype */
97	greg	2.6	extern int rmx_write(const RMATRIX rm, int dtype, FILE fp);
98	greg	2.1
99			/* Allocate and assign square identity matrix with n components */
100			extern RMATRIX *rmx_identity(int dim, int n);
101
102			/* Duplicate the given matrix */
103			extern RMATRIX rmx_copy(const RMATRIX rm);
104
105	greg	2.20	/* Replace data in first matrix with data from second */
106			extern int rmx_transfer_data(RMATRIX rdst, RMATRIX rsrc, int dometa);
107
108	greg	2.25	/* Transpose the given matrix */
109			extern int rmx_transpose(RMATRIX *rm);
110	greg	2.1
111			/* Multiply (concatenate) two matrices and allocate the result */
112			extern RMATRIX rmx_multiply(const RMATRIX m1, const RMATRIX *m2);
113
114	greg	2.8	/* Element-wise multiplication (or division) of m2 into m1 */
115			extern int rmx_elemult(RMATRIX m1, const RMATRIX m2, int divide);
116
117	greg	2.1	/* Sum second matrix into first, applying scale factor beforehand */
118			extern int rmx_sum(RMATRIX msum, const RMATRIX madd, const double sf[]);
119
120			/* Scale the given matrix by the indicated scalar component vector */
121			extern int rmx_scale(RMATRIX *rm, const double sf[]);
122
123			/* Allocate new matrix and apply component transformation */
124			extern RMATRIX rmx_transform(const RMATRIX msrc, int n, const double cmat[]);
125
126			/* Convert a color matrix to newly allocated RMATRIX buffer */
127			extern RMATRIX rmx_from_cmatrix(const CMATRIX cm);
128
129			/* Convert general matrix to newly allocated CMATRIX buffer */
130			extern CMATRIX cm_from_rmatrix(const RMATRIX rm);
131
132			#ifdef __cplusplus
133			}
134			#endif
135			#endif /* _RAD_RMATRIX_H_ */