pans

2016-12-28 db268cb5c15d467b77392146e5b3a2d7465692b7

git-svn-id: http://192.168.1.226/svn/proxy@42 454eff88-639b-444f-9e54-f578c98de674

 RtspFace/demo/include/cv_common.h

New file
@@ -0,0 +1,285 @@
#ifndef CV_COMMON_H_
#define CV_COMMON_H_

/// @defgroup cv_common cv common
/// @brief common definitions & API for cv libs
/// @{

#include <cv_utils.h>

#ifdef __cplusplus
#    define CV_SDK_API extern "C" CV_SDK_API_
#else
#    define CV_SDK_API CV_SDK_API_
#endif

/// cv handle declearation
typedef void *cv_handle_t;

/// cv result declearation
typedef cv_errcode cv_result_t;

/// cv rectangle definition
typedef struct cv_rect_t {
    int left;    ///< çŸ©å½¢æœ€å·¦è¾¹çš„坐标
    int top;    ///< çŸ©å½¢æœ€ä¸Šè¾¹çš„坐标
    int right;    ///< çŸ©å½¢æœ€å³è¾¹çš„坐标
    int bottom;    ///< çŸ©å½¢æœ€ä¸‹è¾¹çš„坐标
} cv_rect_t;

/// cv float type point definition
typedef struct cv_pointf_t {
    float x;    ///< ç‚¹çš„水平方向坐标, ä¸ºæµ®ç‚¹æ•°
    float y;    ///< ç‚¹çš„竖直方向坐标, ä¸ºæµ®ç‚¹æ•°
} cv_pointf_t;

/// cv integer type point definition
typedef struct cv_pointi_t {
    int x;        ///< ç‚¹çš„水平方向坐标, ä¸ºæ•´æ•°
    int y;        ///< ç‚¹çš„竖直方向坐标, ä¸ºæ•´æ•°
} cv_pointi_t;

/// cv object struct
typedef struct cv_object_t {
    cv_pointi_t *corner;
    int corner_count;
} cv_object_t;

/// cv landmark array struct
typedef struct cv_landmarks_t {
    cv_pointf_t *points_array;
    int points_count;
} cv_landmarks_t;

/// @brief å…³é”®ç‚¹è·Ÿè¸ªç»“果结构体
typedef  struct cv_target_t {
    cv_rect_t rect;            ///< ä»£è¡¨é¢éƒ¨çš„矩形区域
    cv_pointf_t *points_array;    ///< ç›®æ ‡å…³é”®ç‚¹åæ ‡
    int points_count;        ///< ç›®æ ‡å…³é”®ç‚¹é•¿åº¦
    float score;            ///< ç›®æ ‡ç½®ä¿¡åº¦
    int id;                ///< ç›®æ ‡ID, ç”¨äºŽè¡¨ç¤ºåœ¨ç›®æ ‡è·Ÿè¸ªä¸­çš„相同目标在不同帧多次出现
} cv_target_t;

typedef struct cv_feature_header_t {
    int ver;        ///< ç‰ˆæœ¬ä¿¡æ¯
    int idx;        ///< æ•°ç»„下标索引
    int len;        ///< CV_FEATURE全部内容的长度, åŒ…括feature_header和特征数组, æŒ‰å­—节计算, ä¸Žsizeof(cv_feature_header_t)定义不同
} cv_feature_header_t;

/// @brief ç‰¹å¾æ ¼å¼å®šä¹‰
typedef struct cv_feature_t {
    int ver;    ///< ç‰¹å¾ç‰ˆå¯¹åº”模型本号
    int idx;    ///< ç‰¹å¾ç´¢å¼•åºå·
    int len;    ///< CV_FEATURE全部内容的长度, åŒ…括feature_header和特征数组, æŒ‰å­—节计算, ä¸Žsizeof(cv_feature_header_t)定义不同
    float feat[0];    ///< ç‰¹å¾æ•°ç»„
} cv_feature_t;

#define CV_FEATURE_HEADER(pf) ((cv_feature_header_t*)(pf))
#define CV_FEATURE_SIZE(pf)   (CV_FEATURE_HEADER(pf)->len)
#define CV_FEATURE_LENGTH(pf)   ((CV_FEATURE_HEADER(pf)->len-sizeof(cv_feature_header_t))/sizeof(float))
#define CV_ENCODE_FEATURE_SIZE(pf) ((CV_FEATURE_HEADER(pf)->len+2)/3*4 + 1)

/// cv pixel format definition
typedef enum {
    CV_PIX_FMT_GRAY8,    ///< Y    1       8bpp ( å•é€šé“8bit灰度像素 )
    CV_PIX_FMT_YUV420P,    ///< YUV  4:2:0   12bpp ( 3通道, ä¸€ä¸ªäº®åº¦é€šé“, å¦ä¸¤ä¸ªä¸ºU分量和V分量通道, æ‰€æœ‰é€šé“都是连续的 )
    CV_PIX_FMT_NV12,    ///< YUV  4:2:0   12bpp ( 2通道, ä¸€ä¸ªé€šé“是连续的亮度通道, å¦ä¸€é€šé“为UV分量交错 )
    CV_PIX_FMT_NV21,    ///< YUV  4:2:0   12bpp ( 2通道, ä¸€ä¸ªé€šé“是连续的亮度通道, å¦ä¸€é€šé“为VU分量交错 )
    CV_PIX_FMT_BGRA8888,    ///< BGRA 8:8:8:8 32bpp ( 4通道32bit BGRA åƒç´  )
    CV_PIX_FMT_BGR888    ///< BGR  8:8:8   24bpp ( 3通道24bit BGR åƒç´  )
} cv_pixel_format;

