← Back to branch summary

~paparazzi-uav/paparazzi/v5.0-manual

« back to all changes in this revision

Viewing changes to sw/ext/opencv_bebop/opencv/3rdparty/openexr/Half/halfFunction.h

  • Committer: Paparazzi buildbot
  • Date: 2016-05-18 15:00:29 UTC
  • Revision ID: felix.ruess+docbot@gmail.com-20160518150029-e8lgzi5kvb4p7un9
Manual import commit 4b8bbb730080dac23cf816b98908dacfabe2a8ec from v5.0 branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sw/ext/opencv_bebop/opencv/3rdparty/openexr/Half/halfFunction.h
 
1
///////////////////////////////////////////////////////////////////////////
 
2
//
 
3
// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
 
4
// Digital Ltd. LLC
 
5
//
 
6
// All rights reserved.
 
7
//
 
8
// Redistribution and use in source and binary forms, with or without
 
9
// modification, are permitted provided that the following conditions are
 
10
// met:
 
11
// *       Redistributions of source code must retain the above copyright
 
12
// notice, this list of conditions and the following disclaimer.
 
13
// *       Redistributions in binary form must reproduce the above
 
14
// copyright notice, this list of conditions and the following disclaimer
 
15
// in the documentation and/or other materials provided with the
 
16
// distribution.
 
17
// *       Neither the name of Industrial Light & Magic nor the names of
 
18
// its contributors may be used to endorse or promote products derived
 
19
// from this software without specific prior written permission.
 
20
//
 
21
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
22
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
23
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
24
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
25
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
26
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
27
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
28
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
29
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
30
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
31
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
32
//
 
33
///////////////////////////////////////////////////////////////////////////
 
34
 
 
35
// Primary authors:
 
36
//     Florian Kainz <kainz@ilm.com>
 
37
//     Rod Bogart <rgb@ilm.com>
 
38
 
 
39
 
 
40
//---------------------------------------------------------------------------
 
41
//
 
42
//      halfFunction<T> -- a class for fast evaluation
 
43
//                         of half --> T functions
 
44
//
 
45
//      The constructor for a halfFunction object,
 
46
//
 
47
//          halfFunction (function,
 
48
//                        domainMin, domainMax,
 
49
//                        defaultValue,
 
50
//                        posInfValue, negInfValue,
 
51
//                        nanValue);
 
52
//
 
53
//      evaluates the function for all finite half values in the interval
 
54
//      [domainMin, domainMax], and stores the results in a lookup table.
 
55
//      For finite half values that are not in [domainMin, domainMax], the
 
56
//      constructor stores defaultValue in the table.  For positive infinity,
 
57
//      negative infinity and NANs, posInfValue, negInfValue and nanValue
 
58
//      are stored in the table.
 
59
//
 
60
//      The tabulated function can then be evaluated quickly for arbitrary
 
61
//      half values by calling the the halfFunction object's operator()
 
62
//      method.
 
63
//
 
64
//      Example:
 
65
//
 
66
//          #include <math.h>
 
67
//          #include <halfFunction.h>
 
68
//
 
69
//          halfFunction<half> hsin (sin);
 
70
//
 
71
//          halfFunction<half> hsqrt (sqrt,             // function
 
72
//                                    0, HALF_MAX,      // domain
 
73
//                                    half::qNan(),     // sqrt(x) for x < 0
 
74
//                                    half::posInf(),   // sqrt(+inf)
 
75
//                                    half::qNan(),     // sqrt(-inf)
 
76
//                                    half::qNan());    // sqrt(nan)
 
77
//
 
78
//          half x = hsin (1);
 
79
//          half y = hsqrt (3.5);
 
80
//
 
81
//---------------------------------------------------------------------------
 
82
 
 
83
#ifndef _HALF_FUNCTION_H_
 
84
#define _HALF_FUNCTION_H_
 
85
 
 
86
#include "half.h"
 
87
 
 
88
#include <IlmBaseConfig.h>
 
89
#ifndef ILMBASE_HAVE_LARGE_STACK
 
90
#include <string.h>     // need this for memset
 
91
#else
 
92
#endif
 
93
 
 
94
#include <float.h>
 
95
 
 
96
 
 
97
template <class T>
 
98
class halfFunction
 
99
{
 
100
  public:
 
101
 
 
102
    //------------
 
103
    // Constructor
 
104
    //------------
 
105
 
 
106
    template <class Function>
 
107
    halfFunction (Function f,
 
108
          half domainMin = -HALF_MAX,
 
109
          half domainMax =  HALF_MAX,
 
110
          T defaultValue = 0,
 
111
          T posInfValue  = 0,
 
112
          T negInfValue  = 0,
 
113
          T nanValue     = 0);
 
114
 
 
115
#ifndef ILMBASE_HAVE_LARGE_STACK
 
116
    ~halfFunction () { delete [] _lut; }
 
117
#endif
 
118
 
 
119
    //-----------
 
120
    // Evaluation
 
121
    //-----------
 
122
 
 
123
    T           operator () (half x) const;
 
124
 
 
125
  private:
 
126
#ifdef ILMBASE_HAVE_LARGE_STACK
 
127
    T           _lut[1 << 16];
 
128
#else
 
129
    T *         _lut;
 
130
#endif
 
131
};
 
132
 
 
133
 
 
134
//---------------
 
135
// Implementation
 
136
//---------------
 
137
 
 
138
template <class T>
 
139
template <class Function>
 
140
halfFunction<T>::halfFunction (Function f,
 
141
                   half domainMin,
 
142
                   half domainMax,
 
143
                   T defaultValue,
 
144
                   T posInfValue,
 
145
                   T negInfValue,
 
146
                   T nanValue)
 
147
{
 
148
#ifndef ILMBASE_HAVE_LARGE_STACK
 
149
    _lut = new T[1<<16];
 
150
    memset (_lut, 0 , (1<<16) * sizeof(T));
 
151
#endif
 
152
 
 
153
    for (int i = 0; i < (1 << 16); i++)
 
154
    {
 
155
    half x;
 
156
    x.setBits (i);
 
157
 
 
158
    if (x.isNan())
 
159
        _lut[i] = nanValue;
 
160
    else if (x.isInfinity())
 
161
        _lut[i] = x.isNegative()? negInfValue: posInfValue;
 
162
    else if (x < domainMin || x > domainMax)
 
163
        _lut[i] = defaultValue;
 
164
    else
 
165
        _lut[i] = f (x);
 
166
    }
 
167
}
 
168
 
 
169
 
 
170
template <class T>
 
171
inline T
 
172
halfFunction<T>::operator () (half x) const
 
173
{
 
174
    return _lut[x.bits()];
 
175
}
 
176
 
 
177
 
 
178
#endif