کدهای زیر کاملا درست کار میکنند
میخوام فریم ها و نمایش کاملا روی gpu باشد تا سرعت sharedmemory بیشتر شود
کد نهایی را کامل بنویس

#include <cuda_runtime.h>
#include <fstream>
#include <fcntl.h>
#include <sys/mman.h>
#include <unistd.h>
#include <cstdint>
#include <iostream>
#include <opencv2/opencv.hpp>
#include <thread>
#include <mutex>
#include <atomic>
#include <condition_variable>
#include <chrono>
#include <semaphore.h>

// Shared Memory Names
static const char* SHM_FRAME_NAME = "/shm_frames";
static const char* SHM_DETS_NAME = "/shm_detections";
static const char* SHM_TRACKS_NAME = "/shm_tracks";

// Semaphore Names
static const char* SEM_FRAME_READY = "/sem_frame_ready";
static const char* SEM_DETS_READY = "/sem_dets_ready";
static const char* SEM_TRACKS_READY = "/sem_tracks_ready";

static const int MAX_DETS = 512;
static const int MAX_TRACKS = 512;

#pragma pack(push, 1)
struct Header {
uint32_t width;
uint32_t height;
uint32_t channels;
uint32_t stride_bytes;
uint32_t frame_id;
uint32_t num_items; // num_detections or num_tracks
uint32_t finished;
uint32_t reserved;
};

struct ShareDetection {
float x, y, w, h;
float confidence;
int32_t class_id;
};

struct ShareTrack {
float x, y, w, h;
int32_t track_id;
int32_t class_id;
float confidence;
int32_t reserved;
};
#pragma pack(pop)

// Global variables
std::atomic<bool> should_exit{false};
std::atomic<uint32_t> current_frame_id{0};

