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.h#2 $ */ |
10 | /* $DateTime: 2012/07/31 22:04:34 $ */ |
11 | /* $Change: 840853 $ */ |
12 | /* $Author: tknoll $ */ |
13 | |
14 | /** \file |
15 | * Table-based color correction data structure. |
16 | */ |
17 | |
18 | /*****************************************************************************/ |
19 | |
20 | #ifndef __dng_hue_sat_map__ |
21 | #define __dng_hue_sat_map__ |
22 | |
23 | /*****************************************************************************/ |
24 | |
25 | #include "dng_classes.h" |
26 | #include "dng_exceptions.h" |
27 | #include "dng_ref_counted_block.h" |
28 | #include "dng_safe_arithmetic.h" |
29 | #include "dng_types.h" |
30 | |
31 | /*****************************************************************************/ |
32 | |
33 | /// \brief A 3D table that maps HSV (hue, saturation, and value) floating-point |
34 | /// input coordinates in the range [0,1] to delta signals. The table must have at |
35 | /// least 1 sample in the hue dimension, at least 2 samples in the saturation |
36 | /// dimension, and at least 1 sample in the value dimension. Tables are stored in |
37 | /// value-hue-saturation order. |
38 | |
39 | class dng_hue_sat_map |
40 | { |
41 | |
42 | public: |
43 | |
44 | /// HSV delta signal. \param fHueShift is a delta value specified in degrees. |
45 | /// This parameter, added to the original hue, determines the output hue. A |
46 | /// value of 0 means no change. \param fSatScale and \param fValScale are |
47 | /// scale factors that are applied to saturation and value components, |
48 | /// respectively. These scale factors, multiplied by the original saturation |
49 | /// and value, determine the output saturation and value. A scale factor of |
50 | /// 1.0 means no change. |
51 | |
52 | struct HSBModify |
53 | { |
54 | real32 fHueShift; |
55 | real32 fSatScale; |
56 | real32 fValScale; |
57 | }; |
58 | |
59 | private: |
60 | |
61 | uint32 fHueDivisions; |
62 | uint32 fSatDivisions; |
63 | uint32 fValDivisions; |
64 | |
65 | uint32 fHueStep; |
66 | uint32 fValStep; |
67 | |
68 | dng_ref_counted_block fDeltas; |
69 | |
70 | HSBModify *SafeGetDeltas () |
71 | { |
72 | return (HSBModify *) fDeltas.Buffer_real32 (); |
73 | } |
74 | |
75 | public: |
76 | |
77 | /// Construct an empty (and invalid) hue sat map. |
78 | |
79 | dng_hue_sat_map (); |
80 | |
81 | /// Copy an existing hue sat map. |
82 | |
83 | dng_hue_sat_map (const dng_hue_sat_map &src); |
84 | |
85 | /// Copy an existing hue sat map. |
86 | |
87 | dng_hue_sat_map & operator= (const dng_hue_sat_map &rhs); |
88 | |
89 | /// Destructor. |
90 | |
91 | virtual ~dng_hue_sat_map (); |
92 | |
93 | /// Is this hue sat map invalid? |
94 | |
95 | bool IsNull () const |
96 | { |
97 | return !IsValid (); |
98 | } |
99 | |
100 | /// Is this hue sat map valid? |
101 | |
102 | bool IsValid () const |
103 | { |
104 | |
105 | return fHueDivisions > 0 && |
106 | fSatDivisions > 1 && |
107 | fValDivisions > 0 && |
108 | fDeltas.Buffer (); |
109 | |
110 | } |
111 | |
112 | /// Clear the hue sat map, making it invalid. |
113 | |
114 | void SetInvalid () |
115 | { |
116 | |
117 | fHueDivisions = 0; |
118 | fSatDivisions = 0; |
119 | fValDivisions = 0; |
120 | |
121 | fHueStep = 0; |
122 | fValStep = 0; |
123 | |
124 | fDeltas.Clear (); |
125 | |
126 | } |
127 | |
128 | /// Get the table dimensions (number of samples in each dimension). |
129 | |
130 | void GetDivisions (uint32 &hueDivisions, |
131 | uint32 &satDivisions, |
132 | uint32 &valDivisions) const |
133 | { |
134 | hueDivisions = fHueDivisions; |
135 | satDivisions = fSatDivisions; |
136 | valDivisions = fValDivisions; |
137 | } |
138 | |
139 | /// Set the table dimensions (number of samples in each dimension). This |
140 | /// erases any existing table data. |
141 | |
142 | void SetDivisions (uint32 hueDivisions, |
143 | uint32 satDivisions, |
144 | uint32 valDivisions = 1); |
145 | |
146 | /// Get a specific table entry, specified by table indices. |
147 | |
148 | void GetDelta (uint32 hueDiv, |
149 | uint32 satDiv, |
150 | uint32 valDiv, |
151 | HSBModify &modify) const; |
152 | |
153 | /// Make sure the table is writeable. |
154 | |
155 | void EnsureWriteable () |
156 | { |
157 | fDeltas.EnsureWriteable (); |
158 | } |
159 | |
160 | /// Set a specific table entry, specified by table indices. |
161 | |
162 | void SetDelta (uint32 hueDiv, |
163 | uint32 satDiv, |
164 | uint32 valDiv, |
165 | const HSBModify &modify) |
166 | { |
167 | |
168 | EnsureWriteable (); |
169 | |
170 | SetDeltaKnownWriteable (hueDiv, |
171 | satDiv, |
172 | valDiv, |
173 | modify); |
174 | |
175 | } |
176 | |
177 | /// Same as SetDelta, without checking that the table is writeable. |
178 | |
179 | void SetDeltaKnownWriteable (uint32 hueDiv, |
180 | uint32 satDiv, |
181 | uint32 valDiv, |
182 | const HSBModify &modify); |
183 | |
184 | /// Get the total number of samples (across all dimensions). |
185 | |
186 | uint32 DeltasCount () const |
187 | { |
188 | uint32 deltaCount; |
189 | if (!SafeUint32Mult(fValDivisions, fHueDivisions, &deltaCount) || |
190 | !SafeUint32Mult(deltaCount, fSatDivisions, &deltaCount)) |
191 | { |
192 | ThrowMemoryFull("Arithmetic overflow computing delta count" ); |
193 | } |
194 | |
195 | return deltaCount; |
196 | } |
197 | |
198 | /// Direct read/write access to table entries. The entries are stored in |
199 | /// value-hue-saturation order (outer to inner). |
200 | |
201 | HSBModify *GetDeltas () |
202 | { |
203 | |
204 | EnsureWriteable (); |
205 | |
206 | return (HSBModify *) fDeltas.Buffer_real32 (); |
207 | |
208 | } |
209 | |
210 | /// Direct read-only access to table entries. The entries are stored in |
211 | /// value-hue-saturation order (outer to inner). |
212 | |
213 | const HSBModify *GetConstDeltas () const |
214 | { |
215 | return (const HSBModify *) fDeltas.Buffer_real32 (); |
216 | } |
217 | |
218 | /// Equality test. |
219 | |
220 | bool operator== (const dng_hue_sat_map &rhs) const; |
221 | |
222 | /// Compute a linearly-interpolated hue sat map (i.e., delta and scale factors) |
223 | /// from the specified tables, with the specified weight. map1 and map2 must |
224 | /// have the same dimensions. |
225 | |
226 | static dng_hue_sat_map * Interpolate (const dng_hue_sat_map &map1, |
227 | const dng_hue_sat_map &map2, |
228 | real64 weight1); |
229 | |
230 | }; |
231 | |
232 | /*****************************************************************************/ |
233 | |
234 | #endif |
235 | |
236 | /*****************************************************************************/ |
237 | |