1 | /*****************************************************************************/ |
2 | // Copyright 2007 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_hue_sat_map.cpp#1 $ */ |
10 | /* $DateTime: 2012/05/30 13:28:51 $ */ |
11 | /* $Change: 832332 $ */ |
12 | /* $Author: tknoll $ */ |
13 | |
14 | /*****************************************************************************/ |
15 | |
16 | #include "dng_hue_sat_map.h" |
17 | |
18 | #include "dng_assertions.h" |
19 | #include "dng_auto_ptr.h" |
20 | #include "dng_bottlenecks.h" |
21 | #include "dng_exceptions.h" |
22 | #include "dng_host.h" |
23 | |
24 | /*****************************************************************************/ |
25 | |
26 | dng_hue_sat_map::dng_hue_sat_map () |
27 | |
28 | : fHueDivisions (0) |
29 | , fSatDivisions (0) |
30 | , fValDivisions (0) |
31 | , fHueStep (0) |
32 | , fValStep (0) |
33 | , fDeltas () |
34 | |
35 | { |
36 | |
37 | } |
38 | |
39 | /*****************************************************************************/ |
40 | |
41 | dng_hue_sat_map::dng_hue_sat_map (const dng_hue_sat_map &src) |
42 | |
43 | : fHueDivisions (0) |
44 | , fSatDivisions (0) |
45 | , fValDivisions (0) |
46 | , fHueStep (0) |
47 | , fValStep (0) |
48 | , fDeltas () |
49 | |
50 | { |
51 | |
52 | *this = src; |
53 | |
54 | } |
55 | |
56 | /*****************************************************************************/ |
57 | |
58 | dng_hue_sat_map &dng_hue_sat_map::operator= (const dng_hue_sat_map &rhs) |
59 | { |
60 | |
61 | if (this != &rhs) |
62 | { |
63 | |
64 | if (!rhs.IsValid ()) |
65 | { |
66 | |
67 | SetInvalid (); |
68 | |
69 | } |
70 | |
71 | else |
72 | { |
73 | |
74 | fHueDivisions = rhs.fHueDivisions; |
75 | fSatDivisions = rhs.fSatDivisions; |
76 | fValDivisions = rhs.fValDivisions; |
77 | |
78 | fHueStep = rhs.fHueStep; |
79 | fValStep = rhs.fValStep; |
80 | |
81 | fDeltas = rhs.fDeltas; |
82 | |
83 | } |
84 | |
85 | } |
86 | |
87 | return *this; |
88 | |
89 | } |
90 | |
91 | /*****************************************************************************/ |
92 | |
93 | dng_hue_sat_map::~dng_hue_sat_map () |
94 | { |
95 | |
96 | } |
97 | |
98 | /*****************************************************************************/ |
99 | |
100 | void dng_hue_sat_map::SetDivisions (uint32 hueDivisions, |
101 | uint32 satDivisions, |
102 | uint32 valDivisions) |
103 | { |
104 | |
105 | DNG_ASSERT (hueDivisions >= 1, "Must have at least 1 hue division." ); |
106 | DNG_ASSERT (satDivisions >= 2, "Must have at least 2 sat divisions." ); |
107 | |
108 | if (valDivisions == 0) |
109 | valDivisions = 1; |
110 | |
111 | if (hueDivisions == fHueDivisions && |
112 | satDivisions == fSatDivisions && |
113 | valDivisions == fValDivisions) |
114 | { |
115 | return; |
116 | } |
117 | |
118 | fHueDivisions = hueDivisions; |
119 | fSatDivisions = satDivisions; |
120 | fValDivisions = valDivisions; |
121 | |
122 | fHueStep = satDivisions; |
123 | fValStep = SafeUint32Mult(hueDivisions, fHueStep); |
124 | |
125 | uint32 size = SafeUint32Mult(DeltasCount (), (uint32) sizeof (HSBModify)); |
126 | |
127 | fDeltas.Allocate (size); |
128 | |
129 | DoZeroBytes (fDeltas.Buffer (), size); |
130 | |
131 | } |
132 | |
133 | /*****************************************************************************/ |
134 | |
135 | void dng_hue_sat_map::GetDelta (uint32 hueDiv, |
136 | uint32 satDiv, |
137 | uint32 valDiv, |
138 | HSBModify &modify) const |
139 | { |
140 | |
141 | if (hueDiv >= fHueDivisions || |
142 | satDiv >= fSatDivisions || |
143 | valDiv >= fValDivisions || |
144 | fDeltas.Buffer () == NULL) |
145 | { |
146 | |
147 | DNG_REPORT ("Bad parameters to dng_hue_sat_map::GetDelta" ); |
148 | |
149 | ThrowProgramError (); |
150 | |
151 | } |
152 | |
153 | int32 offset = valDiv * fValStep + |
154 | hueDiv * fHueStep + |
155 | satDiv; |
156 | |
157 | const HSBModify *deltas = GetConstDeltas (); |
158 | |
159 | modify.fHueShift = deltas [offset].fHueShift; |
160 | modify.fSatScale = deltas [offset].fSatScale; |
161 | modify.fValScale = deltas [offset].fValScale; |
162 | |
163 | } |
164 | |
165 | /*****************************************************************************/ |
166 | |
167 | void dng_hue_sat_map::SetDeltaKnownWriteable (uint32 hueDiv, |
168 | uint32 satDiv, |
169 | uint32 valDiv, |
170 | const HSBModify &modify) |
171 | { |
172 | |
173 | if (hueDiv >= fHueDivisions || |
174 | satDiv >= fSatDivisions || |
175 | valDiv >= fValDivisions || |
176 | fDeltas.Buffer () == NULL) |
177 | { |
178 | |
179 | DNG_REPORT ("Bad parameters to dng_hue_sat_map::SetDelta" ); |
180 | |
181 | ThrowProgramError (); |
182 | |
183 | } |
184 | |
185 | // Set this entry. |
186 | |
187 | int32 offset = valDiv * fValStep + |
188 | hueDiv * fHueStep + |
189 | satDiv; |
190 | |
191 | SafeGetDeltas () [offset] = modify; |
192 | |
193 | // The zero saturation entry is required to have a value scale |
194 | // of 1.0f. |
195 | |
196 | if (satDiv == 0) |
197 | { |
198 | |
199 | if (modify.fValScale != 1.0f) |
200 | { |
201 | |
202 | #if qDNGValidate |
203 | |
204 | ReportWarning ("Value scale for zero saturation entries must be 1.0" ); |
205 | |
206 | #endif |
207 | |
208 | SafeGetDeltas () [offset] . fValScale = 1.0f; |
209 | |
210 | } |
211 | |
212 | } |
213 | |
214 | // If we are settings the first saturation entry and we have not |
215 | // set the zero saturation entry yet, fill in the zero saturation entry |
216 | // by extrapolating first saturation entry. |
217 | |
218 | if (satDiv == 1) |
219 | { |
220 | |
221 | HSBModify zeroSatModify; |
222 | |
223 | GetDelta (hueDiv, 0, valDiv, zeroSatModify); |
224 | |
225 | if (zeroSatModify.fValScale != 1.0f) |
226 | { |
227 | |
228 | zeroSatModify.fHueShift = modify.fHueShift; |
229 | zeroSatModify.fSatScale = modify.fSatScale; |
230 | zeroSatModify.fValScale = 1.0f; |
231 | |
232 | SetDelta (hueDiv, 0, valDiv, zeroSatModify); |
233 | |
234 | } |
235 | |
236 | } |
237 | |
238 | } |
239 | |
240 | /*****************************************************************************/ |
241 | |
242 | bool dng_hue_sat_map::operator== (const dng_hue_sat_map &rhs) const |
243 | { |
244 | |
245 | if (fHueDivisions != rhs.fHueDivisions || |
246 | fSatDivisions != rhs.fSatDivisions || |
247 | fValDivisions != rhs.fValDivisions) |
248 | return false; |
249 | |
250 | if (!IsValid ()) |
251 | return true; |
252 | |
253 | return memcmp (GetConstDeltas (), |
254 | rhs.GetConstDeltas (), |
255 | DeltasCount () * sizeof (HSBModify)) == 0; |
256 | |
257 | } |
258 | |
259 | /*****************************************************************************/ |
260 | |
261 | dng_hue_sat_map * dng_hue_sat_map::Interpolate (const dng_hue_sat_map &map1, |
262 | const dng_hue_sat_map &map2, |
263 | real64 weight1) |
264 | { |
265 | |
266 | if (weight1 >= 1.0) |
267 | { |
268 | |
269 | if (!map1.IsValid ()) |
270 | { |
271 | |
272 | DNG_REPORT ("map1 is not valid" ); |
273 | |
274 | ThrowProgramError (); |
275 | |
276 | } |
277 | |
278 | return new dng_hue_sat_map (map1); |
279 | |
280 | } |
281 | |
282 | if (weight1 <= 0.0) |
283 | { |
284 | |
285 | if (!map2.IsValid ()) |
286 | { |
287 | DNG_REPORT ("map2 is not valid" ); |
288 | |
289 | ThrowProgramError (); |
290 | |
291 | } |
292 | |
293 | return new dng_hue_sat_map (map2); |
294 | |
295 | } |
296 | |
297 | // Both maps must be valid if we are using both. |
298 | |
299 | if (!map1.IsValid () || !map2.IsValid ()) |
300 | { |
301 | |
302 | DNG_REPORT ("map1 or map2 is not valid" ); |
303 | |
304 | ThrowProgramError (); |
305 | |
306 | } |
307 | |
308 | // Must have the same dimensions. |
309 | |
310 | if (map1.fHueDivisions != map2.fHueDivisions || |
311 | map1.fSatDivisions != map2.fSatDivisions || |
312 | map1.fValDivisions != map2.fValDivisions) |
313 | { |
314 | |
315 | DNG_REPORT ("map1 and map2 have different sizes" ); |
316 | |
317 | ThrowProgramError (); |
318 | |
319 | } |
320 | |
321 | // Make table to hold interpolated results. |
322 | |
323 | AutoPtr<dng_hue_sat_map> result (new dng_hue_sat_map); |
324 | |
325 | result->SetDivisions (map1.fHueDivisions, |
326 | map1.fSatDivisions, |
327 | map1.fValDivisions); |
328 | |
329 | // Interpolate between the tables. |
330 | |
331 | real32 w1 = (real32) weight1; |
332 | real32 w2 = 1.0f - w1; |
333 | |
334 | const HSBModify *data1 = map1.GetConstDeltas (); |
335 | const HSBModify *data2 = map2.GetConstDeltas (); |
336 | |
337 | HSBModify *data3 = result->SafeGetDeltas (); |
338 | |
339 | uint32 count = map1.DeltasCount (); |
340 | |
341 | for (uint32 index = 0; index < count; index++) |
342 | { |
343 | |
344 | data3->fHueShift = w1 * data1->fHueShift + |
345 | w2 * data2->fHueShift; |
346 | |
347 | data3->fSatScale = w1 * data1->fSatScale + |
348 | w2 * data2->fSatScale; |
349 | |
350 | data3->fValScale = w1 * data1->fValScale + |
351 | w2 * data2->fValScale; |
352 | |
353 | data1++; |
354 | data2++; |
355 | data3++; |
356 | |
357 | } |
358 | |
359 | // Return interpolated tables. |
360 | |
361 | return result.Release (); |
362 | |
363 | } |
364 | |
365 | /*****************************************************************************/ |
366 | |