class YOLOv8Detector {
public:
YOLOv8Detector(const std::string& model_path, const std::string& class_file_path,
float conf_thresh = 0.30f, float nms_thresh = 0.4f)
: conf_threshold(conf_thresh), nms_threshold(nms_thresh),
input_width(640), input_height(640) {

text
    std::cout << "🔄 Loading YOLOv8 model: " << model_path << std::endl;
    net = cv::dnn::readNet(model_path);
    try {
        net.setPreferableBackend(cv::dnn::DNN_BACKEND_CUDA);
        net.setPreferableTarget(cv::dnn::DNN_TARGET_CUDA);
        std::cout << "✅ Using GPU (CUDA) backend\n";
    } catch (...) {
        net.setPreferableBackend(cv::dnn::DNN_BACKEND_OPENCV);
        net.setPreferableTarget(cv::dnn::DNN_TARGET_CPU);
        std::cout << "⚠️ Using CPU backend\n";
    }
    loadClassNames(class_file_path);
    boxes.reserve(1000); confidences.reserve(1000); class_ids.reserve(1000);
    outputs.reserve(10);
    std::cout << "✅ YOLOv8 model loaded successfully!\n";
}

struct Detection {
    cv::Rect bbox;
    float confidence;
    int class_id;
    std::string class_name;
};

std::vector<Detection> detect(const cv::Mat& frame, double& inference_time_ms) {
    auto t0 = std::chrono::high_resolution_clock::now();

    boxes.clear(); confidences.clear(); class_ids.clear(); outputs.clear();
    cv::dnn::blobFromImage(frame, blob, 1.0/255.0, cv::Size(input_width, input_height),
                           cv::Scalar(0,0,0), true, false, CV_32F);
    net.setInput(blob);
    net.forward(outputs, net.getUnconnectedOutLayersNames());

    auto t1 = std::chrono::high_resolution_clock::now();
    inference_time_ms = std::chrono::duration<double, std::milli>(t1 - t0).count();

    return postProcess(frame, outputs);
}

private:
cv::dnn::Net net;
std::vectorstd::string class_names;
float conf_threshold, nms_threshold;
int input_width, input_height;
cv::Mat blob;
std::vectorcv::Mat outputs;
std::vectorcv::Rect boxes;
std::vector<float> confidences;
std::vector<int> class_ids;

text
void loadClassNames(const std::string& class_file_path) {
    std::ifstream file(class_file_path);
    std::string line;
    if (file.is_open()) {
        while (std::getline(file, line)) class_names.push_back(line);
        file.close();
    } else {
        std::cout << "⚠️ Class file not found. Using fallback labels.\n";
        class_names = {"person", "bicycle", "car", "motorcycle", "airplane", "bus", "train", "truck"};
    }
}

std::vector<Detection> postProcess(const cv::Mat& frame, const std::vector<cv::Mat>& outputs) {
    std::vector<Detection> detections; detections.reserve(100);
    float x_factor = frame.cols / static_cast<float>(input_width);
    float y_factor = frame.rows / static_cast<float>(input_height);

    for (const auto& out : outputs) {
        const float* data = (float*)out.data;
        int num_classes = out.size[1] - 4;
        int num_detections = out.size[2];
        
        for (int i = 0; i < num_detections; ++i) {
            float cx = data[i];
            float cy = data[i + num_detections];
            float w  = data[i + 2*num_detections];
            float h  = data[i + 3*num_detections];

            float best = 0.f; int best_id = 0;
            for (int j = 4; j < 4 + num_classes; ++j) {
                float conf = data[i + j*num_detections];
                if (conf > best) { best = conf; best_id = j - 4; }
            }
            
            if (best >= conf_threshold) {
                int x1 = (int)((cx - w/2) * x_factor);
                int y1 = (int)((cy - h/2) * y_factor);
                int ww = (int)(w * x_factor);
                int hh = (int)(h * y_factor);
                boxes.emplace_back(x1, y1, ww, hh);
                confidences.push_back(best);
                class_ids.push_back(best_id);
            }
        }
    }
    
    std::vector<int> idx;
    cv::dnn::NMSBoxes(boxes, confidences, conf_threshold, nms_threshold, idx);
    detections.reserve(idx.size());
    
    for (int k : idx) {
        Detection d;
        d.bbox = boxes[k];
        d.confidence = confidences[k];
        d.class_id = class_ids[k];
        d.class_name = (d.class_id>=0 && d.class_id<(int)class_names.size()) ? 
                      class_names[d.class_id] : "Unknown";
        detections.push_back(std::move(d));
    }
    return detections;
}

};

