/* ----------------------------------------------------------------------------
 * This file was automatically generated by SWIG (http://www.swig.org).
 * Version 2.0.8
 * 
 * This file is not intended to be easily readable and contains a number of 
 * coding conventions designed to improve portability and efficiency. Do not make
 * changes to this file unless you know what you are doing--modify the SWIG 
 * interface file instead. 
 * ----------------------------------------------------------------------------- */

#define SWIGCSHARP
#define SWIG_DIRECTORS


#ifdef __cplusplus
/* SwigValueWrapper is described in swig.swg */
template<typename T> class SwigValueWrapper {
  struct SwigMovePointer {
    T *ptr;
    SwigMovePointer(T *p) : ptr(p) { }
    ~SwigMovePointer() { delete ptr; }
    SwigMovePointer& operator=(SwigMovePointer& rhs) { T* oldptr = ptr; ptr = 0; delete oldptr; ptr = rhs.ptr; rhs.ptr = 0; return *this; }
  } pointer;
  SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
  SwigValueWrapper(const SwigValueWrapper<T>& rhs);
public:
  SwigValueWrapper() : pointer(0) { }
  SwigValueWrapper& operator=(const T& t) { SwigMovePointer tmp(new T(t)); pointer = tmp; return *this; }
  operator T&() const { return *pointer.ptr; }
  T *operator&() { return pointer.ptr; }
};

template <typename T> T SwigValueInit() {
  return T();
}
#endif

/* -----------------------------------------------------------------------------
 *  This section contains generic SWIG labels for method/variable
 *  declarations/attributes, and other compiler dependent labels.
 * ----------------------------------------------------------------------------- */

/* template workaround for compilers that cannot correctly implement the C++ standard */
#ifndef SWIGTEMPLATEDISAMBIGUATOR
# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
#  define SWIGTEMPLATEDISAMBIGUATOR template
# elif defined(__HP_aCC)
/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
#  define SWIGTEMPLATEDISAMBIGUATOR template
# else
#  define SWIGTEMPLATEDISAMBIGUATOR
# endif
#endif

/* inline attribute */
#ifndef SWIGINLINE
# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
#   define SWIGINLINE inline
# else
#   define SWIGINLINE
# endif
#endif

/* attribute recognised by some compilers to avoid 'unused' warnings */
#ifndef SWIGUNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define SWIGUNUSED __attribute__ ((__unused__)) 
#   else
#     define SWIGUNUSED
#   endif
# elif defined(__ICC)
#   define SWIGUNUSED __attribute__ ((__unused__)) 
# else
#   define SWIGUNUSED 
# endif
#endif

#ifndef SWIG_MSC_UNSUPPRESS_4505
# if defined(_MSC_VER)
#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
# endif 
#endif

#ifndef SWIGUNUSEDPARM
# ifdef __cplusplus
#   define SWIGUNUSEDPARM(p)
# else
#   define SWIGUNUSEDPARM(p) p SWIGUNUSED 
# endif
#endif

/* internal SWIG method */
#ifndef SWIGINTERN
# define SWIGINTERN static SWIGUNUSED
#endif

/* internal inline SWIG method */
#ifndef SWIGINTERNINLINE
# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
#endif

/* exporting methods */
#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
#  ifndef GCC_HASCLASSVISIBILITY
#    define GCC_HASCLASSVISIBILITY
#  endif
#endif

#ifndef SWIGEXPORT
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   if defined(STATIC_LINKED)
#     define SWIGEXPORT
#   else
#     define SWIGEXPORT __declspec(dllexport)
#   endif
# else
#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
#     define SWIGEXPORT __attribute__ ((visibility("default")))
#   else
#     define SWIGEXPORT
#   endif
# endif
#endif

/* calling conventions for Windows */
#ifndef SWIGSTDCALL
# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
#   define SWIGSTDCALL __stdcall
# else
#   define SWIGSTDCALL
# endif 
#endif

/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
# define _CRT_SECURE_NO_DEPRECATE
#endif

/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
# define _SCL_SECURE_NO_DEPRECATE
#endif



#include <stdlib.h>
#include <string.h>
#include <stdio.h>


/* Support for throwing C# exceptions from C/C++. There are two types: 
 * Exceptions that take a message and ArgumentExceptions that take a message and a parameter name. */
typedef enum {
  SWIG_CSharpApplicationException,
  SWIG_CSharpArithmeticException,
  SWIG_CSharpDivideByZeroException,
  SWIG_CSharpIndexOutOfRangeException,
  SWIG_CSharpInvalidCastException,
  SWIG_CSharpInvalidOperationException,
  SWIG_CSharpIOException,
  SWIG_CSharpNullReferenceException,
  SWIG_CSharpOutOfMemoryException,
  SWIG_CSharpOverflowException,
  SWIG_CSharpSystemException
} SWIG_CSharpExceptionCodes;

typedef enum {
  SWIG_CSharpArgumentException,
  SWIG_CSharpArgumentNullException,
  SWIG_CSharpArgumentOutOfRangeException
} SWIG_CSharpExceptionArgumentCodes;

typedef void (SWIGSTDCALL* SWIG_CSharpExceptionCallback_t)(const char *);
typedef void (SWIGSTDCALL* SWIG_CSharpExceptionArgumentCallback_t)(const char *, const char *);

typedef struct {
  SWIG_CSharpExceptionCodes code;
  SWIG_CSharpExceptionCallback_t callback;
} SWIG_CSharpException_t;

typedef struct {
  SWIG_CSharpExceptionArgumentCodes code;
  SWIG_CSharpExceptionArgumentCallback_t callback;
} SWIG_CSharpExceptionArgument_t;

static SWIG_CSharpException_t SWIG_csharp_exceptions[] = {
  { SWIG_CSharpApplicationException, NULL },
  { SWIG_CSharpArithmeticException, NULL },
  { SWIG_CSharpDivideByZeroException, NULL },
  { SWIG_CSharpIndexOutOfRangeException, NULL },
  { SWIG_CSharpInvalidCastException, NULL },
  { SWIG_CSharpInvalidOperationException, NULL },
  { SWIG_CSharpIOException, NULL },
  { SWIG_CSharpNullReferenceException, NULL },
  { SWIG_CSharpOutOfMemoryException, NULL },
  { SWIG_CSharpOverflowException, NULL },
  { SWIG_CSharpSystemException, NULL }
};

static SWIG_CSharpExceptionArgument_t SWIG_csharp_exceptions_argument[] = {
  { SWIG_CSharpArgumentException, NULL },
  { SWIG_CSharpArgumentNullException, NULL },
  { SWIG_CSharpArgumentOutOfRangeException, NULL }
};

static void SWIGUNUSED SWIG_CSharpSetPendingException(SWIG_CSharpExceptionCodes code, const char *msg) {
  SWIG_CSharpExceptionCallback_t callback = SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions)/sizeof(SWIG_CSharpException_t)) {
    callback = SWIG_csharp_exceptions[code].callback;
  }
  callback(msg);
}

static void SWIGUNUSED SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpExceptionArgumentCodes code, const char *msg, const char *param_name) {
  SWIG_CSharpExceptionArgumentCallback_t callback = SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback;
  if ((size_t)code < sizeof(SWIG_csharp_exceptions_argument)/sizeof(SWIG_CSharpExceptionArgument_t)) {
    callback = SWIG_csharp_exceptions_argument[code].callback;
  }
  callback(msg, param_name);
}


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionCallbacks_LidarDSDK(
                                                SWIG_CSharpExceptionCallback_t applicationCallback,
                                                SWIG_CSharpExceptionCallback_t arithmeticCallback,
                                                SWIG_CSharpExceptionCallback_t divideByZeroCallback, 
                                                SWIG_CSharpExceptionCallback_t indexOutOfRangeCallback, 
                                                SWIG_CSharpExceptionCallback_t invalidCastCallback,
                                                SWIG_CSharpExceptionCallback_t invalidOperationCallback,
                                                SWIG_CSharpExceptionCallback_t ioCallback,
                                                SWIG_CSharpExceptionCallback_t nullReferenceCallback,
                                                SWIG_CSharpExceptionCallback_t outOfMemoryCallback, 
                                                SWIG_CSharpExceptionCallback_t overflowCallback, 
                                                SWIG_CSharpExceptionCallback_t systemCallback) {
  SWIG_csharp_exceptions[SWIG_CSharpApplicationException].callback = applicationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpArithmeticException].callback = arithmeticCallback;
  SWIG_csharp_exceptions[SWIG_CSharpDivideByZeroException].callback = divideByZeroCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIndexOutOfRangeException].callback = indexOutOfRangeCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidCastException].callback = invalidCastCallback;
  SWIG_csharp_exceptions[SWIG_CSharpInvalidOperationException].callback = invalidOperationCallback;
  SWIG_csharp_exceptions[SWIG_CSharpIOException].callback = ioCallback;
  SWIG_csharp_exceptions[SWIG_CSharpNullReferenceException].callback = nullReferenceCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOutOfMemoryException].callback = outOfMemoryCallback;
  SWIG_csharp_exceptions[SWIG_CSharpOverflowException].callback = overflowCallback;
  SWIG_csharp_exceptions[SWIG_CSharpSystemException].callback = systemCallback;
}

#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterExceptionArgumentCallbacks_LidarDSDK(
                                                SWIG_CSharpExceptionArgumentCallback_t argumentCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentNullCallback,
                                                SWIG_CSharpExceptionArgumentCallback_t argumentOutOfRangeCallback) {
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentException].callback = argumentCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentNullException].callback = argumentNullCallback;
  SWIG_csharp_exceptions_argument[SWIG_CSharpArgumentOutOfRangeException].callback = argumentOutOfRangeCallback;
}


/* Callback for returning strings to C# without leaking memory */
typedef char * (SWIGSTDCALL* SWIG_CSharpStringHelperCallback)(const char *);
static SWIG_CSharpStringHelperCallback SWIG_csharp_string_callback = NULL;


