# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.4
#
# 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('_magicsquares', [dirname(__file__)])
        except ImportError:
            import _magicsquares
            return _magicsquares
        if fp is not None:
            try:
                _mod = imp.load_module('_magicsquares', fp, pathname, description)
            finally:
                fp.close()
            return _mod
    _magicsquares = swig_import_helper()
    del swig_import_helper
else:
    import _magicsquares
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 SwigPyIterator(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, SwigPyIterator, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, SwigPyIterator, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _magicsquares.delete_SwigPyIterator
    __del__ = lambda self : None;
    def value(self): return _magicsquares.SwigPyIterator_value(self)
    def incr(self, n = 1): return _magicsquares.SwigPyIterator_incr(self, n)
    def decr(self, n = 1): return _magicsquares.SwigPyIterator_decr(self, n)
    def distance(self, *args): return _magicsquares.SwigPyIterator_distance(self, *args)
    def equal(self, *args): return _magicsquares.SwigPyIterator_equal(self, *args)
    def copy(self): return _magicsquares.SwigPyIterator_copy(self)
    def next(self): return _magicsquares.SwigPyIterator_next(self)
    def __next__(self): return _magicsquares.SwigPyIterator___next__(self)
    def previous(self): return _magicsquares.SwigPyIterator_previous(self)
    def advance(self, *args): return _magicsquares.SwigPyIterator_advance(self, *args)
    def __eq__(self, *args): return _magicsquares.SwigPyIterator___eq__(self, *args)
    def __ne__(self, *args): return _magicsquares.SwigPyIterator___ne__(self, *args)
    def __iadd__(self, *args): return _magicsquares.SwigPyIterator___iadd__(self, *args)
    def __isub__(self, *args): return _magicsquares.SwigPyIterator___isub__(self, *args)
    def __add__(self, *args): return _magicsquares.SwigPyIterator___add__(self, *args)
    def __sub__(self, *args): return _magicsquares.SwigPyIterator___sub__(self, *args)
    def __iter__(self): return self
SwigPyIterator_swigregister = _magicsquares.SwigPyIterator_swigregister
SwigPyIterator_swigregister(SwigPyIterator)

class PCA(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCA, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, PCA, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _magicsquares.new_PCA(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _magicsquares.delete_PCA
    __del__ = lambda self : None;
    def AddFeature(self, *args): return _magicsquares.PCA_AddFeature(self, *args)
    def Calculate(self): return _magicsquares.PCA_Calculate(self)
    def Compress(self, *args): return _magicsquares.PCA_Compress(self, *args)
    def Mult(self, *args): return _magicsquares.PCA_Mult(self, *args)
    def Project(self, *args): return _magicsquares.PCA_Project(self, *args)
    def Synth(self, *args): return _magicsquares.PCA_Synth(self, *args)
    __swig_getmethods__["RunTests"] = lambda x: _magicsquares.PCA_RunTests
    if _newclass:RunTests = staticmethod(_magicsquares.PCA_RunTests)
    def GetEigenValues(self): return _magicsquares.PCA_GetEigenValues(self)
    def GetEigenTransform(self): return _magicsquares.PCA_GetEigenTransform(self)
    def EigenTransform(self): return _magicsquares.PCA_EigenTransform(self)
    def GetFeatures(self): return _magicsquares.PCA_GetFeatures(self)
    def GetMean(self): return _magicsquares.PCA_GetMean(self)
    def GetFeatureSize(self): return _magicsquares.PCA_GetFeatureSize(self)
    def GetParamsSize(self): return _magicsquares.PCA_GetParamsSize(self)
    def Load(self, *args): return _magicsquares.PCA_Load(self, *args)
    def Save(self, *args): return _magicsquares.PCA_Save(self, *args)
PCA_swigregister = _magicsquares.PCA_swigregister
PCA_swigregister(PCA)

def PCA_RunTests():
  return _magicsquares.PCA_RunTests()
PCA_RunTests = _magicsquares.PCA_RunTests

class Classifier(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Classifier, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Classifier, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _magicsquares.delete_Classifier
    __del__ = lambda self : None;
    def AddFeature(self, *args): return _magicsquares.Classifier_AddFeature(self, *args)
    def Classify(self, *args): return _magicsquares.Classifier_Classify(self, *args)
    def GroupExists(self, *args): return _magicsquares.Classifier_GroupExists(self, *args)
    def GetGroupMean(self, *args): return _magicsquares.Classifier_GetGroupMean(self, *args)
Classifier_swigregister = _magicsquares.Classifier_swigregister
Classifier_swigregister(Classifier)

class LDAClassifier(Classifier):
    __swig_setmethods__ = {}
    for _s in [Classifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, LDAClassifier, name, value)
    __swig_getmethods__ = {}
    for _s in [Classifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, LDAClassifier, name)
    def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
    __repr__ = _swig_repr
    __swig_destroy__ = _magicsquares.delete_LDAClassifier
    __del__ = lambda self : None;
    def Classify(self, *args): return _magicsquares.LDAClassifier_Classify(self, *args)
LDAClassifier_swigregister = _magicsquares.LDAClassifier_swigregister
LDAClassifier_swigregister(LDAClassifier)


def matrix_inverse(*args):
  return _magicsquares.matrix_inverse(*args)
matrix_inverse = _magicsquares.matrix_inverse
class Image(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Image, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Image, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _magicsquares.new_Image(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _magicsquares.delete_Image
    __del__ = lambda self : None;
    def Clear(self): return _magicsquares.Image_Clear(self)
    def Get(self, *args): return _magicsquares.Image_Get(self, *args)
    def __sub__(self, *args): return _magicsquares.Image___sub__(self, *args)
    def __add__(self, *args): return _magicsquares.Image___add__(self, *args)
    def PrintInfo(self): return _magicsquares.Image_PrintInfo(self)
    def Crop(self, *args): return _magicsquares.Image_Crop(self, *args)
    def Scale(self, *args): return _magicsquares.Image_Scale(self, *args)
    def SubImage(self, *args): return _magicsquares.Image_SubImage(self, *args)
    def Blit(self, *args): return _magicsquares.Image_Blit(self, *args)
    def SSD(self, *args): return _magicsquares.Image_SSD(self, *args)
    def SubMean(self): return _magicsquares.Image_SubMean(self)
    def LBP(self): return _magicsquares.Image_LBP(self)
    def GRAY2RGB(self): return _magicsquares.Image_GRAY2RGB(self)
    def RGB2GRAY(self): return _magicsquares.Image_RGB2GRAY(self)
    def BayerGB2RGB(self): return _magicsquares.Image_BayerGB2RGB(self)
    def Hist(self, *args): return _magicsquares.Image_Hist(self, *args)
    def ToFloatVector(self): return _magicsquares.Image_ToFloatVector(self)
    def NumElements(self): return _magicsquares.Image_NumElements(self)
    def Save(self, *args): return _magicsquares.Image_Save(self, *args)
    def GetBB(self, *args): return _magicsquares.Image_GetBB(self, *args)
    __swig_setmethods__["m_Image"] = _magicsquares.Image_m_Image_set
    __swig_getmethods__["m_Image"] = _magicsquares.Image_m_Image_get
    if _newclass:m_Image = _swig_property(_magicsquares.Image_m_Image_get, _magicsquares.Image_m_Image_set)
Image_swigregister = _magicsquares.Image_swigregister
Image_swigregister(Image)

class PCAClassifier(Classifier):
    __swig_setmethods__ = {}
    for _s in [Classifier]: __swig_setmethods__.update(getattr(_s,'__swig_setmethods__',{}))
    __setattr__ = lambda self, name, value: _swig_setattr(self, PCAClassifier, name, value)
    __swig_getmethods__ = {}
    for _s in [Classifier]: __swig_getmethods__.update(getattr(_s,'__swig_getmethods__',{}))
    __getattr__ = lambda self, name: _swig_getattr(self, PCAClassifier, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _magicsquares.new_PCAClassifier(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _magicsquares.delete_PCAClassifier
    __del__ = lambda self : None;
    def AddFeature(self, *args): return _magicsquares.PCAClassifier_AddFeature(self, *args)
    def Classify(self, *args): return _magicsquares.PCAClassifier_Classify(self, *args)
    def GetPCA(self): return _magicsquares.PCAClassifier_GetPCA(self)
PCAClassifier_swigregister = _magicsquares.PCAClassifier_swigregister
PCAClassifier_swigregister(PCAClassifier)


def dsvd(*args):
  return _magicsquares.dsvd(*args)
dsvd = _magicsquares.dsvd

def SVD(*args):
  return _magicsquares.SVD(*args)
SVD = _magicsquares.SVD

def OpenFile(*args):
  return _magicsquares.OpenFile(*args)
OpenFile = _magicsquares.OpenFile

def CloseFile(*args):
  return _magicsquares.CloseFile(*args)
CloseFile = _magicsquares.CloseFile

def Glob(*args):
  return _magicsquares.Glob(*args)
Glob = _magicsquares.Glob
class Rect(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, Rect, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, Rect, name)
    __repr__ = _swig_repr
    def __init__(self, *args): 
        this = _magicsquares.new_Rect(*args)
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _magicsquares.delete_Rect
    __del__ = lambda self : None;
    __swig_setmethods__["x"] = _magicsquares.Rect_x_set
    __swig_getmethods__["x"] = _magicsquares.Rect_x_get
    if _newclass:x = _swig_property(_magicsquares.Rect_x_get, _magicsquares.Rect_x_set)
    __swig_setmethods__["y"] = _magicsquares.Rect_y_set
    __swig_getmethods__["y"] = _magicsquares.Rect_y_get
    if _newclass:y = _swig_property(_magicsquares.Rect_y_get, _magicsquares.Rect_y_set)
    __swig_setmethods__["w"] = _magicsquares.Rect_w_set
    __swig_getmethods__["w"] = _magicsquares.Rect_w_get
    if _newclass:w = _swig_property(_magicsquares.Rect_w_get, _magicsquares.Rect_w_set)
    __swig_setmethods__["h"] = _magicsquares.Rect_h_set
    __swig_getmethods__["h"] = _magicsquares.Rect_h_get
    if _newclass:h = _swig_property(_magicsquares.Rect_h_get, _magicsquares.Rect_h_set)
Rect_swigregister = _magicsquares.Rect_swigregister
Rect_swigregister(Rect)

class FaceFinder(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FaceFinder, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FaceFinder, name)
    __repr__ = _swig_repr
    def __init__(self): 
        this = _magicsquares.new_FaceFinder()
        try: self.this.append(this)
        except: self.this = this
    __swig_destroy__ = _magicsquares.delete_FaceFinder
    __del__ = lambda self : None;
    def Find(self, *args): return _magicsquares.FaceFinder_Find(self, *args)
FaceFinder_swigregister = _magicsquares.FaceFinder_swigregister
FaceFinder_swigregister(FaceFinder)

class FloatVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatVector, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _magicsquares.delete_FloatVector
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _magicsquares.new_FloatVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def Size(self): return _magicsquares.FloatVector_Size(self)
    def GetRawData(self): return _magicsquares.FloatVector_GetRawData(self)
    def GetRawDataConst(self): return _magicsquares.FloatVector_GetRawDataConst(self)
    def Print(self): return _magicsquares.FloatVector_Print(self)
    def SetAll(self, *args): return _magicsquares.FloatVector_SetAll(self, *args)
    def Zero(self): return _magicsquares.FloatVector_Zero(self)
    def IsInf(self): return _magicsquares.FloatVector_IsInf(self)
    def Mean(self): return _magicsquares.FloatVector_Mean(self)
    def DistanceFrom(self, *args): return _magicsquares.FloatVector_DistanceFrom(self, *args)
    def Magnitude(self): return _magicsquares.FloatVector_Magnitude(self)
    def Dot(self, *args): return _magicsquares.FloatVector_Dot(self, *args)
    def Normalised(self): return _magicsquares.FloatVector_Normalised(self)
    def __add__(self, *args): return _magicsquares.FloatVector___add__(self, *args)
    def __sub__(self, *args): return _magicsquares.FloatVector___sub__(self, *args)
    def __mul__(self, *args): return _magicsquares.FloatVector___mul__(self, *args)
    def __div__(self, *args): return _magicsquares.FloatVector___div__(self, *args)
    def __iadd__(self, *args): return _magicsquares.FloatVector___iadd__(self, *args)
    def __isub__(self, *args): return _magicsquares.FloatVector___isub__(self, *args)
    def __imul__(self, *args): return _magicsquares.FloatVector___imul__(self, *args)
    def __idiv__(self, *args): return _magicsquares.FloatVector___idiv__(self, *args)
    def Save(self, *args): return _magicsquares.FloatVector_Save(self, *args)
    def Load(self, *args): return _magicsquares.FloatVector_Load(self, *args)
    __swig_getmethods__["RunTests"] = lambda x: _magicsquares.FloatVector_RunTests
    if _newclass:RunTests = staticmethod(_magicsquares.FloatVector_RunTests)
    def __getitem__(self, *args): return _magicsquares.FloatVector___getitem__(self, *args)
    def __setitem__(self, *args): return _magicsquares.FloatVector___setitem__(self, *args)
FloatVector_swigregister = _magicsquares.FloatVector_swigregister
FloatVector_swigregister(FloatVector)

def FloatVector_RunTests():
  return _magicsquares.FloatVector_RunTests()
FloatVector_RunTests = _magicsquares.FloatVector_RunTests

class FloatMatrix(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, FloatMatrix, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, FloatMatrix, name)
    __repr__ = _swig_repr
    __swig_destroy__ = _magicsquares.delete_FloatMatrix
    __del__ = lambda self : None;
    def __init__(self, *args): 
        this = _magicsquares.new_FloatMatrix(*args)
        try: self.this.append(this)
        except: self.this = this
    def GetRows(self): return _magicsquares.FloatMatrix_GetRows(self)
    def GetCols(self): return _magicsquares.FloatMatrix_GetCols(self)
    def GetRawData(self): return _magicsquares.FloatMatrix_GetRawData(self)
    def GetRawDataConst(self): return _magicsquares.FloatMatrix_GetRawDataConst(self)
    def GetRowVector(self, *args): return _magicsquares.FloatMatrix_GetRowVector(self, *args)
    def GetColVector(self, *args): return _magicsquares.FloatMatrix_GetColVector(self, *args)
    def SetRowVector(self, *args): return _magicsquares.FloatMatrix_SetRowVector(self, *args)
    def SetColVector(self, *args): return _magicsquares.FloatMatrix_SetColVector(self, *args)
    def NormaliseRows(self): return _magicsquares.FloatMatrix_NormaliseRows(self)
    def NormaliseCols(self): return _magicsquares.FloatMatrix_NormaliseCols(self)
    def Print(self): return _magicsquares.FloatMatrix_Print(self)
    def SetAll(self, *args): return _magicsquares.FloatMatrix_SetAll(self, *args)
    def Zero(self): return _magicsquares.FloatMatrix_Zero(self)
    def IsInf(self): return _magicsquares.FloatMatrix_IsInf(self)
    def Transposed(self): return _magicsquares.FloatMatrix_Transposed(self)
    def Inverted(self): return _magicsquares.FloatMatrix_Inverted(self)
    def __add__(self, *args): return _magicsquares.FloatMatrix___add__(self, *args)
    def __sub__(self, *args): return _magicsquares.FloatMatrix___sub__(self, *args)
    def __mul__(self, *args): return _magicsquares.FloatMatrix___mul__(self, *args)
    def VecMulTransposed(self, *args): return _magicsquares.FloatMatrix_VecMulTransposed(self, *args)
    def __iadd__(self, *args): return _magicsquares.FloatMatrix___iadd__(self, *args)
    def __isub__(self, *args): return _magicsquares.FloatMatrix___isub__(self, *args)
    def __imul__(self, *args): return _magicsquares.FloatMatrix___imul__(self, *args)
    def __eq__(self, *args): return _magicsquares.FloatMatrix___eq__(self, *args)
    def SortRows(self, *args): return _magicsquares.FloatMatrix_SortRows(self, *args)
    def SortCols(self, *args): return _magicsquares.FloatMatrix_SortCols(self, *args)
    def CropRows(self, *args): return _magicsquares.FloatMatrix_CropRows(self, *args)
    def CropCols(self, *args): return _magicsquares.FloatMatrix_CropCols(self, *args)
    def Save(self, *args): return _magicsquares.FloatMatrix_Save(self, *args)
    def Load(self, *args): return _magicsquares.FloatMatrix_Load(self, *args)
    __swig_getmethods__["RunTests"] = lambda x: _magicsquares.FloatMatrix_RunTests
    if _newclass:RunTests = staticmethod(_magicsquares.FloatMatrix_RunTests)
    def Get(self, *args): return _magicsquares.FloatMatrix_Get(self, *args)
    def Set(self, *args): return _magicsquares.FloatMatrix_Set(self, *args)
FloatMatrix_swigregister = _magicsquares.FloatMatrix_swigregister
FloatMatrix_swigregister(FloatMatrix)

def FloatMatrix_RunTests():
  return _magicsquares.FloatMatrix_RunTests()
FloatMatrix_RunTests = _magicsquares.FloatMatrix_RunTests

class RectVector(_object):
    __swig_setmethods__ = {}
    __setattr__ = lambda self, name, value: _swig_setattr(self, RectVector, name, value)
    __swig_getmethods__ = {}
    __getattr__ = lambda self, name: _swig_getattr(self, RectVector, name)
    __repr__ = _swig_repr
    def iterator(self): return _magicsquares.RectVector_iterator(self)
    def __iter__(self): return self.iterator()
    def __nonzero__(self): return _magicsquares.RectVector___nonzero__(self)
    def __bool__(self): return _magicsquares.RectVector___bool__(self)
    def __len__(self): return _magicsquares.RectVector___len__(self)
    def pop(self): return _magicsquares.RectVector_pop(self)
    def __getslice__(self, *args): return _magicsquares.RectVector___getslice__(self, *args)
    def __setslice__(self, *args): return _magicsquares.RectVector___setslice__(self, *args)
    def __delslice__(self, *args): return _magicsquares.RectVector___delslice__(self, *args)
    def __delitem__(self, *args): return _magicsquares.RectVector___delitem__(self, *args)
    def __getitem__(self, *args): return _magicsquares.RectVector___getitem__(self, *args)
    def __setitem__(self, *args): return _magicsquares.RectVector___setitem__(self, *args)
    def append(self, *args): return _magicsquares.RectVector_append(self, *args)
    def empty(self): return _magicsquares.RectVector_empty(self)
    def size(self): return _magicsquares.RectVector_size(self)
    def clear(self): return _magicsquares.RectVector_clear(self)
    def swap(self, *args): return _magicsquares.RectVector_swap(self, *args)
    def get_allocator(self): return _magicsquares.RectVector_get_allocator(self)
    def begin(self): return _magicsquares.RectVector_begin(self)
    def end(self): return _magicsquares.RectVector_end(self)
    def rbegin(self): return _magicsquares.RectVector_rbegin(self)
    def rend(self): return _magicsquares.RectVector_rend(self)
    def pop_back(self): return _magicsquares.RectVector_pop_back(self)
    def erase(self, *args): return _magicsquares.RectVector_erase(self, *args)
    def __init__(self, *args): 
        this = _magicsquares.new_RectVector(*args)
        try: self.this.append(this)
        except: self.this = this
    def push_back(self, *args): return _magicsquares.RectVector_push_back(self, *args)
    def front(self): return _magicsquares.RectVector_front(self)
    def back(self): return _magicsquares.RectVector_back(self)
    def assign(self, *args): return _magicsquares.RectVector_assign(self, *args)
    def resize(self, *args): return _magicsquares.RectVector_resize(self, *args)
    def insert(self, *args): return _magicsquares.RectVector_insert(self, *args)
    def reserve(self, *args): return _magicsquares.RectVector_reserve(self, *args)
    def capacity(self): return _magicsquares.RectVector_capacity(self)
    __swig_destroy__ = _magicsquares.delete_RectVector
    __del__ = lambda self : None;
RectVector_swigregister = _magicsquares.RectVector_swigregister
RectVector_swigregister(RectVector)

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