// Display Thread
void display_thread_function(cv::VideoCapture& cap, Header* frame_hdr, cv::Mat& shm_frame,
Header* det_hdr, ShareDetection* det_arr,
Header* track_hdr, ShareTrack* track_arr,
sem_t* sem_frame, sem_t* sem_dets, sem_t* sem_tracks) {

text
uint32_t frame_counter = 0;
cv::Mat display_frame;

std::cout << "🎬 Display thread started" << std::endl;

while (!should_exit.load()) {
    auto start_time = std::chrono::high_resolution_clock::now();
    
    // Read new frame
    cv::Mat current_frame;
    cap >> current_frame;
    
    if (current_frame.empty()) {
        frame_hdr->finished = 1;
        should_exit.store(true);
        break;
    }
    
    // Copy frame to shared memory
    current_frame.copyTo(shm_frame);
    frame_hdr->frame_id = frame_counter++;
    current_frame_id.store(frame_hdr->frame_id);
    
    // Signal that new frame is ready
    sem_post(sem_frame);
    
    // Prepare display frame
    current_frame.copyTo(display_frame);
    
    // Try to get detections (non-blocking)
    if (sem_trywait(sem_dets) == 0) {
        // Draw detections (pink color)
        for (uint32_t i = 0; i < det_hdr->num_items && i < MAX_DETS; ++i) {
            const auto& det = det_arr[i];
            cv::Rect rect(static_cast<int>(det.x), static_cast<int>(det.y), 
                         static_cast<int>(det.w), static_cast<int>(det.h));
            cv::rectangle(display_frame, rect, cv::Scalar(180, 105, 255), 2);
            cv::putText(display_frame, 
                       cv::format("Det:%d %.2f", det.class_id, det.confidence),
                       cv::Point(rect.x, rect.y - 5),
                       cv::FONT_HERSHEY_SIMPLEX, 0.5, cv::Scalar(180, 105, 255), 1);
        }
    }
    
    // Try to get tracks (non-blocking)
    if (sem_trywait(sem_tracks) == 0) {
        std::cout << "------------ Displaying tracks for frame " << track_hdr->frame_id << " ---------" << std::endl;
        // Draw tracks (light blue color)
        for (uint32_t i = 0; i < track_hdr->num_items && i < MAX_TRACKS; ++i) {
            const auto& track = track_arr[i];
            cv::Rect rect(static_cast<int>(track.x), static_cast<int>(track.y), 
                         static_cast<int>(track.w), static_cast<int>(track.h));
            cv::rectangle(display_frame, rect, cv::Scalar(230, 216, 173), 3);
            cv::putText(display_frame, 
                       cv::format("ID:%d", track.track_id),
                       cv::Point(rect.x, rect.y - 5),
                       cv::FONT_HERSHEY_SIMPLEX, 0.6, cv::Scalar(230, 216, 173), 2);
                       
            std::cout << "+ Track " << i << " | X:" << track.x << " Y:" << track.y 
                     << " W:" << track.w << " H:" << track.h 
                     << " TRACK_ID:" << track.track_id 
                     << " CLASS_ID:" << track.class_id
                     << " CONF:" << track.confidence << std::endl;
        }
    }
    
    // Add frame info
    cv::putText(display_frame, 
               cv::format("Frame: %d", frame_counter),
               cv::Point(10, 30),
               cv::FONT_HERSHEY_SIMPLEX, 1.0, cv::Scalar(0, 255, 0), 2);
    
    // Display frame
    cv::imshow("Multi-threaded Detection & Tracking", display_frame);
    if (cv::waitKey(1) & 0xFF == 'q') {
        should_exit.store(true);
        break;
    }
    
    std::cout << "📺 Frame " << frame_counter << " displayed" << std::endl;
    
    // Maintain 33ms interval (30 FPS)
    auto end_time = std::chrono::high_resolution_clock::now();
    float total_ms = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time).count();
    std::cout << "frame to sharedmemory time : " << total_ms << std::endl;
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
    auto sleep_time = std::chrono::milliseconds(33) - elapsed;
    
    if (sleep_time > std::chrono::milliseconds(0)) {
        std::this_thread::sleep_for(sleep_time);
    }
}

cv::destroyAllWindows();
std::cout << "🎬 Display thread finished" << std::endl;

}

