remove v

Author: PICO-XR-Dev

AGENTS.md

@@ -1,16 +1,23 @@
 # Repository Guidelines
 
 ## Project Structure & Module Organization
-Core C++ sources live in `src/spatialmp4`, with corresponding headers under `spatialmp4/`. Pybind11 bridge code is under `bindings/`, while the published Python package pieces sit in `python/`. Reference assets are stored in `video/`, reusable build logic in `cmake/`, and helper scripts in `scripts/`. End-user docs and design notes are collected in `docs/`, and runnable walkthroughs reside in `examples/`.
+Core C++ sources live in `src/spatialmp4`, with helpers under `src/spatialmp4/utilities` and Google Test fixtures in `src/spatialmp4/reader_test.cc`.
+Python bindings are assembled in `bindings/spatialmp4.cpp`, while Python packaging and tests sit in `python/`.
+Reference assets (for example `video/test.mp4`) and temporary visualization outputs (`tmp_vis_depth/`) are kept at the repository root.
+Example end-to-end scripts are available under `examples/python` and double as smoke tests for new features.
 
 ## Build, Test, and Development Commands
-Build FFmpeg and third-party dependencies once via `bash scripts/build_ffmpeg.sh` (or `pixi run build-ffmpeg`). Configure and compile the C++ library with `pixi run build`, which wraps the Ninja-based CMake invocation. For a clean rebuild, use `pixi run rebuild`. Run the C++ regression suite with `pixi run test` (expects `video/test.mp4` relative to `build/`), and execute Python coverage with `pixi run test-python`. When debugging locally outside Pixi, replicate the commands shown inside `pixi.toml`.
+Install third-party dependencies and FFmpeg once via `bash scripts/install_deps.sh` and `bash scripts/build_ffmpeg.sh`.
+A standard native build flow is `cmake -B build -S . -DCMAKE_BUILD_TYPE=Release -DBUILD_PYTHON=OFF` followed by `cmake --build build`.
+When using Pixi, `pixi run build-ffmpeg`, `pixi run build`, and `pixi run rebuild` mirror those steps.
+Package the Python wheel with `pip install .` or `pixi run build` after enabling `-DBUILD_PYTHON=ON`.
+Run cpp unittest: `./build/host/test_reader`. Run python unittest: `pytest -s python/tests`
 
 ## Coding Style & Naming Conventions
-We enforce clang-format 17 using the repository `.clang-format` (Google base style, two-space indentation, 120 character limit). Ensure each new C++ source file includes the license header inserted by the `insert-license` pre-commit hook. Function and type names should be in PascalCase, while variables use lower_snake_case; mirror existing reader/writer APIs. Python modules follow PEP 8, with snake_case functions and CapWords classes. Install the hooks with `pre-commit install` and run `pre-commit run --all-files` before uploading.
+`.clang-format` enforces Google style with 2-space indentation, 120-character lines, and brace-on-same-line formatting. Run `pre-commit run --all-files` (configured for `clang-format` and license insertion) before submitting patches. C++ classes use PascalCase (e.g., `RandomAccessVideoReader`), member functions stay in UpperCamelCase, and local variables use snake_case. Python modules follow PEP 8 naming; prefer snake_case for functions and lower_case_with_underscores for files.
 
 ## Testing Guidelines
-Prefer authoring new C++ tests next to the feature under `src/spatialmp4/tests` or augmenting `test_reader`. Tests should gate on fixtures in `video/` or clearly documented synthetic inputs. Python tests belong in `python/tests/` and must start with `test_`. Document any new assets and keep them under 5 MB where possible. Capture expected outputs or assertions that cover RGB and depth code paths when adding spatial data features.
+Enable the C++ test suite with `cmake -B build -S . -DBUILD_TESTING=ON && cmake --build build`, then execute `VIDEO=../video/test.mp4 ./build/test_reader`. The Pixi shortcut `pixi run test` wraps the same flow. Python tests live in `python/tests` and use pytest; run them with `pixi run test-python` or `pytest python/tests`. New tests should follow the `test_*.py` or `*_test.cc` naming pattern and cover both RGB-only and depth-enabled paths; set the `VIDEO` environment variable when a custom fixture is required.
 
 ## Commit & Pull Request Guidelines
-Commit messages are short, present-tense imperatives (e.g., `add depth frame normalizer`). Group related changes per commit; avoid umbrella “update” descriptions. Pull requests must describe the motivation, list functional changes, and call out breaking API shifts. Reference tracked issues with `Fixes #ID` when applicable, include reproduction or validation commands (copy the `pixi run …` steps), and attach screenshots for visualization updates.
+History favors short, imperative commit subjects (for example, `set loglevel in reader`). Keep message bodies concise, reference related issues, and group mechanical formatting changes separately from functional updates. Pull requests should describe the feature or fix, outline test coverage (`pixi run test`, `pixi run test-python`, manual example scripts), and include screenshots or logs when touching visualization or CLI output. Ensure CI prerequisites (FFmpeg build, dependencies) are documented in the PR notes for new contributors.

README.md

@@ -268,6 +268,10 @@ camera_extrinsics GetRgbExtrinsicsLeft() const;   // Left RGB camera extrinsics
 camera_extrinsics GetRgbExtrinsicsRight() const;  // Right RGB camera extrinsics
 camera_intrinsics GetDepthIntrinsics() const;     // Depth camera intrinsics
 camera_extrinsics GetDepthExtrinsics() const;     // Depth camera extrinsics
