Frapper  1.0a
core/Helper.h
Go to the documentation of this file.
1 // Toolbox with helper classes
2 #define _USE_MATH_DEFINES 1
3 #include <malloc.h>
4 #include <math.h>
5 #include <iostream>
6 #include <string>
7 #include <fstream>
8 #include <vector>
9 #include <map>
10 #include <algorithm>
11 #include <sstream>
12 #include <time.h>
13 #include <QtCore/QList>
14 #include <Key.h>
15 
16 #ifndef HELPER_H
17 #define HELPER_H
18 
19 // defines
20 #define LINEAR_INTERPOLATE(A,B,mPCAlpha) A+mPCAlpha*(B-A)
21 #define CLAMP_LOWER(A,B) if(A<B) A=B;
22 #define CLAMP_UPPER(A,B) if(A>B) A=B;
23 #define CLAMP(A, Lo, Hi) A=(A<Lo)?Lo:(A>Hi)?Hi:A;
24 
25 namespace Frapper {
26 
27 class Helpers
28 {
29 public:
30  class InterpolationH
31  {
32  public:
33  static inline float Linear(float y1, float y2, unsigned int pos, unsigned int steps)
34  {
35  register float mu = (float) pos / (float) steps;
36  return y1*(1.0-mu) + y2*mu;
37  }
38 
39  static inline float Linear(float y1, float y2, float mu)
40  {
41  return y1*(1.0-mu) + y2*mu;
42  }
43 
44  static inline float Cosine(float y1, float y2, unsigned int pos, unsigned int steps)
45  {
46  register float mu = (float) pos / (float) steps;
47  register float mu2 = (1-cos(mu*M_PI))/2;
48  return (y1*(1-mu2)+y2*mu2);
49  }
50 
51  static inline float Cosine(float y1, float y2, float mu)
52  {
53  register float mu2 = (1-cos(mu*M_PI))/2;
54  return (y1*(1-mu2)+y2*mu2);
55  }
56 
57  static inline float Cubic(float y1, float y2, float y3, float y4, float pos)
58  {
59  register float p = (y4-y3) - (y1-y2);
60  register float q = (y1-y2) - p;
61  register float r = y3 - y1;
62  register float s = y2;
63 
64  return p*pow(pos, 3.0f) + q*pow(pos, 2.0f) + r*pos + s;
65  }
66 
67  static inline void InterpolTo(std::vector<float> &v, unsigned int length)
68  {
69  unsigned int i_pos1, i_pos2;
70  register float scale, pos;
71 
72  i_pos1 = i_pos2 = 0;
73  scale = (float) (v.size()-1) / (length-1);
74  std::vector<float> newdata(length);
75  for (unsigned int i=0; i<length-1; ++i)
76  {
77  i_pos2 = ceil(i * scale);
78  if (i_pos2 == i_pos1+2)
79  i_pos1 = i_pos2-1;
80  pos = (i * scale) - (i_pos1);
81  newdata[i] = Helpers::InterpolationH::Linear(v[i_pos1], v[i_pos2], pos);
82  }
83  newdata[newdata.size()-1] = v[v.size()-1];
84  v = newdata;
85  }
86  };
87 
88  class AnalysisH
89  {
90  public:
91  template <class T>
92  static inline std::vector<T> ComputeDistance(std::vector<T> &v1, std::vector<T> &v2)
93  {
94  int i_pos1, i_pos2;
95  register T pos, newdata, scale;
96  i_pos1 = i_pos2 = 0;
97  const unsigned int v1_size = v1.size();
98  const unsigned int v2_size = v2.size();
99 
100  if (v1_size == v2_size)
101  {
102  std::vector<T> returnvalue(v1_size);
103  for (unsigned int i = 0; i < v1_size; ++i)
104  {
105  returnvalue[i] = abs(v1[i] - v2[i]);
106  }
107  return returnvalue;
108  }
109  else if (v1_size > v2_size)
110  {
111  scale = ((T) v2_size-1) / (v1_size-1);
112  std::vector<T> returnvalue(v1_size);
113  for (unsigned int i = 0; i < v1_size-1; ++i)
114  {
115  i_pos2 = ceil(i * scale);
116  if (i_pos2 == i_pos1+2)
117  i_pos1 = i_pos2-1;
118  pos = (i * scale) - i_pos1;
119  newdata = Helpers::InterpolationH::Linear(v2[i_pos1], v2[i_pos2], pos);
120  returnvalue[i] = abs(v1[i]-newdata);
121  }
122  returnvalue[returnvalue.size()-1] = abs(v1[v1_size-1] - v2[v2_size-1]);
123  return returnvalue;
124  }
125  else
126  {
127  scale = ((T) v1_size-1) / (v2_size-1);
128  std::vector<T> returnvalue(v2_size);
129  for (unsigned int i = 0; i < v2_size-1; ++i)
130  {
131  i_pos2 = ceil(i * scale);
132  if (i_pos2 == i_pos1+2)
133  i_pos1 = i_pos2-1;
134  pos = (i * scale) - i_pos1;
135  newdata = Helpers::InterpolationH::Linear(v1[i_pos1], v1[i_pos2], pos);
136  returnvalue[i] = abs(v2[i]-newdata);
137  }
138  returnvalue[returnvalue.size()-1] = abs(v2[v2_size-1] - v1[v1_size-1]);
139  return returnvalue;
140  }
141  }
142 
143  static inline std::vector<float> SummVerctors(const std::vector<float> &v1, const std::vector<float> &v2, float div = 1)
144  {
145  int i_pos1, i_pos2;
146  register float pos, newdata, scale;
147  i_pos1 = i_pos2 = 0;
148  const unsigned int v1_size = (unsigned int) v1.size();
149  const unsigned int v2_size = (unsigned int) v2.size();
150 
151  if (v2_size==0)
152  return v1;
153 
154  if (v1_size == v2_size)
155  {
156  std::vector<float> returnvalue(v1_size);
157  for (unsigned int i = 0; i < v1_size; ++i)
158  returnvalue[i] = (v1[i] + v2[i])/div;
159  return returnvalue;
160  }
161  else if (v1_size > v2_size)
162  {
163  scale = ((float) v2_size-1) / (v1_size-1);
164  std::vector<float> returnvalue(v1_size);
165  for (unsigned int i = 0; i < v1_size-1; ++i)
166  {
167  i_pos2 = ceil(i * scale);
168  if (i_pos2 == i_pos1+2)
169  i_pos1 = i_pos2-1;
170  pos = (i * scale) - i_pos1;
171  newdata = Helpers::InterpolationH::Linear(v2[i_pos1], v2[i_pos2], pos);
172  returnvalue[i] = (v1[i] + newdata)/div;
173  }
174  returnvalue[returnvalue.size()-1] = (v1[v1_size-1] + v2[v2_size-1])/div;
175  return returnvalue;
176  }
177  else
178  {
179  scale = ((float) v1_size-1) / (v2_size-1);
180  std::vector<float> returnvalue(v2_size);
181  for (unsigned int i = 0; i < v2_size-1; ++i)
182  {
183  i_pos2 = ceil(i * scale);
184  if (i_pos2 == i_pos1+2)
185  i_pos1 = i_pos2-1;
186  pos = (i * scale) - i_pos1;
187  newdata = Helpers::InterpolationH::Linear(v1[i_pos1], v1[i_pos2], pos);
188  returnvalue[i] = (v2[i] + newdata)/div;
189  }
190  returnvalue[returnvalue.size()-1] = (v2[v2_size-1] + v1[v1_size-1])/div;
191  return returnvalue;
192  }
193  }
194 
195  template <class T>
196  static inline T MaxVectorAbs(const std::vector<T> &v)
197  {
198  T max, ab;
199  ab = abs(*std::min_element(v.begin(), v.end()));
200  max = abs(*std::max_element(v.begin(), v.end()));
201  if (ab>max)
202  return ab;
203  else
204  return max;
205  }
206 
207  static inline void UniformVector(std::vector<float> &v)
208  {
209  register float offset, max;
210  offset = v[0];
211  max = MaxVectorAbs(v);
212 
213  if (max == 0) max = 1;
214  v[0]=0;
215  for (unsigned int i=1;i<v.size();++i)
216  {
217  v[i] = (v[i] - offset) / max;
218  }
219  }
220 
221  static inline void UniformVector(std::vector<float> &v, float max)
222  {
223  register float offset;
224  offset = v[0];
225 
226  if (max == 0) max = 1;
227  v[0]=0;
228  for (unsigned int i=1;i<v.size();++i)
229  {
230  v[i] = (v[i] - offset) / max;
231  }
232  }
233 
234  template <class T>
235  static inline void NormalizeVector(std::vector<T> &v, float max)
236  {
237  if (max == 0.0f) max = 1;
238 
239  for (unsigned int i=0;i<v.size();++i)
240  v[i] /= max;
241  }
242 
243  template <class T>
244  static inline void NormalizeVector(std::vector<T> &v)
245  {
246  T max = MaxVectorAbs(v);
247  if (max == 0.0f) max = 1;
248 
249  for (unsigned int i=0;i<v.size();++i)
250  v[i] /= max;
251  }
252 
253  static inline float SpreadVector(std::vector<float> &v)
254  {
255  if (v.size()==1)
256  return v[0];
257  register float mean = SummVector(v);
258  register float returnvalue = 0.0f;
259  for (unsigned int i=1;i<v.size();++i)
260  returnvalue += pow((abs(v[i])-mean), 2.0f);
261  return sqrt(returnvalue/(v.size()-1));
262  }
263 
264  static inline float DistVector(const QList<float> &l1, const QList<float> &l2, const float &length = 1.0f)
265  {
266  register float returnvalue = 0.0f;
267  for (int i=0; i<l1.size(); ++i) {
268  returnvalue += pow( l1[i] - l2[i] / length, 2);
269  }
270  return /*2.0f -*/ sqrt(returnvalue);
271  }
272 
273  static inline float DistVector(const QList<float> &l1, const QList<float> &l2, const QList<float> &s1)
274  {
275  register float returnvalue = 0.0f;
276  for (int i=0; i<l1.size(); ++i) {
277  returnvalue += pow( (l1.at(i) - l2.at(i)) / s1.at(i) + 0.00001f, 2);
278  }
279  return /*2.0f -*/ sqrt(returnvalue);
280  }
281 
282  static inline float DistVectorWin(const QList<QList<float>> &l1, const QList<QList<float>> &l2, const QList<QList<float>> &s1)
283  {
284  const int l1Size = l1.size();
285  float returnvalue = 0.0f;
286  for (int w=0; w<l1Size; ++w) {
287  register float value = 0.0f;
288  const QList<float> &l1w = l1.at(w);
289  const QList<float> &l2w = l2.at(w);
290  const QList<float> &s1w = s1.at(w);
291  for (int i=0; i<l1w.size(); ++i) {
292  value += pow( (l1w.at(i) - l2w.at(i)) / s1w.at(i) + 0.00001f, 2);
293  }
294  returnvalue += sqrt(value);
295  }
296  return returnvalue / l1Size;
297  }
298 
299  // if l1 == l2 returnvalue = 1
300  static inline float AngleVector(const QList<Key *> *l1, const QList<float> *l2, const float &length = 1.0f)
301  {
302  register float returnvalue = 0.0f;
303  if (length > 0) {
304  for (int i=0; i<(*l1).size(); ++i)
305  returnvalue += (*l1)[i]->getValue().toDouble() * ((*l2)[i] / length);
306  }
307  return (returnvalue/2.0f) + 0.5f;
308  }
309 
310  //if l1 == l2 returnvalue = 1
311  /*static inline float AngleVector(const QList<Key *> *l1, const QList<float> *l2, const float &length)
312  {
313  register float returnvalue = 0.0f;
314  if (length > 0) {
315  for (int i=0; i<(*l1).size(); ++i) {
316  register const float keyValue = (*l1)[i]->getValue().toDouble();
317  register const float auValue = (*l2)[i] / length;
318  if (!sameSign(keyValue, auValue))
319  continue;
320  returnvalue += keyValue * auValue;
321  }
322  returnvalue = (returnvalue/2.0f) + 0.5f;
323  }
324  return returnvalue;
325  }*/
326 
327  static inline float DiceCoefficient(const QList<Key *> *l1, const QList<float> *l2, const float &length)
328  {
329  register float returnvalue, div;
330  returnvalue = div = 0.0f;
331  for (int i=0; i<(*l1).size(); ++i) {
332  div += (*l1)[i]->getValue().toDouble() + (*l2)[i] / length;
333  returnvalue += (*l1)[i]->getValue().toDouble() * ((*l2)[i] / length);
334  }
335  return 2.0f*returnvalue/div;
336  }
337 
338  static inline float LengthVector(QList<float> *l)
339  {
340  register float returnvalue = 0.0f;
341  foreach (float elem, *l)
342  returnvalue += pow(elem, 2.0f);
343  return sqrt(returnvalue);
344  }
345 
346  static inline void NormalizeVectorLength(QList<float> *l)
347  {
348  register float length = LengthVector(l);
349  if (length == 0.0f)
350  return;
351 
352  for (int i = 0; i < l->size(); ++i)
353  (*l)[i] = (*l)[i] / length;
354  }
355 
356  static inline void NormalizeVectorLength(QList<float> *l, float &length)
357  {
358  if (length == 0.0f)
359  return;
360  for (int i = 0; i < l->size(); ++i)
361  (*l)[i] = (*l)[i] / length;
362  }
363 
364  static inline float LengthVector(QList<Key *> *l)
365  {
366  register float returnvalue = 0.0f;
367  foreach (Key *elem, *l)
368  returnvalue += pow(elem->getValue().toDouble(), 2);
369  return sqrt(returnvalue);
370  }
371 
372  static inline void NormalizeVectorLength(QList<Key *> *l)
373  {
374  register float length = LengthVector(l);
375  if (length == 0.0)
376  return;
377 
378  foreach (Key *key, *l)
379  key->setValue(key->getValue().toDouble() / length);
380  }
381 
382  static inline void NormalizeVectorLength(QList<Key *> *l, float &length)
383  {
384  foreach (Key *key, *l)
385  key->setValue(key->getValue().toDouble() / length);
386  }
387 
388  static inline float SummVector(std::vector<float> &v)
389  {
390  register float returnvalue = v[0];
391  for (unsigned int i=1;i<v.size();++i)
392  returnvalue += abs(v[i]);
393  return returnvalue/v.size();
394  }
395 
396  template<class T>
397  static inline bool sameSign(T &a, T &b)
398  {
399  return (a < 0) == (b < 0);
400  }
401  };
402 
403  class StringH
404  {
405  public:
406  static inline std::string FloatToString(const float &input)
407  {
408  std::stringstream str;
409  str << input;
410 
411  return str.str();
412  }
413 
414  static inline int Find_Chr(const std::string &ref, const std::string &search, int nbr, const int pos)
415  {
416  if (nbr == 0)
417  return pos;
418  else
419  {
420  --nbr;
421  return Find_Chr(ref, search, nbr, (int) ref.find(search, pos+1));
422  }
423  } const
424 
425  static inline int FindNbrChrs(std::string str, std::string set)
426  {
427  register int returnvalue = 0;
428  for (unsigned int i=0; i<str.length(); ++i)
429  {
430  if (std::binary_search(set.begin(), set.end(), str[i]))
431  ++returnvalue;
432  }
433  return returnvalue;
434  }
435  };
436 
437  class MathH
438  {
439  public:
440  static inline int GetSign(float const &n)
441  {
442  if (n>0) return 1;
443  else return -1;
444  }
445 
446  static inline int NextPow2(int Number)
447  {
448  unsigned int RetVal = 1;
449  __asm
450  {
451  xor ecx, ecx
452  bsr ecx, Number
453  inc ecx
454  shl RetVal, cl
455  }
456  return(RetVal);
457  }
458 
459  static inline int DoubleToInt(double d)
460  {
461  return d<0?d-.5:d+.5;
462  }
463 
464  static inline double Round(double Zahl, int Stellen)
465  {
466  double v[] = { 1, 10, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8 };
467  return floor(Zahl * v[Stellen] + 0.5) / v[Stellen];
468  }
469  };
470  class TimeH
471  {
472  public:
473  static inline char* GetSysTime()
474  {
475  time_t rawtime;
476  time ( &rawtime );
477 
478  return ctime(&rawtime);
479  }
480  };
481 };
482 
483 } // end namespace Frapper
484 
485 #endif
Generated on Tue Sep 18 2012 11:43:02 for Frapper by   doxygen 1.8.2