// Detection Thread
void detection_thread_function(YOLOv8Detector& detector,
Header* frame_hdr, cv::Mat& shm_frame,
Header* det_hdr, ShareDetection* det_arr,
sem_t* sem_frame, sem_t* sem_dets) {

text
double total_det_ms = 0.0;
int detection_count = 0;
uint32_t last_processed_frame = UINT32_MAX;

std::cout << "🔍 Detection thread started" << std::endl;

while (!should_exit.load()) {
    // Wait for new frame
    if (sem_wait(sem_frame) != 0) continue;
    
    if (should_exit.load()) break;
    
    // Check if we have a new frame to process
    uint32_t current_frame_to_process = frame_hdr->frame_id;
    if (current_frame_to_process == last_processed_frame) {
        continue;
    }
    
    // Get frame for detection
    cv::Mat frame_for_detection;
    shm_frame.copyTo(frame_for_detection);
    last_processed_frame = current_frame_to_process;
    
    std::cout << "🔍 Processing detection for frame: " << current_frame_to_process << std::endl;
    
    // Run detection
    double det_ms = 0.0;
    auto detections = detector.detect(frame_for_detection, det_ms);
    total_det_ms += det_ms;
    detection_count++;
    
    // Write results to shared memory
    det_hdr->frame_id = current_frame_to_process;
    det_hdr->num_items = std::min<uint32_t>(detections.size(), MAX_DETS);
    det_hdr->width = frame_hdr->width;
    det_hdr->height = frame_hdr->height;
    det_hdr->channels = frame_hdr->channels;
    det_hdr->stride_bytes = frame_hdr->stride_bytes;
    det_hdr->finished = 0;
    det_hdr->reserved = 0;
    
    for (uint32_t i = 0; i < det_hdr->num_items; ++i) {
        const auto& det = detections[i];
        det_arr[i].x = static_cast<float>(det.bbox.x);
        det_arr[i].y = static_cast<float>(det.bbox.y);
        det_arr[i].w = static_cast<float>(det.bbox.width);
        det_arr[i].h = static_cast<float>(det.bbox.height);
        det_arr[i].confidence = det.confidence;
        det_arr[i].class_id = det.class_id;
        
        std::cout << "ShareDetection " << i 
                  << " | class: " << det.class_id
                  << " | conf: " << det.confidence
                  << " | bbox: [x=" << det.bbox.x 
                  << ", y=" << det.bbox.y 
                  << ", w=" << det.bbox.width 
                  << ", h=" << det.bbox.height 
                  << "]\n";
    }
    
    // Signal detections are ready
    sem_post(sem_dets);
    
    std::cout << "✅ Detection completed: " << det_hdr->num_items 
              << " objects in " << det_ms << " ms" << std::endl;
}

if (detection_count > 0) {
    std::cout << "📊 Average detection time: " << (total_det_ms / detection_count) << " ms" << std::endl;
}
std::cout << "🔍 Detection thread finished" << std::endl;

}