/// @brief æ—¶é—´æˆ³å®šä¹‰
typedef struct cv_time_t {
    long int tv_sec;    ///< ç§’
    long int tv_usec;    ///< å¾®å¦™
}cv_time_t;

/// å›¾åƒæ ¼å¼å®šä¹‰
typedef struct cv_image {
    unsigned char *data;        ///< å›¾åƒæ•°æ®æŒ‡é’ˆ
    cv_pixel_format pixel_format;    ///< åƒç´ æ ¼å¼
    int width;            ///< å®½åº¦(以像素为单位)
    int height;            ///< é«˜åº¦(以像素为单位)
    int stride;            ///< è·¨åº¦, å³æ¯è¡Œæ‰€å çš„字节数
    cv_time_t time_stamp;        ///< æ—¶é—´æˆ³
} cv_image;

typedef struct cv_clustering_result_t {
    unsigned int count;        ///< ç›®æ ‡æ•°é‡
    int *idxs;            ///< ç›®æ ‡ç´¢å¼•æ•°ç»„
    unsigned int group_flags;    ///< ä¿ç•™å‚æ•°
} cv_clustering_result_t;

/// @brief å›¾åƒåˆ†ç±»æ ‡ç­¾ç»“æžœ
typedef struct cv_classifier_result_t {
    int id;                ///标签
    float score;            /// ç½®ä¿¡åº¦
} cv_classifier_result_t;

// ====================== image utilities ========================

/// @brief åˆ›å»ºå›¾åƒæŒ‡é’ˆå¹¶åˆ†é…å†…å­˜
/// @param[in] width è¾“入宽度
/// @param[in] height è¾“入高度
/// @param[in] pixel_format è¾“入像素格式
/// @param[out] image è¾“出图像指针所在地址
/// @return æˆåŠŸè¿”回CV_OK, å¦åˆ™è¿”回错误码
CV_SDK_API
cv_result_t cv_image_allocate(
    int width,
    int height,
    cv_pixel_format pixel_format,
    cv_image ** image
);

/// @brief é‡Šæ”¾å›¾åƒæ•°æ®
/// @param[in] image å›¾åƒæŒ‡é’ˆ
CV_SDK_API void
cv_image_release(cv_image* image);

/// @brief è¿›è¡Œé¢œè‰²æ ¼å¼è½¬æ¢
/// @param[in] image_src ç”¨äºŽå¾…转换的图像数据
/// @param[out] image_dst è½¬æ¢åŽçš„图像数据, ç›®æ ‡å›¾åƒç”±ç”¨æˆ·åˆ†é…å†…å­˜, éœ€æå‰å®šä¹‰å®½, é«˜, PixelFormat等信息, åƒç´ å€¼åˆå§‹åŒ–为0
/// @return æ­£å¸¸è¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API cv_result_t
cv_common_color_convert(
    const cv_image* image_src,
    cv_image* image_dst
);

/// @brief è¿›è¡Œä»¿å°„变换
/// @param[in] image_src ç”¨äºŽå¾…转换的图像数据
/// @param[in] src_points_array æºå›¾çš„仿射点数组
/// @param[in] src_points_count æºå›¾ä»¿å°„点的数目
/// @param[in] dst_points_array ç›®æ ‡å›¾çš„仿射点数组
/// @param[in] dst_points_count ç›®æ ‡å›¾ä»¿å°„点的数目
/// @param[out] image_dst è½¬æ¢åŽçš„图像数据, å¿…须是BGR格式图像，目标图像需要由用户分配内存, éœ€æå‰å®šä¹‰å®½, é«˜, PixelFormat等信息
/// @return æ­£å¸¸è¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API
cv_result_t
cv_common_image_affine_transfer(
    const cv_image *image_src,
    const cv_pointf_t *src_points_array,
    const int src_points_count,
    const cv_pointf_t *dst_points_array,
    const int dst_points_count,
    cv_image *image_dst
);

/// @brief å›¾ç‰‡è°ƒæ•´æ–¹æ³•
typedef enum {
       CV_IMAGE_RESIZE_BILINEAR,    ///< åŒçº¿æ€§æ’值
       CV_IMAGE_RESIZE_AREA        ///< åŒºåŸŸæ’值
} cv_image_resize_method;

/// @brief è¿›è¡Œç¼©æ”¾å˜æ¢
/// @note è¯¥å‡½æ•°ç›®å‰ä¸æ”¯æŒstride参数, æ‰€ä»¥stride参数应等于 width * elemSize
/// @param[in] image_src ç”¨äºŽå¾…转换的图像数据
/// @param[out] image_dst è½¬æ¢åŽçš„图像数据, ç›®æ ‡å›¾åƒç”±ç”¨æˆ·åˆ†é…å†…å­˜, éœ€æå‰å®šä¹‰å®½, é«˜, PixelFormat等信息
/// @param[in] method ç¼©æ”¾è½¬æ¢çš„方法
/// @return æ­£å¸¸è¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API
cv_result_t
cv_common_image_resize(
       const cv_image *image_src,
       cv_image *image_dst,
       cv_image_resize_method method
);

/// @brief è¿›è¡Œå›¾åƒè£å‰ª
/// @param[in] image_src ç”¨äºŽå¾…裁剪的图像数据
/// @param[in] crop_area å›¾åƒè£å‰ªçš„区域
/// @param[out] image_dst è£å‰ªåŽçš„图像数据, ç›®æ ‡å›¾åƒç”±ç”¨æˆ·åˆ†é…å†…å­˜, éœ€æå‰å®šä¹‰å®½, é«˜, PixelFormat等信息
/// @return æ­£å¸¸è¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API
cv_result_t
cv_common_image_crop(
       const cv_image *image_src,
       const cv_rect_t *crop_area,
       cv_image *image_dst
);

