Gilgrim Data Sources and ODbL Notice

Data sources and ODbL notice — Gilgrim

1. Attribution

© OpenStreetMap contributors

Walking-path information and courses in Gilgrim are derived from OpenStreetMap data. OpenStreetMap data is made available under the Open Database License (ODbL) 1.0. Attribution and license information is available at https://www.openstreetmap.org/copyright.

Contains information from OpenStreetMap, which is made available here under the Open Database License (ODbL).

2. The course data is an ODbL derivative database

The course catalog that Gilgrim provides to the app (one course JSON file per district, plus an index) is a derivative database made from OpenStreetMap data. In line with section 4.4 of ODbL 1.0 (share-alike), this catalog is offered under the same terms (ODbL). What is covered is the whole catalog prepared in advance, rather than the individual route guidance generated when the app calculates a course.

The intellectual property in the Gilgrim app and service itself belongs to Naran; this notice concerns the database made from OpenStreetMap.

3. How the derivative database is provided

Section 4.6 of the ODbL requires anyone who publicly uses a derivative database to provide either (a) the entire derivative database or (b) the method of making the alterations (such as an algorithm). Gilgrim provides both of the following, free of charge.

MethodDetails
Section 4.6 (a): the entire derivative database (course catalog and walking graph)Email contact@naranstudio.com and we will send you a link to download it free of charge. Processing time: within 14 days of receiving your request.
Section 4.6 (b): method documentHow the catalog is made from OpenStreetMap (walking-tag rules, graph assembly, the course generation method and the file field definitions) is written out in full in 6. Method document (full text) below on this page. Anyone can read it without making a request.

