valib/gosdk.git

// ***************************************************************
//  TH_PlateID.h   version:  4.0     date: 2010.4.12
//  -------------------------------------------------------------
//  Çå»ª´óÑ§ÖÇÄÜÍ¼ÎÄÐÅÏ¢´¦ÀíÑÐ¾¿ÊÒ¡£°æÈ¨ËùÓÐ¡£
//  -------------------------------------------------------------
//  Center for Intelligent Image and Document Information Processing
//  -------------------------------------------------------------
//  Copyright (C) 2007 - All Rights Reserved
// ***************************************************************
//   Author: Liu CS, Zhou J
// ***************************************************************
//        Revision history:
//            2010.4.12: v4.0, TH_PlateID³µÅÆÊ¶±ðSDKµÄ½Ó¿Ú
// ***************************************************************
 
#ifndef __TH_PLATEID_H_INCLUDE__
#define __TH_PLATEID_H_INCLUDE__
 
#if !defined(WIN32) && !defined(__stdcall)
#define __stdcall
#endif
 
#include "TH_ErrorDef.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
 
//³µÅÆÑÕÉ«
#define LC_UNKNOWN  0    // Î´Öª
#define LC_BLUE   1        // À¶É«
#define LC_YELLOW 2        // »ÆÉ«
#define LC_WHITE  3        // °×É«
#define LC_BLACK  4        // ºÚÉ«
#define LC_GREEN  5        // ÂÌÉ«
#define LC_YELLOWGREEN  6    //»ÆÂÌÉ«-´óÐÍÐÂÄÜÔ´³µÅÆÑÕÉ«
    
//³µÅÆÀàÐÍ
#define LT_UNKNOWN  0   //Î´Öª³µÅÆ
#define LT_BLUE     1   //À¶ÅÆ
#define LT_BLACK    2   //ºÚÅÆ
#define LT_YELLOW   3   //µ¥ÅÅ»ÆÅÆ
#define LT_YELLOW2  4   //Ë«ÅÅ»ÆÅÆ£¨´ó³µÎ²ÅÆ£¬Å©ÓÃ³µ£©
#define LT_POLICE   5   //¾¯³µ³µÅÆ
#define LT_ARMPOL   6   //Îä¾¯³µÅÆ
#define LT_INDIVI   7   //¸öÐÔ»¯³µÅÆ
#define LT_ARMY     8   //µ¥ÅÅ¾ü³µ
#define LT_ARMY2    9   //Ë«ÅÅ¾ü³µ
#define LT_EMBASSY  10  //Ê¹¹ÝÅÆ
#define LT_HONGKONG 11  //Ïã¸ÛÅÆ
#define LT_TRACTOR  12  //ÍÏÀ»ú
#define LT_MACAU    13  //°ÄÃÅÅÆ
#define LT_CHANGNEI 14  //³§ÄÚÅÆ
#define LT_MINHANG  15  //Ãñº½ÅÆ
#define LT_CONSULATE 16 //ÁìÊÂ¹Ý³µÅÆ
#define LT_NEWENERGY 17 //ÐÂÄÜÔ´³µÅÆ-Ð¡ÐÍ³µ
#define LT_NEWENERGY2 18 //ÐÂÄÜÔ´³µÅÆ-´óÐÍ³µ
 
//³µÁ¾ÑÕÉ«
#define LGRAY_DARK    0    //Éî
#define LGRAY_LIGHT    1    //Ç³
 
#define LCOLOUR_WHITE    0    //°×    
#define LCOLOUR_SILVER    1    //»Ò(Òø)
#define LCOLOUR_YELLOW    2    //»Æ
#define LCOLOUR_PINK    3    //·Û
#define LCOLOUR_RED        4    //ºì
#define LCOLOUR_GREEN    5    //ÂÌ
#define LCOLOUR_BLUE    6    //À¶
#define LCOLOUR_BROWN    7    //×Ø 
#define LCOLOUR_BLACK    8    //ºÚ
 
 
//ÔË¶¯·½Ïò
#define DIRECTION_UNKNOWN    0
#define DIRECTION_LEFT    1
#define DIRECTION_RIGHT    2
#define DIRECTION_UP    3
#define DIRECTION_DOWN    4
 