/// @brief è¿›è¡Œå›¾åƒæ—‹è½¬
/// @note è¯¥å‡½æ•°ç›®å‰ä¸æ”¯æŒstride参数, æ‰€ä»¥stride参数应等于 width * elemSize
/// @param[in] image_src ç”¨äºŽå¾…旋转的图像数据
/// @param[out] image_dst æ—‹è½¬åŽçš„图像数据, ç›®æ ‡å›¾åƒç”±ç”¨æˆ·åˆ†é…å†…å­˜, éœ€æå‰å®šä¹‰å®½, é«˜, PixelFormat等信息
/// @param[in] rotate_degree å›¾åƒé¡ºæ—¶é’ˆæ—‹è½¬çš„角度, çŽ°åœ¨åªæ”¯æŒ0, 90, 180, 270
/// @return æ­£å¸¸è¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API
cv_result_t
cv_common_image_rotate(
       const cv_image *image_src,
       cv_image *image_dst,
       unsigned int rotate_degree
);


// ====================== model loader ========================

/// æ¨¡åž‹æŒ‡é’ˆ
typedef void * cv_model_t;

/// ç»„合模型指针
typedef void * cv_composite_model_t;

/// @brief åŠ è½½å¤–部模型
/// @param[in] file è¾“入模型文件路径
/// @param[out] model è¾“出已初始化的模型指针
/// @return æˆåŠŸè¿”回CV_OK
CV_SDK_API cv_result_t
cv_common_load_model(
    const char *file,
    cv_model_t *model
);

/// @brief é”€æ¯å·²åŠ è½½çš„模型
/// @param[in] model æ¨¡åž‹æŒ‡é’ˆ
CV_SDK_API
void cv_common_unload_model(
    cv_model_t model
);

/// @brief åŠ è½½å†…部模型
/// @param[in] model_start å†…部模型指针头
/// @param[in] model_end å†…部模型指针尾
/// @param[out] model è¾“出已初始化的模型指针
/// @return æˆåŠŸè¿”回CV_OK
CV_SDK_API cv_result_t
cv_common_load_resource(
    const unsigned char *model_start,
    const unsigned char *model_end,
    cv_model_t *model
);


/// @brief åŠ è½½ç»„合模型
/// @param[in] file ç»„合模型文件路径， æ–‡ä»¶æ˜¯ç”±å¤šä¸ªå­æ¨¡åž‹æ–‡ä»¶ç»„成tar包
/// @param[out] model è¾“出已初始化的组合模型指针
/// @return æˆåŠŸè¿”回CV_OK
CV_SDK_API cv_result_t
cv_common_load_composite_model(
    const char *file,
    cv_composite_model_t *model
);

/// @brief é”€æ¯å·²åŠ è½½çš„组合模型
/// @param[in] model å°†é”€æ¯çš„模型
CV_SDK_API cv_result_t
cv_common_unload_composite_model(
       cv_composite_model_t model
);

/// @brief èŽ·å–子模型
/// @param[in] model ç»„合模型
/// @param[in] name å­æ¨¡åž‹åå­—
/// @param[in] æˆåŠŸè¿”回CV_OK
CV_SDK_API cv_result_t
cv_common_composite_model_get_submodel(
       cv_composite_model_t model,
       const char *name,
       cv_model_t *submodel
);

/// @}
#endif  // INCLUDE_CV_COMMON_H_

 RtspFace/demo/include/cv_face.h

New file
@@ -0,0 +1,580 @@

#ifndef INCLUDE_CVFACE_API_CV_FACE_EXTERNAL_H_
#define INCLUDE_CVFACE_API_CV_FACE_EXTERNAL_H_


#include "cv_common.h"
/// @defgroup cvface_common cvface common
/// @brief Common definitions for cvface
/// @{

/// @brief äººè„¸ä¿¡æ¯ç»“构体
typedef struct cv_face_t {
    cv_rect_t rect;                        ///< ä»£è¡¨é¢éƒ¨çš„矩形区域
    float score;                        ///< ç½®ä¿¡åº¦ï¼Œç”¨äºŽç­›é™¤è´Ÿä¾‹ï¼Œä¸Žäººè„¸ç…§ç‰‡è´¨é‡æ— å…³ï¼Œå€¼è¶Šé«˜è¡¨ç¤ºç½®ä¿¡åº¦è¶Šé«˜ã€‚
    int points_count;                    ///< äººè„¸å…³é”®ç‚¹æ•°ç»„的长度，如果没有计算关键点，则为0
    float yaw;                            ///< æ°´å¹³è½¬è§’，真实度量的左负右正
    float pitch;                            ///< ä¿¯ä»°è§’，真实度量的上负下正
    float roll;                            ///< æ—‹è½¬è§’，真实度量的左负右正
    float eye_dist;                        ///< ä¸¤çœ¼é—´è·
    int ID;                                ///< faceID，用于表示在实时人脸跟踪中的相同人脸在不同帧多次出现，在人脸检测的结果中无实际意义
    cv_pointf_t points_array[256];        ///< äººè„¸å…³é”®ç‚¹çš„数组支持21点，106点，以及为将来预留的空间
} cv_face_t;

