/*****************************************************************************/
// Copyright 2006-2019 Adobe Systems Incorporated
// All Rights Reserved.
//
// NOTICE:  Adobe permits you to use, modify, and distribute this file in
// accordance with the terms of the Adobe license agreement accompanying it.
/*****************************************************************************/

/** \file
 * Classes for a 1D floating-point to floating-point function abstraction.
 */

/*****************************************************************************/

#ifndef __dng_1d_function__
#define __dng_1d_function__

/*****************************************************************************/

#include "dng_classes.h"
#include "dng_types.h"

#include <vector>

/*****************************************************************************/

/// \brief A 1D floating-point function.
///
/// The domain (input) is always from 0.0 to 1.0, while the range (output) can
/// be an arbitrary interval.

class dng_1d_function
    {

    public:

        virtual ~dng_1d_function ();

        /// 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.

        virtual bool IsIdentity () const;

        /// Return the mapping for value x.
        /// This method must be implemented by a derived class of dng_1d_function and
        /// the derived class determines the lookup method and function used.
        /// \param x A value between 0.0 and 1.0 (inclusive).
        /// \retval Mapped value for x

        virtual real64 Evaluate (real64 x) const = 0;

        /// Return the reverse mapped value for y.
        /// This method can be implemented by derived classes. The default implementation
        /// uses Newton's method to solve for x such that Evaluate(x) == y.
        /// \param y A value to reverse map. Should be within the range of the function
        /// implemented by this dng_1d_function.
        /// \retval A value x such that Evaluate(x) == y (to very close approximation).

        virtual real64 EvaluateInverse (real64 y) const;

    };

/*****************************************************************************/

/// An identity (x -> y such that x == y for all x) mapping function.

class dng_1d_identity: public dng_1d_function
    {

    public:
        /// Always returns true for this class.

        virtual bool IsIdentity () const;

        /// Always returns x for this class.

        virtual real64 Evaluate (real64 x) const;

        /// Always returns y for this class.

        virtual real64 EvaluateInverse (real64 y) const;

        /// This class is a singleton, and is entirely threadsafe. Use this
        /// method to get an instance of the class.

        static const dng_1d_function & Get ();

    };

/*****************************************************************************/

/// A dng_1d_function that represents the composition (curry) of two other
/// dng_1d_functions.

class dng_1d_concatenate: public dng_1d_function
    {

    protected:

        const dng_1d_function &fFunction1;

        const dng_1d_function &fFunction2;

    public:

        /// Create a dng_1d_function which computes
        ///
        /// y = function2.Evaluate (function1.Evaluate (x))
        ///
        /// The range of function1.Evaluate must be a subset of 0.0 to 1.0 inclusive,
        /// otherwise the result of function1(x) will be pinned (clipped) to 0.0
        /// if < 0.0 and to 1.0 if > 1.0.
        ///
        /// \param function1 Inner function of composition.
        /// \param function2 Outer function of composition.

        dng_1d_concatenate (const dng_1d_function &function1,
                            const dng_1d_function &function2);

        /// Only true if both function1 and function2 have IsIdentity equal to true.

        virtual bool IsIdentity () const;

        /// Return the composed mapping for value x.
        /// \param x A value between 0.0 and 1.0 (inclusive).
        /// \retval function2.Evaluate(function1.Evaluate(x)).

        virtual real64 Evaluate (real64 x) const;

        /// Return the reverse mapped value for y.
        /// 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.)
        /// \param y A value to reverse map. Should be within the range of function2.Evaluate.
        /// \retval A value x such that function2.Evaluate(function1.Evaluate(x)) == y
        /// (to very close approximation).

        virtual real64 EvaluateInverse (real64 y) const;

    };

/*****************************************************************************/

/// A dng_1d_function that represents the inverse of another dng_1d_function.

class dng_1d_inverse: public dng_1d_function
    {

    protected:

        const dng_1d_function &fFunction;

    public:

        dng_1d_inverse (const dng_1d_function &f);

        virtual bool IsIdentity () const;

        virtual real64 Evaluate (real64 x) const;

        virtual real64 EvaluateInverse (real64 y) const;

    };

/*****************************************************************************/

// Piecewise-linear 1D function.

class dng_piecewise_linear: public dng_1d_function
    {

    public:

        std::vector<real64> X;
        std::vector<real64> Y;

    public:

        dng_piecewise_linear ();

        virtual ~dng_piecewise_linear ();

        void Reset ();

        void Add (real64 x, real64 y);

        bool IsValid () const
            {
            return (X.size () >= 2) && (X.size () == Y.size ());
            }

        bool NotValid () const
            {
            return !IsValid ();
            }

        virtual bool IsIdentity () const;

        virtual real64 Evaluate (real64 x) const;

        virtual real64 EvaluateInverse (real64 y) const;

        void PutFingerprintData (dng_stream &stream) const;

        bool operator== (const dng_piecewise_linear &piecewise) const;

        bool operator!= (const dng_piecewise_linear &piecewise) const
            {
            return !(*this == piecewise);
            }

    };

/*****************************************************************************/

#endif

/*****************************************************************************/