+bool IsRgbDistorted() const;                      // Whether RGB stream applies lens distortion
+std::string GetRgbDistortionModel() const;        // Distortion model name (e.g., kBrownConrady)
+std::string GetRgbDistortionParamsLeft() const;   // Left RGB distortion parameters
+std::string GetRgbDistortionParamsRight() const;  // Right RGB distortion parameters
 ```
 
 #### Reading Control Methods
@@ -378,6 +382,10 @@ Main class for reading SpatialMP4 files.
 - `get_rgb_extrinsics_right() -> CameraExtrinsics` — Get right RGB camera extrinsics.
 - `get_depth_intrinsics() -> CameraIntrinsics` — Get depth camera intrinsics.
 - `get_depth_extrinsics() -> CameraExtrinsics` — Get depth camera extrinsics.
+- `is_rgb_distorted() -> bool` — Whether the RGB stream includes lens distortion.
+- `get_rgb_distortion_model() -> str` — Distortion model name (`"kBrownConrady"`, etc.).
+- `get_rgb_distortion_params_left() -> str` — Serialized left-eye distortion parameters.
+- `get_rgb_distortion_params_right() -> str` — Serialized right-eye distortion parameters.
 - `get_pose_frames() -> List[PoseFrame]` — Get all pose frames.
 - `set_read_mode(mode: ReadMode)` — Set reading mode (see enums below).
 - `has_next() -> bool` — Whether there is a next frame.

bindings/spatialmp4.cpp

@@ -153,7 +153,7 @@ PYBIND11_MODULE(spatialmp4, m) {
 
   // Bind Reader class
   py::class_<SpatialML::Reader>(m, "Reader")
-      .def(py::init<const std::string &>())
+      .def(py::init<const std::string &, const std::string &>(), py::arg("filename"), py::arg("log_level") = "quiet")
       .def("has_rgb", &SpatialML::Reader::HasRGB)
       .def("has_depth", &SpatialML::Reader::HasDepth)
       .def("has_pose", &SpatialML::Reader::HasPose)

scripts/build_ffmpeg.sh

@@ -126,7 +126,7 @@ build_install_opencv() {
     BUILD_FLAGS="
         -D CMAKE_BUILD_TYPE=RELEASE
         -D BUILD_LIST=core,imgproc,imgcodecs
-        -D WITH_TBB=ON
+        -D WITH_TBB=OFF
         -D WITH_OPENEXR=ON
         -D WITH_EIGEN=ON
         -D WITH_GSTREAMER=OFF

src/spatialmp4/reader.cc

@@ -226,8 +226,31 @@ AVFrame* RandomAccessVideoReader::process_frame(AVFrame* frame) {
 
 /******************** Reader ********************/
 
-Reader::Reader(const std::string& filename)
+void SetFFmpegLogLevel(const std::string& log_level) {
+  static const std::unordered_map<std::string, int> log_level_map = {
+    {"quiet", AV_LOG_QUIET},
+    {"panic", AV_LOG_PANIC},
+    {"fatal", AV_LOG_FATAL},
+    {"error", AV_LOG_ERROR},
+    {"warning", AV_LOG_WARNING},
+    {"info", AV_LOG_INFO},
+    {"verbose", AV_LOG_VERBOSE},
+    {"debug", AV_LOG_DEBUG},
+    {"trace", AV_LOG_TRACE}
+  };
+
+  auto it = log_level_map.find(log_level);
+  if (it != log_level_map.end()) {
+    av_log_set_level(it->second);
+  } else {
+    spdlog::warn("Invalid FFmpeg log level: '{}'. Using 'warning' as default.", log_level);
+    av_log_set_level(AV_LOG_WARNING);
+  }
+}
+
+Reader::Reader(const std::string& filename, const std::string& log_level)
     : filename_(filename),
+      log_level_(log_level),
       read_mode_(ReadMode::DEPTH_FIRST),
       pFormatCtx_(NULL),
       has_rgb_(false),
@@ -253,7 +276,8 @@ Reader::Reader(const std::string& filename)
       keyframe_rgb_idx_(0),
       allframe_rgb_idx_(0),
       keyframe_depth_idx_(0) {
-  // av_log_set_level(AV_LOG_DEBUG);
+  
+  SetFFmpegLogLevel(log_level_);
 
   if (filename_.find(' ') != std::string::npos) {
     throw std::runtime_error("Find blank in filename, please fix it.");
@@ -821,7 +845,7 @@ bool Reader::SeekToRgbKeyframe(int64_t target_pts) {
 }
 
 bool Reader::IsLastFrame() {
-  std::cout << "GetIndex: " << GetIndex() << ", GetFrameCount: " << GetFrameCount() << std::endl;
+  // std::cout << "GetIndex: " << GetIndex() << ", GetFrameCount: " << GetFrameCount() << std::endl;
   return GetIndex() == GetFrameCount() - 1;
 }
 

src/spatialmp4/reader.h

@@ -102,7 +102,7 @@ class SPATIALMP4_EXPORT Reader {
     }
   }
 
-  Reader(const std::string& filename);
+  Reader(const std::string& filename, const std::string& log_level);
   ~Reader();
 
   bool HasRGB() const { return has_rgb_; }
@@ -157,6 +157,7 @@ class SPATIALMP4_EXPORT Reader {
 
  private:
   std::string filename_;
+  std::string log_level_;
   ReadMode read_mode_;
   AVFormatContext* pFormatCtx_;
   AVPacket current_packet_;