Python / Geospatial Algorithm Engineer — Terrain-Aware Path Network Generation from DEM

# Python / Geospatial Algorithm Engineer — Terrain-Aware Path Network Generation from DEM ## Project Overview We are looking for an experienced **Python developer / computational geospatial engineer** to develop an algorithm that automatically generates a network of terrain-following paths from **Digital Elevation Model (DEM)** data. We already have the DEM data and the surrounding application infrastructure. The main task is to design and implement the **terrain-analysis and path-generation algorithm**. This is an algorithmically challenging project. We are **not looking for a general Python developer who simply follows predefined implementation steps**. The ideal candidate should be comfortable with: * DEM / Digital Elevation Models * GIS and raster terrain analysis * Computational geometry * Terrain morphology * Graph/path generation * Spatial algorithms * Python scientific/geospatial libraries * Algorithm design and optimization The algorithm must understand the terrain **globally**, rather than simply moving from one neighboring cell to another. --- # Main Objective Given a DEM representing a mountainous area, the algorithm should automatically generate a connected terrain-aware path network consisting of: 1. **Ridge paths** — paths following major mountain ridges / high terrain. 2. **Valley paths** — paths following natural valleys and drainage directions. 3. **High-point connections** — paths connecting high points and ridge structures toward the valley network. 4. **Branches** — additional paths generated at a configurable spacing, for example every 20 meters. 5. **Terrain-constrained paths** — paths respecting configurable longitudinal and side-slope limits. The generated network should follow the natural geometry of the terrain rather than simply selecting the locally highest, lowest, or steepest neighboring cell. --- # Phase 1 — Global Terrain Structure Extraction The first stage is to analyze the complete DEM and extract its major terrain structures. ### Ridge Detection The algorithm should identify significant mountain ridges / ridge lines from the DEM. The resulting ridge paths should: * Follow the natural geometry of the ridge. * Continue through locally ambiguous terrain. * Detect multiple significant ridge structures. * Avoid behaving like a simple local steepest-ascent algorithm. For example, a ridge may continue hundreds of meters even if some individual DEM cells temporarily point in another direction. ### Valley Detection The algorithm should identify major valleys and natural low-flow/drainage paths. The valley network should be derived automatically from the DEM rather than manually defined. The resulting valley paths should behave conceptually like natural river/drainage structures. ### High-Point Connectivity High points and ridge structures should ultimately be connected toward the valley/path network. The algorithm should therefore produce a coherent terrain network rather than isolated ridge and valley lines. --- # Phase 2 — Path Network Branching After the main terrain structures have been identified, the algorithm should generate additional branches. A configurable spacing parameter will be provided, for example: `PATH_SPACING = 20 meters` The spacing must be configurable rather than hard-coded. Each generated branch should: * Follow the terrain. * Generally progress downhill where appropriate. * Connect toward an existing valley/path. * Maintain approximately the requested spacing. * Avoid unnecessary crossings. * Connect intelligently to the existing network. * Respect terrain constraints. The goal is to create a connected and useful path network rather than a collection of independent lines. --- # Phase 3 — Terrain Constraints Terrain constraints are a critical part of the algorithm. ## Longitudinal / Vertical Slope The algorithm must calculate the slope along the direction of travel for every generated path. Example: `max_vertical_slope = 15°` Any candidate path exceeding the configured maximum should either be rejected or rerouted. The value must be configurable. ## Side / Cross Slope The algorithm must also calculate the terrain slope perpendicular to the direction of travel. This is particularly important because a path can have an acceptable uphill/downhill gradient while still crossing a very steep hillside. Therefore, each candidate path should consider both: * Longitudinal slope * Cross-slope / side slope A configurable maximum side-slope constraint should be enforced. If a candidate violates the constraint, the algorithm should reject or intelligently reroute it. --- # Core Algorithm Requirement The most important requirement is that this **must NOT be a simple greedy neighbor-following algorithm**. For example, the algorithm should be able to recognize that a ridge continues across a large portion of the DEM even when local cells temporarily point in a different direction. Similarly, a valley should be treated as a continuous terrain structure rather than simply a sequence of locally lowest cells. We expect the developer to determine an appropriate algorithmic approach. We are open to different approaches involving: * Raster terrain analysis * Hydrological analysis * Morphological terrain analysis * Graph-based methods * Cost surfaces * Skeletonization / medial-axis methods * Contour-based analysis * Optimization * Computational geometry * Other appropriate approaches The candidate should explain and justify the proposed methodology before implementation. --- # Expected Deliverables ## Deliverable 1 — Algorithm Design Provide a technical design describing: * DEM preprocessing approach * Ridge detection methodology * Valley detection methodology * High-point detection/connectivity * Path-generation methodology * Branch-generation strategy * Terrain constraint calculations * Path scoring / selection logic * Approach for avoiding unnecessary crossings * Global vs. local terrain reasoning * Main configurable parameters The proposed approach should be technically justified. --- ## Deliverable 2 — Terrain Structure Extraction Python implementation capable of taking a DEM as input and extracting: * Significant ridge structures * Major valleys / drainage structures * Relevant high points * Initial terrain network The output should be exportable in a standard geospatial format such as GeoJSON or another agreed format. --- ## Deliverable 3 — Primary Path Network Implementation that converts the extracted terrain structures into a connected path network containing: * Ridge paths * Valley paths * High-point connections The resulting paths should follow the terrain geometry rather than simply following individual DEM cells. --- ## Deliverable 4 — Branch Generation Implementation of configurable branch generation. Example: `PATH_SPACING = 20m` The algorithm should generate additional paths while attempting to maintain the requested spacing and: * connect to the existing network, * follow terrain, * generally progress downhill, * minimize unnecessary crossings, * respect terrain constraints. --- ## Deliverable 5 — Terrain Constraint Engine Implement configurable: * Maximum longitudinal/vertical slope * Maximum side/cross slope * Path validity checking * Candidate rejection * Candidate rerouting where appropriate Example configuration: ```text max_vertical_slope = 15° max_side_slope = configurable path_spacing = 20m ``` --- ## Deliverable 6 — Visualization / Demonstration Provide a reproducible demonstration using sample DEM data showing: **DEM → Terrain Structures → Primary Paths → Branches → Final Constrained Network** The demonstration should make it possible to visually inspect whether the generated network follows the expected terrain structures. Outputs should preferably be viewable in a GIS environment or exported as GeoJSON / similar spatial data. --- ## Deliverable 7 — Testing Provide tests using multiple terrain scenarios, including where possible: * Mountain ridges * Valleys * Multiple ridges * Complex terrain * Steep slopes * Areas containing locally ambiguous terrain The tests should demonstrate that the algorithm is not simply following local neighboring cells. --- ## Deliverable 8 — Documentation Provide technical documentation covering: * Installation * Dependencies * Input DEM requirements * Configuration parameters * Algorithm workflow * Output formats * How to run the algorithm * Important assumptions * Known limitations * Examples The final implementation should be understandable and maintainable by another developer. --- # Expected Input / Output ### Input Digital Elevation Model (DEM), potentially representing a mountainous area. The exact DEM format and existing application interfaces will be provided to the selected developer. ### Output A connected terrain-aware path network containing: * Ridge paths * Valley paths * Connections * Branches Preferably exported as geospatial vector data such as: * GeoJSON * Shapefile * GeoPackage or another format agreed during implementation. --- # Candidate Requirements We are looking for someone with demonstrated experience in **algorithm development**, not only application development. Strong experience in several of the following is preferred: * Python * NumPy * SciPy * Rasterio * GDAL * GeoPandas * Shapely * NetworkX * DEM processing * Digital terrain analysis * GIS * Computational geometry * Hydrological terrain analysis * Path planning / routing * Optimization algorithms Experience with mountainous terrain, road/trail generation, forestry, mining, robotics, autonomous vehicles, or similar terrain-based applications would be a strong advantage. --- # Important This project requires **algorithmic thinking and independent problem solving**. We have defined the required behavior and constraints, but we have intentionally not prescribed every mathematical step. We expect the selected developer to: 1. Analyze the problem. 2. Propose an appropriate algorithm. 3. Explain why the approach should work. 4. Implement it. 5. Test it against real DEM examples. 6. Iterate based on visual and quantitative results. This is therefore **not simply a coding/implementation task**. The developer will be responsible for helping determine the correct computational approach. --- # What We Would Like to See in Your Proposal Please provide: 1. Examples of previous DEM / GIS / terrain-analysis work. 2. Examples of computational geometry or path-generation algorithms you have developed. 3. Your initial thoughts on how you would detect ridges and valleys globally. 4. How you would approach the longitudinal and side-slope constraints. 5. Which Python/geospatial libraries you would use. 6. A rough estimate of the development effort. 7. Links to relevant GitHub repositories, papers, demos, or previous projects if available. Please do not send a generic Python developer proposal. We are specifically looking for someone who understands **terrain analysis and algorithm design**. # Success Criteria The project will be considered successful when the algorithm can take a DEM and automatically produce a coherent path network that: * Recognizes major ridges and valleys. * Connects important terrain structures. * Generates configurable branches. * Maintains approximately the requested path spacing. * Respects maximum longitudinal slope. * Respects maximum side slope. * Avoids unnecessary crossings. * Produces continuous terrain-following paths. * Works using global terrain structure rather than simple greedy cell-by-cell movement. * Can be reproduced and executed from documented Python code. The core challenge is: **Turning a Digital Elevation Model into a globally terrain-aware, connected path network.**