int main() {
std::string model_path = "/home/rayfan/Documents/cpp_projects/test/yolov8n.onnx";
std::string class_file = "/home/rayfan/Documents/cpp_projects/test/coco.names";
std::string video_path = "/home/rayfan/Documents/cpp_projects/test/gettyimages-532142106-640_adpp.mp4";

text
try {
    // Initialize YOLO detector
    YOLOv8Detector detector(model_path, class_file, 0.30f, 0.4f);
    
    // Open video
    cv::VideoCapture cap(video_path);
    if (!cap.isOpened()) {
        std::cerr << "❌ Error: Could not open video: " << video_path << std::endl;
        return 1;
    }
    
    // Get video properties
    uint32_t W = (uint32_t)cap.get(cv::CAP_PROP_FRAME_WIDTH);
    uint32_t H = (uint32_t)cap.get(cv::CAP_PROP_FRAME_HEIGHT);
    uint32_t C = 3;
    uint32_t stride = W * C;
    
    std::cout << "📹 Video properties: " << W << "x" << H << " channels=" << C << std::endl;
    
    // ============= Setup Frame Shared Memory =============
    size_t frame_bytes = H * stride;
    size_t frame_shm_size = sizeof(Header) + frame_bytes;
    
    int fd_frame = shm_open(SHM_FRAME_NAME, O_CREAT | O_RDWR, 0666);
    if (fd_frame < 0) { perror("shm_open frame"); return 1; }
    if (ftruncate(fd_frame, frame_shm_size) != 0) { perror("ftruncate frame"); return 1; }
    
    void* base_frame = mmap(nullptr, frame_shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_frame, 0);
    if (base_frame == MAP_FAILED) { perror("mmap frame"); return 1; }
    close(fd_frame);
    
    Header* frame_hdr = reinterpret_cast<Header*>(base_frame);
    frame_hdr->width = W; frame_hdr->height = H; frame_hdr->channels = C;
    frame_hdr->stride_bytes = stride; frame_hdr->frame_id = 0; frame_hdr->finished = 0;
    frame_hdr->num_items = 0; frame_hdr->reserved = 0;
    
    uint8_t* frame_pixels = reinterpret_cast<uint8_t*>(base_frame) + sizeof(Header);
    cv::Mat shm_frame(H, W, CV_8UC3, frame_pixels, stride);
    
    // ============= Setup Detection Shared Memory =============
    size_t det_shm_size = sizeof(Header) + MAX_DETS * sizeof(ShareDetection);
    int fd_det = shm_open(SHM_DETS_NAME, O_CREAT | O_RDWR, 0666);
    if (fd_det < 0) { perror("shm_open detections"); return 1; }
    if (ftruncate(fd_det, det_shm_size) != 0) { perror("ftruncate detections"); return 1; }
    
    void* base_det = mmap(nullptr, det_shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_det, 0);
    if (base_det == MAP_FAILED) { perror("mmap detections"); return 1; }
    close(fd_det);
    
    Header* det_hdr = reinterpret_cast<Header*>(base_det);
    det_hdr->width = W; det_hdr->height = H; det_hdr->channels = C;
    det_hdr->stride_bytes = stride; det_hdr->finished = 0; det_hdr->num_items = 0;
    det_hdr->frame_id = 0; det_hdr->reserved = 0;
    ShareDetection* det_arr = reinterpret_cast<ShareDetection*>(det_hdr + 1);
    
    // ============= Setup Track Shared Memory =============
    size_t track_shm_size = sizeof(Header) + MAX_TRACKS * sizeof(ShareTrack);
    int fd_track = shm_open(SHM_TRACKS_NAME, O_CREAT | O_RDWR, 0666);
    if (fd_track < 0) { perror("shm_open tracks"); return 1; }
    if (ftruncate(fd_track, track_shm_size) != 0) { perror("ftruncate tracks"); return 1; }
    
    void* base_track = mmap(nullptr, track_shm_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd_track, 0);
    if (base_track == MAP_FAILED) { perror("mmap tracks"); return 1; }
    close(fd_track);
    
    Header* track_hdr = reinterpret_cast<Header*>(base_track);
    track_hdr->width = W; track_hdr->height = H; track_hdr->channels = C;
    track_hdr->stride_bytes = stride; track_hdr->finished = 0; track_hdr->num_items = 0;
    track_hdr->frame_id = 0; track_hdr->reserved = 0;
    ShareTrack* track_arr = reinterpret_cast<ShareTrack*>(track_hdr + 1);
    
    // ============= Setup Semaphores =============
    sem_unlink(SEM_FRAME_READY);  // Clean up if exists
    sem_unlink(SEM_DETS_READY);
    sem_unlink(SEM_TRACKS_READY);
    
    sem_t* sem_frame = sem_open(SEM_FRAME_READY, O_CREAT, 0666, 0);
    sem_t* sem_dets = sem_open(SEM_DETS_READY, O_CREAT, 0666, 0);
    sem_t* sem_tracks = sem_open(SEM_TRACKS_READY, O_CREAT, 0666, 0);
    
    if (sem_frame == SEM_FAILED || sem_dets == SEM_FAILED || sem_tracks == SEM_FAILED) {
        perror("sem_open failed");
        return 1;
    }
    
    std::cout << "🚀 Starting threads..." << std::endl;
    
    // ============= Start Threads =============
    std::thread display_thread(display_thread_function, 
                              std::ref(cap), frame_hdr, std::ref(shm_frame),
                              det_hdr, det_arr, track_hdr, track_arr,
                              sem_frame, sem_dets, sem_tracks);
    
    std::thread detection_thread(detection_thread_function,
                               std::ref(detector), frame_hdr, std::ref(shm_frame),
                               det_hdr, det_arr, sem_frame, sem_dets);
    
    // Wait for threads
    display_thread.join();
    detection_thread.join();
    
    std::cout << "🏁 All threads completed. Cleaning up..." << std::endl;
    
    // ============= Cleanup =============
    munmap(base_frame, frame_shm_size);
    munmap(base_det, det_shm_size);
    munmap(base_track, track_shm_size);
    
    sem_close(sem_frame);
    sem_close(sem_dets);
    sem_close(sem_tracks);
    
    shm_unlink(SHM_FRAME_NAME);
    shm_unlink(SHM_DETS_NAME);
    shm_unlink(SHM_TRACKS_NAME);
    
    sem_unlink(SEM_FRAME_READY);
    sem_unlink(SEM_DETS_READY);
    sem_unlink(SEM_TRACKS_READY);
    
} catch (const std::exception& e) {
    std::cerr << "❌ Exception: " << e.what() << std::endl;
    return -1;
}

return 0;

}