/// äººè„¸æ£€æµ‹ã€è·Ÿè¸ªé…ç½®é€‰é¡¹
#define CV_FACE_DEFAULT_CONFIG        0x00000000        ///< é»˜è®¤é€‰é¡¹ï¼Œä¸è®¾ç½®ä»»ä½•å¼€å…³
#define CV_FACE_RESIZE_IMG_320W        0x00000002        ///< resize图像为长边320的图像
#define CV_FACE_RESIZE_IMG_640W        0x00000004        ///< resize图像为长边640的图像
#define CV_FACE_RESIZE_IMG_1280W    0x00000008        ///< resize图像为长边1280的图像

/// detect config flags, 0x----00-- ~ 0x----FF--
#define CV_DETECT_ENABLE_ALIGN_21                0x00000100  ///< å¼€å¯é¢éƒ¨å…³é”®21点检测选项
#define CV_DETECT_ENABLE_ALIGN_106                0x00000200  ///< å¼€å¯é¢éƒ¨å…³é”®106点检测选项

/// è¯¥ç‰ˆæœ¬sdk未开启此功能(如：面部关键21点检测版本传入了面部关键106点检测参数)
#define CV_E_UNSURPPORTED    (-1000)
/// æŒ‡å®šä½ç½®æœªæ‰¾åˆ°license.lic文件
#define CV_E_MISSLICENSE    (-1001)
/// cv_face_init_license_config å‡½æ•°è¢«é‡å¤è°ƒç”¨
#define  CV_E_MULTI_CALLS    (-1002)

/// @brief  äººè„¸æœå‘
typedef enum {
    CV_FACE_UP        = 0x0000001,        ///< äººè„¸å‘上，即人脸朝向正常
    CV_FACE_LEFT    = 0x0000002,        ///< äººè„¸å‘左，即人脸被逆时针旋转了90度
    CV_FACE_DOWN    = 0x0000004,        ///< äººè„¸å‘下，即人脸被逆时针旋转了180度
    CV_FACE_RIGHT    = 0x0000008,        ///< äººè„¸å‘右，即人脸被逆时针旋转了270度
    CV_FACE_UNKNOWN = 0xf                ///< äººè„¸æœå‘未知，API自动判断人脸朝向，耗时增加。face_track不支持此参数，等同于CV_FACE_UP
} cv_face_orientation;

/// @brief  è¾“出当前SDK所支持的算法及内置模型信息
CV_SDK_API
void
cv_face_algorithm_info();

/// @brief  æ‰‹åŠ¨åŠ è½½license文件，除IOS,Android平台外，都可以不主动调用此函数（但需要将license文件放在可执行程序同一目录，名称命名为license.lic）,该函数只能被成功调用一次
/// param[in]    szLicense æŽˆæƒæ–‡ä»¶ä¸­çš„字符串，license文件的全部内容
CV_SDK_API
cv_result_t
cv_face_init_license_config(const char* szLicense);


/// @defgroup cvface_detect cvface detect
/// @brief face position detection interfaces
///
/// This set of interfaces processing face position & 21 or 106 points landmark detection routines
///
/// @{

/// @brief åˆ›å»ºäººè„¸æ£€æµ‹å¥æŸ„
/// @param[out] handle函数成功时被设置为有效的detector handle
/// @param[in] model_path æ¨¡åž‹æ–‡ä»¶çš„绝对路径或相对路径，若不指定模型可为NULL
/// @param[in] config é…ç½®é€‰é¡¹ï¼Œé»˜è®¤é…ç½®ä¸ºCV_DETECT_ENABLE_ALIGN_21(21关键点检测)。支持106关键点检测CV_DETECT_ENABLE_ALIGN_106和自动缩放CV_FACE_RESIZE_IMG_XXXX。
/// @return è¿”回CV_OK å¤±è´¥è¿”回错误码
CV_SDK_API
cv_result_t
cv_face_create_detector(
    cv_handle_t *handle,
    const char *model_path,
    unsigned int config
);

/// @brief èŽ·å–当前人脸检测的默认阀值
/// @param[in]    handle äººè„¸æ£€æµ‹å¥æŸ„
/// @param[out]    threshold äººè„¸æ£€æµ‹çš„默认阀值
CV_SDK_API
cv_result_t cv_face_detect_get_threshold(
    cv_handle_t detector_handle,
    float *threshold
    );

/// @brief è®¾ç½®å½“前人脸检测的阀值，需要在调用cv_face_detect之前调用此函数，阈值需大于0，设置后调用cv_face_detect_get_threshold为新设置后的值)
/// @param[in] handle äººè„¸æ£€æµ‹å¥æŸ„
/// @param[in] threshold äººè„¸æ£€æµ‹æ–°é˜€å€¼
CV_SDK_API
cv_result_t cv_face_detect_set_threshold(
    cv_handle_t detector_handle,
    float threshold
    );

/// @brief é”€æ¯å·²åˆå§‹åŒ–的人脸检测句柄
/// @param[in] detector_handle å·²åˆå§‹åŒ–的人脸检测句柄
CV_SDK_API
void cv_face_destroy_detector(
    cv_handle_t detector_handle
);

/// @brief äººè„¸æ£€æµ‹
/// @param[in]    detector_handle å·²åˆå§‹åŒ–的人脸检测句柄
/// @param[in]    image ç”¨äºŽæ£€æµ‹çš„图像数据
/// @param[in]    piexl_format ç”¨äºŽæ£€æµ‹çš„图像数据的像素格式
/// @param[in]    image_width ç”¨äºŽæ£€æµ‹çš„图像的宽度(以像素为单位)
/// @param[in]    image_height ç”¨äºŽæ£€æµ‹çš„图像的高度(以像素为单位)
/// @param[in]    image_stride ç”¨äºŽæ£€æµ‹çš„图像中每一行的跨度(以像素为单位) å›¾åƒè·¨åº¦=图像宽度*图像维度
/// @param[in]    orientation å›¾ç‰‡ä¸­äººè„¸çš„方向
/// @param[out]    p_faces_array æ£€æµ‹åˆ°çš„人脸信息数组，api负责分配内存，需要调用cv_face_release_detector_result函数释放
/// @param[out]    p_faces_count æ£€æµ‹åˆ°çš„人脸数量
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_face_detect(
    cv_handle_t detector_handle,
    const unsigned char *image,
    cv_pixel_format pixel_format,
    int image_width,
    int image_height,
    int image_stride,
    cv_face_orientation orientation,
    cv_face_t **p_faces_array,
    int *p_faces_count
);

