Ubuntu Manpage: v.net - Performs network maintenance.

Provided by: grass-doc_7.0.3-1build1_all

NAME

       v.net  - Performs network maintenance.

KEYWORDS

       vector, network, network maintenance

SYNOPSIS

       v.net
       v.net --help
       v.net    [-cs]     [input=name]      [points=name]      [output=name]     operation=string
       [arc_layer=string]   [node_layer=string]   [threshold=float]   [file=name]   [--overwrite]
       [--help]  [--verbose]  [--quiet]  [--ui]

   Flags:
       -c
           Assign unique categories to new points
           For operation ’nodes’

       -s
           Snap points to network
           For  operation  ’connect’.  By  default,  a  new line from the point to the network is
           created.

       --overwrite
           Allow output files to overwrite existing files

       --help
           Print usage summary

       --verbose
           Verbose module output

       --quiet
           Quiet module output

       --ui
           Force launching GUI dialog

   Parameters:
       input=name
           Name of input vector line map (arcs)
           Required for operation ’nodes’, ’connect’, ’report’ and ’nreport’

       points=name
           Name of input vector point map (nodes)
           Required for operation ’connect’ and ’arcs’

       output=name
           Name for output vector map

       operation=string [required]
           Operation to be performed
           Options: nodes, connect, arcs, report, nreport
           nodes: new point is placed on each node (line end) if doesn’t exist
           connect: connect still unconnected points to vector network by inserting new line(s)
           arcs: new line is created from start point to end point
           report:    print    to    standard    output    {line_category    start_point_category
           end_point_category}
           nreport: print to standard output {point_category line_category[,line_category...]}

       arc_layer=string
           Arc layer
           Vector  features  can have category values in different layers. This number determines
           which layer to use. When used with direct OGR access this is the layer name.
           Default: 1

       node_layer=string
           Node layer
           Vector features can have category values in different layers. This  number  determines
           which layer to use. When used with direct OGR access this is the layer name.
           Default: 2

       threshold=float
           Threshold
           Required for operation ’connect’. Connect points in given threshold.

       file=name
           Name of input file
           Required for operation ’arcs’ (’-’ for standard input)

DESCRIPTION

v.net is used for network preparation and maintenance. Its main use is to create a vector
network from vector lines (arcs ) and points (nodes) by creating nodes from intersections
in a map of vector lines (node operator), by connecting a vector lines map with a points
map (connect operator), and by creating new lines between pairs of vector points (arcs
operator).

A GIS network consists of topologically correct lines (arcs). That is, the lines must be
connected by shared vertices where real connections exist. In GRASS GIS you also can add
nodes to the network. These are specially designated vertices used for analyzing network
properties or computing cost/distance measures. That is, not all vertices are treated as
nodes by default. Only v.net.path can use a network without nodes, they are required for
all the other network modules. In GRASS, network arcs are stored in one data layer
(normally layer 1) and nodes are stored in a different data layer (normally layer 2).

v.net offers two ways to add nodes to a network of arcs and one method to add arcs to a
set of nodes:

1 Use the connect operation to create nodes from a vector points file and add these
nodes to an existing vector network of arcs (i.e., lines/boundaries). This is
useful when the goal is to analyze a set of places (points) in relation to a
network--for example travel costs between places. Only points within the thresh
(threshold) distance to a line/boundary will be connected as network nodes. There
are two ways to connect nodes. By default, v.net will create new lines connecting
each point to the closest line of the network. If you use the -s flag, however, the
new nodes will be added on the closest line of the network at the point closest to
the point you wish to add. When using the connect operation, some lines will share
the same category. In order to assign unique costs to each line, a new layer needs
to be created with
v.category map=yourmap operation=add cat=1 step=1 layer=3
followed by
v.db.addtable map=yourmap layer=3 table=tablename.

2 Create nodes and arcs from a vector line/boundary file using the node operation.
This is useful if you are mostly interested in the network itself and thus you can
use intersections of the network as start and end points. Nodes will be created at
all intersections of two or more lines. For an arc that consists of several
segments connected by vertices (the typical case), only the starting and ending
vertices are treated as network nodes.

