Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file
CONTRIBUTING
Repository Summary
| Checkout URI | https://github.com/Fields2Cover/fields2cover.git |
| VCS Type | git |
| VCS Version | main |
| Last Updated | 2026-09-03 |
| Dev Status | DEVELOPED |
| Released | RELEASED |
| Contributing |
Help Wanted (-)
Good First Issues (-) Pull Requests to Review (-) |
Packages
| Name | Version |
|---|---|
| fields2cover | 2.1.0 |
README
Robust and efficient coverage paths for autonomous agricultural vehicles
Documentation • Installation • Quick Start • Tutorials • API • Paper
Fields2Cover is an open-source C++ library with Python bindings that solves the Coverage Path Planning problem for agriculture: given a field and a vehicle, it computes a complete coverage path — headlands, swaths, an optimized route, and a drivable path with feasible turns. It also provides a common, extensible framework to implement and compare coverage path planning algorithms, so researchers don’t have to re-implement every algorithm they want to compare against. The API is still evolving, so expect occasional breaking changes between releases.
Core features
-
Modular pipeline: headland generation, swath generation, route planning and path planning as interchangeable modules — or a single call to
planCovPath. - Non-convex fields and obstacles, handled by trapezoidal and boustrophedon decomposition.
- Route optimization with OR-tools, plus classic patterns like boustrophedon, snake and spiral.
- Kinematically feasible turns using Dubins and Reeds-Shepp curves, with or without continuous curvature.
- C++17 core, Python bindings, and a ROS 2 integration via opennav_coverage.
Quick Start
Fields2Cover builds on GDAL, GEOS and OR-tools, which need to be installed first (details in the installation guide):
# Ubuntu
sudo apt install build-essential libgdal-dev libgeos-dev libeigen3-dev libboost-dev \
libtbb-dev libtinyxml2-dev nlohmann-json3-dev libpython3-dev gnuplot
# plus OR-tools for C++: https://developers.google.com/optimization/install/cpp
# macOS
brew install gdal geos or-tools tinyxml2 eigen tbb boost gnuplot
C++
#include "fields2cover.h"
int main() {
F2CField field = f2c::Parser::importFieldGml("data/test1.xml");
F2CRobot robot(2.0, 6.0, 0.5, 0.2);
F2CPath path = f2c::planCovPath(robot, field, false);
f2c::Visualizer::figure();
f2c::Visualizer::plot(field.getCellsAbsPosition());
f2c::Visualizer::plot(path);
f2c::Visualizer::show();
return 0;
}
find_package(Fields2Cover REQUIRED)
target_link_libraries(<your_target> Fields2Cover)
Python
pip install fields2cover
import fields2cover as f2c
field = f2c.Parser().importFieldGml("data/test1.xml")
robot = f2c.Robot(2.0, 6.0, 0.5, 0.2)
path = f2c.planCovPath(robot, field, False)
f2c.Visualizer.figure()
f2c.Visualizer.plot(field.getCellsAbsPosition())
f2c.Visualizer.plot(path)
f2c.Visualizer.show()
Installation
-
Python:
pip install fields2cover— the package is built from source on your machine, so the system dependencies above must be installed. - C++ / from source: clone this repository and build with CMake — full walkthrough in the installation guide.
- ROS 2: see opennav_coverage, a Nav2-compatible coverage task server built on Fields2Cover.
File truncated at 100 lines see the full file