/// @brief é‡Šæ”¾äººè„¸æ£€æµ‹è¿”回结果时分配的空间
/// @param[in] faces_array æ£€æµ‹åˆ°çš„人脸信息数组
/// @param[in] faces_count æ£€æµ‹åˆ°çš„人脸数量
CV_SDK_API
void
cv_face_release_detector_result(
    cv_face_t *faces_array,
    int faces_count
);


/// @}


/// @defgroup cvface_track cvface track
/// @brief face tracking interfaces
///
/// This set of interfaces processing face tracking routines
///
/// @{

#define CV_FACE_TRACKING_TWO_THREAD        0x00110000    ///< å¼€å¯åŒçº¿ç¨‹äººè„¸è·Ÿè¸ªï¼Œå»ºè®®ä½Žé…ç½®çŽ¯å¢ƒå¼€å¯æ­¤é€‰é¡¹ã€‚

/// @brief åˆ›å»ºå®žæ—¶äººè„¸è·Ÿè¸ªå¥æŸ„。可以调用cv_face_track_set_detect_face_cnt_limit设置检测的最大人脸数目，默认为不限制人脸检测数量。
/// @param[out]    handle函数成功时被设置为有效的tracker handle
/// @param[in]    model_path æ¨¡åž‹æ–‡ä»¶çš„绝对路径或相对路径，若不指定模型可为NULL
/// @param[in]    config é»˜è®¤é…ç½®ä¸ºCV_DETECT_ENABLE_ALIGN_21(21关键点检测)。支持106关键点检测CV_DETECT_ENABLE_ALIGN_106、自动缩放CV_FACE_RESIZE_IMG_XXXX和双线程跟踪CV_FACE_TRACKING_TWO_THREAD。
/// @return è¿”回CV_OK å¤±è´¥è¿”回错误码
CV_SDK_API
cv_result_t
cv_face_create_tracker(
    cv_handle_t *handle,
    const char *model_path,
    unsigned int config
);

/// @brief é”€æ¯å·²åˆå§‹åŒ–的实时人脸跟踪句柄
/// @param[in] tracker_handle å·²åˆå§‹åŒ–的实时人脸跟踪句柄
CV_SDK_API
void
cv_face_destroy_tracker(
    cv_handle_t tracker_handle
);

/// @brief å¯¹è¿žç»­è§†é¢‘帧进行实时快速人脸跟踪
/// @param[in]    tracker_handle å·²åˆå§‹åŒ–的实时人脸跟踪句柄
/// @param[in]    image ç”¨äºŽæ£€æµ‹çš„图像数据
/// @param[in]    piexl_format ç”¨äºŽæ£€æµ‹çš„图像数据的像素格式
/// @param[in]    image_width ç”¨äºŽæ£€æµ‹çš„图像的宽度(以像素为单位)
/// @param[in]    image_height ç”¨äºŽæ£€æµ‹çš„图像的高度(以像素为单位)
/// @param[in]    image_stride ç”¨äºŽæ£€æµ‹çš„图像中每一行的跨度(以像素为单位)，图像跨度=图像宽度*图像维度
/// @param[in]    orientation è§†é¢‘中人脸的方向
/// @param[out]    p_faces_array æ£€æµ‹åˆ°çš„人脸信息数组，api负责分配内存，需要调用cv_facesdk_release_tracker_result函数释放
/// @param[out]    p_faces_count æ£€æµ‹åˆ°çš„人脸数量
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_face_track(
    cv_handle_t tracker_handle,
    const unsigned char *image,
    cv_pixel_format pixel_format,
    int image_width,
    int image_height,
    int image_stride,
    cv_face_orientation orientation,
    cv_face_t **p_faces_array,
    int *p_faces_count
);

/// @brief é‡ç½®äººè„¸è·Ÿè¸ªæ£€æµ‹å™¨
/// @param[in] tracker_handle å·²åˆå§‹åŒ–的实时人脸跟踪句柄
CV_SDK_API
void
cv_face_reset_tracker(
    cv_handle_t tracker_handle
);

/// @brief é‡Šæ”¾å®žæ—¶äººè„¸è·Ÿè¸ªè¿”回结果时分配的空间
/// @param[in] faces_array æ£€æµ‹åˆ°çš„人脸信息数组
/// @param[in] faces_count æ£€æµ‹åˆ°çš„人脸数量
CV_SDK_API
void
cv_face_release_tracker_result(
    cv_face_t *faces_array,
    int faces_count
);

/// @brief è®¾ç½®æ£€æµ‹åˆ°çš„最大人脸数目N，持续track已检测到的N个人脸直到人脸数小于N再继续做detect,如果未调用则不对检测人脸数量做限制
/// @param[in]    tracker_handle å·²åˆå§‹åŒ–的实时人脸跟踪句柄
/// @param[in]    detect_face_cnt_limit æœ€å¤§äººè„¸æ•°ç›®N，-1表示不设上限
/// @param[out]    val å¦‚果为非空指针，则返回采用的新的值，注意，由于内部的限制， å®žé™…采用的值并不一定等于detect_face_cnt_limit
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型 (实际设置检测到的最大目标数目N可能小于detect_face_cnt_limit)
CV_SDK_API
cv_result_t
cv_face_track_set_detect_face_cnt_limit(
    cv_handle_t tracker_handle,
    int detect_face_cnt_limit,
    int* val
);

