You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1276 lines
50 KiB
Python
1276 lines
50 KiB
Python
1 year ago
|
# This file was automatically generated by SWIG (http://www.swig.org).
|
||
|
# Version 4.0.2
|
||
|
#
|
||
|
# Do not make changes to this file unless you know what you are doing--modify
|
||
|
# the SWIG interface file instead.
|
||
|
|
||
|
"""Codes for working with geo features (e.g. polygons)"""
|
||
|
|
||
|
from sys import version_info as _swig_python_version_info
|
||
|
if _swig_python_version_info < (2, 7, 0):
|
||
|
raise RuntimeError("Python 2.7 or later required")
|
||
|
|
||
|
# Import the low-level C/C++ module
|
||
|
if __package__ or "." in __name__:
|
||
|
from . import _geo
|
||
|
else:
|
||
|
import _geo
|
||
|
|
||
|
try:
|
||
|
import builtins as __builtin__
|
||
|
except ImportError:
|
||
|
import __builtin__
|
||
|
|
||
|
def _swig_repr(self):
|
||
|
try:
|
||
|
strthis = "proxy of " + self.this.__repr__()
|
||
|
except __builtin__.Exception:
|
||
|
strthis = ""
|
||
|
return "<%s.%s; %s >" % (self.__class__.__module__, self.__class__.__name__, strthis,)
|
||
|
|
||
|
|
||
|
def _swig_setattr_nondynamic_instance_variable(set):
|
||
|
def set_instance_attr(self, name, value):
|
||
|
if name == "thisown":
|
||
|
self.this.own(value)
|
||
|
elif name == "this":
|
||
|
set(self, name, value)
|
||
|
elif hasattr(self, name) and isinstance(getattr(type(self), name), property):
|
||
|
set(self, name, value)
|
||
|
else:
|
||
|
raise AttributeError("You cannot add instance attributes to %s" % self)
|
||
|
return set_instance_attr
|
||
|
|
||
|
|
||
|
def _swig_setattr_nondynamic_class_variable(set):
|
||
|
def set_class_attr(cls, name, value):
|
||
|
if hasattr(cls, name) and not isinstance(getattr(cls, name), property):
|
||
|
set(cls, name, value)
|
||
|
else:
|
||
|
raise AttributeError("You cannot add class attributes to %s" % cls)
|
||
|
return set_class_attr
|
||
|
|
||
|
|
||
|
def _swig_add_metaclass(metaclass):
|
||
|
"""Class decorator for adding a metaclass to a SWIG wrapped class - a slimmed down version of six.add_metaclass"""
|
||
|
def wrapper(cls):
|
||
|
return metaclass(cls.__name__, cls.__bases__, cls.__dict__.copy())
|
||
|
return wrapper
|
||
|
|
||
|
|
||
|
class _SwigNonDynamicMeta(type):
|
||
|
"""Meta class to enforce nondynamic attributes (no new attributes) for a class"""
|
||
|
__setattr__ = _swig_setattr_nondynamic_class_variable(type.__setattr__)
|
||
|
|
||
|
|
||
|
class SwigPyIterator(object):
|
||
|
thisown = 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__ = _geo.delete_SwigPyIterator
|
||
|
|
||
|
def value(self):
|
||
|
return _geo.SwigPyIterator_value(self)
|
||
|
|
||
|
def incr(self, n=1):
|
||
|
return _geo.SwigPyIterator_incr(self, n)
|
||
|
|
||
|
def decr(self, n=1):
|
||
|
return _geo.SwigPyIterator_decr(self, n)
|
||
|
|
||
|
def distance(self, x):
|
||
|
return _geo.SwigPyIterator_distance(self, x)
|
||
|
|
||
|
def equal(self, x):
|
||
|
return _geo.SwigPyIterator_equal(self, x)
|
||
|
|
||
|
def copy(self):
|
||
|
return _geo.SwigPyIterator_copy(self)
|
||
|
|
||
|
def next(self):
|
||
|
return _geo.SwigPyIterator_next(self)
|
||
|
|
||
|
def __next__(self):
|
||
|
return _geo.SwigPyIterator___next__(self)
|
||
|
|
||
|
def previous(self):
|
||
|
return _geo.SwigPyIterator_previous(self)
|
||
|
|
||
|
def advance(self, n):
|
||
|
return _geo.SwigPyIterator_advance(self, n)
|
||
|
|
||
|
def __eq__(self, x):
|
||
|
return _geo.SwigPyIterator___eq__(self, x)
|
||
|
|
||
|
def __ne__(self, x):
|
||
|
return _geo.SwigPyIterator___ne__(self, x)
|
||
|
|
||
|
def __iadd__(self, n):
|
||
|
return _geo.SwigPyIterator___iadd__(self, n)
|
||
|
|
||
|
def __isub__(self, n):
|
||
|
return _geo.SwigPyIterator___isub__(self, n)
|
||
|
|
||
|
def __add__(self, n):
|
||
|
return _geo.SwigPyIterator___add__(self, n)
|
||
|
|
||
|
def __sub__(self, *args):
|
||
|
return _geo.SwigPyIterator___sub__(self, *args)
|
||
|
def __iter__(self):
|
||
|
return self
|
||
|
|
||
|
# Register SwigPyIterator in _geo:
|
||
|
_geo.SwigPyIterator_swigregister(SwigPyIterator)
|
||
|
|
||
|
import seiscomp.math
|
||
|
import seiscomp.core
|
||
|
class GeoCoordinate(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoCoordinate class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(GeoCoordinate self) -> GeoCoordinate
|
||
|
__init__(GeoCoordinate self, Seiscomp::Geo::GeoCoordinate::ValueType lat_, Seiscomp::Geo::GeoCoordinate::ValueType lon_) -> GeoCoordinate
|
||
|
"""
|
||
|
_geo.GeoCoordinate_swiginit(self, _geo.new_GeoCoordinate(*args))
|
||
|
|
||
|
def set(self, lat, lon):
|
||
|
r"""set(GeoCoordinate self, Seiscomp::Geo::GeoCoordinate::ValueType lat, Seiscomp::Geo::GeoCoordinate::ValueType lon)"""
|
||
|
return _geo.GeoCoordinate_set(self, lat, lon)
|
||
|
|
||
|
def latitude(self):
|
||
|
r"""latitude(GeoCoordinate self) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_latitude(self)
|
||
|
|
||
|
def longitude(self):
|
||
|
r"""longitude(GeoCoordinate self) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_longitude(self)
|
||
|
|
||
|
def __eq__(self, other):
|
||
|
r"""__eq__(GeoCoordinate self, GeoCoordinate other) -> bool"""
|
||
|
return _geo.GeoCoordinate___eq__(self, other)
|
||
|
|
||
|
def __ne__(self, other):
|
||
|
r"""__ne__(GeoCoordinate self, GeoCoordinate other) -> bool"""
|
||
|
return _geo.GeoCoordinate___ne__(self, other)
|
||
|
|
||
|
def normalize(self):
|
||
|
r"""normalize(GeoCoordinate self) -> GeoCoordinate"""
|
||
|
return _geo.GeoCoordinate_normalize(self)
|
||
|
|
||
|
@staticmethod
|
||
|
def width(lon0, lon1):
|
||
|
r"""width(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_width(lon0, lon1)
|
||
|
|
||
|
@staticmethod
|
||
|
def normalizeLat(lat):
|
||
|
r"""normalizeLat(Seiscomp::Geo::GeoCoordinate::ValueType lat) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_normalizeLat(lat)
|
||
|
|
||
|
@staticmethod
|
||
|
def normalizeLon(lon):
|
||
|
r"""normalizeLon(Seiscomp::Geo::GeoCoordinate::ValueType lon) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_normalizeLon(lon)
|
||
|
|
||
|
@staticmethod
|
||
|
def normalizeLatLon(lat, lon):
|
||
|
r"""normalizeLatLon(Seiscomp::Geo::GeoCoordinate::ValueType & lat, Seiscomp::Geo::GeoCoordinate::ValueType & lon)"""
|
||
|
return _geo.GeoCoordinate_normalizeLatLon(lat, lon)
|
||
|
|
||
|
@staticmethod
|
||
|
def distanceLon(lon0, lon1):
|
||
|
r"""distanceLon(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_distanceLon(lon0, lon1)
|
||
|
lat = property(_geo.GeoCoordinate_lat_get, _geo.GeoCoordinate_lat_set, doc=r"""lat : Seiscomp::Geo::GeoCoordinate::ValueType""")
|
||
|
lon = property(_geo.GeoCoordinate_lon_get, _geo.GeoCoordinate_lon_set, doc=r"""lon : Seiscomp::Geo::GeoCoordinate::ValueType""")
|
||
|
__swig_destroy__ = _geo.delete_GeoCoordinate
|
||
|
|
||
|
# Register GeoCoordinate in _geo:
|
||
|
_geo.GeoCoordinate_swigregister(GeoCoordinate)
|
||
|
|
||
|
def GeoCoordinate_width(lon0, lon1):
|
||
|
r"""GeoCoordinate_width(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_width(lon0, lon1)
|
||
|
|
||
|
def GeoCoordinate_normalizeLat(lat):
|
||
|
r"""GeoCoordinate_normalizeLat(Seiscomp::Geo::GeoCoordinate::ValueType lat) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_normalizeLat(lat)
|
||
|
|
||
|
def GeoCoordinate_normalizeLon(lon):
|
||
|
r"""GeoCoordinate_normalizeLon(Seiscomp::Geo::GeoCoordinate::ValueType lon) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_normalizeLon(lon)
|
||
|
|
||
|
def GeoCoordinate_normalizeLatLon(lat, lon):
|
||
|
r"""GeoCoordinate_normalizeLatLon(Seiscomp::Geo::GeoCoordinate::ValueType & lat, Seiscomp::Geo::GeoCoordinate::ValueType & lon)"""
|
||
|
return _geo.GeoCoordinate_normalizeLatLon(lat, lon)
|
||
|
|
||
|
def GeoCoordinate_distanceLon(lon0, lon1):
|
||
|
r"""GeoCoordinate_distanceLon(Seiscomp::Geo::GeoCoordinate::ValueType lon0, Seiscomp::Geo::GeoCoordinate::ValueType lon1) -> Seiscomp::Geo::GeoCoordinate::ValueType"""
|
||
|
return _geo.GeoCoordinate_distanceLon(lon0, lon1)
|
||
|
|
||
|
|
||
|
def contains(*args):
|
||
|
r"""
|
||
|
contains(GeoCoordinate v, GeoCoordinate polygon, size_t sides) -> bool
|
||
|
contains(GeoCoordinate v, GeoCoordinate polygon, size_t sides, double & area) -> bool
|
||
|
"""
|
||
|
return _geo.contains(*args)
|
||
|
|
||
|
def area(polygon, sides):
|
||
|
r"""area(GeoCoordinate polygon, size_t sides) -> double"""
|
||
|
return _geo.area(polygon, sides)
|
||
|
class formatted_lat(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::formatted_lat class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def __init__(self, lat):
|
||
|
r"""__init__(formatted_lat self, double lat) -> formatted_lat"""
|
||
|
_geo.formatted_lat_swiginit(self, _geo.new_formatted_lat(lat))
|
||
|
v = property(_geo.formatted_lat_v_get, _geo.formatted_lat_v_set, doc=r"""v : double""")
|
||
|
__swig_destroy__ = _geo.delete_formatted_lat
|
||
|
|
||
|
# Register formatted_lat in _geo:
|
||
|
_geo.formatted_lat_swigregister(formatted_lat)
|
||
|
|
||
|
class formatted_lon(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::formatted_lon class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def __init__(self, lon):
|
||
|
r"""__init__(formatted_lon self, double lon) -> formatted_lon"""
|
||
|
_geo.formatted_lon_swiginit(self, _geo.new_formatted_lon(lon))
|
||
|
v = property(_geo.formatted_lon_v_get, _geo.formatted_lon_v_set, doc=r"""v : double""")
|
||
|
__swig_destroy__ = _geo.delete_formatted_lon
|
||
|
|
||
|
# Register formatted_lon in _geo:
|
||
|
_geo.formatted_lon_swigregister(formatted_lon)
|
||
|
|
||
|
class GeoBoundingBox(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoBoundingBox class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
Disjunct = _geo.GeoBoundingBox_Disjunct
|
||
|
|
||
|
Contains = _geo.GeoBoundingBox_Contains
|
||
|
|
||
|
Intersects = _geo.GeoBoundingBox_Intersects
|
||
|
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(GeoBoundingBox self) -> GeoBoundingBox
|
||
|
__init__(GeoBoundingBox self, Seiscomp::Geo::GeoBoundingBox::ValueType south, Seiscomp::Geo::GeoBoundingBox::ValueType west, Seiscomp::Geo::GeoBoundingBox::ValueType north, Seiscomp::Geo::GeoBoundingBox::ValueType east) -> GeoBoundingBox
|
||
|
"""
|
||
|
_geo.GeoBoundingBox_swiginit(self, _geo.new_GeoBoundingBox(*args))
|
||
|
|
||
|
def __eq__(self, other):
|
||
|
r"""__eq__(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
|
||
|
return _geo.GeoBoundingBox___eq__(self, other)
|
||
|
|
||
|
def __iadd__(self, other):
|
||
|
r"""__iadd__(GeoBoundingBox self, GeoBoundingBox other) -> GeoBoundingBox"""
|
||
|
return _geo.GeoBoundingBox___iadd__(self, other)
|
||
|
|
||
|
def __add__(self, other):
|
||
|
r"""__add__(GeoBoundingBox self, GeoBoundingBox other) -> GeoBoundingBox"""
|
||
|
return _geo.GeoBoundingBox___add__(self, other)
|
||
|
|
||
|
def __and__(self, other):
|
||
|
r"""__and__(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
|
||
|
return _geo.GeoBoundingBox___and__(self, other)
|
||
|
|
||
|
def normalize(self):
|
||
|
r"""normalize(GeoBoundingBox self) -> GeoBoundingBox"""
|
||
|
return _geo.GeoBoundingBox_normalize(self)
|
||
|
|
||
|
def isEmpty(self):
|
||
|
r"""isEmpty(GeoBoundingBox self) -> bool"""
|
||
|
return _geo.GeoBoundingBox_isEmpty(self)
|
||
|
|
||
|
def isNull(self):
|
||
|
r"""isNull(GeoBoundingBox self) -> bool"""
|
||
|
return _geo.GeoBoundingBox_isNull(self)
|
||
|
|
||
|
def reset(self):
|
||
|
r"""reset(GeoBoundingBox self)"""
|
||
|
return _geo.GeoBoundingBox_reset(self)
|
||
|
|
||
|
def coversFullLongitude(self):
|
||
|
r"""coversFullLongitude(GeoBoundingBox self) -> bool"""
|
||
|
return _geo.GeoBoundingBox_coversFullLongitude(self)
|
||
|
|
||
|
def width(self):
|
||
|
r"""width(GeoBoundingBox self) -> Seiscomp::Geo::GeoBoundingBox::ValueType"""
|
||
|
return _geo.GeoBoundingBox_width(self)
|
||
|
|
||
|
def height(self):
|
||
|
r"""height(GeoBoundingBox self) -> Seiscomp::Geo::GeoBoundingBox::ValueType"""
|
||
|
return _geo.GeoBoundingBox_height(self)
|
||
|
|
||
|
@staticmethod
|
||
|
def crossesDateLine(*args):
|
||
|
r"""
|
||
|
crossesDateLine() -> bool
|
||
|
crossesDateLine(Seiscomp::Geo::GeoBoundingBox::ValueType east, Seiscomp::Geo::GeoBoundingBox::ValueType west) -> bool
|
||
|
"""
|
||
|
return _geo.GeoBoundingBox_crossesDateLine(*args)
|
||
|
|
||
|
def center(self):
|
||
|
r"""center(GeoBoundingBox self) -> GeoCoordinate"""
|
||
|
return _geo.GeoBoundingBox_center(self)
|
||
|
|
||
|
def contains(self, *args):
|
||
|
r"""
|
||
|
contains(GeoBoundingBox self, GeoCoordinate v) -> bool
|
||
|
contains(GeoBoundingBox self, GeoBoundingBox other) -> bool
|
||
|
"""
|
||
|
return _geo.GeoBoundingBox_contains(self, *args)
|
||
|
|
||
|
def relation(self, other):
|
||
|
r"""relation(GeoBoundingBox self, GeoBoundingBox other) -> Seiscomp::Geo::GeoBoundingBox::Relation"""
|
||
|
return _geo.GeoBoundingBox_relation(self, other)
|
||
|
|
||
|
def merge(self, other):
|
||
|
r"""merge(GeoBoundingBox self, GeoBoundingBox other)"""
|
||
|
return _geo.GeoBoundingBox_merge(self, other)
|
||
|
|
||
|
def intersects(self, other):
|
||
|
r"""intersects(GeoBoundingBox self, GeoBoundingBox other) -> bool"""
|
||
|
return _geo.GeoBoundingBox_intersects(self, other)
|
||
|
|
||
|
def fromPolygon(self, n, coords, isClosed=True):
|
||
|
r"""fromPolygon(GeoBoundingBox self, size_t n, GeoCoordinate coords, bool isClosed=True)"""
|
||
|
return _geo.GeoBoundingBox_fromPolygon(self, n, coords, isClosed)
|
||
|
Empty = property(_geo.GeoBoundingBox_Empty_get, _geo.GeoBoundingBox_Empty_set, doc=r"""Empty : Seiscomp::Geo::GeoBoundingBox""")
|
||
|
__swig_destroy__ = _geo.delete_GeoBoundingBox
|
||
|
|
||
|
# Register GeoBoundingBox in _geo:
|
||
|
_geo.GeoBoundingBox_swigregister(GeoBoundingBox)
|
||
|
|
||
|
def GeoBoundingBox_crossesDateLine(*args):
|
||
|
r"""
|
||
|
GeoBoundingBox_crossesDateLine() -> bool
|
||
|
GeoBoundingBox_crossesDateLine(Seiscomp::Geo::GeoBoundingBox::ValueType east, Seiscomp::Geo::GeoBoundingBox::ValueType west) -> bool
|
||
|
"""
|
||
|
return _geo.GeoBoundingBox_crossesDateLine(*args)
|
||
|
cvar = _geo.cvar
|
||
|
|
||
|
|
||
|
def __lshift__(*args):
|
||
|
r"""
|
||
|
__lshift__(std::ostream & os, GeoCoordinate arg2) -> std::ostream
|
||
|
__lshift__(std::ostream & os, formatted_lat arg2) -> std::ostream
|
||
|
__lshift__(std::ostream & os, formatted_lon arg2) -> std::ostream
|
||
|
__lshift__(std::ostream & os, GeoBoundingBox box) -> std::ostream &
|
||
|
"""
|
||
|
return _geo.__lshift__(*args)
|
||
|
class Category(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::Category class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
id = property(_geo.Category_id_get, _geo.Category_id_set, doc=r"""id : unsigned int""")
|
||
|
name = property(_geo.Category_name_get, _geo.Category_name_set, doc=r"""name : std::string""")
|
||
|
localName = property(_geo.Category_localName_get, _geo.Category_localName_set, doc=r"""localName : std::string""")
|
||
|
parent = property(_geo.Category_parent_get, _geo.Category_parent_set, doc=r"""parent : p.q(const).Seiscomp::Geo::Category""")
|
||
|
dataDir = property(_geo.Category_dataDir_get, _geo.Category_dataDir_set, doc=r"""dataDir : std::string""")
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""__init__(Category self, unsigned int id, std::string name="", Category parent=None) -> Category"""
|
||
|
_geo.Category_swiginit(self, _geo.new_Category(*args))
|
||
|
__swig_destroy__ = _geo.delete_Category
|
||
|
|
||
|
# Register Category in _geo:
|
||
|
_geo.Category_swigregister(Category)
|
||
|
|
||
|
class GeoFeature(seiscomp.core.BaseObject):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoFeature class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(GeoFeature self, Category category=None, unsigned int rank=1) -> GeoFeature
|
||
|
__init__(GeoFeature self, std::string const & name, Category category, unsigned int rank) -> GeoFeature
|
||
|
__init__(GeoFeature self, std::string const & name, Category category, unsigned int rank, Seiscomp::Geo::GeoFeature::Attributes const & attributes) -> GeoFeature
|
||
|
"""
|
||
|
_geo.GeoFeature_swiginit(self, _geo.new_GeoFeature(*args))
|
||
|
__swig_destroy__ = _geo.delete_GeoFeature
|
||
|
|
||
|
def setName(self, name):
|
||
|
r"""setName(GeoFeature self, std::string const & name)"""
|
||
|
return _geo.GeoFeature_setName(self, name)
|
||
|
|
||
|
def name(self):
|
||
|
r"""name(GeoFeature self) -> std::string const &"""
|
||
|
return _geo.GeoFeature_name(self)
|
||
|
|
||
|
def category(self):
|
||
|
r"""category(GeoFeature self) -> Category"""
|
||
|
return _geo.GeoFeature_category(self)
|
||
|
|
||
|
def setRank(self, rank):
|
||
|
r"""setRank(GeoFeature self, unsigned int rank)"""
|
||
|
return _geo.GeoFeature_setRank(self, rank)
|
||
|
|
||
|
def rank(self):
|
||
|
r"""rank(GeoFeature self) -> unsigned int"""
|
||
|
return _geo.GeoFeature_rank(self)
|
||
|
|
||
|
def setAttribute(self, name, value):
|
||
|
r"""setAttribute(GeoFeature self, std::string const & name, std::string const & value)"""
|
||
|
return _geo.GeoFeature_setAttribute(self, name, value)
|
||
|
|
||
|
def attributes(self):
|
||
|
r"""attributes(GeoFeature self) -> Seiscomp::Geo::GeoFeature::Attributes const &"""
|
||
|
return _geo.GeoFeature_attributes(self)
|
||
|
|
||
|
def addVertex(self, *args):
|
||
|
r"""
|
||
|
addVertex(GeoFeature self, GeoCoordinate vertex, bool newSubFeature=False)
|
||
|
addVertex(GeoFeature self, float lat, float lon, bool newSubFeature=False)
|
||
|
"""
|
||
|
return _geo.GeoFeature_addVertex(self, *args)
|
||
|
|
||
|
def closedPolygon(self):
|
||
|
r"""closedPolygon(GeoFeature self) -> bool"""
|
||
|
return _geo.GeoFeature_closedPolygon(self)
|
||
|
|
||
|
def setClosedPolygon(self, closed):
|
||
|
r"""setClosedPolygon(GeoFeature self, bool closed)"""
|
||
|
return _geo.GeoFeature_setClosedPolygon(self, closed)
|
||
|
|
||
|
def updateBoundingBox(self):
|
||
|
r"""updateBoundingBox(GeoFeature self)"""
|
||
|
return _geo.GeoFeature_updateBoundingBox(self)
|
||
|
|
||
|
def invertOrder(self):
|
||
|
r"""invertOrder(GeoFeature self)"""
|
||
|
return _geo.GeoFeature_invertOrder(self)
|
||
|
|
||
|
def sort(self):
|
||
|
r"""sort(GeoFeature self)"""
|
||
|
return _geo.GeoFeature_sort(self)
|
||
|
|
||
|
def setUserData(self, arg2):
|
||
|
r"""setUserData(GeoFeature self, void * arg2)"""
|
||
|
return _geo.GeoFeature_setUserData(self, arg2)
|
||
|
|
||
|
def userData(self):
|
||
|
r"""userData(GeoFeature self) -> void *"""
|
||
|
return _geo.GeoFeature_userData(self)
|
||
|
|
||
|
def vertices(self):
|
||
|
r"""vertices(GeoFeature self) -> Vertices"""
|
||
|
return _geo.GeoFeature_vertices(self)
|
||
|
|
||
|
def bbox(self):
|
||
|
r"""bbox(GeoFeature self) -> GeoBoundingBox"""
|
||
|
return _geo.GeoFeature_bbox(self)
|
||
|
|
||
|
def subFeatures(self):
|
||
|
r"""subFeatures(GeoFeature self) -> Indexes"""
|
||
|
return _geo.GeoFeature_subFeatures(self)
|
||
|
|
||
|
def contains(self, v):
|
||
|
r"""contains(GeoFeature self, GeoCoordinate v) -> bool"""
|
||
|
return _geo.GeoFeature_contains(self, v)
|
||
|
|
||
|
@staticmethod
|
||
|
def area(*args):
|
||
|
r"""
|
||
|
area() -> double
|
||
|
area(GeoCoordinate polygon, size_t sides) -> double
|
||
|
"""
|
||
|
return _geo.GeoFeature_area(*args)
|
||
|
|
||
|
# Register GeoFeature in _geo:
|
||
|
_geo.GeoFeature_swigregister(GeoFeature)
|
||
|
|
||
|
def GeoFeature_area(*args):
|
||
|
r"""
|
||
|
GeoFeature_area() -> double
|
||
|
GeoFeature_area(GeoCoordinate polygon, size_t sides) -> double
|
||
|
"""
|
||
|
return _geo.GeoFeature_area(*args)
|
||
|
|
||
|
class GeoFeatureSetObserver(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSetObserver class."""
|
||
|
|
||
|
thisown = 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__ = _geo.delete_GeoFeatureSetObserver
|
||
|
|
||
|
def geoFeatureSetUpdated(self):
|
||
|
r"""geoFeatureSetUpdated(GeoFeatureSetObserver self)"""
|
||
|
return _geo.GeoFeatureSetObserver_geoFeatureSetUpdated(self)
|
||
|
|
||
|
# Register GeoFeatureSetObserver in _geo:
|
||
|
_geo.GeoFeatureSetObserver_swigregister(GeoFeatureSetObserver)
|
||
|
|
||
|
class GeoFeatureSet(seiscomp.core.BaseObject):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSet class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def __init__(self):
|
||
|
r"""__init__(GeoFeatureSet self) -> GeoFeatureSet"""
|
||
|
_geo.GeoFeatureSet_swiginit(self, _geo.new_GeoFeatureSet())
|
||
|
__swig_destroy__ = _geo.delete_GeoFeatureSet
|
||
|
|
||
|
def registerObserver(self, arg2):
|
||
|
r"""registerObserver(GeoFeatureSet self, GeoFeatureSetObserver arg2) -> bool"""
|
||
|
return _geo.GeoFeatureSet_registerObserver(self, arg2)
|
||
|
|
||
|
def unregisterObserver(self, arg2):
|
||
|
r"""unregisterObserver(GeoFeatureSet self, GeoFeatureSetObserver arg2) -> bool"""
|
||
|
return _geo.GeoFeatureSet_unregisterObserver(self, arg2)
|
||
|
|
||
|
def clear(self):
|
||
|
r"""clear(GeoFeatureSet self)"""
|
||
|
return _geo.GeoFeatureSet_clear(self)
|
||
|
|
||
|
def load(self):
|
||
|
r"""load(GeoFeatureSet self)"""
|
||
|
return _geo.GeoFeatureSet_load(self)
|
||
|
|
||
|
def readBNADir(self, dirPath):
|
||
|
r"""readBNADir(GeoFeatureSet self, std::string const & dirPath) -> size_t"""
|
||
|
return _geo.GeoFeatureSet_readBNADir(self, dirPath)
|
||
|
|
||
|
def readBNAFile(self, filename, category):
|
||
|
r"""readBNAFile(GeoFeatureSet self, std::string const & filename, Category category) -> bool"""
|
||
|
return _geo.GeoFeatureSet_readBNAFile(self, filename, category)
|
||
|
|
||
|
def readDir(self, dirPath):
|
||
|
r"""readDir(GeoFeatureSet self, std::string const & dirPath) -> size_t"""
|
||
|
return _geo.GeoFeatureSet_readDir(self, dirPath)
|
||
|
|
||
|
def readFile(self, filename, category):
|
||
|
r"""readFile(GeoFeatureSet self, std::string const & filename, Category category) -> ssize_t"""
|
||
|
return _geo.GeoFeatureSet_readFile(self, filename, category)
|
||
|
|
||
|
def addFeature(self, feature):
|
||
|
r"""addFeature(GeoFeatureSet self, GeoFeature feature) -> bool"""
|
||
|
return _geo.GeoFeatureSet_addFeature(self, feature)
|
||
|
|
||
|
def features(self):
|
||
|
r"""features(GeoFeatureSet self) -> GeoFeatures"""
|
||
|
return _geo.GeoFeatureSet_features(self)
|
||
|
|
||
|
def categories(self):
|
||
|
r"""categories(GeoFeatureSet self) -> Categories"""
|
||
|
return _geo.GeoFeatureSet_categories(self)
|
||
|
|
||
|
# Register GeoFeatureSet in _geo:
|
||
|
_geo.GeoFeatureSet_swigregister(GeoFeatureSet)
|
||
|
|
||
|
class GeoFeatureSetSingleton(object):
|
||
|
r"""Proxy of C++ Seiscomp::Geo::GeoFeatureSetSingleton class."""
|
||
|
|
||
|
thisown = 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
|
||
|
|
||
|
@staticmethod
|
||
|
def getInstance():
|
||
|
r"""getInstance() -> GeoFeatureSet"""
|
||
|
return _geo.GeoFeatureSetSingleton_getInstance()
|
||
|
__swig_destroy__ = _geo.delete_GeoFeatureSetSingleton
|
||
|
|
||
|
# Register GeoFeatureSetSingleton in _geo:
|
||
|
_geo.GeoFeatureSetSingleton_swigregister(GeoFeatureSetSingleton)
|
||
|
|
||
|
def GeoFeatureSetSingleton_getInstance():
|
||
|
r"""GeoFeatureSetSingleton_getInstance() -> GeoFeatureSet"""
|
||
|
return _geo.GeoFeatureSetSingleton_getInstance()
|
||
|
|
||
|
class Categories(object):
|
||
|
r"""Proxy of C++ std::vector< Seiscomp::Geo::Category * > class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def iterator(self):
|
||
|
r"""iterator(Categories self) -> SwigPyIterator"""
|
||
|
return _geo.Categories_iterator(self)
|
||
|
def __iter__(self):
|
||
|
return self.iterator()
|
||
|
|
||
|
def __nonzero__(self):
|
||
|
r"""__nonzero__(Categories self) -> bool"""
|
||
|
return _geo.Categories___nonzero__(self)
|
||
|
|
||
|
def __bool__(self):
|
||
|
r"""__bool__(Categories self) -> bool"""
|
||
|
return _geo.Categories___bool__(self)
|
||
|
|
||
|
def __len__(self):
|
||
|
r"""__len__(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
|
||
|
return _geo.Categories___len__(self)
|
||
|
|
||
|
def __getslice__(self, i, j):
|
||
|
r"""__getslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j) -> Categories"""
|
||
|
return _geo.Categories___getslice__(self, i, j)
|
||
|
|
||
|
def __setslice__(self, *args):
|
||
|
r"""
|
||
|
__setslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j)
|
||
|
__setslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j, Categories v)
|
||
|
"""
|
||
|
return _geo.Categories___setslice__(self, *args)
|
||
|
|
||
|
def __delslice__(self, i, j):
|
||
|
r"""__delslice__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, std::vector< Seiscomp::Geo::Category * >::difference_type j)"""
|
||
|
return _geo.Categories___delslice__(self, i, j)
|
||
|
|
||
|
def __delitem__(self, *args):
|
||
|
r"""
|
||
|
__delitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i)
|
||
|
__delitem__(Categories self, PySliceObject * slice)
|
||
|
"""
|
||
|
return _geo.Categories___delitem__(self, *args)
|
||
|
|
||
|
def __getitem__(self, *args):
|
||
|
r"""
|
||
|
__getitem__(Categories self, PySliceObject * slice) -> Categories
|
||
|
__getitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i) -> Category
|
||
|
"""
|
||
|
return _geo.Categories___getitem__(self, *args)
|
||
|
|
||
|
def __setitem__(self, *args):
|
||
|
r"""
|
||
|
__setitem__(Categories self, PySliceObject * slice, Categories v)
|
||
|
__setitem__(Categories self, PySliceObject * slice)
|
||
|
__setitem__(Categories self, std::vector< Seiscomp::Geo::Category * >::difference_type i, Category x)
|
||
|
"""
|
||
|
return _geo.Categories___setitem__(self, *args)
|
||
|
|
||
|
def pop(self):
|
||
|
r"""pop(Categories self) -> Category"""
|
||
|
return _geo.Categories_pop(self)
|
||
|
|
||
|
def append(self, x):
|
||
|
r"""append(Categories self, Category x)"""
|
||
|
return _geo.Categories_append(self, x)
|
||
|
|
||
|
def empty(self):
|
||
|
r"""empty(Categories self) -> bool"""
|
||
|
return _geo.Categories_empty(self)
|
||
|
|
||
|
def size(self):
|
||
|
r"""size(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
|
||
|
return _geo.Categories_size(self)
|
||
|
|
||
|
def swap(self, v):
|
||
|
r"""swap(Categories self, Categories v)"""
|
||
|
return _geo.Categories_swap(self, v)
|
||
|
|
||
|
def begin(self):
|
||
|
r"""begin(Categories self) -> std::vector< Seiscomp::Geo::Category * >::iterator"""
|
||
|
return _geo.Categories_begin(self)
|
||
|
|
||
|
def end(self):
|
||
|
r"""end(Categories self) -> std::vector< Seiscomp::Geo::Category * >::iterator"""
|
||
|
return _geo.Categories_end(self)
|
||
|
|
||
|
def rbegin(self):
|
||
|
r"""rbegin(Categories self) -> std::vector< Seiscomp::Geo::Category * >::reverse_iterator"""
|
||
|
return _geo.Categories_rbegin(self)
|
||
|
|
||
|
def rend(self):
|
||
|
r"""rend(Categories self) -> std::vector< Seiscomp::Geo::Category * >::reverse_iterator"""
|
||
|
return _geo.Categories_rend(self)
|
||
|
|
||
|
def clear(self):
|
||
|
r"""clear(Categories self)"""
|
||
|
return _geo.Categories_clear(self)
|
||
|
|
||
|
def get_allocator(self):
|
||
|
r"""get_allocator(Categories self) -> std::vector< Seiscomp::Geo::Category * >::allocator_type"""
|
||
|
return _geo.Categories_get_allocator(self)
|
||
|
|
||
|
def pop_back(self):
|
||
|
r"""pop_back(Categories self)"""
|
||
|
return _geo.Categories_pop_back(self)
|
||
|
|
||
|
def erase(self, *args):
|
||
|
r"""
|
||
|
erase(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos) -> std::vector< Seiscomp::Geo::Category * >::iterator
|
||
|
erase(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator first, std::vector< Seiscomp::Geo::Category * >::iterator last) -> std::vector< Seiscomp::Geo::Category * >::iterator
|
||
|
"""
|
||
|
return _geo.Categories_erase(self, *args)
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(Categories self) -> Categories
|
||
|
__init__(Categories self, Categories other) -> Categories
|
||
|
__init__(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type size) -> Categories
|
||
|
__init__(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type size, Category value) -> Categories
|
||
|
"""
|
||
|
_geo.Categories_swiginit(self, _geo.new_Categories(*args))
|
||
|
|
||
|
def push_back(self, x):
|
||
|
r"""push_back(Categories self, Category x)"""
|
||
|
return _geo.Categories_push_back(self, x)
|
||
|
|
||
|
def front(self):
|
||
|
r"""front(Categories self) -> Category"""
|
||
|
return _geo.Categories_front(self)
|
||
|
|
||
|
def back(self):
|
||
|
r"""back(Categories self) -> Category"""
|
||
|
return _geo.Categories_back(self)
|
||
|
|
||
|
def assign(self, n, x):
|
||
|
r"""assign(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type n, Category x)"""
|
||
|
return _geo.Categories_assign(self, n, x)
|
||
|
|
||
|
def resize(self, *args):
|
||
|
r"""
|
||
|
resize(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type new_size)
|
||
|
resize(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type new_size, Category x)
|
||
|
"""
|
||
|
return _geo.Categories_resize(self, *args)
|
||
|
|
||
|
def insert(self, *args):
|
||
|
r"""
|
||
|
insert(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos, Category x) -> std::vector< Seiscomp::Geo::Category * >::iterator
|
||
|
insert(Categories self, std::vector< Seiscomp::Geo::Category * >::iterator pos, std::vector< Seiscomp::Geo::Category * >::size_type n, Category x)
|
||
|
"""
|
||
|
return _geo.Categories_insert(self, *args)
|
||
|
|
||
|
def reserve(self, n):
|
||
|
r"""reserve(Categories self, std::vector< Seiscomp::Geo::Category * >::size_type n)"""
|
||
|
return _geo.Categories_reserve(self, n)
|
||
|
|
||
|
def capacity(self):
|
||
|
r"""capacity(Categories self) -> std::vector< Seiscomp::Geo::Category * >::size_type"""
|
||
|
return _geo.Categories_capacity(self)
|
||
|
__swig_destroy__ = _geo.delete_Categories
|
||
|
|
||
|
# Register Categories in _geo:
|
||
|
_geo.Categories_swigregister(Categories)
|
||
|
|
||
|
class GeoFeatures(object):
|
||
|
r"""Proxy of C++ std::vector< Seiscomp::Geo::GeoFeature * > class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def iterator(self):
|
||
|
r"""iterator(GeoFeatures self) -> SwigPyIterator"""
|
||
|
return _geo.GeoFeatures_iterator(self)
|
||
|
def __iter__(self):
|
||
|
return self.iterator()
|
||
|
|
||
|
def __nonzero__(self):
|
||
|
r"""__nonzero__(GeoFeatures self) -> bool"""
|
||
|
return _geo.GeoFeatures___nonzero__(self)
|
||
|
|
||
|
def __bool__(self):
|
||
|
r"""__bool__(GeoFeatures self) -> bool"""
|
||
|
return _geo.GeoFeatures___bool__(self)
|
||
|
|
||
|
def __len__(self):
|
||
|
r"""__len__(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
|
||
|
return _geo.GeoFeatures___len__(self)
|
||
|
|
||
|
def __getslice__(self, i, j):
|
||
|
r"""__getslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j) -> GeoFeatures"""
|
||
|
return _geo.GeoFeatures___getslice__(self, i, j)
|
||
|
|
||
|
def __setslice__(self, *args):
|
||
|
r"""
|
||
|
__setslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j)
|
||
|
__setslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j, GeoFeatures v)
|
||
|
"""
|
||
|
return _geo.GeoFeatures___setslice__(self, *args)
|
||
|
|
||
|
def __delslice__(self, i, j):
|
||
|
r"""__delslice__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type j)"""
|
||
|
return _geo.GeoFeatures___delslice__(self, i, j)
|
||
|
|
||
|
def __delitem__(self, *args):
|
||
|
r"""
|
||
|
__delitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i)
|
||
|
__delitem__(GeoFeatures self, PySliceObject * slice)
|
||
|
"""
|
||
|
return _geo.GeoFeatures___delitem__(self, *args)
|
||
|
|
||
|
def __getitem__(self, *args):
|
||
|
r"""
|
||
|
__getitem__(GeoFeatures self, PySliceObject * slice) -> GeoFeatures
|
||
|
__getitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i) -> GeoFeature
|
||
|
"""
|
||
|
return _geo.GeoFeatures___getitem__(self, *args)
|
||
|
|
||
|
def __setitem__(self, *args):
|
||
|
r"""
|
||
|
__setitem__(GeoFeatures self, PySliceObject * slice, GeoFeatures v)
|
||
|
__setitem__(GeoFeatures self, PySliceObject * slice)
|
||
|
__setitem__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::difference_type i, GeoFeature x)
|
||
|
"""
|
||
|
return _geo.GeoFeatures___setitem__(self, *args)
|
||
|
|
||
|
def pop(self):
|
||
|
r"""pop(GeoFeatures self) -> GeoFeature"""
|
||
|
return _geo.GeoFeatures_pop(self)
|
||
|
|
||
|
def append(self, x):
|
||
|
r"""append(GeoFeatures self, GeoFeature x)"""
|
||
|
return _geo.GeoFeatures_append(self, x)
|
||
|
|
||
|
def empty(self):
|
||
|
r"""empty(GeoFeatures self) -> bool"""
|
||
|
return _geo.GeoFeatures_empty(self)
|
||
|
|
||
|
def size(self):
|
||
|
r"""size(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
|
||
|
return _geo.GeoFeatures_size(self)
|
||
|
|
||
|
def swap(self, v):
|
||
|
r"""swap(GeoFeatures self, GeoFeatures v)"""
|
||
|
return _geo.GeoFeatures_swap(self, v)
|
||
|
|
||
|
def begin(self):
|
||
|
r"""begin(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator"""
|
||
|
return _geo.GeoFeatures_begin(self)
|
||
|
|
||
|
def end(self):
|
||
|
r"""end(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator"""
|
||
|
return _geo.GeoFeatures_end(self)
|
||
|
|
||
|
def rbegin(self):
|
||
|
r"""rbegin(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::reverse_iterator"""
|
||
|
return _geo.GeoFeatures_rbegin(self)
|
||
|
|
||
|
def rend(self):
|
||
|
r"""rend(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::reverse_iterator"""
|
||
|
return _geo.GeoFeatures_rend(self)
|
||
|
|
||
|
def clear(self):
|
||
|
r"""clear(GeoFeatures self)"""
|
||
|
return _geo.GeoFeatures_clear(self)
|
||
|
|
||
|
def get_allocator(self):
|
||
|
r"""get_allocator(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::allocator_type"""
|
||
|
return _geo.GeoFeatures_get_allocator(self)
|
||
|
|
||
|
def pop_back(self):
|
||
|
r"""pop_back(GeoFeatures self)"""
|
||
|
return _geo.GeoFeatures_pop_back(self)
|
||
|
|
||
|
def erase(self, *args):
|
||
|
r"""
|
||
|
erase(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
|
||
|
erase(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator first, std::vector< Seiscomp::Geo::GeoFeature * >::iterator last) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
|
||
|
"""
|
||
|
return _geo.GeoFeatures_erase(self, *args)
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(GeoFeatures self) -> GeoFeatures
|
||
|
__init__(GeoFeatures self, GeoFeatures other) -> GeoFeatures
|
||
|
__init__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type size) -> GeoFeatures
|
||
|
__init__(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type size, GeoFeature value) -> GeoFeatures
|
||
|
"""
|
||
|
_geo.GeoFeatures_swiginit(self, _geo.new_GeoFeatures(*args))
|
||
|
|
||
|
def push_back(self, x):
|
||
|
r"""push_back(GeoFeatures self, GeoFeature x)"""
|
||
|
return _geo.GeoFeatures_push_back(self, x)
|
||
|
|
||
|
def front(self):
|
||
|
r"""front(GeoFeatures self) -> GeoFeature"""
|
||
|
return _geo.GeoFeatures_front(self)
|
||
|
|
||
|
def back(self):
|
||
|
r"""back(GeoFeatures self) -> GeoFeature"""
|
||
|
return _geo.GeoFeatures_back(self)
|
||
|
|
||
|
def assign(self, n, x):
|
||
|
r"""assign(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n, GeoFeature x)"""
|
||
|
return _geo.GeoFeatures_assign(self, n, x)
|
||
|
|
||
|
def resize(self, *args):
|
||
|
r"""
|
||
|
resize(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type new_size)
|
||
|
resize(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type new_size, GeoFeature x)
|
||
|
"""
|
||
|
return _geo.GeoFeatures_resize(self, *args)
|
||
|
|
||
|
def insert(self, *args):
|
||
|
r"""
|
||
|
insert(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos, GeoFeature x) -> std::vector< Seiscomp::Geo::GeoFeature * >::iterator
|
||
|
insert(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::iterator pos, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n, GeoFeature x)
|
||
|
"""
|
||
|
return _geo.GeoFeatures_insert(self, *args)
|
||
|
|
||
|
def reserve(self, n):
|
||
|
r"""reserve(GeoFeatures self, std::vector< Seiscomp::Geo::GeoFeature * >::size_type n)"""
|
||
|
return _geo.GeoFeatures_reserve(self, n)
|
||
|
|
||
|
def capacity(self):
|
||
|
r"""capacity(GeoFeatures self) -> std::vector< Seiscomp::Geo::GeoFeature * >::size_type"""
|
||
|
return _geo.GeoFeatures_capacity(self)
|
||
|
__swig_destroy__ = _geo.delete_GeoFeatures
|
||
|
|
||
|
# Register GeoFeatures in _geo:
|
||
|
_geo.GeoFeatures_swigregister(GeoFeatures)
|
||
|
|
||
|
class Vertices(object):
|
||
|
r"""Proxy of C++ std::vector< Seiscomp::Geo::GeoCoordinate > class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def iterator(self):
|
||
|
r"""iterator(Vertices self) -> SwigPyIterator"""
|
||
|
return _geo.Vertices_iterator(self)
|
||
|
def __iter__(self):
|
||
|
return self.iterator()
|
||
|
|
||
|
def __nonzero__(self):
|
||
|
r"""__nonzero__(Vertices self) -> bool"""
|
||
|
return _geo.Vertices___nonzero__(self)
|
||
|
|
||
|
def __bool__(self):
|
||
|
r"""__bool__(Vertices self) -> bool"""
|
||
|
return _geo.Vertices___bool__(self)
|
||
|
|
||
|
def __len__(self):
|
||
|
r"""__len__(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
|
||
|
return _geo.Vertices___len__(self)
|
||
|
|
||
|
def __getslice__(self, i, j):
|
||
|
r"""__getslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j) -> Vertices"""
|
||
|
return _geo.Vertices___getslice__(self, i, j)
|
||
|
|
||
|
def __setslice__(self, *args):
|
||
|
r"""
|
||
|
__setslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j)
|
||
|
__setslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j, Vertices v)
|
||
|
"""
|
||
|
return _geo.Vertices___setslice__(self, *args)
|
||
|
|
||
|
def __delslice__(self, i, j):
|
||
|
r"""__delslice__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type j)"""
|
||
|
return _geo.Vertices___delslice__(self, i, j)
|
||
|
|
||
|
def __delitem__(self, *args):
|
||
|
r"""
|
||
|
__delitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i)
|
||
|
__delitem__(Vertices self, PySliceObject * slice)
|
||
|
"""
|
||
|
return _geo.Vertices___delitem__(self, *args)
|
||
|
|
||
|
def __getitem__(self, *args):
|
||
|
r"""
|
||
|
__getitem__(Vertices self, PySliceObject * slice) -> Vertices
|
||
|
__getitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i) -> GeoCoordinate
|
||
|
"""
|
||
|
return _geo.Vertices___getitem__(self, *args)
|
||
|
|
||
|
def __setitem__(self, *args):
|
||
|
r"""
|
||
|
__setitem__(Vertices self, PySliceObject * slice, Vertices v)
|
||
|
__setitem__(Vertices self, PySliceObject * slice)
|
||
|
__setitem__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::difference_type i, GeoCoordinate x)
|
||
|
"""
|
||
|
return _geo.Vertices___setitem__(self, *args)
|
||
|
|
||
|
def pop(self):
|
||
|
r"""pop(Vertices self) -> GeoCoordinate"""
|
||
|
return _geo.Vertices_pop(self)
|
||
|
|
||
|
def append(self, x):
|
||
|
r"""append(Vertices self, GeoCoordinate x)"""
|
||
|
return _geo.Vertices_append(self, x)
|
||
|
|
||
|
def empty(self):
|
||
|
r"""empty(Vertices self) -> bool"""
|
||
|
return _geo.Vertices_empty(self)
|
||
|
|
||
|
def size(self):
|
||
|
r"""size(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
|
||
|
return _geo.Vertices_size(self)
|
||
|
|
||
|
def swap(self, v):
|
||
|
r"""swap(Vertices self, Vertices v)"""
|
||
|
return _geo.Vertices_swap(self, v)
|
||
|
|
||
|
def begin(self):
|
||
|
r"""begin(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator"""
|
||
|
return _geo.Vertices_begin(self)
|
||
|
|
||
|
def end(self):
|
||
|
r"""end(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator"""
|
||
|
return _geo.Vertices_end(self)
|
||
|
|
||
|
def rbegin(self):
|
||
|
r"""rbegin(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::reverse_iterator"""
|
||
|
return _geo.Vertices_rbegin(self)
|
||
|
|
||
|
def rend(self):
|
||
|
r"""rend(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::reverse_iterator"""
|
||
|
return _geo.Vertices_rend(self)
|
||
|
|
||
|
def clear(self):
|
||
|
r"""clear(Vertices self)"""
|
||
|
return _geo.Vertices_clear(self)
|
||
|
|
||
|
def get_allocator(self):
|
||
|
r"""get_allocator(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::allocator_type"""
|
||
|
return _geo.Vertices_get_allocator(self)
|
||
|
|
||
|
def pop_back(self):
|
||
|
r"""pop_back(Vertices self)"""
|
||
|
return _geo.Vertices_pop_back(self)
|
||
|
|
||
|
def erase(self, *args):
|
||
|
r"""
|
||
|
erase(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
|
||
|
erase(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator first, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator last) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
|
||
|
"""
|
||
|
return _geo.Vertices_erase(self, *args)
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(Vertices self) -> Vertices
|
||
|
__init__(Vertices self, Vertices other) -> Vertices
|
||
|
__init__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type size) -> Vertices
|
||
|
__init__(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type size, GeoCoordinate value) -> Vertices
|
||
|
"""
|
||
|
_geo.Vertices_swiginit(self, _geo.new_Vertices(*args))
|
||
|
|
||
|
def push_back(self, x):
|
||
|
r"""push_back(Vertices self, GeoCoordinate x)"""
|
||
|
return _geo.Vertices_push_back(self, x)
|
||
|
|
||
|
def front(self):
|
||
|
r"""front(Vertices self) -> GeoCoordinate"""
|
||
|
return _geo.Vertices_front(self)
|
||
|
|
||
|
def back(self):
|
||
|
r"""back(Vertices self) -> GeoCoordinate"""
|
||
|
return _geo.Vertices_back(self)
|
||
|
|
||
|
def assign(self, n, x):
|
||
|
r"""assign(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n, GeoCoordinate x)"""
|
||
|
return _geo.Vertices_assign(self, n, x)
|
||
|
|
||
|
def resize(self, *args):
|
||
|
r"""
|
||
|
resize(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type new_size)
|
||
|
resize(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type new_size, GeoCoordinate x)
|
||
|
"""
|
||
|
return _geo.Vertices_resize(self, *args)
|
||
|
|
||
|
def insert(self, *args):
|
||
|
r"""
|
||
|
insert(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos, GeoCoordinate x) -> std::vector< Seiscomp::Geo::GeoCoordinate >::iterator
|
||
|
insert(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::iterator pos, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n, GeoCoordinate x)
|
||
|
"""
|
||
|
return _geo.Vertices_insert(self, *args)
|
||
|
|
||
|
def reserve(self, n):
|
||
|
r"""reserve(Vertices self, std::vector< Seiscomp::Geo::GeoCoordinate >::size_type n)"""
|
||
|
return _geo.Vertices_reserve(self, n)
|
||
|
|
||
|
def capacity(self):
|
||
|
r"""capacity(Vertices self) -> std::vector< Seiscomp::Geo::GeoCoordinate >::size_type"""
|
||
|
return _geo.Vertices_capacity(self)
|
||
|
__swig_destroy__ = _geo.delete_Vertices
|
||
|
|
||
|
# Register Vertices in _geo:
|
||
|
_geo.Vertices_swigregister(Vertices)
|
||
|
|
||
|
class Indexes(object):
|
||
|
r"""Proxy of C++ std::vector< size_t > class."""
|
||
|
|
||
|
thisown = property(lambda x: x.this.own(), lambda x, v: x.this.own(v), doc="The membership flag")
|
||
|
__repr__ = _swig_repr
|
||
|
|
||
|
def iterator(self):
|
||
|
r"""iterator(Indexes self) -> SwigPyIterator"""
|
||
|
return _geo.Indexes_iterator(self)
|
||
|
def __iter__(self):
|
||
|
return self.iterator()
|
||
|
|
||
|
def __nonzero__(self):
|
||
|
r"""__nonzero__(Indexes self) -> bool"""
|
||
|
return _geo.Indexes___nonzero__(self)
|
||
|
|
||
|
def __bool__(self):
|
||
|
r"""__bool__(Indexes self) -> bool"""
|
||
|
return _geo.Indexes___bool__(self)
|
||
|
|
||
|
def __len__(self):
|
||
|
r"""__len__(Indexes self) -> std::vector< size_t >::size_type"""
|
||
|
return _geo.Indexes___len__(self)
|
||
|
|
||
|
def __getslice__(self, i, j):
|
||
|
r"""__getslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j) -> Indexes"""
|
||
|
return _geo.Indexes___getslice__(self, i, j)
|
||
|
|
||
|
def __setslice__(self, *args):
|
||
|
r"""
|
||
|
__setslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)
|
||
|
__setslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j, Indexes v)
|
||
|
"""
|
||
|
return _geo.Indexes___setslice__(self, *args)
|
||
|
|
||
|
def __delslice__(self, i, j):
|
||
|
r"""__delslice__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::difference_type j)"""
|
||
|
return _geo.Indexes___delslice__(self, i, j)
|
||
|
|
||
|
def __delitem__(self, *args):
|
||
|
r"""
|
||
|
__delitem__(Indexes self, std::vector< size_t >::difference_type i)
|
||
|
__delitem__(Indexes self, PySliceObject * slice)
|
||
|
"""
|
||
|
return _geo.Indexes___delitem__(self, *args)
|
||
|
|
||
|
def __getitem__(self, *args):
|
||
|
r"""
|
||
|
__getitem__(Indexes self, PySliceObject * slice) -> Indexes
|
||
|
__getitem__(Indexes self, std::vector< size_t >::difference_type i) -> std::vector< size_t >::value_type const &
|
||
|
"""
|
||
|
return _geo.Indexes___getitem__(self, *args)
|
||
|
|
||
|
def __setitem__(self, *args):
|
||
|
r"""
|
||
|
__setitem__(Indexes self, PySliceObject * slice, Indexes v)
|
||
|
__setitem__(Indexes self, PySliceObject * slice)
|
||
|
__setitem__(Indexes self, std::vector< size_t >::difference_type i, std::vector< size_t >::value_type const & x)
|
||
|
"""
|
||
|
return _geo.Indexes___setitem__(self, *args)
|
||
|
|
||
|
def pop(self):
|
||
|
r"""pop(Indexes self) -> std::vector< size_t >::value_type"""
|
||
|
return _geo.Indexes_pop(self)
|
||
|
|
||
|
def append(self, x):
|
||
|
r"""append(Indexes self, std::vector< size_t >::value_type const & x)"""
|
||
|
return _geo.Indexes_append(self, x)
|
||
|
|
||
|
def empty(self):
|
||
|
r"""empty(Indexes self) -> bool"""
|
||
|
return _geo.Indexes_empty(self)
|
||
|
|
||
|
def size(self):
|
||
|
r"""size(Indexes self) -> std::vector< size_t >::size_type"""
|
||
|
return _geo.Indexes_size(self)
|
||
|
|
||
|
def swap(self, v):
|
||
|
r"""swap(Indexes self, Indexes v)"""
|
||
|
return _geo.Indexes_swap(self, v)
|
||
|
|
||
|
def begin(self):
|
||
|
r"""begin(Indexes self) -> std::vector< size_t >::iterator"""
|
||
|
return _geo.Indexes_begin(self)
|
||
|
|
||
|
def end(self):
|
||
|
r"""end(Indexes self) -> std::vector< size_t >::iterator"""
|
||
|
return _geo.Indexes_end(self)
|
||
|
|
||
|
def rbegin(self):
|
||
|
r"""rbegin(Indexes self) -> std::vector< size_t >::reverse_iterator"""
|
||
|
return _geo.Indexes_rbegin(self)
|
||
|
|
||
|
def rend(self):
|
||
|
r"""rend(Indexes self) -> std::vector< size_t >::reverse_iterator"""
|
||
|
return _geo.Indexes_rend(self)
|
||
|
|
||
|
def clear(self):
|
||
|
r"""clear(Indexes self)"""
|
||
|
return _geo.Indexes_clear(self)
|
||
|
|
||
|
def get_allocator(self):
|
||
|
r"""get_allocator(Indexes self) -> std::vector< size_t >::allocator_type"""
|
||
|
return _geo.Indexes_get_allocator(self)
|
||
|
|
||
|
def pop_back(self):
|
||
|
r"""pop_back(Indexes self)"""
|
||
|
return _geo.Indexes_pop_back(self)
|
||
|
|
||
|
def erase(self, *args):
|
||
|
r"""
|
||
|
erase(Indexes self, std::vector< size_t >::iterator pos) -> std::vector< size_t >::iterator
|
||
|
erase(Indexes self, std::vector< size_t >::iterator first, std::vector< size_t >::iterator last) -> std::vector< size_t >::iterator
|
||
|
"""
|
||
|
return _geo.Indexes_erase(self, *args)
|
||
|
|
||
|
def __init__(self, *args):
|
||
|
r"""
|
||
|
__init__(Indexes self) -> Indexes
|
||
|
__init__(Indexes self, Indexes other) -> Indexes
|
||
|
__init__(Indexes self, std::vector< size_t >::size_type size) -> Indexes
|
||
|
__init__(Indexes self, std::vector< size_t >::size_type size, std::vector< size_t >::value_type const & value) -> Indexes
|
||
|
"""
|
||
|
_geo.Indexes_swiginit(self, _geo.new_Indexes(*args))
|
||
|
|
||
|
def push_back(self, x):
|
||
|
r"""push_back(Indexes self, std::vector< size_t >::value_type const & x)"""
|
||
|
return _geo.Indexes_push_back(self, x)
|
||
|
|
||
|
def front(self):
|
||
|
r"""front(Indexes self) -> std::vector< size_t >::value_type const &"""
|
||
|
return _geo.Indexes_front(self)
|
||
|
|
||
|
def back(self):
|
||
|
r"""back(Indexes self) -> std::vector< size_t >::value_type const &"""
|
||
|
return _geo.Indexes_back(self)
|
||
|
|
||
|
def assign(self, n, x):
|
||
|
r"""assign(Indexes self, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)"""
|
||
|
return _geo.Indexes_assign(self, n, x)
|
||
|
|
||
|
def resize(self, *args):
|
||
|
r"""
|
||
|
resize(Indexes self, std::vector< size_t >::size_type new_size)
|
||
|
resize(Indexes self, std::vector< size_t >::size_type new_size, std::vector< size_t >::value_type const & x)
|
||
|
"""
|
||
|
return _geo.Indexes_resize(self, *args)
|
||
|
|
||
|
def insert(self, *args):
|
||
|
r"""
|
||
|
insert(Indexes self, std::vector< size_t >::iterator pos, std::vector< size_t >::value_type const & x) -> std::vector< size_t >::iterator
|
||
|
insert(Indexes self, std::vector< size_t >::iterator pos, std::vector< size_t >::size_type n, std::vector< size_t >::value_type const & x)
|
||
|
"""
|
||
|
return _geo.Indexes_insert(self, *args)
|
||
|
|
||
|
def reserve(self, n):
|
||
|
r"""reserve(Indexes self, std::vector< size_t >::size_type n)"""
|
||
|
return _geo.Indexes_reserve(self, n)
|
||
|
|
||
|
def capacity(self):
|
||
|
r"""capacity(Indexes self) -> std::vector< size_t >::size_type"""
|
||
|
return _geo.Indexes_capacity(self)
|
||
|
__swig_destroy__ = _geo.delete_Indexes
|
||
|
|
||
|
# Register Indexes in _geo:
|
||
|
_geo.Indexes_swigregister(Indexes)
|
||
|
|
||
|
|
||
|
|