xref: /external/dng_sdk/source/dng_1d_table.h

/*****************************************************************************/
// Copyright 2006-2008 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.
/*****************************************************************************/

/* $Id: //mondo/dng_sdk_1_4/dng_sdk/source/dng_1d_table.h#1 $ */
/* $DateTime: 2012/05/30 13:28:51 $ */
/* $Change: 832332 $ */
/* $Author: tknoll $ */

/** \file
 * Definition of a lookup table based 1D floating-point to floating-point function abstraction using linear interpolation.
 */

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

#ifndef __dng_1d_table__
#define __dng_1d_table__

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

#include "dng_assertions.h"
#include "dng_auto_ptr.h"
#include "dng_classes.h"
#include "dng_types.h"

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

/// \brief A 1D floating-point lookup table using linear interpolation.

class dng_1d_table
	{

	public:

		/// Constants denoting size of table.

		enum
			{
			kTableBits = 12,				//< Table is always a power of 2 in size. This is log2(kTableSize).
			kTableSize = (1 << kTableBits)	//< Number of entries in table.
			};

	protected:

		AutoPtr<dng_memory_block> fBuffer;

		real32 *fTable;

	public:

		dng_1d_table ();

		virtual ~dng_1d_table ();

		/// Set up table, initialize entries using functiion.
		/// This method can throw an exception, e.g. if there is not enough memory.
		/// \param allocator Memory allocator from which table memory is allocated.
		/// \param function Table is initialized with values of finction.Evalluate(0.0) to function.Evaluate(1.0).
		/// \param subSample If true, only sample the function a limited number of times and interpolate.

		void Initialize (dng_memory_allocator &allocator,
						 const dng_1d_function &function,
						 bool subSample = false);

		/// Lookup and interpolate mapping for an input.
		/// \param x value from 0.0 to 1.0 used as input for mapping
		/// \retval Approximation of function.Evaluate(x)

		real32 Interpolate (real32 x) const
			{

			real32 y = x * (real32) kTableSize;

			int32 index = (int32) y;

			if (index < 0 || index > kTableSize)
				{

				ThrowBadFormat("Index out of range.");

				}

			DNG_ASSERT (index >= 0 && index <= kTableSize,
						"dng_1d_table::Interpolate parameter out of range");

			real32 z = (real32) index;

			real32 fract = y - z;

			return fTable [index    ] * (1.0f - fract) +
				   fTable [index + 1] * (       fract);

			}

		/// Direct access function for table data.

		const real32 * Table () const
			{
			return fTable;
			}

		/// Expand the table to a 16-bit to 16-bit table.

		void Expand16 (uint16 *table16) const;

	private:

		void SubDivide (const dng_1d_function &function,
						uint32 lower,
						uint32 upper,
						real32 maxDelta);

		// Hidden copy constructor and assignment operator.

		dng_1d_table (const dng_1d_table &table);

		dng_1d_table & operator= (const dng_1d_table &table);

	};

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

#endif

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