import mmap
import posix_ipc
import struct
import numpy as np
import cv2
import time
import os
import threading
from deep_sort_realtime.deepsort_tracker import DeepSort

Shared Memory Names

SHM_FRAME_NAME = "/shm_frames"
SHM_DETS_NAME = "/shm_detections"
SHM_TRACKS_NAME = "/shm_tracks"

Semaphore Names

SEM_FRAME_READY = "/sem_frame_ready"
SEM_DETS_READY = "/sem_dets_ready"
SEM_TRACKS_READY = "/sem_tracks_ready"

MAX_DETS = 512
MAX_TRACKS = 512

Header format: 8 uint32

HDR_FMT = "<8I"
HDR_SIZE = struct.calcsize(HDR_FMT)

ShareDetection format: 4 floats + float confidence + int class_id

DET_FMT = "<4f f i"
DET_SIZE = struct.calcsize(DET_FMT)

ShareTrack format: x,y,w,h (4 floats) + track_id + class_id (2 ints) + confidence (1 float) + reserved (1 int)

Must match C++ struct ShareTrack exactly

TRACK_FMT = "<4f 2i f i"
TRACK_SIZE = struct.calcsize(TRACK_FMT)

class SharedMemoryManager:
def init(self):
self.shm_frame = None
self.shm_dets = None
self.shm_tracks = None
self.mm_frame = None
self.mm_dets = None
self.mm_tracks = None
self.sem_frame = None
self.sem_dets = None
self.sem_tracks = None

text
def setup(self):
    """Setup shared memory and semaphores"""
    try:
        # Open shared memory for frames
        self.shm_frame = posix_ipc.SharedMemory(SHM_FRAME_NAME)
        self.mm_frame = mmap.mmap(self.shm_frame.fd, self.shm_frame.size,
                                  access=mmap.ACCESS_READ)
        self.shm_frame.close_fd()

        # Open shared memory for detections
        self.shm_dets = posix_ipc.SharedMemory(SHM_DETS_NAME)
        self.mm_dets = mmap.mmap(self.shm_dets.fd, self.shm_dets.size,
                                 access=mmap.ACCESS_READ)
        self.shm_dets.close_fd()

        # Open shared memory for tracks (write access)
        self.shm_tracks = posix_ipc.SharedMemory(SHM_TRACKS_NAME)
        self.mm_tracks = mmap.mmap(self.shm_tracks.fd, self.shm_tracks.size,
                                   access=mmap.ACCESS_WRITE)
        self.shm_tracks.close_fd()

        # Open semaphores
        self.sem_frame = posix_ipc.Semaphore(SEM_FRAME_READY)
        self.sem_dets = posix_ipc.Semaphore(SEM_DETS_READY)
        self.sem_tracks = posix_ipc.Semaphore(SEM_TRACKS_READY)

        print("✅ Shared memory and semaphores setup complete")
        return True

    except Exception as e:
        print(f"❌ Error setting up shared memory: {e}")
        return False

