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
Beispiel #2
0
        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.
Beispiel #3
0
    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"""
Beispiel #4
0
    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)


Beispiel #6
0
    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)
Beispiel #8
0
      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)
Beispiel #9
0
    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)
Beispiel #10
0
        """

        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)
Beispiel #11
0
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(
Beispiel #12
0
        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
Beispiel #13
0
    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)



Beispiel #14
0
          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__()

Beispiel #16
0
    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)



Beispiel #20
0
        """
        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)
Beispiel #22
0

    @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)



Beispiel #23
0
    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)
Beispiel #24
0
    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)
Beispiel #25
0
    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)
Beispiel #26
0
        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)



Beispiel #28
0
          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)



Beispiel #30
0
    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)
Beispiel #32
0
    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.
Beispiel #35
0
    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)
Beispiel #38
0
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)



Beispiel #40
0
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)
Beispiel #43
0
    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)
Beispiel #44
0
        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)
Beispiel #46
0
    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)
Beispiel #47
0
    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)
Beispiel #50
0
    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)



Beispiel #51
0
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()
Beispiel #52
0
    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)



Beispiel #54
0
    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)
Beispiel #55
0
            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())
Beispiel #56
0
        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
Beispiel #58
0
        &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):
    """
Beispiel #60
0
    @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)