GRASS-Wiki - User contributions [en]

GRASS Vector Layers

2008-08-19T23:44:08Z

⚠️Wrobell: /* Road Network Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
Sample data can be downloaded using one of the links
* http://entropy.echelon.pl/wrobell/grass/gvl-0.1.zip
* http://wrobell.it-zone.org/grass/gvl-0.1.zip

The archive contains basic relational database and Grass
data based on Spearfish data
* '''gvl.sqlite''' file is SQLite relational database file with tables and view described above
* vector map '''roads''' containing road network map data

To start processing sample data unpack the archive and start Grass
within PERMANENT location

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' provided with sample data has one layer of categories and
it is not connected to any database table. This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

To connect vector map with two layers of data, vector categories
have to be populated into these layers using following commands

$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, detailed information
describing the process is provided below.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required,
it has to be removed using command

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-08-19T23:41:09Z

⚠️Wrobell: /* Appendix: Creating Tutorial's Road Network and Routes Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
Sample data can be downloaded using one of the links
* http://entropy.echelon.pl/wrobell/grass/gvl-0.1.zip
* http://wrobell.it-zone.org/grass/gvl-0.1.zip

The archive contains basic relational database and Grass
data based on Spearfish data
* '''gvl.sqlite''' file is SQLite relational database file with tables and view described above
* vector map '''roads''' containing road network map data

To start processing sample data unpack the archive and start Grass
within PERMANENT location

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' provided with sample data has one layer of categories and
it is not connected to any database table. This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

To connect vector map with two layers of data, vector categories
have to be populated into these layers using following commands

$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, detailed information
describing the process is provided below.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-08-19T23:39:49Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
Sample data can be downloaded using one of the links
* http://entropy.echelon.pl/wrobell/grass/gvl-0.1.zip
* http://wrobell.it-zone.org/grass/gvl-0.1.zip

The archive contains basic relational database and Grass
data based on Spearfish data
* '''gvl.sqlite''' file is SQLite relational database file with tables and view described above
* vector map '''roads''' containing road network map data

To start processing sample data unpack the archive and start Grass
within PERMANENT location

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' provided with sample data has one layer of categories and
it is not connected to any database table. This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

To connect vector map with two layers of data, vector categories
have to be populated into these layers using following commands

$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-08-19T23:37:15Z

⚠️Wrobell: /* Sample Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
Sample data can be downloaded using one of the links
* http://entropy.echelon.pl/wrobell/grass/gvl-0.1.zip
* http://wrobell.it-zone.org/grass/gvl-0.1.zip

The archive contains basic relational database and Grass
data based on Spearfish data
* '''gvl.sqlite''' file is SQLite relational database file with tables and view described above
* vector map '''roads''' containing road network map data

To start processing sample data unpack the archive and start Grass
within PERMANENT location

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-08-19T23:28:39Z

⚠️Wrobell: /* Sample Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
Sample data can be downloaded from [[Media:gvl-0.1.tar.gz]].
The archive contains basic relational database and Grass
data based on Spearfish data
* '''gvl.sqlite''' file is SQLite relational database file with tables and view described above
* vector map '''roads''' containing road network map data

To start processing sample data unpack the archive and start Grass
within PERMANENT location

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-08T08:33:56Z

⚠️Wrobell: /* Datamodel Discussion */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat,
rn.id as id,
r.route_id as route_id
from route r
left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-08T08:32:22Z

⚠️Wrobell: /* Datamodel Discussion */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which references road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-08T08:30:50Z

⚠️Wrobell: /* Problem Description */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on these roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector map, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data change or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-08T08:28:41Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector map using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-07T23:27:59Z

⚠️Wrobell: /* Footnotes */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== References ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-03T22:22:57Z

