Skip to content

evalio.pipelines

For more information about the pipelines included in evalio, see the included pipelines section.

Classes:

  • Pipeline –

    Base class for all pipelines. This class defines the interface for interacting with pipelines, and is intended to be subclassed by specific implementations.

  • CTICP –

    CT-ICP LiDAR-only pipeline performs continuous-time ICP over a small window of scans to perform more accurate dewarping performance. This is the version based on the 2022-ICRA paper.

  • KissICP –

    KissICP LiDAR-only pipeline for point cloud registration. KissICP is designed to be simple and easy to use, while still providing good performance with minimal parameter tuning required across datasets.

  • GenZICP –

    Genz-ICP LiDAR-only pipeline is an extension of KissICP that additionally estimates normals in the local submap voxel map for increased robustness. It also includes a novel weighting scheme for weighting point-to-plane and point-to-point correspondences.

  • LOAM –

    Lidar Odometry and Mapping (LOAM) pipeline. LOAM is a baseline lidar-only odometry method that pioneered feature-based ICP. Our implementation permits both scan-to-scan or scan-to-map matching.

  • LioSAM –

    Lidar-Inertial Smoothing and Mapping (LioSAM) pipeline. LioSAM is an extension of LOAM (=> uses planar and edge features) that additionally utilizes an IMU for initializing ICP steps and for dewarping points

  • MadICP –

    MAD-ICP LiDAR-only pipeline is an extension of KissICP that utilizes a novel kd-tree representation that implicitly computes normals to perform point-to-plane registration.

  • PipelineNotFound –

    Raised when a pipeline is not found in the registry.

  • UnusedPipelineParam –

    Raised when a parameter is not used in the pipeline.

  • InvalidPipelineParamType –

    Raised when a parameter has an invalid type.

Functions:

Pipeline

Base class for all pipelines. This class defines the interface for interacting with pipelines, and is intended to be subclassed by specific implementations.

Methods:

  • __init__ –

    Construct a new pipeline.

  • add_imu –

    Register an IMU measurement.

  • add_lidar –

    Register a LiDAR measurement.

  • default_params –

    Default parameters for the pipeline.

  • initialize –

    Initialize the pipeline. Must be called after constructing the object and before setting parameters.

  • map –

    Map of the environment.

  • name –

    Name of the pipeline.

  • pose –

    Most recent pose estimate.

  • set_imu_T_lidar –

    Set the transformation from IMU to LiDAR frame.

  • set_imu_params –

    Set IMU parameters for the pipeline.

  • set_lidar_params –

    Set LiDAR parameters for the pipeline.

  • set_params –

    Set parameters for the pipeline. This will override any default parameters.

  • url –

    URL for more information about the pipeline.

  • version –

    Version of the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class Pipeline:
    """
    Base class for all pipelines. This class defines the interface for interacting with pipelines, and is intended to be subclassed by specific implementations.
    """

    def __init__(self) -> None:
        """Construct a new pipeline."""

    @staticmethod
    def name() -> str:
        """Name of the pipeline."""

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]:
        """Default parameters for the pipeline."""

    @staticmethod
    def url() -> str:
        """URL for more information about the pipeline."""

    @staticmethod
    def version() -> str:
        """Version of the pipeline."""

    def pose(self) -> evalio._cpp.types.SE3:
        """Most recent pose estimate."""

    def map(self) -> dict[str, list[evalio._cpp.types.Point]]:
        """Map of the environment."""

    def initialize(self) -> None:
        """
        Initialize the pipeline. Must be called after constructing the object and before setting parameters.
        """

    def add_imu(self, mm: evalio._cpp.types.ImuMeasurement) -> None:
        """Register an IMU measurement."""

    def add_lidar(self, mm: evalio._cpp.types.LidarMeasurement) -> dict[str, list[evalio._cpp.types.Point]]:
        """Register a LiDAR measurement."""

    def set_params(self, params: Mapping[str, bool | int | float | str]) -> dict[str, bool | int | float | str]:
        """
        Set parameters for the pipeline. This will override any default parameters.
        """

    def set_imu_params(self, params: evalio._cpp.types.ImuParams) -> None:
        """Set IMU parameters for the pipeline."""

    def set_lidar_params(self, params: evalio._cpp.types.LidarParams) -> None:
        """Set LiDAR parameters for the pipeline."""

    def set_imu_T_lidar(self, T: evalio._cpp.types.SE3) -> None:
        """Set the transformation from IMU to LiDAR frame."""

