msjidandClaude Haiku 4.5
7c8909d496
Includes project overview, features, build instructions, API reference, usage examples, and notes on memory management. Co-Authored-By: Claude Haiku 4.5 <[email protected]> Claude-Session: https://claude.ai/code/session_01PZax2uzbHdkL7ukmmF9C3C
126 lines
3.6 KiB
Markdown
126 lines
3.6 KiB
Markdown
# CPP Buffer Template
|
|
|
|
A generic C++ template-based buffer system designed for efficiently managing and storing image and odometry data.
|
|
|
|
## Overview
|
|
|
|
This project demonstrates a reusable `Buffer` template class that provides a flexible way to manage collections of data with optional associated metadata (odometry information). It's particularly useful for robotics and computer vision applications where you need to buffer sensor data.
|
|
|
|
## Features
|
|
|
|
- **Generic Template Design**: Works with any data type via C++ templates
|
|
- **Flexible Data Storage**: Supports storing single or multiple data items per buffer
|
|
- **Metadata Support**: Optionally associate metadata (e.g., odometry data) with stored items
|
|
- **Configuration Tracking**: Query buffer state and size information
|
|
- **Simple API**: Intuitive `push()` and `read()` interface
|
|
|
|
## Project Structure
|
|
|
|
```
|
|
CPP_buffer_template/
|
|
├── CMakeLists.txt # CMake build configuration
|
|
├── README.md # This file
|
|
├── include/
|
|
│ └── buffer.hpp # Buffer template class definition
|
|
└── src/
|
|
└── main.cpp # Example usage and demonstration
|
|
```
|
|
|
|
## Building
|
|
|
|
### Requirements
|
|
|
|
- C++11 or later
|
|
- CMake 3.4 or higher
|
|
- A C++ compiler (g++, clang, etc.)
|
|
|
|
### Build Steps
|
|
|
|
```bash
|
|
mkdir build
|
|
cd build
|
|
cmake ..
|
|
make
|
|
```
|
|
|
|
### Running
|
|
|
|
After building, run the demonstration:
|
|
|
|
```bash
|
|
./p_demo_04_template_buffer
|
|
```
|
|
|
|
## Usage
|
|
|
|
### Basic Example
|
|
|
|
```cpp
|
|
#include "buffer.hpp"
|
|
|
|
// Create a buffer for storing image data (pair of pointers) and odometry data
|
|
Buffer<std::pair<u_char*,u_char*>, double> buffer;
|
|
|
|
// Push a single data item
|
|
u_char* depth = (u_char*)calloc(100, sizeof(u_char));
|
|
u_char* left = (u_char*)calloc(100, sizeof(u_char));
|
|
buffer.push(std::pair<u_char*,u_char*>(depth, left));
|
|
|
|
// Read the stored data
|
|
std::vector<std::pair<u_char*,u_char*>>* data = buffer.read();
|
|
|
|
// Access configuration (size and timestamp)
|
|
auto cfg = buffer.config();
|
|
std::cout << "Buffer size: " << cfg.first << std::endl;
|
|
```
|
|
|
|
### API Reference
|
|
|
|
#### Constructor
|
|
```cpp
|
|
Buffer<T1, T2>()
|
|
```
|
|
Creates an empty buffer.
|
|
|
|
#### Push Methods
|
|
```cpp
|
|
void push(T1 input) // Store single item
|
|
void push(T1 input_1, T2* input_2) // Store item with metadata
|
|
void push(T1 input_1, T1 input_2) // Store two items
|
|
void push(T1 input_1, T1 input_2, T2* input_3) // Store two items with metadata
|
|
```
|
|
|
|
#### Read Methods
|
|
```cpp
|
|
std::vector<T1>* read() // Get pointer to stored items
|
|
T2* read_odom() // Get metadata pointer
|
|
int64_t time() // Get timestamp
|
|
std::pair<std::size_t, int64_t> config() // Get size and timestamp
|
|
```
|
|
|
|
## Template Parameters
|
|
|
|
- **T1**: The primary data type to store (e.g., `std::pair<u_char*, u_char*>` for image pairs)
|
|
- **T2**: The metadata type to associate with stored data (e.g., `double` for odometry values)
|
|
|
|
## Example Use Cases
|
|
|
|
1. **Robotics**: Buffer sensor frames (RGB, depth) along with odometry data from the robot's pose
|
|
2. **Computer Vision**: Queue image frames from multiple cameras
|
|
3. **Data Processing**: Temporarily store processing results with associated context
|
|
|
|
## Notes
|
|
|
|
- The buffer uses dynamic memory management (pointers); ensure proper cleanup to avoid memory leaks
|
|
- The `odom` metadata pointer is optional and defaults to `nullptr`
|
|
- The timestamp field (`t`) is initialized to 0; it can be updated if needed
|
|
- The buffer stores raw pointers - ensure the pointed-to data remains valid during the buffer's lifetime
|
|
|
|
## License
|
|
|
|
This project is part of the gfuse-show-cases repository.
|
|
|
|
## Author
|
|
|
|
Created as a demonstration of C++ template programming and generic buffer management patterns.
|