【臻识车牌识别机】臻识 打开道闸方法

于 2023-09-27 12:09:46 发布
阅读量849 收藏
点赞数
分类专栏： 物联网 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44836497/article/details/133345540
版权

初始化车牌号登录操作


 	//返回结果
    public long handle =0;
    public static LPRSDK lpr = LPRSDK.INSTANCE;
    public static LPRPlateUtil.VZLPRC_PLATE_INFO_CALLBACK PlateCallBack = new LPRPlateUtil.VZLPRC_PLATE_INFO_CALLBACK();


public void InitClient(String ip,int port,String account,String password) {
        try {
            lpr.VzLPRClient_Setup();
            //打开设备连接
            handle = lpr.VzLPRClient_Open(ip, port, account, password);
            lpr.VzLPRClient_SetPlateInfoCallBack(handle, PlateCallBack, Pointer.NULL, 1);
        } catch (Exception e) {
           e.printStackTrace();
        }
    }

车牌识别回调


  public static class VZLPRC_PLATE_INFO_CALLBACK implements LPRSDK.VZLPRC_PLATE_INFO_CALLBACK{
        public void invoke(long handle,Pointer pUserData,LPRSDK.TH_PlateResult_Pointer.ByReference pResult,int uNumPlates,
                           int eResultType,LPRSDK.VZ_LPRC_IMAGE_INFO_Pointer.ByReference pImgFull,LPRSDK.VZ_LPRC_IMAGE_INFO_Pointer.ByReference pImgPlateClip) {
            int type = LPRSDK.VZ_LPRC_RESULT_TYPE.VZ_LPRC_RESULT_REALTIME.ordinal();
            if (eResultType != type) {
                byte[] device_ip = new byte[32];
                lpr.VzLPRClient_GetDeviceIP(handle, device_ip, 32);
                String deviceIp = new String(device_ip).trim();
                log.info("车牌识别deviceIp：{}",deviceIp);
                try {
                    String license = new String(pResult.license, "gb2312");
                    int index = license.indexOf("\0");
                    if (index > 0) {
                        license = license.substring(0, index);
                    }
                    String strString = BeanTools.GetStrChinese(license) + BeanTools.GetStrNumberEnglish(license);
                    log.info("车牌识别结果：{},设备ip:{}",license,deviceIp);
                    if (!strString.contains("无")) {
                    	// TODO 业务处理成功后，调用打开道闸
                    	// ------------------处理业务 ------------------
                     }
                    } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

打开道闸方法

 	/**
     * 打开道闸 设置io输出，并自动复位
     * @param tdh io输出的通道号，从0开始
     * @return 0表示成功 -1表示失败
     */
    public int openDZ(int tdh){
        // handle 为上述登录结果handle
        int res = lpr.VzLPRClient_SetIOOutputAuto(handle, tdh, 1000);
        return res;
    }

附 BeanTools

public class BeanTools {

    public static final SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd");

    private static final char[] HEX_CHAR = {'0', '1', '2', '3', '4', '5','6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'};


    /**
     * @Author xiaobai
     * @Description TODO 获取字符串中的中文
     * @Date 4:03 2023/8/19
     *
     **/
    public static String GetStrChinese(String str) {
        String regEx="[^\\u4e00-\\u9fa5]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }

    /**
     * @Author xiaobai
     * @Description TODO 获取字符串中的数字+英文
     * @Date 4:03 2023/8/19
     *
     **/
    public  static String GetStrNumberEnglish(String str) {
        String regEx="[^0-9A-Za-z]";
        Pattern p = Pattern.compile(regEx);
        Matcher m = p.matcher(str);
        return m.replaceAll("").trim();
    }
  }

附SDK

import com.sun.jna.*;
import com.sun.jna.ptr.ByteByReference;
import java.util.Arrays;
import java.util.List;

/**
 * @Author xiaobai
 * @Date 2023/9/27 11:12
 * @Description
 */
public interface LPRSDK extends Library {

    /**
     *
    * 加载SDK动态库
     *
     * */
    public static String setFilePath = "D:\\zs\\VzLPRSDK.dll";
    LPRSDK INSTANCE = (LPRSDK) Native.loadLibrary(setFilePath, LPRSDK.class);

    public static class VZ_LPRC_IMAGE_INFO_Pointer extends Structure {
        public int uWidth;
        public int uHeight;
        public int uPitch;
        public int uPixFmt;
        public ByteByReference pBuffer;

        public static class ByReference extends VZ_LPRC_IMAGE_INFO_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPRC_IMAGE_INFO_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"uWidth", "uHeight", "uPitch", "uPixFmt", "pBuffer"});
        }
    }

    public static class VZ_TM extends Structure {
        public short nYear;
        public short nMonth;
        public short nMDay;
        public short nHour;
        public short nMin;
        public short nSec;

        public static class ByReference extends VZ_TM implements Structure.ByReference {
        }

        public static class ByValue extends VZ_TM implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"nYear", "nMonth", "nMDay", "nHour", "nMin", "nSec"});
        }
    }

    public static class VZ_DATE_TIME_INFO extends Structure {
        public int uYear;
        public int nMonth;
        public int nMDay;
        public int nHour;
        public int nMin;
        public int nSec;

        public static class ByReference extends VZ_DATE_TIME_INFO implements Structure.ByReference {
        }

        public static class ByValue extends VZ_DATE_TIME_INFO implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"nYear", "nMonth", "nMDay", "nHour", "nMin", "nSec"});
        }
    }

    public static class VZ_LPR_WLIST_VEHICLE extends Structure {
        public int uVehicleID;
        public byte[] strPlateID = new byte[32];
        public int uCustomerID;
        public int bEnable;
        public int bEnableTMEnable;
        public int bEnableTMOverdule;
        public VZ_TM.ByValue struTMEnable;
        public VZ_TM.ByValue struTMOverdule;
        public int bUsingTimeSeg;
        public byte[] byTimeSegOrRange = new byte[228];
        public int bAlarm;
        public int iColor;
        public int iPlateType;
        public byte[] strCode = new byte[32];
        public byte[] strComment = new byte[64];

        public static class ByReference extends VZ_LPR_WLIST_VEHICLE implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_VEHICLE implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"uVehicleID", "strPlateID", "uCustomerID", "bEnable", "bEnableTMEnable", "bEnableTMOverdule", "struTMEnable", "struTMOverdule",
                    "bUsingTimeSeg", "byTimeSegOrRange", "bAlarm", "iColor", "iPlateType", "strCode", "strComment"});
        }
    }

    public static class VZ_LPR_WLIST_ROW extends Structure {
        public Pointer pCustomer;
        public VZ_LPR_WLIST_VEHICLE.ByReference pVehicle;

        public static class ByReference extends VZ_LPR_WLIST_ROW implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_ROW implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"pCustomer", "pVehicle"});
        }
    }

    public static class VZ_LPR_WLIST_CUSTOMER extends Structure {
        public int uCustomerID;
        public byte[] strName = new byte[32];
        public byte[] strCode = new byte[32];
        public byte[] reserved = new byte[256];

        public static class ByReference extends VZ_LPR_WLIST_CUSTOMER implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_CUSTOMER implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"uCustomerID", "strName", "strCode", "reserved"});
        }
    }


    public static class VZ_LPR_WLIST_IMPORT_RESULT extends Structure {
        public int ret;
        public int error_code;

        public static class ByReference extends VZ_LPR_WLIST_IMPORT_RESULT implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_IMPORT_RESULT implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"ret", "error_code"});
        }
    }

    public enum VZ_LPR_WLIST_LIMIT_TYPE {
        VZ_LPR_WLIST_LIMIT_TYPE_ONE,
        VZ_LPR_WLIST_LIMIT_TYPE_ALL,
        VZ_LPR_WLIST_LIMIT_TYPE_RANGE,
    }


    public static class VZ_LPR_WLIST_RANGE_LIMIT extends Structure {
        public int startIndex;
        public int count;

        public static class ByReference extends VZ_LPR_WLIST_RANGE_LIMIT implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_RANGE_LIMIT implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"startIndex", "count"});
        }
    }

    public static class VZ_LPR_WLIST_LIMIT extends Structure {
        public int limitType;
        public VZ_LPR_WLIST_RANGE_LIMIT.ByReference pRangeLimit;

        public static class ByReference extends VZ_LPR_WLIST_LIMIT implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_LIMIT implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"limitType", "pRangeLimit"});
        }
    }

    public enum VZ_LPR_WLIST_SEARCH_TYPE {
        VZ_LPR_WLIST_SEARCH_TYPE_LIKE,
        VZ_LPR_WLIST_SEARCH_TYPE_EQUAL
    }

    public static class VZ_LPR_WLIST_SEARCH_CONSTRAINT extends Structure {
        public byte[] key = new byte[32];
        public byte[] search_string = new byte[128];

        public static class ByReference extends VZ_LPR_WLIST_SEARCH_CONSTRAINT implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_SEARCH_CONSTRAINT implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"key", "search_string"});
        }
    }

    public static class VZ_LPR_WLIST_SEARCH_WHERE extends Structure {
        public int searchType;
        public int searchConstraintCount;
        public VZ_LPR_WLIST_SEARCH_CONSTRAINT.ByReference pSearchConstraints;

        public static class ByReference extends VZ_LPR_WLIST_SEARCH_WHERE implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_SEARCH_WHERE implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"searchType", "searchConstraintCount", "pSearchConstraints"});
        }
    }

    public static class VZ_LPR_WLIST_LOAD_CONDITIONS extends Structure {
        public VZ_LPR_WLIST_SEARCH_WHERE.ByReference pSearchWhere;
        public VZ_LPR_WLIST_LIMIT.ByReference pLimit;
        public Pointer pSortType;

        public static class ByReference extends VZ_LPR_WLIST_LOAD_CONDITIONS implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPR_WLIST_LOAD_CONDITIONS implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"pSearchWhere", "pLimit", "pSortType"});
        }
    }


    public enum VZ_LPRC_RESULT_TYPE {
        VZ_LPRC_RESULT_REALTIME,
        VZ_LPRC_RESULT_STABLE,
        VZ_LPRC_RESULT_FORCE_TRIGGER,
        VZ_LPRC_RESULT_IO_TRIGGER,
        VZ_LPRC_RESULT_VLOOP_TRIGGER,
        VZ_LPRC_RESULT_MULTI_TRIGGER,
        VZ_LPRC_RESULT_TYPE_NUM
    }

    public static class VZ_LPRC_VERTEX extends Structure {
        public int X_1000;
        public int Y_1000;

        public static class ByReference extends VZ_LPRC_VERTEX implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPRC_VERTEX implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"X_1000", "Y_1000"});
        }
    }

    public static class VZ_LPRC_VIRTUAL_LOOP_EX extends Structure {
        public byte byID;
        public byte byEnable;
        public byte byDraw;
        public byte byRes;
        public byte[] strName = new byte[32];
        public int uNumVertex;
        public VZ_LPRC_VERTEX[] struVertex = new VZ_LPRC_VERTEX[12];
        public int eCrossDir;
        public int uTriggerTimeGap;
        public int uMaxLPWidth;
        public int uMinLPWidth;

        public static class ByReference extends VZ_LPRC_VIRTUAL_LOOP_EX implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPRC_VIRTUAL_LOOP_EX implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"byID", "byEnable", "byDraw", "byRes", "strName", "uNumVertex", "struVertex", "eCrossDir", "uTriggerTimeGap", "uMaxLPWidth", "uMinLPWidth"});
        }
    }


    public static class VZ_LPRC_VIRTUAL_LOOPS_EX extends Structure {
        public int uNumVirtualLoop;
        public VZ_LPRC_VIRTUAL_LOOP_EX[] struLoop = new VZ_LPRC_VIRTUAL_LOOP_EX[8];

        public static class ByReference extends VZ_LPRC_VIRTUAL_LOOPS_EX implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPRC_VIRTUAL_LOOPS_EX implements Structure.ByValue {
        }

        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"uNumVirtualLoop", "struLoop"});
        }
    }


    public static class CarBrand_Pointer extends Structure {
        public byte brand;
        public byte type;
        public short year;

        public static class ByReference extends CarBrand_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends CarBrand_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"brand", "type", "year"});
        }
    }

    public static class TH_RECT_Pointer extends Structure {
        public int left;
        public int top;
        public int right;
        public int bottom;

        public static class ByReference extends TH_RECT_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends TH_RECT_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"left", "top", "right", "bottom"});
        }
    }

    public static class VZ_TIMEVAL_Pointer extends Structure {
        public int uTVSec;
        public int uTVUSec;

        public static class ByReference extends VZ_TIMEVAL_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends VZ_TIMEVAL_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"uTVSec", "uTVUSec"});
        }
    }


    public static class VzBDTime_Pointer extends Structure {
        public byte bdt_sec;
        public byte bdt_min;
        public byte bdt_hour;
        public byte bdt_mday;
        public byte bdt_mon;
        public byte[] res1 = new byte[3];
        public int bdt_year;
        public byte[] res2 = new byte[4];

        public static class ByReference extends VzBDTime_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends VzBDTime_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"bdt_sec", "bdt_min", "bdt_hour", "bdt_mday", "bdt_mon", "res1", "bdt_year", "res2"});
        }
    }

    public static class VZ_LPRC_OSD_Param extends Structure {
        public byte dstampenable;
        /**
         * 0 off 1 on
         */
        public int dateFormat;
        /**
         * 0:YYYY/MM/DD;1:MM/DD/YYYY;2:DD/MM/YYYY
         */
        public int datePosX;
        public int datePosY;
        public byte tstampenable;
        /**
         * 0 off 1 on
         */
        public int timeFormat;
        /**
         * 0:12Hrs;1:24Hrs
         */
        public int timePosX;
        public int timePosY;
        public byte nLogoEnable;
        /**
         * 0 off 1 on
         */
        public int nLogoPositionX;
        /**
         * <  logo position
         */
        public int nLogoPositionY;
        /**
         * <  logo position
         */
        public byte nTextEnable;
        /**
         * 0 off 1 on
         */
        public int nTextPositionX;
        /**
         * <  text position
         */
        public int nTextPositionY;
        /**
         * <  text position
         */
        public byte[] overlaytext = new byte[16];

        /**
         * user define text           	//user define text
         */

        public static class ByReference extends VZ_LPRC_OSD_Param implements Structure.ByReference {
        }

        public static class ByValue extends VZ_LPRC_OSD_Param implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"dstampenable", "dateFormat", "datePosX", "datePosY", "tstampenable", "timeFormat", "timePosX", "timePosY", "nLogoEnable", "nLogoPositionX", "nLogoPositionY",
                    "nTextEnable", "nTextPositionX", "nTextPositionY", "overlaytext"});
        }
    }


    public static class TH_PlateResult_Pointer extends Structure {
        public byte[] license = new byte[16];
        public byte[] color = new byte[8];
        public int nColor;
        public int nType;
        public int nConfidence;
        public int nBright;
        public int nDirection;
        public TH_RECT_Pointer.ByValue rcLocation;
        public int nTime;
        public VZ_TIMEVAL_Pointer.ByValue tvPTS;
        public int uBitsTrigType;
        public byte nCarBright;
        public byte nCarColor;
        public byte[] reserved0 = new byte[2];
        public int uId;
        public VzBDTime_Pointer.ByValue struBDTime;
        public byte nIsEncrypt;
        public byte nPlateTrueWidth;
        public byte nPlateDistance;
        public byte nIsFakePlate;
        public TH_RECT_Pointer.ByValue car_location;
        public CarBrand_Pointer.ByValue car_brand;
        public byte[] featureCode = new byte[20];
        public byte[] reserved = new byte[24];


        public static class ByReference extends TH_PlateResult_Pointer implements Structure.ByReference {
        }

        public static class ByValue extends TH_PlateResult_Pointer implements Structure.ByValue {
        }

        @Override
        protected List<String> getFieldOrder() {
            return Arrays.asList(new String[]{"license", "color", "nColor", "nType", "nConfidence", "nBright", "nDirection", "rcLocation", "nTime", "tvPTS", "uBitsTrigType", "nCarBright", "nCarColor",
                    "reserved0", "uId", "struBDTime", "nIsEncrypt", "nPlateTrueWidth", "nPlateDistance", "nIsFakePlate", "car_location", "car_brand", "featureCode", "reserved"});
        }
    }


    int VzLPRClient_Setup();


    void VzLPRClient_Cleanup();


    long VzLPRClient_Open(String pStrIP, int wPort, String pStrUserName, String pStrPassword);


    long VzLPRClient_OpenV2(String pStrIP, int wPort, String pStrUserName, String pStrPassword, int wRtspPort, int network_type, String sn);


    int VzLPRClient_Close(long handle);


    int VzLPRClient_IsConnected(long handle, byte[] pStatus);


    int VzLPRClient_SerialStart(long handle, int nSerialPort, VZDEV_SERIAL_RECV_DATA_CALLBACK func, Pointer pUserData);


    int VzLPRClient_SerialSend(int nSerialHandle, byte[] pData, int uSizeData);


    int VzLPRClient_SerialStop(int nSerialHandle);


    int VzLPRClient_SetIOOutputAuto(long handle, int uChnId, int nDuration);


    int VzLPRClient_WhiteListImportRows(long handle, int rowcount, VZ_LPR_WLIST_ROW.ByReference pRowDatas, VZ_LPR_WLIST_IMPORT_RESULT.ByReference pResults);


    int VzLPRClient_WhiteListInsertVehicle(long handle, VZ_LPR_WLIST_VEHICLE.ByReference pVehicle);


    int VzLPRClient_WhiteListClearCustomersAndVehicles(long handle);


    int VzLPRClient_SetPlateInfoCallBack(long handle, VZLPRC_PLATE_INFO_CALLBACK func, Pointer pUserData, int bEnableImage);


    int VzLPRClient_ImageSaveToJpeg(VZ_LPRC_IMAGE_INFO_Pointer.ByReference pImgInfo, String pFullPathName, int nQuality);


    int VzLPRClient_SetDateTime(long handle, VZ_DATE_TIME_INFO.ByReference pDTInfo);


    int VzLPRClient_LoadImageById(long handle, int id, byte[] pdata, int[] size);


    int VzLPRClient_WhiteListDeleteVehicle(long handle, byte[] strPlateID);


    int VzLPRClient_SetVirtualLoopEx(long handle, VZ_LPRC_VIRTUAL_LOOPS_EX.ByReference pVirtualLoops);


    int VzLPRClient_GetVirtualLoopEx(long handle, VZ_LPRC_VIRTUAL_LOOPS_EX.ByReference pVirtualLoops);


    int VzLPRClient_SetOsdParam(long handle, VZ_LPRC_OSD_Param.ByReference pParam);


    int VzLPRClient_GetOsdParam(long handle, VZ_LPRC_OSD_Param.ByReference pParam);


    int VzLPRClient_ForceTrigger(long handle);


    int VzLPRClient_GetDeviceIP(long handle, byte[] ip, int max_count);


    int VzLPRClient_SaveSnapImageToJpeg(long handle, String pFullPathName);


    int VzLPRClient_GetSnapImage(long handle, byte[] pDstBuf, int uSizeBuf);


    int VzLPRClient_TcpTransSend(long handle, String cmd_type, String cmd, byte[] response, int max_response_len);

    int VzLPRClient_SaveRealData(long handle, String sFileName);

    int VzLPRClient_StopSaveRealData(long handle);

    public static interface VZLPRC_PLATE_INFO_CALLBACK extends Callback {
        public void invoke(long handle, Pointer pUserData, TH_PlateResult_Pointer.ByReference pResult, int uNumPlates,
                           int eResultType, VZ_LPRC_IMAGE_INFO_Pointer.ByReference pImgFull, VZ_LPRC_IMAGE_INFO_Pointer.ByReference pImgPlateClip);
    }


    public static interface VZDEV_SERIAL_RECV_DATA_CALLBACK extends Callback {
        public void invoke(long handle, Pointer pRecvData, int uRecvSize, Pointer pUserData);
    }

    public static interface VZLPRC_COMMON_NOTIFY_CALLBACK extends Callback {
        public void invoke(long handle, Pointer pUserData, int eNotify, String pStrDetail);
    }

    int VZLPRClient_SetCommonNotifyCallBack(VZLPRC_COMMON_NOTIFY_CALLBACK func, Pointer pUserData);


    public static interface VZLPRC_FIND_DEVICE_CALLBACK_EX extends Callback {
        public void invoke(String pStrDevName, String pStrIPAddr, short usPort1, short usType, long SL, long SH, String netmask, String gateway, Pointer pUserData);
    }


    int VZLPRClient_StartFindDeviceEx(VZLPRC_FIND_DEVICE_CALLBACK_EX func, Pointer pUserData);


    void VZLPRClient_StopFindDevice();

    public static interface VZLPRC_WLIST_QUERY_CALLBACK extends Callback {
        public void invoke(int cbtype, VZ_LPR_WLIST_VEHICLE.ByReference vehicle, VZ_LPR_WLIST_CUSTOMER.ByReference pCustomer, Pointer UserData);
    }

    int VzLPRClient_WhiteListSetQueryCallBack(long handle, VZLPRC_WLIST_QUERY_CALLBACK callback, Pointer pUserData);

    int VzLPRClient_WhiteListQueryVehicleByPlate(long handle, byte[] strPlateID);


    int VzLPRClient_WhiteListGetVehicleCount(long handle, int count[], VZ_LPR_WLIST_SEARCH_WHERE.ByReference pSearchWhere);

    int VzLPRClient_WhiteListLoadVehicle(long handle, VZ_LPR_WLIST_LOAD_CONDITIONS.ByReference pLoadCondition);

}