def cleanup(self):
    """Cleanup resources"""
    try:
        if self.mm_frame:
            self.mm_frame.close()
        if self.mm_dets:
            self.mm_dets.close()
        if self.mm_tracks:
            self.mm_tracks.close()

        if self.sem_frame:
            self.sem_frame.close()
        if self.sem_dets:
            self.sem_dets.close()
        if self.sem_tracks:
            self.sem_tracks.close()

        print("✅ Resources cleaned up")
    except Exception as e:
        print(f"⚠️ Error during cleanup: {e}")

def read_header(mm):
"""Read header from memory mapped file"""
hdr_bytes = mm[:HDR_SIZE]
return struct.unpack(HDR_FMT, hdr_bytes)

def write_header(mm, width, height, channels, stride_bytes, frame_id, num_items, finished=0, reserved=0):
"""Write header to memory mapped file"""
header_data = struct.pack(HDR_FMT, width, height, channels, stride_bytes,
frame_id, num_items, finished, reserved)
mm[:HDR_SIZE] = header_data

def read_frame(mm_frame):
"""Read frame from shared memory"""
try:
width, height, channels, stride_bytes, frame_id, _, _, finished = read_header(mm_frame)

text
    if finished == 1:
        return None, frame_id, True

    # Read pixel data
    pixel_bytes = height * stride_bytes
    pixels = memoryview(mm_frame)[HDR_SIZE: HDR_SIZE + pixel_bytes]
    frame = np.ndarray((height, width, channels), dtype=np.uint8,
                       buffer=pixels, strides=(stride_bytes, channels, 1))

    return np.array(frame, copy=True), frame_id, False

except Exception as e:
    print(f"❌ Error reading frame: {e}")
    return None, -1, True

def read_detections(mm_dets):
"""Read detections from shared memory"""
try:
width, height, channels, stride_bytes, frame_id, num_dets, finished, _ = read_header(mm_dets)

text
    detections = []
    for i in range(min(num_dets, MAX_DETS)):
        off = HDR_SIZE + i * DET_SIZE
        d_bytes = mm_dets[off: off + DET_SIZE]
        if len(d_bytes) != DET_SIZE:
            break
        x, y, w, h, conf, class_id = struct.unpack(DET_FMT, d_bytes)
        detections.append((x, y, w, h, conf, class_id))

    return detections, frame_id

except Exception as e:
    print(f"❌ Error reading detections: {e}")
    return [], -1

def write_tracks(mm_tracks, tracks_data, frame_id, width, height, channels=3):
"""Write tracks to shared memory"""
try:
stride_bytes = width * channels
num_tracks = min(len(tracks_data), MAX_TRACKS)

text
    # Write header with correct frame_id
    write_header(mm_tracks, width, height, channels, stride_bytes,
                 frame_id, num_tracks, finished=0, reserved=0)

    # Write track data
    for i, track_data in enumerate(tracks_data[:num_tracks]):
        x, y, w, h, track_id, class_id, confidence = track_data

        off = HDR_SIZE + i * TRACK_SIZE
        # Pack according to C++ struct: x,y,w,h (4f) + track_id,class_id (2i) + confidence (f) + reserved (i)
        track_bytes = struct.pack(TRACK_FMT,
                                  float(x), float(y), float(w), float(h),
                                  int(track_id), int(class_id),
                                  float(confidence), int(0))  # reserved
        mm_tracks[off: off + TRACK_SIZE] = track_bytes

        print(
            f"write tracks : {i} ||| {{ [{x:.1f}, {y:.1f}, {w:.1f}, {h:.1f}] track_id={track_id} class_id={class_id} conf={confidence:.3f} }}")
    print("--------------------")

    return True

except Exception as e:
    print(f"❌ Error writing tracks: {e}")
    return False

def main():
total_track_time_ms = 0
track_count = 0
print("🚀 Python Tracker Starting...")

