nlua_data.c

Go to the documentation of this file.

/*
 * See Licensing and Copyright notice in naev.h
 */
#include <lauxlib.h>
 
#include "nlua_data.h"
 
#include "nluadef.h"
 
/* Helper functions. */
static size_t dataL_checkpos( lua_State *L, const LuaData_t *ld, long pos );
 
/* Data metatable methods. */
static int dataL_gc( lua_State *L );
static int dataL_eq( lua_State *L );
static int dataL_new( lua_State *L );
static int dataL_get( lua_State *L );
static int dataL_set( lua_State *L );
static int dataL_getSize( lua_State *L );
static int dataL_getString( lua_State *L );
static int dataL_paste( lua_State *L );
static int dataL_addWeighted( lua_State *L );
static int dataL_convolve2d( lua_State *L );
 
static const luaL_Reg dataL_methods[] = {
   { "__gc", dataL_gc },
   { "__eq", dataL_eq },
   { "new", dataL_new },
   { "get", dataL_get },
   { "set", dataL_set },
   { "getSize", dataL_getSize },
   { "getString", dataL_getString },
   { "paste", dataL_paste },
   { "addWeighted", dataL_addWeighted },
   { "convolve2d", dataL_convolve2d },
   { 0, 0 } }; 

int nlua_loadData( nlua_env env )
{
   nlua_register( env, DATA_METATABLE, dataL_methods, 1 );
   return 0;
}

LuaData_t *lua_todata( lua_State *L, int ind )
{
   return (LuaData_t *)lua_touserdata( L, ind );
}

LuaData_t *luaL_checkdata( lua_State *L, int ind )
{
   if ( lua_isdata( L, ind ) )
      return lua_todata( L, ind );
   luaL_typerror( L, ind, DATA_METATABLE );
   return NULL;
}

LuaData_t *lua_pushdata( lua_State *L, LuaData_t data )
{
   LuaData_t *c;
   c  = (LuaData_t *)lua_newuserdata( L, sizeof( LuaData_t ) );
   *c = data;
   luaL_getmetatable( L, DATA_METATABLE );
   lua_setmetatable( L, -2 );
   return c;
}

int lua_isdata( lua_State *L, int ind )
{
   int ret;
 
   if ( lua_getmetatable( L, ind ) == 0 )
      return 0;
   lua_getfield( L, LUA_REGISTRYINDEX, DATA_METATABLE );
 
   ret = 0;
   if ( lua_rawequal( L, -1, -2 ) ) /* does it have the correct mt? */
      ret = 1;
 
   lua_pop( L, 2 ); /* remove both metatables */
   return ret;
}

static int dataL_gc( lua_State *L )
{
   LuaData_t *ld = luaL_checkdata( L, 1 );
   free( ld->data );
   return 0;
}

static int dataL_eq( lua_State *L )
{
   LuaData_t *d1, *d2;
   d1 = luaL_checkdata( L, 1 );
   d2 = luaL_checkdata( L, 2 );
   if ( d1->size != d2->size ) {
      lua_pushboolean( L, 0 );
      return 1;
   }
   lua_pushboolean( L, ( memcmp( d1->data, d2->data, d1->size ) == 0 ) );
   return 1;
}

static int dataL_new( lua_State *L )
{
   LuaData_t   ld;
   size_t      size = luaL_checklong( L, 1 );
   const char *type = luaL_checkstring( L, 2 );
   if ( strcmp( type, "number" ) == 0 ) {
      ld.type = LUADATA_NUMBER;
      ld.elem = sizeof( float );
   } else
      return NLUA_ERROR( L, _( "unknown data type '%s'" ), type );
   ld.size = size * ld.elem;
   ld.data = calloc( ld.elem, size );
   lua_pushdata( L, ld );
   return 1;
}
 
static size_t dataL_checkpos( lua_State *L, const LuaData_t *ld, long pos )
{
   size_t mpos;
   if ( pos < 0 )
      return NLUA_ERROR( L, _( "position argument must be positive!" ) );
   mpos = pos * ld->elem;
   if ( mpos >= ld->size )
      return NLUA_ERROR(
         L, _( "position argument out of bounds: %d of %d elements" ), pos,
         ld->size / ld->elem );
   return mpos;
}

static int dataL_get( lua_State *L )
{
   LuaData_t *ld   = luaL_checkdata( L, 1 );
   long       pos  = luaL_checklong( L, 2 );
   size_t     mpos = dataL_checkpos( L, ld, pos );
   char      *data = ld->data;
   switch ( ld->type ) {
   case LUADATA_NUMBER:
      lua_pushnumber( L, *( (float *)( (void *)&data[mpos] ) ) );
      break;
   }
   return 1;
}

static int dataL_set( lua_State *L )
{
   LuaData_t *ld   = luaL_checkdata( L, 1 );
   long       pos  = luaL_checklong( L, 2 );
   size_t     mpos = dataL_checkpos( L, ld, pos );
   char      *data = ld->data;
   double     value;
   switch ( ld->type ) {
   case LUADATA_NUMBER:
      value                                 = luaL_checknumber( L, 3 );
      *( (float *)( (void *)&data[mpos] ) ) = value;
      break;
   }
   return 0;
}

static int dataL_getSize( lua_State *L )
{
   LuaData_t *ld = luaL_checkdata( L, 1 );
   lua_pushnumber( L, ld->size );
   return 1;
}

static int dataL_getString( lua_State *L )
{
   LuaData_t *ld = luaL_checkdata( L, 1 );
   lua_pushlstring( L, ld->data, ld->size );
   return 1;
}

