def __init__( self, inSpace, h=None, L=2, adj=False, **kparams ): """ Takes h, L as paramaters. h as source so it creates it. """ assert h is not None kparams.update( h=Source(h.getContainer()), L=L, adj=adj ) LinearOperatorStruct.__init__( self, inSpace, **kparams )
def __init__(self, inSpace, nbs, nba, ac, cpxIn=False, adj=False): LinearOperatorStruct.__init__(self, inSpace, nba=nba, nbs=nbs, ac=ac, adj=adj, cpxIn=cpxIn)
def __init__( self, inSpace, axis= 1, type = 'linear', unit=True ): """ @param unit unitary scaling @param type wavelet type """ self.axis = axis kparams = dict( type = type , adj=False, unit=unit ) LinearOperatorStruct.__init__( self, inSpace, **kparams )
def __init__(self, inSpace, num_blocks): env = InstanceManager() np = env['slimvars']['np'] if prod(num_blocks) != np: raise Exception( "num_blocks does not match mpi variable 'np', %(num_blocks)s != %(np)s " % vars()) kparams = dict(num_blocks=tuple(num_blocks)) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, inSpace, filt=1, input=None, adj=0, **kparams): """ Takes filt and input as paramaters. Input as source so it creates it. """ kparams.update(filt=filt, adj=adj) if filt == 1: assert input is not None kparams.update(input=Source(input.getContainer())) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, inSpace, adj=False, **kparams): """ nN is the number of N's that are given to the functions. Note: n1,n2 and n1out,n2out are the same. beg1.end1 - beg2,end2 adds padding to the dataset. """ for nN in kparams: if not re.match('(^beg\d+$|^end\d+$|^n\d+$|^adj$|^n\d+out$)', nN): raise TypeError, "Invalid Parameter, must be n# or n#out, beg# or end#." # kparams['adj'] = False LinearOperatorStruct.__init__(self, inSpace, adj=adj, **kparams)
def __init__(self, inSpace, dataSpace, que='y', adj=False, **kparams): """ inp and out are the input and output's of the file. The que='n' param sets the default mig script to force run in environment. """ # This parameter sets the default mig script to force run in environment. kparams.update(modelSpace=inSpace, dataSpace=dataSpace, adj=adj, que=que) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, inSpace, mask): from slimpy_base.Core.User.Structures.serial_vector import Vector if isinstance(mask, str): from slimpy_base import vector mask = vector(mask) elif not isinstance(mask, Vector): raise TypeError( "argument 'mask' must be a 'Vector' or a 'str' instance got '%s'" % type(mask)) LinearOperatorStruct.__init__(self, inSpace, mask=Source(mask.container))
def __init__(self, inSpace, curveSpace=None, nbs=4, nba=8, ac=1, adj=False): LinearOperatorStruct.__init__(self, inSpace, curveSpace=curveSpace, nbs=nbs, nba=nba, ac=ac, adj=adj)
def __init__(self, space, matrix, adj=False): from slimpy_base.Core.User.Structures.serial_vector import Vector if isinstance(matrix, str): from slimpy_base import vector matrix = vector(matrix) elif not isinstance(matrix, Vector): raise TypeError( "argument 'matrix' must be a 'Vector' or a 'str' instance got '%s'" % type(matrix)) self.inSpace = space kparams = dict(mat=Source(matrix.container), adj=adj) LinearOperatorStruct.__init__(self, self.inSpace, **kparams)
def __init__(self, domain): if isinstance(domain, MetaSpace): adj = False # meta_shape = domain.meta.shape num_blocks = domain.shape else: adj = True # meta_shape = domain.shape num_blocks = domain['num_blocks'] LinearOperatorStruct.__init__( self, domain, # meta_shape=tuple(meta_shape), num_blocks=tuple(num_blocks), adj=adj)
def __init__(self, inSpace, adj=False, Pyr_Level=2, **kparams): """ Only Pyr_Level, K, lambda, beta, mSize, bo, dir_filter allowed. Constructor @param inSpace space instance @param adj create adjoint transform @param Pyr_Level ??? """ for key in kparams: if not key in [ 'Pyr_Level', 'K', 'lamb', 'beta', 'mSize', 'bo', 'dir_filter' ]: raise TypeError, "Invalid Paramter, only Pyr_Level, K, lamb, beta, mSize, bo, dir_filter allowed." kparams.update(adj=adj, Pyr_Level=Pyr_Level) __LR.__init__(self, inSpace, **kparams)
def __init__(self, inSpace, ang1=None, ang2=None, ang3=None, ang4=None, ang=None, angle='n', dim=2, adj=False, **kparams): """ Takes parameters dim=[2/3], pass=[y/n], ang[1-4]= """ for nN in kparams: if not re.match('(^v\d*$|^pass$)', nN): raise TypeError, "Invalid Parameter, must be v# or pass." if ang != None: ang = 90 - ang kparams = dict(kparams, adj=adj, angle=angle, dim=dim, ang1=-ang, ang2=-0.9 * ang, ang3=0.9 * ang, ang4=ang) else: kparams = dict(kparams, adj=adj, angle=angle, dim=dim, ang1=ang1, ang2=ang2, ang3=ang3, ang4=ang4) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, wvec, inSpace): """ The param wvec must be able to be applied to another vector. Or is it is out of core, can be a string TODO if wvec is None, it is the Identity operator. TODO - error trap that if wvec is same type as other when applying. """ msg = "weightoper:Dont use this class!!! use DiagonalWeight" import warnings warnings.warn(msg, DeprecationWarning) self.wvec = wvec if is_vector(wvec): par = Source(wvec.container) LinearOperatorStruct.__init__(self, inSpace, vec=par) if isinstance(wvec, DataContainer): par = Source(wvec) LinearOperatorStruct.__init__(self, inSpace, vec=par) else: LinearOperatorStruct.__init__(self, inSpace, wvec)
def __init__( self, inSpace, sym=True, opt=False, pad=1, axis=2, adj=False ): kparams = dict( sym=sym, opt=opt, pad=pad, axis=axis, adj=adj ) LinearOperatorStruct.__init__( self, inSpace, **kparams )
def __init__(self, domain): kparams = dict(adj=False) LinearOperatorStruct.__init__(self, domain, **kparams)
def __init__(self, domain, sym=True, opt=False): kparams = dict(sym=sym, opt=opt, adj=False) LinearOperatorStruct.__init__(self, domain, **kparams)
def __init__(self, inSpace, inv=True, **kparams): """ Initialize the operator. """ LinearOperatorStruct.__init__(self, inSpace, inv=inv, **kparams)
def __init__(self, inSpace, mask, axis=2): self.axis = axis kparams = dict(mask=Source(mask.container)) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, domain, adj=False): LinearOperatorStruct.__init__(self, domain, adj=False)
def __init__(self, inspace, plane=[1, 2], **kparams): LinearOperatorStruct.__init__(self, inspace, plane=plane, **kparams)
def __init__(self, domain, eps, adj=False): """ Initialize the operator. """ LinearOperatorStruct.__init__(self, domain, adj=False, eps=eps)
def __init__(self, inSpace, **kparams): """ Initialize the operator. """ LinearOperatorStruct.__init__(self, inSpace, adj=False, **kparams)
def __init__(self, inSpace, eps): kparams = dict(eps=eps) LinearOperatorStruct.__init__(self, inSpace, **kparams)
def __init__(self, domain, sigma=0.08): kparams = dict(sigma=0.08, adj=False) LinearOperatorStruct.__init__(self, domain, **kparams)
def __init__(self, inspace): """ Just call the superclass weight operator, that will apply the conj op. """ LinearOperatorStruct.__init__(self, inspace)