#ifdef __cplusplus
extern "C" 
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterStringCallback_LidarDSDK(SWIG_CSharpStringHelperCallback callback) {
  SWIG_csharp_string_callback = callback;
}


/* Contract support */

#define SWIG_contract_assert(nullreturn, expr, msg) if (!(expr)) {SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentOutOfRangeException, msg, ""); return nullreturn; } else

/*  Errors in SWIG */
#define  SWIG_UnknownError    	   -1 
#define  SWIG_IOError        	   -2 
#define  SWIG_RuntimeError   	   -3 
#define  SWIG_IndexError     	   -4 
#define  SWIG_TypeError      	   -5 
#define  SWIG_DivisionByZero 	   -6 
#define  SWIG_OverflowError  	   -7 
#define  SWIG_SyntaxError    	   -8 
#define  SWIG_ValueError     	   -9 
#define  SWIG_SystemError    	   -10
#define  SWIG_AttributeError 	   -11
#define  SWIG_MemoryError    	   -12 
#define  SWIG_NullReferenceError   -13




/* Callback for returning strings to C# without leaking memory */
typedef void * (SWIGSTDCALL* SWIG_CSharpWStringHelperCallback)(const wchar_t *);
static SWIG_CSharpWStringHelperCallback SWIG_csharp_wstring_callback = NULL;


#ifdef __cplusplus
extern "C"
#endif
SWIGEXPORT void SWIGSTDCALL SWIGRegisterWStringCallback_LidarDSDK(SWIG_CSharpWStringHelperCallback callback) {
  SWIG_csharp_wstring_callback = callback;
}

/* -----------------------------------------------------------------------------
 * director.swg
 *
 * This file contains support for director classes so that C# proxy 
 * methods can be called from C++.
 * ----------------------------------------------------------------------------- */

#ifdef __cplusplus

#if defined(DEBUG_DIRECTOR_OWNED)
#include <iostream>
#endif
#include <string>

namespace Swig {
  /* Director base class - not currently used in C# directors */
  class Director {
  };

  /* Base class for director exceptions */
  class DirectorException {
  protected:
    std::string swig_msg;

  public:
    DirectorException(const char* msg) : swig_msg(msg) {
    }
    DirectorException(const std::string &msg) : swig_msg(msg) {
    }
    const std::string& what() const {
      return swig_msg;
    }
    virtual ~DirectorException() {
    }
  };

  /* Pure virtual method exception */
  class DirectorPureVirtualException : public Swig::DirectorException {
  public:
    DirectorPureVirtualException(const char* msg) : DirectorException(std::string("Attempt to invoke pure virtual method ") + msg) {
    }
  };
}

#endif /* __cplusplus */




// host helper functions

#if defined SWIGPYTHON

static PyObject *doubleArrayToObject(const double *value, size_t length)
{
   PyObject *obj = Py_None;
   if(value != NULL)
   {
      obj = PyTuple_New(length);
      for(size_t i = 0; i < length; i += 1)
         PyTuple_SetItem(obj, i, PyFloat_FromDouble(value[i]));
   }
   return obj;
}

static PyObject *stringArrayToObject(char **value, size_t length)
{
   PyObject *obj = Py_None;
   if(value != NULL)
   {
      obj = PyTuple_New(length);
      for(size_t i = 0; i < length; i += 1)
         PyTuple_SetItem(obj, i, PyString_FromString(value[i]));
   }
   return obj;
}

static double *objectToDouble3(PyObject *obj, double value[3])
{
   if(obj == Py_None)
      return NULL;
   else if(PyTuple_Check(obj) && PyObject_Length(obj) == 3)
   {
      for(int i = 0; i < 3; i += 1)
         value[i] = PyFloat_AsDouble(PyTuple_GetItem(obj, i));
      return value;
   }
   //SWIG_exception(SWIG_TypeError, "expected an Array with 3 doubles");
   return NULL;
}

#elif defined SWIGRUBY

static VALUE doubleArrayToObject(const double *value, size_t length)
{
   VALUE obj = Qnil;
   if(value != NULL)
   {
      obj = rb_ary_new2(length);
      for(size_t i = 0; i < length; i += 1)
         rb_ary_store(obj, i, rb_float_new(value[i]));
   }
   return obj;
}

static VALUE stringArrayToObject(char **value, size_t length)
{
   VALUE obj = Qnil;
   if(value != NULL)
   {
      obj = rb_ary_new2(length);
      for(size_t i = 0; i < length; i += 1)
         rb_ary_store(obj, i, rb_str_new2(value[i]));
   }
   return obj;
}

static double *objectToDouble3(VALUE obj, double value[3])
{
   if(obj == Qnil)
      return NULL;
   else if(TYPE(obj) == T_ARRAY && RARRAY_LEN(obj) == 3)
   {
      for(int i = 0; i < 3; i += 1)
         value[i] = NUM2DBL(rb_ary_entry(obj, i));
      return value;
   }
   //SWIG_exception(SWIG_TypeError, "expected an Array with 3 doubles");
   return NULL;
}

#elif defined SWIGCSHARP

#pragma warning(disable:4702)
// all the helper code is in the typemaps because it lives in the C# world


#endif


SWIGINTERN void SWIG_CSharpException(int code, const char *msg) {
  if (code == SWIG_ValueError) {
    SWIG_CSharpExceptionArgumentCodes exception_code = SWIG_CSharpArgumentOutOfRangeException;
    SWIG_CSharpSetPendingExceptionArgument(exception_code, msg, 0);
  } else {
    SWIG_CSharpExceptionCodes exception_code = SWIG_CSharpApplicationException;
    switch(code) {
    case SWIG_MemoryError:
      exception_code = SWIG_CSharpOutOfMemoryException;
      break;
    case SWIG_IndexError:
      exception_code = SWIG_CSharpIndexOutOfRangeException;
      break;
    case SWIG_DivisionByZero:
      exception_code = SWIG_CSharpDivideByZeroException;
      break;
    case SWIG_IOError:
      exception_code = SWIG_CSharpIOException;
      break;
    case SWIG_OverflowError:
      exception_code = SWIG_CSharpOverflowException;
      break;
    case SWIG_RuntimeError:
    case SWIG_TypeError:
    case SWIG_SyntaxError:
    case SWIG_SystemError:
    case SWIG_UnknownError:
    default:
      exception_code = SWIG_CSharpApplicationException;
      break;
    }
    SWIG_CSharpSetPendingException(exception_code, msg);
  }
}


#include <stdexcept>


#include "lidar/Error.h"
#include "lidar/Version.h"
#include "lidar/FileIO.h"
#include "lidar/TXTPointReader.h"
#include "lidar/TXTPointWriter.h"

SWIGINTERN double LizardTech_ChannelData_getValue(LizardTech::ChannelData *self,size_t i){
      const void *values = self->getData();

      switch(self->getDataType())
      {



          case LizardTech::DATATYPE_UINT8:        return static_cast<double>(static_cast<const lt_uint8 *>(values)[i]);
          case LizardTech::DATATYPE_SINT8:        return static_cast<double>(static_cast<const lt_int8 *>(values)[i]);
          case LizardTech::DATATYPE_UINT16:        return static_cast<double>(static_cast<const lt_uint16 *>(values)[i]);
          case LizardTech::DATATYPE_SINT16:        return static_cast<double>(static_cast<const lt_int16 *>(values)[i]);
          case LizardTech::DATATYPE_UINT32:        return static_cast<double>(static_cast<const lt_uint32 *>(values)[i]);
          case LizardTech::DATATYPE_SINT32:        return static_cast<double>(static_cast<const lt_int32 *>(values)[i]);
          case LizardTech::DATATYPE_UINT64:        return static_cast<double>(static_cast<const lt_uint64 *>(values)[i]);
          case LizardTech::DATATYPE_SINT64:        return static_cast<double>(static_cast<const lt_int64 *>(values)[i]);
          case LizardTech::DATATYPE_FLOAT32:        return static_cast<double>(static_cast<const float *>(values)[i]);
          case LizardTech::DATATYPE_FLOAT64:        return static_cast<double>(static_cast<const double *>(values)[i]);

      default:
         return 0;
      }
   }
SWIGINTERN void delete_LizardTech_IO(LizardTech::IO *self){
       //::fprintf(stderr, "in ~" #IO "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_FileIO(LizardTech::FileIO *self){
       //::fprintf(stderr, "in ~" #FileIO "\n");
       self->release();
     }
SWIGINTERN LizardTech::FileIO *new_LizardTech_FileIO(){
         //::fprintf(stderr, "in " #FileIO "\n");
         return LizardTech::FileIO::create();
      }
SWIGINTERN void delete_LizardTech_PointIterator(LizardTech::PointIterator *self){
       //::fprintf(stderr, "in ~" #PointIterator "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_PointSource(LizardTech::PointSource *self){
       //::fprintf(stderr, "in ~" #PointSource "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_PointReader(LizardTech::PointReader *self){
       //::fprintf(stderr, "in ~" #PointReader "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_PointWriter(LizardTech::PointWriter *self){
       //::fprintf(stderr, "in ~" #PointWriter "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_SimplePointWriter(LizardTech::SimplePointWriter *self){
       //::fprintf(stderr, "in ~" #SimplePointWriter "\n");
       self->release();
     }
SWIGINTERN void delete_LizardTech_TXTPointReader(LizardTech::TXTPointReader *self){
       //::fprintf(stderr, "in ~" #TXTPointReader "\n");
       self->release();
     }
SWIGINTERN LizardTech::TXTPointReader *new_LizardTech_TXTPointReader(){
         //::fprintf(stderr, "in " #TXTPointReader "\n");
         return LizardTech::TXTPointReader::create();
      }
SWIGINTERN void delete_LizardTech_TXTPointWriter(LizardTech::TXTPointWriter *self){
       //::fprintf(stderr, "in ~" #TXTPointWriter "\n");
       self->release();
     }
