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