text
# Setup shared memory manager
shm_manager = SharedMemoryManager()
if not shm_manager.setup():
    return 1

# Initialize DeepSORT tracker
tracker = DeepSort(
    max_age=40,
    n_init=3,
    nn_budget=300,
    embedder="torchreid",
    half=False,
    bgr=True,
    max_cosine_distance=0.3,
    polygon=False
)
last_processed_frame_id = -1

try:
    while True:
        # Wait for new detections
        try:
            shm_manager.sem_dets.acquire(timeout=1.0)
        except posix_ipc.BusyError:
            continue  # Timeout, try again
        except Exception as e:
            print(f"⚠️ Semaphore error: {e}")
            break

        # Read frame
        frame, frame_id, finished = read_frame(shm_manager.mm_frame)
        if finished or frame is None:
            print("🏁 Finished signal received, exiting tracking thread")
            break

        # Read detections
        detections, det_frame_id = read_detections(shm_manager.mm_dets)

        if det_frame_id != frame_id:
            print(f"⚠️ Frame ID mismatch: frame={frame_id}, detections={det_frame_id}")
            continue

        # Skip if we already processed this frame
        if frame_id <= last_processed_frame_id:
            print(f"⏭️ Skipping already processed frame {frame_id}")
            continue

        print(f"🎯 Processing tracking for frame {frame_id} with {len(detections)} detections")

        # Run tracking
        start_time = time.time()

        # Convert detections to tracker format (x,y,w,h format for DeepSORT)
        detections_for_tracker = []
        for det in detections:
            x, y, w, h, conf, class_id = det
            # DeepSORT expects [[x, y, w, h], confidence, class_id]
            detections_for_tracker.append([[x, y, w, h], conf, class_id])

        # Update tracks
        tracks = tracker.update_tracks(detections_for_tracker, frame=frame)

        # Convert tracks to output format
        tracks_data = []
        confirmed_count = 0
        for track in tracks:
            if track.is_confirmed():
                confirmed_count += 1
                x1, y1, x2, y2 = track.to_ltrb()  # Get left-top-right-bottom
                w = x2 - x1
                h = y2 - y1
                track_id = track.track_id

                # Get class_id and confidence from detection
                # class_id = getattr(track, 'det_class', 0) if hasattr(track, 'det_class') else 0
                # confidence = getattr(track, 'det_conf', 0.0) if hasattr(track, 'det_conf') else 0.0

                confidence = float(getattr(track, 'det_conf', 0.0) or 0.0)
                class_id = int(getattr(track, 'det_class', 0) or 0)

                tracks_data.append((x1, y1, w, h, track_id, class_id, confidence))
                print(f"track : {confirmed_count} {{ [{x1:.1f}, {y1:.1f}, {w:.1f}, {h:.1f}] track_id={track_id} }}")

        end_time = time.time()
        track_time_ms = (end_time - start_time) * 1000
        total_track_time_ms += track_time_ms
        track_count += 1

        # Write tracks to shared memory
        height, width = frame.shape[:2]
        success = write_tracks(shm_manager.mm_tracks, tracks_data, frame_id, width, height, 3)

        if success:
            # Signal that tracks are ready
            shm_manager.sem_tracks.release()
            print(f"✅ Tracking completed: {len(tracks_data)} tracks in {track_time_ms:.2f} ms")
        else:
            print("❌ Failed to write tracks")

        last_processed_frame_id = frame_id

except KeyboardInterrupt:
    print("🛑 Received keyboard interrupt")
except Exception as e:
    print(f"❌ Error in main: {e}")
finally:
    # Print statistics
    if track_count > 0:
        avg_time = total_track_time_ms / track_count
        print(f"📊 Average tracking time: {avg_time:.2f} ms")

    # Cleanup
    shm_manager.cleanup()
    print("🏁 Python tracker finished")

return 0

if name == "main":
exit(main())