What Is Geometry Simplification in GIS?

Geometry simplification reduces the number of vertices used to represent a line or polygon while trying to preserve its important overall shape. A coastline represented by 20,000 vertices might be simplified to a few thousand—or a few hundred—if that level of detail is unnecessary for the intended map or analysis.

The result is still a line or polygon, but its coordinates have changed. Some vertices have been removed, and the simplified segments approximate the original geometry rather than reproducing it exactly.

Simplification can make vector datasets smaller, faster to render, and less expensive to process. But it is not lossless. Increase the simplification tolerance too far and bends can disappear, boundaries can move, narrow features can collapse, and relationships between neighbouring geometries can change.

The right question is therefore not simply “Can I remove vertices?” It is “How much geographic detail can this use case afford to lose?”

Geometry simplification at a glance

• Before simplification: More vertices; After simplification: Fewer vertices

• Before simplification: More geometric detail; After simplification: Less geometric detail

• Before simplification: Usually larger geometry representation; After simplification: Usually smaller geometry representation

• Before simplification: More expensive to render or process; After simplification: Often faster to render or process

• Before simplification: Closer to the original coordinates; After simplification: Approximation of the original geometry

QGIS describes its Simplify operation as producing line or polygon features with fewer vertices than the input, with methods including distance-based Douglas–Peucker simplification, Visvalingam simplification, and snapping to a grid.

Why vector geometry can contain so many vertices

A straight line segment needs only two endpoints.

Real geographic features, however, are rarely perfectly straight. A coastline, road, river, administrative boundary, or contour may contain many bends.

A line might therefore be stored as:

A •—•—•—•—•—•—•—•—•—• B

rather than simply:

A •--------------------• B

Every intermediate vertex helps describe the shape.

Detailed geometry can originate from:

• high-resolution surveys;

• GPS tracks;

• digitisation at large map scales;

• raster-to-vector conversion;

• remote-sensing products;

• administrative datasets;

• computationally generated boundaries.

That detail may be valuable at one scale and unnecessary at another.

A national boundary used for local cadastral analysis may need substantial detail. The same boundary displayed in a small world overview does not necessarily need every vertex.

Simplification reduces this mismatch between the geometry's level of detail and the task for which it is being used.

Simplification removes vertices according to a rule

A simplification algorithm does not normally remove every second vertex or randomly discard coordinates.

It applies a geometric rule to decide which vertices contribute enough to the shape to remain.

Imagine a nearly straight line:

A •------•----•------•------• B
          slight deviations

Several intermediate vertices may contribute almost nothing to the visible form.

A simplification algorithm may replace those segments with something closer to:

A •--------------------------• B

But consider a sharp bend:

        •
       / \
      /   \
A •--/     \--• B

Removing the vertex at that bend changes the shape much more significantly.

A useful algorithm tries to distinguish between those situations according to a chosen tolerance or importance measure.

Different simplification algorithms define that importance differently.

Tolerance controls how much detail can be removed

Simplification usually exposes a parameter commonly called tolerance.

A low tolerance removes relatively little detail.

A higher tolerance permits greater deviation from the original geometry and can therefore remove more vertices.

Conceptually:

Original
~~~~~~~~~~~~~~~

Low tolerance
~~~~~~~~~~~~~

Medium tolerance
~~~~~\___/~~~~

High tolerance
______/ \_____

The exact meaning of the tolerance depends on the algorithm.

For a distance-based simplification such as Douglas–Peucker, tolerance represents a distance threshold in the units of the geometry's coordinate reference system. PostGIS documents this explicitly for ST_Simplify.

For an area-based algorithm such as Visvalingam–Whyatt, vertex importance is evaluated differently.

This means that a tolerance value cannot be compared blindly across different simplification methods.

10 under one method does not necessarily represent the same geometric decision as 10 under another.

Douglas–Peucker is one common simplification algorithm

One of the best-known simplification methods is the Douglas–Peucker algorithm.

At a high level, it looks for vertices that deviate significantly from a simplified line connecting more distant points. Vertices whose deviation falls within the chosen tolerance can be removed, while more significant deviations are retained.