⚠️Wrobell: /* Routes Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

== Footnotes ==
<references/>
[[Category:Documentation]]

GRASS Vector Layers

2008-06-03T22:22:07Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

[[Category:Documentation]]

GRASS Vector Layers

2008-06-03T22:21:46Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

[[Category:Documentation]]

GRASS Vector Layers

2008-06-03T22:20:55Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
<ref>http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html</ref>
<references/>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

[[Category:Documentation]]

GRASS Vector Layers

2008-05-29T22:27:05Z

⚠️Wrobell: /* Sample Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.tar.gz]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

GRASS Vector Layers

2008-05-29T22:22:25Z

⚠️Wrobell: /* Sample Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File [[Media:gvl-0.1.zip]] attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

GRASS Vector Layers

2008-05-29T22:17:59Z

⚠️Wrobell: /* Routes Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer, roads segments belonging to first route,
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

GRASS Vector Layers

2008-05-29T22:16:47Z

⚠️Wrobell: /* Routes Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
Routes data were created using '''d.what.vect''' command.
Road network vector map '''roads''' has to be displayed
$ d.mon x0
$ d.vect map=roads

Now, it can be queried for data. Run
$ d.what.vect -t map=roads > route-01.txt
Using mouse pointer roads segments belonging to first route
can be identified. When done, file '''route.txt''' can be
processed with '''awk''' or other tool to extract road segment
information, which can be easily uploaded to database.

GRASS Vector Layers

2008-05-29T22:10:50Z

⚠️Wrobell: /* Road Network Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

Finally, vector map '''roads''' is being disconnected from road network table

$ v.db.connect -d map=road

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T22:09:14Z

⚠️Wrobell: /* Road Network Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector map are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T22:08:38Z

⚠️Wrobell: /* Appendix: Creating Tutorial's Road Network and Routes Data */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==
Sample data for this tutorial were extracted from Spearfish data.
As it was quite interesting excersise, below detailed information
is provided describing the process.

=== Road Network Data ===
Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''roads''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=roads option=add
$ g.remove vect=tmpmap

Vector map '''roads''' is connected to DBF file, which is no longer required. Therefore
it has to be removed

$ v.db.droptable -f roads

Road network table needs to be populated with categories and road segment identifiers.
First, road network table has to be connected to vector map
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network

Now, it is possible to upload categories of vector map '''roads''' into road network table
$ v.to.db map=roads option=cat

Road network data usually is provided with some road segment identifiers.
The identifiers are usually set by vendor of road network data but they
are missing in case of Spearfish data. Therefore, for the purpose of this tutorial
they will be generated from categories of vector map '''roads'''. It can be done easily
with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:55:09Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector map '''roads''' has one layer of categories and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:53:34Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with command

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:51:39Z

⚠️Wrobell: /* Problem Description */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:46:02Z

⚠️Wrobell: /* Creating Separate Route Map */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

To display vector '''r4''', '''layer''' parameter has to be used as routing
information is still in second layer
$ d.mon x0
$ d.vect map=r4 layer=2

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:43:44Z

⚠️Wrobell: /* Using Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.mon x0
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

==== Creating Separate Route Map ====
To create separate vector map of route number 4
$ v.extract -t input=roads layer=2 output=r4 where='route_id=4'

Please note '''-t''' parameter, which forces Grass to ''not'' copy database
table, which can be very costly operation.

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:38:12Z

⚠️Wrobell: /* Using Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Almost all Grass commands accept '''layer''' parameter, which determines
layer to be used by a command. Below, some examples are provided.

==== Displaying ====
To display road network map and routes number 1 and 4
$ d.vect map=roads
$ d.vect map=roads layer=2 color=green width=8 where='route_id=1'
$ d.vect map=roads layer=2 color=red width=4 where='route_id=4'

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:33:05Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, database tables have to be connected to Grass vector map using '''v.db.connect'''
command
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>
Road network table is connected as first layer and route information as second layer.

=== Using Layers ===
Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:30:22Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=roads driver=sqlite database=gvl.sqlite table=road_network
$ v.db.connect -o map=roads layer=2 driver=sqlite database=gvl.sqlite table=route_rn
$ v.db.connect -p map=roads
Vector map <roads> is connected by:
layer <1> table <road_network> in database <gvl.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <gvl.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:27:15Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads
$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825
Layer: 2
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:25:02Z

⚠️Wrobell: /* Creating Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Vector categories have to be populated into two layers
(or more if required)
$ v.category --o input=roads layer=2 output=tmprn
$ g.remove vect=roads
$ g.rename vect=tmprn,roads

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:23:23Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 825
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 825

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T21:19:46Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==
=== Sample Data ===
File gvl-0.1.zip attached to this tutorial contains Grass data based on Spearfish
data and basic relational database
* road network Grass vector map '''roads'''
* '''gvl.sqlite''' file is SQLite relational database file, which has tables and view described above

Unzip the file with sample data, enter its directory and start Grass

$ unzip gvl-0.1.zip
$ cd gvl-0.1
$ grass PERMANENT

=== Creating Layers ===
Vector '''roads''' has one layer and it is not connected to any database table.
This can be checked with commands

$ v.db.connect -p map=roads
ERROR: Database connection for map <roads> is not defined in DB file

$ v.category option=report input=roads
Layer: 1
type count min max
point 0 0 0
line 825 1 5
boundary 0 0 0
centroid 0 0 0
area 0 0 0
all 825 1 5

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T20:46:14Z

⚠️Wrobell:

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

== Appendix: Creating Tutorial's Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

GRASS Vector Layers

2008-05-29T20:43:01Z

⚠️Wrobell: /* Datamodel Discussion */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to have at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Routes table shall consist of
* route identifier
* id of road segment driven on a route, which reference road segment id in road network table

Routes table also has to provide vector category information. This can be
realized with a SQL view, i.e.
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

GRASS Vector Layers

2008-05-29T20:18:47Z

⚠️Wrobell: /* Datamode Discussion */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamodel Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

GRASS Vector Layers

2008-05-29T20:04:21Z

⚠️Wrobell:

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Datamode Discussion ==
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

== Road Network and Routes Data ==

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

GRASS Vector Layers

2008-05-23T00:09:39Z

⚠️Wrobell:

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers
:http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

GRASS Vector Layers

2008-05-23T00:08:20Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>Vector data processing in GRASS GIS, http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html.</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and routes 1 and 4]]

References: <references/>

GRASS Vector Layers

2008-05-23T00:07:34Z

⚠️Wrobell:

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.
<ref>Vector data processing in GRASS GIS, http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html.</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

[[Image:routes.png|frame|Road network and routes 1 and 4]]

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

References: <references/>

GRASS Vector Layers

2008-05-23T00:06:16Z

⚠️Wrobell:

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.<ref>Vector data processing in GRASS GIS.</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

== References ==
References: <references/>
http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-23T00:04:42Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers.<ref>Vector data processing in GRASS GIS.</ref>

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-23T00:03:49Z

⚠️Wrobell: /* Introduction */

== Introduction ==

Grass documentation provides basic information about vector attribute management,
categories of vector features and vector layers, see
<ref>Vector data processing in GRASS GIS</ref>.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-23T00:01:35Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined
* routes to road network view exists to associate route information with Grass vector data

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and route information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-22T23:59:32Z

⚠️Wrobell: /* Database Tables */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Routes table also has to provide vector category information. This can be
realized with a SQL view
create view route_rn as
select rn.cat as cat, rn.id as id, r.route_id as route_id
from route r left join road_network rn on r.rn_id = rn.id;

Above tables and view allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and routes information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-22T23:55:44Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Above tables allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and routes information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and routes no 1 and 4 can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'
which is rendered as on the map presented below
[[Image:routes.png|frame|Road network and routes 1 and 4]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-22T23:53:32Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Above tables allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and routes information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and all routes can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and two routes]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

GRASS Vector Layers

2008-05-22T23:53:12Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Above tables allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and routes information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and all routes can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and two routes]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html

File:Routes.png

2008-05-22T23:43:50Z

⚠️Wrobell: uploaded a new version of "Image:Routes.png"

GRASS Vector Layers

2008-05-22T23:42:57Z

⚠️Wrobell: /* Creating Grass Vector Layers */

== Introduction ==

Grass documentation provides basic information about vector attribute management.
categories of vector features and vector layers.

The aim of this tutorial is to show how to create, manipulate and
display different layers of a vector using relational database.

== Problem Description ==
An organization provides information about routes to be driven
by drivers. The organization's database consists of
* roads (road network)
* routes driven on that roads

Simple approach can be taken to present the routes to drivers.
For every route a vector map could be created and overlayed over
the road network vector, i.e.

$ d.vect map=roads
$ d.vect map=route01 color=green width=2

Above idea has a major flaw. If route data changes or new route is added
then vector maps has to be regenerated or removed.

Assuming that route network and routes data are stored in relational database,
the database tables can be linked to road network map as its layers.
Such layer information could be utilized to display maps, i.e.

$ d.vect map=roads
$ d.vect map=roads layer=2 where="route_id=1" color=green width=2

The tutorial reuses road network provided with Spearfish data. To solve
problem defined above, the roads data and sample routes needs to be prepared.
This is described in next section.

== Road Network and Routes Data ==

=== Database Tables ===
Relation database should contain two tables
* road network table
* driven routes table