/// @}


/// @defgroup cvface_verify cvface verify
/// @brief face verification interfaces
///
/// This set of interfaces processing face verification routines.
///
/// @{

/// @brief åˆ›å»ºäººè„¸éªŒè¯å¥æŸ„
/// @param[out]    handle函数成功时被设置为有效的verify handle
/// @param[in]    model_path æ¨¡åž‹åº“所在文件夹的绝对路径或相对路径(sdk中模型文件路径为sdk/models/verify.model")，不能为NULL
/// @return è¿”回CV_OK å¤±è´¥è¿”回错误码
CV_SDK_API
cv_result_t
cv_verify_create_handle(
    cv_handle_t* handle,
    const char *model_path
);

/// @brief åˆ›å»ºäººè„¸éªŒè¯å¥æŸ„的副本，与旧的句柄共享内存，可用于多线程调用
/// @param[in]    old_handle æ—§çš„人脸验证句柄，新句柄释放后才能释放旧句柄
/// @param[out]    new_handle å‡½æ•°æˆåŠŸè¿”回人脸验证句柄的副本
/// @return æˆåŠŸè¿”回CV_OK
CV_SDK_API
cv_result_t
cv_verify_duplicate_handle(
    cv_handle_t old_handle,
    cv_handle_t* new_handle
);

/// @brief é”€æ¯å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in] verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
CV_SDK_API
void
cv_verify_destroy_handle(
    cv_handle_t verify_handle
);

/// @brief èŽ·å–当前人脸验证使用的模型版本号
/// @param[in] verify_handle äººè„¸éªŒè¯å¥æŸ„
/// @return ç‰ˆæœ¬å·
CV_SDK_API
int
cv_verify_get_version(
    cv_handle_t verify_handle
);

/// @brief èŽ·å–当前人脸验证使用的模型提取的feature长度，不包含cv_feature_header_t的长度
/// @param[in] verify_handle äººè„¸éªŒè¯å¥æŸ„
/// @return ç‰¹å¾é•¿åº¦
CV_SDK_API
int
cv_verify_get_feature_length(
    cv_handle_t verify_handle
);

/// @brief æå–人脸特征，返回特征数据长度，可以把返回数组编码成字符串后存储起来以便以后使用
/// @param[in]    verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in]    image ç”¨äºŽæ£€æµ‹çš„图像数据
/// @param[in]    piexl_format ç”¨äºŽæ£€æµ‹çš„图像数据的像素格式
/// @param[in]    image_width ç”¨äºŽæ£€æµ‹çš„图像的宽度(以像素为单位)
/// @param[in]    image_height ç”¨äºŽæ£€æµ‹çš„图像的高度(以像素为单位)
/// @param[in]    image_stride ç”¨äºŽæ£€æµ‹çš„图像中每一行的跨度(以像素为单位)，图像跨度=图像宽度*图像维度
/// @param[in]    face è¾“入待处理的人脸信息，需要包括关键点信息，即 face.points_array ä¸ä¸ºNULL
/// @param[out]    p_feature äººè„¸ç‰¹å¾æ•°æ®ï¼Œéœ€è¦è°ƒç”¨cv_verify_release_feature函数释放
/// @param[out]    feature_blob_size ç‰¹å¾çš„长度，包含cv_feature_header_t的长度，与cv_feature_header_t->len一致
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_get_feature(
    cv_handle_t verify_handle,
    const unsigned char *image,
    cv_pixel_format pixel_format,
    int image_width,
    int image_height,
    int image_stride,
    const cv_face_t *face,
    cv_feature_t **p_feature,
    unsigned int *feature_blob_size
);

/// @brief ç‰¹å¾ä¿¡æ¯ç¼–码成字符串，编码后的字符串用于保存
/// @param[in]    feature è¾“入的特征信息
/// @param[out]    feature_str è¾“出的编码后的字符串,由用户分配和释放
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_serialize_feature(
    const cv_feature_t *feature,
    char *feature_str
);


/// @brief è§£ç å­—符串成特征信息
/// @param[in] feature_str è¾“入的待解码的字符串，api负责分配内存，需要调用cv_verify_release_feature释放
/// @return è¿”回解码后的feature, éœ€è¦ç”¨æˆ·ä½¿ç”¨ cv_common_feature_release() é‡Šæ”¾
CV_SDK_API
cv_feature_t *
cv_verify_deserialize_feature(
    const char *feature_str
);

/// @brief äººè„¸éªŒè¯
/// @param[in]    verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in]    feature1 ç¬¬ä¸€å¼ äººè„¸ç‰¹å¾ä¿¡æ¯
/// @param[in]    feature2 ç¬¬äºŒå¼ äººè„¸ç‰¹å¾ä¿¡æ¯
/// @param[out]    score äººè„¸éªŒè¯ç›¸ä¼¼åº¦å¾—分，范围0-1，得分越接近1越相似
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_compare_feature(
    cv_handle_t verify_handle,
    const cv_feature_t *feature1,
    const cv_feature_t *feature2,
    float *score
);

/// @brief é‡Šæ”¾æå–人脸特征时分配的空间
/// @param[in]  feature æå–到的人脸特征信息
CV_SDK_API
void
cv_verify_release_feature(
    cv_feature_t *feature
);

/// @}