The result can dramatically reduce the number of points while preserving large bends.

For example:

Original:

A •--•----•-------•
                   \
                    •
                     \
                      •----•--• B

might become:

Simplified:

A •----------------•
                   \
                    \
                     •----------• B

The detailed mechanics deserve their own explanation, so the important point here is simply that simplification is algorithmic. Different methods may retain different vertices even when given the same source geometry.

Visvalingam simplification uses a different idea

Another common method is associated with Visvalingam and Whyatt.

Rather than focusing primarily on perpendicular distance from a simplified segment, it evaluates the effective area associated with vertices.

Vertices contributing very small areas can be treated as less important and removed progressively.

This can produce a different visual character from Douglas–Peucker, particularly for irregular geographic boundaries.

Neither method is universally superior.

The appropriate choice depends on factors such as:

• the geometry;

• intended visual appearance;

• map scale;

• preservation requirements;

• software implementation;

• whether topology between related features must remain intact.

The existence of several algorithms is itself a reminder that there is no unique mathematically inevitable “simplified version” of a feature.

Simplification can improve map rendering

One major use case is cartographic display.

Suppose a web map displays thousands of polygons, each containing thousands of vertices.

At a small zoom level, many of those vertices may correspond to details smaller than a screen pixel.

Sending, decoding, and drawing them still requires resources even though the reader cannot see the difference.

A simplified representation can:

• reduce geometry size;

• lower transfer costs;

• reduce parsing work;

• make rendering faster;

• make interactive maps more responsive.

For this reason, map systems commonly use different geometry detail at different zoom levels.

A highly detailed boundary can be appropriate when zoomed in while a simplified representation is used at continental or global scale.

This is a form of generalisation: the representation is adapted to the scale at which it will be used.

Simplifying for display is not always the same as changing the data

This distinction is particularly important.

A GIS application may simplify geometry only while rendering it.

The underlying stored coordinates remain unchanged.

QGIS, for example, supports rendering-oriented feature simplification that can reduce the geometry used for drawing without permanently modifying the original geometry.

That is different from running a processing operation such as Simplify and saving its output.

In the latter case, the new dataset actually contains different geometry with fewer vertices.

Conceptually:

Rendering simplification

Original stored geometry
        ↓
temporary simplified representation
        ↓
screen

versus:

Geometry simplification

Original geometry
        ↓
simplification operation
        ↓
new simplified geometry

This distinction matters if the data will later be measured, intersected, buffered, exported, or used for another analysis.

A display optimisation can preserve the authoritative source geometry while still speeding up visualisation.

A saved simplified dataset changes what later operations receive.

Simplification can make processing faster too

Rendering is not the only possible benefit.

Complex geometry can make spatial operations more expensive.

An overlay between polygons with millions of vertices may require considerably more geometric computation than an overlay between appropriately simplified versions.

Simplification can therefore be useful as part of a processing pipeline when the removed detail is irrelevant to the question.

For example, an exploratory continental-scale analysis may not require centimetre-level boundary detail.

But this introduces a trade-off.

Simplify too aggressively and the geometry used by the analysis no longer represents the source closely enough.

The optimisation is legitimate only when the resulting loss of detail is acceptable for the analytical purpose.

Simplification changes coordinates

This point is easy to overlook because the resulting feature often looks almost identical.

Suppose a boundary contains:

(0,0)
(1,0.03)
(2,-0.02)
(3,0.04)
(4,0)

A simplification operation might replace that with:

(0,0)
(4,0)

The feature has not simply become cheaper to store.

Its geometric representation has changed.

That means measurements derived from the new geometry can also change:

• length;

• perimeter;

• area;

• centroid;

• distances to nearby features;

• intersection locations.

At low tolerances, the changes may be negligible for the intended use.

At high tolerances, they may not be.

Simplification can distort boundaries

Consider an administrative border containing a narrow projection.

A simplification algorithm may decide that several vertices defining that projection are below its importance threshold.

The simplified boundary can then cut across it.

The polygon may remain valid and recognisable while no longer containing exactly the same locations as before.

This is especially important for geographic boundaries whose precise location carries meaning:

• property parcels;

