C wrappers

AlexeyAB

2018-03-16 e947bf29af0540eda50fd298bb5492c2d8fa7680

C wrappers

 src/yolo_console_dll.cpp

@@ -361,7 +361,8 @@
                            auto current_image = det_image;
                            consumed = true;
                            while (current_image.use_count() > 0) {
                                auto result = detector.detect_resized(*current_image, frame_size, thresh, false);   // true
                                auto result = detector.detect_resized(*current_image, frame_size.width, frame_size.height, 
                                    thresh, false); // true
                                ++fps_det_counter;
                                std::unique_lock<std::mutex> lock(mtx);
                                thread_result_vec = result;

 src/yolo_v2_class.cpp

@@ -22,6 +22,13 @@

#define FRAMES 3

void check_cuda(cudaError_t status) {
    if (status != cudaSuccess) {
        const char *s = cudaGetErrorString(status);
        printf("CUDA Error Prev: %s\n", s);
    }
}

struct detector_gpu_t{
    float **probs;
    box *boxes;
@@ -38,14 +45,15 @@
    wait_stream = 0;
    int old_gpu_index;
#ifdef GPU
    cudaGetDevice(&old_gpu_index);
    check_cuda( cudaGetDevice(&old_gpu_index) );
#endif

    detector_gpu_ptr = std::make_shared<detector_gpu_t>();
    detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &detector_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());

#ifdef GPU
    cudaSetDevice(gpu_id);
    check_cuda( cudaSetDevice(gpu_id) );
    printf(" Used GPU %d \n", gpu_id);
#endif
    network &net = detector_gpu.net;
    net.gpu_index = gpu_id;
@@ -76,14 +84,14 @@
    for (j = 0; j < l.classes; ++j) detector_gpu.track_id[j] = 1;

#ifdef GPU
    cudaSetDevice(old_gpu_index);
    check_cuda( cudaSetDevice(old_gpu_index) );
#endif
}


YOLODLL_API Detector::~Detector() 
{
    detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &detector_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    layer l = detector_gpu.net.layers[detector_gpu.net.n - 1];

    free(detector_gpu.track_id);
@@ -110,11 +118,11 @@
}

YOLODLL_API int Detector::get_net_width() const {
    detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &detector_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    return detector_gpu.net.w;
}
YOLODLL_API int Detector::get_net_height() const {
    detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &detector_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    return detector_gpu.net.h;
}

@@ -172,7 +180,7 @@

