Exemplo n.º 1
0
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)
Exemplo n.º 2
0
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)
Exemplo n.º 3
0
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)