static int dataL_paste( lua_State *L )
{
   LuaData_t  *dest   = luaL_checkdata( L, 1 );
   LuaData_t  *source = luaL_checkdata( L, 2 );
   long        dx     = luaL_checklong( L, 3 ) * dest->elem;
   long        sx     = luaL_checklong( L, 4 ) * source->elem;
   long        sw     = luaL_checklong( L, 5 ) * source->elem;
   char       *ddata  = dest->data;
   const char *sdata  = source->data;
 
   /* Check fits. */
   if ( dx + sw > (long)dest->size )
      return NLUA_ERROR(
         L, _( "size mismatch: out of bound access dest: %d of %d elements" ),
         dx + sw, dest->size );
   else if ( sx + sw > (long)source->size )
      return NLUA_ERROR(
         L,
         _( "size mismatch: out of bound access of source: %d of %d elements" ),
         sx + sw, source->size );
 
   /* Copy memory over. */
   memcpy( &ddata[dx], &sdata[sx], sw );
 
   /* Return destination. */
   lua_pushvalue( L, 1 );
   return 1;
}

static int dataL_addWeighted( lua_State *L )
{
   LuaData_t *A = luaL_checkdata( L, 1 );
   LuaData_t *B = luaL_checkdata( L, 2 );
   LuaData_t  out;
   double     alpha = luaL_checknumber( L, 3 );
   double     beta  = luaL_optnumber( L, 4, 1. - alpha );
   double     bias  = luaL_optnumber( L, 5, 0. );
   int        i, n;
   float     *o, *a, *b;
 
   /* Checks. */
   if ( A->size != B->size )
      return NLUA_ERROR(
         L, _( "size mismatch: A has %d elements but B has %d elements" ),
         A->size, B->size );
   if ( A->type != LUADATA_NUMBER || B->type != LUADATA_NUMBER )
      return NLUA_ERROR( L, _( "%s is only implemented for number types" ),
                         __func__ );
 
   /* Create new data. */
   out.size = A->size;
   out.elem = A->elem;
   out.type = A->type;
   out.data = malloc( out.size );
 
   /* Interpolate. */
   n = out.size / out.elem;
   a = (float *)A->data;
   b = (float *)B->data;
   o = (float *)out.data;
   for ( i = 0; i < n; i++ )
      o[i] = a[i] * alpha + b[i] * beta + bias;
 
   /* Return new data. */
   lua_pushdata( L, out );
   return 1;
}

static int dataL_convolve2d( lua_State *L )
{
   LuaData_t   *lI = luaL_checkdata( L, 1 );
   long         iw = luaL_checklong( L, 2 );
   long         ih = luaL_checklong( L, 3 );
   LuaData_t   *lK = luaL_checkdata( L, 4 );
   long         kw = luaL_checklong( L, 5 );
   long         kh = luaL_checklong( L, 6 );
   LuaData_t    out;
   int          kw2, kh2, bw, bh, ow, oh;
   const float *I = (const float *)lI->data;
   const float *K = (const float *)lK->data;
   float       *B, *O;
 
   /* Checks. */
   if ( iw * ih * 4 * lI->elem != lI->size )
      return NLUA_ERROR(
         L, _( "size mismatch for data: got %dx%dx4x%d, expected %d" ), iw, ih,
         lI->elem, lI->size );
   if ( kw * kh * 4 * lK->elem != lK->size )
      return NLUA_ERROR(
         L, _( "size mismatch for data: got %dx%dx4x%d, expected %d" ), kw, kh,
         lK->elem, lK->size );
   if ( lI->type != LUADATA_NUMBER || lK->type != LUADATA_NUMBER )
      return NLUA_ERROR( L, _( "%s is only implemented for number types" ),
                         __func__ );
 
   /* Set up. */
   kw2 = ( kw - 1 ) / 2;
   kh2 = ( kh - 1 ) / 2;
 
   /* Create new data. */
   ow       = iw + kw2;
   oh       = ih + kw2;
   out.elem = lI->elem;
   out.type = lI->type;
   out.size = ow * oh * 4 * out.elem;
   out.data = calloc( out.size, 1 );
   O        = (float *)out.data;
 
#define POS( U, V, W ) ( 4 * ( ( V ) * ( W ) + ( U ) ) )
   /* Create buffer. */
   bw = ow + 2 * kw2;
   bh = oh + 2 * kh2;
   B  = calloc( bw * bh * 4, sizeof( float ) );
   for ( int v = 0; v < ih; v++ )
      memcpy( &B[POS( kw2, v + kh2, bw )], &I[POS( 0, v, iw )],
              4 * sizeof( float ) * iw );
 
   /* Convolve. */
   for ( int v = 0; v < oh; v++ ) {
      for ( int u = 0; u < ow; u++ ) {
         for ( int kv = 0; kv < kh; kv++ ) {
            for ( int ku = 0; ku < kw; ku++ ) {
               int bu = u + ku;
               int bv = v + kv;
               for ( int p = 0; p < 4; p++ )
                  O[POS( u, v, ow ) + p] +=
                     B[POS( bu, bv, bw ) + p] * K[POS( ku, kv, kw ) + p];
            }
         }
      }
   }
#undef POS
 
   /* Cleanup. */
   free( B );
 
   /* Return new data. */
   lua_pushdata( L, out );
   lua_pushinteger( L, ow );
   lua_pushinteger( L, oh );
   return 3;
}