Feature Request: Provide Direct Access to EVO KPIs and Plots via Method Calls for Automated Pipelines

[pavan-opteran]

Is your feature request related to a problem? Please describe.

In our automated verification pipeline, we currently rely on the EVO tool to evaluate pose estimation performance. However, the KPIs (e.g., Absolute Pose Error, Relative Pose Error) and plots are saved in a zip file, which we then have to manually read and extract. This process is not ideal for automated pipelines as it introduces unnecessary storage and file reading steps. We need a way to access the KPIs and plots directly via class method calls in our custom interface.

Describe the solution you'd like

We would like the EVO tool to offer direct access to KPIs and plot data through method calls, rather than storing the results in a zip file and requiring manual extraction. For example, the evo_ape and evo_rpe methods should return KPIs in a structured format (e.g., a dictionary or class object). Additionally, the plot data (e.g., figure objects or raw data for plots) should also be returned as part of the method call so that we can embed them in our verification reports without needing to read from files.

This could be implemented by adding optional parameters to the existing methods, such as return_kpis=True and return_plots=True, which would enable users to access the results programmatically. For eg in their scripts, they can pass in the arguments and retrieve the KPIs

Retrieve KPIs and error arrays via method calls

import evo.main_rpe as main_rpe

self.ape_data, self.ape_error_array = main_ape.run(args)
self.rpe_data, self.rpe_error_array = main_rpe.run(args)

Describe alternatives you've considered

Currently, we store the EVO results in a zip file and manually extract the KPIs and plots from there. While this works, it introduces unnecessary overhead, especially in a fully automated pipeline. Another alternative would be writing custom scripts to parse the output files, but this adds complexity and isn’t efficient for our real-time processing.

Additional context

This feature would be particularly useful in automated testing pipelines where efficiency and direct access to results are critical. By returning KPIs and plots via method calls, users can easily integrate the EVO tool’s results into larger verification workflows and generate reports dynamically without the need for intermediate file storage.

[MichaelGrupp]

The main_*.py files / run() functions are first and foremost application logic for the command line tools that are shipped with this package. They are not designed to be used in other custom app logics.

To build a custom app or pipeline, a developer can either:

• call the CLI apps in a script, and work with files
• use the library to build a completely custom app
  • dummy example custom_app.py
  • "KPIs" can be retrieved via get_statistics(), get_result() etc of the metrics classes

A convenience class with a complete app logic does not make much sense in this upstream package, because every downstream project will have different requirements for their use-case that I can't cover here. And since you mention that you have a "custom interface" and do "real-time processing", you also seem to have special requirements.