//Í¼Ïñ¸ñÊ½£¨TH_SetImageFormatº¯ÊýµÄcImageFormat²ÎÊý£©
#define ImageFormatRGB        0            //RGBRGBRGB...
#define ImageFormatBGR        1            //BGRBGRBGR...
#define ImageFormatYUV422    2            //YYYY...UU...VV..    (YV16)
#define ImageFormatYUV420COMPASS 3        //YYYY...UV...        (NV12)
#define ImageFormatYUV420    4            //YYYY...U...V...    (YU12)
#define ImageFormatUYVY        5            //UYVYUYVYUYVY...    (UYVY)
#define ImageFormatNV21        6            //YYYY...VU...        (NV21)
#define ImageFormatYV12        7            //YYYY...V...U        (YV12)
#define ImageFormatNV16     8           //YYYY...UVUV...    (NV16»òYUV422SP) UVÁÐ·½Ïò³éÑù£¬ÐÐ·½Ïò²»±ä 
 
//³µÅÆÀàÐÍÖ§³ÖÉèÖÃ¶¨Òå
//£¨TH_SetEnabledPlateFormatº¯ÊýµÄdFormat²ÎÊý£©
#define PARAM_INDIVIDUAL_ON          0        // ¸öÐÔ»¯³µÅÆ¿ªÆô
#define PARAM_INDIVIDUAL_OFF         1        // ¸öÐÔ»¯³µÅÆ¹Ø±Õ
#define PARAM_TWOROWYELLOW_ON         2        // Ë«²ã»ÆÉ«³µÅÆ¿ªÆô
#define PARAM_TWOROWYELLOW_OFF         3        // Ë«²ã»ÆÉ«³µÅÆ¹Ø±Õ
#define PARAM_ARMPOLICE_ON           4        // µ¥²ãÎä¾¯³µÅÆ¿ªÆô
#define PARAM_ARMPOLICE_OFF          5        // µ¥²ãÎä¾¯³µÅÆ¹Ø±Õ
#define PARAM_TWOROWARMY_ON          6        // Ë«²ã¾ü¶Ó³µÅÆ¿ªÆô
#define PARAM_TWOROWARMY_OFF         7        // Ë«²ã¾ü¶Ó³µÅÆ¹Ø±Õ
#define PARAM_TRACTOR_ON             8        // Å©ÓÃ³µ³µÅÆ¿ªÆô
#define PARAM_TRACTOR_OFF             9        // Å©ÓÃ³µ³µÅÆ¹Ø±Õ
#define PARAM_ONLY_TWOROWYELLOW_ON   10        // Ö»Ê¶±ðË«²ã»ÆÅÆ¿ªÆô
#define PARAM_ONLY_TWOROWYELLOW_OFF  11        // Ö»Ê¶±ðË«²ã»ÆÅÆ¹Ø±Õ
#define PARAM_EMBASSY_ON             12        // Ê¹¹Ý³µÅÆ¿ªÆô
#define PARAM_EMBASSY_OFF             13        // Ê¹¹Ý³µÅÆ¹Ø±Õ
#define PARAM_ONLY_LOCATION_ON         14        // Ö»¶¨Î»³µÅÆ¿ªÆô
#define PARAM_ONLY_LOCATION_OFF         15        // Ö»¶¨Î»³µÅÆ¹Ø±Õ
#define PARAM_ARMPOLICE2_ON             16        // Ë«²ãÎä¾¯³µÅÆ¿ªÆô
#define PARAM_ARMPOLICE2_OFF         17        // Ë«²ãÎä¾¯³µÅÆ¹Ø±Õ
#define PARAM_CHANGNEI_ON             18        // ³§ÄÚ³µÅÆ¿ªÆô
#define PARAM_CHANGNEI_OFF             19        // ³§ÄÚ³µÅÆ¹Ø±Õ
#define PARAM_MINHANG_ON             20        // Ãñº½³µÅÆ¿ªÆô
#define PARAM_MINHANG_OFF             21        // Ãñº½³µÅÆ¹Ø±Õ
#define PARAM_CONSULATE_ON           22     // ÁìÊÂ¹Ý³µÅÆ¿ªÆô
#define PARAM_CONSULATE_OFF          23     // ÁìÊÂ¹Ý³µÅÆ¹Ø±Õ
#define PARAM_NEWENERGY_ON           24     // ÐÂÄÜÔ´³µÅÆ¿ªÆô
#define PARAM_NEWENERGY_OFF          25     // ÐÂÄÜÔ´³µÅÆ¹Ø±Õ
 
