Mercurial > hg > svcore
comparison base/RangeMapper.cpp @ 1038:cc27f35aa75c cxx11
Introducing the signed 64-bit frame index type, and fixing build failures from inclusion of -Wconversion with -Werror. Not finished yet.
author | Chris Cannam |
---|---|
date | Tue, 03 Mar 2015 15:18:24 +0000 |
parents | 12a6140b3ae0 |
children | c7b9c902642f |
comparison
equal
deleted
inserted
replaced
1037:bf0e5944289b | 1038:cc27f35aa75c |
---|---|
20 #include <cmath> | 20 #include <cmath> |
21 | 21 |
22 #include <iostream> | 22 #include <iostream> |
23 | 23 |
24 LinearRangeMapper::LinearRangeMapper(int minpos, int maxpos, | 24 LinearRangeMapper::LinearRangeMapper(int minpos, int maxpos, |
25 float minval, float maxval, | 25 double minval, double maxval, |
26 QString unit, bool inverted) : | 26 QString unit, bool inverted) : |
27 m_minpos(minpos), | 27 m_minpos(minpos), |
28 m_maxpos(maxpos), | 28 m_maxpos(maxpos), |
29 m_minval(minval), | 29 m_minval(minval), |
30 m_maxval(maxval), | 30 m_maxval(maxval), |
34 assert(m_maxval != m_minval); | 34 assert(m_maxval != m_minval); |
35 assert(m_maxpos != m_minpos); | 35 assert(m_maxpos != m_minpos); |
36 } | 36 } |
37 | 37 |
38 int | 38 int |
39 LinearRangeMapper::getPositionForValue(float value) const | 39 LinearRangeMapper::getPositionForValue(double value) const |
40 { | 40 { |
41 int position = getPositionForValueUnclamped(value); | 41 int position = getPositionForValueUnclamped(value); |
42 if (position < m_minpos) position = m_minpos; | 42 if (position < m_minpos) position = m_minpos; |
43 if (position > m_maxpos) position = m_maxpos; | 43 if (position > m_maxpos) position = m_maxpos; |
44 return position; | 44 return position; |
45 } | 45 } |
46 | 46 |
47 int | 47 int |
48 LinearRangeMapper::getPositionForValueUnclamped(float value) const | 48 LinearRangeMapper::getPositionForValueUnclamped(double value) const |
49 { | 49 { |
50 int position = m_minpos + | 50 int position = m_minpos + |
51 lrintf(((value - m_minval) / (m_maxval - m_minval)) | 51 int(lrint(((value - m_minval) / (m_maxval - m_minval)) |
52 * (m_maxpos - m_minpos)); | 52 * (m_maxpos - m_minpos))); |
53 if (m_inverted) return m_maxpos - (position - m_minpos); | 53 if (m_inverted) return m_maxpos - (position - m_minpos); |
54 else return position; | 54 else return position; |
55 } | 55 } |
56 | 56 |
57 float | 57 double |
58 LinearRangeMapper::getValueForPosition(int position) const | 58 LinearRangeMapper::getValueForPosition(int position) const |
59 { | 59 { |
60 if (position < m_minpos) position = m_minpos; | 60 if (position < m_minpos) position = m_minpos; |
61 if (position > m_maxpos) position = m_maxpos; | 61 if (position > m_maxpos) position = m_maxpos; |
62 float value = getValueForPositionUnclamped(position); | 62 double value = getValueForPositionUnclamped(position); |
63 return value; | 63 return value; |
64 } | 64 } |
65 | 65 |
66 float | 66 double |
67 LinearRangeMapper::getValueForPositionUnclamped(int position) const | 67 LinearRangeMapper::getValueForPositionUnclamped(int position) const |
68 { | 68 { |
69 if (m_inverted) position = m_maxpos - (position - m_minpos); | 69 if (m_inverted) position = m_maxpos - (position - m_minpos); |
70 float value = m_minval + | 70 double value = m_minval + |
71 ((float(position - m_minpos) / float(m_maxpos - m_minpos)) | 71 ((double(position - m_minpos) / double(m_maxpos - m_minpos)) |
72 * (m_maxval - m_minval)); | 72 * (m_maxval - m_minval)); |
73 return value; | 73 return value; |
74 } | 74 } |
75 | 75 |
76 LogRangeMapper::LogRangeMapper(int minpos, int maxpos, | 76 LogRangeMapper::LogRangeMapper(int minpos, int maxpos, |
77 float minval, float maxval, | 77 double minval, double maxval, |
78 QString unit, bool inverted) : | 78 QString unit, bool inverted) : |
79 m_minpos(minpos), | 79 m_minpos(minpos), |
80 m_maxpos(maxpos), | 80 m_maxpos(maxpos), |
81 m_unit(unit), | 81 m_unit(unit), |
82 m_inverted(inverted) | 82 m_inverted(inverted) |
95 // cerr << "LogRangeMapper: maxlog = " << m_maxlog << endl; | 95 // cerr << "LogRangeMapper: maxlog = " << m_maxlog << endl; |
96 } | 96 } |
97 | 97 |
98 void | 98 void |
99 LogRangeMapper::convertMinMax(int minpos, int maxpos, | 99 LogRangeMapper::convertMinMax(int minpos, int maxpos, |
100 float minval, float maxval, | 100 double minval, double maxval, |
101 float &minlog, float &ratio) | 101 double &minlog, double &ratio) |
102 { | 102 { |
103 static float thresh = powf(10, -10); | 103 static double thresh = powf(10, -10); |
104 if (minval < thresh) minval = thresh; | 104 if (minval < thresh) minval = thresh; |
105 minlog = log10f(minval); | 105 minlog = log10(minval); |
106 ratio = (maxpos - minpos) / (log10f(maxval) - minlog); | 106 ratio = (maxpos - minpos) / (log10(maxval) - minlog); |
107 } | 107 } |
108 | 108 |
109 void | 109 void |
110 LogRangeMapper::convertRatioMinLog(float ratio, float minlog, | 110 LogRangeMapper::convertRatioMinLog(double ratio, double minlog, |
111 int minpos, int maxpos, | 111 int minpos, int maxpos, |
112 float &minval, float &maxval) | 112 double &minval, double &maxval) |
113 { | 113 { |
114 minval = powf(10, minlog); | 114 minval = pow(10, minlog); |
115 maxval = powf(10, (maxpos - minpos) / ratio + minlog); | 115 maxval = pow(10, (maxpos - minpos) / ratio + minlog); |
116 } | 116 } |
117 | 117 |
118 int | 118 int |
119 LogRangeMapper::getPositionForValue(float value) const | 119 LogRangeMapper::getPositionForValue(double value) const |
120 { | 120 { |
121 int position = getPositionForValueUnclamped(value); | 121 int position = getPositionForValueUnclamped(value); |
122 if (position < m_minpos) position = m_minpos; | 122 if (position < m_minpos) position = m_minpos; |
123 if (position > m_maxpos) position = m_maxpos; | 123 if (position > m_maxpos) position = m_maxpos; |
124 return position; | 124 return position; |
125 } | 125 } |
126 | 126 |
127 int | 127 int |
128 LogRangeMapper::getPositionForValueUnclamped(float value) const | 128 LogRangeMapper::getPositionForValueUnclamped(double value) const |
129 { | 129 { |
130 static float thresh = powf(10, -10); | 130 static double thresh = pow(10, -10); |
131 if (value < thresh) value = thresh; | 131 if (value < thresh) value = thresh; |
132 int position = lrintf((log10(value) - m_minlog) * m_ratio) + m_minpos; | 132 int position = int(lrint((log10(value) - m_minlog) * m_ratio)) + m_minpos; |
133 if (m_inverted) return m_maxpos - (position - m_minpos); | 133 if (m_inverted) return m_maxpos - (position - m_minpos); |
134 else return position; | 134 else return position; |
135 } | 135 } |
136 | 136 |
137 float | 137 double |
138 LogRangeMapper::getValueForPosition(int position) const | 138 LogRangeMapper::getValueForPosition(int position) const |
139 { | 139 { |
140 if (position < m_minpos) position = m_minpos; | 140 if (position < m_minpos) position = m_minpos; |
141 if (position > m_maxpos) position = m_maxpos; | 141 if (position > m_maxpos) position = m_maxpos; |
142 float value = getValueForPositionUnclamped(position); | 142 double value = getValueForPositionUnclamped(position); |
143 return value; | 143 return value; |
144 } | 144 } |
145 | 145 |
146 float | 146 double |
147 LogRangeMapper::getValueForPositionUnclamped(int position) const | 147 LogRangeMapper::getValueForPositionUnclamped(int position) const |
148 { | 148 { |
149 if (m_inverted) position = m_maxpos - (position - m_minpos); | 149 if (m_inverted) position = m_maxpos - (position - m_minpos); |
150 float value = powf(10, (position - m_minpos) / m_ratio + m_minlog); | 150 double value = pow(10, (position - m_minpos) / m_ratio + m_minlog); |
151 return value; | 151 return value; |
152 } | 152 } |
153 | 153 |
154 InterpolatingRangeMapper::InterpolatingRangeMapper(CoordMap pointMappings, | 154 InterpolatingRangeMapper::InterpolatingRangeMapper(CoordMap pointMappings, |
155 QString unit) : | 155 QString unit) : |
161 m_reverse[i->second] = i->first; | 161 m_reverse[i->second] = i->first; |
162 } | 162 } |
163 } | 163 } |
164 | 164 |
165 int | 165 int |
166 InterpolatingRangeMapper::getPositionForValue(float value) const | 166 InterpolatingRangeMapper::getPositionForValue(double value) const |
167 { | 167 { |
168 int pos = getPositionForValueUnclamped(value); | 168 int pos = getPositionForValueUnclamped(value); |
169 CoordMap::const_iterator i = m_mappings.begin(); | 169 CoordMap::const_iterator i = m_mappings.begin(); |
170 if (pos < i->second) pos = i->second; | 170 if (pos < i->second) pos = i->second; |
171 i = m_mappings.end(); --i; | 171 i = m_mappings.end(); --i; |
172 if (pos > i->second) pos = i->second; | 172 if (pos > i->second) pos = i->second; |
173 return pos; | 173 return pos; |
174 } | 174 } |
175 | 175 |
176 int | 176 int |
177 InterpolatingRangeMapper::getPositionForValueUnclamped(float value) const | 177 InterpolatingRangeMapper::getPositionForValueUnclamped(double value) const |
178 { | 178 { |
179 float p = interpolate(&m_mappings, value); | 179 double p = interpolate(&m_mappings, value); |
180 return lrintf(p); | 180 return int(lrint(p)); |
181 } | 181 } |
182 | 182 |
183 float | 183 double |
184 InterpolatingRangeMapper::getValueForPosition(int position) const | 184 InterpolatingRangeMapper::getValueForPosition(int position) const |
185 { | 185 { |
186 float val = getValueForPositionUnclamped(position); | 186 double val = getValueForPositionUnclamped(position); |
187 CoordMap::const_iterator i = m_mappings.begin(); | 187 CoordMap::const_iterator i = m_mappings.begin(); |
188 if (val < i->first) val = i->first; | 188 if (val < i->first) val = i->first; |
189 i = m_mappings.end(); --i; | 189 i = m_mappings.end(); --i; |
190 if (val > i->first) val = i->first; | 190 if (val > i->first) val = i->first; |
191 return val; | 191 return val; |
192 } | 192 } |
193 | 193 |
194 float | 194 double |
195 InterpolatingRangeMapper::getValueForPositionUnclamped(int position) const | 195 InterpolatingRangeMapper::getValueForPositionUnclamped(int position) const |
196 { | 196 { |
197 return interpolate(&m_reverse, position); | 197 return interpolate(&m_reverse, position); |
198 } | 198 } |
199 | 199 |
200 template <typename T> | 200 template <typename T> |
201 float | 201 double |
202 InterpolatingRangeMapper::interpolate(T *mapping, float value) const | 202 InterpolatingRangeMapper::interpolate(T *mapping, double value) const |
203 { | 203 { |
204 // lower_bound: first element which does not compare less than value | 204 // lower_bound: first element which does not compare less than value |
205 typename T::const_iterator i = mapping->lower_bound(value); | 205 typename T::const_iterator i = |
206 mapping->lower_bound(typename T::key_type(value)); | |
206 | 207 |
207 if (i == mapping->begin()) { | 208 if (i == mapping->begin()) { |
208 // value is less than or equal to first element, so use the | 209 // value is less than or equal to first element, so use the |
209 // gradient from first to second and extend it | 210 // gradient from first to second and extend it |
210 ++i; | 211 ++i; |
217 } | 218 } |
218 | 219 |
219 typename T::const_iterator j = i; | 220 typename T::const_iterator j = i; |
220 --j; | 221 --j; |
221 | 222 |
222 float gradient = float(i->second - j->second) / float(i->first - j->first); | 223 double gradient = double(i->second - j->second) / double(i->first - j->first); |
223 | 224 |
224 return j->second + (value - j->first) * gradient; | 225 return j->second + (value - j->first) * gradient; |
225 } | 226 } |
226 | 227 |
227 AutoRangeMapper::AutoRangeMapper(CoordMap pointMappings, | 228 AutoRangeMapper::AutoRangeMapper(CoordMap pointMappings, |
314 | 315 |
315 return Interpolating; | 316 return Interpolating; |
316 } | 317 } |
317 | 318 |
318 int | 319 int |
319 AutoRangeMapper::getPositionForValue(float value) const | 320 AutoRangeMapper::getPositionForValue(double value) const |
320 { | 321 { |
321 return m_mapper->getPositionForValue(value); | 322 return m_mapper->getPositionForValue(value); |
322 } | 323 } |
323 | 324 |
324 float | 325 double |
325 AutoRangeMapper::getValueForPosition(int position) const | 326 AutoRangeMapper::getValueForPosition(int position) const |
326 { | 327 { |
327 return m_mapper->getValueForPosition(position); | 328 return m_mapper->getValueForPosition(position); |
328 } | 329 } |
329 | 330 |
330 int | 331 int |
331 AutoRangeMapper::getPositionForValueUnclamped(float value) const | 332 AutoRangeMapper::getPositionForValueUnclamped(double value) const |
332 { | 333 { |
333 return m_mapper->getPositionForValueUnclamped(value); | 334 return m_mapper->getPositionForValueUnclamped(value); |
334 } | 335 } |
335 | 336 |
336 float | 337 double |
337 AutoRangeMapper::getValueForPositionUnclamped(int position) const | 338 AutoRangeMapper::getValueForPositionUnclamped(int position) const |
338 { | 339 { |
339 return m_mapper->getValueForPositionUnclamped(position); | 340 return m_mapper->getValueForPositionUnclamped(position); |
340 } | 341 } |