C wrappers

src/yolo_console_dll.cpp

@@ -361,7 +361,8 @@ int main(int argc, char *argv[])
 							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 @@ extern "C" {
 
 #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 @@ YOLODLL_API Detector::Detector(std::string cfg_filename, std::string weight_file
 	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 @@ YOLODLL_API Detector::Detector(std::string cfg_filename, std::string weight_file
 	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 Detector::~Detector()
 }
 
 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 void Detector::free_image(image_t m)
 
 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::detect(image_t img, float thresh, bool
 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 @@ struct image_t {
 	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,25 +61,25 @@ public:
 	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);
 
-#ifdef OPENCV
+	std::vector<bbox_t> detect_resized(image_t img, int init_w, int init_h, float thresh = 0.2, bool use_mean = false)
-	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;
+		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.cols, mat.rows, thresh, use_mean);
+	}
+
 	std::shared_ptr<image_t> mat_to_image_resize(cv::Mat mat) const
 	{
 		if (mat.data == NULL) return std::shared_ptr<image_t>(NULL);
@@ -588,3 +588,54 @@ public:
 	}
 };
 #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
+*/