LUT.h File Reference

#include <stdbool.h>
#include <stdint.h>

Include dependency graph for LUT.h:

Go to the source code of this file.

Classes
struct	point
struct	table

Macros
#define	TABLE_CAPACITY   64

Functions
int	point_compare (const void *a, const void *b)
	Compares two points by input. More...
bool	point_is_between (const point *min, const point *max, float in)
	Determines if the input value is between the input of two points. More...
bool	table_init (table *table, uint16_t count)
	Initializes the table. More...
bool	table_add_reference_point (table *table, float in, float out)
	Adds a reference point to the table. More...
bool	table_is_initialized (table *table)
	Checks if the table has been fully initialized, with all reference points added. More...
const point *	table_min_point (table *table)
	Retrieves the point in the table with the least input value. More...
const point *	table_max_point (table *table)
	Retrieves the point in the table with the greatest input value. More...
bool	table_can_sample (table *table, float in)
	Checks if the input input is valid for the table. More...
bool	table_sample (table *table, float in, float *out)
	Samples a output value from the table for an input value. More...

Macro Definition Documentation

TABLE_CAPACITY

#define TABLE_CAPACITY   64

Definition at line 36 of file LUT.h.

Function Documentation

point_compare()

int point_compare	(	const void *	a,
		const void *	b
	)

Compares two points by input.

Parameters

a	The first point to compare.
b	The second point to compare.

Returns

A negative integer if the first point is before the second point, zero if the first point is equal to the second point, or a positive integer if the first point is greater than the second point.

Definition at line 6 of file LUT.c.

                                                {
  const point *pa = a;
  const point *pb = b;
  if (pa->input < pb->input)
    return -1;
  if (pa->input > pb->input)
    return 1;
  return 0;
}

Here is the caller graph for this function:

point_is_between()

bool point_is_between	(	const point *	min,
		const point *	max,
		float	in
	)

Determines if the input value is between the input of two points.

Parameters

min	A point with an input less than the input of max.
max	A point with an input greater than the input of min.
in	An input value to test with the two points.

Returns

True if the input value is between the minimum input and maximum input.

Definition at line 16 of file LUT.c.

                                                                    {
  return min->input <= in && in <= max->input;
}

Here is the caller graph for this function:

table_add_reference_point()

bool table_add_reference_point	(	table *	table,
		float	in,
		float	out
	)

Adds a reference point to the table.

Parameters

table	A pointer to the table to add the point to.
in	The input ("from") value.
out	The output ("to") value at the input value.

Returns

True if the reference point was added to the table.

Definition at line 79 of file LUT.c.

                                                                  {
  if (table_is_initialized(table)) {
    return false;
  }
 
  // NOTE This may should not actually be necessary; the only way to get here is
  // if the table is not initialized already; there may be a lurking logic error
  table->initialized_ = false;
 
  table->points_[table->added_].input = in;
  table->points_[table->added_].output = out;
  table->added_++;
 
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

table_can_sample()

bool table_can_sample	(	table *	table,
		float	in
	)

Checks if the input input is valid for the table.

Parameters

table	A pointer to the table to check.
in	The input value to check.

Returns

True if the input value is valid for the table.

Definition at line 107 of file LUT.c.

                                              {
  const point *min = table_min_point(table);
  const point *max = table_max_point(table);
  return can_interpolate(min, max, in);
}

Here is the call graph for this function:

Here is the caller graph for this function:

table_init()

bool table_init	(	table *	table,
		uint16_t	count
	)

Initializes the table.

Parameters

table	A pointer to the table to initialize.
count	The number of reference points in the table.

Returns

True if the table was successfully initialized.

Definition at line 31 of file LUT.c.

                                              {
  if (table == NULL) {
    return false;
  }
 
  // Table must contain at least two reference points
  if (count < 2 || count > TABLE_CAPACITY) {
    return false;
  }
 
  // Set up table values to expected values
  table->count_ = count;
  table->added_ = 0;
  table->initialized_ = false;
  for (uint16_t n = 0; n < count; ++n) {
    table->points_[n].input = 0;
    table->points_[n].output = 0;
  }
 
  return true;
}

Here is the caller graph for this function:

table_is_initialized()

bool table_is_initialized

(

table *

table

)

Checks if the table has been fully initialized, with all reference points added.

Parameters

table

A pointer to the table to check.

Returns

True if the table has been fully initialized.

Definition at line 53 of file LUT.c.

                                        {
  // Nothing has invalidated the initialized state of the table
  if (table->initialized_) {
    return true;
  }
 
  bool all_reference_points = table->added_ == table->count_;
 
  if (!all_reference_points) {
    table->initialized_ = false;
    return table->initialized_;
  }
 
  bool sorted = true;
  const point *previous_point = &table->points_[0];
  for (uint16_t n = 1; n < table->count_; ++n) {
    const point *point = &table->points_[n];
    // Found a decrease, which violates table being sorted
    if (point->input < previous_point->input) {
      sorted = false;
    }
  }
  table->initialized_ = sorted;
  return table->initialized_;
}

Here is the caller graph for this function:

table_max_point()

const point * table_max_point

(

table *

table

)

Retrieves the point in the table with the greatest input value.

Parameters

table

A pointer to the table.

Returns

If there is a maximum point, a pointer to the maximum point, otherwise NULL.

Definition at line 101 of file LUT.c.

                                           {
  if (!table_is_initialized(table))
    return NULL;
  return &table->points_[table->count_ - 1];
}

Here is the call graph for this function:

Here is the caller graph for this function:

table_min_point()

const point * table_min_point

(

table *

table

)

Retrieves the point in the table with the least input value.

Parameters

table

A pointer to the table.

Returns

If there is a minimum point, a pointer to the minimum point, otherwise NULL.

Definition at line 95 of file LUT.c.

                                           {
  if (!table_is_initialized(table))
    return NULL;
  return &table->points_[0];
}

Here is the call graph for this function:

Here is the caller graph for this function:

table_sample()

bool table_sample	(	table *	table,
		float	in,
		float *	out
	)

Samples a output value from the table for an input value.

Parameters

table	A pointer to the table to sample.
in	The input value to sample.
out	A pointer to the destination of the output value.

Returns

True if the output value was written, otherwise false.

Definition at line 137 of file LUT.c.

                                                      {
  // This is where the constraint that the table contains at least two elements
  // is derived from
  const point *min = table_min_point(table);
  const point *max = table_max_point(table);
 
  // If can't interpolate between the endpoints, can't interpolate between
  // intermediate points
  if (!can_interpolate(min, max, in)) {
    return false;
  }
 
  if (in == min->input) {
    *out = min->output;
    return true;
  }
 
  if (in == max->input) {
    *out = max->output;
    return true;
  }
 
  // Search for the first point in the table that has a greater input
  uint16_t n = table_search(table, in);
  point low = table->points_[n - 1];
  point high = table->points_[n];
 
  // Map the input value to a t-value [0, 1]
  float t = (in - low.input) / (high.input - low.input);
 
  *out = low.output + t * (high.output - low.output);
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function: