v.generalize - Vector based generalization.
vector, generalization, simplification, smoothing, displacement, network generalization
v.generalize [-cr] input=name output=name [type=string[,string,...]] method=string threshold=float [look_ahead=integer] [reduction=float] [slide=float] [angle_thresh=float] [degree_thresh=integer] [closeness_thresh=float] [betweeness_thresh=float] [alpha=float] [beta=float] [iterations=integer] [layer=integer] [cats=range] [where=sql_query] [--overwrite] [--verbose] [--quiet]
- Copy attributes
- This does nothing. It is retained for backwards compatibility
- Allow output files to overwrite existing files
- Verbose module output
- Quiet module output
- Name of input vector map
- Name for output vector map
- Feature type
- Options: line,boundary,area
- Default: line,boundary,area
- Generalization algorithm
- Options: douglas,douglas_reduction,lang,reduction,reumann,boyle,sliding_averaging,distance_weighting,chaiken,hermite,snakes,network,displacement
- douglas: Douglas-Peucker Algorithm
- douglas_reduction: Douglas-Peucker Algorithm with reduction parameter
- lang: Lang Simplification Algorithm
- reduction: Vertex Reduction Algorithm eliminates points close to each other
- reumann: Reumann-Witkam Algorithm
- boyle: Boyle's Forward-Looking Algorithm
- sliding_averaging: McMaster's Sliding Averaging Algorithm
- distance_weighting: McMaster's Distance-Weighting Algorithm
- chaiken: Chaiken's Algorithm
- hermite: Interpolation by Cubic Hermite Splines
- snakes: Snakes method for line smoothing
- network: Network generalization
- displacement: Displacement of lines close to each other
- Maximal tolerance value
- Options: 0-1000000000
- Look-ahead parameter
- Default: 7
- Percentage of the points in the output of 'douglas_reduction' algorithm
- Options: 0-100
- Default: 50
- Slide of computed point toward the original point
- Options: 0-1
- Default: 0.5
- Minimum angle between two consecutive segments in Hermite method
- Options: 0-180
- Default: 3
- Degree threshold in network generalization
- Default: 0
- Closeness threshold in network generalization
- Options: 0-1
- Default: 0
- Betweeness threshold in network generalization
- Default: 0
- Snakes alpha parameter
- Default: 1.0
- Snakes beta parameter
- Default: 1.0
- Number of iterations
- Default: 1
- Layer number
- A single vector map can be connected to multiple database tables. This number determines which table to use.
- Default: 1
- Category values
- Example: 1,3,7-9,13
- WHERE conditions of SQL statement without 'where' keyword
- Example: income < 1000 and inhab >= 10000
is a module for the generalization of GRASS vector maps. This module
consists of algorithms for line simplification, line smoothing,
network generalization and displacement (new methods may be added later).
For more examples and nice pictures, see
If type=area is selected, boundaries of selected areas will be
generalized, and the options cats, where, and
layer will be used to select areas.
(Line) simplification is a process of reducing the complexity of vector
features. The module transforms a line into another line consisting of
fewer vertices, that still approximate the original line. Most of the
algorithms described below select a subset of points on the original line.
(Line) smoothing is a "reverse" process which takes as input a line and
produces a smoother approximate of the original. In some cases, this is
achieved by inserting new vertices into the original line, and can total
up to 4000% of the number of vertices in the original. In such an instance,
it is always a good idea to simplify the line after smoothing.
Smoothing and simplification algorithms implemented in this module work
line by line, i.e. simplification/smoothing of one line does not affect
the other lines; they are treated separately. Also, the first and the
last point of each line is never translated and/or deleted.
v.generalize contains following line simplification algorithms:
Different algorithms require different parameters, but all the algorithms
have one parameter in common: the threshold parameter. In general,
the degree of simplification increases with the increasing value of
- Douglas-Peucker Algorithm
- Douglas-Peucker Reduction Algorithm
- Lang Algorithm
- Vertex Reduction
- Reumann-Witkam Algorithm
- Remove Small Lines/Areas
Douglas-Peucker and Douglas-Peucker Reduction Algorithm
use the same method to simplify the lines. Note that
- Douglas-Peucker - "Quicksort" of line simplification, the
most widely used algorithm. Input parameters: input,
threshold. For more information, see:
- Douglas-Peucker Reduction Algorithm is essentially the same
algorithm as the algorithm above, the difference being that it takes
an additional reduction parameter which denotes the percentage
of the number of points on the new line with respect to the number
of points on the original line. Input parameters: input,
- Lang - Another standard algorithm. Input parameters:
input, threshold, look_ahead.
For an excellent description, see:
- Vertex Reduction - Simplest among the algorithms. Input
parameters: input, threshold.
Given a line, this algorithm removes the points of this line which
are closer to each other than threshold. More precisely, if
p1 and p2 are two consecutive points, and the distance between p2
and p1 is less than threshold, it removes p2 and repeats the
same process on the remaining points.
- Reuman-Witkam - Input parameters: input,
This algorithm quite reasonably preserves the global characteristics
of the lines. For more information, see:
is equivalent to
v.generalize input=boundary_county output=boundary_county_dp20 method=douglas threshold=20
However, in this case, the first method is faster. Also observe that
douglas_reduction never outputs more vertices than douglas,
and that, in general, douglas is more efficient than
douglas_reduction. More importantly, the effect of
v.generalize input=boundary_county output=boundary_county_dp_red20_100 \
method=douglas_reduction threshold=20 reduction=100
is that 'out' contains approximately only 30% of points of 'in'.
v.generalize input=boundary_county output=boundary_county_dp_red0_30 \
method=douglas_reduction threshold=0 reduction=30
The following smoothing algorithms are implemented in v.generalize:
One of the key advantages of Hermite Interpolation is the fact
that the computed line always passes through the points of the original
line, whereas the lines produced by the remaining algorithms never pass
through these points. In some sense, this algorithm outputs a line which
"circumscribes" the input line.
- Boyle's Forward-Looking Algorithm - The position of each point
depends on the position of the previous points and the point
look_ahead ahead. look_ahead consecutive points. Input
parameters: input, look_ahead.
- McMaster's Sliding Averaging Algorithm - Input Parameters:
input, slide, look_ahead.
The new position of each point is the average of the look_ahead
points around. Parameter slide is used for linear interpolation
between old and new position (see below).
- McMaster's Distance-Weighting Algorithm - Takes the weighted
average of look_ahead consecutive points where the weight is
the reciprocal of the distance from the point to the currently
smoothed point. The parameter slide is used for linear
interpolation between the original position of the point and newly
computed position where value 0 means the original position.
Input parameters: input, slide, look_ahead.
- Chaiken's Algorithm - "Inscribes" a line touching the original
line such that the points on this new line are at least
threshold apart. Input parameters: input,
threshold. This algorithm approximates the given line very
- Hermite Interpolation - This algorithm takes the points of
the given line as the control points of hermite cubic spline and
approximates this spline by the points approximately
threshold apart. This method has excellent results for small
values of threshold, but in this case it produces a huge
number of new points and some simplification is usually needed.
Input parameters: input, threshold, angle_thresh.
Angle_thresh is used for reducing the number of the points.
It denotes the minimal angle (in degrees) between two consecutive
segments of a line.
- Snakes is the method of minimisation of the "energy" of a
line. This method preserves the general characteristics of the lines
but smooths the "sharp corners" of a line. Input parameters
input, alpha, beta.
This algorithm works very well for small values of alpha and
beta (between 0 and 5). These parameters affect the
"sharpness" and the curvature of the computed line.
On the other hand, Chaiken's Algorithm outputs a line which
"inscribes" a given line. The output line always touches/intersects the
centre of the input line segment between two consecutive points. For
more iterations, the property above does not hold, but the computed
lines are very similar to the Bezier Splines. The disadvantage of the
two algorithms given above is that they increase the number of points.
However, Hermite Interpolation can be used as another
simplification algorithm. To achieve this, it is necessary to set
angle_thresh to higher values (15 or so).
One restriction on both McMasters' Algorithms is that look_ahead
parameter must be odd. Also note that these algorithms have no effect if
look_ahead = 1.
Note that Boyle's, McMasters' and Snakes algorithm
are sometimes used in the signal processing to smooth the signals.
More importantly, these algorithms never change the number of points on
the lines; they only translate the points, and do not insert any new points.
Snakes Algorithm is (asymptotically) the slowest among the
algorithms presented above. Also, it requires quite a lot of memory.
This means that it is not very efficient for maps with the lines
consisting of many segments.
The displacement is used when the lines overlap and/or are close to each
other at the current level of detail. In general, displacement methods
move the conflicting features apart so that they do not interact and can
This module implements an algorithm for displacement of linear features
based on the Snakes approach. This method generally yields very
good results; however, it requires a lot of memory and is not very efficient.
Displacement is selected by method=displacement. It uses the
The lines affected by the algorithm can be specified by the layer,
cats and where parameters.
threshold - specifies critical distance. Two features interact if
they are closer than threshold apart.
alpha, beta - These parameters define the rigidity of lines.
For larger values of alpha, beta (>=1), the algorithm
does a better job at retaining the original shape of the lines, possibly
at the expense of displacement distance. If the values of alpha,
beta are too small (<=0.001), then the lines are moved
sufficiently, but the geometry and topology of lines can be destroyed.
Most likely the best way to find the good values of alpha, beta
is by trial and error.
iterations - denotes the number of iterations the interactions
between the lines are resolved. Good starting points for values of
iterations are between 10 and 100.
Used for selecting "the most important" part of the network. This is based
on the graph algorithms. Network generalization is applied if method=network.
The algorithm calculates three centrality measures for each line in the
network and only the lines with the values greater than thresholds are selected.
The behaviour of algorithm can be altered by the following parameters:
All three parameters above can be presented at the same time. In that
case, the algorithm selects only the lines which meet each criterion.
degree_thresh - algorithm selects only the lines which share a point
with at least degree_thresh different lines.
closeness_thresh - is always in the range (0, 1]. Only the lines
with the closeness centrality value at least closeness_thresh apart
are selected. The lines in the centre of a network have greater values of
this measure than the lines near the border of a network. This means that
this parameter can be used for selecting the centre(s) of a network. Note
that if closeness_thresh=0 then everything is selected.
betweeness_thresh - Again, only the lines with a betweeness
centrality measure at least betweeness_thresh are selected. This
value is always positive and is larger for large networks. It denotes to
what extent a line is in between the other lines in the network. This
value is large for the lines which lie between other lines and lie on
the paths between two parts of a network. In the terminology of road
networks, these are highways, bypasses, main roads/streets, etc.
Also, the outputed network may not be connected if the value of
betweeness_thresh is too large.
v.generalize Tutorial (from GRASS-Wiki)
Daniel Bundala, Google Summer of Code 2007, Student
Wolf Bergenheim, Mentor
Last changed: $Date: 2011-11-08 01:42:51 -0800 (Tue, 08 Nov 2011) $
Main index - vector index - Full index
© 2003-2012 GRASS Development Team