# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.8
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.



from sys import version_info
if version_info >= (2,6,0):
    def swig_import_helper():
        from os.path import dirname
        import imp
        fp = None
        try:
            fp, pathname, description = imp.find_module('_LidarDSDK', [dirname(__file__)])
        except ImportError:
            import _LidarDSDK
            return _LidarDSDK
        if fp is not None:
            try:
                _mod = imp.load_module('_LidarDSDK', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _LidarDSDK = swig_import_helper()
    del swig_import_helper
else:
    import _LidarDSDK
del version_info
try:
    _swig_property = property
except NameError:
    pass # Python < 2.2 doesn't have 'property'.
def _swig_setattr_nondynamic(self,class_type,name,value,static=1):
    if (name == "thisown"): return self.this.own(value)
    if (name == "this"):
        if type(value).__name__ == 'SwigPyObject':
            self.__dict__[name] = value
            return
    method = class_type.__swig_setmethods__.get(name,None)
    if method: return method(self,value)
    if (not static):
        self.__dict__[name] = value
    else:
        raise AttributeError("You cannot add attributes to %s" % self)

def _swig_setattr(self,class_type,name,value):
    return _swig_setattr_nondynamic(self,class_type,name,value,0)

def _swig_getattr(self,class_type,name):
    if (name == "thisown"): return self.this.own()
    method = class_type.__swig_getmethods__.get(name,None)
    if method: return method(self)
    raise AttributeError(name)

def _swig_repr(self):
    try: strthis = "proxy of " + self.this.__repr__()
    except: strthis = ""
    return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)

try:
    _object = object
    _newclass = 1
except AttributeError:
    class _object : pass
    _newclass = 0


try:
    import weakref
    weakref_proxy = weakref.proxy
except:
    weakref_proxy = lambda x: x


