1/*****************************************************************************/
2// Copyright 2006 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_1d_function.h#1 $ */
10/* $DateTime: 2012/05/30 13:28:51 $ */
11/* $Change: 832332 $ */
12/* $Author: tknoll $ */
13
14/** \file
15 * Classes for a 1D floating-point to floating-point function abstraction.
16 */
17
18/*****************************************************************************/
19
20#ifndef __dng_1d_function__
21#define __dng_1d_function__
22
23/*****************************************************************************/
24
25#include "dng_classes.h"
26#include "dng_types.h"
27
28/*****************************************************************************/
29
30/// \brief A 1D floating-point function.
31///
32/// The domain (input) is always from 0.0 to 1.0, while the range (output) can be an arbitrary interval.
33
34class dng_1d_function
35 {
36
37 public:
38
39 virtual ~dng_1d_function ();
40
41 /// Returns true if this function is the map x -> y such that x == y for all x . That is if Evaluate(x) == x for all x.
42
43 virtual bool IsIdentity () const;
44
45 /// Return the mapping for value x.
46 /// This method must be implemented by a derived class of dng_1d_function and the derived class determines the
47 /// lookup method and function used.
48 /// \param x A value between 0.0 and 1.0 (inclusive).
49 /// \retval Mapped value for x
50
51 virtual real64 Evaluate (real64 x) const = 0;
52
53 /// Return the reverse mapped value for y.
54 /// This method can be implemented by derived classes. The default implementation uses Newton's method to solve
55 /// for x such that Evaluate(x) == y.
56 /// \param y A value to reverse map. Should be within the range of the function implemented by this dng_1d_function .
57 /// \retval A value x such that Evaluate(x) == y (to very close approximation).
58
59 virtual real64 EvaluateInverse (real64 y) const;
60
61 };
62
63/*****************************************************************************/
64
65/// An identity (x -> y such that x == y for all x) mapping function.
66
67class dng_1d_identity: public dng_1d_function
68 {
69
70 public:
71 /// Always returns true for this class.
72
73 virtual bool IsIdentity () const;
74
75 /// Always returns x for this class.
76
77 virtual real64 Evaluate (real64 x) const;
78
79 /// Always returns y for this class.
80
81 virtual real64 EvaluateInverse (real64 y) const;
82
83 /// This class is a singleton, and is entirely threadsafe. Use this method to get an instance of the class.
84
85 static const dng_1d_function & Get ();
86
87 };
88
89/*****************************************************************************/
90
91/// A dng_1d_function that represents the composition (curry) of two other dng_1d_functions.
92
93class dng_1d_concatenate: public dng_1d_function
94 {
95
96 protected:
97
98 const dng_1d_function &fFunction1;
99
100 const dng_1d_function &fFunction2;
101
102 public:
103
104 /// Create a dng_1d_function which computes y = function2.Evaluate(function1.Evaluate(x)).
105 /// Compose function1 and function2 to compute y = function2.Evaluate(function1.Evaluate(x)). The range of function1.Evaluate must be a subset of 0.0 to 1.0 inclusive,
106 /// otherwise the result of function1(x) will be pinned (clipped) to 0.0 if <0.0 and to 1.0 if > 1.0 .
107 /// \param function1 Inner function of composition.
108 /// \param function2 Outer function of composition.
109
110 dng_1d_concatenate (const dng_1d_function &function1,
111 const dng_1d_function &function2);
112
113 /// Only true if both function1 and function2 have IsIdentity equal to true.
114
115 virtual bool IsIdentity () const;
116
117 /// Return the composed mapping for value x.
118 /// \param x A value between 0.0 and 1.0 (inclusive).
119 /// \retval function2.Evaluate(function1.Evaluate(x)).
120
121 virtual real64 Evaluate (real64 x) const;
122
123 /// Return the reverse mapped value for y.
124 /// Be careful using this method with compositions where the inner function does not have a range 0.0 to 1.0 . (Or better yet, do not use such functions.)
125 /// \param y A value to reverse map. Should be within the range of function2.Evaluate.
126 /// \retval A value x such that function2.Evaluate(function1.Evaluate(x)) == y (to very close approximation).
127
128 virtual real64 EvaluateInverse (real64 y) const;
129
130 };
131
132/*****************************************************************************/
133
134/// A dng_1d_function that represents the inverse of another dng_1d_function.
135
136class dng_1d_inverse: public dng_1d_function
137 {
138
139 protected:
140
141 const dng_1d_function &fFunction;
142
143 public:
144
145 dng_1d_inverse (const dng_1d_function &f);
146
147 virtual bool IsIdentity () const;
148
149 virtual real64 Evaluate (real64 x) const;
150
151 virtual real64 EvaluateInverse (real64 y) const;
152
153 };
154
155/*****************************************************************************/
156
157#endif
158
159/*****************************************************************************/
160