# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.5
#
# 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('_efitlib', [dirname(__file__)])
        except ImportError:
            import _efitlib
            return _efitlib
        if fp is not None:
            try:
                _mod = imp.load_module('_efitlib', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _efitlib = swig_import_helper()
    del swig_import_helper
else:
    import _efitlib
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):
        if _newclass:
            object.__setattr__(self, name, value)
        else:
            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_nondynamic(self, class_type, name, static=1):
    if (name == "thisown"):
        return self.this.own()
    method = class_type.__swig_getmethods__.get(name, None)
    if method:
        return method(self)
    if (not static):
        return object.__getattr__(self, name)
    else:
        raise AttributeError(name)

def _swig_getattr(self, class_type, name):
    return _swig_getattr_nondynamic(self, class_type, name, 0)


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


class ellipsoid(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, ellipsoid, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, ellipsoid, name)
    __repr__ = _swig_repr
    __swig_setmethods__["name"] = _efitlib.ellipsoid_name_set
    __swig_getmethods__["name"] = _efitlib.ellipsoid_name_get
    if _newclass:
        name = _swig_property(_efitlib.ellipsoid_name_get, _efitlib.ellipsoid_name_set)
    __swig_setmethods__["position"] = _efitlib.ellipsoid_position_set
    __swig_getmethods__["position"] = _efitlib.ellipsoid_position_get
    if _newclass:
        position = _swig_property(_efitlib.ellipsoid_position_get, _efitlib.ellipsoid_position_set)
    __swig_setmethods__["axis"] = _efitlib.ellipsoid_axis_set
    __swig_getmethods__["axis"] = _efitlib.ellipsoid_axis_get
    if _newclass:
        axis = _swig_property(_efitlib.ellipsoid_axis_get, _efitlib.ellipsoid_axis_set)
    __swig_setmethods__["orientation"] = _efitlib.ellipsoid_orientation_set
    __swig_getmethods__["orientation"] = _efitlib.ellipsoid_orientation_get
    if _newclass:
        orientation = _swig_property(_efitlib.ellipsoid_orientation_get, _efitlib.ellipsoid_orientation_set)
    __swig_setmethods__["inv_orientation"] = _efitlib.ellipsoid_inv_orientation_set
    __swig_getmethods__["inv_orientation"] = _efitlib.ellipsoid_inv_orientation_get
    if _newclass:
        inv_orientation = _swig_property(_efitlib.ellipsoid_inv_orientation_get, _efitlib.ellipsoid_inv_orientation_set)
    __swig_setmethods__["tensor"] = _efitlib.ellipsoid_tensor_set
    __swig_getmethods__["tensor"] = _efitlib.ellipsoid_tensor_get
    if _newclass:
        tensor = _swig_property(_efitlib.ellipsoid_tensor_get, _efitlib.ellipsoid_tensor_set)

    def getPosition(self):
        return _efitlib.ellipsoid_getPosition(self)

    def getAxis(self):
        return _efitlib.ellipsoid_getAxis(self)

    def getOrientation(self):
        return _efitlib.ellipsoid_getOrientation(self)

    def __init__(self):
        this = _efitlib.new_ellipsoid()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _efitlib.delete_ellipsoid
    __del__ = lambda self: None
ellipsoid_swigregister = _efitlib.ellipsoid_swigregister
ellipsoid_swigregister(ellipsoid)

class efit_info(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, efit_info, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, efit_info, name)
    __repr__ = _swig_repr
    __swig_setmethods__["weightflag"] = _efitlib.efit_info_weightflag_set
    __swig_getmethods__["weightflag"] = _efitlib.efit_info_weightflag_get
    if _newclass:
        weightflag = _swig_property(_efitlib.efit_info_weightflag_get, _efitlib.efit_info_weightflag_set)
    __swig_setmethods__["covarflag"] = _efitlib.efit_info_covarflag_set
    __swig_getmethods__["covarflag"] = _efitlib.efit_info_covarflag_get
    if _newclass:
        covarflag = _swig_property(_efitlib.efit_info_covarflag_get, _efitlib.efit_info_covarflag_set)
    __swig_setmethods__["volumeflag"] = _efitlib.efit_info_volumeflag_set
    __swig_getmethods__["volumeflag"] = _efitlib.efit_info_volumeflag_get
    if _newclass:
        volumeflag = _swig_property(_efitlib.efit_info_volumeflag_get, _efitlib.efit_info_volumeflag_set)
    __swig_setmethods__["matrixflag"] = _efitlib.efit_info_matrixflag_set
    __swig_getmethods__["matrixflag"] = _efitlib.efit_info_matrixflag_get
    if _newclass:
        matrixflag = _swig_property(_efitlib.efit_info_matrixflag_get, _efitlib.efit_info_matrixflag_set)
    __swig_setmethods__["nocenterflag"] = _efitlib.efit_info_nocenterflag_set
    __swig_getmethods__["nocenterflag"] = _efitlib.efit_info_nocenterflag_get
    if _newclass:
        nocenterflag = _swig_property(_efitlib.efit_info_nocenterflag_get, _efitlib.efit_info_nocenterflag_set)
    __swig_setmethods__["noscaleflag"] = _efitlib.efit_info_noscaleflag_set
    __swig_getmethods__["noscaleflag"] = _efitlib.efit_info_noscaleflag_get
    if _newclass:
        noscaleflag = _swig_property(_efitlib.efit_info_noscaleflag_get, _efitlib.efit_info_noscaleflag_set)
    __swig_setmethods__["nosortflag"] = _efitlib.efit_info_nosortflag_set
    __swig_getmethods__["nosortflag"] = _efitlib.efit_info_nosortflag_get
    if _newclass:
        nosortflag = _swig_property(_efitlib.efit_info_nosortflag_get, _efitlib.efit_info_nosortflag_set)
    __swig_setmethods__["count"] = _efitlib.efit_info_count_set
    __swig_getmethods__["count"] = _efitlib.efit_info_count_get
    if _newclass:
        count = _swig_property(_efitlib.efit_info_count_get, _efitlib.efit_info_count_set)
    __swig_setmethods__["cov_scale"] = _efitlib.efit_info_cov_scale_set
    __swig_getmethods__["cov_scale"] = _efitlib.efit_info_cov_scale_get
    if _newclass:
        cov_scale = _swig_property(_efitlib.efit_info_cov_scale_get, _efitlib.efit_info_cov_scale_set)
    __swig_setmethods__["ell_scale"] = _efitlib.efit_info_ell_scale_set
    __swig_getmethods__["ell_scale"] = _efitlib.efit_info_ell_scale_get
    if _newclass:
        ell_scale = _swig_property(_efitlib.efit_info_ell_scale_get, _efitlib.efit_info_ell_scale_set)

    def __init__(self):
        this = _efitlib.new_efit_info()
        try:
            self.this.append(this)
        except:
            self.this = this
    __swig_destroy__ = _efitlib.delete_efit_info
    __del__ = lambda self: None