class Range(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Range, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Range, name)
    __repr__ = _swig_repr
    __swig_setmethods__["min"] = _LidarDSDK.Range_min_set
    __swig_getmethods__["min"] = _LidarDSDK.Range_min_get
    if _newclass:min = _swig_property(_LidarDSDK.Range_min_get, _LidarDSDK.Range_min_set)
    __swig_setmethods__["max"] = _LidarDSDK.Range_max_set
    __swig_getmethods__["max"] = _LidarDSDK.Range_max_get
    if _newclass:max = _swig_property(_LidarDSDK.Range_max_get, _LidarDSDK.Range_max_set)
    def __init__(self, *args): 
        this = _LidarDSDK.new_Range(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args): return _LidarDSDK.Range___eq__(self, *args)
    def __ne__(self, *args): return _LidarDSDK.Range___ne__(self, *args)
    def contains(self, *args): return _LidarDSDK.Range_contains(self, *args)
    def overlaps(self, *args): return _LidarDSDK.Range_overlaps(self, *args)
    def empty(self): return _LidarDSDK.Range_empty(self)
    def length(self): return _LidarDSDK.Range_length(self)
    def shift(self, *args): return _LidarDSDK.Range_shift(self, *args)
    def scale(self, *args): return _LidarDSDK.Range_scale(self, *args)
    def clip(self, *args): return _LidarDSDK.Range_clip(self, *args)
    def grow(self, *args): return _LidarDSDK.Range_grow(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_Range
    __del__ = lambda self : None;
Range_swigregister = _LidarDSDK.Range_swigregister
Range_swigregister(Range)

class Bounds(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Bounds, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Bounds, name)
    __repr__ = _swig_repr
    __swig_setmethods__["x"] = _LidarDSDK.Bounds_x_set
    __swig_getmethods__["x"] = _LidarDSDK.Bounds_x_get
    if _newclass:x = _swig_property(_LidarDSDK.Bounds_x_get, _LidarDSDK.Bounds_x_set)
    __swig_setmethods__["y"] = _LidarDSDK.Bounds_y_set
    __swig_getmethods__["y"] = _LidarDSDK.Bounds_y_get
    if _newclass:y = _swig_property(_LidarDSDK.Bounds_y_get, _LidarDSDK.Bounds_y_set)
    __swig_setmethods__["z"] = _LidarDSDK.Bounds_z_set
    __swig_getmethods__["z"] = _LidarDSDK.Bounds_z_get
    if _newclass:z = _swig_property(_LidarDSDK.Bounds_z_get, _LidarDSDK.Bounds_z_set)
    __swig_getmethods__["Huge"] = lambda x: _LidarDSDK.Bounds_Huge
    if _newclass:Huge = staticmethod(_LidarDSDK.Bounds_Huge)
    def __init__(self, *args): 
        this = _LidarDSDK.new_Bounds(*args)
        try: self.this.append(this)
        except: self.this = this
    def __eq__(self, *args): return _LidarDSDK.Bounds___eq__(self, *args)
    def __ne__(self, *args): return _LidarDSDK.Bounds___ne__(self, *args)
    def contains(self, *args): return _LidarDSDK.Bounds_contains(self, *args)
    def overlaps(self, *args): return _LidarDSDK.Bounds_overlaps(self, *args)
    def empty(self): return _LidarDSDK.Bounds_empty(self)
    def volume(self): return _LidarDSDK.Bounds_volume(self)
    def shift(self, *args): return _LidarDSDK.Bounds_shift(self, *args)
    def scale(self, *args): return _LidarDSDK.Bounds_scale(self, *args)
    def clip(self, *args): return _LidarDSDK.Bounds_clip(self, *args)
    def grow(self, *args): return _LidarDSDK.Bounds_grow(self, *args)
    __swig_getmethods__["overlapFraction"] = lambda x: _LidarDSDK.Bounds_overlapFraction
    if _newclass:overlapFraction = staticmethod(_LidarDSDK.Bounds_overlapFraction)
    __swig_destroy__ = _LidarDSDK.delete_Bounds
    __del__ = lambda self : None;
Bounds_swigregister = _LidarDSDK.Bounds_swigregister
Bounds_swigregister(Bounds)

def Bounds_Huge():
  return _LidarDSDK.Bounds_Huge()
Bounds_Huge = _LidarDSDK.Bounds_Huge

def Bounds_overlapFraction(*args):
  return _LidarDSDK.Bounds_overlapFraction(*args)
Bounds_overlapFraction = _LidarDSDK.Bounds_overlapFraction

DATATYPE_INVALID = _LidarDSDK.DATATYPE_INVALID
DATATYPE_UINT8 = _LidarDSDK.DATATYPE_UINT8
DATATYPE_SINT8 = _LidarDSDK.DATATYPE_SINT8
DATATYPE_UINT16 = _LidarDSDK.DATATYPE_UINT16
DATATYPE_SINT16 = _LidarDSDK.DATATYPE_SINT16
DATATYPE_UINT32 = _LidarDSDK.DATATYPE_UINT32
DATATYPE_SINT32 = _LidarDSDK.DATATYPE_SINT32
DATATYPE_UINT64 = _LidarDSDK.DATATYPE_UINT64
DATATYPE_SINT64 = _LidarDSDK.DATATYPE_SINT64
DATATYPE_FLOAT32 = _LidarDSDK.DATATYPE_FLOAT32
DATATYPE_FLOAT64 = _LidarDSDK.DATATYPE_FLOAT64
class DataTypeUtils(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, DataTypeUtils, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, DataTypeUtils, name)
    __repr__ = _swig_repr
    __swig_getmethods__["isSigned"] = lambda x: _LidarDSDK.DataTypeUtils_isSigned
    if _newclass:isSigned = staticmethod(_LidarDSDK.DataTypeUtils_isSigned)
    __swig_getmethods__["isFloat"] = lambda x: _LidarDSDK.DataTypeUtils_isFloat
    if _newclass:isFloat = staticmethod(_LidarDSDK.DataTypeUtils_isFloat)
    __swig_getmethods__["byteWidth"] = lambda x: _LidarDSDK.DataTypeUtils_byteWidth
    if _newclass:byteWidth = staticmethod(_LidarDSDK.DataTypeUtils_byteWidth)
    __swig_getmethods__["toString"] = lambda x: _LidarDSDK.DataTypeUtils_toString
    if _newclass:toString = staticmethod(_LidarDSDK.DataTypeUtils_toString)
    __swig_getmethods__["toDataType"] = lambda x: _LidarDSDK.DataTypeUtils_toDataType
    if _newclass:toDataType = staticmethod(_LidarDSDK.DataTypeUtils_toDataType)
    def __init__(self): 
        this = _LidarDSDK.new_DataTypeUtils()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _LidarDSDK.delete_DataTypeUtils
    __del__ = lambda self : None;
DataTypeUtils_swigregister = _LidarDSDK.DataTypeUtils_swigregister
DataTypeUtils_swigregister(DataTypeUtils)

def DataTypeUtils_isSigned(*args):
  return _LidarDSDK.DataTypeUtils_isSigned(*args)
DataTypeUtils_isSigned = _LidarDSDK.DataTypeUtils_isSigned

def DataTypeUtils_isFloat(*args):
  return _LidarDSDK.DataTypeUtils_isFloat(*args)
DataTypeUtils_isFloat = _LidarDSDK.DataTypeUtils_isFloat

def DataTypeUtils_byteWidth(*args):
  return _LidarDSDK.DataTypeUtils_byteWidth(*args)
DataTypeUtils_byteWidth = _LidarDSDK.DataTypeUtils_byteWidth

def DataTypeUtils_toString(*args):
  return _LidarDSDK.DataTypeUtils_toString(*args)
DataTypeUtils_toString = _LidarDSDK.DataTypeUtils_toString

def DataTypeUtils_toDataType(*args):
  return _LidarDSDK.DataTypeUtils_toDataType(*args)
DataTypeUtils_toDataType = _LidarDSDK.DataTypeUtils_toDataType

CHANNEL_NAME_X = _LidarDSDK.CHANNEL_NAME_X
CHANNEL_NAME_Y = _LidarDSDK.CHANNEL_NAME_Y
CHANNEL_NAME_Z = _LidarDSDK.CHANNEL_NAME_Z
CHANNEL_NAME_Intensity = _LidarDSDK.CHANNEL_NAME_Intensity
CHANNEL_NAME_ReturnNum = _LidarDSDK.CHANNEL_NAME_ReturnNum
CHANNEL_NAME_NumReturns = _LidarDSDK.CHANNEL_NAME_NumReturns
CHANNEL_NAME_ScanDir = _LidarDSDK.CHANNEL_NAME_ScanDir
CHANNEL_NAME_EdgeFlightLine = _LidarDSDK.CHANNEL_NAME_EdgeFlightLine
CHANNEL_NAME_ScannerChannel = _LidarDSDK.CHANNEL_NAME_ScannerChannel
CHANNEL_NAME_ClassId = _LidarDSDK.CHANNEL_NAME_ClassId
CHANNEL_NAME_ClassFlags = _LidarDSDK.CHANNEL_NAME_ClassFlags
CHANNEL_NAME_ScanAngle = _LidarDSDK.CHANNEL_NAME_ScanAngle
CHANNEL_NAME_UserData = _LidarDSDK.CHANNEL_NAME_UserData
CHANNEL_NAME_SourceId = _LidarDSDK.CHANNEL_NAME_SourceId
CHANNEL_NAME_GPSTime_Week = _LidarDSDK.CHANNEL_NAME_GPSTime_Week
CHANNEL_NAME_GPSTime_Adjusted = _LidarDSDK.CHANNEL_NAME_GPSTime_Adjusted
CHANNEL_NAME_Red = _LidarDSDK.CHANNEL_NAME_Red
CHANNEL_NAME_Green = _LidarDSDK.CHANNEL_NAME_Green
CHANNEL_NAME_Blue = _LidarDSDK.CHANNEL_NAME_Blue
CHANNEL_NAME_NearInfrared = _LidarDSDK.CHANNEL_NAME_NearInfrared
CHANNEL_NAME_Skip = _LidarDSDK.CHANNEL_NAME_Skip
class ChannelInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelInfo, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_ChannelInfo
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_ChannelInfo()
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _LidarDSDK.ChannelInfo_init(self, *args)
    def getName(self): return _LidarDSDK.ChannelInfo_getName(self)
    def getDataType(self): return _LidarDSDK.ChannelInfo_getDataType(self)
    def getBits(self): return _LidarDSDK.ChannelInfo_getBits(self)
    def getQuantization(self): return _LidarDSDK.ChannelInfo_getQuantization(self)
    def setQuantization(self, *args): return _LidarDSDK.ChannelInfo_setQuantization(self, *args)
    def __eq__(self, *args): return _LidarDSDK.ChannelInfo___eq__(self, *args)
    def __ne__(self, *args): return _LidarDSDK.ChannelInfo___ne__(self, *args)
ChannelInfo_swigregister = _LidarDSDK.ChannelInfo_swigregister
ChannelInfo_swigregister(ChannelInfo)

class PointInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PointInfo, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_PointInfo
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_PointInfo()
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _LidarDSDK.PointInfo_init(self, *args)
    def getNumChannels(self): return _LidarDSDK.PointInfo_getNumChannels(self)
    def hasChannel(self, *args): return _LidarDSDK.PointInfo_hasChannel(self, *args)
    def getChannel(self, *args): return _LidarDSDK.PointInfo_getChannel(self, *args)
    def getChannelIndex(self, *args): return _LidarDSDK.PointInfo_getChannelIndex(self, *args)
    def hasValidXYZ(self): return _LidarDSDK.PointInfo_hasValidXYZ(self)
    def __eq__(self, *args): return _LidarDSDK.PointInfo___eq__(self, *args)
    def __ne__(self, *args): return _LidarDSDK.PointInfo___ne__(self, *args)
PointInfo_swigregister = _LidarDSDK.PointInfo_swigregister
PointInfo_swigregister(PointInfo)

class ChannelData(ChannelInfo):
    __swig_setmethods__ = {}
    for _s in [ChannelInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, ChannelData, name, value)
    __swig_getmethods__ = {}
    for _s in [ChannelInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, ChannelData, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_ChannelData
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_ChannelData()
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _LidarDSDK.ChannelData_init(self, *args)
    def getNumSamples(self): return _LidarDSDK.ChannelData_getNumSamples(self)
    __swig_getmethods__["copy"] = lambda x: _LidarDSDK.ChannelData_copy
    if _newclass:copy = staticmethod(_LidarDSDK.ChannelData_copy)
    __swig_getmethods__["convert"] = lambda x: _LidarDSDK.ChannelData_convert
    if _newclass:convert = staticmethod(_LidarDSDK.ChannelData_convert)
    def resize(self, *args): return _LidarDSDK.ChannelData_resize(self, *args)
    def setOffset(self, *args): return _LidarDSDK.ChannelData_setOffset(self, *args)
    def setData(self, *args): return _LidarDSDK.ChannelData_setData(self, *args)
    def getValue(self, *args): return _LidarDSDK.ChannelData_getValue(self, *args)
ChannelData_swigregister = _LidarDSDK.ChannelData_swigregister
ChannelData_swigregister(ChannelData)

def ChannelData_copy(*args):
  return _LidarDSDK.ChannelData_copy(*args)
ChannelData_copy = _LidarDSDK.ChannelData_copy

def ChannelData_convert(*args):
  return _LidarDSDK.ChannelData_convert(*args)
ChannelData_convert = _LidarDSDK.ChannelData_convert

class PointData(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointData, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PointData, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_PointData
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_PointData()
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _LidarDSDK.PointData_init(self, *args)
    def getNumChannels(self): return _LidarDSDK.PointData_getNumChannels(self)
    def getNumSamples(self): return _LidarDSDK.PointData_getNumSamples(self)
    def hasChannel(self, *args): return _LidarDSDK.PointData_hasChannel(self, *args)
    def getChannel(self, *args): return _LidarDSDK.PointData_getChannel(self, *args)
    __swig_getmethods__["copy"] = lambda x: _LidarDSDK.PointData_copy
    if _newclass:copy = staticmethod(_LidarDSDK.PointData_copy)
    __swig_getmethods__["merge"] = lambda x: _LidarDSDK.PointData_merge
    if _newclass:merge = staticmethod(_LidarDSDK.PointData_merge)
    def resize(self, *args): return _LidarDSDK.PointData_resize(self, *args)
    def setOffset(self, *args): return _LidarDSDK.PointData_setOffset(self, *args)
PointData_swigregister = _LidarDSDK.PointData_swigregister
PointData_swigregister(PointData)

def PointData_copy(*args):
  return _LidarDSDK.PointData_copy(*args)
PointData_copy = _LidarDSDK.PointData_copy

def PointData_merge(*args):
  return _LidarDSDK.PointData_merge(*args)
PointData_merge = _LidarDSDK.PointData_merge

class Object(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Object, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Object, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
    __repr__ = _swig_repr
    def retain(self): return _LidarDSDK.Object_retain(self)
    def release(self): return _LidarDSDK.Object_release(self)
Object_swigregister = _LidarDSDK.Object_swigregister
Object_swigregister(Object)

class IO(Object):
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IO, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IO, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def open(self): return _LidarDSDK.IO_open(self)
    def close(self): return _LidarDSDK.IO_close(self)
    def pread(self, *args): return _LidarDSDK.IO_pread(self, *args)
    def pwrite(self, *args): return _LidarDSDK.IO_pwrite(self, *args)
    def size(self): return _LidarDSDK.IO_size(self)
    def truncate(self, *args): return _LidarDSDK.IO_truncate(self, *args)
    def unlink(self): return _LidarDSDK.IO_unlink(self)
    __swig_destroy__ = _LidarDSDK.delete_IO
    __del__ = lambda self : None;
IO_swigregister = _LidarDSDK.IO_swigregister
IO_swigregister(IO)

class FileIO(IO):
    __swig_setmethods__ = {}
    for _s in [IO]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, FileIO, name, value)
    __swig_getmethods__ = {}
    for _s in [IO]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, FileIO, name)
    __repr__ = _swig_repr
    def init(self, *args): return _LidarDSDK.FileIO_init(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_FileIO
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_FileIO()
        try: self.this.append(this)
        except: self.this = this
FileIO_swigregister = _LidarDSDK.FileIO_swigregister
FileIO_swigregister(FileIO)

METADATA_KEY_FileSourceID = _LidarDSDK.METADATA_KEY_FileSourceID
METADATA_KEY_ProjectID = _LidarDSDK.METADATA_KEY_ProjectID
METADATA_KEY_SystemID = _LidarDSDK.METADATA_KEY_SystemID
METADATA_KEY_GeneratingSoftware = _LidarDSDK.METADATA_KEY_GeneratingSoftware
METADATA_KEY_FileCreationDate = _LidarDSDK.METADATA_KEY_FileCreationDate
METADATA_KEY_PointRecordsByReturnCount = _LidarDSDK.METADATA_KEY_PointRecordsByReturnCount
METADATA_KEY_PreCompressionPointCount = _LidarDSDK.METADATA_KEY_PreCompressionPointCount
METADATA_KEY_LASBBox = _LidarDSDK.METADATA_KEY_LASBBox
METADATA_DATATYPE_INVALID = _LidarDSDK.METADATA_DATATYPE_INVALID
METADATA_DATATYPE_STRING = _LidarDSDK.METADATA_DATATYPE_STRING
METADATA_DATATYPE_BLOB = _LidarDSDK.METADATA_DATATYPE_BLOB
METADATA_DATATYPE_REAL_ARRAY = _LidarDSDK.METADATA_DATATYPE_REAL_ARRAY
class Metadata(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Metadata, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Metadata, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_Metadata
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_Metadata()
        try: self.this.append(this)
        except: self.this = this
    def getNumRecords(self): return _LidarDSDK.Metadata_getNumRecords(self)
    def has(self, *args): return _LidarDSDK.Metadata_has(self, *args)
    def getKeyIndex(self, *args): return _LidarDSDK.Metadata_getKeyIndex(self, *args)
    def getKey(self, *args): return _LidarDSDK.Metadata_getKey(self, *args)
    def getDescription(self, *args): return _LidarDSDK.Metadata_getDescription(self, *args)
    def getDataType(self, *args): return _LidarDSDK.Metadata_getDataType(self, *args)
    def getValue(self, *args): return _LidarDSDK.Metadata_getValue(self, *args)
    def getValueLength(self, *args): return _LidarDSDK.Metadata_getValueLength(self, *args)
    def add(self, *args): return _LidarDSDK.Metadata_add(self, *args)
    def remove(self, *args): return _LidarDSDK.Metadata_remove(self, *args)
    def sort(self): return _LidarDSDK.Metadata_sort(self)
Metadata_swigregister = _LidarDSDK.Metadata_swigregister
Metadata_swigregister(Metadata)

class ProgressDelegate(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ProgressDelegate, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ProgressDelegate, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _LidarDSDK.delete_ProgressDelegate
    __del__ = lambda self : None;
    def reportProgress(self, *args): return _LidarDSDK.ProgressDelegate_reportProgress(self, *args)
    def getCancelled(self): return _LidarDSDK.ProgressDelegate_getCancelled(self)
    def setTotal(self, *args): return _LidarDSDK.ProgressDelegate_setTotal(self, *args)
    def updateCompleted(self, *args): return _LidarDSDK.ProgressDelegate_updateCompleted(self, *args)
    def getProgress(self): return _LidarDSDK.ProgressDelegate_getProgress(self)
    def warning(self, *args): return _LidarDSDK.ProgressDelegate_warning(self, *args)
    def displayWarning(self, *args): return _LidarDSDK.ProgressDelegate_displayWarning(self, *args)
    def __init__(self): 
        if self.__class__ == ProgressDelegate:
            _self = None
        else:
            _self = self
        this = _LidarDSDK.new_ProgressDelegate(_self, )
        try: self.this.append(this)
        except: self.this = this
    def __disown__(self):
        self.this.disown()
        _LidarDSDK.disown_ProgressDelegate(self)
        return weakref_proxy(self)
ProgressDelegate_swigregister = _LidarDSDK.ProgressDelegate_swigregister
ProgressDelegate_swigregister(ProgressDelegate)

class PercentProgressDelegate(ProgressDelegate):
    __swig_setmethods__ = {}
    for _s in [ProgressDelegate]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PercentProgressDelegate, name, value)
    __swig_getmethods__ = {}
    for _s in [ProgressDelegate]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PercentProgressDelegate, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _LidarDSDK.new_PercentProgressDelegate()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _LidarDSDK.delete_PercentProgressDelegate
    __del__ = lambda self : None;
    def setCancelled(self, *args): return _LidarDSDK.PercentProgressDelegate_setCancelled(self, *args)
PercentProgressDelegate_swigregister = _LidarDSDK.PercentProgressDelegate_swigregister
PercentProgressDelegate_swigregister(PercentProgressDelegate)

class PointIterator(Object):
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointIterator, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getNextPoints(self, *args): return _LidarDSDK.PointIterator_getNextPoints(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_PointIterator
    __del__ = lambda self : None;
PointIterator_swigregister = _LidarDSDK.PointIterator_swigregister
PointIterator_swigregister(PointIterator)

class PointSource(Object):
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointSource, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointSource, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def getPointInfo(self): return _LidarDSDK.PointSource_getPointInfo(self)
    def getNumChannels(self): return _LidarDSDK.PointSource_getNumChannels(self)
    def hasChannel(self, *args): return _LidarDSDK.PointSource_hasChannel(self, *args)
    def getChannel(self, *args): return _LidarDSDK.PointSource_getChannel(self, *args)
    def getNumPoints(self): return _LidarDSDK.PointSource_getNumPoints(self)
    def getWKT(self): return _LidarDSDK.PointSource_getWKT(self)
    def loadMetadata(self, *args): return _LidarDSDK.PointSource_loadMetadata(self, *args)
    def getBounds(self): return _LidarDSDK.PointSource_getBounds(self)
    def getScale(self): return _LidarDSDK.PointSource_getScale(self)
    def getOffset(self): return _LidarDSDK.PointSource_getOffset(self)
    def getNumClassIdNames(self): return _LidarDSDK.PointSource_getNumClassIdNames(self)
    def getClassIdNames(self): return _LidarDSDK.PointSource_getClassIdNames(self)
    def getTotalWork(self, *args): return _LidarDSDK.PointSource_getTotalWork(self, *args)
    def createIterator(self, *args): return _LidarDSDK.PointSource_createIterator(self, *args)
    def read(self, *args): return _LidarDSDK.PointSource_read(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_PointSource
    __del__ = lambda self : None;
PointSource_swigregister = _LidarDSDK.PointSource_swigregister
PointSource_swigregister(PointSource)

class PointReader(PointSource):
    __swig_setmethods__ = {}
    for _s in [PointSource]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointReader, name, value)
    __swig_getmethods__ = {}
    for _s in [PointSource]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointReader, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def overrideWKT(self, *args): return _LidarDSDK.PointReader_overrideWKT(self, *args)
    def getFileFormatString(self): return _LidarDSDK.PointReader_getFileFormatString(self)
    __swig_destroy__ = _LidarDSDK.delete_PointReader
    __del__ = lambda self : None;
PointReader_swigregister = _LidarDSDK.PointReader_swigregister
PointReader_swigregister(PointReader)

class PointWriter(Object):
    __swig_setmethods__ = {}
    for _s in [Object]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PointWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [Object]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PointWriter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def setMetadata(self, *args): return _LidarDSDK.PointWriter_setMetadata(self, *args)
    def getMetadata(self): return _LidarDSDK.PointWriter_getMetadata(self)
    def setQuantization(self, *args): return _LidarDSDK.PointWriter_setQuantization(self, *args)
    def getScale(self): return _LidarDSDK.PointWriter_getScale(self)
    def getOffset(self): return _LidarDSDK.PointWriter_getOffset(self)
    def write(self, *args): return _LidarDSDK.PointWriter_write(self, *args)
    def setChunckSize(self, *args): return _LidarDSDK.PointWriter_setChunckSize(self, *args)
    def supportedChannels(self, *args): return _LidarDSDK.PointWriter_supportedChannels(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_PointWriter
    __del__ = lambda self : None;
PointWriter_swigregister = _LidarDSDK.PointWriter_swigregister
PointWriter_swigregister(PointWriter)

class SimplePointWriter(PointWriter):
    __swig_setmethods__ = {}
    for _s in [PointWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SimplePointWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [PointWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SimplePointWriter, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def writeBegin(self, *args): return _LidarDSDK.SimplePointWriter_writeBegin(self, *args)
    def writePoints(self, *args): return _LidarDSDK.SimplePointWriter_writePoints(self, *args)
    def writeEnd(self, *args): return _LidarDSDK.SimplePointWriter_writeEnd(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_SimplePointWriter
    __del__ = lambda self : None;
SimplePointWriter_swigregister = _LidarDSDK.SimplePointWriter_swigregister
SimplePointWriter_swigregister(SimplePointWriter)

class TXTPointReader(PointReader):
    __swig_setmethods__ = {}
    for _s in [PointReader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TXTPointReader, name, value)
    __swig_getmethods__ = {}
    for _s in [PointReader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TXTPointReader, name)
    __repr__ = _swig_repr
    def init(self, *args): return _LidarDSDK.TXTPointReader_init(self, *args)
    def initBoundsAndNumPoints(self): return _LidarDSDK.TXTPointReader_initBoundsAndNumPoints(self)
    __swig_getmethods__["parseFormat"] = lambda x: _LidarDSDK.TXTPointReader_parseFormat
    if _newclass:parseFormat = staticmethod(_LidarDSDK.TXTPointReader_parseFormat)
    __swig_getmethods__["parseQuantization"] = lambda x: _LidarDSDK.TXTPointReader_parseQuantization
    if _newclass:parseQuantization = staticmethod(_LidarDSDK.TXTPointReader_parseQuantization)
    __swig_destroy__ = _LidarDSDK.delete_TXTPointReader
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_TXTPointReader()
        try: self.this.append(this)
        except: self.this = this
TXTPointReader_swigregister = _LidarDSDK.TXTPointReader_swigregister
TXTPointReader_swigregister(TXTPointReader)

def TXTPointReader_parseFormat(*args):
  return _LidarDSDK.TXTPointReader_parseFormat(*args)
TXTPointReader_parseFormat = _LidarDSDK.TXTPointReader_parseFormat

def TXTPointReader_parseQuantization(*args):
  return _LidarDSDK.TXTPointReader_parseQuantization(*args)
TXTPointReader_parseQuantization = _LidarDSDK.TXTPointReader_parseQuantization

class TXTPointWriter(SimplePointWriter):
    __swig_setmethods__ = {}
    for _s in [SimplePointWriter]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TXTPointWriter, name, value)
    __swig_getmethods__ = {}
    for _s in [SimplePointWriter]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TXTPointWriter, name)
    __repr__ = _swig_repr
    def init(self, *args): return _LidarDSDK.TXTPointWriter_init(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_TXTPointWriter
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_TXTPointWriter()
        try: self.this.append(this)
        except: self.this = this
TXTPointWriter_swigregister = _LidarDSDK.TXTPointWriter_swigregister
TXTPointWriter_swigregister(TXTPointWriter)

class Version(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Version, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Version, name)
    __repr__ = _swig_repr
    __swig_getmethods__["getSDKMajorVersion"] = lambda x: _LidarDSDK.Version_getSDKMajorVersion
    if _newclass:getSDKMajorVersion = staticmethod(_LidarDSDK.Version_getSDKMajorVersion)
    __swig_getmethods__["getSDKMinorVersion"] = lambda x: _LidarDSDK.Version_getSDKMinorVersion
    if _newclass:getSDKMinorVersion = staticmethod(_LidarDSDK.Version_getSDKMinorVersion)
    __swig_getmethods__["getSDKVersionAge"] = lambda x: _LidarDSDK.Version_getSDKVersionAge
    if _newclass:getSDKVersionAge = staticmethod(_LidarDSDK.Version_getSDKVersionAge)
    __swig_getmethods__["getSDKBuildNumber"] = lambda x: _LidarDSDK.Version_getSDKBuildNumber
    if _newclass:getSDKBuildNumber = staticmethod(_LidarDSDK.Version_getSDKBuildNumber)
    __swig_getmethods__["getSDKVersionString"] = lambda x: _LidarDSDK.Version_getSDKVersionString
    if _newclass:getSDKVersionString = staticmethod(_LidarDSDK.Version_getSDKVersionString)
    __swig_getmethods__["getSDKBuildDate"] = lambda x: _LidarDSDK.Version_getSDKBuildDate
    if _newclass:getSDKBuildDate = staticmethod(_LidarDSDK.Version_getSDKBuildDate)
    def __init__(self): 
        this = _LidarDSDK.new_Version()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _LidarDSDK.delete_Version
    __del__ = lambda self : None;
Version_swigregister = _LidarDSDK.Version_swigregister
Version_swigregister(Version)

def Version_getSDKMajorVersion():
  return _LidarDSDK.Version_getSDKMajorVersion()
Version_getSDKMajorVersion = _LidarDSDK.Version_getSDKMajorVersion

def Version_getSDKMinorVersion():
  return _LidarDSDK.Version_getSDKMinorVersion()
Version_getSDKMinorVersion = _LidarDSDK.Version_getSDKMinorVersion

def Version_getSDKVersionAge():
  return _LidarDSDK.Version_getSDKVersionAge()
Version_getSDKVersionAge = _LidarDSDK.Version_getSDKVersionAge

def Version_getSDKBuildNumber():
  return _LidarDSDK.Version_getSDKBuildNumber()
Version_getSDKBuildNumber = _LidarDSDK.Version_getSDKBuildNumber

def Version_getSDKVersionString():
  return _LidarDSDK.Version_getSDKVersionString()
Version_getSDKVersionString = _LidarDSDK.Version_getSDKVersionString

def Version_getSDKBuildDate():
  return _LidarDSDK.Version_getSDKBuildDate()
Version_getSDKBuildDate = _LidarDSDK.Version_getSDKBuildDate

class MG4PointReader(PointReader):
    __swig_setmethods__ = {}
    for _s in [PointReader]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MG4PointReader, name, value)
    __swig_getmethods__ = {}
    for _s in [PointReader]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MG4PointReader, name)
    __repr__ = _swig_repr
    def init(self, *args): return _LidarDSDK.MG4PointReader_init(self, *args)
    __swig_destroy__ = _LidarDSDK.delete_MG4PointReader
    __del__ = lambda self : None;
    def __init__(self): 
        this = _LidarDSDK.new_MG4PointReader()
        try: self.this.append(this)
        except: self.this = this
MG4PointReader_swigregister = _LidarDSDK.MG4PointReader_swigregister
MG4PointReader_swigregister(MG4PointReader)

# This file is compatible with both classic and new-style classes.


