Python new.new_instancemethod函数代码示例

 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

        
          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)

    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)

    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"""

        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)

    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)

    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)

        
          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)

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

    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)

      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)

    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)

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

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

    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)