SWIGINTERN LizardTech::TXTPointWriter *new_LizardTech_TXTPointWriter(){
         //::fprintf(stderr, "in " #TXTPointWriter "\n");
         return LizardTech::TXTPointWriter::create();
      }

#include "lidar/MG4PointReader.h"

SWIGINTERN void delete_LizardTech_MG4PointReader(LizardTech::MG4PointReader *self){
       //::fprintf(stderr, "in ~" #MG4PointReader "\n");
       self->release();
     }
SWIGINTERN LizardTech::MG4PointReader *new_LizardTech_MG4PointReader(){
         //::fprintf(stderr, "in " #MG4PointReader "\n");
         return LizardTech::MG4PointReader::create();
      }


/* ---------------------------------------------------
 * C++ director class methods
 * --------------------------------------------------- */

#include "LidarDSDK.h"

SwigDirector_ProgressDelegate::SwigDirector_ProgressDelegate() : LizardTech::ProgressDelegate(), Swig::Director() {
  swig_init_callbacks();
}

SwigDirector_ProgressDelegate::~SwigDirector_ProgressDelegate() {
  
}


void SwigDirector_ProgressDelegate::reportProgress(double progress, char const *message) {
  double jprogress  ;
  char * jmessage = 0 ;
  
  if (!swig_callbackreportProgress) {
    throw Swig::DirectorPureVirtualException("LizardTech::ProgressDelegate::reportProgress");
  } else {
    jprogress = progress;
    jmessage = SWIG_csharp_string_callback((const char *)message); 
    swig_callbackreportProgress(jprogress, jmessage);
  }
}

bool SwigDirector_ProgressDelegate::getCancelled() {
  bool c_result = SwigValueInit< bool >() ;
  unsigned int jresult = 0 ;
  
  if (!swig_callbackgetCancelled) {
    throw Swig::DirectorPureVirtualException("LizardTech::ProgressDelegate::getCancelled");
  } else {
    jresult = (unsigned int) swig_callbackgetCancelled();
    c_result = jresult ? true : false; 
  }
  return c_result;
}

void SwigDirector_ProgressDelegate::displayWarning(char const *message) {
  char * jmessage = 0 ;
  
  if (!swig_callbackdisplayWarning) {
    LizardTech::ProgressDelegate::displayWarning(message);
    return;
  } else {
    jmessage = SWIG_csharp_string_callback((const char *)message); 
    swig_callbackdisplayWarning(jmessage);
  }
}

void SwigDirector_ProgressDelegate::swig_connect_director(SWIG_Callback0_t callbackreportProgress, SWIG_Callback1_t callbackgetCancelled, SWIG_Callback2_t callbackdisplayWarning) {
  swig_callbackreportProgress = callbackreportProgress;
  swig_callbackgetCancelled = callbackgetCancelled;
  swig_callbackdisplayWarning = callbackdisplayWarning;
}

void SwigDirector_ProgressDelegate::swig_init_callbacks() {
  swig_callbackreportProgress = 0;
  swig_callbackgetCancelled = 0;
  swig_callbackdisplayWarning = 0;
}


