src/util/rmatrix.h

/* RCSid $Id: rmatrix.h,v 2.26 2025/04/04 18:06:48 greg Exp $ */
/*
 * Header file for general matrix routines.
 */

#ifndef _RAD_RMATRIX_H_
#define _RAD_RMATRIX_H_

#include "cmatrix.h"

#ifdef __cplusplus
extern "C" {
#endif

/* 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);

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