forked from xuos/xiuos
12 changed files with 3883 additions and 11 deletions
@ -0,0 +1,7 @@ |
|||
config HELMET_DETECT |
|||
bool "enable apps/helmet detect" |
|||
depends on BOARD_K210_EVB |
|||
depends on DRV_USING_OV2640 |
|||
depends on USING_KPU_POSTPROCESSING |
|||
depends on USING_YOLOV2 |
|||
default n |
|||
@ -0,0 +1,9 @@ |
|||
from building import * |
|||
|
|||
cwd = GetCurrentDir() |
|||
src = Glob('*.c') + Glob('*.cpp') |
|||
CPPPATH = [cwd] |
|||
|
|||
group = DefineGroup('Applications', src, depend = ['HELMET_DETECT'], LOCAL_CPPPATH = CPPPATH) |
|||
|
|||
Return('group') |
|||
File diff suppressed because it is too large
@ -0,0 +1,293 @@ |
|||
/*
|
|||
Copyright (c) 2009-2017 Dave Gamble and cJSON contributors |
|||
|
|||
Permission is hereby granted, free of charge, to any person obtaining a copy |
|||
of this software and associated documentation files (the "Software"), to deal |
|||
in the Software without restriction, including without limitation the rights |
|||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
|||
copies of the Software, and to permit persons to whom the Software is |
|||
furnished to do so, subject to the following conditions: |
|||
|
|||
The above copyright notice and this permission notice shall be included in |
|||
all copies or substantial portions of the Software. |
|||
|
|||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
|||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
|||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
|||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN |
|||
THE SOFTWARE. |
|||
*/ |
|||
|
|||
#ifndef cJSON__h |
|||
#define cJSON__h |
|||
|
|||
#ifdef __cplusplus |
|||
extern "C" |
|||
{ |
|||
#endif |
|||
|
|||
#if !defined(__WINDOWS__) && (defined(WIN32) || defined(WIN64) || defined(_MSC_VER) || defined(_WIN32)) |
|||
#define __WINDOWS__ |
|||
#endif |
|||
|
|||
#ifdef __WINDOWS__ |
|||
|
|||
/* When compiling for windows, we specify a specific calling convention to avoid issues where we are being called from a project with a different default calling convention. For windows you have 3 define options:
|
|||
|
|||
CJSON_HIDE_SYMBOLS - Define this in the case where you don't want to ever dllexport symbols |
|||
CJSON_EXPORT_SYMBOLS - Define this on library build when you want to dllexport symbols (default) |
|||
CJSON_IMPORT_SYMBOLS - Define this if you want to dllimport symbol |
|||
|
|||
For *nix builds that support visibility attribute, you can define similar behavior by |
|||
|
|||
setting default visibility to hidden by adding |
|||
-fvisibility=hidden (for gcc) |
|||
or |
|||
-xldscope=hidden (for sun cc) |
|||
to CFLAGS |
|||
|
|||
then using the CJSON_API_VISIBILITY flag to "export" the same symbols the way CJSON_EXPORT_SYMBOLS does |
|||
|
|||
*/ |
|||
|
|||
#define CJSON_CDECL __cdecl |
|||
#define CJSON_STDCALL __stdcall |
|||
|
|||
/* export symbols by default, this is necessary for copy pasting the C and header file */ |
|||
#if !defined(CJSON_HIDE_SYMBOLS) && !defined(CJSON_IMPORT_SYMBOLS) && !defined(CJSON_EXPORT_SYMBOLS) |
|||
#define CJSON_EXPORT_SYMBOLS |
|||
#endif |
|||
|
|||
#if defined(CJSON_HIDE_SYMBOLS) |
|||
#define CJSON_PUBLIC(type) type CJSON_STDCALL |
|||
#elif defined(CJSON_EXPORT_SYMBOLS) |
|||
#define CJSON_PUBLIC(type) __declspec(dllexport) type CJSON_STDCALL |
|||
#elif defined(CJSON_IMPORT_SYMBOLS) |
|||
#define CJSON_PUBLIC(type) __declspec(dllimport) type CJSON_STDCALL |
|||
#endif |
|||
#else /* !__WINDOWS__ */ |
|||
#define CJSON_CDECL |
|||
#define CJSON_STDCALL |
|||
|
|||
#if (defined(__GNUC__) || defined(__SUNPRO_CC) || defined (__SUNPRO_C)) && defined(CJSON_API_VISIBILITY) |
|||
#define CJSON_PUBLIC(type) __attribute__((visibility("default"))) type |
|||
#else |
|||
#define CJSON_PUBLIC(type) type |
|||
#endif |
|||
#endif |
|||
|
|||
/* project version */ |
|||
#define CJSON_VERSION_MAJOR 1 |
|||
#define CJSON_VERSION_MINOR 7 |
|||
#define CJSON_VERSION_PATCH 14 |
|||
|
|||
#include <stddef.h> |
|||
|
|||
/* cJSON Types: */ |
|||
#define cJSON_Invalid (0) |
|||
#define cJSON_False (1 << 0) |
|||
#define cJSON_True (1 << 1) |
|||
#define cJSON_NULL (1 << 2) |
|||
#define cJSON_Number (1 << 3) |
|||
#define cJSON_String (1 << 4) |
|||
#define cJSON_Array (1 << 5) |
|||
#define cJSON_Object (1 << 6) |
|||
#define cJSON_Raw (1 << 7) /* raw json */ |
|||
|
|||
#define cJSON_IsReference 256 |
|||
#define cJSON_StringIsConst 512 |
|||
|
|||
/* The cJSON structure: */ |
|||
typedef struct cJSON |
|||
{ |
|||
/* next/prev allow you to walk array/object chains. Alternatively, use GetArraySize/GetArrayItem/GetObjectItem */ |
|||
struct cJSON *next; |
|||
struct cJSON *prev; |
|||
/* An array or object item will have a child pointer pointing to a chain of the items in the array/object. */ |
|||
struct cJSON *child; |
|||
|
|||
/* The type of the item, as above. */ |
|||
int type; |
|||
|
|||
/* The item's string, if type==cJSON_String and type == cJSON_Raw */ |
|||
char *valuestring; |
|||
/* writing to valueint is DEPRECATED, use cJSON_SetNumberValue instead */ |
|||
int valueint; |
|||
/* The item's number, if type==cJSON_Number */ |
|||
double valuedouble; |
|||
|
|||
/* The item's name string, if this item is the child of, or is in the list of subitems of an object. */ |
|||
char *string; |
|||
} cJSON; |
|||
|
|||
typedef struct cJSON_Hooks |
|||
{ |
|||
/* malloc/free are CDECL on Windows regardless of the default calling convention of the compiler, so ensure the hooks allow passing those functions directly. */ |
|||
void *(CJSON_CDECL *malloc_fn)(size_t sz); |
|||
void (CJSON_CDECL *free_fn)(void *ptr); |
|||
} cJSON_Hooks; |
|||
|
|||
typedef int cJSON_bool; |
|||
|
|||
/* Limits how deeply nested arrays/objects can be before cJSON rejects to parse them.
|
|||
* This is to prevent stack overflows. */ |
|||
#ifndef CJSON_NESTING_LIMIT |
|||
#define CJSON_NESTING_LIMIT 1000 |
|||
#endif |
|||
|
|||
/* returns the version of cJSON as a string */ |
|||
CJSON_PUBLIC(const char*) cJSON_Version(void); |
|||
|
|||
/* Supply malloc, realloc and free functions to cJSON */ |
|||
CJSON_PUBLIC(void) cJSON_InitHooks(cJSON_Hooks* hooks); |
|||
|
|||
/* Memory Management: the caller is always responsible to free the results from all variants of cJSON_Parse (with cJSON_Delete) and cJSON_Print (with stdlib free, cJSON_Hooks.free_fn, or cJSON_free as appropriate). The exception is cJSON_PrintPreallocated, where the caller has full responsibility of the buffer. */ |
|||
/* Supply a block of JSON, and this returns a cJSON object you can interrogate. */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_Parse(const char *value); |
|||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithLength(const char *value, size_t buffer_length); |
|||
/* ParseWithOpts allows you to require (and check) that the JSON is null terminated, and to retrieve the pointer to the final byte parsed. */ |
|||
/* If you supply a ptr in return_parse_end and parsing fails, then return_parse_end will contain a pointer to the error so will match cJSON_GetErrorPtr(). */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithOpts(const char *value, const char **return_parse_end, cJSON_bool require_null_terminated); |
|||
CJSON_PUBLIC(cJSON *) cJSON_ParseWithLengthOpts(const char *value, size_t buffer_length, const char **return_parse_end, cJSON_bool require_null_terminated); |
|||
|
|||
/* Render a cJSON entity to text for transfer/storage. */ |
|||
CJSON_PUBLIC(char *) cJSON_Print(const cJSON *item); |
|||
/* Render a cJSON entity to text for transfer/storage without any formatting. */ |
|||
CJSON_PUBLIC(char *) cJSON_PrintUnformatted(const cJSON *item); |
|||
/* Render a cJSON entity to text using a buffered strategy. prebuffer is a guess at the final size. guessing well reduces reallocation. fmt=0 gives unformatted, =1 gives formatted */ |
|||
CJSON_PUBLIC(char *) cJSON_PrintBuffered(const cJSON *item, int prebuffer, cJSON_bool fmt); |
|||
/* Render a cJSON entity to text using a buffer already allocated in memory with given length. Returns 1 on success and 0 on failure. */ |
|||
/* NOTE: cJSON is not always 100% accurate in estimating how much memory it will use, so to be safe allocate 5 bytes more than you actually need */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_PrintPreallocated(cJSON *item, char *buffer, const int length, const cJSON_bool format); |
|||
/* Delete a cJSON entity and all subentities. */ |
|||
CJSON_PUBLIC(void) cJSON_Delete(cJSON *item); |
|||
|
|||
/* Returns the number of items in an array (or object). */ |
|||
CJSON_PUBLIC(int) cJSON_GetArraySize(const cJSON *array); |
|||
/* Retrieve item number "index" from array "array". Returns NULL if unsuccessful. */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_GetArrayItem(const cJSON *array, int index); |
|||
/* Get item "string" from object. Case insensitive. */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItem(const cJSON * const object, const char * const string); |
|||
CJSON_PUBLIC(cJSON *) cJSON_GetObjectItemCaseSensitive(const cJSON * const object, const char * const string); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_HasObjectItem(const cJSON *object, const char *string); |
|||
/* For analysing failed parses. This returns a pointer to the parse error. You'll probably need to look a few chars back to make sense of it. Defined when cJSON_Parse() returns 0. 0 when cJSON_Parse() succeeds. */ |
|||
CJSON_PUBLIC(const char *) cJSON_GetErrorPtr(void); |
|||
|
|||
/* Check item type and return its value */ |
|||
CJSON_PUBLIC(char *) cJSON_GetStringValue(const cJSON * const item); |
|||
CJSON_PUBLIC(double) cJSON_GetNumberValue(const cJSON * const item); |
|||
|
|||
/* These functions check the type of an item */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsInvalid(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsFalse(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsTrue(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsBool(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsNull(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsNumber(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsString(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsArray(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsObject(const cJSON * const item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_IsRaw(const cJSON * const item); |
|||
|
|||
/* These calls create a cJSON item of the appropriate type. */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateNull(void); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateTrue(void); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateFalse(void); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateBool(cJSON_bool boolean); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateNumber(double num); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateString(const char *string); |
|||
/* raw json */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateRaw(const char *raw); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateArray(void); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateObject(void); |
|||
|
|||
/* Create a string where valuestring references a string so
|
|||
* it will not be freed by cJSON_Delete */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateStringReference(const char *string); |
|||
/* Create an object/array that only references it's elements so
|
|||
* they will not be freed by cJSON_Delete */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateObjectReference(const cJSON *child); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateArrayReference(const cJSON *child); |
|||
|
|||
/* These utilities create an Array of count items.
|
|||
* The parameter count cannot be greater than the number of elements in the number array, otherwise array access will be out of bounds.*/ |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateIntArray(const int *numbers, int count); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateFloatArray(const float *numbers, int count); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateDoubleArray(const double *numbers, int count); |
|||
CJSON_PUBLIC(cJSON *) cJSON_CreateStringArray(const char *const *strings, int count); |
|||
|
|||
/* Append item to the specified array/object. */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToArray(cJSON *array, cJSON *item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObject(cJSON *object, const char *string, cJSON *item); |
|||
/* Use this when string is definitely const (i.e. a literal, or as good as), and will definitely survive the cJSON object.
|
|||
* WARNING: When this function was used, make sure to always check that (item->type & cJSON_StringIsConst) is zero before |
|||
* writing to `item->string` */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemToObjectCS(cJSON *object, const char *string, cJSON *item); |
|||
/* Append reference to item to the specified array/object. Use this when you want to add an existing cJSON to a new cJSON, but don't want to corrupt your existing cJSON. */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToArray(cJSON *array, cJSON *item); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_AddItemReferenceToObject(cJSON *object, const char *string, cJSON *item); |
|||
|
|||
/* Remove/Detach items from Arrays/Objects. */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemViaPointer(cJSON *parent, cJSON * const item); |
|||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromArray(cJSON *array, int which); |
|||
CJSON_PUBLIC(void) cJSON_DeleteItemFromArray(cJSON *array, int which); |
|||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObject(cJSON *object, const char *string); |
|||
CJSON_PUBLIC(cJSON *) cJSON_DetachItemFromObjectCaseSensitive(cJSON *object, const char *string); |
|||
CJSON_PUBLIC(void) cJSON_DeleteItemFromObject(cJSON *object, const char *string); |
|||
CJSON_PUBLIC(void) cJSON_DeleteItemFromObjectCaseSensitive(cJSON *object, const char *string); |
|||
|
|||
/* Update array items. */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_InsertItemInArray(cJSON *array, int which, cJSON *newitem); /* Shifts pre-existing items to the right. */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemViaPointer(cJSON * const parent, cJSON * const item, cJSON * replacement); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInArray(cJSON *array, int which, cJSON *newitem); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObject(cJSON *object,const char *string,cJSON *newitem); |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_ReplaceItemInObjectCaseSensitive(cJSON *object,const char *string,cJSON *newitem); |
|||
|
|||
/* Duplicate a cJSON item */ |
|||
CJSON_PUBLIC(cJSON *) cJSON_Duplicate(const cJSON *item, cJSON_bool recurse); |
|||
/* Duplicate will create a new, identical cJSON item to the one you pass, in new memory that will
|
|||
* need to be released. With recurse!=0, it will duplicate any children connected to the item. |
|||
* The item->next and ->prev pointers are always zero on return from Duplicate. */ |
|||
/* Recursively compare two cJSON items for equality. If either a or b is NULL or invalid, they will be considered unequal.
|
|||
* case_sensitive determines if object keys are treated case sensitive (1) or case insensitive (0) */ |
|||
CJSON_PUBLIC(cJSON_bool) cJSON_Compare(const cJSON * const a, const cJSON * const b, const cJSON_bool case_sensitive); |
|||
|
|||
/* Minify a strings, remove blank characters(such as ' ', '\t', '\r', '\n') from strings.
|
|||
* The input pointer json cannot point to a read-only address area, such as a string constant, |
|||
* but should point to a readable and writable adress area. */ |
|||
CJSON_PUBLIC(void) cJSON_Minify(char *json); |
|||
|
|||
/* Helper functions for creating and adding items to an object at the same time.
|
|||
* They return the added item or NULL on failure. */ |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddNullToObject(cJSON * const object, const char * const name); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddTrueToObject(cJSON * const object, const char * const name); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddFalseToObject(cJSON * const object, const char * const name); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddBoolToObject(cJSON * const object, const char * const name, const cJSON_bool boolean); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddNumberToObject(cJSON * const object, const char * const name, const double number); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddStringToObject(cJSON * const object, const char * const name, const char * const string); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddRawToObject(cJSON * const object, const char * const name, const char * const raw); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddObjectToObject(cJSON * const object, const char * const name); |
|||
CJSON_PUBLIC(cJSON*) cJSON_AddArrayToObject(cJSON * const object, const char * const name); |
|||
|
|||
/* When assigning an integer value, it needs to be propagated to valuedouble too. */ |
|||
#define cJSON_SetIntValue(object, number) ((object) ? (object)->valueint = (object)->valuedouble = (number) : (number)) |
|||
/* helper for the cJSON_SetNumberValue macro */ |
|||
CJSON_PUBLIC(double) cJSON_SetNumberHelper(cJSON *object, double number); |
|||
#define cJSON_SetNumberValue(object, number) ((object != NULL) ? cJSON_SetNumberHelper(object, (double)number) : (number)) |
|||
/* Change the valuestring of a cJSON_String object, only takes effect when type of object is cJSON_String */ |
|||
CJSON_PUBLIC(char*) cJSON_SetValuestring(cJSON *object, const char *valuestring); |
|||
|
|||
/* Macro for iterating over an array or object */ |
|||
#define cJSON_ArrayForEach(element, array) for(element = (array != NULL) ? (array)->child : NULL; element != NULL; element = element->next) |
|||
|
|||
/* malloc/free objects using the malloc/free functions that have been set with cJSON_InitHooks */ |
|||
CJSON_PUBLIC(void *) cJSON_malloc(size_t size); |
|||
CJSON_PUBLIC(void) cJSON_free(void *object); |
|||
|
|||
#ifdef __cplusplus |
|||
} |
|||
#endif |
|||
|
|||
#endif |
|||
@ -0,0 +1,38 @@ |
|||
{ |
|||
"net_input_size": [ |
|||
256, |
|||
256 |
|||
], |
|||
"net_output_shape": [ |
|||
8, |
|||
8, |
|||
35 |
|||
], |
|||
"sensor_output_size": [ |
|||
256, |
|||
256 |
|||
], |
|||
"anchors": [ |
|||
1.0432, |
|||
1.0920, |
|||
0.8391, |
|||
2.1250, |
|||
1.1085, |
|||
2.7463, |
|||
1.3783, |
|||
3.6706, |
|||
2.0491, |
|||
4.6711 |
|||
], |
|||
"kmodel_path": "/kmodel/helmet.kmodel", |
|||
"kmodel_size": 2714044, |
|||
"obj_thresh": [ |
|||
0.85, |
|||
0.6 |
|||
], |
|||
"labels": [ |
|||
"helmet", |
|||
"head" |
|||
], |
|||
"nms_thresh": 0.3 |
|||
} |
|||
@ -0,0 +1,379 @@ |
|||
#include <transform.h> |
|||
|
|||
#include "cJSON.h" |
|||
#include "region_layer.h" |
|||
#define ANCHOR_NUM 5 |
|||
#define STACK_SIZE (128 * 1024) |
|||
#define JSON_FILE_PATH "/kmodel/helmet.json" |
|||
#define JSON_BUFFER_SIZE (4 * 1024) |
|||
|
|||
// params from json
|
|||
float anchor[ANCHOR_NUM * 2] = {}; |
|||
int net_output_shape[3] = {}; |
|||
int net_input_size[2] = {}; |
|||
int sensor_output_size[2] = {}; |
|||
char kmodel_path[127] = ""; |
|||
int kmodel_size = 0; |
|||
float obj_thresh[20] = {}; |
|||
float nms_thresh = 0.0; |
|||
char labels[20][32] = {}; |
|||
int class_num = 0; |
|||
|
|||
#define THREAD_PRIORITY_HELMET_D (11) |
|||
static pthread_t helmettid = 0; |
|||
static void *thread_helmet_detect_entry(void *parameter); |
|||
static int g_fd = 0; |
|||
static int kmodel_fd = 0; |
|||
static int if_exit = 0; |
|||
static unsigned char *showbuffer = NULL; |
|||
static unsigned char *kpurgbbuffer = NULL; |
|||
|
|||
static _ioctl_shoot_para shoot_para_t = {0}; |
|||
unsigned char *model_data = NULL; // kpu data load memory
|
|||
unsigned char *model_data_align = NULL; |
|||
|
|||
kpu_model_context_t helmet_detect_task; |
|||
static region_layer_t helmet_detect_rl; |
|||
static obj_info_t helmet_detect_info; |
|||
volatile uint32_t g_ai_done_flag; |
|||
|
|||
static void ai_done(void *ctx) { g_ai_done_flag = 1; } |
|||
|
|||
static void param_parse() |
|||
{ |
|||
int fin; |
|||
char buffer[JSON_BUFFER_SIZE] = ""; |
|||
// char *buffer;
|
|||
// if (NULL != (buffer = (char*)malloc(JSON_BUFFER_SIZE * sizeof(char)))) {
|
|||
// memset(buffer, 0, JSON_BUFFER_SIZE * sizeof(char));
|
|||
// } else {
|
|||
// printf("Json buffer malloc failed!");
|
|||
// exit(-1);
|
|||
// }
|
|||
int array_size; |
|||
cJSON *json_obj; |
|||
cJSON *json_item; |
|||
cJSON *json_array_item; |
|||
|
|||
fin = open(JSON_FILE_PATH, O_RDONLY); |
|||
if (!fin) { |
|||
printf("Error open file %s", JSON_FILE_PATH); |
|||
exit(-1); |
|||
} |
|||
read(fin, buffer, sizeof(buffer)); |
|||
close(fin); |
|||
|
|||
// read json string
|
|||
json_obj = cJSON_Parse(buffer); |
|||
// free(buffer);
|
|||
char *json_print_str = cJSON_Print(json_obj); |
|||
printf("Json file content: \n%s\n", json_print_str); |
|||
cJSON_free(json_print_str); |
|||
// get anchors
|
|||
json_item = cJSON_GetObjectItem(json_obj, "anchors"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (ANCHOR_NUM * 2 != array_size) { |
|||
printf("Expect anchor size: %d, got %d in json file", ANCHOR_NUM * 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d anchors from json file\n", ANCHOR_NUM); |
|||
} |
|||
for (int i = 0; i < ANCHOR_NUM * 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
anchor[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, anchor[i]); |
|||
} |
|||
// net_input_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_input_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect net_input_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_input_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_input_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_input_size[i]); |
|||
} |
|||
// net_output_shape
|
|||
json_item = cJSON_GetObjectItem(json_obj, "net_output_shape"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (3 != array_size) { |
|||
printf("Expect net_output_shape: %d, got %d in json file", 3, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d net_output_shape from json file\n", 3); |
|||
} |
|||
for (int i = 0; i < 3; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
net_output_shape[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, net_output_shape[i]); |
|||
} |
|||
// sensor_output_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "sensor_output_size"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (2 != array_size) { |
|||
printf("Expect sensor_output_size: %d, got %d in json file", 2, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d sensor_output_size from json file\n", 2); |
|||
} |
|||
for (int i = 0; i < 2; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
sensor_output_size[i] = json_array_item->valueint; |
|||
printf("%d: %d\n", i, sensor_output_size[i]); |
|||
} |
|||
// kmodel_path
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_path"); |
|||
memcpy(kmodel_path, json_item->valuestring, strlen(json_item->valuestring)); |
|||
printf("Got kmodel_path: %s\n", kmodel_path); |
|||
// kmodel_size
|
|||
json_item = cJSON_GetObjectItem(json_obj, "kmodel_size"); |
|||
kmodel_size = json_item->valueint; |
|||
printf("Got kmodel_size: %d\n", kmodel_size); |
|||
// labels
|
|||
json_item = cJSON_GetObjectItem(json_obj, "labels"); |
|||
class_num = cJSON_GetArraySize(json_item); |
|||
if (0 >= class_num) { |
|||
printf("No labels!"); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d labels\n"); |
|||
} |
|||
for (int i = 0; i < class_num; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
memcpy(labels[i], json_item->valuestring, strlen(json_item->valuestring)); |
|||
printf("%d: %f\n", i, labels[i]); |
|||
} |
|||
// obj_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "obj_thresh"); |
|||
array_size = cJSON_GetArraySize(json_item); |
|||
if (class_num != array_size) { |
|||
printf("label number and thresh number mismatch! label number : %d, obj thresh number %d", class_num, array_size); |
|||
exit(-1); |
|||
} else { |
|||
printf("Got %d obj_thresh\n"); |
|||
} |
|||
for (int i = 0; i < array_size; i++) { |
|||
json_array_item = cJSON_GetArrayItem(json_item, i); |
|||
obj_thresh[i] = json_array_item->valuedouble; |
|||
printf("%d: %f\n", i, obj_thresh[i]); |
|||
} |
|||
// nms_thresh
|
|||
json_item = cJSON_GetObjectItem(json_obj, "nms_thresh"); |
|||
nms_thresh = json_item->valuedouble; |
|||
printf("Got nms_thresh: %f\n", nms_thresh); |
|||
|
|||
cJSON_Delete(json_obj); |
|||
return; |
|||
} |
|||
|
|||
void helmet_detect() |
|||
{ |
|||
int ret = 0; |
|||
int result = 0; |
|||
int size = 0; |
|||
param_parse(); |
|||
g_fd = open("/dev/ov2640", O_RDONLY); |
|||
if (g_fd < 0) { |
|||
printf("open ov2640 fail !!"); |
|||
return; |
|||
} |
|||
showbuffer = (unsigned char *)malloc(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
if (NULL == showbuffer) { |
|||
close(g_fd); |
|||
printf("showbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
kpurgbbuffer = (unsigned char *)malloc(net_input_size[0] * net_input_size[1] * 3); |
|||
if (NULL == kpurgbbuffer) { |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
printf("kpurgbbuffer apply memory fail !!"); |
|||
return; |
|||
} |
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
close(g_fd); |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
memset(showbuffer, 0, sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
memset(kpurgbbuffer, 127, net_input_size[0] * net_input_size[1] * 3); |
|||
shoot_para_t.pdata = (unsigned int *)(showbuffer); |
|||
shoot_para_t.length = (size_t)(sensor_output_size[0] * sensor_output_size[1] * 2); |
|||
/*
|
|||
load memory |
|||
*/ |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
if (kmodel_fd < 0) { |
|||
printf("open kmodel fail"); |
|||
close(g_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} else { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
|
|||
} else { |
|||
printf("read kmodel success \n"); |
|||
} |
|||
} |
|||
unsigned char *model_data_align = (unsigned char *)(((unsigned int)model_data + 255) & (~255)); |
|||
dvp_set_ai_addr((uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0])), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[1] * (net_input_size[0] - sensor_output_size[0]) + |
|||
net_input_size[0] * net_input_size[1]), |
|||
(uint32_t)(kpurgbbuffer + net_input_size[0] * net_input_size[1] * 2 + |
|||
net_input_size[1] * (net_input_size[0] - sensor_output_size[0]))); |
|||
if (kpu_load_kmodel(&helmet_detect_task, model_data_align) != 0) { |
|||
printf("\nmodel init error\n"); |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
return; |
|||
} |
|||
helmet_detect_rl.anchor_number = ANCHOR_NUM; |
|||
helmet_detect_rl.anchor = anchor; |
|||
helmet_detect_rl.threshold = malloc(class_num * sizeof(float)); |
|||
for (int idx = 0; idx < class_num; idx++) { |
|||
helmet_detect_rl.threshold[idx] = obj_thresh[idx]; |
|||
} |
|||
helmet_detect_rl.nms_value = nms_thresh; |
|||
result = region_layer_init(&helmet_detect_rl, net_output_shape[0], net_output_shape[1], net_output_shape[2], |
|||
net_input_size[1], net_input_size[0]); |
|||
printf("region_layer_init result %d \n\r", result); |
|||
size_t stack_size = STACK_SIZE; |
|||
pthread_attr_t attr; /* 线程属性 */ |
|||
struct sched_param prio; /* 线程优先级 */ |
|||
prio.sched_priority = 8; /* 优先级设置为 8 */ |
|||
pthread_attr_init(&attr); /* 先使用默认值初始化属性 */ |
|||
pthread_attr_setschedparam(&attr, &prio); /* 修改属性对应的优先级 */ |
|||
pthread_attr_setstacksize(&attr, stack_size); |
|||
|
|||
/* 创建线程 1, 属性为 attr，入口函数是 thread_entry，入口函数参数是 1 */ |
|||
result = pthread_create(&helmettid, &attr, thread_helmet_detect_entry, NULL); |
|||
if (0 == result) { |
|||
printf("thread_helmet_detect_entry successfully!\n"); |
|||
} else { |
|||
printf("thread_helmet_detect_entry failed! error code is %d\n", result); |
|||
close(g_fd); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(helmet_detect, helmet detect task); |
|||
#endif |
|||
|
|||
static void *thread_helmet_detect_entry(void *parameter) |
|||
{ |
|||
extern void lcd_draw_picture(uint16_t x1, uint16_t y1, uint16_t width, uint16_t height, uint32_t * ptr); |
|||
printf("thread_helmet_detect_entry start!\n"); |
|||
int ret = 0; |
|||
// sysctl_enable_irq();
|
|||
while (1) { |
|||
// memset(showbuffer,0,320*240*2);
|
|||
g_ai_done_flag = 0; |
|||
ret = ioctl(g_fd, IOCTRL_CAMERA_START_SHOT, &shoot_para_t); |
|||
if (RT_ERROR == ret) { |
|||
printf("ov2640 can't wait event flag"); |
|||
rt_free(showbuffer); |
|||
close(g_fd); |
|||
pthread_exit(NULL); |
|||
return NULL; |
|||
} |
|||
kpu_run_kmodel(&helmet_detect_task, kpurgbbuffer, DMAC_CHANNEL5, ai_done, NULL); |
|||
while (!g_ai_done_flag) |
|||
; |
|||
float *output; |
|||
size_t output_size; |
|||
kpu_get_output(&helmet_detect_task, 0, (uint8_t **)&output, &output_size); |
|||
helmet_detect_rl.input = output; |
|||
region_layer_run(&helmet_detect_rl, &helmet_detect_info); |
|||
/* display result */ |
|||
#ifdef BSP_USING_LCD |
|||
for (int helmet_cnt = 0; helmet_cnt < helmet_detect_info.obj_number; helmet_cnt++) { |
|||
// draw_edge((uint32_t *)showbuffer, &helmet_detect_info, helmet_cnt, 0xF800,
|
|||
// (uint16_t)sensor_output_size[1],
|
|||
// (uint16_t)sensor_output_size[0]);
|
|||
printf("%d: (%d, %d, %d, %d) cls: %s conf: %f\t", helmet_cnt, helmet_detect_info.obj[helmet_cnt].x1, |
|||
helmet_detect_info.obj[helmet_cnt].y1, helmet_detect_info.obj[helmet_cnt].x2, |
|||
helmet_detect_info.obj[helmet_cnt].y2, labels[helmet_detect_info.obj[helmet_cnt].class_id], |
|||
helmet_detect_info.obj[helmet_cnt].prob); |
|||
} |
|||
if (0 != helmet_detect_info.obj_number) { |
|||
printf("\n"); |
|||
} else { |
|||
printf("No helmet or head found!\n"); |
|||
} |
|||
lcd_draw_picture(0, 0, (uint16_t)sensor_output_size[1], (uint16_t)sensor_output_size[0], (unsigned int *)showbuffer); |
|||
#endif |
|||
usleep(1); |
|||
if (1 == if_exit) { |
|||
if_exit = 0; |
|||
printf("thread_helmet_detect_entry exit"); |
|||
pthread_exit(NULL); |
|||
} |
|||
} |
|||
} |
|||
|
|||
void helmet_detect_delete() |
|||
{ |
|||
if (showbuffer != NULL) { |
|||
int ret = 0; |
|||
close(g_fd); |
|||
close(kmodel_fd); |
|||
free(showbuffer); |
|||
free(kpurgbbuffer); |
|||
free(model_data); |
|||
printf("helmet detect task cancel!!! ret %d ", ret); |
|||
if_exit = 1; |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(helmet_detect_delete, helmet detect task delete); |
|||
#endif |
|||
|
|||
void kmodel_load(unsigned char *model_data) |
|||
{ |
|||
int kmodel_fd = 0; |
|||
int size = 0; |
|||
kmodel_fd = open(kmodel_path, O_RDONLY); |
|||
|
|||
model_data = (unsigned char *)malloc(kmodel_size + 255); |
|||
if (NULL == model_data) { |
|||
printf("model_data apply memory fail !!"); |
|||
return; |
|||
} |
|||
memset(model_data, 0, kmodel_size + 255); |
|||
|
|||
if (kmodel_fd >= 0) { |
|||
size = read(kmodel_fd, model_data, kmodel_size); |
|||
if (size != kmodel_size) { |
|||
printf("read kmodel error size %d\n", size); |
|||
|
|||
} else { |
|||
printf("read kmodel success"); |
|||
} |
|||
} else { |
|||
free(model_data); |
|||
printf("open kmodel fail"); |
|||
} |
|||
} |
|||
#ifdef __RT_THREAD_H__ |
|||
MSH_CMD_EXPORT(kmodel_load, kmodel load memory); |
|||
#endif |
|||
Loading…
Reference in new issue