Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
jazzy

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
kilted

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
lyrical

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
rolling

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro ardent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro bouncy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro crystal showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro eloquent showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro dashing showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro galactic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro foxy showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
iron

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro lunar showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro jade showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro indigo showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro hydro showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro kinetic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

No version for distro melodic showing humble. Known supported distros are highlighted in the buttons above.
Repo symbol

fields2cover repository

fields2cover

ROS Distro
humble

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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

Repo symbol

fields2cover repository

fields2cover

ROS Distro
noetic

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

Fields2Cover logo

Robust and efficient coverage paths for autonomous agricultural vehicles

DocumentationInstallationQuick StartTutorialsAPIPaper

build coverage PyPI license DOI

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.

Fields2Cover module diagram

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