How to request it

  1. Send an email to contact@naranstudio.com with the subject "Gilgrim ODbL derivative database request".
  2. You do not need to write anything in the body other than the email address you want us to send it to. Please do not include personal information such as your location, name or phone number.
  3. The file you receive is a compressed archive (zip or tar.gz) that contains the following: the per-district course JSON files and the index (catalog/…), the walking-graph array files and the district, connected-component and metadata files (graph/…; the file formats are described in README.txt, the graph's meta.json is a copy with the internal working-path fields removed, and the hash correspondence to the original is in MANIFEST.json), the ODbL notice and full text (LICENSE-ODbL.txt, the copy of the license under section 4.2 (b)), the explanation (README.txt), the file list, hashes and input-data date (MANIFEST.json), and the method document (derivative-db-method.md). If the size is large, the catalog and the graph may be sent as two separate archives.
ItemDetails
Scope providedThe course catalog and walking graph for the domestic areas in service (the 47 districts of the Seoul metropolitan area and the other domestic areas). Overseas cities will be included in the same way from the time they become part of the service. As the service area grows, the scope provided grows with it.
Data date2026-09-22 (OpenStreetMap snapshot; the exact time is in graphVersions in MANIFEST.json)
LicenseOpen Database License (ODbL) 1.0
Contact for requestscontact@naranstudio.com

4. No personal information is included

The course paths and entry-point coordinates in the catalog are points on publicly mapped paths in OpenStreetMap, and the guide lines on the map are shape outlines placed to fit the courses. No user location, install ID or request information is included in the catalog, and when the files are produced, the item names in all JSON files are checked to make sure no such names are present. Your location is used only while a course is being calculated and is not stored. For how personal information is handled, see the Privacy Policy.

5. Full license text

6. Method document (full text)

Below is the full text of the document provided as the "method of making the alterations" under ODbL section 4.6 (b). A file with the same content (derivative-db-method.md) is also included in the package we provide.

Document version: 2026-10-28 revision 2 (reflects Codex verification #8: seed, distance-field and matching rules aligned with the code) · Operator: Naran (naranstudio.com) · Contact: contact@naranstudio.com

Public information page: https://naranstudio.com/gilgrim/odbl

This document describes how the "Gilgrim course catalog" (a derivative database) is made from OpenStreetMap data, in enough detail that the same kind of result can be produced again from the same input. Section 4.6 of ODbL 1.0 requires a person who publicly uses a derivative database to provide recipients, in a machine-readable form, with either (a) the entire derivative database or (b) "a file containing all of the alterations made to the original database, or the method of making the alterations (such as an algorithm)". This document is the description that corresponds to the "method of making the alterations" in (b); (a) is provided on request through the same information page. This document contains no coordinates (latitude/longitude) and no user information. It also contains no secrets, server addresses or keys from the code. It is a technical description, not a judgment on legal effect. A legal professional has not yet confirmed whether this document satisfies 4.6(b) ([Confirmation needed]).

0. Overview

OSM source (Geofabrik per-country extract, .osm.pbf)
  └─① Select only walkable ways using the walking-tag rules
  └─② Attach node coordinates and build the walking graph (CSR) — edge lengths, stairs bit, district assignment
  └─③ For each district, place seed grid points, lay 6 shapes x 3 distances as shape lines and fit them to the roads (map-matching), and store only the courses that pass as a JSON catalog
  • The output of ① and ② (the walking graph) is a derivative database of OpenStreetMap data and is used only inside the service server (this follows the reading that internal use within an organization is not public use under ODbL 4.5(c); it has not yet been confirmed by a legal professional [Confirmation needed]). To keep the share-alike conditions broadly, however, this graph too is provided free of charge on request, in the same way as the course catalog (operator's delegated decision, 2026-10-28). The graph package consists of CSR array files (edges, lengths, attribute bits, node coordinates), district numbers, connected components and a metadata file (serving-only files and internal measurement files are not included); the format of each file (data type, length, meaning) is described in the README inside the package. All domestic graphs in service are covered by default, and for overseas cities only the graphs that are part of the service are included. The graph's meta.json is included as a copy with the fields that contain the producer's internal working paths (such as note) removed, and the MANIFEST lists the sha256 of both the original and the copy.
  • The output of ③ (the course catalog) is the source of the courses offered in the app. The package provided together with this document is exactly this.

1. Input — OSM snapshot

ItemDetails
SourceGeofabrik per-country/region extracts (*-latest.osm.pbf), OpenStreetMap data, © OpenStreetMap contributors, ODbL 1.0
South Korea (Seoul, Gyeonggi, Incheon, nationwide shards)south-korea-latest.osm.pbf (287,765,288 bytes, md5 b5214eac6cc39075d254ec4d8531c6d0), OSM replication timestamp 2026-09-22T20:22:59Z (the same as the graphVersion value of the graph and the catalog)
Overseas (pilot cities, not yet in this package)Japan regions such as Tokyo and Osaka, US state-level extracts, Australia extract — all with replication timestamp 2026-10-25T21:21:21Z
RetentionGeofabrik's "latest" files are updated continuously, so the same bytes cannot be downloaded again. All that exists is a record that OSM data as of this timestamp was the input. To obtain the same kind of result, run the same procedure on an extract from another point in time (the result will differ according to OSM edits).

2. Step ① — Selecting walkable ways (walking-tag rules)

Each OSM way (a line of road) is judged by its tags. The rules below follow the judgment order of the actual judgment code (for domestic and overseas use) as is. The rule that matches first, from the top, wins.

2.1 Domestic (South Korea) rules

Sets used:

  • List HW = footway, path, pedestrian, steps, living_street, track, corridor, residential, unclassified, tertiary, tertiary_link, secondary, secondary_link, primary, primary_link, service, road, cycleway
  • foot deny values = no, private, use_sidepath / foot allow values = yes, designated, permissive, destination
  • access deny values = no, private, permit, agricultural, forestry, customers, delivery
OrderConditionResult
1The way has neither highway nor foot, or highway ∉ HW and foot ∉ allow valuesExcluded (not a target)
2foot ∈ deny valuesExcluded
3foot ∉ allow values and access ∈ access deny valuesExcluded
4area=yesExcluded
5indoor=yesExcluded
6Fewer than 2 nodesExcluded
7Anything elseIncluded
  • Effect: roads in the list HW are included by default, and a highway outside the list, such as motorway, trunk, construction, busway or proposed, is included only when foot is explicitly set to an allow value (yes, etc.) (the code has a separate "prohibited highway" set, but anything outside the list is already filtered out at rule 1, so the result is the same as the table above). A foot allow value overrides an access deny.
  • Edge attribute bits (determined from the way's tags and attached to every edge of that way): 1 = highway=steps (stairs), 2 = track, 4 = service, 8 = cycleway, 16 = surface ∈ {unpaved, gravel, dirt, ground, sand}.
  • Basis document (operator-internal): walking profile v2. Cycleways (cycleway) are included because in Korea many serve as shared walking paths along streams.

2.2 Overseas rules (per-country v2) — this package has no overseas catalog, but they are described here as the graph-making method

The order of rules 1–7 for domestic is used as the base, but tag values are normalized first (OPL escape decoding, trimming leading and trailing whitespace, lowercasing; a ; multi-value is split into its parts, and it is denied if any part is a deny value / for allow values the strongest one is used; for area, indoor, motorroad, expressway and tunnel, the result is yes if any part is yes). If highway is a ; multi-value, one is chosen in the order motorway family > construction/proposed > trunk family > the first value that is in the list HW > the first value; for foot and access, if any part is a deny value that value is used, otherwise the strongest allow value is used (for foot, in the order designated > yes > permissive > destination). The judgment order after that is:

OrderConditionResult
1foot ∈ deny valuesExcluded
2highway ∈ {motorway, motorway_link}Excluded (even with foot=yes)
3motorroad=yesExcluded
4highway ∈ {construction, proposed}Excluded (even with foot=yes)
5If highway ∈ {trunk, trunk_link}, first apply the access deny, area, indoor and 2-or-more-nodes rules (domestic rules 3–6), then the separate guard below
6Otherwise, the same common rules as domestic (list HW, foot allow, access deny, area, indoor, 2-or-more-nodes)

Trunk-family guard: "sidewalk present (SIDE_OK)" = any value of sidewalk is one of both/left/right/yes/separate, or any of sidewalk:both, sidewalk:left, sidewalk:right has yes/separate. "Explicitly no sidewalk (SIDE_NO)" = at least one of the following three is true: (a) sidewalk has a value and all of its parts are no/none, (b) sidewalk:both has a value and all of its parts are no/none, (c) sidewalk:left and sidewalk:right both have values and each has parts that are all no/none. With contradictory sidewalk tags (for example sidewalk=no together with sidewalk:left=yes), SIDE_OK and SIDE_NO can both be true, and the Japan rule below looks at SIDE_NO before EV. "Pedestrian evidence (EV)" = SIDE_OK, or foot=designated, or (foot=yes and not SIDE_NO).

  • Japan: SIDE_NO and foot≠designated → excluded (even with EV) / trunk_link without EV → excluded / trunk with expressway=yes, tunnel=yes or maxspeed>60 (only when it reads as a numeric km/h) and without EV → excluded / otherwise included.
  • US and Australia: trunk and trunk_link are included only when EV is present.
  • Edge bits are the same as domestic (judged using the normalized highway).

3. Step ② — Assembling the walking graph (CSR)

  1. Collect the node references (node ids) of the selected ways, and read only the coordinates of those nodes (longitude and latitude x 10^7 as 32-bit integers) from the source.
  2. For every two consecutive nodes in a way, create 2 bidirectional edges. A way that has even one node without coordinates is excluded entirely. Parallel edges are not merged, and 0 m edges are kept.
  3. Edge length = the haversine distance between the two nodes (Earth radius 6,371,000 m), rounded to whole metres (16-bit; values above 65,535 are clamped to 65,535). The edge attribute bits are copied as is from the values in 2.1.
  4. Only nodes that take part in edges are kept, and they are renumbered 0..N-1 in ascending OSM node id order. Edges are sorted by (source node number, destination node number) and stored as CSR arrays (indptr, indices, lengths, flags) plus a node coordinate array (coords).
  5. District assignment: the boundary ways of administrative-area relations (boundary=administrative, admin_level 6 = city/county/district, 4 for Sejong) are joined where their end points coincide to form closed rings (outer/inner). A node inside a district polygon (even-odd test; if they overlap, the first matching district) gets that district number; a node outside the districts but within 2,000 m of a boundary is marked "buffer" (255); the remaining nodes are discarded. The service-area shards (the 47 districts of the Seoul metropolitan area, and 6 other domestic shards) are subgraphs of the nationwide graph that keep only the edges between nodes of the relevant districts (node numbers are reassigned keeping the original order).
  6. Connected components: undirected connected components are computed, each node stores its component number (16-bit), and the largest component is marked separately. Course seeds are afterwards placed only inside components of at least a certain size (4.2).
  7. For an overseas city graph, only the nodes inside a circle of radius R (set per city) around the city centre are assigned to districts; those up to radius + 2,000 m are buffer, and anything farther is discarded. The rest is as above.

4. Step ③ — Generating the course catalog

Processed one district (city/county/district) at a time. The catalog pipeline name is v30-p1.

4.1 Shape templates (6 kinds, closed curves of unit perimeter 1)

heart, star (5-point star), letter_L (the letter L), triangle (equilateral triangle), square, circle.

  • heart: x = 16 sin³t, y = 13 cos t − 5 cos 2t − 2 cos 3t − cos 4t (t from 0 to 2π).
  • circle: (cos t, sin t).
  • star: 10 vertices with outer radius 1 and inner radius 0.5 / triangle: circumscribed circle radius 1 / square: (±1, ±1) / letter_L: vertices (0,0)(0.6,0)(0.6,0.3)(0.3,0.3)(0.3,1)(0,1).
  • Each curve is normalized so that its perimeter is 1 (for star, triangle, square and letter L, the perimeter of the line connecting the vertices; for heart and circle, the perimeter of the line connecting 4,096 points sampled from the formulas above). Then the mean of 1,024 points taken evenly along the perimeter is moved to the origin. y is up.
  • Rotation and mirror policy: heart, circle, star, square and triangle use 24 rotations at 15-degree steps x mirror on/off; letter_L uses rotations {345, 0, 15} degrees with no mirror. Mirroring flips the sign of x and is applied first, followed by a counter-clockwise rotation.

4.2 Seed grid — two modes

There are two ways of placing seeds, depending on the build mode. If the district file's seedStats has a seed_tier entry, it was built in mode 2; if not, in mode 1.

  • Mode 1 — the initial build of the 47 Seoul-metro districts (no density tiers): every grid point in 1 below is a candidate. Snap candidate nodes are limited to nodes in the largest connected component.
  • Mode 2 — domestic expansion shards and overseas cities: each grid point is assigned a density tier A/B/C, C is discarded, and only the tier to be run (one of A, B, AB) produces courses. Snap candidate nodes are nodes in a connected component of 5,000 nodes or more that are not district buffer (255) nodes. A district file whose seed_tier is A was built from tier-A seeds only, so it contains no courses from tier-B seeds.
  1. Place grid points at 1 km spacing inside the district polygon (the area left after subtracting inner from outer). The plane approximation is 1 degree of latitude = 111,320 m, with longitude corrected by the cosine of the mean latitude of the district boundary vertices. The grid lies at integer multiples of 1,000 m in these plane coordinates, and the position of the district's bounding box left and bottom rounded down to 1 km is counted as column 0 and row 0. For overseas cities, only grid points inside the city service-radius circle are additionally used (for the other district, the area left after subtracting the actual districts from the circle).
  2. (Mode 2 only) For each grid point, count the number n of graph nodes belonging to this district inside the 1 km x 1 km cell centred on that point ([g−500 m, g+500 m)) (only nodes whose district number is this district; buffer 255 is not counted).

- Tier A: n ≥ 300 → every grid point is used as a seed candidate.

- Tier B: 150 ≤ n < 300 → only points whose column and row numbers are both even (in effect 2 km spacing) are used.

- Tier C: n < 150 → no seed is placed.

  1. Seed candidate grid points are snapped to the nearest graph node within 300 m. The candidate node conditions are: the component condition of the mode above, degree ≥ 2 (at least 2 edges leaving the node), not more than 400 m outside the district bounding box, and in mode 2 not a buffer node. If there is no candidate within 300 m, that grid point is discarded. Of seeds snapped to the same node, only the one that comes first in grid order is kept. The seed number is <2-digit district number>-<4-digit serial number>, assigned in ascending grid y and then ascending grid x over the list after snapping and de-duplication. In mode 2, numbers are assigned over the full list of tier A and B and then only the tier to be run is kept, so seed numbers of a district run with one tier only may not be consecutive.

4.3 Shape template matching (seed x 6 shapes x distance {3000, 5000, 8000} m)

  1. Local graph: take a square window aligned to the latitude/longitude axes (radius R) with the seed node as origin. R = D + 700 + 400 + 100 m, where D is obtained as follows: place each of the 6 shapes with perimeter = target distance x 1.15 (the maximum scale), compute the maximum distance between two points on the shape (taking the shape line as 512 points), and take the maximum over the 6 shapes (computed separately for each target distance). Of the nodes in the window, keep the nodes in the same connected component as the seed and the edges whose both ends are inside the window, and remove stairs edges (bit 1). A road that connects only by crossing stairs is cut at this stage.
  2. Placement candidates and distance-field approximation: the perimeter of the shape line = target distance x scale, with scales {0.85, 0.92, 1.0, 1.08, 1.15}. Centres are 100 m grid points within 700 m of the seed origin (exactly 700 m included), and rotation and mirror follow the policy in 4.1. The "distance to the graph" used when screening placements is not an actual nearest-node query but a value of a 6 m-spacing distance field (raster). The distance field is computed in advance by dividing the area formed by the local graph's node extent plus 50 m on every side into 6 m cells and calculating, for each cell centre, the distance to the nearest node; a lookup reads the value of the cell nearest to the point, so it can differ from the real value by up to about 4.3 m (= 6 m x 0.71). Points outside the raster are treated as 10,000 m. Take 256 points along the shape line by perimeter ratio, and keep only placements for which the median of the distance-field values at 16 of them (every 16th) is 150 m or less; then keep only placements for which the 90th percentile (linear interpolation) of the values at 64 points (every 4th) is 120 m or less. Sort by (90th percentile, mean) ascending and look at the top 100 placements. Because of this approximation, the selection for placements near a threshold can differ from what would result from calculating with real distances.
  3. Map-matching (tube matching): put a tube of width ε around the shape line and find a graph path that follows the shape line from start to end in order (without going back) without leaving the tube (discrete Fréchet map-matching). The detailed rules are as follows.

- Layer curve: divide the shape line into k points. k = round(perimeter ÷ 25 m) clamped to 64–200. For polygonal shapes (star, triangle, square, letter L), the points near a vertex (within 0.3 times the spacing) are removed and the vertex is added, so that vertex positions are always included as points. The start of the curve is the point on the placed shape line nearest to the seed origin. The region of layer i is within ε of the i-th segment of the curve.

- Transitions: from a (node, layer) state: ① move along one edge in the same layer, ② stay in place and go up one layer only (cost 0.001), ③ move along an edge and go up one layer at the same time. Layers never decrease. An edge longer than the average spacing of the layer curve can skip at most min(8, 1 + floor(edge length ÷ average spacing)) layers at a time, and when it skips 2 or more layers, the edge midpoint must also be within ε of the segment of the middle layer of the skipped span.

- Start and end nodes: only the 3 local-graph nodes nearest to the curve start are start candidates. A closed curve must start and end at the same node (both layer 0 and the last layer inside the tube), and paths possible only from the fourth or later nearest node are not searched.

- Minimum tube width ε: find the minimum feasible value ε* in 5 m steps in the range 10–400 m. First test at 80 m; if infeasible, test once more at the upper limit (400 m), then binary-search on the feasible side. If there are already 5 or more different paths that passed the length, U-turn and stairs conditions for the same (seed, shape, distance), the search upper limit is lowered to the value of min(0.10, ε/width of the fifth-best path) x shape width rounded up to a 5 m unit (at most 400 m), and any ε* larger than that is discarded without further search.

- Path selection: inside the tube of ε*, the path with the smallest sum of edge costs, where edge cost = length x (1.5 if the service bit 4 or the unpaved bit 16 is set, otherwise 1; stairs have already been removed), is taken as the course (the smallest among the 3 start candidates). The path length is the sum of the integer-metre lengths of its edges. It follows only real roads and does not join non-existent roads with straight lines.

  1. Acceptance conditions: (a) the real path length is within ±20 % of the target distance, (b) ε*/shape width ≤ 0.10 (shape width = the larger of the x range and the y range of the layer-curve points), (c) at most 1 U-turn (in the path's node sequence, a place where the node two steps later is the same, like A-B-A), (d) 0 stairs edges on the global graph (when all parallel edges between two consecutive nodes are stairs, it counts as stairs), (e) among paths with the same edge set, only the one with the smaller ε/width. For each (seed, shape, distance) combination, at most 5 are kept in ascending (ε/width, length) order, excluding those whose edge-set Jaccard similarity with an already kept one exceeds 0.7. Each combination has a processing time limit (240 seconds), and if it is exceeded, the remaining placements are not processed (so the result may vary with the speed of the machine it was run on).
  2. District assembly: gather all seed results of the district and sort them in (ε/width, length, seed) order, and discard any whose edge-set Jaccard similarity with an already adopted course exceeds 0.7. The remaining courses are given courseId = <district>-<4-digit number> in (shape name, target distance, ε/width) order.
  3. Index: from the courses of all districts, an index.json is made that groups the centre (bbox centre) and the 3 entry points into 0.01-degree grid cells (floor(lat/0.01)_floor(lon/0.01)).
  4. Before being put into service, there is a step that compiles the catalog into an array format for the server (the content is the same and only the format differs); it neither adds nor changes information. Files and courses that fail the format check of the compile (server-load) step may be excluded from the service, so the courses in service may be a subset of this catalog.

5. Output format (files inside the package)

5.1 <district>.json (district file)

Top level: schemaVersion, catalogVersion·pipeline (v30-p1), regionId, districtIndex, districtName, graph (the name of the relative path of the graph folder within the repository, for example out/graph_kr_s6_jeju; it corresponds to the name of the package's graph/<name>/ folder), graphVersion (the input OSM replication timestamp), params (below), seedStats (aggregates such as the number of seeds, snap failures and de-duplications; for a district built in mode 2 it also includes seed_tier and the number of grid points and seeds per tier), seedsProcessed, coursesRaw (before de-duplication), coursesAfterDedupe, attribution, courses (array).

params: seed_grid_m 1000, snap_m 300, center_r_m 700, center_grid_m 100, top_placements 100, scales, rot_step_deg 15, eps_ratio_max 0.1, len_tol 0.2, uturn_max 1, jaccard_max 0.7, keep_per_combo 5, templates, dists, stairs_excluded_from_graph true.

One course (courses[i]):

FieldMeaning
courseIdCourse number (<district>-<4 digits>)
shapeIdShape (heart, star, letter_L, triangle, square, circle)
dist_targetTarget distance (m): 3000 / 5000 / 8000
geometryArray of course path vertices [latitude, longitude] (6 decimal places). A closed curve, so the first and last are the same node
guideGeometryThe shape line fitted to the course (64 points) [latitude, longitude] — a guide line on the map. It is not points on roads but the placed shape laid on the plane
lengthMetersReal length of the path (m)
epsMetersMinimum tube width ε*(m) found by map-matching — how far the course departs from the shape
epsRatioε* / shape width (smaller means closer to the shape; only 0.10 or less is adopted)
widthMetersShape width (m)
uturnNumber of U-turns (0 or 1)
entryNodes3 entry points on the course (nodeIndex graph node number, lat, lon, atMeters cumulative distance along the path) — the start, 1/3 and 2/3 points
seedIdNumber of the seed that produced the course
placementShape-line placement values: s scale, rot rotation (degrees), mir whether mirrored, cx·cy centre offset from the seed (m, east and north)
builtAtGeneration time (UTC)
bbox[min latitude, min longitude, max latitude, max longitude]

The coordinates in geometry and entryNodes are OSM walking-graph nodes (points on publicly mapped roads), and guideGeometry is the placed shape line (which may not be on roads). Neither comes from any user's location or identifier, and no such values are included (when the package is generated, the key names in all JSON files are checked to confirm that requestId, install and the like are absent).

5.2 index.json

schemaVersion, cellSizeDeg 0.01, cellKey, attribution·attributionUrl·license·licenseUrl, courseCount, courses (per-course summary: courseId, regionId, shapeId, dist_target, lengthMeters, epsRatio, bbox, center, entry, cells), cells (cell → list of courseId).

5.3 Service-area file regions-manifest.json (public GET /v1/regions/manifest)

  • For each area in service: regionId, shard, number of served courses, course counts per shape, catalog version, and the area boundary (GeoJSON MultiPolygon, [longitude, latitude]). Generated by work/api/regions_manifest.py (run after catalog compilation).
  • Boundary source: polygons made from OSM administrative boundary relations (cities/counties/districts in South Korea; per-city areas overseas). Coastal areas include the seaward administrative boundary.
  • Simplification: Douglas–Peucker with a 50 m tolerance (in metres, on a local plane projection at the area's central latitude), coordinates rounded to 5 decimals. Measured maximum area error from simplification: 0.46 % across the 47 Seoul-metropolitan areas.
  • Areas with no courses are included with courseCount: 0.

6. Points to note when reproducing

  • Even with the same input and the same procedure, the result may not be bit-for-bit identical because of floating-point arithmetic and the time limit (the per-combination run limit of 240 seconds).
  • Seed numbers and course numbers change when the input OSM data changes.
  • The code is not a subject covered by the ODbL (section 2.3 (a): the license does not apply to computer programs used to create or operate the database). The code is not published (operator's delegated decision, 2026-10-28), and this document is written so that the method can be understood without the code.

7. Attribution and license