def SnapToNode(e, n, tresh, vectMap):
"""Find nearest node to click coordinates (within given threshold)"""
if not haveCtypes:
return None
vectMap, mapSet = ParseMapStr(vectMap)
openedMap = pointer(vectlib.Map_info())
ret = vectlib.Vect_open_old(openedMap, c_char_p(vectMap), c_char_p(mapSet))
if ret == 1:
vectlib.Vect_close(openedMap)
if ret != 2:
return None
nodeNum = vectlib.Vect_find_node(openedMap, c_double(e), c_double(n),
c_double(0), c_double(tresh),
vectlib.WITHOUT_Z)
if nodeNum > 0:
e = c_double(0)
n = c_double(0)
vectlib.Vect_get_node_coor(openedMap, nodeNum, byref(e), byref(n),
None) # z
e = e.value
n = n.value
else:
vectlib.Vect_close(openedMap)
return False
return e, n
def getcoords(self):
""" Method creating a dict() of point coordinates: {a:(xa,ya), b:(xb,yb)...} """
# Create a new Map_info() object
map = vect.pointer(vect.Map_info())
# Load the vector map to Map_info() object. Level should be 2 (with topology)
vect.Vect_open_old2(map, self.layer, "", "-1")
# Get number of point features (1) in the layer
n_lines = vect.Vect_get_num_primitives(map, 1)
# Create new line and categories structures
line = vect.Vect_new_line_struct()
cats = vect.Vect_new_cats_struct()
# Make an empty list to store all feature cats and their coordinates in
coordsdict = {}
# Iterate through all features and write their coordinates to the list
for i in xrange(0, n_lines):
# Read next line from Map_info()
vect.Vect_read_next_line(map, line, cats, 1)
# Get line structure values, i.e. coordinates
x = line.contents.x[0]
y = line.contents.y[0]
# Get the point category number
cat = cats.contents.cat[0]
coordsdict[cat] = (x, y)
# Do some cleanup
vect.Vect_destroy_line_struct(line)
vect.Vect_destroy_cats_struct(cats)
vect.Vect_close(map)
# Return coordinate dictionary. Example: {1: (635185.6745587245, 6434401.869609355), 3: (634763.0860512792, 6437526.1793751), 4: (636855.7953351085, 6435785.045250954), 5: (636705.1202666728, 6432286.035328391), 6: (633607.9105266054, 6432286.035328391), 7: (632762.4559759387, 6435655.297275356)}
return coordsdict
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 featcount(self):
""" Method returning the number of features in the layer """
# Create a new Map_info() object
map = vect.pointer(vect.Map_info())
# Load the vector map to Map_info() object. Level should be 2 (with topology)
vect.Vect_open_old2(map, self.layer, "", "-1")
# Get number of point features (1) in the layer
n_feats = vect.Vect_get_num_primitives(map, 1)
# Close the Map_info() object
vect.Vect_close(map)
# Return number of features in the layer (integer)
return n_feats
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 curved(self):
"""Return"""
mapset = GrassGis.G_find_vector2(self.nametin, "")
if not mapset:
sys.exit("Vector map <%s> not found" % self.nametin)
# define map structure
map_info = GrassGis.pointer(GrassVect.Map_info())
# define open level (level 2: topology)
GrassVect.Vect_set_open_level(2)
# open existing vector map
GrassVect.Vect_open_old(map_info, self.nametin, mapset)
print("Calculating curves")
allrectas = []
rectas = self.get_rectas(map_info)
for nivel in rectas:
for recta in nivel:
allrectas.append(recta)
GrassVect.Vect_close(map_info)
new = VectorTopo(self.namelines)
new.open("w", with_z=True)
for line in allrectas:
new.write(Line(line))
new.close()
grass.run_command(
"v.build.polylines",
input=self.namelines,
output=self.namecurved,
overwrite=True,
quiet=True,
)
def GetNearestNodeCat(e, n, layer, tresh, vectMap):
if not haveCtypes:
return -2
vectMapName, mapSet = ParseMapStr(vectMap)
openedMap = pointer(vectlib.Map_info())
ret = vectlib.Vect_open_old(openedMap,
c_char_p(encode(vectMapName)),
c_char_p(encode(mapSet)))
if ret == 1:
vectlib.Vect_close(openedMap)
if ret != 2:
return -1
nodeNum = vectlib.Vect_find_node(openedMap,
c_double(e),
c_double(n),
c_double(0),
c_double(tresh),
vectlib.WITHOUT_Z)
if nodeNum > 0:
e = c_double(0)
n = c_double(0)
vectlib.Vect_get_node_coor(openedMap,
nodeNum,
byref(e),
byref(n),
None) # z
e = e.value
n = n.value
else:
vectlib.Vect_close(openedMap)
return -1
box = vectlib.bound_box()
List = POINTER(vectlib.boxlist)
List = vectlib.Vect_new_boxlist(c_int(0))
box.E = box.W = e
box.N = box.S = n
box.T = box.B = 0
vectlib.Vect_select_lines_by_box(
openedMap, byref(box),
vectlib.GV_POINT, List)
found = 0
dcost = 0
Cats = POINTER(vectlib.line_cats)
Cats = vectlib.Vect_new_cats_struct()
cat = c_int(0)
for j in range(List.contents.n_values):
line = List.contents.id[j]
type = vectlib.Vect_read_line(openedMap, None, Cats, line)
if type != vectlib.GV_POINT:
continue
if vectlib.Vect_cat_get(Cats, c_int(layer), byref(cat)):
found = 1
break
if found:
return cat.value
return -1
def close(self):
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)
def _read_vector_info(name, mapset):
"""Read the vector map info from the file system and store the content
into a dictionary
This method uses the ctypes interface to the vector libraries
to read the map metadata information
:param name: The name of the map
:param mapset: The mapset of the map
:returns: The key value pairs of the map specific metadata, or None in
case of an error
"""
kvp = {}
if not libgis.G_find_vector(name, mapset):
return None
# The vector map structure
Map = libvector.Map_info()
# We open the maps always in topology mode first
libvector.Vect_set_open_level(2)
with_topo = True
# Code lend from v.info main.c
if libvector.Vect_open_old_head2(byref(Map), name, mapset, "1") < 2:
# force level 1, open fully
# NOTE: number of points, lines, boundaries, centroids,
# faces, kernels is still available
libvector.Vect_set_open_level(1) # no topology
with_topo = False
if libvector.Vect_open_old2(byref(Map), name, mapset, "1") < 1:
logging.error(
_("Unable to open vector map <%s>" %
(libvector.Vect_get_full_name(byref(Map)))))
return None
# Release the vector spatial index memory when closed
libvector.Vect_set_release_support(byref(Map))
# Read the extent information
bbox = libvector.bound_box()
libvector.Vect_get_map_box(byref(Map), byref(bbox))
kvp["north"] = bbox.N
kvp["south"] = bbox.S
kvp["east"] = bbox.E
kvp["west"] = bbox.W
kvp["top"] = bbox.T
kvp["bottom"] = bbox.B
kvp["map3d"] = bool(libvector.Vect_is_3d(byref(Map)))
# Read number of features
if with_topo:
kvp["points"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_POINT)
kvp["lines"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_LINE)
kvp["boundaries"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_BOUNDARY)
kvp["centroids"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_CENTROID)
kvp["faces"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_FACE)
kvp["kernels"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_KERNEL)
# Summarize the primitives
kvp["primitives"] = kvp["points"] + kvp["lines"] + \
kvp["boundaries"] + kvp["centroids"]
if kvp["map3d"]:
kvp["primitives"] += kvp["faces"] + kvp["kernels"]
# Read topology information
kvp["nodes"] = libvector.Vect_get_num_nodes(byref(Map))
kvp["areas"] = libvector.Vect_get_num_areas(byref(Map))
kvp["islands"] = libvector.Vect_get_num_islands(byref(Map))
kvp["holes"] = libvector.Vect_get_num_holes(byref(Map))
kvp["volumes"] = libvector.Vect_get_num_primitives(
byref(Map), libvector.GV_VOLUME)
else:
kvp["points"] = None
kvp["lines"] = None
kvp["boundaries"] = None
kvp["centroids"] = None
kvp["faces"] = None
kvp["kernels"] = None
kvp["primitives"] = None
kvp["nodes"] = None
kvp["areas"] = None
kvp["islands"] = None
kvp["holes"] = None
kvp["volumes"] = None
libvector.Vect_close(byref(Map))
return kvp
