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