python-openmeeg 2.0.0.dfsg-5.1ubuntu1 / usr / share / pyshared / openmeeg.py

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


"""
OpenMEEG bindings for python
"""


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('_openmeeg', [dirname(__file__)])
        except ImportError:
            import _openmeeg
            return _openmeeg
        if fp is not None:
            try:
                _mod = imp.load_module('_openmeeg', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _openmeeg = swig_import_helper()
    del swig_import_helper
else:
    import _openmeeg
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


class Vect3(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vect3, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Vect3, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Vect3(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Vect3
    __del__ = lambda self : None;
    def x(self, *args): return _openmeeg.Vect3_x(self, *args)
    def y(self, *args): return _openmeeg.Vect3_y(self, *args)
    def z(self, *args): return _openmeeg.Vect3_z(self, *args)
    def norm(self): return _openmeeg.Vect3_norm(self)
    def norm2(self): return _openmeeg.Vect3_norm2(self)
    def __eq__(self, *args): return _openmeeg.Vect3___eq__(self, *args)
    def __iadd__(self, *args): return _openmeeg.Vect3___iadd__(self, *args)
    def __imul__(self, *args): return _openmeeg.Vect3___imul__(self, *args)
    def multadd(self, *args): return _openmeeg.Vect3_multadd(self, *args)
    def __add__(self, *args): return _openmeeg.Vect3___add__(self, *args)
    def __sub__(self, *args): return _openmeeg.Vect3___sub__(self, *args)
    def __xor__(self, *args): return _openmeeg.Vect3___xor__(self, *args)
    def __mul__(self, *args): return _openmeeg.Vect3___mul__(self, *args)
    def __div__(self, *args): return _openmeeg.Vect3___div__(self, *args)
    def __call__(self, *args): return _openmeeg.Vect3___call__(self, *args)
    def __neg__(self): return _openmeeg.Vect3___neg__(self)
    def det(self, *args): return _openmeeg.Vect3_det(self, *args)
    def solangl(self, *args): return _openmeeg.Vect3_solangl(self, *args)
    def normal(self, *args): return _openmeeg.Vect3_normal(self, *args)
    def normalize(self): return _openmeeg.Vect3_normalize(self)
Vect3_swigregister = _openmeeg.Vect3_swigregister
Vect3_swigregister(Vect3)

class Triangle(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Triangle, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Triangle, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Triangle(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Triangle
    __del__ = lambda self : None;
    def som(self, *args): return _openmeeg.Triangle_som(self, *args)
    def next(self, *args): return _openmeeg.Triangle_next(self, *args)
    def prev(self, *args): return _openmeeg.Triangle_prev(self, *args)
    def s1(self, *args): return _openmeeg.Triangle_s1(self, *args)
    def s2(self, *args): return _openmeeg.Triangle_s2(self, *args)
    def s3(self, *args): return _openmeeg.Triangle_s3(self, *args)
    def normal(self, *args): return _openmeeg.Triangle_normal(self, *args)
    def contains(self, *args): return _openmeeg.Triangle_contains(self, *args)
    def getArea(self): return _openmeeg.Triangle_getArea(self)
    def setArea(self, *args): return _openmeeg.Triangle_setArea(self, *args)
    def area(self): return _openmeeg.Triangle_area(self)
Triangle_swigregister = _openmeeg.Triangle_swigregister
Triangle_swigregister(Triangle)

class LinOpInfo(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinOpInfo, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinOpInfo, name)
    __repr__ = _swig_repr
    FULL = _openmeeg.LinOpInfo_FULL
    SYMMETRIC = _openmeeg.LinOpInfo_SYMMETRIC
    SPARSE = _openmeeg.LinOpInfo_SPARSE
    def __init__(self, *args): 
        this = _openmeeg.new_LinOpInfo(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_LinOpInfo
    __del__ = lambda self : None;
    def nlin(self, *args): return _openmeeg.LinOpInfo_nlin(self, *args)
    def ncol(self, *args): return _openmeeg.LinOpInfo_ncol(self, *args)
    def storageType(self, *args): return _openmeeg.LinOpInfo_storageType(self, *args)
    def dimension(self, *args): return _openmeeg.LinOpInfo_dimension(self, *args)
    def default_io(self): return _openmeeg.LinOpInfo_default_io(self)
LinOpInfo_swigregister = _openmeeg.LinOpInfo_swigregister
LinOpInfo_swigregister(LinOpInfo)

class LinOp(LinOpInfo):
    __swig_setmethods__ = {}
    for _s in [LinOpInfo]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinOp, name, value)
    __swig_getmethods__ = {}
    for _s in [LinOpInfo]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LinOp, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    def size(self): return _openmeeg.LinOp_size(self)
    def info(self): return _openmeeg.LinOp_info(self)
    __swig_destroy__ = _openmeeg.delete_LinOp
    __del__ = lambda self : None;
LinOp_swigregister = _openmeeg.LinOp_swigregister
LinOp_swigregister(LinOp)

DEEP_COPY = _openmeeg.DEEP_COPY
class LinOpValue(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, LinOpValue, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, LinOpValue, name)
    __repr__ = _swig_repr
    __swig_setmethods__["data"] = _openmeeg.LinOpValue_data_set
    __swig_getmethods__["data"] = _openmeeg.LinOpValue_data_get
    if _newclass:data = _swig_property(_openmeeg.LinOpValue_data_get, _openmeeg.LinOpValue_data_set)
    def __init__(self, *args): 
        this = _openmeeg.new_LinOpValue(*args)
        try: self.this.append(this)
        except: self.this = this
    def init(self, *args): return _openmeeg.LinOpValue_init(self, *args)
    __swig_destroy__ = _openmeeg.delete_LinOpValue
    __del__ = lambda self : None;
    def empty(self): return _openmeeg.LinOpValue_empty(self)
LinOpValue_swigregister = _openmeeg.LinOpValue_swigregister
LinOpValue_swigregister(LinOpValue)

class Vector(LinOp):
    __swig_setmethods__ = {}
    for _s in [LinOp]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Vector, name, value)
    __swig_getmethods__ = {}
    for _s in [LinOp]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Vector, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Vector(*args)
        try: self.this.append(this)
        except: self.this = this
    def alloc_data(self): return _openmeeg.Vector_alloc_data(self)
    def reference_data(self, *args): return _openmeeg.Vector_reference_data(self, *args)
    def size(self): return _openmeeg.Vector_size(self)
    def empty(self): return _openmeeg.Vector_empty(self)
    def data(self): return _openmeeg.Vector_data(self)
    def __call__(self, *args): return _openmeeg.Vector___call__(self, *args)
    def __iadd__(self, *args): return _openmeeg.Vector___iadd__(self, *args)
    def __isub__(self, *args): return _openmeeg.Vector___isub__(self, *args)
    def __imul__(self, *args): return _openmeeg.Vector___imul__(self, *args)
    def __idiv__(self, *args): return _openmeeg.Vector___idiv__(self, *args)
    def __add__(self, *args): return _openmeeg.Vector___add__(self, *args)
    def __sub__(self, *args): return _openmeeg.Vector___sub__(self, *args)
    def __div__(self, *args): return _openmeeg.Vector___div__(self, *args)
    def __mul__(self, *args): return _openmeeg.Vector___mul__(self, *args)
    def kmult(self, *args): return _openmeeg.Vector_kmult(self, *args)
    def norm(self): return _openmeeg.Vector_norm(self)
    def sum(self): return _openmeeg.Vector_sum(self)
    def mean(self): return _openmeeg.Vector_mean(self)
    def set(self, *args): return _openmeeg.Vector_set(self, *args)
    def save(self, *args): return _openmeeg.Vector_save(self, *args)
    def load(self, *args): return _openmeeg.Vector_load(self, *args)
    def info(self): return _openmeeg.Vector_info(self)
    __swig_destroy__ = _openmeeg.delete_Vector
    __del__ = lambda self : None;
Vector_swigregister = _openmeeg.Vector_swigregister
Vector_swigregister(Vector)


def __mul__(*args):
  return _openmeeg.__mul__(*args)
__mul__ = _openmeeg.__mul__

def __rshift__(*args):
  return _openmeeg.__rshift__(*args)
__rshift__ = _openmeeg.__rshift__
class Matrix(LinOp):
    __swig_setmethods__ = {}
    for _s in [LinOp]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Matrix, name, value)
    __swig_getmethods__ = {}
    for _s in [LinOp]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Matrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Matrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def alloc_data(self): return _openmeeg.Matrix_alloc_data(self)
    def reference_data(self, *args): return _openmeeg.Matrix_reference_data(self, *args)
    def empty(self): return _openmeeg.Matrix_empty(self)
    def size(self): return _openmeeg.Matrix_size(self)
    def data(self): return _openmeeg.Matrix_data(self)
    def __call__(self, *args): return _openmeeg.Matrix___call__(self, *args)
    def submat(self, *args): return _openmeeg.Matrix_submat(self, *args)
    def getcol(self, *args): return _openmeeg.Matrix_getcol(self, *args)
    def setcol(self, *args): return _openmeeg.Matrix_setcol(self, *args)
    def getlin(self, *args): return _openmeeg.Matrix_getlin(self, *args)
    def setlin(self, *args): return _openmeeg.Matrix_setlin(self, *args)
    def set(self, *args): return _openmeeg.Matrix_set(self, *args)
    def __add__(self, *args): return _openmeeg.Matrix___add__(self, *args)
    def __sub__(self, *args): return _openmeeg.Matrix___sub__(self, *args)
    def __div__(self, *args): return _openmeeg.Matrix___div__(self, *args)
    def __iadd__(self, *args): return _openmeeg.Matrix___iadd__(self, *args)
    def __isub__(self, *args): return _openmeeg.Matrix___isub__(self, *args)
    def __imul__(self, *args): return _openmeeg.Matrix___imul__(self, *args)
    def __idiv__(self, *args): return _openmeeg.Matrix___idiv__(self, *args)
    def __mul__(self, *args): return _openmeeg.Matrix___mul__(self, *args)
    def tmult(self, *args): return _openmeeg.Matrix_tmult(self, *args)
    def multt(self, *args): return _openmeeg.Matrix_multt(self, *args)
    def tmultt(self, *args): return _openmeeg.Matrix_tmultt(self, *args)
    def mean(self): return _openmeeg.Matrix_mean(self)
    def tmean(self): return _openmeeg.Matrix_tmean(self)
    def transpose(self): return _openmeeg.Matrix_transpose(self)
    def inverse(self): return _openmeeg.Matrix_inverse(self)
    def frobenius_norm(self): return _openmeeg.Matrix_frobenius_norm(self)
    def dot(self, *args): return _openmeeg.Matrix_dot(self, *args)
    def save(self, *args): return _openmeeg.Matrix_save(self, *args)
    def load(self, *args): return _openmeeg.Matrix_load(self, *args)
    def info(self): return _openmeeg.Matrix_info(self)
    __swig_destroy__ = _openmeeg.delete_Matrix
    __del__ = lambda self : None;
Matrix_swigregister = _openmeeg.Matrix_swigregister
Matrix_swigregister(Matrix)

class SymMatrix(LinOp):
    __swig_setmethods__ = {}
    for _s in [LinOp]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SymMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [LinOp]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SymMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_SymMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def size(self): return _openmeeg.SymMatrix_size(self)
    def info(self): return _openmeeg.SymMatrix_info(self)
    def ncol(self, *args): return _openmeeg.SymMatrix_ncol(self, *args)
    def alloc_data(self): return _openmeeg.SymMatrix_alloc_data(self)
    def reference_data(self, *args): return _openmeeg.SymMatrix_reference_data(self, *args)
    def empty(self): return _openmeeg.SymMatrix_empty(self)
    def set(self, *args): return _openmeeg.SymMatrix_set(self, *args)
    def data(self): return _openmeeg.SymMatrix_data(self)
    def __call__(self, *args): return _openmeeg.SymMatrix___call__(self, *args)
    def submat(self, *args): return _openmeeg.SymMatrix_submat(self, *args)
    def solveLin(self, *args): return _openmeeg.SymMatrix_solveLin(self, *args)
    def __add__(self, *args): return _openmeeg.SymMatrix___add__(self, *args)
    def __sub__(self, *args): return _openmeeg.SymMatrix___sub__(self, *args)
    def __div__(self, *args): return _openmeeg.SymMatrix___div__(self, *args)
    def __iadd__(self, *args): return _openmeeg.SymMatrix___iadd__(self, *args)
    def __isub__(self, *args): return _openmeeg.SymMatrix___isub__(self, *args)
    def __imul__(self, *args): return _openmeeg.SymMatrix___imul__(self, *args)
    def __idiv__(self, *args): return _openmeeg.SymMatrix___idiv__(self, *args)
    def __mul__(self, *args): return _openmeeg.SymMatrix___mul__(self, *args)
    def inverse(self): return _openmeeg.SymMatrix_inverse(self)
    def posdefinverse(self): return _openmeeg.SymMatrix_posdefinverse(self)
    def det(self): return _openmeeg.SymMatrix_det(self)
    def save(self, *args): return _openmeeg.SymMatrix_save(self, *args)
    def load(self, *args): return _openmeeg.SymMatrix_load(self, *args)
    __swig_destroy__ = _openmeeg.delete_SymMatrix
    __del__ = lambda self : None;
SymMatrix_swigregister = _openmeeg.SymMatrix_swigregister
SymMatrix_swigregister(SymMatrix)

class SparseMatrix(LinOp):
    __swig_setmethods__ = {}
    for _s in [LinOp]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SparseMatrix, name, value)
    __swig_getmethods__ = {}
    for _s in [LinOp]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SparseMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_SparseMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_SparseMatrix
    __del__ = lambda self : None;
    def __call__(self, *args): return _openmeeg.SparseMatrix___call__(self, *args)
    def size(self): return _openmeeg.SparseMatrix_size(self)
    def begin(self): return _openmeeg.SparseMatrix_begin(self)
    def end(self): return _openmeeg.SparseMatrix_end(self)
    def transpose(self): return _openmeeg.SparseMatrix_transpose(self)
    def tank(self): return _openmeeg.SparseMatrix_tank(self)
    def save(self, *args): return _openmeeg.SparseMatrix_save(self, *args)
    def load(self, *args): return _openmeeg.SparseMatrix_load(self, *args)
    def info(self): return _openmeeg.SparseMatrix_info(self)
    def __mul__(self, *args): return _openmeeg.SparseMatrix___mul__(self, *args)
SparseMatrix_swigregister = _openmeeg.SparseMatrix_swigregister
SparseMatrix_swigregister(SparseMatrix)

class FastSparseMatrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FastSparseMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FastSparseMatrix, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_FastSparseMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_FastSparseMatrix
    __del__ = lambda self : None;
    def nlin(self): return _openmeeg.FastSparseMatrix_nlin(self)
    def ncol(self): return _openmeeg.FastSparseMatrix_ncol(self)
    def write(self, *args): return _openmeeg.FastSparseMatrix_write(self, *args)
    def read(self, *args): return _openmeeg.FastSparseMatrix_read(self, *args)
    def __call__(self, *args): return _openmeeg.FastSparseMatrix___call__(self, *args)
    def __mul__(self, *args): return _openmeeg.FastSparseMatrix___mul__(self, *args)
    def info(self): return _openmeeg.FastSparseMatrix_info(self)
FastSparseMatrix_swigregister = _openmeeg.FastSparseMatrix_swigregister
FastSparseMatrix_swigregister(FastSparseMatrix)

class Geometry(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Geometry, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Geometry, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _openmeeg.new_Geometry()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Geometry
    __del__ = lambda self : None;
    def read(self, *args): return _openmeeg.Geometry_read(self, *args)
    def nb(self): return _openmeeg.Geometry_nb(self)
    def size(self): return _openmeeg.Geometry_size(self)
    def sigma_in(self, *args): return _openmeeg.Geometry_sigma_in(self, *args)
    def sigma_out(self, *args): return _openmeeg.Geometry_sigma_out(self, *args)
    def sigma(self, *args): return _openmeeg.Geometry_sigma(self, *args)
    def surf(self, *args): return _openmeeg.Geometry_surf(self, *args)
    def getM(self, *args): return _openmeeg.Geometry_getM(self, *args)
    def getNumberOfPoints(self): return _openmeeg.Geometry_getNumberOfPoints(self)
    def selfCheck(self): return _openmeeg.Geometry_selfCheck(self)
    def check(self, *args): return _openmeeg.Geometry_check(self, *args)
    def getDomain(self, *args): return _openmeeg.Geometry_getDomain(self, *args)
Geometry_swigregister = _openmeeg.Geometry_swigregister
Geometry_swigregister(Geometry)

class Sensors(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Sensors, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Sensors, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Sensors(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Sensors
    __del__ = lambda self : None;
    def load(self, *args): return _openmeeg.Sensors_load(self, *args)
    def save(self, *args): return _openmeeg.Sensors_save(self, *args)
    def getNumberOfSensors(self): return _openmeeg.Sensors_getNumberOfSensors(self)
    def getNumberOfPositions(self): return _openmeeg.Sensors_getNumberOfPositions(self)
    def getPositions(self, *args): return _openmeeg.Sensors_getPositions(self, *args)
    def getOrientations(self, *args): return _openmeeg.Sensors_getOrientations(self, *args)
    def getSensorsNames(self, *args): return _openmeeg.Sensors_getSensorsNames(self, *args)
    def hasOrientations(self): return _openmeeg.Sensors_hasOrientations(self)
    def hasNames(self): return _openmeeg.Sensors_hasNames(self)
    def getPosition(self, *args): return _openmeeg.Sensors_getPosition(self, *args)
    def getOrientation(self, *args): return _openmeeg.Sensors_getOrientation(self, *args)
    def setPosition(self, *args): return _openmeeg.Sensors_setPosition(self, *args)
    def setOrientation(self, *args): return _openmeeg.Sensors_setOrientation(self, *args)
    def hasSensor(self, *args): return _openmeeg.Sensors_hasSensor(self, *args)
    def getSensorIdx(self, *args): return _openmeeg.Sensors_getSensorIdx(self, *args)
    def getWeightsMatrix(self): return _openmeeg.Sensors_getWeightsMatrix(self)
    def isEmpty(self): return _openmeeg.Sensors_isEmpty(self)
Sensors_swigregister = _openmeeg.Sensors_swigregister
Sensors_swigregister(Sensors)


def __lshift__(*args):
  return _openmeeg.__lshift__(*args)
__lshift__ = _openmeeg.__lshift__

def tri_tri_overlap_test_3d(*args):
  return _openmeeg.tri_tri_overlap_test_3d(*args)
tri_tri_overlap_test_3d = _openmeeg.tri_tri_overlap_test_3d
class Mesh(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Mesh, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Mesh, name)
    __repr__ = _swig_repr
    VTK = _openmeeg.Mesh_VTK
    TRI = _openmeeg.Mesh_TRI
    BND = _openmeeg.Mesh_BND
    MESH = _openmeeg.Mesh_MESH
    OFF = _openmeeg.Mesh_OFF
    def __init__(self, *args): 
        this = _openmeeg.new_Mesh(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Mesh
    __del__ = lambda self : None;
    def nbPts(self): return _openmeeg.Mesh_nbPts(self)
    def nbTrgs(self): return _openmeeg.Mesh_nbTrgs(self)
    def getPt(self, *args): return _openmeeg.Mesh_getPt(self, *args)
    def getTrg(self, *args): return _openmeeg.Mesh_getTrg(self, *args)
    def getTrianglesForPoint(self, *args): return _openmeeg.Mesh_getTrianglesForPoint(self, *args)
    def getTrianglesForPoints(self): return _openmeeg.Mesh_getTrianglesForPoints(self)
    def normal(self, *args): return _openmeeg.Mesh_normal(self, *args)
    def setPt(self, *args): return _openmeeg.Mesh_setPt(self, *args)
    def setTrg(self, *args): return _openmeeg.Mesh_setTrg(self, *args)
    def make_links(self): return _openmeeg.Mesh_make_links(self)
    def load(self, *args): return _openmeeg.Mesh_load(self, *args)
    def save(self, *args): return _openmeeg.Mesh_save(self, *args)
    def getFileFormat(self, *args): return _openmeeg.Mesh_getFileFormat(self, *args)
    def append(self, *args): return _openmeeg.Mesh_append(self, *args)
    def info(self): return _openmeeg.Mesh_info(self)
    def smooth(self, *args): return _openmeeg.Mesh_smooth(self, *args)
    def getNeighTrg(self, *args): return _openmeeg.Mesh_getNeighTrg(self, *args)
    def gradient(self): return _openmeeg.Mesh_gradient(self)
    def containsPoint(self, *args): return _openmeeg.Mesh_containsPoint(self, *args)
    def areas(self): return _openmeeg.Mesh_areas(self)
    __swig_getmethods__["triangle_intersection"] = lambda x: _openmeeg.Mesh_triangle_intersection
    if _newclass:triangle_intersection = staticmethod(_openmeeg.Mesh_triangle_intersection)
    def selfIntersection(self): return _openmeeg.Mesh_selfIntersection(self)
    def intersection(self, *args): return _openmeeg.Mesh_intersection(self, *args)
    def correct_orientation(self): return _openmeeg.Mesh_correct_orientation(self)
Mesh_swigregister = _openmeeg.Mesh_swigregister
Mesh_swigregister(Mesh)

def Mesh_triangle_intersection(*args):
  return _openmeeg.Mesh_triangle_intersection(*args)
Mesh_triangle_intersection = _openmeeg.Mesh_triangle_intersection


def P1Vector(*args):
  return _openmeeg.P1Vector(*args)
P1Vector = _openmeeg.P1Vector
class HeadMat(SymMatrix):
    __swig_setmethods__ = {}
    for _s in [SymMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HeadMat, name, value)
    __swig_getmethods__ = {}
    for _s in [SymMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HeadMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_HeadMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_HeadMat
    __del__ = lambda self : None;
HeadMat_swigregister = _openmeeg.HeadMat_swigregister
HeadMat_swigregister(HeadMat)

class SurfSourceMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SurfSourceMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SurfSourceMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_SurfSourceMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_SurfSourceMat
    __del__ = lambda self : None;
SurfSourceMat_swigregister = _openmeeg.SurfSourceMat_swigregister
SurfSourceMat_swigregister(SurfSourceMat)

class DipSourceMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DipSourceMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DipSourceMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_DipSourceMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_DipSourceMat
    __del__ = lambda self : None;
DipSourceMat_swigregister = _openmeeg.DipSourceMat_swigregister
DipSourceMat_swigregister(DipSourceMat)

class EITSourceMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, EITSourceMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, EITSourceMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_EITSourceMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_EITSourceMat
    __del__ = lambda self : None;
EITSourceMat_swigregister = _openmeeg.EITSourceMat_swigregister
EITSourceMat_swigregister(EITSourceMat)

class Surf2VolMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Surf2VolMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Surf2VolMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Surf2VolMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Surf2VolMat
    __del__ = lambda self : None;
Surf2VolMat_swigregister = _openmeeg.Surf2VolMat_swigregister
Surf2VolMat_swigregister(Surf2VolMat)

class Head2EEGMat(SparseMatrix):
    __swig_setmethods__ = {}
    for _s in [SparseMatrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Head2EEGMat, name, value)
    __swig_getmethods__ = {}
    for _s in [SparseMatrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Head2EEGMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Head2EEGMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Head2EEGMat
    __del__ = lambda self : None;
Head2EEGMat_swigregister = _openmeeg.Head2EEGMat_swigregister
Head2EEGMat_swigregister(Head2EEGMat)

class Head2MEGMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Head2MEGMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Head2MEGMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Head2MEGMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Head2MEGMat
    __del__ = lambda self : None;
Head2MEGMat_swigregister = _openmeeg.Head2MEGMat_swigregister
Head2MEGMat_swigregister(Head2MEGMat)

class SurfSource2MEGMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, SurfSource2MEGMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, SurfSource2MEGMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_SurfSource2MEGMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_SurfSource2MEGMat
    __del__ = lambda self : None;
SurfSource2MEGMat_swigregister = _openmeeg.SurfSource2MEGMat_swigregister
SurfSource2MEGMat_swigregister(SurfSource2MEGMat)

class DipSource2MEGMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DipSource2MEGMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DipSource2MEGMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_DipSource2MEGMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_DipSource2MEGMat
    __del__ = lambda self : None;
DipSource2MEGMat_swigregister = _openmeeg.DipSource2MEGMat_swigregister
DipSource2MEGMat_swigregister(DipSource2MEGMat)

class DipSource2InternalPotMat(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, DipSource2InternalPotMat, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, DipSource2InternalPotMat, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_DipSource2InternalPotMat(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_DipSource2InternalPotMat
    __del__ = lambda self : None;
DipSource2InternalPotMat_swigregister = _openmeeg.DipSource2InternalPotMat_swigregister
DipSource2InternalPotMat_swigregister(DipSource2InternalPotMat)

class GainMEG(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GainMEG, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GainMEG, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_GainMEG(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_GainMEG
    __del__ = lambda self : None;
GainMEG_swigregister = _openmeeg.GainMEG_swigregister
GainMEG_swigregister(GainMEG)

class GainEEG(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GainEEG, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GainEEG, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_GainEEG(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_GainEEG
    __del__ = lambda self : None;
GainEEG_swigregister = _openmeeg.GainEEG_swigregister
GainEEG_swigregister(GainEEG)

class GainInternalPot(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, GainInternalPot, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, GainInternalPot, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_GainInternalPot(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_GainInternalPot
    __del__ = lambda self : None;
GainInternalPot_swigregister = _openmeeg.GainInternalPot_swigregister
GainInternalPot_swigregister(GainInternalPot)

class Forward(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, Forward, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, Forward, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_Forward(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_Forward
    __del__ = lambda self : None;
Forward_swigregister = _openmeeg.Forward_swigregister
Forward_swigregister(Forward)


def compute_forward(*args):
  return _openmeeg.compute_forward(*args)
compute_forward = _openmeeg.compute_forward
EPSILON = _openmeeg.EPSILON
MINRES_TOL = _openmeeg.MINRES_TOL

def gentv(*args):
  return _openmeeg.gentv(*args)
gentv = _openmeeg.gentv

def compute_one_tv(*args):
  return _openmeeg.compute_one_tv(*args)
compute_one_tv = _openmeeg.compute_one_tv
class MN_Hessian(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, MN_Hessian, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, MN_Hessian, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_MN_Hessian(*args)
        try: self.this.append(this)
        except: self.this = this
    def __mul__(self, *args): return _openmeeg.MN_Hessian___mul__(self, *args)
    __swig_destroy__ = _openmeeg.delete_MN_Hessian
    __del__ = lambda self : None;
MN_Hessian_swigregister = _openmeeg.MN_Hessian_swigregister
MN_Hessian_swigregister(MN_Hessian)

class WMN_Hessian(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, WMN_Hessian, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, WMN_Hessian, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_WMN_Hessian(*args)
        try: self.this.append(this)
        except: self.this = this
    def __mul__(self, *args): return _openmeeg.WMN_Hessian___mul__(self, *args)
    __swig_destroy__ = _openmeeg.delete_WMN_Hessian
    __del__ = lambda self : None;
WMN_Hessian_swigregister = _openmeeg.WMN_Hessian_swigregister
WMN_Hessian_swigregister(WMN_Hessian)

class HEAT_Hessian(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, HEAT_Hessian, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, HEAT_Hessian, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_HEAT_Hessian(*args)
        try: self.this.append(this)
        except: self.this = this
    def __mul__(self, *args): return _openmeeg.HEAT_Hessian___mul__(self, *args)
    __swig_destroy__ = _openmeeg.delete_HEAT_Hessian
    __del__ = lambda self : None;
HEAT_Hessian_swigregister = _openmeeg.HEAT_Hessian_swigregister
HEAT_Hessian_swigregister(HEAT_Hessian)


def compute_mn(*args):
  return _openmeeg.compute_mn(*args)
compute_mn = _openmeeg.compute_mn
class IMN_inverse(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, IMN_inverse, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, IMN_inverse, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_IMN_inverse(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_IMN_inverse
    __del__ = lambda self : None;
IMN_inverse_swigregister = _openmeeg.IMN_inverse_swigregister
IMN_inverse_swigregister(IMN_inverse)

class MN_inverse(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, MN_inverse, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, MN_inverse, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_MN_inverse(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_MN_inverse
    __del__ = lambda self : None;
MN_inverse_swigregister = _openmeeg.MN_inverse_swigregister
MN_inverse_swigregister(MN_inverse)

class WMN_inverse(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, WMN_inverse, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, WMN_inverse, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_WMN_inverse(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_WMN_inverse
    __del__ = lambda self : None;
WMN_inverse_swigregister = _openmeeg.WMN_inverse_swigregister
WMN_inverse_swigregister(WMN_inverse)

class HEAT_inverse(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, HEAT_inverse, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, HEAT_inverse, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_HEAT_inverse(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_HEAT_inverse
    __del__ = lambda self : None;
HEAT_inverse_swigregister = _openmeeg.HEAT_inverse_swigregister
HEAT_inverse_swigregister(HEAT_inverse)


def compute_tv(*args):
  return _openmeeg.compute_tv(*args)
compute_tv = _openmeeg.compute_tv
class TV_inverse(Matrix):
    __swig_setmethods__ = {}
    for _s in [Matrix]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, TV_inverse, name, value)
    __swig_getmethods__ = {}
    for _s in [Matrix]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, TV_inverse, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _openmeeg.new_TV_inverse(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _openmeeg.delete_TV_inverse
    __del__ = lambda self : None;
TV_inverse_swigregister = _openmeeg.TV_inverse_swigregister
TV_inverse_swigregister(TV_inverse)


def asarray(*args):
  return _openmeeg.asarray(*args)
asarray = _openmeeg.asarray
# This file is compatible with both classic and new-style classes.