lrs(1grass)

📦
version 8.5.0 · 9 versions
, in alpine 3.24, ubuntu stonking

✨ LRS — Toolset for LRS (Linear Referencing System) ✨

okay so this is the lrs(1grass) page from the GRASS User's Manual, and bestie, it's a whole vibe 💅 it's a toolset, not a single command, so buckle up 🎀

🌸 DESCRIPTION 🌸

okay so real talk: a Linear Referencing System (LRS) is a system where features (points or segments) get localized by a measure along a linear element. That's it, that's the whole girlboss concept 💖

The LRS can be used to reference events for any network of linear features — like roads, railways, rivers, pipelines, electric and telephone lines, water and sewer networks. An event is defined in LRS by a route ID and a measure. A route is a path on the network, usually composed from more features in the input map. And events can be either points or lines (segments). no cap 🫶

LRS is created from input lines and points in vector map. The points — MP (mileposts) — must have attached attributes specifying line and distance. The distances from the beginning of the linear feature in real world are specified by MP+offset. Typically, MP is in kilometers and offset in meters. iconic fr 📏

The implementation of LRS in GRASS has some particularities. buckle up 🦋

💫 Double referenced system 💫

This feature gives a possibility to continue to use most of old mileposts if only a small part of a linear object in real world has changed. Example time:

--- road (linear feature)
 +   MP (milepost, point, distance from the beginning in km)
Old situation:
+----+----+----+----+----+
0    2    3    4    5    6
New situation (for example a new bypass around the village)
          ?    ?
          +----+
          |    |
          |    |
+----+----+    +----+----+
0    2    3    4    5    6

so the segment between km 3 and 4 is now longer — it's now 3 km, not 1 km like in the old version. It would be expensive to change also all MP >= 4, but bestie, we cannot use km 4 twice 😭 It IS possible to use another notation for the new segment: we reference the segment from the kilometer 3, using only offset. like:

      3+1000  3+2000
          +----+
          |    |
          |    |
+----+----+    +----+----+
0    2    3  3+3000 5    6
               4

This way, there is no ambiguity and minimal changes are needed. But the MP 4 is no more the end of segment 3 - 4, it's now the end of segment 3+2000 - 3+3000. This information must be entered to the system, and it is done by optional MP attributes:

  • end_mp — end MP
  • end_off — end offset

In this case original MP on km 4 will have these attributes:

start_mp:  4
start_off: 0
end_mp:    3
end_off:   3000

Because each MP can keep 2 values (start, end) it is called a 'double' referenced LRS. two moods, one milepost 💅

To avoid potential confusion, MP values are limited to integers only. It would be ambiguous to have for example segments 3.500 - 3.500+200 and 3.600 - 3.600+200. The position 3+650 would fall into 2 segments, correct would be 3.600+50. That means MP must be the beginning of an autonomous segment, and all parts which become longer than before must be referenced from the last not-changed MP. lowkey strict but it's for your own good 🙈

The MP start_mp and end_mp columns must be decimal, but v.lrs.create takes only the decimal part, and adds its value to offset and prints a warning. ⚠️

It is highly recommended to work with polylines instead of segmented vector lines. The command v.build.polylines creates this map structure. do it bestie, don't be messy 🌸

📋 LRS table structure 📋

okay here's the whole table layout, one bullet per column because we're keeping every single detail 👑

  • rsid — integer — reference segment ID, unique in the table
  • lcat — integer — category of the line in the LRS map
  • lid — integer — route ID (LID)
  • start_map — double precision — distance measured along the line in LRS map from the beginning of the line to the beginning of the segment (absolute milepost distance)
  • end_map — double precision — distance measured along the line in LRS map from the beginning of the line to the end of the segment (absolute distance of subsequent milepost)
  • start_mp — double precision — milepost number assigned to the start of the segment
  • start_off — double precision — distance from start_mp to the start of the segment measured along the physical object
  • end_mp — double precision — milepost number assigned to the end of the segment
  • end_off — double precision — distance from end_mp to end of the segment measured along the physical object
  • end_type — integer — 1: the same as specified for from_ ; 2: calculated from map along the line from previous MP; 3: defined by user

🎀 Available commands 🎀

  • v.lrs.create — to create a linear referencing system,
  • v.lrs.label — to create stationing on the LRS,
  • v.lrs.segment — to create points/segments on LRS, and
  • v.lrs.where — to find line id and real km+offset for given points in vector map using linear referencing system.

the whole squad honestly 🫶

🧚 Input lines for v.lrs.segment and v.lrs.label 🧚

v.lrs.create joins all connected lines of the same line ID into one line — the LRS library and other modules using LRS expect this! (like, they expect it, do not test them 😭)

LR_get_nearest_offset in the LRS library checks duplicate segments only by line_cat and map_offset, not by coordinates in map. noted. periodt. 💅

💀 Duplicate positions 💀

It can happen that one offset appears on 2 different lines:

------1-------     --------2------
+0.0            +1.0              +2.0

In this case, the module gives error because the position results in 2 points. 💀

It can be also intended, for example a part of the road is shared with another one, but MP are used only for one:

 + road1/km15         + road1/km22
  \                  /
   \ road1/km17     / road1/km20
    +--------------+
   / road2/km52     \ road2/km52
  /                  \
 + road2/km50         + road2/km54

sharing is caring, but the MP are monogamous for this one 🥰

✨ NOTES ✨

Explanations of selected options, coming right up:

  • llayer — vector layer in line map (usually 1; see vectorintro for "layer" concept)
  • player — vector layer in point map (usually 1; see vectorintro for "layer" concept)
  • rsdriver — Driver name for LRS table - DBMI SQL driver (dbf, pg, mysql, sqlite, etc)
  • rsdatabase — Database name for LRS table - DBMI SQL database name (e.g., "lrsdb")
  • rstable — Name of the LRS table - DBMI SQL table name (e.g., "streamslrs")

📚 SEE ALSO 📚

go read the lore bestie, it's giving academic:

  • R. Blazek, 2004, Introducing the Linear Reference System in GRASS, Bangkok, GRASS User Conf. Proc.
  • R. Blazek, 2005, Introducing the Linear Reference System in GRASS, International Journal of Geoinformatics, Vol. 1(3), pp. 95-100

and the modules you'll actually be typing:

  • v.build.polylines
  • v.lrs.create
  • v.lrs.segment
  • v.lrs.where
  • v.lrs.label

💖 AUTHORS 💖

  • Radim Blazek, ITC-irst/MPA Solutions Trento
  • Documentation update (based on above journal article and available fragments): Markus Neteler

🔥 SOURCE CODE 🔥

Available at: LRS source code (history)

Accessed: Friday May 08 10:38:24 2026

Main index | Topics index | Keywords index | Graphical index | Full index

and that's the tea ☕ this whole thing is lrs(1grass) from GRASS 8.5.0, the GRASS 8.5.0 Reference Manual, © 2003-2026 GRASS Development Team, and we were last touched by the fine folks on Friday May 08 10:38:24 2026. slay, go build yourself a linear referencing system bestie 💅✨🌈

📦 where this page comes from