Road network table has to contain at least two columns
* road segment id usually provided with road network data by vendor
* vectory category required by Grass to identify vector features

Road network table can be defined like
create table road_network (
cat integer,
id integer -- road segment id
);

Routes table contains route identifier and id of road segment driven
on a route
create table route (
route_id integer,
rn_id integer -- references road_network.id
);

Above tables allow to provide road network and driven routes information. They
can be more complicated depending on application but for purpose of this tutorial
such minimal approach is being kept.

=== Road Network Data ===

Spearfish data provides road network map in '''roads''' vector.
It contains few hundred vector lines - road network segments.
Data associated with this vector are very simple and they have to be
extended
* unique category id for every vector road segment needs to generated
* unique id has to be assigned to every road segment

Below, vector '''rn''' is created with every vector line having unique
category

$ v.category --o in=roads out=tmpmap option=del
$ v.category --o in=tmpmap out=rn option=add
$ g.remove vect=tmpmap

Vector '''rn''' is connected to DBF file, which is no longer required. Therefore
it has to be removed.

$ v.db.droptable -f rn

Road network table needs to be associated with road network vector
(SQLite driver is used with database located in '''data.sqlite''' file; of course,
any other RDBMS can be used)

$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network

Categories of vector '''rn''' has to be uploaded into road network table

$ v.to.db map=rn option=cat

As it was said above, road network data usually is provided with some road
segment identifiers. There is no road segment ids in case of Spearfish data.
Therefore, for the purpose of this tutorial they will be generated from categories
of vector '''rn'''. It can be done easily with SQL query

update road_network set id = cat;

=== Routes Data ===
SQL queries below create four sample routes driven on road network provided
in Spearfish data.

insert into route (route_id, rn_id) values (1, 10);
insert into route (route_id, rn_id) values (1, 411);
insert into route (route_id, rn_id) values (1, 412);
insert into route (route_id, rn_id) values (1, 413);
insert into route (route_id, rn_id) values (1, 414);
insert into route (route_id, rn_id) values (2, 407);
insert into route (route_id, rn_id) values (2, 408);
insert into route (route_id, rn_id) values (2, 410);
insert into route (route_id, rn_id) values (2, 413);
insert into route (route_id, rn_id) values (2, 414);
insert into route (route_id, rn_id) values (3, 10);
insert into route (route_id, rn_id) values (3, 408);
insert into route (route_id, rn_id) values (3, 409);
insert into route (route_id, rn_id) values (3, 415);
insert into route (route_id, rn_id) values (4, 407);
insert into route (route_id, rn_id) values (4, 415);
insert into route (route_id, rn_id) values (4, 9);

== Creating Grass Vector Layers ==

Previous section described in detail how to prepare sample data
to illustrate problem defined in this tutorial. To summarize
* road network vector map exists in Grass
* road network database table is associated with road network map; it has columns
** id - identifies road segment id
** cat - identifies road segment in Grass vector map
* routes table is created, it has route id and road segment id columns; four routes are defined

Route network table is connected as first layer to '''rn''' vector.
This can be checked with command

$ v.db.connect -p map=rn

Let's disconnect vector '''rn''' from its first layer

$ v.db.connect -d map=rn layer=1

Now, without copying database table, vector categories can be populated
into two layers (or more if required)
$ v.category --o input=rn layer=2 output=tmprn
$ g.remove vect=rn
$ g.rename vect=tmprn,rn
'''Above step is very important. Vector categories needs to be populated in all layers.'''

Road network table can be reconnected as first layer
and routes information as second layer
$ v.db.connect -o map=rn driver=sqlite database=data.sqlite table=road_network
$ v.db.connect -o map=rn layer=2 driver=sqlite database=data.sqlite table=route_rn
$ v.db.connect -p map=rn
Vector map <rn> is connected by:
layer <1> table <road_network> in database <data.sqlite> through driver <sqlite> with key <cat>
layer <2> table <route_rn> in database <data.sqlite> through driver <sqlite> with key <cat>

Road network map and all routes can be displayed
$ d.vect map=rn
$ d.vect map=rn layer=2 color=green width=8 where='route_id=1'
$ d.vect map=rn layer=2 color=red width=4 where='route_id=4'

[[Image:routes.png|frame|Road network and two routes]]

http://grass.osgeo.org/grass63/manuals/html63_user/vectorintro.html