pointcloud/lib/pc_val.c

/***********************************************************************
* pc_val.c
*
*  Pointclound value handling. Create, get and set values.
*
* Portions Copyright (c) 2012, OpenGeo
*
***********************************************************************/

#include <math.h>
#include "pc_api_internal.h"



double
pc_value_from_ptr(const uint8_t *ptr, const PCDIMENSION *dim)
{
	double val = pc_double_from_ptr(ptr, dim->interpretation);
	
	/* Scale value */
	if ( dim->scale )
		val *= dim->scale;

	/* Offset value */
	if ( dim->offset )
		val += dim->offset;
	
    return val;
}

double 
pc_double_from_ptr(const uint8_t *ptr, uint32_t interpretation)
{	
	switch( interpretation ) 
	{
		case PC_UINT8:
		{
			uint8_t v;
			memcpy(&(v), ptr, sizeof(uint8_t));
			return (double)v;
		}
		case PC_UINT16:
		{
			uint16_t v;
			memcpy(&(v), ptr, sizeof(uint16_t));
			return (double)v;
		}
		case PC_UINT32:
		{
			uint32_t v;
			memcpy(&(v), ptr, sizeof(uint32_t));
			return (double)v;
		}
		case PC_UINT64:
		{
			uint64_t v;
			memcpy(&(v), ptr, sizeof(uint64_t));
			return (double)v;
		}
		case PC_INT8:
		{
			int8_t v;
			memcpy(&(v), ptr, sizeof(int8_t));
			return (double)v;
		}
		case PC_INT16:
		{
			int16_t v;
			memcpy(&(v), ptr, sizeof(int16_t));
			return (double)v;
		}
		case PC_INT32:
		{
			int32_t v;
			memcpy(&(v), ptr, sizeof(int32_t));
			return (double)v;
		}
		case PC_INT64:
		{
			int64_t v;
			memcpy(&(v), ptr, sizeof(int64_t));
			return (double)v;
		}
		case PC_FLOAT:
		{
			float v;
			memcpy(&(v), ptr, sizeof(float));
			return (double)v;
		}
		case PC_DOUBLE:
		{
			double v;
			memcpy(&(v), ptr, sizeof(double));
			return v;
		}
		default:
		{
			pcerror("unknown interpretation type %d encountered in pc_double_from_ptr", interpretation);
		}
	}
	return 0.0;
}


int 
pc_double_to_ptr(uint8_t *ptr, uint32_t interpretation, double val)
{	
	switch( interpretation ) 
	{
		case PC_UINT8:
		{
			uint8_t v = (uint8_t)lround(val);
			memcpy(ptr, &(v), sizeof(uint8_t));
			break;
		}
		case PC_UINT16:
		{
			uint16_t v = (uint16_t)lround(val);
			memcpy(ptr, &(v), sizeof(uint16_t));
			break;
		}
		case PC_UINT32:
		{
			uint32_t v = (uint32_t)lround(val);
			memcpy(ptr, &(v), sizeof(uint32_t));
			break;
		}
		case PC_UINT64:
		{
			uint64_t v = (uint64_t)lround(val);
			memcpy(ptr, &(v), sizeof(uint64_t));
			break;
		}
		case PC_INT8:
		{
			int8_t v = (int8_t)lround(val);
			memcpy(ptr, &(v), sizeof(int8_t));
			break;
		}
		case PC_INT16:
		{
			int16_t v = (int16_t)lround(val);
			memcpy(ptr, &(v), sizeof(int16_t));
			break;
		}
		case PC_INT32:
		{
			int32_t v = (int32_t)lround(val);
			memcpy(ptr, &(v), sizeof(int32_t));
			break;
		}
		case PC_INT64:
		{
			int64_t v = (int64_t)lround(val);
			memcpy(ptr, &(v), sizeof(int64_t));
			break;
		}
		case PC_FLOAT:
		{
			float v = (float)val;
			memcpy(ptr, &(v), sizeof(float));
			break;
		}
		case PC_DOUBLE:
		{
			double v = val;
			memcpy(ptr, &(v), sizeof(double));
			break;
		}
		default:
		{
			pcerror("unknown interpretation type %d encountered in pc_double_to_ptr", interpretation);
			return PC_FAILURE;
		}
	}
	return PC_SUCCESS;
}