Real-Time Target Detection and Tracking
Confidentiality note
This work is subject to confidentiality obligations. Client and product names, performance parameters, screenshots and test data are deliberately omitted; the account stays at the level of the engineering problem solved and the technology used. Technical detail can be shown in person, to the extent confidentiality allows.
The problem
I developed real-time image processing based target detection and tracking software for a defence industry client. The detection side was written in C++, the tracking side in Python. I built the data-driven symbol overlay rendering on live video and the operator interface in Qt Creator/C++.
To meet the real-time throughput requirement I built parallel processing pipelines with C++ multithreading, CUDA C and OpenMP. The whole pipeline was integrated to run on NVIDIA Jetson embedded platforms, with data exchange carried over TCP, UDP and UART.
Visual and thermal channels
The system works on both visual and thermal/infrared camera feeds: the same detection and tracking pipeline locks onto aerial targets, including drones, across both spectra, with real-time bounding boxes, crosshair targeting and data-driven symbol overlay rendered onto the live video.
Everything beyond what these frames show stays confidential: no end-client names, no performance parameters, no test data. More can be discussed in person, to the extent confidentiality allows.
Fielded, operational software: this is the project where I learned what it takes for a detector to survive outside the lab, on real hardware, on a real video feed, for years.
// Uretici-tuketici iskeleti: yakalama asla cikarimi beklemez.
// Kuyruk dolarsa EN ESKI kare atilir; gercek zamanda gecikme,
// kare kaybindan daha pahalidir.
template <typename T>
class SinirliKuyruk {
std::deque<T> q_; std::mutex m_; std::condition_variable cv_;
size_t kapasite_;
public:
void koy(T kare) {
{ std::lock_guard<std::mutex> k(m_);
if (q_.size() >= kapasite_) q_.pop_front(); // eskiyi at
q_.push_back(std::move(kare)); }
cv_.notify_one();
}
T al() {
std::unique_lock<std::mutex> k(m_);
cv_.wait(k, [&]{ return !q_.empty(); });
T kare = std::move(q_.front()); q_.pop_front();
return kare;
}
};