3 Create straight-line arcs between pairs of nodes with the arcs option. This
produces networks like those of airline flights between airports. It is also
similar to the kind of network created with social networking software, making it
possible to create georeferenced social networks.

While the arcs created with v.net will retain any attribute information associated with
the input vector line/boundary file in data layer 1, nodes created and stored in data
layer 2 will not have any associated attribute information.

For nodes created using the connect and arcs operations (methods 1 and 3 above), the nodes
can be reconnected to the attribute table of the input vector points file using the
attribute table manager ("manage layers" tab) or by running v.db.connect.

For nodes created using the nodes operation (method 2 above), it is possible to create an
attribute table for the new nodes in layer 2 using the attribute table manager and connect
it to layer 2 ("manage layers" tab) or to create a table with v.db.addtable, connect it to
layer 2 with v.db.connect, and update the new table with cat values with v.to.db.

Once a vector network has been created, it can be analyzed in a number of powerful ways
using the suite of v.net.* modules. The shortest route between two nodes, following arcs,
can be computed (v.net.path), as can the shortest route that will pass through a set of
nodes and return to the starting node (v.net.salesman). Least cost routes through the
network can be calculated on the basis of distance only or on the basis of distance
weighted by an attribute associated with each arc (for example, travel speed along a
network segment). A network can be divided into concentric zones of equal travel cost
around one or more nodes (v.net.iso) or subdivided so that each node is surrounded by a
zone in which all arcs can be reached with the same travel costs as all arcs surrounding
each other node (v.net.alloc). In addition to the modules listed above, the GRASS vector
networking suite includes numerous other modules for analysis of network costs and
connectivity. These include: v.net.allpairs, v.net.bridge, v.net.centrality,
v.net.components, v.net.distance, v.net.flow, v.net.spanningtree, v.net.steiner,
v.net.timetable, and v.net.visibility.

NOTES

       For a vector map prepared for network analysis in GRASS,  nodes  are  represented  by  the
       grass-internal  geometry  type node and arcs by the geometry type line.  If vector editing
       is required to modify the graph, g.gui.vdigit or v.edit can be used.  See also the  Linear
       Referencing System available in GRASS GIS.

EXAMPLES

       The examples are North Carolina dataset based.

   Create nodes globally for all line ends and intersections
       v.net input=streets_wake output=streets_node operation=nodes
       # verify result
       v.category streets_node operation=report

   Merge in nodes from a separate map within given threshold
       v.net input=streets_wake points=firestations out=streets_net \
             operation=connect threshold=500
       # verify result
       v.category streets_net operation=report
       The nodes are stored in layer 2 unless node_layer=1 is used.

   Generating network for vector point map
       For generating network for given vector point map an input file in the following format is
       required:
       [category of edge] [category of start node] [category of end node]

       Option 1: Save the file (e.g. "points.txt") and generate the map:
       v.net points=geodetic_swwake_pts output=geodetic_swwake_pts_net \
             operation=arcs file=points.txt
       # verify result
       v.category geodetic_swwake_pts_net operation=report

       Option 2: Read in from command line:
       v.net points=geodetic_swwake_pts output=geodetic_swwake_pts_net \
             operation=arcs file=- << EOF
       1 28000 28005
       2 27945 27958
       3 27886 27897
       EOF
       # verify result
       v.category geodetic_swwake_pts_net operation=report

AUTHORS

       Radim Blazek, ITC-irst, Trento, Italy
       Martin Landa, FBK-irst (formerly  ITC-irst),  Trento,  Italy  and  CTU  in  Prague,  Czech
       Republic (operation ’connect’ and ’arcs’)
       Markus Metz: important fixes and improvements

       Last changed: $Date: 2015-10-27 16:43:43 +0100 (Tue, 27 Oct 2015) $

       Main index | Vector index | Topics index | Keywords index | Full index

       © 2003-2016 GRASS Development Team, GRASS GIS 7.0.3 Reference Manual