__init__ 

__init__() -> None

Construct a new pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
11
12
def __init__(self) -> None:
    """Construct a new pipeline."""

add_imu 

add_imu(mm: ImuMeasurement) -> None

Register an IMU measurement.

Source code in python/evalio/_cpp/pipelines.pyi 
41
42
def add_imu(self, mm: evalio._cpp.types.ImuMeasurement) -> None:
    """Register an IMU measurement."""

add_lidar 

add_lidar(mm: LidarMeasurement) -> dict[str, list[Point]]

Register a LiDAR measurement.

Source code in python/evalio/_cpp/pipelines.pyi 
44
45
def add_lidar(self, mm: evalio._cpp.types.LidarMeasurement) -> dict[str, list[evalio._cpp.types.Point]]:
    """Register a LiDAR measurement."""

default_params staticmethod 

default_params() -> dict[str, bool | int | float | str]

Default parameters for the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
18
19
20
@staticmethod
def default_params() -> dict[str, bool | int | float | str]:
    """Default parameters for the pipeline."""

initialize 

initialize() -> None

Initialize the pipeline. Must be called after constructing the object and before setting parameters.

Source code in python/evalio/_cpp/pipelines.pyi 
36
37
38
39
def initialize(self) -> None:
    """
    Initialize the pipeline. Must be called after constructing the object and before setting parameters.
    """

map 

map() -> dict[str, list[Point]]

Map of the environment.

Source code in python/evalio/_cpp/pipelines.pyi 
33
34
def map(self) -> dict[str, list[evalio._cpp.types.Point]]:
    """Map of the environment."""

name staticmethod 

name() -> str

Name of the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
14
15
16
@staticmethod
def name() -> str:
    """Name of the pipeline."""

pose 

pose() -> SE3

Most recent pose estimate.

Source code in python/evalio/_cpp/pipelines.pyi 
30
31
def pose(self) -> evalio._cpp.types.SE3:
    """Most recent pose estimate."""

set_imu_T_lidar 

set_imu_T_lidar(T: SE3) -> None

Set the transformation from IMU to LiDAR frame.

Source code in python/evalio/_cpp/pipelines.pyi 
58
59
def set_imu_T_lidar(self, T: evalio._cpp.types.SE3) -> None:
    """Set the transformation from IMU to LiDAR frame."""

set_imu_params 

set_imu_params(params: ImuParams) -> None

Set IMU parameters for the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
52
53
def set_imu_params(self, params: evalio._cpp.types.ImuParams) -> None:
    """Set IMU parameters for the pipeline."""

set_lidar_params 

set_lidar_params(params: LidarParams) -> None

Set LiDAR parameters for the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
55
56
def set_lidar_params(self, params: evalio._cpp.types.LidarParams) -> None:
    """Set LiDAR parameters for the pipeline."""

set_params 

set_params(
    params: Mapping[str, bool | int | float | str],
) -> dict[str, bool | int | float | str]

Set parameters for the pipeline. This will override any default parameters.

Source code in python/evalio/_cpp/pipelines.pyi 
47
48
49
50
def set_params(self, params: Mapping[str, bool | int | float | str]) -> dict[str, bool | int | float | str]:
    """
    Set parameters for the pipeline. This will override any default parameters.
    """

url staticmethod 

url() -> str

URL for more information about the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
22
23
24
@staticmethod
def url() -> str:
    """URL for more information about the pipeline."""

version staticmethod 

version() -> str

Version of the pipeline.

Source code in python/evalio/_cpp/pipelines.pyi 
26
27
28
@staticmethod
def version() -> str:
    """Version of the pipeline."""

CTICP

Bases: Pipeline

CT-ICP LiDAR-only pipeline performs continuous-time ICP over a small window of scans to perform more accurate dewarping performance. This is the version based on the 2022-ICRA paper.

