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

#include "dng_1d_function.h"

#include "dng_assertions.h"
#include "dng_stream.h"
#include "dng_utils.h"

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

dng_1d_function::~dng_1d_function ()
	{
	
	}

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

bool dng_1d_function::IsIdentity () const
	{
	
	return false;
	
	}

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

real64 dng_1d_function::EvaluateInverse (real64 y) const
	{
	
	const uint32 kMaxIterations = 30;
	const real64 kNearZero		= 1.0e-10;
	
	real64 x0 = 0.0;
	real64 y0 = Evaluate (x0);
	
	real64 x1 = 1.0;
	real64 y1 = Evaluate (x1);
	
	for (uint32 iteration = 0; iteration < kMaxIterations; iteration++)		
		{
		
		if (Abs_real64 (y1 - y0) < kNearZero)
			{
			break;
			}
		
		real64 x2 = Pin_real64 (0.0, 
								x1 + (y - y1) * (x1 - x0) / (y1 - y0),
								1.0);
		
		real64 y2 = Evaluate (x2);
		
		x0 = x1;
		y0 = y1;
		
		x1 = x2;
		y1 = y2;
		
		}
	
	return x1;
	
	}
	
/*****************************************************************************/

bool dng_1d_identity::IsIdentity () const
	{
	
	return true;
	
	}
		
/*****************************************************************************/

real64 dng_1d_identity::Evaluate (real64 x) const
	{
	
	return x;
	
	}
		
/*****************************************************************************/

real64 dng_1d_identity::EvaluateInverse (real64 x) const
	{
	
	return x;
	
	}
		
/*****************************************************************************/

const dng_1d_function & dng_1d_identity::Get ()
	{
	
	static dng_1d_identity static_function;
	
	return static_function;
	
	}

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

dng_1d_concatenate::dng_1d_concatenate (const dng_1d_function &function1,
										const dng_1d_function &function2)
										
	:	fFunction1 (function1)
	,	fFunction2 (function2)
	
	{
	
	}
	
/*****************************************************************************/

bool dng_1d_concatenate::IsIdentity () const
	{
	
	return fFunction1.IsIdentity () &&
		   fFunction2.IsIdentity ();
	
	}
		
/*****************************************************************************/

real64 dng_1d_concatenate::Evaluate (real64 x) const
	{
	
	real64 y = Pin_real64 (0.0, fFunction1.Evaluate (x), 1.0);
	
	return fFunction2.Evaluate (y);
	
	}

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

real64 dng_1d_concatenate::EvaluateInverse (real64 x) const
	{
	
	real64 y = fFunction2.EvaluateInverse (x);
	
	return fFunction1.EvaluateInverse (y);
	
	}
	
/*****************************************************************************/

dng_1d_inverse::dng_1d_inverse (const dng_1d_function &f)
	
	:	fFunction (f)
	
	{
	
	}
	
/*****************************************************************************/

bool dng_1d_inverse::IsIdentity () const
	{
	
	return fFunction.IsIdentity ();
	
	}
	
/*****************************************************************************/

real64 dng_1d_inverse::Evaluate (real64 x) const
	{
	
	return fFunction.EvaluateInverse (x);
	
	}

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

real64 dng_1d_inverse::EvaluateInverse (real64 y) const
	{
	
	return fFunction.Evaluate (y);
	
	}
	
/*****************************************************************************/

dng_piecewise_linear::dng_piecewise_linear ()

	:	X ()
	,	Y ()

	{

	}
	
/*****************************************************************************/

dng_piecewise_linear::~dng_piecewise_linear ()
	{

	}
	
/*****************************************************************************/

void dng_piecewise_linear::Reset ()
	{
	
	X.clear ();
	Y.clear ();
	
	}

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

void dng_piecewise_linear::Add (real64 x, real64 y)
	{
	
	X.push_back (x);
	Y.push_back (y);
	
	}

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

bool dng_piecewise_linear::IsIdentity () const
	{
	
	return (X.size () == 2					&&
			X.size () == Y.size ()			&&
			X [0] == 0.0 && Y [0] == 0.0	&&
			X [1] == 1.0 && Y [1] == 1.0);
		
	}

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

real64 dng_piecewise_linear::Evaluate (real64 x) const
	{

	DNG_ASSERT (X.size () >= 2, "Too few points.");

	DNG_ASSERT (X.size () == Y.size (), "Input/output vector size mismatch.");
	
	// Check for extremes.

	if (x <= X.front ())
		{
		return Y.front ();
		}

	else if (x >= X.back ())
		{
		return Y.back ();
		}

	// Binary search for the X index.
	
	int32 lower = 1;
	int32 upper = ((int32) (X.size ())) - 1;
	
	while (upper > lower)
		{
		
		int32 mid = (lower + upper) >> 1;
		
		if (x == X [mid]) return Y [mid];
			
		if (x > X [mid]) lower = mid + 1;

		else upper = mid;
		
		}
		
	DNG_ASSERT (upper == lower, "Binary search error in point list.");

	int32 index0 = lower - 1;
	int32 index1 = lower;

	real64 X0 = X [index0];
	real64 X1 = X [index1];

	real64 Y0 = Y [index0];
	real64 Y1 = Y [index1];

	if (X0 == X1) return 0.5 * (Y0 + Y1);

	real64 t = (x - X0) / (X1 - X0);

	return Y0 + t * (Y1 - Y0);

	}
		
/*****************************************************************************/

real64 dng_piecewise_linear::EvaluateInverse (real64 y) const
	{
	
	DNG_ASSERT (X.size () >= 2, "Too few points.");

	DNG_ASSERT (X.size () == Y.size (), "Input/output vector size mismatch.");
	
	// Binary search for the Y index.

	int32 lower = 1;
	int32 upper = ((int32) (Y.size ())) - 1;
	
	while (upper > lower)
		{
		
		int32 mid = (lower + upper) >> 1;
		
		if (y == Y [mid]) return X [mid];
			
		if (y > Y [mid]) lower = mid + 1;

		else upper = mid;
		
		}
		
	DNG_ASSERT (upper == lower, "Binary search error in point list.");

	int32 index0 = lower - 1;
	int32 index1 = lower;

	real64 X0 = X [index0];
	real64 X1 = X [index1];

	real64 Y0 = Y [index0];
	real64 Y1 = Y [index1];

	if (Y0 == Y1) return 0.5 * (X0 + X1);

	real64 t = (y - Y0) / (Y1 - Y0);

	return X0 + t * (X1 - X0);
	
	}

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

void dng_piecewise_linear::PutFingerprintData (dng_stream &stream) const
	{
	
	const char *name = "dng_piecewise_linear";

	stream.Put (name, (uint32) strlen (name));
	
	if (IsValid ())
		{

		for (size_t i = 0; i < X.size (); i++)
			{

			stream.Put_real64 (X [i]);
			stream.Put_real64 (Y [i]);

			}
	
		}
	
	}

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

bool dng_piecewise_linear::operator== (const dng_piecewise_linear &piecewise) const
	{
	
	return X == piecewise.X &&
		   Y == piecewise.Y;
	
	}

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