efit_info_swigregister = _efitlib.efit_info_swigregister
efit_info_swigregister(efit_info)


def fitEllipse(pts, ell_scale, cov_scale, eptr, ellipsoid):
    return _efitlib.fitEllipse(pts, ell_scale, cov_scale, eptr, ellipsoid)
fitEllipse = _efitlib.fitEllipse

def vec_normalize(vector_in_out):
    return _efitlib.vec_normalize(vector_in_out)
vec_normalize = _efitlib.vec_normalize

def vec_centroid(count, src, p):
    return _efitlib.vec_centroid(count, src, p)
vec_centroid = _efitlib.vec_centroid

def vec_dot(arg1, arg2):
    return _efitlib.vec_dot(arg1, arg2)
vec_dot = _efitlib.vec_dot

def vec_magsq(VECTOR):
    return _efitlib.vec_magsq(VECTOR)
vec_magsq = _efitlib.vec_magsq

def vec_mag(VECTOR):
    return _efitlib.vec_mag(VECTOR)
vec_mag = _efitlib.vec_mag

def vec_distancesq(arg1, arg2):
    return _efitlib.vec_distancesq(arg1, arg2)
vec_distancesq = _efitlib.vec_distancesq

def vec_distance(arg1, arg2):
    return _efitlib.vec_distance(arg1, arg2)
vec_distance = _efitlib.vec_distance

def vec_max(VECTOR):
    return _efitlib.vec_max(VECTOR)
vec_max = _efitlib.vec_max

def vec_length(VECTOR):
    return _efitlib.vec_length(VECTOR)
vec_length = _efitlib.vec_length

def vec_ctos(VECTOR):
    return _efitlib.vec_ctos(VECTOR)
vec_ctos = _efitlib.vec_ctos

def vec_stoc(VECTOR):
    return _efitlib.vec_stoc(VECTOR)
vec_stoc = _efitlib.vec_stoc

def vec_sub(arg1, arg2):
    return _efitlib.vec_sub(arg1, arg2)
vec_sub = _efitlib.vec_sub

def vec_copy(VECTOR):
    return _efitlib.vec_copy(VECTOR)
vec_copy = _efitlib.vec_copy

def vec_add(arg1, arg2):
    return _efitlib.vec_add(arg1, arg2)
vec_add = _efitlib.vec_add

def vec_scale(f, VECTOR):
    return _efitlib.vec_scale(f, VECTOR)
vec_scale = _efitlib.vec_scale

def vec_zero():
    return _efitlib.vec_zero()
vec_zero = _efitlib.vec_zero

def vec_cross(arg1, arg2):
    return _efitlib.vec_cross(arg1, arg2)
vec_cross = _efitlib.vec_cross

def vec_mult(arg1, arg2):
    return _efitlib.vec_mult(arg1, arg2)
vec_mult = _efitlib.vec_mult

def vec_offset(s, arg2, arg3):
    return _efitlib.vec_offset(s, arg2, arg3)
vec_offset = _efitlib.vec_offset

def vec_rand():
    return _efitlib.vec_rand()
vec_rand = _efitlib.vec_rand

def vec_average(arg1, arg2, arg3):
    return _efitlib.vec_average(arg1, arg2, arg3)
vec_average = _efitlib.vec_average

def vec_transform(VECTOR, ARRAY2D):
    return _efitlib.vec_transform(VECTOR, ARRAY2D)
vec_transform = _efitlib.vec_transform

def vec_ftransform(VECTOR, ARRAY2D):
    return _efitlib.vec_ftransform(VECTOR, ARRAY2D)
vec_ftransform = _efitlib.vec_ftransform

def mat_jacobi(ARRAY2D):
    return _efitlib.mat_jacobi(ARRAY2D)
mat_jacobi = _efitlib.mat_jacobi

def quat_to_mat(VECTOR):
    return _efitlib.quat_to_mat(VECTOR)
quat_to_mat = _efitlib.quat_to_mat

def mat_to_quat(ARRAY2D, VECTOR):
    return _efitlib.mat_to_quat(ARRAY2D, VECTOR)
mat_to_quat = _efitlib.mat_to_quat
# This file is compatible with both classic and new-style classes.


