def __call__(self):
u"""
If you call the object return either the method/function object or
None if it has died. Arguments are ignored.
"""
inst = self._inst()
if inst:
return new_instancemethod(self._func, inst, inst.__class__)
return None
is (most of the time) equivalent to:
obj = itkMinimumMaximumImageFilterIF2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkMinimumMaximumImageFilterIF2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkMinimumMaximumImageFilterIF2.Clone = new_instancemethod(
_itkMinimumMaximumImageFilterPython.itkMinimumMaximumImageFilterIF2_Clone,
None, itkMinimumMaximumImageFilterIF2)
itkMinimumMaximumImageFilterIF2.GetMinimumOutput = new_instancemethod(
_itkMinimumMaximumImageFilterPython.
itkMinimumMaximumImageFilterIF2_GetMinimumOutput, None,
itkMinimumMaximumImageFilterIF2)
itkMinimumMaximumImageFilterIF2.GetMinimum = new_instancemethod(
_itkMinimumMaximumImageFilterPython.
itkMinimumMaximumImageFilterIF2_GetMinimum, None,
itkMinimumMaximumImageFilterIF2)
itkMinimumMaximumImageFilterIF2.GetMaximumOutput = new_instancemethod(
_itkMinimumMaximumImageFilterPython.
itkMinimumMaximumImageFilterIF2_GetMaximumOutput, None,
itkMinimumMaximumImageFilterIF2)
itkMinimumMaximumImageFilterIF2.GetMaximum = new_instancemethod(
_itkMinimumMaximumImageFilterPython.
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self, *args):
"""__init__(self, char _message) -> TSTException"""
_tst.TSTException_swiginit(self, _tst.new_TSTException(*args))
def what(self):
"""what(self) -> char"""
return _tst.TSTException_what(self)
__swig_destroy__ = _tst.delete_TSTException
TSTException.what = new_instancemethod(_tst.TSTException_what, None, TSTException)
TSTException_swigregister = _tst.TSTException_swigregister
TSTException_swigregister(TSTException)
cvar = _tst.cvar
TST_VERSION = cvar.TST_VERSION
UNDEFINED_INDEX = cvar.UNDEFINED_INDEX
class _TST(object):
"""Proxy of C++ tst<(char,PythonReference,memory_storage<(char,PythonReference)>,ObjectSerializer,string_type)> class"""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
__repr__ = _swig_repr
def __init__(self):
"""__init__(self) -> _TST"""
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _IntImpParGen.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_IntImpParGen.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_IntImpParGen.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_IntImpParGen.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_IntImpParGen.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_IntImpParGen.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_IntImpParGen.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_IntImpParGen.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_IntImpParGen.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_IntImpParGen.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_IntImpParGen.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_IntImpParGen.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_IntImpParGen.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_IntImpParGen.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_IntImpParGen.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_IntImpParGen.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_IntImpParGen.SwigPyIterator___sub__,None,SwigPyIterator)
itkQuaternionRigidTransformD.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkQuaternionRigidTransformD.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkQuaternionRigidTransformD.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkQuaternionRigidTransformD.SetRotation = new_instancemethod(_itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD_SetRotation,None,itkQuaternionRigidTransformD)
itkQuaternionRigidTransformD.GetRotation = new_instancemethod(_itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD_GetRotation,None,itkQuaternionRigidTransformD)
itkQuaternionRigidTransformD.GetPointer = new_instancemethod(_itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD_GetPointer,None,itkQuaternionRigidTransformD)
itkQuaternionRigidTransformD_swigregister = _itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD_swigregister
itkQuaternionRigidTransformD_swigregister(itkQuaternionRigidTransformD)
def itkQuaternionRigidTransformD___New_orig__():
"""itkQuaternionRigidTransformD___New_orig__()"""
return _itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD___New_orig__()
def itkQuaternionRigidTransformD_cast(*args):
"""itkQuaternionRigidTransformD_cast(itkLightObject obj) -> itkQuaternionRigidTransformD"""
return _itkQuaternionRigidTransformPython.itkQuaternionRigidTransformD_cast(*args)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _ShapeAlgo.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_ShapeAlgo.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_ShapeAlgo.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_ShapeAlgo.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_ShapeAlgo.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_ShapeAlgo.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_ShapeAlgo.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_ShapeAlgo.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_ShapeAlgo.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_ShapeAlgo.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_ShapeAlgo.SwigPyIterator___sub__,None,SwigPyIterator)
return obj
New = staticmethod(New)
def __len__(self):
return self.GetNumberOfLabelObjects()
def __getitem__(self, label):
return self.GetLabelObject(label)
def __iter__(self):
labels = self.GetLabels()
for label in labels:
yield self.GetLabelObject(label)
itkLabelMap2.SetRegions = new_instancemethod(_itkLabelMapPython.itkLabelMap2_SetRegions,None,itkLabelMap2)
itkLabelMap2.HasLabel = new_instancemethod(_itkLabelMapPython.itkLabelMap2_HasLabel,None,itkLabelMap2)
itkLabelMap2.GetNthLabelObject = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetNthLabelObject,None,itkLabelMap2)
itkLabelMap2.GetPixel = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetPixel,None,itkLabelMap2)
itkLabelMap2.SetPixel = new_instancemethod(_itkLabelMapPython.itkLabelMap2_SetPixel,None,itkLabelMap2)
itkLabelMap2.SetLine = new_instancemethod(_itkLabelMapPython.itkLabelMap2_SetLine,None,itkLabelMap2)
itkLabelMap2.GetLabelObject = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetLabelObject,None,itkLabelMap2)
itkLabelMap2.AddLabelObject = new_instancemethod(_itkLabelMapPython.itkLabelMap2_AddLabelObject,None,itkLabelMap2)
itkLabelMap2.PushLabelObject = new_instancemethod(_itkLabelMapPython.itkLabelMap2_PushLabelObject,None,itkLabelMap2)
itkLabelMap2.RemoveLabelObject = new_instancemethod(_itkLabelMapPython.itkLabelMap2_RemoveLabelObject,None,itkLabelMap2)
itkLabelMap2.RemoveLabel = new_instancemethod(_itkLabelMapPython.itkLabelMap2_RemoveLabel,None,itkLabelMap2)
itkLabelMap2.ClearLabels = new_instancemethod(_itkLabelMapPython.itkLabelMap2_ClearLabels,None,itkLabelMap2)
itkLabelMap2.GetLabelObjectContainer = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetLabelObjectContainer,None,itkLabelMap2)
itkLabelMap2.GetNumberOfLabelObjects = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetNumberOfLabelObjects,None,itkLabelMap2)
itkLabelMap2.GetLabels = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetLabels,None,itkLabelMap2)
itkLabelMap2.GetLabelObjects = new_instancemethod(_itkLabelMapPython.itkLabelMap2_GetLabelObjects,None,itkLabelMap2)
raise RuntimeException("Class is expecting a pickled object with version number %d, but we found %d" % (cls.pickle_format_version(), version))
inst = cls.__new__(cls)
inst.__init__()
inst.set(*args)
return inst
import full_physics_swig.state_vector
import full_physics_swig.generic_object
class ObservablePressure(full_physics_swig.generic_object.GenericObject):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _pressure.delete_ObservablePressure
ObservablePressure.add_observer_and_keep_reference = new_instancemethod(_pressure.ObservablePressure_add_observer_and_keep_reference, None, ObservablePressure)
ObservablePressure.add_observer = new_instancemethod(_pressure.ObservablePressure_add_observer, None, ObservablePressure)
ObservablePressure.remove_observer = new_instancemethod(_pressure.ObservablePressure_remove_observer, None, ObservablePressure)
ObservablePressure_swigregister = _pressure.ObservablePressure_swigregister
ObservablePressure_swigregister(ObservablePressure)
class ObserverPressure(full_physics_swig.generic_object.GenericObject):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
_pressure.ObserverPressure_swiginit(self, _pressure.new_ObserverPressure())
__swig_destroy__ = _pressure.delete_ObserverPressure
ObserverPressure.notify_update = new_instancemethod(_pressure.ObserverPressure_notify_update, None, ObserverPressure)
ObserverPressure.notify_add = new_instancemethod(_pressure.ObserverPressure_notify_add, None, ObserverPressure)
ObserverPressure.notify_remove = new_instancemethod(_pressure.ObserverPressure_notify_remove, None, ObserverPressure)
See the discussion in RegisterOutputBase why this isn't just part of
the ConnnorSolver class.
C++ includes: max_a_posteriori_output.h
"""
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _max_a_posteriori_output.delete_MaxAPosterioriOutput
def register_output(self, out):
"""
void MaxAPosterioriOutput::register_output(const boost::shared_ptr< Output > &out) const
"""
return _max_a_posteriori_output.MaxAPosterioriOutput_register_output(
self, out)
MaxAPosterioriOutput.register_output = new_instancemethod(
_max_a_posteriori_output.MaxAPosterioriOutput_register_output, None,
MaxAPosterioriOutput)
MaxAPosterioriOutput_swigregister = _max_a_posteriori_output.MaxAPosterioriOutput_swigregister
MaxAPosterioriOutput_swigregister(MaxAPosterioriOutput)
"""
void StokesCoefficientFractionOutput::register_output(const boost::shared_ptr< Output > &out) const
"""
return _stokes_coefficient_fraction_output.StokesCoefficientFractionOutput_register_output(
self, out)
def register_output_apriori(self, out):
"""
void StokesCoefficientFractionOutput::register_output_apriori(const boost::shared_ptr< Output > &out) const
"""
return _stokes_coefficient_fraction_output.StokesCoefficientFractionOutput_register_output_apriori(
self, out)
__swig_destroy__ = _stokes_coefficient_fraction_output.delete_StokesCoefficientFractionOutput
StokesCoefficientFractionOutput.register_output = new_instancemethod(
_stokes_coefficient_fraction_output.
StokesCoefficientFractionOutput_register_output, None,
StokesCoefficientFractionOutput)
StokesCoefficientFractionOutput.register_output_apriori = new_instancemethod(
_stokes_coefficient_fraction_output.
StokesCoefficientFractionOutput_register_output_apriori, None,
StokesCoefficientFractionOutput)
StokesCoefficientFractionOutput_swigregister = _stokes_coefficient_fraction_output.StokesCoefficientFractionOutput_swigregister
StokesCoefficientFractionOutput_swigregister(StokesCoefficientFractionOutput)
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _ShapeConstruct.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_ShapeConstruct.SwigPyIterator_value,
None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_ShapeConstruct.SwigPyIterator_incr,
None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_ShapeConstruct.SwigPyIterator_decr,
None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(
_ShapeConstruct.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_ShapeConstruct.SwigPyIterator_equal,
None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_ShapeConstruct.SwigPyIterator_copy,
None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_ShapeConstruct.SwigPyIterator_next,
None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(
_ShapeConstruct.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(
if self.__class__ == LuaCallback:
_self = None
else:
_self = self
_luabind_object.LuaCallback_swiginit(
self, _luabind_object.new_LuaCallback(_self, Ls))
__swig_destroy__ = _luabind_object.delete_LuaCallback
def __disown__(self):
self.this.disown()
_luabind_object.disown_LuaCallback(self)
return weakref_proxy(self)
LuaCallback.call = new_instancemethod(_luabind_object.LuaCallback_call, None,
LuaCallback)
LuaCallback.__str__ = new_instancemethod(_luabind_object.LuaCallback___str__,
None, LuaCallback)
LuaCallback_swigregister = _luabind_object.LuaCallback_swigregister
LuaCallback_swigregister(LuaCallback)
class LuaCallbackWrap(LuaCallback):
def __init__(self, ls, f):
LuaCallback.__init__(self, ls)
self.ls = ls
self.f = f
t = inspect.getargspec(f)[0]
self.narg = len(t)
if (self.narg > 0 and t[0] == 'self'):
self.narg = self.narg - 1
def parameters(self):
return self._v_parameters()
@parameters.setter
def parameters(self, value):
self._v_parameters(value)
def _v_max_a_posteriori(self):
"""
boost::shared_ptr<MaxAPosteriori> FullPhysics::NLLSMaxAPosteriori::max_a_posteriori()
"""
return _nlls_max_a_posteriori.NLLSMaxAPosteriori__v_max_a_posteriori(self)
@property
def max_a_posteriori(self):
return self._v_max_a_posteriori()
NLLSMaxAPosteriori._v_residual = new_instancemethod(_nlls_max_a_posteriori.NLLSMaxAPosteriori__v_residual, None, NLLSMaxAPosteriori)
NLLSMaxAPosteriori._v_jacobian = new_instancemethod(_nlls_max_a_posteriori.NLLSMaxAPosteriori__v_jacobian, None, NLLSMaxAPosteriori)
NLLSMaxAPosteriori._v_parameters = new_instancemethod(_nlls_max_a_posteriori.NLLSMaxAPosteriori__v_parameters, None, NLLSMaxAPosteriori)
NLLSMaxAPosteriori._v_max_a_posteriori = new_instancemethod(_nlls_max_a_posteriori.NLLSMaxAPosteriori__v_max_a_posteriori, None, NLLSMaxAPosteriori)
NLLSMaxAPosteriori_swigregister = _nlls_max_a_posteriori.NLLSMaxAPosteriori_swigregister
NLLSMaxAPosteriori_swigregister(NLLSMaxAPosteriori)
itkMeshFileWriterMD2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkMeshFileWriterMD2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkMeshFileWriterMD2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkMeshFileWriterMD2.Clone = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_Clone, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetInput = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetInput, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.GetInput = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_GetInput, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetFileName = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetFileName, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.GetFileName = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_GetFileName, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetMeshIO = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetMeshIO, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.GetModifiableMeshIO = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_GetModifiableMeshIO, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.GetMeshIO = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_GetMeshIO, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetFileTypeAsASCII = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetFileTypeAsASCII, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetFileTypeAsBINARY = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetFileTypeAsBINARY, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.Write = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_Write, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.SetUseCompression = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_SetUseCompression, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.GetUseCompression = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_GetUseCompression, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.UseCompressionOn = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_UseCompressionOn, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2.UseCompressionOff = new_instancemethod(_itkMeshFileWriterPython.itkMeshFileWriterMD2_UseCompressionOff, None, itkMeshFileWriterMD2)
itkMeshFileWriterMD2_swigregister = _itkMeshFileWriterPython.itkMeshFileWriterMD2_swigregister
is (most of the time) equivalent to:
obj = itkLabelMapFilterLM2IF2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkLabelMapFilterLM2IF2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkLabelMapFilterLM2IF2.Clone = new_instancemethod(
_itkLabelMapFilterPython.itkLabelMapFilterLM2IF2_Clone, None,
itkLabelMapFilterLM2IF2)
itkLabelMapFilterLM2IF2.GenerateInputRequestedRegion = new_instancemethod(
_itkLabelMapFilterPython.
itkLabelMapFilterLM2IF2_GenerateInputRequestedRegion, None,
itkLabelMapFilterLM2IF2)
itkLabelMapFilterLM2IF2_swigregister = _itkLabelMapFilterPython.itkLabelMapFilterLM2IF2_swigregister
itkLabelMapFilterLM2IF2_swigregister(itkLabelMapFilterLM2IF2)
def itkLabelMapFilterLM2IF2___New_orig__(
) -> "itkLabelMapFilterLM2IF2_Pointer":
"""itkLabelMapFilterLM2IF2___New_orig__() -> itkLabelMapFilterLM2IF2_Pointer"""
return _itkLabelMapFilterPython.itkLabelMapFilterLM2IF2___New_orig__()
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
@property
def number_stokes(self):
return self._v_number_stokes()
def _v_surface_type(self):
"""
virtual int FullPhysics::SpurrRt::surface_type() const
Integer representing the surface type using the LIDORT indexing
nomenclature.
"""
return _spurr_rt.SpurrRt__v_surface_type(self)
@property
def surface_type(self):
return self._v_surface_type()
__swig_destroy__ = _spurr_rt.delete_SpurrRt
SpurrRt._v_surface_type = new_instancemethod(_spurr_rt.SpurrRt__v_surface_type, None, SpurrRt)
SpurrRt_swigregister = _spurr_rt.SpurrRt_swigregister
SpurrRt_swigregister(SpurrRt)
itkNearestNeighborInterpolateImageFunctionID2D.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkNearestNeighborInterpolateImageFunctionID2D.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkNearestNeighborInterpolateImageFunctionID2D.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkNearestNeighborInterpolateImageFunctionID2D.GetPointer = new_instancemethod(_itkNearestNeighborInterpolateImageFunctionPython.itkNearestNeighborInterpolateImageFunctionID2D_GetPointer,None,itkNearestNeighborInterpolateImageFunctionID2D)
itkNearestNeighborInterpolateImageFunctionID2D_swigregister = _itkNearestNeighborInterpolateImageFunctionPython.itkNearestNeighborInterpolateImageFunctionID2D_swigregister
itkNearestNeighborInterpolateImageFunctionID2D_swigregister(itkNearestNeighborInterpolateImageFunctionID2D)
def itkNearestNeighborInterpolateImageFunctionID2D___New_orig__():
"""itkNearestNeighborInterpolateImageFunctionID2D___New_orig__()"""
return _itkNearestNeighborInterpolateImageFunctionPython.itkNearestNeighborInterpolateImageFunctionID2D___New_orig__()
def itkNearestNeighborInterpolateImageFunctionID2D_cast(*args):
"""itkNearestNeighborInterpolateImageFunctionID2D_cast(itkLightObject obj) -> itkNearestNeighborInterpolateImageFunctionID2D"""
return _itkNearestNeighborInterpolateImageFunctionPython.itkNearestNeighborInterpolateImageFunctionID2D_cast(*args)
class itkNearestNeighborInterpolateImageFunctionID3D(itkInterpolateImageFunctionPython.itkInterpolateImageFunctionID3D):
"""Proxy of C++ itkNearestNeighborInterpolateImageFunctionID3D class"""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
is (most of the time) equivalent to:
obj = itkBYUMeshIO.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkBYUMeshIO.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkBYUMeshIO.Clone = new_instancemethod(_itkBYUMeshIOPython.itkBYUMeshIO_Clone,
None, itkBYUMeshIO)
itkBYUMeshIO_swigregister = _itkBYUMeshIOPython.itkBYUMeshIO_swigregister
itkBYUMeshIO_swigregister(itkBYUMeshIO)
def itkBYUMeshIO___New_orig__() -> "itkBYUMeshIO_Pointer":
"""itkBYUMeshIO___New_orig__() -> itkBYUMeshIO_Pointer"""
return _itkBYUMeshIOPython.itkBYUMeshIO___New_orig__()
def itkBYUMeshIO_cast(obj: 'itkLightObject') -> "itkBYUMeshIO *":
"""itkBYUMeshIO_cast(itkLightObject obj) -> itkBYUMeshIO"""
return _itkBYUMeshIOPython.itkBYUMeshIO_cast(obj)
class itkBYUMeshIOFactory(ITKCommonBasePython.itkObjectFactoryBase):
@property
def volume_mixing_ratio_level(self):
return self._v_volume_mixing_ratio_level()
def _v_volume_mixing_ratio_active_level(self):
"""
blitz::Array<double, 1> FullPhysics::AbsorberVmrFixedLevel::volume_mixing_ratio_active_level() const
Volume mixing ratio on the fixed pressure levels, restricted to the
active levels.
"""
return _absorber_vmr_fixed_level.AbsorberVmrFixedLevel__v_volume_mixing_ratio_active_level(self)
@property
def volume_mixing_ratio_active_level(self):
return self._v_volume_mixing_ratio_active_level()
__swig_destroy__ = _absorber_vmr_fixed_level.delete_AbsorberVmrFixedLevel
AbsorberVmrFixedLevel.clone = new_instancemethod(_absorber_vmr_fixed_level.AbsorberVmrFixedLevel_clone, None, AbsorberVmrFixedLevel)
AbsorberVmrFixedLevel._v_volume_mixing_ratio_level = new_instancemethod(_absorber_vmr_fixed_level.AbsorberVmrFixedLevel__v_volume_mixing_ratio_level, None, AbsorberVmrFixedLevel)
AbsorberVmrFixedLevel._v_volume_mixing_ratio_active_level = new_instancemethod(_absorber_vmr_fixed_level.AbsorberVmrFixedLevel__v_volume_mixing_ratio_active_level, None, AbsorberVmrFixedLevel)
AbsorberVmrFixedLevel_swigregister = _absorber_vmr_fixed_level.AbsorberVmrFixedLevel_swigregister
AbsorberVmrFixedLevel_swigregister(AbsorberVmrFixedLevel)
"""
return _lsi_rt.LsiRt__v_low_stream_radiative_transfer(self)
@property
def low_stream_radiative_transfer(self):
return self._v_low_stream_radiative_transfer()
def _v_high_stream_radiative_transfer(self):
"""
boost::shared_ptr<RadiativeTransfer> FullPhysics::LsiRt::high_stream_radiative_transfer() const
"""
return _lsi_rt.LsiRt__v_high_stream_radiative_transfer(self)
@property
def high_stream_radiative_transfer(self):
return self._v_high_stream_radiative_transfer()
__swig_destroy__ = _lsi_rt.delete_LsiRt
LsiRt.correction_only = new_instancemethod(_lsi_rt.LsiRt_correction_only, None,
LsiRt)
LsiRt._v_low_stream_radiative_transfer = new_instancemethod(
_lsi_rt.LsiRt__v_low_stream_radiative_transfer, None, LsiRt)
LsiRt._v_high_stream_radiative_transfer = new_instancemethod(
_lsi_rt.LsiRt__v_high_stream_radiative_transfer, None, LsiRt)
LsiRt_swigregister = _lsi_rt.LsiRt_swigregister
LsiRt_swigregister(LsiRt)
import weakref
weakref_proxy = weakref.proxy
except:
weakref_proxy = lambda x: x
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _solar_model.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_solar_model.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_solar_model.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_solar_model.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_solar_model.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_solar_model.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_solar_model.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_solar_model.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_solar_model.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_solar_model.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_solar_model.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_solar_model.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_solar_model.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_solar_model.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_solar_model.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_solar_model.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_solar_model.SwigPyIterator___sub__, None, SwigPyIterator)
@property
def fluorescence_slope(self):
return self._v_fluorescence_slope()
def _v_fluorescence_slope_uncertainty(self):
"""
double FullPhysics::FluorescenceEffect::fluorescence_slope_uncertainty() const
Assumed uncertainty of fluorescence slope.
"""
return _fluorescence_effect.FluorescenceEffect__v_fluorescence_slope_uncertainty(self)
@property
def fluorescence_slope_uncertainty(self):
return self._v_fluorescence_slope_uncertainty()
__swig_destroy__ = _fluorescence_effect.delete_FluorescenceEffect
FluorescenceEffect._v_fluorescence_at_reference = new_instancemethod(_fluorescence_effect.FluorescenceEffect__v_fluorescence_at_reference, None, FluorescenceEffect)
FluorescenceEffect._v_fluorescence_at_reference_uncertainty = new_instancemethod(_fluorescence_effect.FluorescenceEffect__v_fluorescence_at_reference_uncertainty, None, FluorescenceEffect)
FluorescenceEffect._v_fluorescence_slope = new_instancemethod(_fluorescence_effect.FluorescenceEffect__v_fluorescence_slope, None, FluorescenceEffect)
FluorescenceEffect._v_fluorescence_slope_uncertainty = new_instancemethod(_fluorescence_effect.FluorescenceEffect__v_fluorescence_slope_uncertainty, None, FluorescenceEffect)
FluorescenceEffect_swigregister = _fluorescence_effect.FluorescenceEffect_swigregister
FluorescenceEffect_swigregister(FluorescenceEffect)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _BRepClass.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_BRepClass.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_BRepClass.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_BRepClass.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_BRepClass.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_BRepClass.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_BRepClass.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_BRepClass.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_BRepClass.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_BRepClass.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_BRepClass.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_BRepClass.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_BRepClass.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_BRepClass.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_BRepClass.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_BRepClass.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_BRepClass.SwigPyIterator___sub__,None,SwigPyIterator)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _AppParCurves.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_AppParCurves.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_AppParCurves.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_AppParCurves.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_AppParCurves.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_AppParCurves.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_AppParCurves.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_AppParCurves.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_AppParCurves.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_AppParCurves.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_AppParCurves.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_AppParCurves.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_AppParCurves.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_AppParCurves.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_AppParCurves.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_AppParCurves.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_AppParCurves.SwigPyIterator___sub__,None,SwigPyIterator)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _IntImp.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_IntImp.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_IntImp.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_IntImp.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_IntImp.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_IntImp.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_IntImp.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_IntImp.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_IntImp.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_IntImp.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_IntImp.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_IntImp.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_IntImp.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_IntImp.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_IntImp.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_IntImp.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_IntImp.SwigPyIterator___sub__,None,SwigPyIterator)
is (most of the time) equivalent to:
obj = itkVelocityFieldTransformD2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkVelocityFieldTransformD2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkVelocityFieldTransformD2.Clone = new_instancemethod(
_itkVelocityFieldTransformPython.itkVelocityFieldTransformD2_Clone, None,
itkVelocityFieldTransformD2)
itkVelocityFieldTransformD2.SetVelocityField = new_instancemethod(
_itkVelocityFieldTransformPython.
itkVelocityFieldTransformD2_SetVelocityField, None,
itkVelocityFieldTransformD2)
itkVelocityFieldTransformD2.GetModifiableVelocityField = new_instancemethod(
_itkVelocityFieldTransformPython.
itkVelocityFieldTransformD2_GetModifiableVelocityField, None,
itkVelocityFieldTransformD2)
itkVelocityFieldTransformD2.GetVelocityField = new_instancemethod(
_itkVelocityFieldTransformPython.
itkVelocityFieldTransformD2_GetVelocityField, None,
itkVelocityFieldTransformD2)
itkVelocityFieldTransformD2.SetVelocityFieldInterpolator = new_instancemethod(
_itkVelocityFieldTransformPython.
ArrayAd< double, 1 > TemperatureFixedLevel::temperature_levels() const
Return the temperature on the fixed levels (which may include values
from below the surface).
This is in Kelvin.
"""
return _temperature_fixed_level.TemperatureFixedLevel__v_temperature_levels(self)
@property
def temperature_levels(self):
return self._v_temperature_levels()
def clone(self, *args):
"""
boost::shared_ptr< Temperature > TemperatureFixedLevel::clone(const boost::shared_ptr< Pressure > &Press) const
"""
return _temperature_fixed_level.TemperatureFixedLevel_clone(self, *args)
__swig_destroy__ = _temperature_fixed_level.delete_TemperatureFixedLevel
TemperatureFixedLevel._v_temperature_levels = new_instancemethod(_temperature_fixed_level.TemperatureFixedLevel__v_temperature_levels, None, TemperatureFixedLevel)
TemperatureFixedLevel.clone = new_instancemethod(_temperature_fixed_level.TemperatureFixedLevel_clone, None, TemperatureFixedLevel)
TemperatureFixedLevel_swigregister = _temperature_fixed_level.TemperatureFixedLevel_swigregister
TemperatureFixedLevel_swigregister(TemperatureFixedLevel)
itkMinimumImageFilterIF2IF2IF2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkMinimumImageFilterIF2IF2IF2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkMinimumImageFilterIF2IF2IF2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkMinimumImageFilterIF2IF2IF2.Clone = new_instancemethod(_itkMinimumImageFilterPython.itkMinimumImageFilterIF2IF2IF2_Clone, None, itkMinimumImageFilterIF2IF2IF2)
itkMinimumImageFilterIF2IF2IF2_swigregister = _itkMinimumImageFilterPython.itkMinimumImageFilterIF2IF2IF2_swigregister
itkMinimumImageFilterIF2IF2IF2_swigregister(itkMinimumImageFilterIF2IF2IF2)
def itkMinimumImageFilterIF2IF2IF2___New_orig__() -> "itkMinimumImageFilterIF2IF2IF2_Pointer":
"""itkMinimumImageFilterIF2IF2IF2___New_orig__() -> itkMinimumImageFilterIF2IF2IF2_Pointer"""
return _itkMinimumImageFilterPython.itkMinimumImageFilterIF2IF2IF2___New_orig__()
def itkMinimumImageFilterIF2IF2IF2_cast(obj: 'itkLightObject') -> "itkMinimumImageFilterIF2IF2IF2 *":
"""itkMinimumImageFilterIF2IF2IF2_cast(itkLightObject obj) -> itkMinimumImageFilterIF2IF2IF2"""
return _itkMinimumImageFilterPython.itkMinimumImageFilterIF2IF2IF2_cast(obj)
class itkMinimumImageFilterIF3IF3IF3(itkBinaryGeneratorImageFilterPython.itkBinaryGeneratorImageFilterIF3IF3IF3):
"""Proxy of C++ itkMinimumImageFilterIF3IF3IF3 class."""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def _v_acquisition_mode(self):
"""
const std::string& FullPhysics::Level1bOco::acquisition_mode() const
The acquisition mode.
The data we process will be "Nadir", "Glint" or "Target".
"""
return _level_1b_oco.Level1bOco__v_acquisition_mode(self)
@property
def acquisition_mode(self):
return self._v_acquisition_mode()
__swig_destroy__ = _level_1b_oco.delete_Level1bOco
Level1bOco.has_spike_eof = new_instancemethod(_level_1b_oco.Level1bOco_has_spike_eof, None, Level1bOco)
Level1bOco.spike_eof = new_instancemethod(_level_1b_oco.Level1bOco_spike_eof, None, Level1bOco)
Level1bOco._v_has_solar_relative_velocity = new_instancemethod(_level_1b_oco.Level1bOco__v_has_solar_relative_velocity, None, Level1bOco)
Level1bOco._v_land_fraction = new_instancemethod(_level_1b_oco.Level1bOco__v_land_fraction, None, Level1bOco)
Level1bOco._v_solar_distance = new_instancemethod(_level_1b_oco.Level1bOco__v_solar_distance, None, Level1bOco)
Level1bOco._v_solar_velocity = new_instancemethod(_level_1b_oco.Level1bOco__v_solar_velocity, None, Level1bOco)
Level1bOco._v_acquisition_mode = new_instancemethod(_level_1b_oco.Level1bOco__v_acquisition_mode, None, Level1bOco)
Level1bOco_swigregister = _level_1b_oco.Level1bOco_swigregister
Level1bOco_swigregister(Level1bOco)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _TopBas.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_TopBas.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_TopBas.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_TopBas.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_TopBas.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_TopBas.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_TopBas.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_TopBas.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_TopBas.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_TopBas.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_TopBas.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_TopBas.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_TopBas.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_TopBas.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_TopBas.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_TopBas.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_TopBas.SwigPyIterator___sub__,None,SwigPyIterator)
itkRigid3DPerspectiveTransformD.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkRigid3DPerspectiveTransformD.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkRigid3DPerspectiveTransformD.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkRigid3DPerspectiveTransformD.GetOffset = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetOffset,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetRotation = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetRotation,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.SetOffset = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_SetOffset,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.SetRotation = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_SetRotation,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.SetFocalDistance = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_SetFocalDistance,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetFocalDistance = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetFocalDistance,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetRotationMatrix = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetRotationMatrix,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.ComputeMatrix = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_ComputeMatrix,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetFixedOffset = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetFixedOffset,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.SetFixedOffset = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_SetFixedOffset,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.SetCenterOfRotation = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_SetCenterOfRotation,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetCenterOfRotation = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetCenterOfRotation,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD.GetPointer = new_instancemethod(_ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_GetPointer,None,itkRigid3DPerspectiveTransformD)
itkRigid3DPerspectiveTransformD_swigregister = _ITKRigidPerspectiveTransformPython.itkRigid3DPerspectiveTransformD_swigregister
itkRigid3DPerspectiveTransformD_swigregister(itkRigid3DPerspectiveTransformD)
This is an ILS function that is a Gaussian.
C++ includes: ils_gaussian.h
"""
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
def ils(self, wn_center, wn, OUTPUT):
"""
void IlsGaussian::ils(const AutoDerivative< double > &wn_center, const blitz::Array<
double, 1 > &wn, ArrayAd< double, 1 > &res) const
"""
return _ils_gaussian.IlsGaussian_ils(self, wn_center, wn, OUTPUT)
__swig_destroy__ = _ils_gaussian.delete_IlsGaussian
IlsGaussian.ils = new_instancemethod(_ils_gaussian.IlsGaussian_ils, None,
IlsGaussian)
IlsGaussian_swigregister = _ils_gaussian.IlsGaussian_swigregister
IlsGaussian_swigregister(IlsGaussian)
@property
def lua_state(self):
return self._v_lua_state()
def _v_output_name(self, *args):
"""
void FullPhysics::L2FpConfigurationLua::output_name(const std::string &F)
"""
return _l2_fp_configuration_lua.L2FpConfigurationLua__v_output_name(self, *args)
@property
def output_name(self):
return self._v_output_name()
@output_name.setter
def output_name(self, value):
self._v_output_name(value)
__swig_destroy__ = _l2_fp_configuration_lua.delete_L2FpConfigurationLua
L2FpConfigurationLua._v_lua_state = new_instancemethod(_l2_fp_configuration_lua.L2FpConfigurationLua__v_lua_state, None, L2FpConfigurationLua)
L2FpConfigurationLua._v_output_name = new_instancemethod(_l2_fp_configuration_lua.L2FpConfigurationLua__v_output_name, None, L2FpConfigurationLua)
L2FpConfigurationLua_swigregister = _l2_fp_configuration_lua.L2FpConfigurationLua_swigregister
L2FpConfigurationLua_swigregister(L2FpConfigurationLua)
is (most of the time) equivalent to:
obj = itkAzimuthElevationToCartesianTransformD2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkAzimuthElevationToCartesianTransformD2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkAzimuthElevationToCartesianTransformD2.Clone = new_instancemethod(
_itkAzimuthElevationToCartesianTransformPython.
itkAzimuthElevationToCartesianTransformD2_Clone, None,
itkAzimuthElevationToCartesianTransformD2)
itkAzimuthElevationToCartesianTransformD2.SetAzimuthElevationToCartesianParameters = new_instancemethod(
_itkAzimuthElevationToCartesianTransformPython.
itkAzimuthElevationToCartesianTransformD2_SetAzimuthElevationToCartesianParameters,
None, itkAzimuthElevationToCartesianTransformD2)
itkAzimuthElevationToCartesianTransformD2.BackTransform = new_instancemethod(
_itkAzimuthElevationToCartesianTransformPython.
itkAzimuthElevationToCartesianTransformD2_BackTransform, None,
itkAzimuthElevationToCartesianTransformD2)
itkAzimuthElevationToCartesianTransformD2.BackTransformPoint = new_instancemethod(
_itkAzimuthElevationToCartesianTransformPython.
itkAzimuthElevationToCartesianTransformD2_BackTransformPoint, None,
itkAzimuthElevationToCartesianTransformD2)
itkAzimuthElevationToCartesianTransformD2.SetForwardAzimuthElevationToCartesian = new_instancemethod(
_itkAzimuthElevationToCartesianTransformPython.
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _GccInt.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_GccInt.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_GccInt.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_GccInt.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_GccInt.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_GccInt.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_GccInt.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_GccInt.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_GccInt.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_GccInt.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_GccInt.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_GccInt.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_GccInt.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_GccInt.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_GccInt.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_GccInt.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_GccInt.SwigPyIterator___sub__,None,SwigPyIterator)
is (most of the time) equivalent to:
obj = itkPointBasedSpatialObject2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkPointBasedSpatialObject2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkPointBasedSpatialObject2.Clone = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_Clone, None,
itkPointBasedSpatialObject2)
itkPointBasedSpatialObject2.AddPoint = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_AddPoint,
None, itkPointBasedSpatialObject2)
itkPointBasedSpatialObject2.RemovePoint = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_RemovePoint,
None, itkPointBasedSpatialObject2)
itkPointBasedSpatialObject2.SetPoints = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_SetPoints,
None, itkPointBasedSpatialObject2)
itkPointBasedSpatialObject2.GetPoints = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_GetPoints,
None, itkPointBasedSpatialObject2)
itkPointBasedSpatialObject2.GetPoint = new_instancemethod(
_itkPointBasedSpatialObjectPython.itkPointBasedSpatialObject2_GetPoint,
import weakref
weakref_proxy = weakref.proxy
except:
weakref_proxy = lambda x: x
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _gas_absorption.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_gas_absorption.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_gas_absorption.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_gas_absorption.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_gas_absorption.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_gas_absorption.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_gas_absorption.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_gas_absorption.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_gas_absorption.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_gas_absorption.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_gas_absorption.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_gas_absorption.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_gas_absorption.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_gas_absorption.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_gas_absorption.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_gas_absorption.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_gas_absorption.SwigPyIterator___sub__, None, SwigPyIterator)
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _Adaptor2d.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_Adaptor2d.SwigPyIterator_value,
None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_Adaptor2d.SwigPyIterator_incr, None,
SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_Adaptor2d.SwigPyIterator_decr, None,
SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(
_Adaptor2d.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_Adaptor2d.SwigPyIterator_equal,
None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_Adaptor2d.SwigPyIterator_copy, None,
SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_Adaptor2d.SwigPyIterator_next, None,
SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(
_Adaptor2d.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(
up.
Max_chisq: The maximum chisq
"""
_connor_convergence.ConnorConvergence_swiginit(self, _connor_convergence.new_ConnorConvergence(Fm, Threshold, Max_iteration, Max_divergence, Max_chisq))
def _v_maximum_number_iteration(self, *args):
"""
void FullPhysics::ConnorConvergence::maximum_number_iteration(int Max_iter)
"""
return _connor_convergence.ConnorConvergence__v_maximum_number_iteration(self, *args)
@property
def maximum_number_iteration(self):
return self._v_maximum_number_iteration()
@maximum_number_iteration.setter
def maximum_number_iteration(self, value):
self._v_maximum_number_iteration(value)
__swig_destroy__ = _connor_convergence.delete_ConnorConvergence
ConnorConvergence._v_maximum_number_iteration = new_instancemethod(_connor_convergence.ConnorConvergence__v_maximum_number_iteration, None, ConnorConvergence)
ConnorConvergence_swigregister = _connor_convergence.ConnorConvergence_swigregister
ConnorConvergence_swigregister(ConnorConvergence)
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _RWStl.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_RWStl.SwigPyIterator_value, None,
SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_RWStl.SwigPyIterator_incr, None,
SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_RWStl.SwigPyIterator_decr, None,
SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_RWStl.SwigPyIterator_distance,
None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_RWStl.SwigPyIterator_equal, None,
SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_RWStl.SwigPyIterator_copy, None,
SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_RWStl.SwigPyIterator_next, None,
SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_RWStl.SwigPyIterator___next__,
None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_RWStl.SwigPyIterator_previous,
"""Proxy of C++ vnl_unary_functionD_vnl_vectorD class"""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
def f(self, *args):
"""f(self, vnl_vectorD i) -> double"""
return _vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_f(self, *args)
def get_range_min(self):
"""get_range_min(self) -> double"""
return _vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_get_range_min(self)
def get_range_max(self):
"""get_range_max(self) -> double"""
return _vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_get_range_max(self)
def Copy(self):
"""Copy(self) -> vnl_unary_functionD_vnl_vectorD"""
return _vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_Copy(self)
__swig_destroy__ = _vnl_unary_functionPython.delete_vnl_unary_functionD_vnl_vectorD
vnl_unary_functionD_vnl_vectorD.f = new_instancemethod(_vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_f,None,vnl_unary_functionD_vnl_vectorD)
vnl_unary_functionD_vnl_vectorD.get_range_min = new_instancemethod(_vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_get_range_min,None,vnl_unary_functionD_vnl_vectorD)
vnl_unary_functionD_vnl_vectorD.get_range_max = new_instancemethod(_vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_get_range_max,None,vnl_unary_functionD_vnl_vectorD)
vnl_unary_functionD_vnl_vectorD.Copy = new_instancemethod(_vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_Copy,None,vnl_unary_functionD_vnl_vectorD)
vnl_unary_functionD_vnl_vectorD_swigregister = _vnl_unary_functionPython.vnl_unary_functionD_vnl_vectorD_swigregister
vnl_unary_functionD_vnl_vectorD_swigregister(vnl_unary_functionD_vnl_vectorD)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _BRepIntCurveSurface.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_BRepIntCurveSurface.SwigPyIterator___sub__,None,SwigPyIterator)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _IntCurve.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_IntCurve.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_IntCurve.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_IntCurve.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_IntCurve.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_IntCurve.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_IntCurve.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_IntCurve.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_IntCurve.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_IntCurve.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_IntCurve.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_IntCurve.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_IntCurve.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_IntCurve.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_IntCurve.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_IntCurve.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_IntCurve.SwigPyIterator___sub__,None,SwigPyIterator)
Surface jacobian.
"""
return _l_rad_driver.LRadDriver_surface_jacobian(self)
def print_desc(self, Os, Short_form=False):
"""
void LRadDriver::print(std::ostream &Os, bool Short_form=false) const
"""
return _l_rad_driver.LRadDriver_print_desc(self, Os, Short_form)
__swig_destroy__ = _l_rad_driver.delete_LRadDriver
LRadDriver._v_number_stokes = new_instancemethod(
_l_rad_driver.LRadDriver__v_number_stokes, None, LRadDriver)
LRadDriver._v_number_stream = new_instancemethod(
_l_rad_driver.LRadDriver__v_number_stream, None, LRadDriver)
LRadDriver.z_matrix = new_instancemethod(_l_rad_driver.LRadDriver_z_matrix,
None, LRadDriver)
LRadDriver.setup_geometry = new_instancemethod(
_l_rad_driver.LRadDriver_setup_geometry, None, LRadDriver)
LRadDriver.setup_surface_params = new_instancemethod(
_l_rad_driver.LRadDriver_setup_surface_params, None, LRadDriver)
LRadDriver.setup_optical_inputs = new_instancemethod(
_l_rad_driver.LRadDriver_setup_optical_inputs, None, LRadDriver)
LRadDriver.clear_linear_inputs = new_instancemethod(
_l_rad_driver.LRadDriver_clear_linear_inputs, None, LRadDriver)
LRadDriver.setup_linear_inputs = new_instancemethod(
_l_rad_driver.LRadDriver_setup_linear_inputs, None, LRadDriver)
LRadDriver.calculate_first_order = new_instancemethod(
import weakref
weakref_proxy = weakref.proxy
except:
weakref_proxy = lambda x: x
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _auto_derivative.delete_SwigPyIterator
def __iter__(self):
return self
SwigPyIterator.value = new_instancemethod(_auto_derivative.SwigPyIterator_value, None, SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_auto_derivative.SwigPyIterator_incr, None, SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_auto_derivative.SwigPyIterator_decr, None, SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_auto_derivative.SwigPyIterator_distance, None, SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_auto_derivative.SwigPyIterator_equal, None, SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_auto_derivative.SwigPyIterator_copy, None, SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_auto_derivative.SwigPyIterator_next, None, SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_auto_derivative.SwigPyIterator___next__, None, SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_auto_derivative.SwigPyIterator_previous, None, SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_auto_derivative.SwigPyIterator_advance, None, SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_auto_derivative.SwigPyIterator___eq__, None, SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_auto_derivative.SwigPyIterator___ne__, None, SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_auto_derivative.SwigPyIterator___iadd__, None, SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_auto_derivative.SwigPyIterator___isub__, None, SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_auto_derivative.SwigPyIterator___add__, None, SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_auto_derivative.SwigPyIterator___sub__, None, SwigPyIterator)
This implementation just gets the log of the extinction coefficient
for each level from the state vector.
C++ includes: aerosol_extinction_log.h
"""
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
def clone(self, *args):
"""
boost::shared_ptr< AerosolExtinction > AerosolExtinctionLog::clone(const boost::shared_ptr< Pressure > &P) const
"""
return _aerosol_extinction_log.AerosolExtinctionLog_clone(self, *args)
__swig_destroy__ = _aerosol_extinction_log.delete_AerosolExtinctionLog
AerosolExtinctionLog.clone = new_instancemethod(
_aerosol_extinction_log.AerosolExtinctionLog_clone, None,
AerosolExtinctionLog)
AerosolExtinctionLog_swigregister = _aerosol_extinction_log.AerosolExtinctionLog_swigregister
AerosolExtinctionLog_swigregister(AerosolExtinctionLog)
loadProgress = _swig_property(_webview.eWebView_loadProgress_get, _webview.eWebView_loadProgress_set)
loadStarted = _swig_property(_webview.eWebView_loadStarted_get, _webview.eWebView_loadStarted_set)
menuBarVisibilityChangeRequested = _swig_property(_webview.eWebView_menuBarVisibilityChangeRequested_get, _webview.eWebView_menuBarVisibilityChangeRequested_set)
microFocusChanged = _swig_property(_webview.eWebView_microFocusChanged_get, _webview.eWebView_microFocusChanged_set)
selectionChanged = _swig_property(_webview.eWebView_selectionChanged_get, _webview.eWebView_selectionChanged_set)
statusBarMessage = _swig_property(_webview.eWebView_statusBarMessage_get, _webview.eWebView_statusBarMessage_set)
statusBarVisibilityChangeRequested = _swig_property(_webview.eWebView_statusBarVisibilityChangeRequested_get, _webview.eWebView_statusBarVisibilityChangeRequested_set)
toolBarVisibilityChangeRequested = _swig_property(_webview.eWebView_toolBarVisibilityChangeRequested_get, _webview.eWebView_toolBarVisibilityChangeRequested_set)
unsupportedContent = _swig_property(_webview.eWebView_unsupportedContent_get, _webview.eWebView_unsupportedContent_set)
windowCloseRequested = _swig_property(_webview.eWebView_windowCloseRequested_get, _webview.eWebView_windowCloseRequested_set)
javaScriptAlert = _swig_property(_webview.eWebView_javaScriptAlert_get, _webview.eWebView_javaScriptAlert_set)
windowRequested = _swig_property(_webview.eWebView_windowRequested_get, _webview.eWebView_windowRequested_set)
authenticationRequired = _swig_property(_webview.eWebView_authenticationRequired_get, _webview.eWebView_authenticationRequired_set)
proxyAuthenticationRequired = _swig_property(_webview.eWebView_proxyAuthenticationRequired_get, _webview.eWebView_proxyAuthenticationRequired_set)
sslErrors = _swig_property(_webview.eWebView_sslErrors_get, _webview.eWebView_sslErrors_set)
eWebView.navigate = new_instancemethod(_webview.eWebView_navigate,None,eWebView)
eWebView.asciiInput = new_instancemethod(_webview.eWebView_asciiInput,None,eWebView)
eWebView.load = new_instancemethod(_webview.eWebView_load,None,eWebView)
eWebView.scroll = new_instancemethod(_webview.eWebView_scroll,None,eWebView)
eWebView.getHtml = new_instancemethod(_webview.eWebView_getHtml,None,eWebView)
eWebView.setHtml = new_instancemethod(_webview.eWebView_setHtml,None,eWebView)
eWebView.setZoomFactor = new_instancemethod(_webview.eWebView_setZoomFactor,None,eWebView)
eWebView.getZoomFactor = new_instancemethod(_webview.eWebView_getZoomFactor,None,eWebView)
eWebView.setDict = new_instancemethod(_webview.eWebView_setDict,None,eWebView)
eWebView.enablePersistentStorage = new_instancemethod(_webview.eWebView_enablePersistentStorage,None,eWebView)
eWebView.getRawCookies = new_instancemethod(_webview.eWebView_getRawCookies,None,eWebView)
eWebView.setRawCookies = new_instancemethod(_webview.eWebView_setRawCookies,None,eWebView)
eWebView.setBackgroundTransparent = new_instancemethod(_webview.eWebView_setBackgroundTransparent,None,eWebView)
eWebView.setAcceptLanguage = new_instancemethod(_webview.eWebView_setAcceptLanguage,None,eWebView)
eWebView.leftClick = new_instancemethod(_webview.eWebView_leftClick,None,eWebView)
eWebView.show = new_instancemethod(_webview.eWebView_show,None,eWebView)
raise RuntimeException("Class is expecting a pickled object with version number %d, but we found %d" % (cls.pickle_format_version(), version))
inst = cls.__new__(cls)
inst.__init__()
inst.set(*args)
return inst
import full_physics_swig.state_vector
import full_physics_swig.generic_object
class ObservableInstrumentCorrection(full_physics_swig.generic_object.GenericObject):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _instrument_correction.delete_ObservableInstrumentCorrection
ObservableInstrumentCorrection.add_observer_and_keep_reference = new_instancemethod(_instrument_correction.ObservableInstrumentCorrection_add_observer_and_keep_reference, None, ObservableInstrumentCorrection)
ObservableInstrumentCorrection.add_observer = new_instancemethod(_instrument_correction.ObservableInstrumentCorrection_add_observer, None, ObservableInstrumentCorrection)
ObservableInstrumentCorrection.remove_observer = new_instancemethod(_instrument_correction.ObservableInstrumentCorrection_remove_observer, None, ObservableInstrumentCorrection)
ObservableInstrumentCorrection_swigregister = _instrument_correction.ObservableInstrumentCorrection_swigregister
ObservableInstrumentCorrection_swigregister(ObservableInstrumentCorrection)
class ObserverInstrumentCorrection(full_physics_swig.generic_object.GenericObject):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
_instrument_correction.ObserverInstrumentCorrection_swiginit(self, _instrument_correction.new_ObserverInstrumentCorrection())
__swig_destroy__ = _instrument_correction.delete_ObserverInstrumentCorrection
ObserverInstrumentCorrection.notify_update = new_instancemethod(_instrument_correction.ObserverInstrumentCorrection_notify_update, None, ObserverInstrumentCorrection)
ObserverInstrumentCorrection.notify_add = new_instancemethod(_instrument_correction.ObserverInstrumentCorrection_notify_add, None, ObserverInstrumentCorrection)
ObserverInstrumentCorrection.notify_remove = new_instancemethod(_instrument_correction.ObserverInstrumentCorrection_notify_remove, None, ObserverInstrumentCorrection)
itkGridForwardWarpImageFilterIVF22IUC2.New( reader, Threshold=10 )
is (most of the time) equivalent to:
obj = itkGridForwardWarpImageFilterIVF22IUC2.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkGridForwardWarpImageFilterIVF22IUC2.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkGridForwardWarpImageFilterIVF22IUC2.SetBackgroundValue = new_instancemethod(_itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_SetBackgroundValue,None,itkGridForwardWarpImageFilterIVF22IUC2)
itkGridForwardWarpImageFilterIVF22IUC2.GetBackgroundValue = new_instancemethod(_itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_GetBackgroundValue,None,itkGridForwardWarpImageFilterIVF22IUC2)
itkGridForwardWarpImageFilterIVF22IUC2.SetForegroundValue = new_instancemethod(_itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_SetForegroundValue,None,itkGridForwardWarpImageFilterIVF22IUC2)
itkGridForwardWarpImageFilterIVF22IUC2.GetForegroundValue = new_instancemethod(_itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_GetForegroundValue,None,itkGridForwardWarpImageFilterIVF22IUC2)
itkGridForwardWarpImageFilterIVF22IUC2.GetPointer = new_instancemethod(_itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_GetPointer,None,itkGridForwardWarpImageFilterIVF22IUC2)
itkGridForwardWarpImageFilterIVF22IUC2_swigregister = _itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_swigregister
itkGridForwardWarpImageFilterIVF22IUC2_swigregister(itkGridForwardWarpImageFilterIVF22IUC2)
def itkGridForwardWarpImageFilterIVF22IUC2___New_orig__():
"""itkGridForwardWarpImageFilterIVF22IUC2___New_orig__()"""
return _itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2___New_orig__()
def itkGridForwardWarpImageFilterIVF22IUC2_cast(*args):
"""itkGridForwardWarpImageFilterIVF22IUC2_cast(itkLightObject obj) -> itkGridForwardWarpImageFilterIVF22IUC2"""
return _itkGridForwardWarpImageFilterPython.itkGridForwardWarpImageFilterIVF22IUC2_cast(*args)
C++ includes: radiance_scaling_linear_fit.h
"""
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _radiance_scaling_linear_fit.delete_RadianceScalingLinearFit
def _v_radiance_scaling_coeff_uncertainty(self):
"""
blitz::Array<double, 1> FullPhysics::RadianceScalingLinearFit::radiance_scaling_coeff_uncertainty() const
"""
return _radiance_scaling_linear_fit.RadianceScalingLinearFit__v_radiance_scaling_coeff_uncertainty(self)
@property
def radiance_scaling_coeff_uncertainty(self):
return self._v_radiance_scaling_coeff_uncertainty()
RadianceScalingLinearFit._v_radiance_scaling_coeff_uncertainty = new_instancemethod(_radiance_scaling_linear_fit.RadianceScalingLinearFit__v_radiance_scaling_coeff_uncertainty, None, RadianceScalingLinearFit)
RadianceScalingLinearFit_swigregister = _radiance_scaling_linear_fit.RadianceScalingLinearFit_swigregister
RadianceScalingLinearFit_swigregister(RadianceScalingLinearFit)
try:
import weakref
weakref_proxy = weakref.proxy
except:
weakref_proxy = lambda x: x
import enigma
class eSocket_UI(enigma.eMMI_UI):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined")
__repr__ = _swig_repr
socketStateChanged = _swig_property(_socketmmi.eSocket_UI_socketStateChanged_get, _socketmmi.eSocket_UI_socketStateChanged_set)
getInstance = staticmethod(_socketmmi.eSocket_UI_getInstance)
eSocket_UI.setInit = new_instancemethod(_socketmmi.eSocket_UI_setInit,None,eSocket_UI)
eSocket_UI.setReset = new_instancemethod(_socketmmi.eSocket_UI_setReset,None,eSocket_UI)
eSocket_UI.startMMI = new_instancemethod(_socketmmi.eSocket_UI_startMMI,None,eSocket_UI)
eSocket_UI.stopMMI = new_instancemethod(_socketmmi.eSocket_UI_stopMMI,None,eSocket_UI)
eSocket_UI.answerMenu = new_instancemethod(_socketmmi.eSocket_UI_answerMenu,None,eSocket_UI)
eSocket_UI.answerEnq = new_instancemethod(_socketmmi.eSocket_UI_answerEnq,None,eSocket_UI)
eSocket_UI.cancelEnq = new_instancemethod(_socketmmi.eSocket_UI_cancelEnq,None,eSocket_UI)
eSocket_UI.getState = new_instancemethod(_socketmmi.eSocket_UI_getState,None,eSocket_UI)
eSocket_UI.getMMIState = new_instancemethod(_socketmmi.eSocket_UI_getMMIState,None,eSocket_UI)
eSocket_UI.numConnections = new_instancemethod(_socketmmi.eSocket_UI_numConnections,None,eSocket_UI)
eSocket_UI.getName = new_instancemethod(_socketmmi.eSocket_UI_getName,None,eSocket_UI)
eSocket_UI_swigregister = _socketmmi.eSocket_UI_swigregister
eSocket_UI_swigregister(eSocket_UI)
def eSocket_UI_getInstance():
return _socketmmi.eSocket_UI_getInstance()
C++ includes: oco_forward_model_output.h
"""
thisown = _swig_property(lambda x: x.this.own(),
lambda x, v: x.this.own(v),
doc='The membership flag')
def __init__(self, *args, **kwargs):
raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
def register_output(self, out):
"""
void OcoForwardModelOutput::register_output(const boost::shared_ptr< Output > &out) const
"""
return _oco_forward_model_output.OcoForwardModelOutput_register_output(
self, out)
__swig_destroy__ = _oco_forward_model_output.delete_OcoForwardModelOutput
OcoForwardModelOutput.register_output = new_instancemethod(
_oco_forward_model_output.OcoForwardModelOutput_register_output, None,
OcoForwardModelOutput)
OcoForwardModelOutput_swigregister = _oco_forward_model_output.OcoForwardModelOutput_swigregister
OcoForwardModelOutput_swigregister(OcoForwardModelOutput)
@property
def number_stokes(self):
return self._v_number_stokes()
@property
def number_stream(self):
return self._v_number_stream()
def _v_rt(self):
"""
virtual boost::shared_ptr<RadiativeTransfer> FullPhysics::HresWrapper::rt() const
"""
return _hres_wrapper.HresWrapper__v_rt(self)
@property
def rt(self):
return self._v_rt()
__swig_destroy__ = _hres_wrapper.delete_HresWrapper
HresWrapper._v_rt = new_instancemethod(_hres_wrapper.HresWrapper__v_rt, None, HresWrapper)
HresWrapper_swigregister = _hres_wrapper.HresWrapper_swigregister
HresWrapper_swigregister(HresWrapper)
def set_attr(self,name,value):
if (name == "thisown"): return self.this.own(value)
if hasattr(self,name) or (name == "this"):
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
class SwigPyIterator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
def __init__(self, *args, **kwargs): raise AttributeError("No constructor defined - class is abstract")
__repr__ = _swig_repr
__swig_destroy__ = _AppBlend.delete_SwigPyIterator
def __iter__(self): return self
SwigPyIterator.value = new_instancemethod(_AppBlend.SwigPyIterator_value,None,SwigPyIterator)
SwigPyIterator.incr = new_instancemethod(_AppBlend.SwigPyIterator_incr,None,SwigPyIterator)
SwigPyIterator.decr = new_instancemethod(_AppBlend.SwigPyIterator_decr,None,SwigPyIterator)
SwigPyIterator.distance = new_instancemethod(_AppBlend.SwigPyIterator_distance,None,SwigPyIterator)
SwigPyIterator.equal = new_instancemethod(_AppBlend.SwigPyIterator_equal,None,SwigPyIterator)
SwigPyIterator.copy = new_instancemethod(_AppBlend.SwigPyIterator_copy,None,SwigPyIterator)
SwigPyIterator.next = new_instancemethod(_AppBlend.SwigPyIterator_next,None,SwigPyIterator)
SwigPyIterator.__next__ = new_instancemethod(_AppBlend.SwigPyIterator___next__,None,SwigPyIterator)
SwigPyIterator.previous = new_instancemethod(_AppBlend.SwigPyIterator_previous,None,SwigPyIterator)
SwigPyIterator.advance = new_instancemethod(_AppBlend.SwigPyIterator_advance,None,SwigPyIterator)
SwigPyIterator.__eq__ = new_instancemethod(_AppBlend.SwigPyIterator___eq__,None,SwigPyIterator)
SwigPyIterator.__ne__ = new_instancemethod(_AppBlend.SwigPyIterator___ne__,None,SwigPyIterator)
SwigPyIterator.__iadd__ = new_instancemethod(_AppBlend.SwigPyIterator___iadd__,None,SwigPyIterator)
SwigPyIterator.__isub__ = new_instancemethod(_AppBlend.SwigPyIterator___isub__,None,SwigPyIterator)
SwigPyIterator.__add__ = new_instancemethod(_AppBlend.SwigPyIterator___add__,None,SwigPyIterator)
SwigPyIterator.__sub__ = new_instancemethod(_AppBlend.SwigPyIterator___sub__,None,SwigPyIterator)
set(self,name,value)
else:
raise AttributeError("You cannot add attributes to %s" % self)
return set_attr
atCube = _Visualization.atCube
atNormal = _Visualization.atNormal
atNormalAutoScale = _Visualization.atNormalAutoScale
class Tesselator(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self, *args):
_Visualization.Tesselator_swiginit(self,_Visualization.new_Tesselator(*args))
__swig_destroy__ = _Visualization.delete_Tesselator
Tesselator.VerticesList = new_instancemethod(_Visualization.Tesselator_VerticesList,None,Tesselator)
Tesselator.ObjGetTriangleCount = new_instancemethod(_Visualization.Tesselator_ObjGetTriangleCount,None,Tesselator)
Tesselator.ObjGetVertexCount = new_instancemethod(_Visualization.Tesselator_ObjGetVertexCount,None,Tesselator)
Tesselator.ObjGetNormalCount = new_instancemethod(_Visualization.Tesselator_ObjGetNormalCount,None,Tesselator)
Tesselator.ExportShapeToJSON = new_instancemethod(_Visualization.Tesselator_ExportShapeToJSON,None,Tesselator)
Tesselator.ExportShapeToX3D = new_instancemethod(_Visualization.Tesselator_ExportShapeToX3D,None,Tesselator)
Tesselator.SetDeviation = new_instancemethod(_Visualization.Tesselator_SetDeviation,None,Tesselator)
Tesselator_swigregister = _Visualization.Tesselator_swigregister
Tesselator_swigregister(Tesselator)
class Display3d(object):
thisown = _swig_property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc='The membership flag')
__repr__ = _swig_repr
def __init__(self):
"""__init__(Display3d self) -> Display3d"""
_Visualization.Display3d_swiginit(self,_Visualization.new_Display3d())
is (most of the time) equivalent to:
obj = itkRelabelLabelMapFilterLM2_Superclass.New()
obj.SetInput( 0, reader.GetOutput() )
obj.SetThreshold( 10 )
"""
obj = itkRelabelLabelMapFilterLM2_Superclass.__New_orig__()
import itkTemplate
itkTemplate.New(obj, *args, **kargs)
return obj
New = staticmethod(New)
itkRelabelLabelMapFilterLM2_Superclass.Clone = new_instancemethod(
_itkRelabelLabelMapFilterPython.
itkRelabelLabelMapFilterLM2_Superclass_Clone, None,
itkRelabelLabelMapFilterLM2_Superclass)
itkRelabelLabelMapFilterLM2_Superclass.SetReverseOrdering = new_instancemethod(
_itkRelabelLabelMapFilterPython.
itkRelabelLabelMapFilterLM2_Superclass_SetReverseOrdering, None,
itkRelabelLabelMapFilterLM2_Superclass)
itkRelabelLabelMapFilterLM2_Superclass.GetReverseOrdering = new_instancemethod(
_itkRelabelLabelMapFilterPython.
itkRelabelLabelMapFilterLM2_Superclass_GetReverseOrdering, None,
itkRelabelLabelMapFilterLM2_Superclass)
itkRelabelLabelMapFilterLM2_Superclass.ReverseOrderingOn = new_instancemethod(
_itkRelabelLabelMapFilterPython.
itkRelabelLabelMapFilterLM2_Superclass_ReverseOrderingOn, None,
itkRelabelLabelMapFilterLM2_Superclass)
itkRelabelLabelMapFilterLM2_Superclass.ReverseOrderingOff = new_instancemethod(
_itkRelabelLabelMapFilterPython.
@property
def speceff_size(self):
return self._speceff_size()
@property
def spectrum_effect(self):
res = []
for i in range(self.speceff_size):
res2 = []
for j in range(self.speceff_size2(i)):
res2.append(self.speceff_val(i, j))
res.append(res2)
return res
OcoForwardModel.radiance = new_instancemethod(_oco_forward_model.OcoForwardModel_radiance, None, OcoForwardModel)
OcoForwardModel._v_instrument = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_instrument, None, OcoForwardModel
)
OcoForwardModel._v_spectral_window = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectral_window, None, OcoForwardModel
)
OcoForwardModel._v_level_1b = new_instancemethod(_oco_forward_model.OcoForwardModel__v_level_1b, None, OcoForwardModel)
OcoForwardModel._v_radiative_transfer = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_radiative_transfer, None, OcoForwardModel
)
OcoForwardModel._v_spectrum_sampling = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectrum_sampling, None, OcoForwardModel
)
OcoForwardModel._v_spectral_grid = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectral_grid, None, OcoForwardModel
&Used_flag, const std::string &Coeff_unit_name, const std::string
&Band_name, int Number_pixel, bool Is_one_based)
Constructor.
Pass units by string because Units class does not compile well with
Lua
"""
_dispersion_polynomial.DispersionPolynomial_swiginit(
self, _dispersion_polynomial.new_DispersionPolynomial(*args))
__swig_destroy__ = _dispersion_polynomial.delete_DispersionPolynomial
def _v_pixel_grid(self):
"""
SpectralDomain DispersionPolynomial::pixel_grid() const
"""
return _dispersion_polynomial.DispersionPolynomial__v_pixel_grid(self)
@property
def pixel_grid(self):
return self._v_pixel_grid()
DispersionPolynomial._v_pixel_grid = new_instancemethod(
_dispersion_polynomial.DispersionPolynomial__v_pixel_grid, None,
DispersionPolynomial)
DispersionPolynomial_swigregister = _dispersion_polynomial.DispersionPolynomial_swigregister
DispersionPolynomial_swigregister(DispersionPolynomial)
return self._value()
@value.setter
def value(self,v):
self._value(v)
@property
def units(self):
return self._units()
@units.setter
def units(self,v):
self._units(v)
__swig_destroy__ = _array_with_unit.delete_ArrayWithUnit_double_1
ArrayWithUnit_double_1._value = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1__value, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1._units = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1__units, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1.__imul__ = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1___imul__, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1.__idiv__ = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1___idiv__, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1.convert = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1_convert, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1.convert_wave = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1_convert_wave, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1._v_rows = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1__v_rows, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1._v_cols = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1__v_cols, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1._v_depth = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1__v_depth, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1.__str__ = new_instancemethod(_array_with_unit.ArrayWithUnit_double_1___str__, None, ArrayWithUnit_double_1)
ArrayWithUnit_double_1_swigregister = _array_with_unit.ArrayWithUnit_double_1_swigregister
ArrayWithUnit_double_1_swigregister(ArrayWithUnit_double_1)
class ArrayWithUnit_double_2(full_physics_swig.generic_object.GenericObject):
"""
@property
def speceff_size(self):
return self._speceff_size()
@property
def spectrum_effect(self):
res = []
for i in range(self.speceff_size):
res2 = []
for j in range(self.speceff_size2(i)):
res2.append(self.speceff_val(i, j))
res.append(res2)
return res
OcoForwardModel.radiance = new_instancemethod(
_oco_forward_model.OcoForwardModel_radiance, None, OcoForwardModel)
OcoForwardModel._v_instrument = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_instrument, None, OcoForwardModel)
OcoForwardModel._v_spectral_window = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectral_window, None,
OcoForwardModel)
OcoForwardModel._v_level_1b = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_level_1b, None, OcoForwardModel)
OcoForwardModel._v_radiative_transfer = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_radiative_transfer, None,
OcoForwardModel)
OcoForwardModel._v_spectrum_sampling = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectrum_sampling, None,
OcoForwardModel)
OcoForwardModel._v_spectral_grid = new_instancemethod(
_oco_forward_model.OcoForwardModel__v_spectral_grid, None, OcoForwardModel)