#ifdef __cplusplus
extern "C" {
#endif

SWIGEXPORT void SWIGSTDCALL CSharp_Range_min_set(void * jarg1, double jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->min = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Range_min_get(void * jarg1) {
  double jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  result = (double) ((arg1)->min);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_max_set(void * jarg1, double jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  if (arg1) (arg1)->max = arg2;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Range_max_get(void * jarg1) {
  double jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  result = (double) ((arg1)->max);
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Range__SWIG_0(double jarg1, double jarg2) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  LizardTech::Range *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      result = (LizardTech::Range *)new LizardTech::Range(arg1,arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Range__SWIG_1(double jarg1) {
  void * jresult ;
  double arg1 ;
  LizardTech::Range *result = 0 ;
  
  arg1 = (double)jarg1; 
  {
    try
    {
      result = (LizardTech::Range *)new LizardTech::Range(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Range__SWIG_2() {
  void * jresult ;
  LizardTech::Range *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::Range *)new LizardTech::Range();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Range_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  LizardTech::Range *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::Range const *)arg1)->operator ==((LizardTech::Range const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Range_contains(void * jarg1, double jarg2) {
  unsigned int jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  bool result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      result = (bool)((LizardTech::Range const *)arg1)->contains(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Range_overlaps(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  LizardTech::Range *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::Range const *)arg1)->overlaps((LizardTech::Range const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Range_empty(void * jarg1) {
  unsigned int jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  bool result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  {
    try
    {
      result = (bool)((LizardTech::Range const *)arg1)->empty();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Range_length(void * jarg1) {
  double jresult ;
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double result;
  
  arg1 = (LizardTech::Range *)jarg1; 
  {
    try
    {
      result = (double)((LizardTech::Range const *)arg1)->length();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_shift(void * jarg1, double jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      (arg1)->shift(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_scale(void * jarg1, double jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      (arg1)->scale(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_clip(void * jarg1, void * jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  LizardTech::Range *arg2 = 0 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->clip((LizardTech::Range const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_grow__SWIG_0(void * jarg1, void * jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  LizardTech::Range *arg2 = 0 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->grow((LizardTech::Range const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Range_grow__SWIG_1(void * jarg1, double jarg2) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      (arg1)->grow(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Range(void * jarg1) {
  LizardTech::Range *arg1 = (LizardTech::Range *) 0 ;
  
  arg1 = (LizardTech::Range *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_x_set(void * jarg1, void * jarg2) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *arg2 = (LizardTech::Range *) 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2; 
  if (arg1) (arg1)->x = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Bounds_x_get(void * jarg1) {
  void * jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *result = 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  result = (LizardTech::Range *)& ((arg1)->x);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_y_set(void * jarg1, void * jarg2) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *arg2 = (LizardTech::Range *) 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2; 
  if (arg1) (arg1)->y = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Bounds_y_get(void * jarg1) {
  void * jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *result = 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  result = (LizardTech::Range *)& ((arg1)->y);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_z_set(void * jarg1, void * jarg2) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *arg2 = (LizardTech::Range *) 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Range *)jarg2; 
  if (arg1) (arg1)->z = *arg2;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Bounds_z_get(void * jarg1) {
  void * jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Range *result = 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  result = (LizardTech::Range *)& ((arg1)->z);
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Bounds_Huge() {
  void * jresult ;
  LizardTech::Bounds *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::Bounds *) &LizardTech::Bounds::Huge();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_0(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5, double jarg6) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  double arg6 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1,arg2,arg3,arg4,arg5,arg6);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_1(double jarg1, double jarg2, double jarg3, double jarg4, double jarg5) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  double arg5 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  arg5 = (double)jarg5; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1,arg2,arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_2(double jarg1, double jarg2, double jarg3, double jarg4) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1,arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_3(double jarg1, double jarg2, double jarg3) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  double arg3 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1,arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_4(double jarg1, double jarg2) {
  void * jresult ;
  double arg1 ;
  double arg2 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1,arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_5(double jarg1) {
  void * jresult ;
  double arg1 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (double)jarg1; 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_6() {
  void * jresult ;
  LizardTech::Bounds *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Bounds__SWIG_7(void * jarg1, void * jarg2, void * jarg3) {
  void * jresult ;
  LizardTech::Range *arg1 = 0 ;
  LizardTech::Range *arg2 = 0 ;
  LizardTech::Range *arg3 = 0 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (LizardTech::Range *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return 0;
  } 
  arg2 = (LizardTech::Range *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return 0;
  } 
  arg3 = (LizardTech::Range *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Range const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (LizardTech::Bounds *)new LizardTech::Bounds((LizardTech::Range const &)*arg1,(LizardTech::Range const &)*arg2,(LizardTech::Range const &)*arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Bounds_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::Bounds const *)arg1)->operator ==((LizardTech::Bounds const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Bounds_contains(void * jarg1, double jarg2, double jarg3, double jarg4) {
  unsigned int jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  bool result;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  {
    try
    {
      result = (bool)((LizardTech::Bounds const *)arg1)->contains(arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Bounds_overlaps(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::Bounds const *)arg1)->overlaps((LizardTech::Bounds const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Bounds_empty(void * jarg1) {
  unsigned int jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  bool result;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  {
    try
    {
      result = (bool)((LizardTech::Bounds const *)arg1)->empty();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_Bounds_volume(void * jarg1) {
  double jresult ;
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  double result;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  {
    try
    {
      result = (double)((LizardTech::Bounds const *)arg1)->volume();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_shift(void * jarg1, double jarg2, double jarg3, double jarg4) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  {
    try
    {
      (arg1)->shift(arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_scale(void * jarg1, double jarg2, double jarg3, double jarg4) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  {
    try
    {
      (arg1)->scale(arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_clip(void * jarg1, void * jarg2) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->clip((LizardTech::Bounds const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_grow__SWIG_0(void * jarg1, void * jarg2) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->grow((LizardTech::Bounds const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Bounds_grow__SWIG_1(void * jarg1, double jarg2, double jarg3, double jarg4) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  double arg2 ;
  double arg3 ;
  double arg4 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (double)jarg3; 
  arg4 = (double)jarg4; 
  {
    try
    {
      (arg1)->grow(arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_Bounds_overlapFraction(void * jarg1, void * jarg2) {
  double jresult ;
  LizardTech::Bounds *arg1 = 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  double result;
  
  arg1 = (LizardTech::Bounds *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (double)LizardTech::Bounds::overlapFraction((LizardTech::Bounds const &)*arg1,(LizardTech::Bounds const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Bounds(void * jarg1) {
  LizardTech::Bounds *arg1 = (LizardTech::Bounds *) 0 ;
  
  arg1 = (LizardTech::Bounds *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DataTypeUtils_isSigned(int jarg1) {
  unsigned int jresult ;
  LizardTech::DataType arg1 ;
  bool result;
  
  arg1 = (LizardTech::DataType)jarg1; 
  {
    try
    {
      result = (bool)LizardTech::DataTypeUtils::isSigned(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_DataTypeUtils_isFloat(int jarg1) {
  unsigned int jresult ;
  LizardTech::DataType arg1 ;
  bool result;
  
  arg1 = (LizardTech::DataType)jarg1; 
  {
    try
    {
      result = (bool)LizardTech::DataTypeUtils::isFloat(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DataTypeUtils_byteWidth(int jarg1) {
  int jresult ;
  LizardTech::DataType arg1 ;
  int result;
  
  arg1 = (LizardTech::DataType)jarg1; 
  {
    try
    {
      result = (int)LizardTech::DataTypeUtils::byteWidth(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_DataTypeUtils_toString(int jarg1) {
  char * jresult ;
  LizardTech::DataType arg1 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::DataType)jarg1; 
  {
    try
    {
      result = (char *)LizardTech::DataTypeUtils::toString(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_DataTypeUtils_toDataType(char * jarg1) {
  int jresult ;
  char *arg1 = (char *) 0 ;
  LizardTech::DataType result;
  
  arg1 = (char *)jarg1; 
  {
    try
    {
      result = (LizardTech::DataType)LizardTech::DataTypeUtils::toDataType((char const *)arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_DataTypeUtils() {
  void * jresult ;
  LizardTech::DataTypeUtils *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::DataTypeUtils *)new LizardTech::DataTypeUtils();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_DataTypeUtils(void * jarg1) {
  LizardTech::DataTypeUtils *arg1 = (LizardTech::DataTypeUtils *) 0 ;
  
  arg1 = (LizardTech::DataTypeUtils *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_X_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("X");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Y_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Y");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Z_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Z");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Intensity_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Intensity");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ReturnNum_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ReturnNum");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_NumReturns_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("NumReturns");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ScanDir_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ScanDir");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_EdgeFlightLine_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("EdgeFlightLine");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ScannerChannel_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ScannerChannel");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ClassId_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ClassId");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ClassFlags_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ClassFlags");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_ScanAngle_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ScanAngle");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_UserData_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("UserData");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_SourceId_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("SourceId");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_GPSTime_Week_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("GPSTime");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_GPSTime_Adjusted_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("GPSTime_Adjusted");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Red_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Red");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Green_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Green");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Blue_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("Blue");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_NearInfrared_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("NearInfrared");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_CHANNEL_NAME_Skip_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("@Skip");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ChannelInfo(void * jarg1) {
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ChannelInfo() {
  void * jresult ;
  LizardTech::ChannelInfo *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::ChannelInfo *)new LizardTech::ChannelInfo();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelInfo_init__SWIG_0(void * jarg1, char * jarg2, int jarg3, int jarg4, double jarg5) {
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::DataType arg3 ;
  int arg4 ;
  double arg5 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (LizardTech::DataType)jarg3; 
  arg4 = (int)jarg4; 
  arg5 = (double)jarg5; 
  {
    try
    {
      (arg1)->init((char const *)arg2,arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelInfo_init__SWIG_1(void * jarg1, char * jarg2, int jarg3, int jarg4) {
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::DataType arg3 ;
  int arg4 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (LizardTech::DataType)jarg3; 
  arg4 = (int)jarg4; 
  {
    try
    {
      (arg1)->init((char const *)arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelInfo_init__SWIG_2(void * jarg1, void * jarg2) {
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  LizardTech::ChannelInfo *arg2 = 0 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  arg2 = (LizardTech::ChannelInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->init((LizardTech::ChannelInfo const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_ChannelInfo_getName(void * jarg1) {
  char * jresult ;
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  {
    try
    {
      result = (char *)((LizardTech::ChannelInfo const *)arg1)->getName();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_ChannelInfo_getDataType(void * jarg1) {
  int jresult ;
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  LizardTech::DataType result;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  {
    try
    {
      result = (LizardTech::DataType)((LizardTech::ChannelInfo const *)arg1)->getDataType();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_ChannelInfo_getBits(void * jarg1) {
  unsigned long jresult ;
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  {
    try
    {
      result = ((LizardTech::ChannelInfo const *)arg1)->getBits();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_ChannelInfo_getQuantization(void * jarg1) {
  double jresult ;
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  double result;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  {
    try
    {
      result = (double)((LizardTech::ChannelInfo const *)arg1)->getQuantization();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelInfo_setQuantization(void * jarg1, double jarg2) {
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      (arg1)->setQuantization(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ChannelInfo_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::ChannelInfo *arg1 = (LizardTech::ChannelInfo *) 0 ;
  LizardTech::ChannelInfo *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::ChannelInfo *)jarg1; 
  arg2 = (LizardTech::ChannelInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelInfo const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::ChannelInfo const *)arg1)->operator ==((LizardTech::ChannelInfo const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointInfo(void * jarg1) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PointInfo() {
  void * jresult ;
  LizardTech::PointInfo *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::PointInfo *)new LizardTech::PointInfo();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_0(void * jarg1, unsigned long jarg2) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->init(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_1(void * jarg1, void * jarg2) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->init((LizardTech::PointInfo const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_2(void * jarg1, void * jarg2) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointData *arg2 = 0 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointData *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->init((LizardTech::PointData const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  char **arg3 = (char **) 0 ;
  size_t arg4 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  arg3 = (char **)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointInfo const &)*arg2,(char const *const *)arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_4(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointData *arg2 = 0 ;
  char **arg3 = (char **) 0 ;
  size_t arg4 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointData *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  arg3 = (char **)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointData const &)*arg2,(char const *const *)arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_5(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t arg4 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  arg3 = (size_t *)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointInfo const &)*arg2,(size_t const *)arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointInfo_init__SWIG_6(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4) {
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointData *arg2 = 0 ;
  size_t *arg3 = (size_t *) 0 ;
  size_t arg4 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointData *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  arg3 = (size_t *)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointData const &)*arg2,(size_t const *)arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointInfo_getNumChannels(void * jarg1) {
  unsigned long jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  {
    try
    {
      result = ((LizardTech::PointInfo const *)arg1)->getNumChannels();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointInfo_getChannel__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  size_t arg2 ;
  LizardTech::ChannelInfo *result = 0 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelInfo *) &((LizardTech::PointInfo const *)arg1)->getChannel(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointInfo_hasChannel(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (bool)((LizardTech::PointInfo const *)arg1)->hasChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointInfo_getChannel__SWIG_2(void * jarg1, char * jarg2) {
  void * jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::ChannelInfo *result = 0 ;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelInfo *)((LizardTech::PointInfo const *)arg1)->getChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointInfo_getChannelIndex(void * jarg1, char * jarg2) {
  unsigned long jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = ((LizardTech::PointInfo const *)arg1)->getChannelIndex((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointInfo_hasValidXYZ(void * jarg1) {
  unsigned int jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  bool result;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  {
    try
    {
      result = (bool)((LizardTech::PointInfo const *)arg1)->hasValidXYZ();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointInfo_Equals(void * jarg1, void * jarg2) {
  unsigned int jresult ;
  LizardTech::PointInfo *arg1 = (LizardTech::PointInfo *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  bool result;
  
  arg1 = (LizardTech::PointInfo *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::PointInfo const *)arg1)->operator ==((LizardTech::PointInfo const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ChannelData(void * jarg1) {
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ChannelData() {
  void * jresult ;
  LizardTech::ChannelData *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::ChannelData *)new LizardTech::ChannelData();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_init(void * jarg1, void * jarg2, unsigned long jarg3) {
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  LizardTech::ChannelInfo *arg2 = 0 ;
  size_t arg3 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  arg2 = (LizardTech::ChannelInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelInfo const & type is null", 0);
    return ;
  } 
  arg3 = (size_t)jarg3; 
  {
    try
    {
      (arg1)->init((LizardTech::ChannelInfo const &)*arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_ChannelData_getNumSamples(void * jarg1) {
  unsigned long jresult ;
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  {
    try
    {
      result = ((LizardTech::ChannelData const *)arg1)->getNumSamples();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_copy(void * jarg1, unsigned long jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  LizardTech::ChannelData *arg1 = 0 ;
  size_t arg2 ;
  LizardTech::ChannelData *arg3 = 0 ;
  size_t arg4 ;
  size_t arg5 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData & type is null", 0);
    return ;
  } 
  arg2 = (size_t)jarg2; 
  arg3 = (LizardTech::ChannelData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = (size_t)jarg5; 
  {
    try
    {
      LizardTech::ChannelData::copy(*arg1,arg2,(LizardTech::ChannelData const &)*arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_convert__SWIG_0(void * jarg1, unsigned long jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  LizardTech::ChannelData *arg1 = 0 ;
  size_t arg2 ;
  LizardTech::ChannelData *arg3 = 0 ;
  size_t arg4 ;
  size_t arg5 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData & type is null", 0);
    return ;
  } 
  arg2 = (size_t)jarg2; 
  arg3 = (LizardTech::ChannelData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = (size_t)jarg5; 
  {
    try
    {
      LizardTech::ChannelData::convert(*arg1,arg2,(LizardTech::ChannelData const &)*arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_convert__SWIG_1(void * jarg1, unsigned long jarg2, void * jarg3, unsigned long jarg4, double jarg5, double jarg6, unsigned long jarg7) {
  LizardTech::ChannelData *arg1 = 0 ;
  size_t arg2 ;
  LizardTech::ChannelData *arg3 = 0 ;
  size_t arg4 ;
  double arg5 ;
  double arg6 ;
  size_t arg7 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData & type is null", 0);
    return ;
  } 
  arg2 = (size_t)jarg2; 
  arg3 = (LizardTech::ChannelData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::ChannelData const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = (double)jarg5; 
  arg6 = (double)jarg6; 
  arg7 = (size_t)jarg7; 
  {
    try
    {
      LizardTech::ChannelData::convert(*arg1,arg2,(LizardTech::ChannelData const &)*arg3,arg4,arg5,arg6,arg7);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_resize(void * jarg1, unsigned long jarg2) {
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->resize(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_setOffset(void * jarg1, unsigned long jarg2) {
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->setOffset(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ChannelData_setData(void * jarg1, void * jarg2, unsigned int jarg3) {
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  void *arg2 = (void *) 0 ;
  bool arg3 ;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  arg2 = (void *)jarg2; 
  arg3 = jarg3 ? true : false; 
  {
    try
    {
      (arg1)->setData(arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_ChannelData_getValue(void * jarg1, unsigned long jarg2) {
  double jresult ;
  LizardTech::ChannelData *arg1 = (LizardTech::ChannelData *) 0 ;
  size_t arg2 ;
  double result;
  
  arg1 = (LizardTech::ChannelData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (double)LizardTech_ChannelData_getValue(arg1,arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointData(void * jarg1) {
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PointData() {
  void * jresult ;
  LizardTech::PointData *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::PointData *)new LizardTech::PointData();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointData_init(void * jarg1, void * jarg2, unsigned long jarg3) {
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  size_t arg3 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  arg3 = (size_t)jarg3; 
  {
    try
    {
      (arg1)->init((LizardTech::PointInfo const &)*arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointData_getNumChannels(void * jarg1) {
  unsigned long jresult ;
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  {
    try
    {
      result = ((LizardTech::PointData const *)arg1)->getNumChannels();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointData_getNumSamples(void * jarg1) {
  unsigned long jresult ;
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  {
    try
    {
      result = ((LizardTech::PointData const *)arg1)->getNumSamples();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointData_getChannel__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  size_t arg2 ;
  LizardTech::ChannelData *result = 0 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelData *) &((LizardTech::PointData const *)arg1)->getChannel(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointData_hasChannel(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (bool)((LizardTech::PointData const *)arg1)->hasChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointData_getChannel__SWIG_2(void * jarg1, char * jarg2) {
  void * jresult ;
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::ChannelData *result = 0 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelData *)((LizardTech::PointData const *)arg1)->getChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointData_copy(void * jarg1, unsigned long jarg2, void * jarg3, unsigned long jarg4, unsigned long jarg5) {
  LizardTech::PointData *arg1 = 0 ;
  size_t arg2 ;
  LizardTech::PointData *arg3 = 0 ;
  size_t arg4 ;
  size_t arg5 ;
  
  arg1 = (LizardTech::PointData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData & type is null", 0);
    return ;
  } 
  arg2 = (size_t)jarg2; 
  arg3 = (LizardTech::PointData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = (size_t)jarg5; 
  {
    try
    {
      LizardTech::PointData::copy(*arg1,arg2,(LizardTech::PointData const &)*arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointData_merge(void * jarg1, unsigned long jarg2, void * jarg3, unsigned long jarg4) {
  LizardTech::PointData *arg1 = 0 ;
  size_t arg2 ;
  LizardTech::PointData *arg3 = 0 ;
  size_t arg4 ;
  
  arg1 = (LizardTech::PointData *)jarg1;
  if (!arg1) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData & type is null", 0);
    return ;
  } 
  arg2 = (size_t)jarg2; 
  arg3 = (LizardTech::PointData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      LizardTech::PointData::merge(*arg1,arg2,(LizardTech::PointData const &)*arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointData_resize(void * jarg1, unsigned long jarg2) {
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->resize(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointData_setOffset(void * jarg1, unsigned long jarg2) {
  LizardTech::PointData *arg1 = (LizardTech::PointData *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::PointData *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->setOffset(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT int SWIGSTDCALL CSharp_Object_retain(void * jarg1) {
  int jresult ;
  LizardTech::Object *arg1 = (LizardTech::Object *) 0 ;
  int result;
  
  arg1 = (LizardTech::Object *)jarg1; 
  {
    try
    {
      result = (int)((LizardTech::Object const *)arg1)->retain();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Object_release(void * jarg1) {
  int jresult ;
  LizardTech::Object *arg1 = (LizardTech::Object *) 0 ;
  int result;
  
  arg1 = (LizardTech::Object *)jarg1; 
  {
    try
    {
      result = (int)((LizardTech::Object const *)arg1)->release();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IO_open(void * jarg1) {
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  
  arg1 = (LizardTech::IO *)jarg1; 
  {
    try
    {
      (arg1)->open();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_IO_close(void * jarg1) {
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  
  arg1 = (LizardTech::IO *)jarg1; 
  {
    try
    {
      (arg1)->close();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_IO_pread(void * jarg1, long long jarg2, void * jarg3, unsigned long jarg4) {
  unsigned long jresult ;
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  LizardTech::IO::offset_type arg2 ;
  void *arg3 = (void *) 0 ;
  size_t arg4 ;
  size_t result;
  
  arg1 = (LizardTech::IO *)jarg1; 
  arg2 = (LizardTech::IO::offset_type)jarg2; 
  arg3 = (void *)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      result = ((LizardTech::IO const *)arg1)->pread(arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_IO_pwrite(void * jarg1, long long jarg2, void * jarg3, unsigned long jarg4) {
  unsigned long jresult ;
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  LizardTech::IO::offset_type arg2 ;
  void *arg3 = (void *) 0 ;
  size_t arg4 ;
  size_t result;
  
  arg1 = (LizardTech::IO *)jarg1; 
  arg2 = (LizardTech::IO::offset_type)jarg2; 
  arg3 = (void *)jarg3; 
  arg4 = (size_t)jarg4; 
  {
    try
    {
      result = ((LizardTech::IO const *)arg1)->pwrite(arg2,(void const *)arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT long long SWIGSTDCALL CSharp_IO_size(void * jarg1) {
  long long jresult ;
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  LizardTech::IO::offset_type result;
  
  arg1 = (LizardTech::IO *)jarg1; 
  {
    try
    {
      result = (LizardTech::IO::offset_type)((LizardTech::IO const *)arg1)->size();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_IO_truncate(void * jarg1, long long jarg2) {
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  LizardTech::IO::offset_type arg2 ;
  
  arg1 = (LizardTech::IO *)jarg1; 
  arg2 = (LizardTech::IO::offset_type)jarg2; 
  {
    try
    {
      (arg1)->truncate(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_IO_unlink(void * jarg1) {
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  
  arg1 = (LizardTech::IO *)jarg1; 
  {
    try
    {
      (arg1)->unlink();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_IO(void * jarg1) {
  LizardTech::IO *arg1 = (LizardTech::IO *) 0 ;
  
  arg1 = (LizardTech::IO *)jarg1; 
  {
    try
    {
      delete_LizardTech_IO(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_FileIO_init__SWIG_0(void * jarg1, wchar_t * jarg2, char * jarg3) {
  LizardTech::FileIO *arg1 = (LizardTech::FileIO *) 0 ;
  wchar_t *arg2 = (wchar_t *) 0 ;
  char *arg3 = (char *) 0 ;
  
  arg1 = (LizardTech::FileIO *)jarg1; 
  arg2 = (wchar_t *)jarg2; 
  arg3 = (char *)jarg3; 
  {
    try
    {
      (arg1)->init((wchar_t const *)arg2,(char const *)arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_FileIO_init__SWIG_1(void * jarg1, wchar_t * jarg2) {
  LizardTech::FileIO *arg1 = (LizardTech::FileIO *) 0 ;
  wchar_t *arg2 = (wchar_t *) 0 ;
  
  arg1 = (LizardTech::FileIO *)jarg1; 
  arg2 = (wchar_t *)jarg2; 
  {
    try
    {
      (arg1)->init((wchar_t const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_FileIO(void * jarg1) {
  LizardTech::FileIO *arg1 = (LizardTech::FileIO *) 0 ;
  
  arg1 = (LizardTech::FileIO *)jarg1; 
  {
    try
    {
      delete_LizardTech_FileIO(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_FileIO() {
  void * jresult ;
  LizardTech::FileIO *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::FileIO *)new_LizardTech_FileIO();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_FileSourceID_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("FileSourceID");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_ProjectID_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("ProjectID");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_SystemID_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("SystemID");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_GeneratingSoftware_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("GeneratingSoftware");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_FileCreationDate_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("FileCreationDate");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_PointRecordsByReturnCount_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PointRecordsByReturnCount");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_PreCompressionPointCount_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("PreCompressionPointCount");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_METADATA_KEY_LASBBox_get() {
  char * jresult ;
  char *result = 0 ;
  
  result = (char *)("LAS_BoundingBox");
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Metadata(void * jarg1) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Metadata() {
  void * jresult ;
  LizardTech::Metadata *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::Metadata *)new LizardTech::Metadata();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Metadata_getNumRecords(void * jarg1) {
  unsigned long jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  {
    try
    {
      result = ((LizardTech::Metadata const *)arg1)->getNumRecords();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_Metadata_has(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (bool)((LizardTech::Metadata const *)arg1)->has((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Metadata_getKeyIndex(void * jarg1, char * jarg2) {
  unsigned long jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  char *arg2 = (char *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = ((LizardTech::Metadata const *)arg1)->getKeyIndex((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Metadata_getKey(void * jarg1, unsigned long jarg2) {
  char * jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (char *)((LizardTech::Metadata const *)arg1)->getKey(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Metadata_getDescription(void * jarg1, unsigned long jarg2) {
  char * jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (char *)((LizardTech::Metadata const *)arg1)->getDescription(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Metadata_getDataType(void * jarg1, unsigned long jarg2) {
  int jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  LizardTech::MetadataDataType result;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (LizardTech::MetadataDataType)((LizardTech::Metadata const *)arg1)->getDataType(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_Metadata_getValue(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  void *result = 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (void *)((LizardTech::Metadata const *)arg1)->getValue(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_Metadata_getValueLength(void * jarg1, unsigned long jarg2) {
  unsigned long jresult ;
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  size_t result;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = ((LizardTech::Metadata const *)arg1)->getValueLength(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_add__SWIG_0(void * jarg1, char * jarg2, char * jarg3, int jarg4, void * jarg5, unsigned long jarg6) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  LizardTech::MetadataDataType arg4 ;
  void *arg5 = (void *) 0 ;
  size_t arg6 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (LizardTech::MetadataDataType)jarg4; 
  arg5 = (void *)jarg5; 
  arg6 = (size_t)jarg6; 
  {
    try
    {
      (arg1)->add((char const *)arg2,(char const *)arg3,arg4,(void const *)arg5,arg6);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_add__SWIG_1(void * jarg1, void * jarg2) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  LizardTech::Metadata *arg2 = 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (LizardTech::Metadata *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Metadata const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->add((LizardTech::Metadata const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_remove__SWIG_0(void * jarg1) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  {
    try
    {
      (arg1)->remove();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_remove__SWIG_1(void * jarg1, unsigned long jarg2) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->remove(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_remove__SWIG_2(void * jarg1, char * jarg2) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->remove((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_Metadata_sort(void * jarg1) {
  LizardTech::Metadata *arg1 = (LizardTech::Metadata *) 0 ;
  
  arg1 = (LizardTech::Metadata *)jarg1; 
  {
    try
    {
      (arg1)->sort();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_ProgressDelegate(void * jarg1) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_reportProgress(void * jarg1, double jarg2, char * jarg3) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  double arg2 ;
  char *arg3 = (char *) 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (char *)jarg3; 
  {
    try
    {
      (arg1)->reportProgress(arg2,(char const *)arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_ProgressDelegate_getCancelled(void * jarg1) {
  unsigned int jresult ;
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  bool result;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  {
    try
    {
      result = (bool)(arg1)->getCancelled();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_setTotal(void * jarg1, double jarg2) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  double arg2 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (double)jarg2; 
  {
    try
    {
      (arg1)->setTotal(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_updateCompleted(void * jarg1, double jarg2, char * jarg3) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  double arg2 ;
  char *arg3 = (char *) 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (double)jarg2; 
  arg3 = (char *)jarg3; 
  {
    try
    {
      (arg1)->updateCompleted(arg2,(char const *)arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT double SWIGSTDCALL CSharp_ProgressDelegate_getProgress(void * jarg1) {
  double jresult ;
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  double result;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  {
    try
    {
      result = (double)((LizardTech::ProgressDelegate const *)arg1)->getProgress();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_warning(void * jarg1, char * jarg2) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  char *arg2 = (char *) 0 ;
  void *arg3 = 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->warning((char const *)arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_displayWarning(void * jarg1, char * jarg2) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->displayWarning((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_displayWarningSwigExplicitProgressDelegate(void * jarg1, char * jarg2) {
  LizardTech::ProgressDelegate *arg1 = (LizardTech::ProgressDelegate *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (LizardTech::ProgressDelegate *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->LizardTech::ProgressDelegate::displayWarning((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_ProgressDelegate() {
  void * jresult ;
  LizardTech::ProgressDelegate *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::ProgressDelegate *)new SwigDirector_ProgressDelegate();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_ProgressDelegate_director_connect(void *objarg, SwigDirector_ProgressDelegate::SWIG_Callback0_t callback0, SwigDirector_ProgressDelegate::SWIG_Callback1_t callback1, SwigDirector_ProgressDelegate::SWIG_Callback2_t callback2) {
  LizardTech::ProgressDelegate *obj = (LizardTech::ProgressDelegate *)objarg;
  SwigDirector_ProgressDelegate *director = dynamic_cast<SwigDirector_ProgressDelegate *>(obj);
  if (director) {
    director->swig_connect_director(callback0, callback1, callback2);
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_PercentProgressDelegate() {
  void * jresult ;
  LizardTech::PercentProgressDelegate *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::PercentProgressDelegate *)new LizardTech::PercentProgressDelegate();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PercentProgressDelegate(void * jarg1) {
  LizardTech::PercentProgressDelegate *arg1 = (LizardTech::PercentProgressDelegate *) 0 ;
  
  arg1 = (LizardTech::PercentProgressDelegate *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PercentProgressDelegate_setCancelled(void * jarg1, unsigned int jarg2) {
  LizardTech::PercentProgressDelegate *arg1 = (LizardTech::PercentProgressDelegate *) 0 ;
  bool arg2 ;
  
  arg1 = (LizardTech::PercentProgressDelegate *)jarg1; 
  arg2 = jarg2 ? true : false; 
  {
    try
    {
      (arg1)->setCancelled(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointIterator_getNextPoints(void * jarg1, void * jarg2) {
  unsigned long jresult ;
  LizardTech::PointIterator *arg1 = (LizardTech::PointIterator *) 0 ;
  LizardTech::PointData *arg2 = 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointIterator *)jarg1; 
  arg2 = (LizardTech::PointData *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (arg1)->getNextPoints(*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointIterator(void * jarg1) {
  LizardTech::PointIterator *arg1 = (LizardTech::PointIterator *) 0 ;
  
  arg1 = (LizardTech::PointIterator *)jarg1; 
  {
    try
    {
      delete_LizardTech_PointIterator(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointSource_getPointInfo(void * jarg1) {
  void * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::PointInfo *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (LizardTech::PointInfo *) &((LizardTech::PointSource const *)arg1)->getPointInfo();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointSource_getNumChannels(void * jarg1) {
  unsigned long jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = ((LizardTech::PointSource const *)arg1)->getNumChannels();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointSource_hasChannel(void * jarg1, char * jarg2) {
  unsigned int jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  char *arg2 = (char *) 0 ;
  bool result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (bool)((LizardTech::PointSource const *)arg1)->hasChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointSource_getChannel__SWIG_0(void * jarg1, unsigned long jarg2) {
  void * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  size_t arg2 ;
  LizardTech::ChannelInfo *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelInfo *) &((LizardTech::PointSource const *)arg1)->getChannel(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointSource_getChannel__SWIG_1(void * jarg1, char * jarg2) {
  void * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::ChannelInfo *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      result = (LizardTech::ChannelInfo *)((LizardTech::PointSource const *)arg1)->getChannel((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT long long SWIGSTDCALL CSharp_PointSource_getNumPoints(void * jarg1) {
  long long jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::PointSource::count_type result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (LizardTech::PointSource::count_type)((LizardTech::PointSource const *)arg1)->getNumPoints();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_PointSource_getWKT(void * jarg1) {
  char * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (char *)((LizardTech::PointSource const *)arg1)->getWKT();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointSource_loadMetadata(void * jarg1, void * jarg2, unsigned int jarg3) {
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::Metadata *arg2 = 0 ;
  bool arg3 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (LizardTech::Metadata *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Metadata & type is null", 0);
    return ;
  } 
  arg3 = jarg3 ? true : false; 
  {
    try
    {
      ((LizardTech::PointSource const *)arg1)->loadMetadata(*arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointSource_getBounds(void * jarg1) {
  void * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::Bounds *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (LizardTech::Bounds *) &((LizardTech::PointSource const *)arg1)->getBounds();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT double * SWIGSTDCALL CSharp_PointSource_getScale(void * jarg1) {
  double * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  double *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (double *)((LizardTech::PointSource const *)arg1)->getScale();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT double * SWIGSTDCALL CSharp_PointSource_getOffset(void * jarg1) {
  double * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  double *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (double *)((LizardTech::PointSource const *)arg1)->getOffset();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointSource_getNumClassIdNames(void * jarg1) {
  unsigned long jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = ((LizardTech::PointSource const *)arg1)->getNumClassIdNames();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT char ** SWIGSTDCALL CSharp_PointSource_getClassIdNames(void * jarg1) {
  char ** jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  char **result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      result = (char **)((LizardTech::PointSource const *)arg1)->getClassIdNames();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT double SWIGSTDCALL CSharp_PointSource_getTotalWork(void * jarg1, void * jarg2, double jarg3) {
  double jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  double arg3 ;
  double result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  {
    try
    {
      result = (double)((LizardTech::PointSource const *)arg1)->getTotalWork((LizardTech::Bounds const &)*arg2,arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointSource_createIterator(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5) {
  void * jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  double arg3 ;
  LizardTech::PointInfo *arg4 = 0 ;
  LizardTech::ProgressDelegate *arg5 = (LizardTech::ProgressDelegate *) 0 ;
  LizardTech::PointIterator *result = 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  arg4 = (LizardTech::PointInfo *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return 0;
  } 
  arg5 = (LizardTech::ProgressDelegate *)jarg5; 
  {
    try
    {
      result = (LizardTech::PointIterator *)((LizardTech::PointSource const *)arg1)->createIterator((LizardTech::Bounds const &)*arg2,arg3,(LizardTech::PointInfo const &)*arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  
  return jresult;
}


SWIGEXPORT unsigned long SWIGSTDCALL CSharp_PointSource_read(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  unsigned long jresult ;
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  LizardTech::PointData *arg3 = 0 ;
  LizardTech::ProgressDelegate *arg4 = (LizardTech::ProgressDelegate *) 0 ;
  size_t result;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  arg3 = (LizardTech::PointData *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData & type is null", 0);
    return 0;
  } 
  arg4 = (LizardTech::ProgressDelegate *)jarg4; 
  {
    try
    {
      result = ((LizardTech::PointSource const *)arg1)->read((LizardTech::Bounds const &)*arg2,*arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (unsigned long)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointSource(void * jarg1) {
  LizardTech::PointSource *arg1 = (LizardTech::PointSource *) 0 ;
  
  arg1 = (LizardTech::PointSource *)jarg1; 
  {
    try
    {
      delete_LizardTech_PointSource(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointReader_overrideWKT(void * jarg1, char * jarg2) {
  LizardTech::PointReader *arg1 = (LizardTech::PointReader *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (LizardTech::PointReader *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->overrideWKT((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT char * SWIGSTDCALL CSharp_PointReader_getFileFormatString(void * jarg1) {
  char * jresult ;
  LizardTech::PointReader *arg1 = (LizardTech::PointReader *) 0 ;
  char *result = 0 ;
  
  arg1 = (LizardTech::PointReader *)jarg1; 
  {
    try
    {
      result = (char *)((LizardTech::PointReader const *)arg1)->getFileFormatString();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointReader(void * jarg1) {
  LizardTech::PointReader *arg1 = (LizardTech::PointReader *) 0 ;
  
  arg1 = (LizardTech::PointReader *)jarg1; 
  {
    try
    {
      delete_LizardTech_PointReader(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointWriter_setMetadata(void * jarg1, void * jarg2) {
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  LizardTech::Metadata *arg2 = 0 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  arg2 = (LizardTech::Metadata *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Metadata const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->setMetadata((LizardTech::Metadata const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_PointWriter_getMetadata(void * jarg1) {
  void * jresult ;
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  LizardTech::Metadata *result = 0 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  {
    try
    {
      result = (LizardTech::Metadata *) &(arg1)->getMetadata();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointWriter_setQuantization(void * jarg1, double* jarg2, double* jarg3) {
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  double *arg2 ;
  double *arg3 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  arg2 = jarg2;
  arg3 = jarg3;
  {
    try
    {
      (arg1)->setQuantization((double const (*))arg2,(double const (*))arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
  
  
  
  
}


SWIGEXPORT double * SWIGSTDCALL CSharp_PointWriter_getScale(void * jarg1) {
  double * jresult ;
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  double *result = 0 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  {
    try
    {
      result = (double *)((LizardTech::PointWriter const *)arg1)->getScale();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT double * SWIGSTDCALL CSharp_PointWriter_getOffset(void * jarg1) {
  double * jresult ;
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  double *result = 0 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  {
    try
    {
      result = (double *)((LizardTech::PointWriter const *)arg1)->getOffset();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result;
  return jresult;
}


SWIGEXPORT long long SWIGSTDCALL CSharp_PointWriter_write(void * jarg1, void * jarg2, double jarg3, void * jarg4, void * jarg5) {
  long long jresult ;
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  LizardTech::Bounds *arg2 = 0 ;
  double arg3 ;
  LizardTech::PointInfo *arg4 = 0 ;
  LizardTech::ProgressDelegate *arg5 = (LizardTech::ProgressDelegate *) 0 ;
  LizardTech::PointWriter::count_type result;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  arg2 = (LizardTech::Bounds *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return 0;
  } 
  arg3 = (double)jarg3; 
  arg4 = (LizardTech::PointInfo *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return 0;
  } 
  arg5 = (LizardTech::ProgressDelegate *)jarg5; 
  {
    try
    {
      result = (LizardTech::PointWriter::count_type)(arg1)->write((LizardTech::Bounds const &)*arg2,arg3,(LizardTech::PointInfo const &)*arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_PointWriter_setChunckSize(void * jarg1, unsigned long jarg2) {
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  size_t arg2 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  arg2 = (size_t)jarg2; 
  {
    try
    {
      (arg1)->setChunckSize(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT unsigned int SWIGSTDCALL CSharp_PointWriter_supportedChannels(void * jarg1, void * jarg2, void * jarg3) {
  unsigned int jresult ;
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  LizardTech::PointInfo *arg3 = 0 ;
  bool result;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return 0;
  } 
  arg3 = (LizardTech::PointInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo & type is null", 0);
    return 0;
  } 
  {
    try
    {
      result = (bool)((LizardTech::PointWriter const *)arg1)->supportedChannels((LizardTech::PointInfo const &)*arg2,*arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_PointWriter(void * jarg1) {
  LizardTech::PointWriter *arg1 = (LizardTech::PointWriter *) 0 ;
  
  arg1 = (LizardTech::PointWriter *)jarg1; 
  {
    try
    {
      delete_LizardTech_PointWriter(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_SimplePointWriter_writeBegin(void * jarg1, void * jarg2) {
  LizardTech::SimplePointWriter *arg1 = (LizardTech::SimplePointWriter *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  
  arg1 = (LizardTech::SimplePointWriter *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->writeBegin((LizardTech::PointInfo const &)*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_SimplePointWriter_writePoints(void * jarg1, void * jarg2, unsigned long jarg3, void * jarg4) {
  LizardTech::SimplePointWriter *arg1 = (LizardTech::SimplePointWriter *) 0 ;
  LizardTech::PointData *arg2 = 0 ;
  size_t arg3 ;
  LizardTech::ProgressDelegate *arg4 = (LizardTech::ProgressDelegate *) 0 ;
  
  arg1 = (LizardTech::SimplePointWriter *)jarg1; 
  arg2 = (LizardTech::PointData *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointData const & type is null", 0);
    return ;
  } 
  arg3 = (size_t)jarg3; 
  arg4 = (LizardTech::ProgressDelegate *)jarg4; 
  {
    try
    {
      (arg1)->writePoints((LizardTech::PointData const &)*arg2,arg3,arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_SimplePointWriter_writeEnd(void * jarg1, long long jarg2, void * jarg3) {
  LizardTech::SimplePointWriter *arg1 = (LizardTech::SimplePointWriter *) 0 ;
  LizardTech::PointSource::count_type arg2 ;
  LizardTech::Bounds *arg3 = 0 ;
  
  arg1 = (LizardTech::SimplePointWriter *)jarg1; 
  arg2 = (LizardTech::PointSource::count_type)jarg2; 
  arg3 = (LizardTech::Bounds *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::Bounds const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->writeEnd(arg2,(LizardTech::Bounds const &)*arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_SimplePointWriter(void * jarg1) {
  LizardTech::SimplePointWriter *arg1 = (LizardTech::SimplePointWriter *) 0 ;
  
  arg1 = (LizardTech::SimplePointWriter *)jarg1; 
  {
    try
    {
      delete_LizardTech_SimplePointWriter(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_init__SWIG_0(void * jarg1, char * jarg2, char * jarg3, unsigned long jarg4, unsigned int jarg5) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  char *arg2 = (char *) 0 ;
  char *arg3 = (char *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (size_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try
    {
      (arg1)->init((char const *)arg2,(char const *)arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_init__SWIG_1(void * jarg1, void * jarg2, char * jarg3, unsigned long jarg4, unsigned int jarg5) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  LizardTech::IO *arg2 = (LizardTech::IO *) 0 ;
  char *arg3 = (char *) 0 ;
  size_t arg4 ;
  bool arg5 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  arg2 = (LizardTech::IO *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (size_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try
    {
      (arg1)->init(arg2,(char const *)arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_init__SWIG_2(void * jarg1, char * jarg2, void * jarg3, unsigned long jarg4, unsigned int jarg5) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  char *arg2 = (char *) 0 ;
  LizardTech::PointInfo *arg3 = 0 ;
  size_t arg4 ;
  bool arg5 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  arg2 = (char *)jarg2; 
  arg3 = (LizardTech::PointInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try
    {
      (arg1)->init((char const *)arg2,(LizardTech::PointInfo const &)*arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_init__SWIG_3(void * jarg1, void * jarg2, void * jarg3, unsigned long jarg4, unsigned int jarg5) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  LizardTech::IO *arg2 = (LizardTech::IO *) 0 ;
  LizardTech::PointInfo *arg3 = 0 ;
  size_t arg4 ;
  bool arg5 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  arg2 = (LizardTech::IO *)jarg2; 
  arg3 = (LizardTech::PointInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  arg4 = (size_t)jarg4; 
  arg5 = jarg5 ? true : false; 
  {
    try
    {
      (arg1)->init(arg2,(LizardTech::PointInfo const &)*arg3,arg4,arg5);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_initBoundsAndNumPoints(void * jarg1) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  {
    try
    {
      (arg1)->initBoundsAndNumPoints();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_parseFormat__SWIG_0(char * jarg1, void * jarg2) {
  char *arg1 = (char *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  
  arg1 = (char *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo & type is null", 0);
    return ;
  } 
  {
    try
    {
      LizardTech::TXTPointReader::parseFormat((char const *)arg1,*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_parseFormat__SWIG_1(char * jarg1, void * jarg2, void * jarg3) {
  char *arg1 = (char *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  LizardTech::PointInfo *arg3 = 0 ;
  
  arg1 = (char *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo & type is null", 0);
    return ;
  } 
  arg3 = (LizardTech::PointInfo *)jarg3;
  if (!arg3) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      LizardTech::TXTPointReader::parseFormat((char const *)arg1,*arg2,(LizardTech::PointInfo const &)*arg3);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointReader_parseQuantization(char * jarg1, void * jarg2) {
  char *arg1 = (char *) 0 ;
  LizardTech::PointInfo *arg2 = 0 ;
  
  arg1 = (char *)jarg1; 
  arg2 = (LizardTech::PointInfo *)jarg2;
  if (!arg2) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo & type is null", 0);
    return ;
  } 
  {
    try
    {
      LizardTech::TXTPointReader::parseQuantization((char const *)arg1,*arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_TXTPointReader(void * jarg1) {
  LizardTech::TXTPointReader *arg1 = (LizardTech::TXTPointReader *) 0 ;
  
  arg1 = (LizardTech::TXTPointReader *)jarg1; 
  {
    try
    {
      delete_LizardTech_TXTPointReader(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TXTPointReader() {
  void * jresult ;
  LizardTech::TXTPointReader *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::TXTPointReader *)new_LizardTech_TXTPointReader();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointWriter_init__SWIG_0(void * jarg1, void * jarg2, char * jarg3, char * jarg4) {
  LizardTech::TXTPointWriter *arg1 = (LizardTech::TXTPointWriter *) 0 ;
  LizardTech::PointSource *arg2 = (LizardTech::PointSource *) 0 ;
  char *arg3 = (char *) 0 ;
  char *arg4 = (char *) 0 ;
  
  arg1 = (LizardTech::TXTPointWriter *)jarg1; 
  arg2 = (LizardTech::PointSource *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (char *)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointSource const *)arg2,(char const *)arg3,(char const *)arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointWriter_init__SWIG_1(void * jarg1, void * jarg2, void * jarg3, char * jarg4) {
  LizardTech::TXTPointWriter *arg1 = (LizardTech::TXTPointWriter *) 0 ;
  LizardTech::PointSource *arg2 = (LizardTech::PointSource *) 0 ;
  LizardTech::IO *arg3 = (LizardTech::IO *) 0 ;
  char *arg4 = (char *) 0 ;
  
  arg1 = (LizardTech::TXTPointWriter *)jarg1; 
  arg2 = (LizardTech::PointSource *)jarg2; 
  arg3 = (LizardTech::IO *)jarg3; 
  arg4 = (char *)jarg4; 
  {
    try
    {
      (arg1)->init((LizardTech::PointSource const *)arg2,arg3,(char const *)arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointWriter_init__SWIG_2(void * jarg1, void * jarg2, char * jarg3, void * jarg4) {
  LizardTech::TXTPointWriter *arg1 = (LizardTech::TXTPointWriter *) 0 ;
  LizardTech::PointSource *arg2 = (LizardTech::PointSource *) 0 ;
  char *arg3 = (char *) 0 ;
  LizardTech::PointInfo *arg4 = 0 ;
  
  arg1 = (LizardTech::TXTPointWriter *)jarg1; 
  arg2 = (LizardTech::PointSource *)jarg2; 
  arg3 = (char *)jarg3; 
  arg4 = (LizardTech::PointInfo *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->init((LizardTech::PointSource const *)arg2,(char const *)arg3,(LizardTech::PointInfo const &)*arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_TXTPointWriter_init__SWIG_3(void * jarg1, void * jarg2, void * jarg3, void * jarg4) {
  LizardTech::TXTPointWriter *arg1 = (LizardTech::TXTPointWriter *) 0 ;
  LizardTech::PointSource *arg2 = (LizardTech::PointSource *) 0 ;
  LizardTech::IO *arg3 = (LizardTech::IO *) 0 ;
  LizardTech::PointInfo *arg4 = 0 ;
  
  arg1 = (LizardTech::TXTPointWriter *)jarg1; 
  arg2 = (LizardTech::PointSource *)jarg2; 
  arg3 = (LizardTech::IO *)jarg3; 
  arg4 = (LizardTech::PointInfo *)jarg4;
  if (!arg4) {
    SWIG_CSharpSetPendingExceptionArgument(SWIG_CSharpArgumentNullException, "LizardTech::PointInfo const & type is null", 0);
    return ;
  } 
  {
    try
    {
      (arg1)->init((LizardTech::PointSource const *)arg2,arg3,(LizardTech::PointInfo const &)*arg4);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_TXTPointWriter(void * jarg1) {
  LizardTech::TXTPointWriter *arg1 = (LizardTech::TXTPointWriter *) 0 ;
  
  arg1 = (LizardTech::TXTPointWriter *)jarg1; 
  {
    try
    {
      delete_LizardTech_TXTPointWriter(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_TXTPointWriter() {
  void * jresult ;
  LizardTech::TXTPointWriter *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::TXTPointWriter *)new_LizardTech_TXTPointWriter();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_getSDKMajorVersion() {
  int jresult ;
  int result;
  
  {
    try
    {
      result = (int)LizardTech::Version::getSDKMajorVersion();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_getSDKMinorVersion() {
  int jresult ;
  int result;
  
  {
    try
    {
      result = (int)LizardTech::Version::getSDKMinorVersion();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_getSDKVersionAge() {
  int jresult ;
  int result;
  
  {
    try
    {
      result = (int)LizardTech::Version::getSDKVersionAge();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT int SWIGSTDCALL CSharp_Version_getSDKBuildNumber() {
  int jresult ;
  int result;
  
  {
    try
    {
      result = (int)LizardTech::Version::getSDKBuildNumber();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = result; 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Version_getSDKVersionString() {
  char * jresult ;
  char *result = 0 ;
  
  {
    try
    {
      result = (char *)LizardTech::Version::getSDKVersionString();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT char * SWIGSTDCALL CSharp_Version_getSDKBuildDate() {
  char * jresult ;
  char *result = 0 ;
  
  {
    try
    {
      result = (char *)LizardTech::Version::getSDKBuildDate();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = SWIG_csharp_string_callback((const char *)result); 
  return jresult;
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_Version() {
  void * jresult ;
  LizardTech::Version *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::Version *)new LizardTech::Version();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  return jresult;
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_Version(void * jarg1) {
  LizardTech::Version *arg1 = (LizardTech::Version *) 0 ;
  
  arg1 = (LizardTech::Version *)jarg1; 
  {
    try
    {
      delete arg1;
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_MG4PointReader_init__SWIG_0(void * jarg1, char * jarg2) {
  LizardTech::MG4PointReader *arg1 = (LizardTech::MG4PointReader *) 0 ;
  char *arg2 = (char *) 0 ;
  
  arg1 = (LizardTech::MG4PointReader *)jarg1; 
  arg2 = (char *)jarg2; 
  {
    try
    {
      (arg1)->init((char const *)arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_MG4PointReader_init__SWIG_1(void * jarg1, void * jarg2) {
  LizardTech::MG4PointReader *arg1 = (LizardTech::MG4PointReader *) 0 ;
  LizardTech::IO *arg2 = (LizardTech::IO *) 0 ;
  
  arg1 = (LizardTech::MG4PointReader *)jarg1; 
  arg2 = (LizardTech::IO *)jarg2; 
  {
    try
    {
      (arg1)->init(arg2);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void SWIGSTDCALL CSharp_delete_MG4PointReader(void * jarg1) {
  LizardTech::MG4PointReader *arg1 = (LizardTech::MG4PointReader *) 0 ;
  
  arg1 = (LizardTech::MG4PointReader *)jarg1; 
  {
    try
    {
      delete_LizardTech_MG4PointReader(arg1);
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return ; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return ; 
      };
    }
  }
}


SWIGEXPORT void * SWIGSTDCALL CSharp_new_MG4PointReader() {
  void * jresult ;
  LizardTech::MG4PointReader *result = 0 ;
  
  {
    try
    {
      result = (LizardTech::MG4PointReader *)new_LizardTech_MG4PointReader();
    }
    catch(std::exception &err)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, err.what()); return 0; 
      };
    }
    catch(...)
    {
      {
        SWIG_CSharpException(SWIG_RuntimeError, "Unknown exception"); return 0; 
      };
    }
  }
  jresult = (void *)result; 
  
  return jresult;
}


SWIGEXPORT LizardTech::ChannelInfo * SWIGSTDCALL CSharp_ChannelData_SWIGUpcast(LizardTech::ChannelData *jarg1) {
    return (LizardTech::ChannelInfo *)jarg1;
}

SWIGEXPORT LizardTech::Object * SWIGSTDCALL CSharp_IO_SWIGUpcast(LizardTech::IO *jarg1) {
    return (LizardTech::Object *)jarg1;
}

SWIGEXPORT LizardTech::IO * SWIGSTDCALL CSharp_FileIO_SWIGUpcast(LizardTech::FileIO *jarg1) {
    return (LizardTech::IO *)jarg1;
}

SWIGEXPORT LizardTech::ProgressDelegate * SWIGSTDCALL CSharp_PercentProgressDelegate_SWIGUpcast(LizardTech::PercentProgressDelegate *jarg1) {
    return (LizardTech::ProgressDelegate *)jarg1;
}

SWIGEXPORT LizardTech::Object * SWIGSTDCALL CSharp_PointIterator_SWIGUpcast(LizardTech::PointIterator *jarg1) {
    return (LizardTech::Object *)jarg1;
}

SWIGEXPORT LizardTech::Object * SWIGSTDCALL CSharp_PointSource_SWIGUpcast(LizardTech::PointSource *jarg1) {
    return (LizardTech::Object *)jarg1;
}

SWIGEXPORT LizardTech::PointSource * SWIGSTDCALL CSharp_PointReader_SWIGUpcast(LizardTech::PointReader *jarg1) {
    return (LizardTech::PointSource *)jarg1;
}

SWIGEXPORT LizardTech::Object * SWIGSTDCALL CSharp_PointWriter_SWIGUpcast(LizardTech::PointWriter *jarg1) {
    return (LizardTech::Object *)jarg1;
}

SWIGEXPORT LizardTech::PointWriter * SWIGSTDCALL CSharp_SimplePointWriter_SWIGUpcast(LizardTech::SimplePointWriter *jarg1) {
    return (LizardTech::PointWriter *)jarg1;
}

SWIGEXPORT LizardTech::PointReader * SWIGSTDCALL CSharp_TXTPointReader_SWIGUpcast(LizardTech::TXTPointReader *jarg1) {
    return (LizardTech::PointReader *)jarg1;
}

SWIGEXPORT LizardTech::SimplePointWriter * SWIGSTDCALL CSharp_TXTPointWriter_SWIGUpcast(LizardTech::TXTPointWriter *jarg1) {
    return (LizardTech::SimplePointWriter *)jarg1;
}

SWIGEXPORT LizardTech::PointReader * SWIGSTDCALL CSharp_MG4PointReader_SWIGUpcast(LizardTech::MG4PointReader *jarg1) {
    return (LizardTech::PointReader *)jarg1;
}

#ifdef __cplusplus
}
#endif