YOLODLL_API std::vector<bbox_t> Detector::detect(image_t img, float thresh, bool use_mean)
{
    detector_gpu_t &detector_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &detector_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    network &net = detector_gpu.net;
    int old_gpu_index;
#ifdef GPU
@@ -254,7 +262,7 @@
YOLODLL_API std::vector<bbox_t> Detector::tracking_id(std::vector<bbox_t> cur_bbox_vec, bool const change_history, 
    int const frames_story, int const max_dist)
{
    detector_gpu_t &det_gpu = *reinterpret_cast<detector_gpu_t *>(detector_gpu_ptr.get());
    detector_gpu_t &det_gpu = *static_cast<detector_gpu_t *>(detector_gpu_ptr.get());

    bool prev_track_id_present = false;
    for (auto &i : prev_bbox_vec_deque)

 src/yolo_v2_class.hpp

@@ -1,15 +1,4 @@
#pragma once
#include <memory>
#include <vector>
#include <deque>
#include <algorithm>

#ifdef OPENCV
#include <opencv2/opencv.hpp>           // C++
#include "opencv2/highgui/highgui_c.h"  // C
#include "opencv2/imgproc/imgproc_c.h"  // C
#endif  // OPENCV

#ifdef YOLODLL_EXPORTS
#if defined(_MSC_VER)
#define YOLODLL_API __declspec(dllexport) 
@@ -39,6 +28,17 @@
    float *data;                // pointer to the image data
};

#ifdef __cplusplus
#include <memory>
#include <vector>
#include <deque>
#include <algorithm>

#ifdef OPENCV
#include <opencv2/opencv.hpp>           // C++
#include "opencv2/highgui/highgui_c.h"  // C
#include "opencv2/imgproc/imgproc_c.h"  // C
#endif  // OPENCV

class Detector {
    std::shared_ptr<void> detector_gpu_ptr;
@@ -61,23 +61,23 @@
    YOLODLL_API std::vector<bbox_t> tracking_id(std::vector<bbox_t> cur_bbox_vec, bool const change_history = true, 
                                                int const frames_story = 10, int const max_dist = 150);

    std::vector<bbox_t> detect_resized(image_t img, int init_w, int init_h, float thresh = 0.2, bool use_mean = false)
    {
        if (img.data == NULL)
            throw std::runtime_error("Image is empty");
        auto detection_boxes = detect(img, thresh, use_mean);
        float wk = (float)init_w / img.w, hk = (float)init_h / img.h;
        for (auto &i : detection_boxes) i.x *= wk, i.w *= wk, i.y *= hk, i.h *= hk;
        return detection_boxes;
    }

#ifdef OPENCV
    std::vector<bbox_t> detect(cv::Mat mat, float thresh = 0.2, bool use_mean = false)
    {
        if(mat.data == NULL)
            throw std::runtime_error("Image is empty");
        auto image_ptr = mat_to_image_resize(mat);
        return detect_resized(*image_ptr, mat.size(), thresh, use_mean);
    }

    std::vector<bbox_t> detect_resized(image_t img, cv::Size init_size, float thresh = 0.2, bool use_mean = false)
    {
        if (img.data == NULL)
            throw std::runtime_error("Image is empty");
        auto detection_boxes = detect(img, thresh, use_mean);
        float wk = (float)init_size.width / img.w, hk = (float)init_size.height / img.h;
        for (auto &i : detection_boxes) i.x *= wk, i.w *= wk, i.y *= hk, i.h *= hk;
        return detection_boxes;
        return detect_resized(*image_ptr, mat.cols, mat.rows, thresh, use_mean);
    }

    std::shared_ptr<image_t> mat_to_image_resize(cv::Mat mat) const
@@ -588,3 +588,54 @@
    }
};
#endif  // OPENCV

//extern "C" {
#endif  // __cplusplus

/*
    // C - wrappers
    YOLODLL_API void create_detector(char const* cfg_filename, char const* weight_filename, int gpu_id);
    YOLODLL_API void delete_detector();
    YOLODLL_API bbox_t* detect_custom(image_t img, float thresh, bool use_mean, int *result_size);
    YOLODLL_API bbox_t* detect_resized(image_t img, int init_w, int init_h, float thresh, bool use_mean, int *result_size);
    YOLODLL_API bbox_t* detect(image_t img, int *result_size);
    YOLODLL_API image_t load_img(char *image_filename);
    YOLODLL_API void free_img(image_t m);

#ifdef __cplusplus
}   // extern "C"

static std::shared_ptr<void> c_detector_ptr;
static std::vector<bbox_t> c_result_vec;

void create_detector(char const* cfg_filename, char const* weight_filename, int gpu_id) {
    c_detector_ptr = std::make_shared<YOLODLL_API Detector>(cfg_filename, weight_filename, gpu_id);
}

void delete_detector() { c_detector_ptr.reset(); }

bbox_t* detect_custom(image_t img, float thresh, bool use_mean, int *result_size) {
    c_result_vec = static_cast<Detector*>(c_detector_ptr.get())->detect(img, thresh, use_mean);
    *result_size = c_result_vec.size();
    return c_result_vec.data();
}

bbox_t* detect_resized(image_t img, int init_w, int init_h, float thresh, bool use_mean, int *result_size) {
    c_result_vec = static_cast<Detector*>(c_detector_ptr.get())->detect_resized(img, init_w, init_h, thresh, use_mean);
    *result_size = c_result_vec.size();
    return c_result_vec.data();
}

bbox_t* detect(image_t img, int *result_size) {
    return detect_custom(img, 0.24, true, result_size);
}

image_t load_img(char *image_filename) {
    return static_cast<Detector*>(c_detector_ptr.get())->load_image(image_filename);
}
void free_img(image_t m) {
    static_cast<Detector*>(c_detector_ptr.get())->free_image(m);
}

#endif  // __cplusplus
*/