1 /*****************************************************************************/
2 // Copyright 2006-2019 Adobe Systems Incorporated
3 // All Rights Reserved.
4 //
5 // NOTICE: Adobe permits you to use, modify, and distribute this file in
6 // accordance with the terms of the Adobe license agreement accompanying it.
7 /*****************************************************************************/
8
9 /** \file
10 * Matrix and vector classes, including specialized 3x3 and 4x3 versions as
11 * well as length 3 vectors.
12 */
13
14 /*****************************************************************************/
15
16 #ifndef __dng_matrix__
17 #define __dng_matrix__
18
19 /*****************************************************************************/
20
21 #include "dng_sdk_limits.h"
22 #include "dng_types.h"
23
24 /*****************************************************************************/
25
26 /// \brief Class to represent 2D matrix up to kMaxColorPlanes x kMaxColorPlanes
27 /// in size.
28
29 class dng_matrix
30 {
31
32 protected:
33
34 uint32 fRows;
35 uint32 fCols;
36
37 real64 fData [kMaxColorPlanes] [kMaxColorPlanes];
38
39 public:
40
41 dng_matrix ();
42
43 dng_matrix (uint32 rows,
44 uint32 cols);
45
46 dng_matrix (const dng_matrix &m);
47
~dng_matrix()48 virtual ~dng_matrix ()
49 {
50 }
51
52 void Clear ();
53
54 void SetIdentity (uint32 count);
55
Rows()56 uint32 Rows () const
57 {
58 return fRows;
59 }
60
Cols()61 uint32 Cols () const
62 {
63 return fCols;
64 }
65
66 real64 * operator [] (uint32 row)
67 {
68 return fData [row];
69 }
70
71 const real64 * operator [] (uint32 row) const
72 {
73 return fData [row];
74 }
75
76 bool operator== (const dng_matrix &m) const;
77
78 bool operator!= (const dng_matrix &m) const
79 {
80 return !(*this == m);
81 }
82
IsEmpty()83 bool IsEmpty () const
84 {
85 return fRows == 0 || fCols == 0;
86 }
87
NotEmpty()88 bool NotEmpty () const
89 {
90 return !IsEmpty ();
91 }
92
93 bool IsDiagonal () const;
94
95 bool IsIdentity () const;
96
97 real64 MaxEntry () const;
98
99 real64 MinEntry () const;
100
101 void Scale (real64 factor);
102
103 void Round (real64 factor);
104
105 void SafeRound (real64 factor);
106
107 bool AlmostEqual (const dng_matrix &m,
108 real64 slop = 1.0e-8) const;
109
110 bool AlmostIdentity (real64 slop = 1.0e-8) const;
111
112 };
113
114 /*****************************************************************************/
115
116 /// \brief A 3x3 matrix.
117
118 class dng_matrix_3by3: public dng_matrix
119 {
120
121 public:
122
123 dng_matrix_3by3 ();
124
125 dng_matrix_3by3 (const dng_matrix &m);
126
127 dng_matrix_3by3 (real64 a00, real64 a01, real64 a02,
128 real64 a10, real64 a11, real64 a12,
129 real64 a20, real64 a21, real64 a22);
130
131 dng_matrix_3by3 (real64 a00, real64 a11, real64 a22);
132
133 };
134
135 /*****************************************************************************/
136
137 /// \brief A 4x3 matrix. Handy for working with 4-color cameras.
138
139 class dng_matrix_4by3: public dng_matrix
140 {
141
142 public:
143
144 dng_matrix_4by3 ();
145
146 dng_matrix_4by3 (const dng_matrix &m);
147
148 dng_matrix_4by3 (real64 a00, real64 a01, real64 a02,
149 real64 a10, real64 a11, real64 a12,
150 real64 a20, real64 a21, real64 a22,
151 real64 a30, real64 a31, real64 a32);
152
153 };
154
155 /*****************************************************************************/
156
157 /// \brief A 4x4 matrix. Handy for GPU APIs.
158
159 class dng_matrix_4by4: public dng_matrix
160 {
161
162 public:
163
164 dng_matrix_4by4 ();
165
166 dng_matrix_4by4 (const dng_matrix &m);
167
168 dng_matrix_4by4 (real64 a00, real64 a01, real64 a02, real64 a03,
169 real64 a10, real64 a11, real64 a12, real64 a13,
170 real64 a20, real64 a21, real64 a22, real64 a23,
171 real64 a30, real64 a31, real64 a32, real64 a33);
172
173 dng_matrix_4by4 (real64 a00, real64 a11, real64 a22, real64 a33);
174
175 };
176
177 /*****************************************************************************/
178
179 /// \brief Class to represent 1-dimensional vector with up to kMaxColorPlanes
180 /// components.
181
182 class dng_vector
183 {
184
185 protected:
186
187 uint32 fCount;
188
189 real64 fData [kMaxColorPlanes];
190
191 public:
192
193 dng_vector ();
194
195 dng_vector (uint32 count);
196
197 dng_vector (const dng_vector &v);
198
~dng_vector()199 virtual ~dng_vector ()
200 {
201 }
202
203 void Clear ();
204
205 void SetIdentity (uint32 count);
206
Count()207 uint32 Count () const
208 {
209 return fCount;
210 }
211
212 real64 & operator [] (uint32 index)
213 {
214 return fData [index];
215 }
216
217 const real64 & operator [] (uint32 index) const
218 {
219 return fData [index];
220 }
221
222 bool operator== (const dng_vector &v) const;
223
224 bool operator!= (const dng_vector &v) const
225 {
226 return !(*this == v);
227 }
228
IsEmpty()229 bool IsEmpty () const
230 {
231 return fCount == 0;
232 }
233
NotEmpty()234 bool NotEmpty () const
235 {
236 return !IsEmpty ();
237 }
238
239 real64 MaxEntry () const;
240
241 real64 MinEntry () const;
242
243 void Scale (real64 factor);
244
245 void Round (real64 factor);
246
247 dng_matrix AsDiagonal () const;
248
249 dng_matrix AsColumn () const;
250
251 };
252
253 /*****************************************************************************/
254
255 /// \brief A 3-element vector.
256
257 class dng_vector_3: public dng_vector
258 {
259
260 public:
261
262 dng_vector_3 ();
263
264 dng_vector_3 (const dng_vector &v);
265
266 dng_vector_3 (real64 a0,
267 real64 a1,
268 real64 a2);
269
270 };
271
272 /*****************************************************************************/
273
274 /// \brief A 4-element vector.
275
276 class dng_vector_4: public dng_vector
277 {
278
279 public:
280
281 dng_vector_4 ();
282
283 dng_vector_4 (const dng_vector &v);
284
285 dng_vector_4 (real64 a0,
286 real64 a1,
287 real64 a2,
288 real64 a3);
289
290 };
291
292 /*****************************************************************************/
293
294 dng_matrix operator* (const dng_matrix &A,
295 const dng_matrix &B);
296
297 dng_vector operator* (const dng_matrix &A,
298 const dng_vector &B);
299
300 dng_matrix operator* (real64 scale,
301 const dng_matrix &A);
302
303 dng_vector operator* (real64 scale,
304 const dng_vector &A);
305
306 /*****************************************************************************/
307
308 dng_matrix operator+ (const dng_matrix &A,
309 const dng_matrix &B);
310
311 /*****************************************************************************/
312
313 dng_vector operator- (const dng_vector &a,
314 const dng_vector &b);
315
316 /*****************************************************************************/
317
318 dng_matrix Transpose (const dng_matrix &A);
319
320 /*****************************************************************************/
321
322 dng_matrix Invert (const dng_matrix &A);
323
324 dng_matrix Invert (const dng_matrix &A,
325 const dng_matrix &hint);
326
327 /*****************************************************************************/
328
MaxEntry(const dng_matrix & A)329 inline real64 MaxEntry (const dng_matrix &A)
330 {
331 return A.MaxEntry ();
332 }
333
MaxEntry(const dng_vector & A)334 inline real64 MaxEntry (const dng_vector &A)
335 {
336 return A.MaxEntry ();
337 }
338
339 /*****************************************************************************/
340
MinEntry(const dng_matrix & A)341 inline real64 MinEntry (const dng_matrix &A)
342 {
343 return A.MinEntry ();
344 }
345
MinEntry(const dng_vector & A)346 inline real64 MinEntry (const dng_vector &A)
347 {
348 return A.MinEntry ();
349 }
350
351 /*****************************************************************************/
352
353 real64 Dot (const dng_vector &a,
354 const dng_vector &b);
355
356 /*****************************************************************************/
357
358 real64 Distance (const dng_vector &a,
359 const dng_vector &b);
360
361 /*****************************************************************************/
362
363 #endif
364
365 /*****************************************************************************/
366