def open(
self,
mode=None,
layer=1,
overwrite=None,
with_z=None,
# parameters valid only if mode == 'w'
tab_name='',
tab_cols=None,
link_name=None,
link_key='cat',
link_db='$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db',
link_driver='sqlite'):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and mode != 'w':
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if mode not in ('r', 'rw', 'w'):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and mode in ('r', 'rw'):
# open in READ mode
if mode == 'r':
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif mode == 'rw':
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if mode == 'w':
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if tab_cols:
# create a link
link = Link(layer, link_name if link_name else self.name,
tab_name if tab_name else self.name, link_key,
link_db, link_driver)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
self.layer = self.dblinks.by_layer(layer).layer
self.table = self.dblinks.by_layer(layer).table()
self.n_lines = self.table.n_rows()
self.writable = self.mapset == functions.getenv("MAPSET")
self.find = {
'by_point': PointFinder(self.c_mapinfo, self.table, self.writable),
'by_box': BboxFinder(self.c_mapinfo, self.table, self.writable),
'by_polygon': PolygonFinder(self.c_mapinfo, self.table,
self.writable),
}
class Info(object):
"""Basic vector info.
To get access to the vector info the map must be opened. ::
>>> cens = Info('census')
>>> cens.open(mode='r')
Then it is possible to read and write the following map attributes: ::
>>> cens.organization
'NC OneMap'
>>> cens.person
'hmitaso'
>>> cens.title
'Wake County census blocks with attributes, clipped (polygon map)'
>>> cens.map_date
datetime.datetime(2007, 3, 19, 22, 1, 37)
>>> cens.date
''
>>> cens.scale
1
>>> cens.comment
''
>>> cens.comment = "One useful comment!"
>>> cens.comment
'One useful comment!'
>>> cens.zone
0
>>> cens.proj
99
There are some read only attributes: ::
>>> cens.full_name
'census@PERMANENT'
>>> cens.proj_name
'Lambert Conformal Conic'
>>> cens.maptype
'native'
And some basic methods: ::
>>> cens.is_3D()
False
>>> cens.exist()
True
>>> cens.is_open()
True
>>> cens.close()
"""
def __init__(self, name, mapset='', *aopen, **kwopen):
self._name = ''
self._mapset = ''
# Set map name and mapset
self.name = name
self.mapset = mapset
self._aopen = aopen
self._kwopen = kwopen
self.c_mapinfo = ctypes.pointer(libvect.Map_info())
self._topo_level = 1
self._class_name = 'Vector'
self.overwrite = False
self.date_fmt = '%a %b %d %H:%M:%S %Y'
def __enter__(self):
self.open(*self._aopen, **self._kwopen)
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def _get_name(self):
"""Private method to obtain the Vector name"""
return self._name
def _set_name(self, newname):
"""Private method to change the Vector name"""
if not functions.is_clean_name(newname):
str_err = _("Map name {0} not valid")
raise ValueError(str_err.format(newname))
if self.exist():
self.rename(newname)
self._name = newname
name = property(fget=_get_name,
fset=_set_name,
doc="Set or obtain the Vector name")
def _get_mapset(self):
"""Private method to obtain the Vector mapset"""
return self._mapset
def _set_mapset(self, mapset):
"""Private method to change the Vector mapset"""
if mapset:
self._mapset = mapset
mapset = property(fget=_get_mapset,
fset=_set_mapset,
doc="Set or obtain the Vector mapset")
def _get_organization(self):
"""Private method to obtain the Vector organization"""
return libvect.Vect_get_organization(self.c_mapinfo)
def _set_organization(self, org):
"""Private method to change the Vector organization"""
libvect.Vect_set_organization(self.c_mapinfo, ctypes.c_char_p(org))
organization = property(fget=_get_organization,
fset=_set_organization,
doc="Set or obtain the Vector organization")
def _get_date(self):
"""Private method to obtain the Vector date"""
return libvect.Vect_get_date(self.c_mapinfo)
def _set_date(self, date):
"""Private method to change the Vector date"""
return libvect.Vect_set_date(self.c_mapinfo, ctypes.c_char_p(date))
date = property(fget=_get_date,
fset=_set_date,
doc="Set or obtain the Vector date")
def _get_person(self):
"""Private method to obtain the Vector person"""
return libvect.Vect_get_person(self.c_mapinfo)
def _set_person(self, person):
"""Private method to change the Vector person"""
libvect.Vect_set_person(self.c_mapinfo, ctypes.c_char_p(person))
person = property(fget=_get_person,
fset=_set_person,
doc="Set or obtain the Vector author")
def _get_title(self):
"""Private method to obtain the Vector title"""
return libvect.Vect_get_map_name(self.c_mapinfo)
def _set_title(self, title):
"""Private method to change the Vector title"""
libvect.Vect_set_map_name(self.c_mapinfo, ctypes.c_char_p(title))
title = property(fget=_get_title,
fset=_set_title,
doc="Set or obtain the Vector title")
def _get_map_date(self):
"""Private method to obtain the Vector map date"""
date_str = libvect.Vect_get_map_date(self.c_mapinfo)
return datetime.datetime.strptime(date_str, self.date_fmt)
def _set_map_date(self, datetimeobj):
"""Private method to change the Vector map date"""
date_str = datetimeobj.strftime(self.date_fmt)
libvect.Vect_set_map_date(self.c_mapinfo, ctypes.c_char_p(date_str))
map_date = property(fget=_get_map_date,
fset=_set_map_date,
doc="Set or obtain the Vector map date")
def _get_scale(self):
"""Private method to obtain the Vector scale"""
return libvect.Vect_get_scale(self.c_mapinfo)
def _set_scale(self, scale):
"""Private method to set the Vector scale"""
return libvect.Vect_set_scale(self.c_mapinfo, ctypes.c_int(scale))
scale = property(fget=_get_scale,
fset=_set_scale,
doc="Set or obtain the Vector scale")
def _get_comment(self):
"""Private method to obtain the Vector comment"""
return libvect.Vect_get_comment(self.c_mapinfo)
def _set_comment(self, comm):
"""Private method to set the Vector comment"""
return libvect.Vect_set_comment(self.c_mapinfo, ctypes.c_char_p(comm))
comment = property(fget=_get_comment,
fset=_set_comment,
doc="Set or obtain the Vector comment")
def _get_zone(self):
"""Private method to obtain the Vector projection zone"""
return libvect.Vect_get_zone(self.c_mapinfo)
def _set_zone(self, zone):
"""Private method to set the Vector projection zone"""
return libvect.Vect_set_zone(self.c_mapinfo, ctypes.c_int(zone))
zone = property(fget=_get_zone,
fset=_set_zone,
doc="Set or obtain the Vector projection zone")
def _get_proj(self):
"""Private method to obtain the Vector projection code"""
return libvect.Vect_get_proj(self.c_mapinfo)
def _set_proj(self, proj):
"""Private method to set the Vector projection code"""
libvect.Vect_set_proj(self.c_mapinfo, ctypes.c_int(proj))
proj = property(fget=_get_proj,
fset=_set_proj,
doc="Set or obtain the Vector projection code")
def _get_thresh(self):
"""Private method to obtain the Vector threshold"""
return libvect.Vect_get_thresh(self.c_mapinfo)
def _set_thresh(self, thresh):
"""Private method to set the Vector threshold"""
return libvect.Vect_set_thresh(self.c_mapinfo, ctypes.c_double(thresh))
thresh = property(fget=_get_thresh,
fset=_set_thresh,
doc="Set or obtain the Vector threshold")
@property
@must_be_open
def full_name(self):
"""Return the full name of Vector"""
return libvect.Vect_get_full_name(self.c_mapinfo)
@property
@must_be_open
def maptype(self):
"""Return the map type of Vector"""
return MAPTYPE[libvect.Vect_maptype(self.c_mapinfo)]
@property
@must_be_open
def proj_name(self):
"""Return the project name of Vector"""
return libvect.Vect_get_proj_name(self.c_mapinfo)
def write_header(self):
"""Save the change in the C struct permanently to disk."""
libvect.Vect_write_header(self.c_mapinfo)
def rename(self, newname):
"""Method to rename the Vector map
:param newname: the new name for the Vector map
:type newname: str
"""
if self.exist():
if not self.is_open():
functions.rename(self.name, newname, 'vect')
else:
raise GrassError("The map is open, not able to renamed it.")
self._name = newname
def is_3D(self):
"""Return if the Vector is 3D"""
return bool(libvect.Vect_is_3d(self.c_mapinfo))
def exist(self):
"""Return if the Vector exists or not"""
if self.name:
if self.mapset == '':
mapset = functions.get_mapset_vector(self.name, self.mapset)
self.mapset = mapset if mapset else ''
return True if mapset else False
return bool(functions.get_mapset_vector(self.name, self.mapset))
else:
return False
def is_open(self):
"""Return if the Vector is open"""
return is_open(self.c_mapinfo)
def open(
self,
mode=None,
layer=1,
overwrite=None,
with_z=None,
# parameters valid only if mode == 'w'
tab_name='',
tab_cols=None,
link_name=None,
link_key='cat',
link_db='$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db',
link_driver='sqlite'):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and mode != 'w':
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if mode not in ('r', 'rw', 'w'):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and mode in ('r', 'rw'):
# open in READ mode
if mode == 'r':
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif mode == 'rw':
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if mode == 'w':
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if tab_cols:
# create a link
link = Link(layer, link_name if link_name else self.name,
tab_name if tab_name else self.name, link_key,
link_db, link_driver)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
self.layer = self.dblinks.by_layer(layer).layer
self.table = self.dblinks.by_layer(layer).table()
self.n_lines = self.table.n_rows()
self.writable = self.mapset == functions.getenv("MAPSET")
self.find = {
'by_point': PointFinder(self.c_mapinfo, self.table, self.writable),
'by_box': BboxFinder(self.c_mapinfo, self.table, self.writable),
'by_polygon': PolygonFinder(self.c_mapinfo, self.table,
self.writable),
}
def close(self, build=False):
"""Method to close the Vector
:param build: True if the vector map should be build before close it
:type build: bool
"""
if hasattr(self, 'table') and self.table is not None:
self.table.conn.close()
if self.is_open():
if libvect.Vect_close(self.c_mapinfo) != 0:
str_err = 'Error when trying to close the map with Vect_close'
raise GrassError(str_err)
if ((self.c_mapinfo.contents.mode == libvect.GV_MODE_RW
or self.c_mapinfo.contents.mode == libvect.GV_MODE_WRITE)
and build):
self.build()
def remove(self):
"""Remove vector map"""
if self.is_open():
self.close()
functions.remove(self.name, 'vect')
def build(self):
"""Close the vector map and build vector Topology"""
self.close()
libvect.Vect_set_open_level(1)
if libvect.Vect_open_old2(self.c_mapinfo, self.name, self.mapset,
'0') != 1:
str_err = 'Error when trying to open the vector map.'
raise GrassError(str_err)
# Vect_build returns 1 on success and 0 on error (bool approach)
if libvect.Vect_build(self.c_mapinfo) != 1:
str_err = 'Error when trying build topology with Vect_build'
raise GrassError(str_err)
libvect.Vect_close(self.c_mapinfo)
def open(self, mode=None, layer=1, overwrite=None, with_z=None,
# parameters valid only if mode == 'w'
tab_name='', tab_cols=None, link_name=None, link_key='cat',
link_db='$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db',
link_driver='sqlite'):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and mode != 'w':
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if mode not in ('r', 'rw', 'w'):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and mode in ('r', 'rw'):
# open in READ mode
if mode == 'r':
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif mode == 'rw':
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if mode == 'w':
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if tab_cols:
# create a link
link = Link(layer,
link_name if link_name else self.name,
tab_name if tab_name else self.name,
link_key, link_db, link_driver)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
self.layer = self.dblinks.by_layer(layer).layer
self.table = self.dblinks.by_layer(layer).table()
self.n_lines = self.table.n_rows()
self.writable = self.mapset == functions.getenv("MAPSET")
self.find = {'by_point': PointFinder(self.c_mapinfo, self.table,
self.writable),
'by_box': BboxFinder(self.c_mapinfo, self.table,
self.writable),
'by_polygon': PolygonFinder(self.c_mapinfo, self.table,
self.writable), }
class Info(object):
"""Basic vector info.
To get access to the vector info the map must be opened. ::
>>> cens = Info('census')
>>> cens.open(mode='r')
Then it is possible to read and write the following map attributes: ::
>>> cens.organization
'NC OneMap'
>>> cens.person
'hmitaso'
>>> cens.title
'Wake County census blocks with attributes, clipped (polygon map)'
>>> cens.map_date
datetime.datetime(2007, 3, 19, 22, 1, 37)
>>> cens.date
''
>>> cens.scale
1
>>> cens.comment
''
>>> cens.comment = "One useful comment!"
>>> cens.comment
'One useful comment!'
>>> cens.zone
0
>>> cens.proj
99
There are some read only attributes: ::
>>> cens.full_name
'census@PERMANENT'
>>> cens.proj_name
'Lambert Conformal Conic'
>>> cens.maptype
'native'
And some basic methods: ::
>>> cens.is_3D()
False
>>> cens.exist()
True
>>> cens.is_open()
True
>>> cens.close()
"""
def __init__(self, name, mapset='', *aopen, **kwopen):
self._name = ''
self._mapset = ''
# Set map name and mapset
self.name = name
self.mapset = mapset
self._aopen = aopen
self._kwopen = kwopen
self.c_mapinfo = ctypes.pointer(libvect.Map_info())
self._topo_level = 1
self._class_name = 'Vector'
self.overwrite = False
self.date_fmt = '%a %b %d %H:%M:%S %Y'
def __enter__(self):
self.open(*self._aopen, **self._kwopen)
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def _get_name(self):
"""Private method to obtain the Vector name"""
return self._name
def _set_name(self, newname):
"""Private method to change the Vector name"""
if not functions.is_clean_name(newname):
str_err = _("Map name {0} not valid")
raise ValueError(str_err.format(newname))
if self.exist():
self.rename(newname)
self._name = newname
name = property(fget=_get_name, fset=_set_name,
doc="Set or obtain the Vector name")
def _get_mapset(self):
"""Private method to obtain the Vector mapset"""
return self._mapset
def _set_mapset(self, mapset):
"""Private method to change the Vector mapset"""
if mapset:
self._mapset = mapset
mapset = property(fget=_get_mapset, fset=_set_mapset,
doc="Set or obtain the Vector mapset")
def _get_organization(self):
"""Private method to obtain the Vector organization"""
return libvect.Vect_get_organization(self.c_mapinfo)
def _set_organization(self, org):
"""Private method to change the Vector organization"""
libvect.Vect_set_organization(self.c_mapinfo, ctypes.c_char_p(org))
organization = property(fget=_get_organization, fset=_set_organization,
doc="Set or obtain the Vector organization")
def _get_date(self):
"""Private method to obtain the Vector date"""
return libvect.Vect_get_date(self.c_mapinfo)
def _set_date(self, date):
"""Private method to change the Vector date"""
return libvect.Vect_set_date(self.c_mapinfo, ctypes.c_char_p(date))
date = property(fget=_get_date, fset=_set_date,
doc="Set or obtain the Vector date")
def _get_person(self):
"""Private method to obtain the Vector person"""
return libvect.Vect_get_person(self.c_mapinfo)
def _set_person(self, person):
"""Private method to change the Vector person"""
libvect.Vect_set_person(self.c_mapinfo, ctypes.c_char_p(person))
person = property(fget=_get_person, fset=_set_person,
doc="Set or obtain the Vector author")
def _get_title(self):
"""Private method to obtain the Vector title"""
return libvect.Vect_get_map_name(self.c_mapinfo)
def _set_title(self, title):
"""Private method to change the Vector title"""
libvect.Vect_set_map_name(self.c_mapinfo, ctypes.c_char_p(title))
title = property(fget=_get_title, fset=_set_title,
doc="Set or obtain the Vector title")
def _get_map_date(self):
"""Private method to obtain the Vector map date"""
date_str = libvect.Vect_get_map_date(self.c_mapinfo)
return datetime.datetime.strptime(date_str, self.date_fmt)
def _set_map_date(self, datetimeobj):
"""Private method to change the Vector map date"""
date_str = datetimeobj.strftime(self.date_fmt)
libvect.Vect_set_map_date(self.c_mapinfo, ctypes.c_char_p(date_str))
map_date = property(fget=_get_map_date, fset=_set_map_date,
doc="Set or obtain the Vector map date")
def _get_scale(self):
"""Private method to obtain the Vector scale"""
return libvect.Vect_get_scale(self.c_mapinfo)
def _set_scale(self, scale):
"""Private method to set the Vector scale"""
return libvect.Vect_set_scale(self.c_mapinfo, ctypes.c_int(scale))
scale = property(fget=_get_scale, fset=_set_scale,
doc="Set or obtain the Vector scale")
def _get_comment(self):
"""Private method to obtain the Vector comment"""
return libvect.Vect_get_comment(self.c_mapinfo)
def _set_comment(self, comm):
"""Private method to set the Vector comment"""
return libvect.Vect_set_comment(self.c_mapinfo, ctypes.c_char_p(comm))
comment = property(fget=_get_comment, fset=_set_comment,
doc="Set or obtain the Vector comment")
def _get_zone(self):
"""Private method to obtain the Vector projection zone"""
return libvect.Vect_get_zone(self.c_mapinfo)
def _set_zone(self, zone):
"""Private method to set the Vector projection zone"""
return libvect.Vect_set_zone(self.c_mapinfo, ctypes.c_int(zone))
zone = property(fget=_get_zone, fset=_set_zone,
doc="Set or obtain the Vector projection zone")
def _get_proj(self):
"""Private method to obtain the Vector projection code"""
return libvect.Vect_get_proj(self.c_mapinfo)
def _set_proj(self, proj):
"""Private method to set the Vector projection code"""
libvect.Vect_set_proj(self.c_mapinfo, ctypes.c_int(proj))
proj = property(fget=_get_proj, fset=_set_proj,
doc="Set or obtain the Vector projection code")
def _get_thresh(self):
"""Private method to obtain the Vector threshold"""
return libvect.Vect_get_thresh(self.c_mapinfo)
def _set_thresh(self, thresh):
"""Private method to set the Vector threshold"""
return libvect.Vect_set_thresh(self.c_mapinfo, ctypes.c_double(thresh))
thresh = property(fget=_get_thresh, fset=_set_thresh,
doc="Set or obtain the Vector threshold")
@property
@must_be_open
def full_name(self):
"""Return the full name of Vector"""
return libvect.Vect_get_full_name(self.c_mapinfo)
@property
@must_be_open
def maptype(self):
"""Return the map type of Vector"""
return MAPTYPE[libvect.Vect_maptype(self.c_mapinfo)]
@property
@must_be_open
def proj_name(self):
"""Return the project name of Vector"""
return libvect.Vect_get_proj_name(self.c_mapinfo)
def write_header(self):
"""Save the change in the C struct permanently to disk."""
libvect.Vect_write_header(self.c_mapinfo)
def rename(self, newname):
"""Method to rename the Vector map
:param newname: the new name for the Vector map
:type newname: str
"""
if self.exist():
if not self.is_open():
functions.rename(self.name, newname, 'vect')
else:
raise GrassError("The map is open, not able to renamed it.")
self._name = newname
def is_3D(self):
"""Return if the Vector is 3D"""
return bool(libvect.Vect_is_3d(self.c_mapinfo))
def exist(self):
"""Return if the Vector exists or not"""
if self.name:
if self.mapset == '':
mapset = functions.get_mapset_vector(self.name, self.mapset)
self.mapset = mapset if mapset else ''
return True if mapset else False
return bool(functions.get_mapset_vector(self.name, self.mapset))
else:
return False
def is_open(self):
"""Return if the Vector is open"""
return is_open(self.c_mapinfo)
def open(self, mode=None, layer=1, overwrite=None, with_z=None,
# parameters valid only if mode == 'w'
tab_name='', tab_cols=None, link_name=None, link_key='cat',
link_db='$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db',
link_driver='sqlite'):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and mode != 'w':
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if mode not in ('r', 'rw', 'w'):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and mode in ('r', 'rw'):
# open in READ mode
if mode == 'r':
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif mode == 'rw':
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if mode == 'w':
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if tab_cols:
# create a link
link = Link(layer,
link_name if link_name else self.name,
tab_name if tab_name else self.name,
link_key, link_db, link_driver)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
self.layer = self.dblinks.by_layer(layer).layer
self.table = self.dblinks.by_layer(layer).table()
self.n_lines = self.table.n_rows()
self.writable = self.mapset == functions.getenv("MAPSET")
self.find = {'by_point': PointFinder(self.c_mapinfo, self.table,
self.writable),
'by_box': BboxFinder(self.c_mapinfo, self.table,
self.writable),
'by_polygon': PolygonFinder(self.c_mapinfo, self.table,
self.writable), }
def close(self, build=False):
"""Method to close the Vector
:param build: True if the vector map should be build before close it
:type build: bool
"""
if hasattr(self, 'table') and self.table is not None:
self.table.conn.close()
if self.is_open():
if libvect.Vect_close(self.c_mapinfo) != 0:
str_err = 'Error when trying to close the map with Vect_close'
raise GrassError(str_err)
if ((self.c_mapinfo.contents.mode == libvect.GV_MODE_RW or
self.c_mapinfo.contents.mode == libvect.GV_MODE_WRITE) and
build):
self.build()
def remove(self):
"""Remove vector map"""
if self.is_open():
self.close()
functions.remove(self.name, 'vect')
def build(self):
"""Close the vector map and build vector Topology"""
self.close()
libvect.Vect_set_open_level(1)
if libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, '0') != 1:
str_err = 'Error when trying to open the vector map.'
raise GrassError(str_err)
# Vect_build returns 1 on success and 0 on error (bool approach)
if libvect.Vect_build(self.c_mapinfo) != 1:
str_err = 'Error when trying build topology with Vect_build'
raise GrassError(str_err)
libvect.Vect_close(self.c_mapinfo)
def open(
self,
mode=None,
layer=1,
overwrite=None,
with_z=None,
# parameters valid only if mode == 'w'
tab_name="",
tab_cols=None,
link_name=None,
link_key="cat",
link_db="$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db",
link_driver="sqlite",
):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
self.mode = mode if mode else self.mode
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and self.mode != "w":
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if self.mode not in ("r", "rw", "w"):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and self.mode in ("r", "rw"):
# open in READ mode
if self.mode == "r":
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif self.mode == "rw":
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if self.mode == "w":
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if self.mode in ("w", "rw") and tab_cols:
# create a link
link = Link(
layer,
link_name if link_name else self.name,
tab_name if tab_name else self.name,
link_key,
link_db,
link_driver,
)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols, overwrite=overwrite)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
# Load attribute table for selected layer.
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
layer_db_link = self.dblinks.by_layer(layer)
if not layer_db_link:
raise LookupError(
"There appears to be no database link for layer %d of <%s>."
% (layer, self.name))
if layer_db_link.layer != layer:
raise RuntimeError(
"The databse link for layer %d of <%s> references layer %d."
% (layer, self.name, layer_db_link.layer))
self.layer = layer
try:
self.table = layer_db_link.table()
except Exception as error:
raise RuntimeError(
"Loading the attribute table for layer %d of <%s> failed."
% (layer, self.name)) from error
self.n_lines = self.table.n_rows()
self.writeable = self.mapset == utils.getenv("MAPSET")
# Initialize the finder
self.find = {
"by_point":
PointFinder(self.c_mapinfo, self.table, self.writeable),
"by_bbox":
BboxFinder(self.c_mapinfo, self.table, self.writeable),
"by_polygon":
PolygonFinder(self.c_mapinfo, self.table, self.writeable),
}
self.find_by_point = self.find["by_point"]
self.find_by_bbox = self.find["by_bbox"]
self.find_by_polygon = self.find["by_polygon"]
class Info(object):
"""Basic vector info.
To get access to the vector info the map must be opened. ::
>>> test_vect = Info(test_vector_name)
>>> test_vect.open(mode='r')
Then it is possible to read and write the following map attributes: ::
>>> test_vect.organization
'Thuenen Institut'
>>> test_vect.person
'Soeren Gebbert'
>>> test_vect.title
'Test dataset'
>>> test_vect.scale
1
>>> test_vect.comment
'This is a comment'
>>> test_vect.comment = "One useful comment!"
>>> test_vect.comment
'One useful comment!'
There are some read only attributes: ::
>>> test_vect.maptype
'native'
And some basic methods: ::
>>> test_vect.is_3D()
False
>>> test_vect.exist()
True
>>> test_vect.is_open()
True
>>> test_vect.close()
"""
def __init__(self, name, mapset="", *aopen, **kwopen):
self._name = ""
self._mapset = ""
# Set map name and mapset
self.name = name
self.mapset = mapset
self._aopen = aopen
self._kwopen = kwopen
self.c_mapinfo = ctypes.pointer(libvect.Map_info())
self._topo_level = 1
self._class_name = "Vector"
self._mode = "r"
self.overwrite = False
self.date_fmt = "%a %b %d %H:%M:%S %Y"
def __enter__(self):
self.open(*self._aopen, **self._kwopen)
return self
def __exit__(self, exc_type, exc_value, traceback):
self.close()
def _get_mode(self):
return self._mode
def _set_mode(self, mode):
if mode.upper() not in "RW":
str_err = _("Mode type: {0} not supported ('r', 'w')")
raise ValueError(str_err.format(mode))
self._mode = mode
mode = property(fget=_get_mode, fset=_set_mode)
def _get_name(self):
"""Private method to obtain the Vector name"""
return self._name
def _set_name(self, newname):
"""Private method to change the Vector name"""
if not utils.is_clean_name(newname):
str_err = _("Map name {0} not valid")
raise ValueError(str_err.format(newname))
self._name = newname
name = property(fget=_get_name,
fset=_set_name,
doc="Set or obtain the Vector name")
def _get_mapset(self):
"""Private method to obtain the Vector mapset"""
return self._mapset
def _set_mapset(self, mapset):
"""Private method to change the Vector mapset"""
if mapset:
self._mapset = mapset
mapset = property(fget=_get_mapset,
fset=_set_mapset,
doc="Set or obtain the Vector mapset")
def _get_organization(self):
"""Private method to obtain the Vector organization"""
return utils.decode(libvect.Vect_get_organization(self.c_mapinfo))
def _set_organization(self, org):
"""Private method to change the Vector organization"""
libvect.Vect_set_organization(self.c_mapinfo, org)
organization = property(
fget=_get_organization,
fset=_set_organization,
doc="Set or obtain the Vector organization",
)
def _get_date(self):
"""Private method to obtain the Vector date"""
return utils.decode(libvect.Vect_get_date(self.c_mapinfo))
def _set_date(self, date):
"""Private method to change the Vector date"""
return libvect.Vect_set_date(self.c_mapinfo, date)
date = property(fget=_get_date,
fset=_set_date,
doc="Set or obtain the Vector date")
def _get_person(self):
"""Private method to obtain the Vector person"""
return utils.decode(libvect.Vect_get_person(self.c_mapinfo))
def _set_person(self, person):
"""Private method to change the Vector person"""
libvect.Vect_set_person(self.c_mapinfo, person)
person = property(fget=_get_person,
fset=_set_person,
doc="Set or obtain the Vector author")
def _get_title(self):
"""Private method to obtain the Vector title"""
return utils.decode(libvect.Vect_get_map_name(self.c_mapinfo))
def _set_title(self, title):
"""Private method to change the Vector title"""
libvect.Vect_set_map_name(self.c_mapinfo, title)
title = property(fget=_get_title,
fset=_set_title,
doc="Set or obtain the Vector title")
def _get_map_date(self):
"""Private method to obtain the Vector map date"""
date_str = utils.decode(libvect.Vect_get_map_date(self.c_mapinfo))
try:
return datetime.datetime.strptime(date_str, self.date_fmt)
except ValueError:
return date_str
def _set_map_date(self, datetimeobj):
"""Private method to change the Vector map date"""
date_str = datetimeobj.strftime(self.date_fmt)
libvect.Vect_set_map_date(self.c_mapinfo, date_str)
map_date = property(fget=_get_map_date,
fset=_set_map_date,
doc="Set or obtain the Vector map date")
def _get_scale(self):
"""Private method to obtain the Vector scale"""
return libvect.Vect_get_scale(self.c_mapinfo)
def _set_scale(self, scale):
"""Private method to set the Vector scale"""
return libvect.Vect_set_scale(self.c_mapinfo, ctypes.c_int(scale))
scale = property(fget=_get_scale,
fset=_set_scale,
doc="Set or obtain the Vector scale")
def _get_comment(self):
"""Private method to obtain the Vector comment"""
return utils.decode(libvect.Vect_get_comment(self.c_mapinfo))
def _set_comment(self, comm):
"""Private method to set the Vector comment"""
return libvect.Vect_set_comment(self.c_mapinfo, comm)
comment = property(fget=_get_comment,
fset=_set_comment,
doc="Set or obtain the Vector comment")
def _get_zone(self):
"""Private method to obtain the Vector projection zone"""
return libvect.Vect_get_zone(self.c_mapinfo)
def _set_zone(self, zone):
"""Private method to set the Vector projection zone"""
return libvect.Vect_set_zone(self.c_mapinfo, ctypes.c_int(zone))
zone = property(fget=_get_zone,
fset=_set_zone,
doc="Set or obtain the Vector projection zone")
def _get_proj(self):
"""Private method to obtain the Vector projection code"""
return libvect.Vect_get_proj(self.c_mapinfo)
def _set_proj(self, proj):
"""Private method to set the Vector projection code"""
libvect.Vect_set_proj(self.c_mapinfo, ctypes.c_int(proj))
proj = property(fget=_get_proj,
fset=_set_proj,
doc="Set or obtain the Vector projection code")
def _get_thresh(self):
"""Private method to obtain the Vector threshold"""
return libvect.Vect_get_thresh(self.c_mapinfo)
def _set_thresh(self, thresh):
"""Private method to set the Vector threshold"""
return libvect.Vect_set_thresh(self.c_mapinfo, ctypes.c_double(thresh))
thresh = property(fget=_get_thresh,
fset=_set_thresh,
doc="Set or obtain the Vector threshold")
@property
@must_be_open
def full_name(self):
"""Return the full name of Vector"""
return libvect.Vect_get_full_name(self.c_mapinfo)
@property
@must_be_open
def maptype(self):
"""Return the map type of Vector"""
return MAPTYPE[libvect.Vect_maptype(self.c_mapinfo)]
@property
@must_be_open
def proj_name(self):
"""Return the project name of Vector"""
return libvect.Vect_get_proj_name(self.c_mapinfo)
def write_header(self):
"""Save the change in the C struct permanently to disk."""
libvect.Vect_write_header(self.c_mapinfo)
def rename(self, newname):
"""Method to rename the Vector map
:param newname: the new name for the Vector map
:type newname: str
"""
if self.exist():
if not self.is_open():
utils.rename(self.name, newname, "vect")
else:
raise GrassError("The map is open, not able to renamed it.")
self._name = newname
def is_3D(self):
"""Return if the Vector is 3D"""
return bool(libvect.Vect_is_3d(self.c_mapinfo))
def exist(self):
"""Return if the Vector exists or not"""
if self.name:
if self.mapset == "":
mapset = utils.get_mapset_vector(self.name, self.mapset)
self.mapset = mapset if mapset else ""
return True if mapset else False
return bool(utils.get_mapset_vector(self.name, self.mapset))
else:
return False
def is_open(self):
"""Return if the Vector is open"""
return is_open(self.c_mapinfo)
def open(
self,
mode=None,
layer=1,
overwrite=None,
with_z=None,
# parameters valid only if mode == 'w'
tab_name="",
tab_cols=None,
link_name=None,
link_key="cat",
link_db="$GISDBASE/$LOCATION_NAME/$MAPSET/sqlite/sqlite.db",
link_driver="sqlite",
):
"""Open a Vector map.
:param mode: open a vector map in ``r`` in reading, ``w`` in writing
and in ``rw`` read and write mode
:type mode: str
:param layer: specify the layer that you want to use
:type layer: int
:param overwrite: valid only for ``w`` mode
:type overwrite: bool
:param with_z: specify if vector map must be open with third dimension
enabled or not. Valid only for ``w`` mode,
default: False
:type with_z: bool
:param tab_name: define the name of the table that will be generate
:type tab_name: str
:param tab_cols: define the name and type of the columns of the
attribute table of the vecto map
:type tab_cols: list of pairs
:param link_name: define the name of the link connecttion with the
database
:type link_name: str
:param link_key: define the nema of the column that will be use as
vector category
:type link_key: str
:param link_db: define the database connection parameters
:type link_db: str
:param link_driver: define witch database driver will be used
:param link_driver: str
Some of the parameters are valid only with mode ``w`` or ``rw``
See more examples in the documentation of the ``read`` and ``write``
methods
"""
self.mode = mode if mode else self.mode
with_z = libvect.WITH_Z if with_z else libvect.WITHOUT_Z
# check if map exists or not
if not self.exist() and self.mode != "w":
raise OpenError("Map <%s> not found." % self._name)
if libvect.Vect_set_open_level(self._topo_level) != 0:
raise OpenError("Invalid access level.")
# update the overwrite attribute
self.overwrite = overwrite if overwrite is not None else self.overwrite
# check if the mode is valid
if self.mode not in ("r", "rw", "w"):
raise ValueError("Mode not supported. Use one of: 'r', 'rw', 'w'.")
# check if the map exist
if self.exist() and self.mode in ("r", "rw"):
# open in READ mode
if self.mode == "r":
openvect = libvect.Vect_open_old2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# open in READ and WRITE mode
elif self.mode == "rw":
openvect = libvect.Vect_open_update2(self.c_mapinfo, self.name,
self.mapset, str(layer))
# instantiate class attributes
self.dblinks = DBlinks(self.c_mapinfo)
# If it is opened in write mode
if self.mode == "w":
openvect = libvect.Vect_open_new(self.c_mapinfo, self.name, with_z)
self.dblinks = DBlinks(self.c_mapinfo)
if self.mode in ("w", "rw") and tab_cols:
# create a link
link = Link(
layer,
link_name if link_name else self.name,
tab_name if tab_name else self.name,
link_key,
link_db,
link_driver,
)
# add the new link
self.dblinks.add(link)
# create the table
table = link.table()
table.create(tab_cols, overwrite=overwrite)
table.conn.commit()
# check the C function result.
if openvect == -1:
str_err = "Not able to open the map, C function return %d."
raise OpenError(str_err % openvect)
# Load attribute table for selected layer.
if len(self.dblinks) == 0:
self.layer = layer
self.table = None
self.n_lines = 0
else:
layer_db_link = self.dblinks.by_layer(layer)
if not layer_db_link:
raise LookupError(
"There appears to be no database link for layer %d of <%s>."
% (layer, self.name))
if layer_db_link.layer != layer:
raise RuntimeError(
"The databse link for layer %d of <%s> references layer %d."
% (layer, self.name, layer_db_link.layer))
self.layer = layer
try:
self.table = layer_db_link.table()
except Exception as error:
raise RuntimeError(
"Loading the attribute table for layer %d of <%s> failed."
% (layer, self.name)) from error
self.n_lines = self.table.n_rows()
self.writeable = self.mapset == utils.getenv("MAPSET")
# Initialize the finder
self.find = {
"by_point":
PointFinder(self.c_mapinfo, self.table, self.writeable),
"by_bbox":
BboxFinder(self.c_mapinfo, self.table, self.writeable),
"by_polygon":
PolygonFinder(self.c_mapinfo, self.table, self.writeable),
}
self.find_by_point = self.find["by_point"]
self.find_by_bbox = self.find["by_bbox"]
self.find_by_polygon = self.find["by_polygon"]
def close(self, build=False):
"""Method to close the Vector
:param build: True if the vector map should be build before close it
:type build: bool
"""
if hasattr(self, "table") and self.table is not None:
self.table.conn.close()
if self.is_open():
if libvect.Vect_close(self.c_mapinfo) != 0:
str_err = "Error when trying to close the map with Vect_close"
raise GrassError(str_err)
if (self.c_mapinfo.contents.mode == libvect.GV_MODE_RW
or self.c_mapinfo.contents.mode
== libvect.GV_MODE_WRITE) and build:
self.build()
def remove(self):
"""Remove vector map"""
if self.is_open():
self.close()
utils.remove(self.name, "vect")
def build(self):
"""Close the vector map and build vector Topology"""
self.close()
libvect.Vect_set_open_level(1)
if libvect.Vect_open_old2(self.c_mapinfo, self.name, self.mapset,
"0") != 1:
str_err = "Error when trying to open the vector map."
raise GrassError(str_err)
# Vect_build returns 1 on success and 0 on error (bool approach)
if libvect.Vect_build(self.c_mapinfo) != 1:
str_err = "Error when trying build topology with Vect_build"
raise GrassError(str_err)
libvect.Vect_close(self.c_mapinfo)