附 动态库下载

官网下载对应的设备sdk
https://www.vzenith.com/resources/

笑风尘灬
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
车牌识别SDK简析
vzenith的专栏
06-04 4337
△什么是车牌识别SDK 车牌识别SDK是开发包形态的汽车牌照识别产品，采用动态连接库(DLL)，支持C ，C#，VB，Delphi等多种开发语言，支持的操作系统包括windows xp，win7，win8，win2008，linux等。开发接口简单，并且提供完整的示例程序、详尽的开发文档，便于用户在应用程序中嵌入实现车牌识别功能。 △车牌识别SDK支持车牌类型 目前市面上的车牌识别SDK能识
0.（臻识）车牌识别停车场软件(20180412).zip
05-22
臻识摄像机调试工具，黑白名单下载，有效期设置，以及线圈、车辆运动方向等设置。
臻识TCP摄像头 SDK交叉编译
weixin_43479963的博客
05-23 1127
修改arm_make.cmake文件 修改后的文件内容： # CMake toolchain file for building ARM software on OI environment include(CMakeForceCompiler) # this one is important SET(CMAKE_SYSTEM_NAME Linux) set( CMAKE_SYSTEM_PROCESSOR arm ) #this one not so much SET(CMAKE_SYSTEM_VE.
一体机开发
weixin_44846288的博客
07-13 1461
一体机 连接 需要添加一体机 dll文件 和封装的调用方法 public void serialPort1() { string cfgINI = @"config\set.ini"; IniFile ini = new IniFile(cfgINI); string ip = ini.I...
臻识车牌识别一体机开发包2.0.5.9.rar
11-24
成都臻识车牌识别相机 车牌识别一体机开发包2.0.5.9.rar 含ActiveX控件、开源TcpSDK、一体机SDK以及DEMO、.h头文件、开发文档等
车牌识别--http协议
最新发布
lijianhua003的博客
07-11 511
基于https协议访问网址实现车牌识别一、libcurllibcurl是一个跨平台的网络协议库，支持http, https, ftp, gopher, telnet, dict, file, 和ldap 协议库下载：https://github.com/curl/curl/releases/tag/curl-7_71_1 二、车牌识别 1.curl使用2.函数介绍curl_easy_setopt()3.登录翔云去购买key4.通过https协议调用翔云车牌识别接口
java调用 火眼臻睛,火眼臻睛车牌识别SDK评测
weixin_32145817的博客
03-11 296
【CPS中安网 cps.com.cn】CPSLAB总评:用专业角度解读产品--CPS评测中心对火眼臻睛车牌识别SDK进行了全面评测,火眼臻睛车牌识别SDK在综合识别率、车牌定位成功率、大角度下的识别率、夜间环境下的识别率、极端环境下的识别率、支持的最小车牌像素宽度等测试表现,都位于行业前列,整体表现优异.其系统具有识别率高、适应性强、应用形态广、使用便捷等特点,可广泛应用于各类车辆管理场景中.总...
车牌识别一体机客户端物业专用软件
10-05
车牌识别一体机客户端软件是专为物业管理设计的一款高效、智能化的工具，主要应用于小区和道闸系统的出入口控制。这款软件结合了先进的车牌识别技术，实现了自动识别进出车辆的车牌号码，大大提升了通行效率和安全性...
华夏车牌识别相机调试工具
04-06
划线，调试，识别区设置
车牌识别动态库
07-18
车牌识别动态库，完成车牌区域位置检测及号牌的识别。
车牌识别一体机开发包
10-28
1. ActiveX控件： 车牌识别ActiveX是推出的基于一体机SDK封装的控件，支持在windows系统下的开发。包括系统、设备、音频、视频、图片、识别、白名单等功能。 2. 开源TcpSDK： 对TCP协议进行封装，提供源码，可以在Linux平台编译运行。TcpSDK包括车牌识别一体机接收识别结果、管理白名单、透明串口数据发送与接收、继电器控制等功能。 3. 一体机SDK 车牌识别一体机SDK是我公司推出的基于一体机的软件开发工具包，支持在windows系统下的开发。提供32位和64位开发包，主要功能包括系统配置、音频、视频、图片、识别、白名单、设备维护等功
华夏车牌识别二次开发软件.rar
11-06
华夏相机车牌识别系统sdk开发库for windows 有多个代码实例，非常方便。
成都臻识相机 opensdk_rm_20190604.rar
11-24
成都臻识相机 一体机 车牌识别相机 OPENSDK开发包 RM版本相机
成都臻识相机 opensdk_r3_20210414.rar
11-24
成都臻识相机 车牌识别相机 OPENSDK 开发包 最新R3版本相机
asp.net 集成车牌识别一体机-SDK
10-09
asp.net 集成车牌识别一体机-SDK
中控车牌识别6600一体机配置工具.zip
02-08
5. **报警设置**：设置异常情况下的报警策略，例如当连续多次无法识别车牌时触发警报。 6. **固件升级**：允许用户更新LPR6600的固件，以获取新功能或修复已知问题。 7. **用户权限管理**：设置不同操作员的访问权限...
臻识车牌识别linux,成都臻训识车牌识别摄像机C#用户控件封装源码 直接使用
weixin_31355483的博客
05-15 488
/wwwbt/wwwroot/a_haozhan/public/index.php ( 0.90 KB )/wwwbt/wwwroot/a_haozhan/thinkphp/start.php ( 0.74 KB )/wwwbt/wwwroot/a_haozhan/thinkphp/base.php ( 2.66 KB )/wwwbt/wwwroot/a_haozhan/thinkphp/libr...
物联网(java版本)臻识摄像头+本地实时显示视频
Rs的博客
11-02 1582
部分代码显示 package com.xdnnaovideo.videoservice.listenermessage; import com.google.gson.Gson; import com.xdnnaovideo.videoservice.entity.AddAndUpdateRtspVo; import com.xdnnaovideo.videoservice.entity.AjaxResult; import com.xdnnaovideo.videoservice.rts...
Java实现：Socket远程控制臻识道闸的开闸
05-29
首先需要在道闸系统中实现一个监听指令的程序，可以通过Socket接收来自客户端的指令。这个程序可以使用Java Socket编程实现。 客户端可以使用Java Socket编程实现一个连接到道闸系统的程序，通过Socket向道闸系统发送开闸指令。 以下是一个简单的Java Socket程序示例： 服务端代码： ```java import java.io.*; import java.net.*; public class Server { public static void main(String[] args) { try { ServerSocket serverSocket = new ServerSocket(8888); System.out.println("等待客户端连接..."); Socket clientSocket = serverSocket.accept(); System.out.println("客户端连接成功！"); // 获取客户端输出流 OutputStream outputStream = clientSocket.getOutputStream(); PrintWriter out = new PrintWriter(outputStream); // 发送开闸指令 out.println("open"); out.flush(); // 关闭流和连接 out.close(); outputStream.close(); clientSocket.close(); serverSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 客户端代码： ```java import java.io.*; import java.net.*; public class Client { public static void main(String[] args) { try { String serverHost = "192.168.1.100"; // 道闸系统IP地址 int serverPort = 8888; // 道闸系统监听端口 Socket clientSocket = new Socket(serverHost, serverPort); // 获取服务端输入流 InputStream inputStream = clientSocket.getInputStream(); BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream)); // 读取服务端返回的数据 String response = reader.readLine(); System.out.println("服务端返回：" + response); // 关闭流和连接 reader.close(); inputStream.close(); clientSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } ``` 注意在道闸系统中需要针对接收到的指令进行相应的处理，例如执行开闸操作。这个部分需要根据具体的道闸系统进行实现。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

笑风尘灬

如果有用，请博主喝杯咖啡叭

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值