#define RECOG_STAGE_ALL            0        // ÎÞ´íÎó
#define RECOG_STAGE_FINDPLATE    1        // Ã»ÓÐÕÒµ½³µÅÆ
#define RECOG_STAGE_PLATESCORE_ZERO    2    // ³µÅÆÆÀ¼ÛÖµ(0·Ö)
#define RECOG_STAGE_PLATESCORE_LOW    3    // ³µÅÆÆÀ¼ÛÖµ(²»¼°¸ñ)
#define RECOG_STAGE_RECOGSCORE_ZERO    4    // ³µÅÆÊ¶±ð·ÖÊý(0·Ö)
#define RECOG_STAGE_RECOGSCORE_LOW    5    // ³µÅÆÊ¶±ð·ÖÊý(²»¼°¸ñ)
 
    
//³µ±êÀàÐÍ
#define CarLogo_UNKNOWN       0    //Î´Öª
#define CarLogo_AUDI          1    //°ÂµÏ
#define CarLogo_BMW           2    //±¦Âí
#define CarLogo_BENZ          3    //±¼³Û
#define CarLogo_HONDA         4    //±¾Ìï
#define CarLogo_PEUGEOT       5    //±êÖ¾
#define CarLogo_BUICK         6    //±ð¿Ë
#define CarLogo_DASAUTO       7    //´óÖÚ
#define CarLogo_TOYOTA        8    //·áÌï
#define CarLogo_FORD          9    //¸£ÌØ
#define CarLogo_SUZUKI        10   //ÁåÄ¾
#define CarLogo_MAZDA         11   //Âí×Ô´ï
#define CarLogo_KIA           12   //ÆðÑÇ
#define CarLogo_NISSAN        13   //ÈÕ²úÄáÉ£
#define CarLogo_HYUNDAI       14   //ÏÖ´ú
#define CarLogo_CHEVROLET     15   //Ñ©·ðÀ¼
#define CarLogo_CITROEN       16   //Ñ©ÌúÁú
 
#define CarLogo_QIRUI         17   //ÆæÈð
#define CarLogo_WULING        18   //ÎåÁâ
#define CarLogo_DONGFENG      19   //¶«·ç
#define CarLogo_JIANGHUAI     20   //½»´
#define CarLogo_BEIQI         21   //±±Æû
#define CarLogo_CHANGAN       22   //³¤°²
#define CarLogo_AOCHI         23   //°Â³Û
#define CarLogo_SHAOLING      24   //ÉÙÁÖ
#define CarLogo_SHANQI        25   //ÉÂÆû
#define CarLogo_SANLING       26   //ÈýÁâ
#define CarLogo_JILI          27   //¼ªÀû
#define CarLogo_HAOWO         28   //ºÀÎÖ
#define CarLogo_HAIMA         29   //º£Âí
#define CarLogo_HAFEI         30   //¹þ·É
#define CarLogo_CHANGCHENG    31   //³¤³Ç
#define CarLogo_FUTIAN        32   //¸£Ìï
#define CarLogo_NANJUN        33   //ÄÏ¿¥
#define CarLogo_LIUQI         34   //ÁøÆû
 
// ³µÁ¾ÀàÐÍ
#define CARTYPE_UNKNOWN        0    // Î´Öª
#define CARTYPE_SALOON        1    // ½Î³µ
#define CARTYPE_VAN            2    // Ãæ°ü³µ
 
