Upload 6 files

LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2026] [loubet--bonino Grégory]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

README.md

@@ -1,3 +1,237 @@
----
-license: gpl-3.0
----
+# UAV Testing Competition
+
+
+Unmanned Aerial Vehicles (UAVs) equipped with onboard cameras and various sensors have already demonstrated the possibility of autonomous flights in real environments, leading to great interest in various application scenarios: crop monitoring, surveillance, medical and food delivery.
+
+Over the years, support for UAV developers has increased with open-access projects for software and hardware, such as the autopilot support provided by [PX4](https://github.com/PX4/PX4-Autopilot) and [Ardupilot](https://github.com/ArduPilot/ardupilot).
+However, despite the necessity of systematically testing such complex and automated systems to ensure their safe operation in real-world environments, there has been relatively limited investment in this direction so far.
+
+The UAV Testing Competition organized jointly by the [International Conference on Software Testing, Verification and Validation (ICST)](https://conf.researchr.org/home/icst-2026) and [Search-Based and Fuzz Testing (SBFT) workshop](https://search-based-and-fuzz-testing.github.io/sbft26/) is an initiative designed to inspire and encourage the Software Testing Community to direct their attention toward UAVs as a rapidly emerging and crucial domain. The joint call is meant to help interested authors/participants reduce travel costs by selecting the most convenient and close venue.
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `UAV.db` | SQLite database — all flight data |
+| `UAV_notebook.ipynb` | Exploration notebook — visualizations, metrics, ML export, and tools to add new missions |
+| `Dataset_gen.ipynb` | Python pipeline — scans flight folders and populates the database |
+| `requirements.txt` | Pinned library versions for reproducible environment setup |
+
+Place all files in the same directory before running the notebook.
+
+---
+
+## What's in the database?
+
+The database currently holds flights from PX4 simulations. Each flight contains two types of data:
+
+**Dynamic data** — sensor time-series recorded during the flight, stored as ULog topics:
+- `vehicle_local_position` — position in NED frame: x, y, z (meters) and velocity (m/s)
+- `vehicle_attitude` — orientation as quaternion (w, x, y, z); dimensionless
+- `sensor_combined` — raw IMU measurements: accelerometer (m/s²), gyroscope (rad/s)
+- `vehicle_status` — flight mode and arming state
+
+**Static data** — simulation conditions set before the flight:
+- Wind parameters: mean velocity (m/s), direction (unit vector), gusts and variance (m/s)
+- Obstacle positions (meters) and dimensions — height, length, width (meters) — up to N obstacles per flight
+- PX4 flight controller parameters: navigation acceptance radius (meters), takeoff altitude (meters), etc.
+
+### Database schema
+
+```
+missions
+  └── flights              one row per simulation flight
+        ├── flight_context static conditions (wind, obstacles, PX4 params)
+        └── topics         ULog topics recorded during the flight
+              ├── topic_fields  field names and data types
+              └── topic_data    time-series values (long format)
+```
+
+`topic_data` uses **long format** — each row is one `(topic_id, row_index, field_name, value)` tuple.  
+The notebook's `get_topic()` helper pivots this into a wide DataFrame automatically.
+
+---
+
+## Quickstart
+
+### Requirements
+
+Install dependencies using the provided `requirements.txt` to ensure version compatibility:
+
+```bash
+pip install -r requirements.txt
+```
+
+### Open the notebook
+
+```bash
+jupyter notebook UAV_notebook.ipynb
+```
+
+The notebook connects to `UAV.db` directly — no additional setup needed.
+
+### Query the database directly
+
+```python
+import sqlite3
+import pandas as pd
+
+con = sqlite3.connect("UAV.db")
+
+# All flights with duration
+flights = pd.read_sql(
+    "SELECT iter_number, duration_s FROM flights ORDER BY iter_number", con
+)
+
+# Position time-series for flight iteration #2 (long → wide)
+pos_raw = pd.read_sql("""
+    SELECT td.row_index, td.field_name, td.value
+    FROM topic_data td
+    JOIN topics  t ON t.id = td.topic_id
+    JOIN flights f ON f.id = t.flight_id
+    WHERE f.iter_number = 2
+      AND t.name = 'vehicle_local_position'
+    ORDER BY td.row_index
+""", con)
+
+pos = pos_raw.pivot(index="row_index", columns="field_name", values="value")
+
+# Simulation conditions for every flight (wide format)
+context = pd.read_sql("""
+    SELECT f.iter_number, c.key, c.value
+    FROM flights f
+    JOIN flight_context c ON c.flight_id = f.id
+""", con)
+
+context_wide = context.pivot_table(
+    index="iter_number", columns="key", values="value"
+).reset_index()
+```
+
+---
+
+## ML export
+
+Use `build_ml_dataset()` (or run Section 7 of the notebook) to export a flat Parquet file ready for training.  
+Every row is one timestep. Static features are repeated on all rows belonging to the same flight.
+
+| Group | Example columns | Note |
+|-------|-----------------|------|
+| Time | `timestamp` | Microseconds; resampled to a uniform grid |
+| Position | `vehicle_local_position__x/y/z` | NED frame (meters) — use `-z` for altitude |
+| Attitude | `vehicle_attitude__q[0..3]` | Quaternion, scalar-first (w, x, y, z); dimensionless |
+| Wind | `wind_velocity_mean`, `wind_dir_x/y/z` | Static per flight; velocity in m/s, direction as unit vector |
+| Obstacles | `obs0_x/y/z/h/l/w`, `obs1_...` | Static per flight; position and dimensions in meters |
+| PX4 params | `px4_NAV_ACC_RAD`, `px4_MIS_TAKEOFF_ALT` | Static per flight; distances in meters |
+| Flight ID | `iter_number`, `iter_name` | Use to group or split by flight |
+
+---
+
+## Notebook 
+Inside the notebook you will find everything that can be useful for data science such as statistics, queries, and how the database is structured. There is also code showing how the database is constructed.
+
+---
+
+## Adding new flights
+
+Section 8 of the notebook walks through the full import process. In short:
+
+1. Organize your flights under a root folder (one subfolder per iteration, each containing a `.ulg` file and optionally a `.yaml` config)
+2. Set `NEW_ROOT_DIR` in the notebook
+3. Run the discovery cell to preview what will be imported
+4. Run the pipeline cell to write to `UAV.db`
+
+You can also call the pipeline directly from Python:
+
+```python
+from Dataset_gen import run_pipeline
+
+run_pipeline(
+    root_dir          = "./my_flights",
+    db_path           = "UAV.db",
+    ml_topics         = ["vehicle_local_position", "vehicle_attitude"],
+    resample_us       = 100_000,   # 10 Hz
+    downsample_factor = 10,
+    skip_existing     = True,
+)
+```
+
+---
+
+## Notes
+
+- **NED frame**: `z` points downward — use `-z` to get altitude above ground (meters)
+- **Quaternion convention**: `q[0]` = scalar part (w), `q[1..3]` = vector part (x, y, z)
+- `topic_data` stores values in long format; use `pivot()` or the `get_topic()` helper to work with it
+
+## Full dataset 
+The full dataset can be found at the website here : 
+https://zenodo.org/records/18727376
+
+## References
+
+If you use this tool in your research, please cite the following papers:
+
+- **Sajad Khatiri**, Sebastiano Panichella, and Paolo Tonella, "Simulation-based Testing of Unmanned Aerial Vehicles with Aerialist," *In 2024 International Conference on Software Engineering (ICSE)*. [Link](https://dl.acm.org/doi/10.1145/3639478.3640031).
+
+  ````{code-block} bibtex
+  @inproceedings{icse2024Aerialist,
+    title={Simulation-based Testing of Unmanned Aerial Vehicles with Aerialist},
+    author={Khatiri, Sajad and Panichella, Sebastiano and Tonella, Paolo},
+    booktitle={International Conference on Software Engineering (ICSE)},
+    year={2024},
+  }
+  ````
+
+- **SBFT Tool competition report** 
+  ````{code-block} bibtex
+  @inproceedings{SBFT-UAV2026,
+    author       = {Ramazan Erdem Uysal and Ali Javadi and Prakash Aryan and Aren Babikian and  Dmytro Humeniuk and  Sajad Mazraehkhatiri and  Sebastiano Panichella},
+    title        = {{SBFT} Tool Competition 2026 – UAV Testing Track},
+    booktitle    = {International Workshop on Search-Based and Fuzz Testing,
+                    SBFT@ICSE 2026},
+    year         = {2026}
+  }
+  ````
+
+- **ICST Tool competition report** 
+  ````{code-block} bibtex
+  @inproceedings{ICST-UAV2026,
+    author       = {Ramazan Erdem Uysal and Ali Javadi and Prakash Aryan and Aren Babikian and  Dmytro Humeniuk and  Sajad Mazraehkhatiri and  Sebastiano Panichella},
+    title        = {{ICST} Tool Competition 2026 – UAV Testing Track},
+    booktitle    = {International Conference on Software Testing, Verification and Validation (ICST)},
+    year         = {2026}
+  }
+  ````
+
+- **Sajad Khatiri**, Sebastiano Panichella, and Paolo Tonella, "Simulation-based Test Case Generation for Unmanned Aerial Vehicles in the Neighborhood of Real Flights," *In 2023 IEEE 16th International Conference on Software Testing, Verification and Validation (ICST)*. [Link](https://ieeexplore.ieee.org/document/10132225).
+
+  ````{code-block} bibtex
+  @inproceedings{khatiri2023simulation,
+    title={Simulation-based test case generation for unmanned aerial vehicles in the neighborhood of real flights},
+    author={Khatiri, Sajad and Panichella, Sebastiano and Tonella, Paolo},
+    booktitle={2023 16th IEEE International Conference on Software Testing, Verification and Validation (ICST)},
+    year={2023},
+  }
+  ````
+
+## License
+
+The software we developed is distributed under the Apache 2.0 license. See the [LICENSE](./LICENSE) file.
+
+## Contacts
+
+Please refer to the [FAQ page](https://github.com/skhatiri/UAV-Testing-Competition/wiki/Home) in the Wiki.
+
+You may also refer to (and contribute to) the [Discussions Page](https://github.com/skhatiri/UAV-Testing-Competition/discussions), where you may find user-submitted questions and corresponding answers.
+
+You can also contact us directly using email:
+
+- Ramazan Erdem Uysal, University of Bern, ramazan.uysal@unibe.ch
+- Ali Javadi, University of Bern, ali.javadi@unibe.ch, 
+- Prakash Aryan, University of Bern, prakash.aryan@unibe.ch
+- Loubet--Bonino Grégory, University of Bern, gregory.loubet-bonino@unibe.ch
+- Aren Babikian, University of Toronto, aren.babikian@utoronto.ca
+- Dmytro Humeniuk, Polytechnique Montréal, dmytro.humeniuk@polymtl.ca, 
+- Sajad Mazraehkhatiri, University of Bern, sajad.mazraehkhatiri@unibe.ch
+- Sebastiano Panichella, University of Bern, sebastiano.panichella@unibe.ch

Requierement.txt

@@ -0,0 +1,10 @@
+pandas==2.2.2
+numpy==1.26.4
+matplotlib==3.9.0
+seaborn==0.13.2
+scikit-learn==1.5.0
+pyarrow==16.1.0
+pyulog==0.9.0
+pyyaml==6.0.1
+tqdm==4.66.4
+jupyter==1.0.0

UAV.zip

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31b5c49f16e65233361eb284b0989ed25a1f22cde72f39f926f5327dad23d2da
+size 135

dataset_gen.ipynb

@@ -0,0 +1,614 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "211b4872-8a32-461f-b66e-df285aae26f9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sqlite3\n",
+    "import yaml\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from pyulog import ULog\n",
+    "from pathlib import Path\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "\n",
+    "def flatten_yaml(yaml_path: Path) -> dict:\n",
+    "    \"\"\"Flatten YAML config into scalar key-value pairs.\"\"\"\n",
+    "    with open(yaml_path, \"r\") as f:\n",
+    "        cfg = yaml.safe_load(f)\n",
+    "\n",
+    "    flat = {}\n",
+    "\n",
+    "    # PX4 params\n",
+    "    params = cfg.get(\"robot\", {}).get(\"params\", {})\n",
+    "    if hasattr(params, '__dict__'):\n",
+    "        params = params.__dict__\n",
+    "    for k, v in params.items():\n",
+    "        flat[f\"px4_{k}\"] = float(v) if v is not None else float(\"nan\")\n",
+    "\n",
+    "    # Mission command\n",
+    "    commands = cfg.get(\"mission\", {}).get(\"commands\", [])\n",
+    "    if commands:\n",
+    "        cmd = commands[0]\n",
+    "        flat[\"cmd_mode\"] = float(cmd.get(\"mode\", float(\"nan\")))\n",
+    "        flat[\"cmd_x\"]    = float(cmd.get(\"x\",    float(\"nan\")))\n",
+    "        flat[\"cmd_y\"]    = float(cmd.get(\"y\",    float(\"nan\")))\n",
+    "        flat[\"cmd_z\"]    = float(cmd.get(\"z\",    float(\"nan\")))\n",
+    "        flat[\"cmd_r\"]    = float(cmd.get(\"r\",    float(\"nan\")))\n",
+    "\n",
+    "    # Wind\n",
+    "    wind = cfg.get(\"simulation\", {}).get(\"wind\", {})\n",
+    "    flat[\"wind_velocity_mean\"]      = float(wind.get(\"velocity_mean\",      float(\"nan\")))\n",
+    "    flat[\"wind_velocity_max\"]       = float(wind.get(\"velocity_max\",       float(\"nan\")))\n",
+    "    flat[\"wind_velocity_variance\"]  = float(wind.get(\"velocity_variance\",  float(\"nan\")))\n",
+    "    flat[\"wind_direction_variance\"] = float(wind.get(\"direction_variance\", float(\"nan\")))\n",
+    "    flat[\"wind_gust_velocity_mean\"] = float(wind.get(\"gust_velocity_mean\", float(\"nan\")))\n",
+    "    flat[\"wind_gust_velocity_max\"]  = float(wind.get(\"gust_velocity_max\",  float(\"nan\")))\n",
+    "    flat[\"wind_gust_duration\"]      = float(wind.get(\"gust_duration\",      float(\"nan\")))\n",
+    "    flat[\"wind_gust_start\"]         = float(wind.get(\"gust_start\",         float(\"nan\")))\n",
+    "\n",
+    "    direction = wind.get(\"direction\", [float(\"nan\")] * 3)\n",
+    "    flat[\"wind_dir_x\"] = float(direction[0]) if len(direction) > 0 else float(\"nan\")\n",
+    "    flat[\"wind_dir_y\"] = float(direction[1]) if len(direction) > 1 else float(\"nan\")\n",
+    "    flat[\"wind_dir_z\"] = float(direction[2]) if len(direction) > 2 else float(\"nan\")\n",
+    "\n",
+    "    gust_dir = wind.get(\"gust_direction\", [float(\"nan\")] * 3)\n",
+    "    flat[\"wind_gust_dir_x\"] = float(gust_dir[0]) if len(gust_dir) > 0 else float(\"nan\")\n",
+    "    flat[\"wind_gust_dir_y\"] = float(gust_dir[1]) if len(gust_dir) > 1 else float(\"nan\")\n",
+    "    flat[\"wind_gust_dir_z\"] = float(gust_dir[2]) if len(gust_dir) > 2 else float(\"nan\")\n",
+    "\n",
+    "    # Obstacles\n",
+    "    obstacles = cfg.get(\"simulation\", {}).get(\"obstacles\", [])\n",
+    "    flat[\"obs_count\"] = float(len(obstacles))\n",
+    "    shape_map = {\"box\": 0, \"cylinder\": 1, \"sphere\": 2}\n",
+    "\n",
+    "    for i, obs in enumerate(obstacles):\n",
+    "        prefix = f\"obs{i}_\"\n",
+    "        pos  = obs.get(\"position\", {})\n",
+    "        size = obs.get(\"size\",     {})\n",
+    "        flat[f\"{prefix}x\"]     = float(pos.get(\"x\",  float(\"nan\")))\n",
+    "        flat[f\"{prefix}y\"]     = float(pos.get(\"y\",  float(\"nan\")))\n",
+    "        flat[f\"{prefix}z\"]     = float(pos.get(\"z\",  float(\"nan\")))\n",
+    "        flat[f\"{prefix}r\"]     = float(pos.get(\"r\",  float(\"nan\")))\n",
+    "        flat[f\"{prefix}h\"]     = float(size.get(\"h\", float(\"nan\")))\n",
+    "        flat[f\"{prefix}l\"]     = float(size.get(\"l\", float(\"nan\")))\n",
+    "        flat[f\"{prefix}w\"]     = float(size.get(\"w\", float(\"nan\")))\n",
+    "        flat[f\"{prefix}shape\"] = float(shape_map.get(obs.get(\"shape\", \"\"), float(\"nan\")))\n",
+    "\n",
+    "    return flat\n",
+    "\n",
+    "\n",
+    "def discover_all_missions(root_dir: str) -> dict[str, list[dict]]:\n",
+    "    \"\"\"\n",
+    "    Scan root folder and auto-discover all missions.\n",
+    "    \n",
+    "    Returns:\n",
+    "      {\n",
+    "        \"mission2\": [iterations],\n",
+    "        \"mission3\": [iterations],\n",
+    "        ...\n",
+    "      }\n",
+    "    \"\"\"\n",
+    "    root = Path(root_dir)\n",
+    "    if not root.exists():\n",
+    "        raise FileNotFoundError(f\"Root directory not found: {root_dir}\")\n",
+    "\n",
+    "    missions = {}\n",
+    "\n",
+    "    for mission_folder in sorted(root.iterdir()):\n",
+    "        if not mission_folder.is_dir():\n",
+    "            continue\n",
+    "        \n",
+    "        mission_name = mission_folder.name\n",
+    "        iterations = []\n",
+    "\n",
+    "        for iter_folder in sorted(mission_folder.iterdir()):\n",
+    "            if not iter_folder.is_dir():\n",
+    "                continue\n",
+    "\n",
+    "            iter_number = -1\n",
+    "            if iter_folder.name.startswith(\"iter\"):\n",
+    "                try:\n",
+    "                    iter_number = int(iter_folder.name[4:7])\n",
+    "                except (ValueError, IndexError):\n",
+    "                    pass\n",
+    "            elif iter_folder.name.startswith(\"test-\"):\n",
+    "                try:\n",
+    "                    iter_number = int(iter_folder.name.split(\"-\")[1])\n",
+    "                except (ValueError, IndexError):\n",
+    "                    pass\n",
+    "\n",
+    "            ulg_files = list(iter_folder.glob(\"*.ulg\"))\n",
+    "            yaml_files = list(iter_folder.glob(\"*.yaml\"))\n",
+    "\n",
+    "            iterations.append({\n",
+    "                \"iter_name\":   iter_folder.name,\n",
+    "                \"iter_number\": iter_number,\n",
+    "                \"iter_dir\":    iter_folder,\n",
+    "                \"ulg_files\":   ulg_files,\n",
+    "                \"yaml_path\":   yaml_files[0] if yaml_files else None,\n",
+    "            })\n",
+    "\n",
+    "        if iterations:\n",
+    "            missions[mission_name] = iterations\n",
+    "\n",
+    "    return missions\n",
+    "\n",
+    "\n",
+    "class ULogToDB:\n",
+    "\n",
+    "    def __init__(self, db_path: str = \"ulg_database.db\"):\n",
+    "        self.db_path = db_path\n",
+    "        self._migrate_and_init()\n",
+    "\n",
+    "    def _get_existing_tables(self, conn) -> set:\n",
+    "        return {r[0] for r in conn.execute(\n",
+    "            \"SELECT name FROM sqlite_master WHERE type='table'\"\n",
+    "        ).fetchall()}\n",
+    "\n",
+    "    def _get_existing_columns(self, conn, table: str) -> set:\n",
+    "        return {r[1] for r in conn.execute(f\"PRAGMA table_info({table})\").fetchall()}\n",
+    "\n",
+    "    def _migrate_and_init(self):\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            tables = self._get_existing_tables(conn)\n",
+    "\n",
+    "            if \"missions\" not in tables:\n",
+    "                conn.execute(\"\"\"\n",
+    "                CREATE TABLE missions (\n",
+    "                    id       INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                    name     TEXT UNIQUE,\n",
+    "                    root_dir TEXT\n",
+    "                )\"\"\")\n",
+    "                if \"flights\" in tables:\n",
+    "                    conn.execute(\n",
+    "                        \"INSERT OR IGNORE INTO missions (id, name, root_dir) VALUES (1, 'legacy', '')\"\n",
+    "                    )\n",
+    "\n",
+    "            if \"flights\" not in tables:\n",
+    "                conn.execute(\"\"\"\n",
+    "                CREATE TABLE flights (\n",
+    "                    id                  INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                    mission_id          INTEGER,\n",
+    "                    iter_name           TEXT,\n",
+    "                    iter_number         INTEGER,\n",
+    "                    filename            TEXT,\n",
+    "                    duration_s          REAL,\n",
+    "                    start_timestamp_us  INTEGER,\n",
+    "                    FOREIGN KEY(mission_id) REFERENCES missions(id)\n",
+    "                )\"\"\")\n",
+    "            else:\n",
+    "                cols = self._get_existing_columns(conn, \"flights\")\n",
+    "                if \"mission_id\" not in cols:\n",
+    "                    conn.execute(\"ALTER TABLE flights ADD COLUMN mission_id INTEGER DEFAULT 1\")\n",
+    "                if \"iter_name\" not in cols:\n",
+    "                    conn.execute(\"ALTER TABLE flights ADD COLUMN iter_name TEXT\")\n",
+    "                if \"iter_number\" not in cols:\n",
+    "                    conn.execute(\"ALTER TABLE flights ADD COLUMN iter_number INTEGER DEFAULT -1\")\n",
+    "\n",
+    "            if \"flight_context\" not in tables:\n",
+    "                conn.execute(\"\"\"\n",
+    "                CREATE TABLE flight_context (\n",
+    "                    id        INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                    flight_id INTEGER,\n",
+    "                    key       TEXT,\n",
+    "                    value     REAL,\n",
+    "                    FOREIGN KEY(flight_id) REFERENCES flights(id)\n",
+    "                )\"\"\")\n",
+    "\n",
+    "            conn.executescript(\"\"\"\n",
+    "            CREATE TABLE IF NOT EXISTS topics (\n",
+    "                id            INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                flight_id     INTEGER,\n",
+    "                name          TEXT,\n",
+    "                multi_id      INTEGER,\n",
+    "                message_count INTEGER,\n",
+    "                FOREIGN KEY(flight_id) REFERENCES flights(id)\n",
+    "            );\n",
+    "\n",
+    "            CREATE TABLE IF NOT EXISTS topic_fields (\n",
+    "                id         INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                topic_id   INTEGER,\n",
+    "                field_name TEXT,\n",
+    "                dtype      TEXT,\n",
+    "                FOREIGN KEY(topic_id) REFERENCES topics(id)\n",
+    "            );\n",
+    "\n",
+    "            CREATE TABLE IF NOT EXISTS topic_data (\n",
+    "                id         INTEGER PRIMARY KEY AUTOINCREMENT,\n",
+    "                topic_id   INTEGER,\n",
+    "                row_index  INTEGER,\n",
+    "                field_name TEXT,\n",
+    "                value      REAL,\n",
+    "                FOREIGN KEY(topic_id) REFERENCES topics(id)\n",
+    "            );\n",
+    "\n",
+    "            CREATE INDEX IF NOT EXISTS idx_topic_data_topic_id ON topic_data(topic_id);\n",
+    "            CREATE INDEX IF NOT EXISTS idx_flights_mission     ON flights(mission_id);\n",
+    "            CREATE INDEX IF NOT EXISTS idx_topics_flight       ON topics(flight_id);\n",
+    "            CREATE INDEX IF NOT EXISTS idx_ctx_flight          ON flight_context(flight_id);\n",
+    "            \"\"\")\n",
+    "\n",
+    "    def get_or_create_mission(self, name: str, root_dir: str) -> int:\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            cur = conn.cursor()\n",
+    "            cur.execute(\"SELECT id FROM missions WHERE name = ?\", (name,))\n",
+    "            row = cur.fetchone()\n",
+    "            if row:\n",
+    "                return row[0]\n",
+    "            cur.execute(\"INSERT INTO missions (name, root_dir) VALUES (?, ?)\", (name, str(root_dir)))\n",
+    "            return cur.lastrowid\n",
+    "\n",
+    "    def is_already_imported(self, filename: str, iter_name: str, mission_id: int) -> bool:\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            row = conn.execute(\n",
+    "                \"SELECT id FROM flights WHERE filename = ? AND iter_name = ? AND mission_id = ?\",\n",
+    "                (filename, iter_name, mission_id),\n",
+    "            ).fetchone()\n",
+    "        return row is not None\n",
+    "\n",
+    "    def insert_flight(self, ulog: ULog, ulg_path: Path, mission_id: int,\n",
+    "                      iter_name: str, iter_number: int) -> int:\n",
+    "        duration = (ulog.last_timestamp - ulog.start_timestamp) / 1e6\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            cur = conn.cursor()\n",
+    "            cur.execute(\n",
+    "                \"\"\"INSERT INTO flights\n",
+    "                   (mission_id, iter_name, iter_number, filename, duration_s, start_timestamp_us)\n",
+    "                   VALUES (?, ?, ?, ?, ?, ?)\"\"\",\n",
+    "                (mission_id, iter_name, iter_number, ulg_path.name, duration, ulog.start_timestamp),\n",
+    "            )\n",
+    "            return cur.lastrowid\n",
+    "\n",
+    "    def insert_yaml_context(self, flight_id: int, flat: dict):\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            conn.executemany(\n",
+    "                \"INSERT INTO flight_context (flight_id, key, value) VALUES (?, ?, ?)\",\n",
+    "                [(flight_id, k, v) for k, v in flat.items()],\n",
+    "            )\n",
+    "\n",
+    "    def insert_topics_and_data(self, ulog: ULog, flight_id: int, topics_filter: list[str] | None = None):\n",
+    "        \"\"\"\n",
+    "        Insert topics + data with optional filtering.\n",
+    "        \n",
+    "        Args:\n",
+    "            topics_filter: If provided, only store these topics to reduce DB size\n",
+    "        \"\"\"\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            cur = conn.cursor()\n",
+    "            for dataset in ulog.data_list:\n",
+    "                if topics_filter and dataset.name not in topics_filter:\n",
+    "                    continue  # Skip this topic entirely\n",
+    "\n",
+    "                cur.execute(\n",
+    "                    \"INSERT INTO topics (flight_id, name, multi_id, message_count) VALUES (?, ?, ?, ?)\",\n",
+    "                    (flight_id, dataset.name, dataset.multi_id, len(dataset.data[\"timestamp\"])),\n",
+    "                )\n",
+    "                topic_id = cur.lastrowid\n",
+    "\n",
+    "                for field_name, values in dataset.data.items():\n",
+    "                    cur.execute(\n",
+    "                        \"INSERT INTO topic_fields (topic_id, field_name, dtype) VALUES (?, ?, ?)\",\n",
+    "                        (topic_id, field_name, str(values.dtype)),\n",
+    "                    )\n",
+    "                    cur.executemany(\n",
+    "                        \"INSERT INTO topic_data (topic_id, row_index, field_name, value) VALUES (?, ?, ?, ?)\",\n",
+    "                        [(topic_id, i, field_name, float(v)) for i, v in enumerate(values)],\n",
+    "                    )\n",
+    "\n",
+    "    def process_single(self, ulg_path: Path, yaml_flat: dict,\n",
+    "                       mission_id: int, iter_name: str, iter_number: int,\n",
+    "                       topics_filter: list[str] | None = None) -> int:\n",
+    "        ulog = ULog(str(ulg_path))\n",
+    "        flight_id = self.insert_flight(ulog, ulg_path, mission_id, iter_name, iter_number)\n",
+    "        if yaml_flat:\n",
+    "            self.insert_yaml_context(flight_id, yaml_flat)\n",
+    "        self.insert_topics_and_data(ulog, flight_id, topics_filter)\n",
+    "        return flight_id\n",
+    "\n",
+    "\n",
+    "class ULogExporter:\n",
+    "\n",
+    "    def __init__(self, db_path: str = \"ulg_database.db\"):\n",
+    "        self.db_path = db_path\n",
+    "\n",
+    "    def _get_yaml_context(self, flight_id: int) -> dict:\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            rows = conn.execute(\n",
+    "                \"SELECT key, value FROM flight_context WHERE flight_id = ?\", (flight_id,)\n",
+    "            ).fetchall()\n",
+    "        return {k: v for k, v in rows}\n",
+    "\n",
+    "    def topic_to_dataframe(self, topic_id: int, downsample_factor: int = 1) -> pd.DataFrame:\n",
+    "        \"\"\"\n",
+    "        Load topic data with optional downsampling.\n",
+    "        \n",
+    "        Args:\n",
+    "            downsample_factor: Keep every Nth sample (1 = no downsampling, 10 = 10x reduction)\n",
+    "        \"\"\"\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            if downsample_factor == 1:\n",
+    "                df_raw = pd.read_sql_query(\n",
+    "                    \"SELECT row_index, field_name, value FROM topic_data WHERE topic_id = ? ORDER BY row_index\",\n",
+    "                    conn, params=(topic_id,),\n",
+    "                )\n",
+    "            else:\n",
+    "                # Downsample at query time\n",
+    "                df_raw = pd.read_sql_query(\n",
+    "                    f\"\"\"SELECT row_index, field_name, value \n",
+    "                        FROM topic_data \n",
+    "                        WHERE topic_id = ? AND row_index % ? = 0\n",
+    "                        ORDER BY row_index\"\"\",\n",
+    "                    conn, params=(topic_id, downsample_factor),\n",
+    "                )\n",
+    "        \n",
+    "        if df_raw.empty:\n",
+    "            return pd.DataFrame()\n",
+    "        df = df_raw.pivot(index=\"row_index\", columns=\"field_name\", values=\"value\")\n",
+    "        df.columns.name = None\n",
+    "        return df.reset_index(drop=True)\n",
+    "\n",
+    "    def build_ml_dataset(\n",
+    "        self,\n",
+    "        mission_name: str,\n",
+    "        topics: list[str],\n",
+    "        output_path: str = \"ml_dataset.parquet\",\n",
+    "        resample_us: int = 100_000,      # ← 100ms = 10Hz instead of 10ms\n",
+    "        downsample_factor: int = 10,     # ← Skip 9 out of 10 samples\n",
+    "    ) -> pd.DataFrame:\n",
+    "        \"\"\"\n",
+    "        Build optimized ML dataset with aggressive size reduction.\n",
+    "        \n",
+    "        Args:\n",
+    "            downsample_factor: Subsample raw data (10 = keep 1 in 10 samples)\n",
+    "            resample_us: Target resampling period in microseconds (100000 = 10Hz)\n",
+    "        \"\"\"\n",
+    "        with sqlite3.connect(self.db_path) as conn:\n",
+    "            mission_row = conn.execute(\"SELECT id FROM missions WHERE name = ?\", (mission_name,)).fetchone()\n",
+    "            if not mission_row:\n",
+    "                raise ValueError(f\"Mission unknown: {mission_name}\")\n",
+    "            mission_id = mission_row[0]\n",
+    "\n",
+    "            flights = conn.execute(\n",
+    "                \"SELECT id, iter_name, iter_number, filename FROM flights WHERE mission_id = ? ORDER BY iter_number, filename\",\n",
+    "                (mission_id,),\n",
+    "            ).fetchall()\n",
+    "\n",
+    "        all_dfs = []\n",
+    "        print(f\"\\n🔧 Building optimized ML dataset for {mission_name}\")\n",
+    "        print(f\"   Downsample factor : {downsample_factor}x\")\n",
+    "        print(f\"   Resample period   : {resample_us/1000:.0f}ms ({1e6/resample_us:.0f}Hz)\")\n",
+    "        print(f\"   Processing {len(flights)} flights...\")\n",
+    "\n",
+    "        for flight_id, iter_name, iter_number, filename in tqdm(flights, desc=\"Merging\"):\n",
+    "            with sqlite3.connect(self.db_path) as conn:\n",
+    "                topic_rows = conn.execute(\n",
+    "                    \"SELECT id, name FROM topics WHERE flight_id = ?\", (flight_id,)\n",
+    "                ).fetchall()\n",
+    "            topic_map = {name: tid for tid, name in topic_rows}\n",
+    "\n",
+    "            dfs = {}\n",
+    "            for name in topics:\n",
+    "                if name not in topic_map:\n",
+    "                    continue\n",
+    "                df = self.topic_to_dataframe(topic_map[name], downsample_factor)\n",
+    "                if \"timestamp\" not in df.columns or df.empty:\n",
+    "                    continue\n",
+    "                df = df.rename(columns={c: f\"{name}__{c}\" if c != \"timestamp\" else c for c in df.columns})\n",
+    "                dfs[name] = df.set_index(\"timestamp\")\n",
+    "\n",
+    "            if not dfs:\n",
+    "                continue\n",
+    "\n",
+    "            merged = pd.concat(dfs.values(), axis=1, join=\"outer\").sort_index()\n",
+    "            \n",
+    "            # Resample to uniform grid\n",
+    "            t_min, t_max = merged.index.min(), merged.index.max()\n",
+    "            grid = np.arange(t_min, t_max, resample_us)\n",
+    "            \n",
+    "            if len(grid) > 0:\n",
+    "                merged = (\n",
+    "                    merged.reindex(merged.index.union(grid))\n",
+    "                          .interpolate(\"index\")\n",
+    "                          .loc[grid]\n",
+    "                          .reset_index()\n",
+    "                          .rename(columns={\"index\": \"timestamp\"})\n",
+    "                )\n",
+    "            else:\n",
+    "                merged = merged.reset_index().rename(columns={\"index\": \"timestamp\"})\n",
+    "\n",
+    "            # Static YAML features\n",
+    "            for key, value in self._get_yaml_context(flight_id).items():\n",
+    "                merged[key] = value\n",
+    "\n",
+    "            merged[\"iter_number\"] = iter_number\n",
+    "            merged[\"iter_name\"]   = iter_name\n",
+    "            merged[\"filename\"]    = filename\n",
+    "            all_dfs.append(merged)\n",
+    "\n",
+    "        if not all_dfs:\n",
+    "            print(\"⚠️  No data found.\")\n",
+    "            return pd.DataFrame()\n",
+    "\n",
+    "        final = pd.concat(all_dfs, ignore_index=True)\n",
+    "        out = Path(output_path)\n",
+    "        out.parent.mkdir(parents=True, exist_ok=True)\n",
+    "        final.to_parquet(out, index=False, compression=\"gzip\")  # Add gzip compression\n",
+    "\n",
+    "        size_mb = out.stat().st_size / (1024**2)\n",
+    "        \n",
+    "        print(f\"\\n✅ ML dataset: {out}\")\n",
+    "        print(f\"   File size  : {size_mb:.1f} MB\")\n",
+    "        print(f\"   Shape      : {final.shape}\")\n",
+    "        print(f\"   Iterations : {final['iter_name'].nunique()}\")\n",
+    "        print(f\"   Flights    : {final['filename'].nunique()}\")\n",
+    "        return final\n",
+    "\n",
+    "\n",
+    "# ======================================================\n",
+    "# PIPELINE\n",
+    "# ======================================================\n",
+    "\n",
+    "def run_pipeline(\n",
+    "    root_dir: str,\n",
+    "    db_path: str = \"test.db\",\n",
+    "    ml_topics: list[str] | None = None,\n",
+    "    resample_us: int = 100_000,          \n",
+    "    downsample_factor: int = 10,        \n",
+    "    skip_existing: bool = True,\n",
+    "    export_per_mission: bool = True,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Optimized pipeline with aggressive size reduction.\n",
+    "    \n",
+    "    Size reduction strategies:\n",
+    "    1. Only store ml_topics (not all topics)\n",
+    "    2. Downsample raw data by downsample_factor\n",
+    "    3. Resample to lower frequency (resample_us)\n",
+    "    4. Compress Parquet with gzip\n",
+    "    \"\"\"\n",
+    "    print(f\"\\n{'='*60}\")\n",
+    "    print(f\"SURREALIST MULTI-MISSION PIPELINE (OPTIMIZED)\")\n",
+    "    print(f\"{'='*60}\")\n",
+    "    print(f\"Root directory    : {root_dir}\")\n",
+    "    print(f\"Database          : {db_path}\")\n",
+    "    print(f\"Topics to store   : {ml_topics}\")\n",
+    "    print(f\"Downsample factor : {downsample_factor}x\")\n",
+    "    print(f\"Target frequency  : {1e6/resample_us:.0f}Hz\\n\")\n",
+    "\n",
+    "    missions_data = discover_all_missions(root_dir)\n",
+    "\n",
+    "    total_iters = sum(len(iters) for iters in missions_data.values())\n",
+    "    total_ulg   = sum(len(it[\"ulg_files\"]) for iters in missions_data.values() for it in iters)\n",
+    "\n",
+    "    print(f\"=== DISCOVERY ===\")\n",
+    "    print(f\"  Missions found    : {len(missions_data)}\")\n",
+    "    print(f\"  Total iterations  : {total_iters}\")\n",
+    "    print(f\"  Total .ulg files  : {total_ulg}\")\n",
+    "    for mission_name, iters in missions_data.items():\n",
+    "        n_ulg = sum(len(it[\"ulg_files\"]) for it in iters)\n",
+    "        print(f\"    {mission_name:<15} : {len(iters)} iters, {n_ulg} .ulg\")\n",
+    "\n",
+    "    print(f\"\\n=== IMPORT → {db_path} ===\")\n",
+    "    db = ULogToDB(db_path=db_path)\n",
+    "\n",
+    "    imported = skipped = failed = 0\n",
+    "\n",
+    "    for mission_name, iterations in missions_data.items():\n",
+    "        mission_id = db.get_or_create_mission(mission_name, root_dir)\n",
+    "        print(f\"\\n  [{mission_name}]\")\n",
+    "\n",
+    "        for it in tqdm(iterations, desc=f\"  {mission_name}\", leave=False):\n",
+    "            yaml_flat = {}\n",
+    "            if it[\"yaml_path\"] and it[\"yaml_path\"].exists():\n",
+    "                try:\n",
+    "                    yaml_flat = flatten_yaml(it[\"yaml_path\"])\n",
+    "                except Exception as e:\n",
+    "                    print(f\"    ⚠️  YAML parse error in {it['iter_name']}: {e}\")\n",
+    "\n",
+    "            for ulg_path in it[\"ulg_files\"]:\n",
+    "                if skip_existing and db.is_already_imported(ulg_path.name, it[\"iter_name\"], mission_id):\n",
+    "                    skipped += 1\n",
+    "                    continue\n",
+    "                try:\n",
+    "                    db.process_single(\n",
+    "                        ulg_path, yaml_flat, mission_id, it[\"iter_name\"], it[\"iter_number\"],\n",
+    "                        topics_filter=ml_topics  # Only store ML topics\n",
+    "                    )\n",
+    "                    imported += 1\n",
+    "                except Exception as e:\n",
+    "                    print(f\"    ❌ {ulg_path.name}: {e}\")\n",
+    "                    failed += 1\n",
+    "\n",
+    "    print(f\"\\n  Imported : {imported}\")\n",
+    "    print(f\"  Skipped  : {skipped}\")\n",
+    "    print(f\"  Failed   : {failed}\")\n",
+    "\n",
+    "    if ml_topics:\n",
+    "        print(f\"\\n=== ML EXPORT (OPTIMIZED) ===\")\n",
+    "        exporter = ULogExporter(db_path=db_path)\n",
+    "\n",
+    "        if export_per_mission:\n",
+    "            for mission_name in missions_data.keys():\n",
+    "                exporter.build_ml_dataset(\n",
+    "                    mission_name      = mission_name,\n",
+    "                    topics            = ml_topics,\n",
+    "                    output_path       = f\"exports/{mission_name}/ml_dataset.parquet\",\n",
+    "                    resample_us       = resample_us,\n",
+    "                    downsample_factor = downsample_factor,\n",
+    "                )\n",
+    "\n",
+    "    print(f\"\\n{'='*60}\")\n",
+    "    print(\"PIPELINE COMPLETE\")\n",
+    "    print(f\"{'='*60}\\n\")\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b41f2ee7-a073-4ca3-8ed2-1eac49b92150",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "if __name__ == \"__main__\":\n",
+    "\n",
+    "    run_pipeline(\n",
+    "        root_dir = \".\\Surrealist\\Surrealist-evaluated-tests\",\n",
+    "        db_path  = \"UAV.db\",\n",
+    "\n",
+    "        ml_topics = [\n",
+    "            \"vehicle_local_position\",\n",
+    "            \"vehicle_attitude\",\n",
+    "            \"sensor_combined\",\n",
+    "            \"vehicle_status\",\n",
+    "        ],\n",
+    "\n",
+    "        resample_us       = 100_000,  \n",
+    "        downsample_factor = 10,\n",
+    "        skip_existing     = True,\n",
+    "        export_per_mission = True,\n",
+    "    )"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "33410dc3",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.13.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}