/// @defgroup cvface_search cvface search
/// @brief face searching interfaces
///
/// This set of interfaces processing face search routines.
///
/// @{

/// @defgroup cvface_database cvface database for search
/// @ingroup cvface_search
/// @brief face database CURD interfaces for face searching
/// @{

/// @brief    åˆ›å»ºäººè„¸æ•°æ®åº“句柄
/// @handle[out]    æˆåŠŸæ—¶å€™è®¾ç½®ä¸ºäººè„¸æ•°æ®åº“句柄
/// @return[in]        æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_create_db(cv_handle_t *handle);

/// @brief é”€æ¯å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in] db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
CV_SDK_API
void
cv_verify_destroy_db(
    cv_handle_t db_handle
);

/// @brief äººè„¸æ•°æ®åº“增加数据
/// @param[in] db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in] items ç”¨äºŽåˆ›å»ºæ•°æ®åº“的人脸特征信息数组
/// @param[in] item_count ç‰¹å¾ä¿¡æ¯æ•°é‡
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_build_db(
    cv_handle_t db_handle,
    cv_feature_t* const *items,
    unsigned int item_count
);

/// @brief äººè„¸æ•°æ®åº“增加数据
/// @param[in]    db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in]    item å¾…加入的人脸特征信息
/// @param[out]    idx åŠ å…¥åŽçš„人脸数据库索引值
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_add_face(
    cv_handle_t db_handle,
    const cv_feature_t *item,
    int *idx
);

/// @brief äººè„¸æ•°æ®åº“删除数据
/// @param[in]    db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in]    idx å¾…删除的人脸数据库索引值(与加入时一致)
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_delete_face(
    cv_handle_t db_handle,
    int idx
);

/// @brief å°†äººè„¸æ•°æ®åº“信息保存为数据库文件
/// @param[in] db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in] db_path äººè„¸æ•°æ®åº“保存文件的路径
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_save_db(
    cv_handle_t db_handle,
    const char *db_path
);

/// @brief åŠ è½½äººè„¸æ•°æ®åº“文件
/// @param[in] db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in] db_path äººè„¸æ•°æ®åº“保存文件的路径
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_load_db(
    cv_handle_t db_handle,
    const char *db_path
);

/// @}

/// @brief æœç´¢äººè„¸æ•°æ®åº“
/// @param[in]    verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in]    db_handle å·²åˆå§‹åŒ–的人脸数据库句柄
/// @param[in]    query å¾…搜索的人脸特征信息
/// @param[in]    top_k æœ€å¤§çš„人脸搜索数量
/// @param[out] top_idxs æœç´¢åˆ°çš„人脸数据库索引值数组(由用户分配和释放)
/// @param[out]    top_scores æœç´¢åˆ°çš„人脸相似度得分数组(由用户分配和释放)，范围0-1，得分越接近1越相似
/// @param result_length å®žé™…搜索到的人脸数量
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_search_face(
    cv_handle_t verify_handle,
    cv_handle_t db_handle,
    const cv_feature_t *query,
    unsigned int top_k,
    int *top_idxs,
    float *top_scores,
    unsigned int *result_length
);

/// @brief ä»Žä¸€ç»„特征数组中搜索人脸
/// @param[in]    verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in]    list_feature äººè„¸ç‰¹å¾ä¿¡æ¯æ•°ç»„
/// @param[in]    list_count äººè„¸ç‰¹å¾ä¿¡æ¯æ•°é‡
/// @param[in]    query å¾…搜索的人脸特征信息
/// @param[in]    top_k æœ€å¤§çš„人脸搜索数量
/// @param[out]    top_idxs æœç´¢åˆ°çš„人脸数据库索引值数组(由用户分配和释放)
/// @param[out]    top_scores æœç´¢åˆ°çš„人脸相似度得分数组(由用户分配和释放)，范围0-1，得分越接近1越相似
/// @param[out]    result_length å®žé™…搜索到的人脸数量
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_search_face_from_list(
    cv_handle_t verify_handle,
    cv_feature_t* const *list_feature,
    int list_count,
    const cv_feature_t *query,
    unsigned int top_k,
    int *top_idxs,
    float *top_scores,
    unsigned int *result_length
);

/// @}


/// @defgroup cvface_group cvface group
/// @brief face grouping interfaces
///
/// This set of interfaces processing face grouping routines.
///
/// @{


/// @brief æ‰¹é‡äººè„¸åˆ†ç»„
/// @param[in]    verify_handle å·²åˆå§‹åŒ–的人脸验证句柄
/// @param[in]    features äººè„¸ç‰¹å¾ä¿¡æ¯æ•°ç»„
/// @param[in]    feature_count äººè„¸ç‰¹å¾ä¿¡æ¯æ•°é‡
/// @param[out]    p_groups_array åˆ†ç»„结果，index对应features的index，p_groups_array[0]表示index为0的feature对应的分组，内存由用户管理，p_groups_array大小与feature_count一致
/// @param[out]    group_count åˆ†ç»„的组数，需用户初始化为0
/// @return æˆåŠŸè¿”回CV_OK，否则返回错误类型
CV_SDK_API
cv_result_t
cv_verify_grouping(
    cv_handle_t verify_handle,
    const cv_feature_t * const *features,
    unsigned int feature_count,
    unsigned int *p_groups_array,
    unsigned int *groups_count
);

/// @brief åˆå§‹åŒ–特征数组结果
/// @param[in] p_groups_array    ç‰¹å¾åˆ†ç»„结果存储地址
/// @param[in] feature_count    ç‰¹å¾æ•°ç»„长度
CV_SDK_API
void
cv_verify_initialize_labels(
    unsigned int *p_groups_array,
    unsigned int feature_count
);