Source code in python/evalio/_cpp/pipelines.pyi 
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
class CTICP(Pipeline):
    """
    CT-ICP LiDAR-only pipeline performs continuous-time ICP over a small window of scans to perform more accurate dewarping performance. This is the version based on the 2022-ICRA paper.
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

KissICP

Bases: Pipeline

KissICP LiDAR-only pipeline for point cloud registration. KissICP is designed to be simple and easy to use, while still providing good performance with minimal parameter tuning required across datasets.

Source code in python/evalio/_cpp/pipelines.pyi 
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
class KissICP(Pipeline):
    """
    KissICP LiDAR-only pipeline for point cloud registration. KissICP is designed to be simple and easy to use, while still providing good performance with minimal parameter tuning required across datasets.
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

GenZICP

Bases: Pipeline

Genz-ICP LiDAR-only pipeline is an extension of KissICP that additionally estimates normals in the local submap voxel map for increased robustness. It also includes a novel weighting scheme for weighting point-to-plane and point-to-point correspondences.

Source code in python/evalio/_cpp/pipelines.pyi 
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
class GenZICP(Pipeline):
    """
    Genz-ICP LiDAR-only pipeline is an extension of KissICP that additionally estimates normals in the local submap voxel map for increased robustness. It also includes a novel weighting scheme for weighting point-to-plane and point-to-point correspondences.
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

LOAM

Bases: Pipeline

Lidar Odometry and Mapping (LOAM) pipeline. LOAM is a baseline lidar-only odometry method that pioneered feature-based ICP. Our implementation permits both scan-to-scan or scan-to-map matching.

Source code in python/evalio/_cpp/pipelines.pyi 
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
class LOAM(Pipeline):
    """
    Lidar Odometry and Mapping (LOAM) pipeline. LOAM is a baseline lidar-only odometry method that pioneered feature-based ICP. Our implementation permits both scan-to-scan or scan-to-map matching.
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

LioSAM

Bases: Pipeline

Lidar-Inertial Smoothing and Mapping (LioSAM) pipeline. LioSAM is an extension of LOAM (=> uses planar and edge features) that additionally utilizes an IMU for initializing ICP steps and for dewarping points