• legal jurisdictions;

• protected areas;

• electoral boundaries;

• engineering footprints.

A geometry that is perfectly adequate for a small-scale overview map may be unacceptable as the authoritative geometry for legal or analytical decisions.

The dedicated How Simplification Can Distort Boundaries article will examine these effects more closely.

Simplification can affect topology

Topology concerns relationships such as connectivity, adjacency, containment, and shared boundaries.

Suppose two neighbouring polygons share exactly the same detailed boundary.

If each polygon is simplified independently, they are not necessarily guaranteed to produce the same replacement boundary.

One side may become:

/\/\____

while the other becomes:

/\______

The result can contain tiny gaps or overlaps between polygons that originally fitted together perfectly.

This is why topology-preserving or coverage-aware simplification exists.

PostGIS's ST_SimplifyPreserveTopology, for example, constrains simplification so that an individual geometry retains its topology and remains valid. However, its documentation also warns that this does not preserve boundaries shared between separate polygon features; a coverage-specific simplifier is required when those shared edges must remain coincident.

QGIS likewise provides a separate Simplify coverage operation for polygon coverages with matching boundaries.

So the phrase topology preserving needs context. Preserving the structure of each polygon is not automatically the same as preserving the relationships between neighbouring polygons.

Some simplification methods can produce invalid geometry

An ordinary simplification algorithm may not guarantee that the result remains topologically valid.

At aggressive tolerances, polygon rings can behave unexpectedly, narrow structures can collapse, or simplified linework can create problematic geometry.

PostGIS explicitly notes that its ordinary ST_Simplify may return invalid polygonal results and directs users to topology-preserving alternatives when validity must be maintained.

This does not mean basic simplification is unsafe or unusable.

It means that the algorithm should match the requirement.

For approximate visualisation, very fast simplification may be appropriate.

For analytical polygon geometry, preserving validity and relevant topology may be much more important.

Small features can disappear

Suppose a small polygon is represented by only a handful of vertices and the simplification tolerance is larger than important dimensions of the feature.

Depending on the algorithm and implementation, it can collapse or disappear.

The same can happen to very short lines.

This behaviour can be especially noticeable in maps containing many small islands, narrow waterways, tiny administrative units, or short road segments.

Their absence may improve visual legibility at a particular map scale—or it may create a serious analytical omission.

Again, intent matters.

A generalised map of the world does not need to display every tiny island at every zoom level.

A dataset being used to determine whether a particular island lies inside a protected zone might.

More vertices do not automatically mean more accuracy

It is tempting to treat the most detailed geometry as the most accurate geometry.

That is not always true.

A line containing one vertex every metre is not necessarily accurate to one metre.

The points could have originated from:

• noisy GPS measurements;

• raster tracing artefacts;

• an inaccurate source map;

• interpolation;

• an unnecessarily dense export.

Simplification removes geometric detail. It does not tell you whether that detail was meaningful in the first place.

Conversely, a simplified geometry with fewer vertices is not automatically less useful. At the scale and precision for which it was designed, it may be the more appropriate representation.

Vertex density and positional accuracy are different properties.

Simplification is not smoothing

Simplification and smoothing are often grouped together because both can make geometry look less complex.

They do different things.

Simplification primarily aims to reduce geometric detail, often by removing vertices.

Smoothing primarily aims to soften sharp changes in direction and create a less angular or jagged shape.

Smoothing can even increase the number of vertices.

For example:

Original
/\/\/\/\

Simplified
/\/\

Smoothed
~~~~~~~

The simplified line contains fewer significant bends.

The smoothed line has a softer form.

A workflow that wants fewer coordinates is therefore not necessarily asking for smoothing, while a map that needs visually flowing contour lines is not necessarily asking for simplification.

The next article, Simplification vs Smoothing, owns that comparison.

Simplification is not general geometry cleaning

Simplification can remove small-looking details, but it should not be treated as a universal repair operation.

If a polygon contains:

• self-intersections;

• duplicated vertices;

• gaps;

• overlaps;

• inaccurate boundaries;

reducing its vertex count does not necessarily correct those problems.