/// @}


/// @defgroup cvface_group cvface group
/// @brief face grouping interfaces
///
/// This set of interfaces processing face grouping routines.
///
/// @{

/// @brief åˆ›å»ºç‰¹å¾èšç±»å¥æŸ„
/// @param[out] handle è¾“出已初始化的特征聚类句柄所在地址
/// @param[in] model è½½å…¥çš„模型路径
/// @return æˆåŠŸè¿”回CV_OK, å¦åˆ™è¿”回错误信息
CV_SDK_API
cv_result_t
cv_face_create_clustering(
cv_handle_t *clustering_handle,
const char* model_path
);

/// @brief ç‰¹å¾èšç±»ï¼ˆåŒ…含增量聚类）
/// @param[in] handle å·²åˆå§‹åŒ–的特征聚类句柄
/// @param[in] features å¾…聚类的特征数组
/// @param[out] labels ç±»åˆ«æ•°ç»„, 0表示需要重新聚类，1表示是单张人脸（当人脸数量大于等于2是才会单独分组），2表示噪音（模糊、侧脸、不是人脸等），3及其以上表示实际分类结果
/// @param[out] size ç‰¹å¾å’Œç±»åˆ«çš„数量
/// @return æˆåŠŸè¿”回CV_OK, å¦åˆ™è¿”回错误类型
CV_SDK_API
cv_result_t
cv_face_clustering(
cv_handle_t clustering_handle,
const cv_feature_t * const *features,
unsigned int *labels,
int size
);


/// @brief é”€æ¯å·²åˆå§‹åŒ–的特征聚类句柄
/// @param[in] handle å·²åˆå§‹åŒ–的特征聚类句柄
CV_SDK_API
void
cv_face_clustering_destroy(
cv_handle_t clustering_handle
);

/// @}


#endif  // INCLUDE_CVFACE_API_CV_FACE_H_

 RtspFace/demo/include/cv_utils.h

New file
@@ -0,0 +1,47 @@
#ifndef CV_UTILS_H
#define CV_UTILS_H

#ifdef _MSC_VER
#    ifdef CV_STATIC_LIB
#        define CV_SDK_API_
#    elif defined SDK_EXPORTS
#        define CV_SDK_API_ __declspec(dllexport)
#    else
#        define CV_SDK_API_ __declspec(dllimport)
#    endif
#else /* _MSC_VER */
#    ifdef SDK_EXPORTS
#        define CV_SDK_API_ __attribute__((visibility ("default")))
#    else
#        define CV_SDK_API_
#    endif
#endif

typedef int cv_errcode;

#define    CV_OK 0                    ///< æ­£å¸¸è¿è¡Œ

#define    CV_E_INVALIDARG -1            ///< æ— æ•ˆå‚æ•°
#define    CV_E_HANDLE -2                ///< å¥æŸ„错误
#define    CV_E_OUTOFMEMORY -3            ///< å†…存不足
#define    CV_E_FAIL -4                ///< è¿è¡Œå¤±è´¥ï¼Œå†…部错误
#define    CV_E_DELNOTFOUND -5            ///< å®šä¹‰ç¼ºå¤±
#define    CV_E_INVALID_PIXEL_FORMAT -6        ///< ä¸æ”¯æŒçš„图像格式
#define    CV_E_FILE_NOT_FOUND -7            ///< æ–‡ä»¶ä¸å­˜åœ¨
#define    CV_E_INVALID_FILE_FORMAT -8        ///< æ¨¡åž‹æ ¼å¼ä¸æ­£ç¡®å¯¼è‡´åŠ è½½å¤±è´¥
#define    CV_E_FILE_EXPIRE -9            ///< æ¨¡åž‹æ–‡ä»¶è¿‡æœŸ

#define    CV_E_INVALID_AUTH -13            ///< license不合法
#define    CV_E_INVALID_APPID -14            ///< åŒ…名错误
#define    CV_E_AUTH_EXPIRE -15            ///< SDK过期
#define    CV_E_UUID_MISMATCH -16            ///< UUID不匹配
#define    CV_E_ONLINE_AUTH_CONNECT_FAIL -17    ///< åœ¨çº¿éªŒè¯è¿žæŽ¥å¤±è´¥
#define    CV_E_ONLINE_AUTH_TIMEOUT -18        ///< åœ¨çº¿éªŒè¯è¶…æ—¶
#define    CV_E_ONLINE_AUTH_INVALID -19        ///< åœ¨çº¿æ ¡éªŒå¤±è´¥
#define    CV_E_LICENSE_IS_NOT_ACTIVABLE -20    ///< license不可激活
#define    CV_E_ACTIVE_FAIL -21            ///< license激活失败
#define    CV_E_ACTIVE_CODE_INVALID -22        ///< æ¿€æ´»ç æ— æ•ˆ

#define    CV_E_UNSUPPORTED -1000            ///< ä¸æ”¯æŒçš„函数调用方式

#endif

 RtspFace/demo/models/verify.model

 RtspFace/demo/src/Makefile

 RtspFace/demo/src/faceAPI.cpp

 RtspFace/demo/src/faceAPI.h

 RtspFace/demo/src/faceDB.cpp

 RtspFace/demo/src/faceDB.h

 RtspFace/demo/src/out.db

Binary files differ

 RtspFace/demo/src/sample_face_track.cpp

 RtspFace/demo/src/test.cpp

 RtspFace/demo/src/test.sh

 RtspFace/demo/src/time_helper.h

 RtspFace/demo/н¨Îı¾Îĵµ.txt

File was deleted