Source code in python/evalio/_cpp/pipelines.pyi 
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
class LioSAM(Pipeline):
    """
    Lidar-Inertial Smoothing and Mapping (LioSAM) pipeline. LioSAM is an extension of LOAM (=> uses planar and edge features) that additionally utilizes an IMU for initializing ICP steps and for dewarping points
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

MadICP

Bases: Pipeline

MAD-ICP LiDAR-only pipeline is an extension of KissICP that utilizes a novel kd-tree representation that implicitly computes normals to perform point-to-plane registration.

Source code in python/evalio/_cpp/pipelines.pyi 
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
class MadICP(Pipeline):
    """
    MAD-ICP LiDAR-only pipeline is an extension of KissICP that utilizes a novel kd-tree representation that implicitly computes normals to perform point-to-plane registration.
    """

    def __init__(self) -> None: ...

    @staticmethod
    def name() -> str: ...

    @staticmethod
    def default_params() -> dict[str, bool | int | float | str]: ...

    @staticmethod
    def url() -> str: ...

    @staticmethod
    def version() -> str: ...

PipelineNotFound

Bases: CustomException

Raised when a pipeline is not found in the registry.

Source code in python/evalio/pipelines/parser.py 
21
22
23
24
25
26
class PipelineNotFound(CustomException):
    """Raised when a pipeline is not found in the registry."""

    def __init__(self, name: str):
        super().__init__(f"Pipeline '{name}' not found")
        self.name = name

UnusedPipelineParam

Bases: CustomException

Raised when a parameter is not used in the pipeline.

Source code in python/evalio/pipelines/parser.py 
35
36
37
38
39
40
41
class UnusedPipelineParam(CustomException):
    """Raised when a parameter is not used in the pipeline."""

    def __init__(self, param: str, pipeline: str):
        super().__init__(f"Parameter '{param}' is not used in pipeline '{pipeline}'")
        self.param = param
        self.pipeline = pipeline

InvalidPipelineParamType

Bases: CustomException

Raised when a parameter has an invalid type.

Source code in python/evalio/pipelines/parser.py 
44
45
46
47
48
49
50
51
52
53
class InvalidPipelineParamType(CustomException):
    """Raised when a parameter has an invalid type."""

    def __init__(self, param: str, expected_type: type, actual_type: type):
        super().__init__(
            f"Parameter '{param}' has invalid type. Expected '{expected_type.__name__}', got '{actual_type.__name__}'"
        )
        self.param = param
        self.expected_type = expected_type
        self.actual_type = actual_type

all_pipelines 

all_pipelines() -> dict[str, type[Pipeline]]

Get all registered pipelines.

Returns:

  • dict[str, type[Pipeline]] –

    A dictionary mapping pipeline names to their classes.

Source code in python/evalio/pipelines/parser.py 
106
107
108
109
110
111
112
113
def all_pipelines() -> dict[str, type[Pipeline]]:
    """Get all registered pipelines.

    Returns:
        A dictionary mapping pipeline names to their classes.
    """
    global _PIPELINES
    return {p.name(): p for p in _PIPELINES}

get_pipeline 

get_pipeline(
    name: str,
) -> type[Pipeline] | PipelineNotFound

Get a pipeline class by its name.

Parameters:

  • name (str) –

    The name of the pipeline.

Returns:

Source code in python/evalio/pipelines/parser.py 
116
117
118
119
120
121
122
123
124
125
def get_pipeline(name: str) -> type[Pipeline] | PipelineNotFound:
    """Get a pipeline class by its name.

    Args:
        name (str): The name of the pipeline.

    Returns:
        The pipeline class if found, otherwise a PipelineNotFound error.
    """
    return all_pipelines().get(name, PipelineNotFound(name))

register_pipeline 

register_pipeline(
    pipeline: Optional[type[Pipeline]] = None,
    module: Optional[ModuleType | str] = None,
) -> int | ImportError

Add a pipeline or a module containing pipelines to the registry.

Parameters:

  • pipeline (Optional[type[Pipeline]], default: None ) –

    A specific pipeline class to add. Defaults to None.

  • module (Optional[ModuleType | str], default: None ) –

    The module to search for pipelines. Defaults to None.

Source code in python/evalio/pipelines/parser.py 
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
def register_pipeline(
    pipeline: Optional[type[Pipeline]] = None,
    module: Optional[ModuleType | str] = None,
) -> int | ImportError:
    """Add a pipeline or a module containing pipelines to the registry.

    Args:
        pipeline (Optional[type[Pipeline]], optional): A specific pipeline class to add. Defaults to None.
        module (Optional[ModuleType  |  str], optional): The module to search for pipelines. Defaults to None.
    """
    global _PIPELINES

    total = 0
    if module is not None:
        if isinstance(module, str):
            try:
                module = importlib.import_module(module)
            except ImportError as e:
                return e

        new_pipes = _search_module(module)
        _PIPELINES.update(new_pipes)
        total += len(new_pipes)

    if pipeline is not None and _is_pipe(pipeline):
        _PIPELINES.add(pipeline)
        total += 1

    return total

validate_params 

validate_params(
    pipe: type[Pipeline], params: dict[str, Param]
) -> None | InvalidPipelineParamType | UnusedPipelineParam

Validate the parameters for a given pipeline.

Parameters:

  • pipe (type[Pipeline]) –

    The pipeline class.

  • params (dict[str, Param]) –

    The parameters to validate.

Returns:

Source code in python/evalio/pipelines/parser.py 
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
def validate_params(
    pipe: type[Pipeline],
    params: dict[str, Param],
) -> None | InvalidPipelineParamType | UnusedPipelineParam:
    """Validate the parameters for a given pipeline.

    Args:
        pipe (type[Pipeline]): The pipeline class.
        params (dict[str, Param]): The parameters to validate.

    Returns:
        An error if validation fails, otherwise None.
    """
    default_params = pipe.default_params()
    for p in params:
        if p not in default_params:
            return UnusedPipelineParam(p, pipe.name())

        expected_type = type(default_params[p])
        actual_type = type(params[p])
        if actual_type != expected_type:
            return InvalidPipelineParamType(p, expected_type, actual_type)

    return None