Likewise, if a raster-to-vector conversion produces a staircase boundary, simplification may visually reduce the effect, but that does not establish that the resulting line is geographically more accurate.

Use simplification when reducing geometric complexity is itself justified.

Use validation, repair, snapping, conflation, or other processes when the problem is actually data quality.

Tolerance should follow the intended scale and precision

There is no universal simplification tolerance such as:

Always simplify boundaries by 10 metres.

Ten metres might be negligible for a world coastline dataset and unacceptable for a cadastral parcel.

An appropriate tolerance depends on questions such as:

• At what map scale will the geometry be shown?

• What is the source data's actual precision?

• How much positional deviation is acceptable?

• Will the output be used only for visualisation?

• Will measurements or overlay operations use the simplified geometry?

• Are neighbouring polygons expected to retain shared boundaries?

• Can small features disappear?

• Does legal or scientific interpretation depend on fine boundary detail?

Tolerance is therefore a modelling decision, not merely a performance parameter.

Different zoom levels can use different simplifications

A useful mapping system does not always need one simplified dataset.

Instead, geometry can be generalised progressively.

At a close zoom:

many vertices
high detail

At a regional zoom:

fewer vertices
moderate detail

At a continental zoom:

much fewer vertices
only major shape retained

This allows maps to preserve useful detail when readers can see it while avoiding unnecessary geometry when they cannot.

The idea is especially relevant for vector tiles and multi-scale web maps.

The correct simplification is therefore often scale-dependent rather than global.

When should you simplify geometry?

Simplification is a good candidate when:

A dataset contains substantially more geometric detail than the current representation requires.

Examples include:

• preparing boundaries for small-scale web maps;

• reducing the size of vector tiles;

• speeding up exploratory rendering;

• producing a generalised overview dataset;

• reducing unnecessary vertices created during vectorisation;

• simplifying geometry before an analysis whose required precision is coarser than the source data.

But simplification deserves caution when:

• exact boundaries carry legal significance;

• fine-scale spatial relationships matter;

• area or length must remain highly precise;

• narrow features are important;

• neighbouring polygons must remain perfectly coincident;

• the output will replace the authoritative source geometry.

The solution may be to preserve the original dataset and create a separate simplified derivative rather than modifying the source.

A simple workflow for choosing a simplification level

Rather than entering a large tolerance and accepting whatever comes out, compare several levels.

For example:

1. preserve the original geometry;

2. create a low-tolerance simplified version;

3. create a moderate version;

4. compare vertex counts;

5. inspect important boundaries and small features;

6. test any measurements or analyses that matter;

7. select the lowest-detail representation that still satisfies the use case.

This turns simplification into an explicit trade-off rather than an aesthetic guess.

For production datasets, documenting the algorithm and tolerance also makes the derivative reproducible.

The objective is appropriate detail, not the fewest possible vertices

Geometry simplification is sometimes presented as an optimisation contest:

50,000 vertices became 2,000.

That number can be useful, but it does not tell you whether the result is good.

A geometry reduced by 95 percent is impressive only if the remaining 5 percent still represents everything the use case requires.

The purpose of simplification is therefore not to remove as many vertices as possible.

It is to remove unnecessary geometric detail while retaining enough structure for the intended map or analysis.

That balance changes with scale, source quality, geography, algorithm, and purpose.

So before simplifying, ask:

Which details matter at the scale and precision of this task?

Then choose the method and tolerance around that requirement.

A simplified feature is not the original feature made more efficient. It is a new approximation of that feature—and it should be treated accordingly.

References

1. QGIS Documentation — Simplify. Documents QGIS geometry simplification as reducing vertices in line and polygon features and describes its distance-based Douglas–Peucker, area-based Visvalingam, and snap-to-grid methods.

2. PostGIS — ST_Simplify. Defines Douglas–Peucker geometry simplification, explains tolerance in the units of the input spatial reference system, and documents potential loss of validity and topology under ordinary simplification.

3. PostGIS — ST_SimplifyPreserveTopology. Documents topology-preserving simplification and clarifies the important limitation that preserving an individual geometry's topology does not itself preserve shared boundaries between separate polygon features.