tracking_types.h

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstdint>
 
namespace tracking
{
constexpr int kGridW = 40;
constexpr int kGridH = 30;
constexpr int kCells = kGridW * kGridH;
constexpr int kMaxBlobs = 16;
 
using GrayFrame = std::array<uint8_t, kCells>;
 
struct Box {
    int x0 = 0;
    int y0 = 0;
    int x1 = -1;
    int y1 = -1;
 
    bool empty() const { return x1 < x0 || y1 < y0; }
    int width() const { return empty() ? 0 : x1 - x0 + 1; }
    int height() const { return empty() ? 0 : y1 - y0 + 1; }
 
    bool overlaps(const Box& o) const
    {
        return !empty() && !o.empty() && x0 <= o.x1 && o.x0 <= x1 && y0 <= o.y1 && o.y0 <= y1;
    }
 
    void merge(const Box& o)
    {
        if (o.empty())
        {
            return;
        }
        if (empty())
        {
            *this = o;
            return;
        }
        x0 = o.x0 < x0 ? o.x0 : x0;
        y0 = o.y0 < y0 ? o.y0 : y0;
        x1 = o.x1 > x1 ? o.x1 : x1;
        y1 = o.y1 > y1 ? o.y1 : y1;
    }
};
 
struct Blob {
    Box box;
    int area = 0;    
    float cx = 0.0f; 
    float cy = 0.0f;
};
 
struct DetectorConfig {
    int diff_threshold = 20;             
    int bg_shift = 4;                    
    int fg_shift = 7;                    
    int fg_age_limit = 34;               
    float scene_change_fraction = 0.35f; 
    int scene_change_mean_shift = 25;    
    int warmup_frames = 17;              
    int min_blob_cells = 2;              
    int max_blobs = kMaxBlobs;           
};
 
struct DetectionResult {
    bool scene_change = false;   
    bool warming_up = false;     
    bool label_overflow = false; 
    int foreground_cells = 0;    
    int dropped_components = 0;  
    int blob_count = 0;
    std::array<Blob, kMaxBlobs> blobs{};
};
 
enum class TrackPhase : uint8_t { Idle = 0, Tentative = 1, Locked = 2, Coasting = 3 };
 
inline const char* to_string(TrackPhase phase)
{
    switch (phase)
    {
    case TrackPhase::Tentative:
        return "tentative";
    case TrackPhase::Locked:
        return "locked";
    case TrackPhase::Coasting:
        return "coasting";
    default:
        return "idle";
    }
}
 
struct TrackerConfig {
    int confirm_frames = 3;        
    int coast_frames = 17;         
    float alpha = 0.5f;            
    float beta = 0.2f;             
    int gate_margin_min = 2;       
    float gate_margin_frac = 0.5f; 
    float velocity_decay = 0.8f;   
    int coast_gate_growth = 1;     
};
 
struct TrackState {
    TrackPhase state = TrackPhase::Idle;
    uint32_t id = 0;
    Box box;
    float cx = 0.0f;
    float cy = 0.0f;
    float vx = 0.0f;
    float vy = 0.0f;
    int frames_since_seen = 0;
    int area = 0;
};
} // namespace tracking