typedef struct TH_RECT
{
    int left;
    int top;
    int right;
    int bottom;
}TH_RECT;
 
 
typedef struct TH_PlateIDCfg
{
    int nMinPlateWidth;                    // ¼ì²âµÄ×îÐ¡³µÅÆ¿í¶È£¬ÒÔÏñËØÎªµ¥Î»
    int nMaxPlateWidth;                    // ¼ì²âµÄ×î´ó³µÅÆ¿í¶È£¬ÒÔÏñËØÎªµ¥Î»
    
    int nMaxImageWidth;                    // ×î´óÍ¼Ïñ¿í¶È
    int nMaxImageHeight;                // ×î´óÍ¼Ïñ¸ß¶È
 
    unsigned char bVertCompress;        // ÊÇ·ñ´¹Ö±·½ÏòÑ¹Ëõ1±¶ºóÊ¶±ð
    unsigned char bIsFieldImage;        // ÊÇ·ñÊÇ³¡Í¼Ïñ
    unsigned char bOutputSingleFrame;    // ÊÇ·ñÊÓÆµÍ¼ÏñÖÐÍ¬Ò»¸ö³µµÄ¶à·ùÍ¼ÏñÖ»Êä³öÒ»´Î½á¹û        
    unsigned char bMovingImage;            // Ê¶±ðÔË¶¯or¾²Ö¹Í¼Ïñ
 
    unsigned char bIsNight;
    unsigned char nImageFormat;
 
    unsigned char * pFastMemory;        // DSPµÈµÄÆ¬ÄÚÄÚ´æ£¬ºÄÊ±¶àµÄÔËËãÓÅÏÈÊ¹ÓÃÕâÐ©ÄÚ´æ
    int nFastMemorySize;                // ¿ìËÙÄÚ´æµÄ´óÐ¡
 
    unsigned char *pMemory;                // ÆÕÍ¨ÄÚ´æµÄµØÖ·£¬ÄÚ½¨µÄÄÚ´æ¹ÜÀí£¬±ÜÃâÄÚ´æÐ¹Â©µÈÎÊÌâ
    int nMemorySize;                    // ÆÕÍ¨ÄÚ´æµÄ´óÐ¡
 
    int (*DMA_DataCopy)(void *dst, void *src,int nSize);
    int (*Check_DMA_Finished)();
 
    int nLastError;            // ÓÃÓÚ´«µÝ´íÎóÐÅÏ¢
                            // 0: ÎÞ´íÎó
                            // 1: FindPlate(Ã»ÓÐÕÒµ½³µÅÆ)
                            // 2: ³µÅÆÆÀ¼ÛÖµ(0·Ö)
                            // 3: ³µÅÆÆÀ¼ÛÖµ(²»¼°¸ñ)
                            // 4: ³µÅÆÊ¶±ð·ÖÊý(0·Ö)
                            // 5: ³µÅÆÊ¶±ð·ÖÊý(²»¼°¸ñ)
    int nErrorModelSN;        // ³ö´íµÄÄ£¿é±àºÅ
    unsigned char nOrderOpt;            //Êä³öË³ÐòÑ¡Ïî 0-ÖÃÐÅ¶È 1-×ÔÉÏ¶øÏÂ 2-×ÔÏÂ¶øÉÏ
    unsigned char bLeanCorrection;        // ÊÇ·ñÆôÓÃ³µÅÆÐý×ª¹¦ÄÜ£¬Ä¬ÈÏ¿ªÆô
    unsigned char bMovingOutputOpt;       // 0-ÄÚ²¿ÍÆËÍ+Íâ²¿»ñÈ¡ 1:Íâ²¿»ñÈ¡    
    unsigned char nImproveSpeed;        // 0: Ê¶±ðÂÊÓÅÏÈ 1:Ê¶±ðËÙ¶ÈÓÅÏÈ
    unsigned char bCarLogo;             // 0: ²»¼ì²â³µ±ê 1: ¼ì²â³µ±ê
    unsigned char bLotDetect;            // 0: ²»¼ì²â³µÎ» 1: ¼ì²â³µÎ»
 
    unsigned char bShadow;              // 0: Õë¶ÔÎÞÒõÓ°µÄ³µÅÆ 1£ºÕë¶ÔÓÐÒõÓ°µÄ³µÅÆ£¬Ä¬ÈÏ¿ªÆô
    unsigned char bUTF8;                // 0:ºº×ÖGBK,1:ºº×ÖUTF-8
    unsigned char bShieldRailing;        // 0: ÆÁ±ÎÀ¸¸Ë¸ÉÈÅ£¬ 1:²»ÆÁ±ÎÀ¸¸Ë¸ÉÈÅ
    unsigned char bCarModel;        // 0: ²»Ê¶±ð³µÐÍ£¬ 1: Ê¶±ð³µÐÍ
    //char reserved[110];                // WIN_X86
    char reserved[110+128];                // WIN_X64
 
}TH_PlateIDCfg;
 
 
typedef struct TH_PlateIDResult 
{
    char license[16];    // ³µÅÆ×Ö·û´®
    char color[8];        // ³µÅÆÑÕÉ«
 
    int nColor;            // ³µÅÆÑÕÉ«
    int nType;            // ³µÅÆÀàÐÍ
    int nConfidence;    // ÕûÅÆ¿ÉÐÅ¶È
    int nBright;        // ÁÁ¶ÈÆÀ¼Û
    int nDirection;        // ³µÅÆÔË¶¯·½Ïò£¬0 unknown, 1 left, 2 right, 3 up, 4 down 
    
    TH_RECT rcLocation;                // ³µÅÆ×ø±ê
    const unsigned char *pbyBits;    /* ¸ÃÊ¶±ð½á¹û¶ÔÓ¦µÄÍ¼Æ¬µÄ»º³åÇø, Ö»ÓÐµ± bOutputSingleFrame = true Ê±£¬¸ÃÖ¸Õë²ÅÓÐÐ§¡£
                                    ÏÂ´ÎÊ¶±ðºó£¬¸Ã»º³åÇøÄÚÈÝ±»¸²¸Ç¡£µ÷ÓÃ³ÌÐòÎÞÐèÊÍ·Å¸Ã»º³åÇø¡£
                                    »º³åÇø´óÐ¡µÈÓÚ´«µÝ½øÀ´µÄÍ¼Æ¬Êý¾ÝµÄ³¤¶È*/
    int nTime;                        // Ê¶±ðºÄÊ±
    unsigned char nCarBright;        //³µµÄÁÁ¶È
    unsigned char nCarColor;        //³µµÄÑÕÉ«
    unsigned char nCarLogo;         //³µ±êÀàÐÍ
    unsigned char nCarType;            //³µÁ¾ÀàÐÍ
    unsigned char *pbyPlateBin;     //³µÅÆ¶þÖµ»¯½á¹û£¨°´bit´æ´¢£©
    unsigned short nBinPlateWidth;  //¶þÖµ»¯½á¹ûÖÐ³µÅÆ¿í¶È
    unsigned short nBinPlateHeight; //¶þÖµ»¯½á¹ûÖÐ³µÅÆ¸ß¶È
    char reserved[70];                //±£Áô
    TH_RECT rcLogoLocation;            // ³µ±ê×ø±ê
    unsigned short nCarModel;        // ³µÁ¾ÀàÐÍ
    unsigned short nCarModelConfidence;        //³µÐÍ¿ÉÐÅ¶È    
}TH_PlateIDResult;
 
 
/************************************************************************/
/* TH_InitPlateIDSDK: ³õÊ¼»¯³µÅÆÊ¶±ðSDK£¬ÔÚÊ¹ÓÃ¸ÃSDKµÄ¹¦ÄÜÇ°            */
/*            ±ØÐèÇÒ½öÐèµ÷ÓÃÒ»´Î¸Ãº¯Êý                                    */
/*        Parameters:                                                        */
/*            pPlateConfig[in]: ³µÅÆÊ¶±ðSDKµÄÅäÖÃ                            */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_InitPlateIDSDK(TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_UninitPlateIDSDK: ÊÍ·Å³µÅÆÊ¶±ðSDK£¬ÔÚÊ¹ÓÃ¸ÃSDKµÄ¹¦ÄÜºó            */
/*            ±ØÐèÇÒ½öÐèµ÷ÓÃÒ»´Î¸Ãº¯Êý£¬ÒÔÊÍ·ÅÄÚ´æ¡£                        */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_UninitPlateIDSDK(TH_PlateIDCfg *pPlateCfg);
 
/************************************************************************/
/* TH_RecogImage: Ê¶±ðÄÚ´æÖÐ³µÅÆÍ¼Ïñ(Êä³öÊ¶±ðµ½µÄ¶à¸ö½á¹û)    */
/*        Parameters:                                                        */
/*            pbyBits[in]: Ö¸ÏòÄÚ´æÍ¼ÏñÊý¾ÝµÄÖ¸Õë£¬3¸ö×Ö½Ú±íÊ¾1¸öÏñËØ        */
/*            nWidth[in]: Í¼ÏñµÄ¿í¶È                                        */
/*            nHeight[in]: Í¼ÏñµÄ¸ß¶È                                        */
/*            pResult[out]: ³µÅÆÊ¶±ð½á¹ûÊý×é, µ÷ÓÃ·½¿ª±ÙpResult[nResultNum]ÄÚ´æ*/
/*            nResultNum[in,out]: in ×î´óºòÑ¡³µÅÆ¸öÊý£¬out Ê¶±ð³öµÄ³µÅÆ¸öÊý*/
/*            prcRange[in]: Ö¸¶¨Ê¶±ð·¶Î§                                    */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_RecogImage(const unsigned char *pbyBits, int nWidth, int nHeight, TH_PlateIDResult *pResult,
    int *nResultNum, const TH_RECT *prcRange, TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_EvaluateCarColor: Ê¶±ð³µµÄÑÕÉ«                                    */
/*        Parameters:                                                        */
/*            pbyBits[in]: Ö¸ÏòÄÚ´æÍ¼ÏñÊý¾ÝµÄÖ¸Õë£¬3¸ö×Ö½Ú±íÊ¾1¸öÏñËØ        */
/*            nWidth[in]: Í¼ÏñµÄ¿í¶È                                        */
/*            nHeight[in]: Í¼ÏñµÄ¸ß¶È                                        */
/*            pResult[out]: ³µÅÆÊ¶±ð½á¹ûÊý×é, µ÷ÓÃ·½¿ª±ÙpResult[nResultNum]ÄÚ´æ*/
/*            nResultNum[in,out]: in ×î´óºòÑ¡³µÅÆ¸öÊý£¬out Ê¶±ð³öµÄ³µÅÆ¸öÊý*/
/*            prcRange[in]: Ö¸¶¨Ê¶±ð·¶Î§                                    */
/*        Return Value: int(ERR_Code)                                        */
/*        TH_EvaluateCarColor½ô½ÓTH_RecogImageÖ®ºóµ÷ÓÃ£¬±£³Ö²ÎÊý²»±ä        */
/************************************************************************/
int __stdcall TH_EvaluateCarColor(const unsigned char *pbyBits, int nWidth, int nHeight, TH_PlateIDResult *pResult,
    int *nResultNum, const TH_RECT *prcRange, TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_SetImageFormat: ÉèÖÃÍ¼Ïñ¸ñÊ½                                        */
/*        Parameters:                                                        */
/*            cImageFormat[in]: Í¼Ïñ¸ñÊ½                                    */
/*            bVertFlip[in]: ÊÇ·ñµßµ¹                                        */
/*            bDwordAligned[in]: ÊÇ·ñ4×Ö½Ú¶ÔÆë                            */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetImageFormat( unsigned char cImageFormat, unsigned char bVertFlip, unsigned char bDwordAligned, TH_PlateIDCfg *pPlateConfig );
 
/************************************************************************/
/* TH_SetEnabledPlateFormat: ÉèÖÃÖ§³ÖµÄ³µÅÆÀàÐÍ                            */
/*        Parameters:                                                        */
/*            dFormat[in]: ³µÅÆÀàÐÍ¿ª¹Ø£¬ÀýÈçPARAM_INDIVIDUAL_ON            */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetEnabledPlateFormat(unsigned int dFormat, TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_SetProvinceOrder: ÉèÖÃÊ¡·Ý×Ö·û´®                                    */
/*        Parameters:                                                        */
/*            szProvince[in]: Ä¬ÈÏÊ¡·Ý×Ö·û´®£¬ÀýÈç"¾©½ò¼½"£¬×î¶àÖ§³Ö8¸öÊ¡·Ý*/
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetProvinceOrder( char* szProvince, TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_SetRecogThreshold: ÉèÖÃÊ¶±ðãÐÖµ                                    */
/*        Parameters:                                                        */
/*            nPlateLocate_Th[in]: 0 - 9        --   7: Ä¬ÈÏãÐÖµ            */
/*                    nOCR_Th[in]: 0 - 9        --   5: Ä¬ÈÏãÐÖµ            */
/*                0: ×î¿íËÉµÄãÐÖµ                                            */
/*                9:×îÑÏ¸ñµÄãÐÖµ                                            */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetRecogThreshold( unsigned char nPlateLocate_Th, unsigned char nOCR_Th, TH_PlateIDCfg *pPlateCfg);
 
//¼ì²é¹¤×÷¹ý³ÌÖÐ×îÐ¡µÄÊ£ÓàÄÚ´æ£¬Èç¹û³öÏÖ¸ºÊý£¬ÔòÐèÒªÔö¼Ó¸ø¶¨µÄ³õÊ¼ÄÚ´æ
int __stdcall TH_CheckMinFreeMemory( int *pnMinFreeSRAM, int *pnMinFreeSDRAM, TH_PlateIDCfg *pPlateCfg);
 
/************************************************************************/
/* ¹¦ÄÜ: »ñÈ¡°æ±¾ºÅ                                                        */
/*        Parameters£ºÎÞ                                                    */
/*        ·µ»ØÖµ: ×Ö·û´® ¸ñÊ½£ºÖ÷°æ±¾ºÅ.¸±°æ±¾ºÅ.ÐÞ¶©ºÅ.±àÒëºÅ            */
/*                ²»ÓÃÊÍ·Å¸ÃÖ¸Õë¡£                                        */
/************************************************************************/
const char * __stdcall TH_GetVersion();
 
/************************************************************************/
/* ¹¦ÄÜ: »ñÈ¡¼ÓÃÜËøID, ¼ÓÃÜËøIDÊÇ8×Ö½ÚÎ¨Ò»ID£¬                            */
/*        µ÷ÓÃ´Ëº¯ÊýÇ°ÐèÒªµ÷ÓÃTH_InitPlateIDSDK                            */
/*        Parameters£º´æÔÚÎ¨Ò»IDÊ±£¬ID1ÊÇÇ°4×Ö½Ú,ID2ÊÇºóËÄ×Ö½Ú            */
/*        ·µ»ØÖµ: 0-ÓÐÎ¨Ò»ID                                                */
/*                1-ÎÞÎ¨Ò»ID                                                */
/************************************************************************/
int __stdcall TH_GetKeyID(unsigned int* ID1, unsigned int* ID2);
 
/************************************************************************/
/* ¹¦ÄÜ: »ñÈ¡¼ÓÃÜËøÂ·ÊýÐÅÏ¢£¬                                            */
/*        Ê¹ÓÃTH_InitPlateIDSDKÇ°µ÷ÓÃ´Ëº¯Êý                                */
/*        Parameters£ºnMaxThread[out]:                                    */
/*        ·µ»ØÖµ:  int(ERR_Code)                                            */
/************************************************************************/
int __stdcall TH_GetKeyMaxThread(int* nMaxThread);
 
 
/************************************************************************/
/* ¹¦ÄÜ: ÉèÖÃµ±Ç°Ê¶±ðµÄ¶Ô±È¶ÈãÐÖµ                                        */
/*        Parameters£ºnContrast[int]:                                        */
/*        ¶Ô±È¶ÈÖ¸Êý nContrast[in]: 0 - 9                                    */
/*        ×îÄ£ºýÊ±ÉèÎª1;×îÇåÎúÊ±ÉèÎª9;×Ô¶¯Ì½²âÉèÎª0;Ä¬ÈÏÖµÎª0                */
/*        ·µ»ØÖµ:  int(ERR_Code)                                            */
/************************************************************************/
int __stdcall TH_SetContrast( unsigned char nContrast, TH_PlateIDCfg *pPlateCfg );
                                                                            
 
 
/************************************************************************/
/* TH_SetEnableCarTypeClassify: ÉèÖÃÊÇ·ñ³µÁ¾ÀàÐÍÅÐ±ð                    */
/*        Parameters:                                                        */
/*            bCarTypeClass[in]: true:³µÐÍ·ÖÀà;                            */
/*                                false:²»½øÐÐ³µÐÍ·ÖÀà                    */
/*        Return Value: int(ERR_Code)                                        */
/*        Ö§³Ö¸ñÊ½: ImageFormatBGR, ImageFormatRGB,ImageFormatYUV422,
                ImageFormatUYVY,ImageFormatNV21*/
/************************************************************************/
int __stdcall TH_SetEnableCarTypeClassify( unsigned char bCarTypeClass, TH_PlateIDCfg *pPlateCfg);
 
 
/************************************************************************/
/* TH_SetEnableCarLogo: ÉèÖÃÊÇ·ñ³µ±êÊ¶±ð                                */
/*        Parameters:                                                        */
/*            bCarLogo[in]: true:³µ±êÊ¶±ð;                                */
/*                                false:²»½øÐÐ³µ±êÊ¶±ð                    */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetEnableCarLogo( unsigned char bCarLogo, TH_PlateIDCfg *pPlateCfg);
 
/************************************************************************/
/* TH_SetEnableCarWidth: ÉèÖÃÊÇ·ñ²âÁ¿³µÁ¾¿í¶È                            */
/*        Parameters:                                                        */
/*            bCarLogo[in]: true:²âÁ¿³µÁ¾¿í¶È;                            */
/*                            false:²»²âÁ¿³µÁ¾¿í¶È                        */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetEnableCarWidth( unsigned char bCarWidth, TH_PlateIDCfg *pPlateCfg);
 
int __stdcall TH_SetReserveInfo(unsigned char* pSN);
int __stdcall TH_SetTFInfo(int Num, char *pTF);
 
// TH_SetDayNightMode: V4.3.13.0ÒÔºóº¯ÊýÎÞÊµ¼ÊÒâÒå£¬Îª±£Ö¤¼æÈÝÐÔ±£Áô´Ëº¯Êý
int __stdcall TH_SetDayNightMode( unsigned char bIsNight, TH_PlateIDCfg *pPlateConfig);
 
/************************************************************************/
/* TH_SetVideoModeOutPutPosRatio: ÉèÖÃÊÓÆµÄ£Ê½³µÅÆÊä³öÎ»ÖÃÏµÊý                */
/*        Parameters:                                                        */
/*            ratio[in]: (0.1, 0.9);                                        */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetVideoModeOutPutPosRatio(float ratio);
 
/************************************************************************/
/* TH_GetVehicleModelName: Êä³ö³µÐÍ×Ö·û´®£¬ÔÚµ÷ÓÃTH_RecogImageºóµ÷ÓÃ¸Ãº¯Êý*/
/*        Parameters:                                                        */
/*            nModel[in]: ³µÐÍÀàÐÍÖµ£¬TH_PlateIDResult½á¹¹ÌåÖÐµÄnCarModel;*/
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
const char *  __stdcall TH_GetVehicleModelName(int nModel);
 
/************************************************************************/
/* TH_SetEnableLeanCorrection: ÉèÖÃÊÇ·ñ´ò¿ªÇãÐ±Ð£Õý                                */
/*        Parameters:                                                        */
/*            bLeanCorrection[in]: true:´ò¿ªÇãÐ±Ð£Õý;                                */
/*                                 false:¹Ø±ÕÇãÐ±Ð£Õý                    */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetEnableLeanCorrection( unsigned char bLeanCorrection, TH_PlateIDCfg *pPlateCfg);
 
/************************************************************************/
/* TH_SetEnableShadow: ÉèÖÃÊÇ·ñ´ò¿ªÒõÑôÅÆÊ¶±ð                                */
/*        Parameters:                                                        */
/*            bShadow[in]: true:´ò¿ªÒõÑôÅÆ;                                */
/*                         false:¹Ø±ÕÒõÑôÅÆ                    */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetEnableShadow( unsigned char bShadow, TH_PlateIDCfg *pPlateCfg);
 
/************************************************************************/
/* TH_GetLicenseNum: »ñÈ¡ÍøÂç¼ÓÃÜËøÐí¿ÉÊýÁ¿                                */
/*        Parameters:                                                        */
/*            pnTotalNum[out]:    Ðí¿É×ÜÊý;                                */
/*            pnRemainingNum1[out]:    ·þÎñÆ÷Ò»Ê£ÓàÐí¿ÉÊý                    */
/*            pnRemainingNum2[out]:    ·þÎñÆ÷¶þÊ£ÓàÐí¿ÉÊý                    */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_GetLicenseNum(int *pnTotalNum, int *pnRemainingNum1, int *pnRemainingNum2);
 
/************************************************************************/
/* TH_SetServer:                                */
/*        Parameters:                                                        */
/*            pServer1[in]: server 1 : 192.168.0.10                                */
/*            pServer2[in]: server 2 : 192.168.0.11                */
/*                                */
/*        Return Value: int(ERR_Code)                                        */
/************************************************************************/
int __stdcall TH_SetServer(const char *pServer1, const char *pServer2);
 
int __stdcall TH_SetSoPath(char *pSoPath);
 
#ifdef __cplusplus
}
#endif
 
#endif    //    __TH_PLATEID_H_INCLUDE__