package com.netsdk.demo.customize;
|
|
import java.io.File;
|
import java.io.UnsupportedEncodingException;
|
import java.util.Arrays;
|
|
import com.netsdk.demo.util.CaseMenu;
|
import com.netsdk.lib.ImageAlgLib;
|
import com.netsdk.lib.LibraryLoad;
|
import com.netsdk.lib.NetSDKLib;
|
import com.netsdk.lib.ToolKits;
|
import com.netsdk.lib.NetSDKLib.*;
|
import com.netsdk.lib.structure.NET_IN_RADIOMETRY_RANDOM_REGION_TEMPER;
|
import com.netsdk.lib.structure.NET_OUT_RADIOMETRY_RANDOM_REGION_TEMPER;
|
import com.sun.jna.Memory;
|
import com.sun.jna.Native;
|
import com.sun.jna.Pointer;
|
import com.sun.jna.ptr.IntByReference;
|
|
// 热成像
|
public class Radiometry {
|
static NetSDKLib netsdkApi = NetSDKLib.NETSDK_INSTANCE;
|
static NetSDKLib configApi = NetSDKLib.CONFIG_INSTANCE;
|
static ImageAlgLib imageAlgApi = ImageAlgLib.imageAlgApi;
|
|
////////////////////////////////////////////////////////////////
|
// String m_strIp = "172.11.4.18"; // 热成像 172.32.101.81 172.12.18.22 172.12.4.85 172.32.102.146
|
String m_strIp = "10.35.248.168"; // 172.32.103.7 172.32.103.3
|
int m_nPort = 37777;
|
String m_strUser = "admin";
|
String m_strPassword = "admin123";
|
////////////////////////////////////////////////////////////////
|
private int nQueryChannel = 1;
|
private NetSDKLib.NET_DEVICEINFO_Ex deviceinfo = new NetSDKLib.NET_DEVICEINFO_Ex();
|
private static LLong loginHandle = new LLong(0); //登陆句柄
|
private static LLong m_lRadiometryHandle = new LLong(0);
|
|
private static final int MAX_QUERY_PRESET_NUM = 20; // 目前设置的最大查询预置点个数，根据实际调整
|
|
// 设备断线回调: 通过 CLIENT_Init 设置该回调函数，当设备出现断线时，SDK会调用该函数
|
public static class fDisConnectCB implements NetSDKLib.fDisConnect{
|
public void invoke(LLong lLoginID, String pchDVRIP, int nDVRPort, Pointer dwUser){
|
System.out.printf("Device[%s] Port[%d] Disconnect!\n" , pchDVRIP , nDVRPort);
|
}
|
}
|
|
// 网络连接恢复，设备重连成功回调
|
// 通过 CLIENT_SetAutoReconnect 设置该回调函数，当已断线的设备重连成功时，SDK会调用该函数
|
public static class HaveReConnect implements NetSDKLib.fHaveReConnect {
|
public void invoke(LLong loginHandle, String pchDVRIP, int nDVRPort, Pointer dwUser) {
|
System.out.printf("ReConnect Device[%s] Port[%d]\n", pchDVRIP, nDVRPort);
|
}
|
}
|
|
private static fDisConnectCB m_DisConnectCB = new fDisConnectCB();
|
private static HaveReConnect haveReConnect = new HaveReConnect();
|
|
public void EndTest()
|
{
|
System.out.println("End Test");
|
if( loginHandle.longValue() != 0)
|
{
|
netsdkApi.CLIENT_Logout(loginHandle);
|
}
|
System.out.println("See You...");
|
|
netsdkApi.CLIENT_Cleanup();
|
System.exit(0);
|
}
|
|
public void InitTest()
|
{
|
// 初始化SDK库， 在启动工程的时候调用，只需要调用一次即可，属于初始化sdk的库
|
netsdkApi.CLIENT_Init(m_DisConnectCB, null);
|
|
// 设置断线重连回调接口，设置过断线重连成功回调函数后，当设备出现断线情况，SDK内部会自动进行重连操作
|
// 此操作为可选操作，但建议用户进行设置
|
netsdkApi.CLIENT_SetAutoReconnect(haveReConnect, null);
|
|
//设置登录超时时间和尝试次数，可选
|
int waitTime = 5000; //登录请求响应超时时间设置为5S
|
int tryTimes = 3; //登录时尝试建立链接3次
|
netsdkApi.CLIENT_SetConnectTime(waitTime, tryTimes);
|
|
// 设置更多网络参数，NET_PARAM的nWaittime，nConnectTryNum成员与CLIENT_SetConnectTime
|
// 接口设置的登录设备超时时间和尝试次数意义相同,可选
|
NetSDKLib.NET_PARAM netParam = new NetSDKLib.NET_PARAM();
|
netParam.nConnectTime = 10000; //登录时尝试建立链接的超时时间
|
netsdkApi.CLIENT_SetNetworkParam(netParam);
|
|
// 打开日志，可选
|
NetSDKLib.LOG_SET_PRINT_INFO setLog = new NetSDKLib.LOG_SET_PRINT_INFO();
|
|
File path = new File(".");
|
String logPath = path.getAbsoluteFile().getParent() + "\\sdk_log\\" + System.currentTimeMillis() + ".log";
|
|
setLog.bSetFilePath = 1;
|
System.arraycopy(logPath.getBytes(), 0, setLog.szLogFilePath, 0, logPath.getBytes().length);
|
|
setLog.bSetPrintStrategy = 1;
|
setLog.nPrintStrategy = 0;
|
boolean bLogopen = netsdkApi.CLIENT_LogOpen(setLog);
|
if (!bLogopen) {
|
System.err.println("Failed to open NetSDK log !!!");
|
}
|
|
// 向设备登入
|
int nSpecCap = 0;
|
Pointer pCapParam = null;
|
IntByReference nError = new IntByReference(0);
|
loginHandle = netsdkApi.CLIENT_LoginEx2(m_strIp, m_nPort, m_strUser ,
|
m_strPassword ,nSpecCap,pCapParam, deviceinfo,nError);
|
|
if(loginHandle.longValue() != 0) {
|
System.out.printf("Login Device[%s] Port[%d]Success!\n" , m_strIp , m_nPort);
|
}
|
else {
|
System.out.printf("Login Device[%s] Port[%d]Fail.Last Error[0x%x]\n" , m_strIp , m_nPort , netsdkApi.CLIENT_GetLastError());
|
|
// 此方法里的 netsdkApi.CLIENT_Cleanup(); 在关闭工程的时候调用
|
EndTest();
|
}
|
}
|
|
/**
|
* 获取接口错误码
|
* @return
|
*/
|
public String getErrorCode() {
|
return " { error code: ( 0x80000000|" + (netsdkApi.CLIENT_GetLastError() & 0x7fffffff) +" ). 参考 NetSDKLib.java }";
|
}
|
|
/**
|
* 获取测温区域的参数值
|
*/
|
public void RadiometryGetRandomRegionTemper(){
|
NET_IN_RADIOMETRY_RANDOM_REGION_TEMPER stIn = new NET_IN_RADIOMETRY_RANDOM_REGION_TEMPER();
|
NET_OUT_RADIOMETRY_RANDOM_REGION_TEMPER stOut = new NET_OUT_RADIOMETRY_RANDOM_REGION_TEMPER();
|
stIn.nChannel = 1;
|
stIn.nPointNum = 1;
|
stIn.stuPolygon[0].nx = 100;
|
stIn.stuPolygon[0].ny = 100;
|
stIn.write();
|
stOut.write();
|
|
boolean bet = netsdkApi.CLIENT_RadiometryGetRandomRegionTemper(loginHandle,stIn.getPointer(),stOut.getPointer(), 3000);
|
|
stIn.read();
|
stOut.read();
|
|
if(bet) {
|
System.out.println("获取测温区域的参数值成功" );
|
System.out.println("温度单位：" + stOut.stuRegionTempInfo.emTemperatureUnit);
|
System.out.println("平均温度：" + stOut.stuRegionTempInfo.nTemperAver);
|
System.out.println("最高温度：" + stOut.stuRegionTempInfo.nTemperMax);
|
System.out.println("最低温度：" + stOut.stuRegionTempInfo.nTemperMin);
|
System.out.println("最高温坐标：" + stOut.stuRegionTempInfo.stuTemperMaxPoint.nx + ":" + stOut.stuRegionTempInfo.stuTemperMaxPoint.ny);
|
System.out.println("最低温坐标：" + stOut.stuRegionTempInfo.stuTemperMinPoint.nx + ":" + stOut.stuRegionTempInfo.stuTemperMinPoint.ny);
|
}else {
|
System.err.println("获取测温区域的参数值失败," + getErrorCode());
|
}
|
}
|
|
/**
|
* 订阅温度分布数据（热图）
|
*/
|
public void RadiometryAttach() {
|
/*
|
* 入参
|
*/
|
NET_IN_RADIOMETRY_ATTACH stIn = new NET_IN_RADIOMETRY_ATTACH();
|
stIn.nChannel = nQueryChannel; // 通道号
|
stIn.cbNotify = RadiometryAttachCB.getInstance(); // 回调函数
|
|
|
/*
|
* 出参
|
*/
|
NET_OUT_RADIOMETRY_ATTACH stOut = new NET_OUT_RADIOMETRY_ATTACH();
|
m_lRadiometryHandle = netsdkApi.CLIENT_RadiometryAttach(loginHandle, stIn, stOut, 3000);
|
|
if(m_lRadiometryHandle.longValue() != 0) {
|
System.out.println("订阅温度分布数据成功!");
|
} else {
|
System.err.println("订阅温度分布数据失败, " + getErrorCode());
|
}
|
}
|
|
/**
|
* 开始获取热图数据
|
*/
|
String[] status = {"未知", "空闲", "获取热图中"};
|
public void RadiometryFetch() {
|
/*
|
* 入参
|
*/
|
NET_IN_RADIOMETRY_FETCH stIn = new NET_IN_RADIOMETRY_FETCH();
|
stIn.nChannel = nQueryChannel; // 通道号
|
|
/*
|
* 出参
|
*/
|
NET_OUT_RADIOMETRY_FETCH stOut = new NET_OUT_RADIOMETRY_FETCH();
|
|
if(netsdkApi.CLIENT_RadiometryFetch(loginHandle, stIn, stOut, 3000)) {
|
System.out.println("开始获取热图数据, 状态 ： " + status[stOut.nStatus]);
|
}else {
|
System.err.println("开始获取热图数据失败, " + getErrorCode());
|
}
|
}
|
|
/**
|
* 订阅回调
|
*/
|
private static class RadiometryAttachCB implements fRadiometryAttachCB {
|
private RadiometryAttachCB() {}
|
|
private static class RadiometryAttachCBHolder {
|
private static RadiometryAttachCB instance = new RadiometryAttachCB();
|
}
|
|
public static RadiometryAttachCB getInstance() {
|
return RadiometryAttachCBHolder.instance;
|
}
|
|
|
@Override
|
public void invoke(LLong lAttachHandle, final NET_RADIOMETRY_DATA pBuf,
|
int nBufLen, Pointer dwUser) {
|
|
/*new Thread() {
|
final NET_RADIOMETRY_DATA stuData = pBuf;
|
public void run() {
|
try {
|
sleep(5000);
|
} catch (InterruptedException e) {
|
e.printStackTrace();
|
}
|
dealRadiometryData(stuData); // 此处同步处理，如需异步，需要拷贝pBuf
|
};
|
}.start();*/
|
|
dealRadiometryData(pBuf); // 此处同步处理，如需异步，需要拷贝pBuf
|
}
|
}
|
|
/**
|
* 处理回调数据（热图）
|
*/
|
private static void dealRadiometryData(NET_RADIOMETRY_DATA pBuf) {
|
System.out.println(" 解析开始 ");
|
|
int nWidth = pBuf.stMetaData.nWidth;
|
int nHeight = pBuf.stMetaData.nHeight;
|
System.out.println("nWidth " + nWidth + " nHeight " + nHeight);
|
System.out.println("time " + pBuf.stMetaData.stTime.toStringTime());
|
short[] pGrayImg = new short[nWidth * nHeight];
|
float[] pTempForPixels = new float[nWidth * nHeight];
|
|
if(netsdkApi.CLIENT_RadiometryDataParse(pBuf, pGrayImg, pTempForPixels)) {
|
byte[] pYData = new byte[nWidth*nHeight*2];
|
imageAlgApi.drcTable(pGrayImg, (short)nWidth, (short)nHeight, 0, pYData, null);
|
ToolKits.savePicture(pYData, "./RAW.yuv");
|
Arrays.sort(pTempForPixels);
|
System.out.println("最低温度："+pTempForPixels[0]);
|
System.out.println("最高温度："+pTempForPixels[nWidth * nHeight-1]);
|
} else {
|
System.err.println("解析失败");
|
return;
|
}
|
|
System.out.println(" 解析完成 ");
|
}
|
|
/**
|
* 取消订阅温度分布数据
|
*/
|
public void RadiometryDetach() {
|
if(m_lRadiometryHandle.longValue() != 0) {
|
netsdkApi.CLIENT_RadiometryDetach(m_lRadiometryHandle);
|
m_lRadiometryHandle.setValue(0);
|
}
|
}
|
|
/**
|
* 查询热成像预设信息
|
*/
|
public void QueryPresetInfo() {
|
int nQueryType = NetSDKLib.NET_QUERY_DEV_THERMO_GRAPHY_PRESET;
|
|
// 入参
|
NET_IN_THERMO_GET_PRESETINFO stIn = new NET_IN_THERMO_GET_PRESETINFO();
|
stIn.nChannel = nQueryChannel;
|
stIn.emMode = NET_THERMO_MODE.NET_THERMO_MODE_DEFAULT; // 默认
|
|
// 出参
|
NET_OUT_THERMO_GET_PRESETINFO stOut = new NET_OUT_THERMO_GET_PRESETINFO();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.FIELD_NOT_PRINT = "stCustomRegions";
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("QueryDev Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 查询热成像感兴趣区域信息
|
*/
|
public void QueryOptRegion() {
|
int nQueryType = NetSDKLib.NET_QUERY_DEV_THERMO_GRAPHY_OPTREGION;
|
|
// 入参
|
NET_IN_THERMO_GET_OPTREGION stIn = new NET_IN_THERMO_GET_OPTREGION();
|
stIn.nChannel = nQueryChannel;
|
|
// 出参
|
NET_OUT_THERMO_GET_OPTREGION stOut = new NET_OUT_THERMO_GET_OPTREGION();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("QueryDev Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 查询热成像外部系统信息
|
*/
|
public void QueryExtSysInfo() {
|
int nQueryType = NetSDKLib.NET_QUERY_DEV_THERMO_GRAPHY_EXTSYSINFO;
|
|
// 入参
|
NET_IN_THERMO_GET_EXTSYSINFO stIn = new NET_IN_THERMO_GET_EXTSYSINFO();
|
stIn.nChannel = nQueryChannel;
|
|
// 出参
|
NET_OUT_THERMO_GET_EXTSYSINFO stOut = new NET_OUT_THERMO_GET_EXTSYSINFO();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("QueryDev Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 查询测温点的参数值
|
*/
|
public void QueryPointTemper() {
|
int nQueryType = NetSDKLib.NET_QUERY_DEV_RADIOMETRY_POINT_TEMPER;
|
|
// 入参
|
NET_IN_RADIOMETRY_GETPOINTTEMPER stIn = new NET_IN_RADIOMETRY_GETPOINTTEMPER();
|
stIn.nChannel = nQueryChannel;
|
stIn.stCoordinate.nx = 10;
|
stIn.stCoordinate.nx = 10;
|
|
// 出参
|
NET_OUT_RADIOMETRY_GETPOINTTEMPER stOut = new NET_OUT_RADIOMETRY_GETPOINTTEMPER();
|
|
stIn.write();
|
stOut.write();
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("QueryDev Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 查询测温项的参数值
|
*/
|
public void QueryGetTemper() {
|
int nQueryType = NetSDKLib.NET_QUERY_DEV_RADIOMETRY_TEMPER;
|
|
// 入参
|
NET_IN_RADIOMETRY_GETTEMPER stIn = new NET_IN_RADIOMETRY_GETTEMPER();
|
stIn.stCondition.nPresetId = 1;
|
stIn.stCondition.nRuleId = 0;
|
stIn.stCondition.nMeterType = NET_RADIOMETRY_METERTYPE.NET_RADIOMETRY_METERTYPE_AREA;
|
stIn.stCondition.nChannel = nQueryChannel;
|
|
// 出参
|
NET_OUT_RADIOMETRY_GETTEMPER stOut = new NET_OUT_RADIOMETRY_GETTEMPER();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("QueryDev Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 热成像摄像头属性配置
|
*/
|
public boolean ConfigThermographyOptions() {
|
|
String command = NetSDKLib.CFG_CMD_THERMO_GRAPHY;
|
CFG_THERMOGRAPHY_INFO cfg = new CFG_THERMOGRAPHY_INFO();
|
|
if(ToolKits.GetDevConfig(loginHandle, nQueryChannel, command, cfg)) { // 获取
|
PrintStruct.FIELD_NOT_PRINT = "stCustomRegions";
|
PrintStruct.print(cfg);
|
|
if(ToolKits.SetDevConfig(loginHandle, nQueryChannel, command, cfg)) {
|
System.out.println("设置热成像摄像头属性成功!");
|
return true;
|
} else {
|
System.err.println("设置热成像摄像头属性失败!" + ToolKits.getErrorCode());
|
}
|
} else {
|
System.err.println("获取热成像摄像头属性失败!" + ToolKits.getErrorCode());
|
}
|
|
return false;
|
}
|
|
|
/**
|
* 获取当前云台的预置点列表
|
*/
|
public void GetPresetList() {
|
|
int nType = NetSDKLib.NET_DEVSTATE_PTZ_PRESET_LIST;
|
|
NET_PTZ_PRESET_LIST stuPresetList = new NET_PTZ_PRESET_LIST();
|
|
NET_PTZ_PRESET[] arrPreset = new NET_PTZ_PRESET[MAX_QUERY_PRESET_NUM];
|
for(int i = 0; i < arrPreset.length; i++) {
|
arrPreset[i] = new NET_PTZ_PRESET();
|
}
|
|
stuPresetList.dwMaxPresetNum = arrPreset.length;
|
int nMemoryLen = arrPreset[0].size() * stuPresetList.dwMaxPresetNum;
|
stuPresetList.pstuPtzPorsetList = new Memory(nMemoryLen); // 申请内存
|
stuPresetList.pstuPtzPorsetList.clear(nMemoryLen);
|
ToolKits.SetStructArrToPointerData(arrPreset, stuPresetList.pstuPtzPorsetList); // 将数组内存拷贝到Pointer
|
|
stuPresetList.write();
|
|
IntByReference intRetLen = new IntByReference();
|
|
// if(netsdkApi.CLIENT_QueryDevState(loginHandle,
|
// nType,
|
// stuPresetList.getPointer(),
|
// stuPresetList.size(),
|
// intRetLen,
|
// 5000)) {
|
if (netsdkApi.CLIENT_QueryRemotDevState(loginHandle,
|
nType,
|
nQueryChannel,
|
stuPresetList.getPointer(),
|
stuPresetList.size(),
|
intRetLen,
|
5000)) {
|
|
stuPresetList.read();
|
ToolKits.GetPointerDataToStructArr(stuPresetList.pstuPtzPorsetList, arrPreset);
|
System.out.println("返回预置点个数: " + stuPresetList.dwRetPresetNum);
|
for (int i = 0; i < stuPresetList.dwRetPresetNum; ++i) {
|
try {
|
System.out.println(new String(arrPreset[i].szName, "GBK"));
|
} catch (UnsupportedEncodingException e) {
|
System.out.println(new String(arrPreset[i].szName));
|
}
|
// PrintStruct.print(arrPreset[i]);
|
}
|
} else {
|
System.err.println("QueryDevState Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 设置预置点
|
*/
|
public void SetPreset() {
|
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_SET_CONTROL;
|
int nPresetIndex = 7; // 预置点值，从1开始
|
String name = "Preset7"; // 预置点名称 TIPS:热成像预置点名称无法修改
|
if(PTZControl(dwPTZCommand, 0, nPresetIndex, 0, 0, ToolKits.GetGBKStringToPointer(name))) {
|
System.out.println("SetPreset success!");
|
} else {
|
System.err.println("SetPreset Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 转至预置点
|
*/
|
public void MovePreset() {
|
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_MOVE_CONTROL;
|
int nPresetIndex = 7; // 预置点值，从1开始
|
if(PTZControl(dwPTZCommand, 0, nPresetIndex, 0, 0, null)) {
|
System.out.println("MovePreset success!");
|
} else {
|
System.err.println("MovePreset Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 删除预置点
|
*/
|
public void DeletePreset() {
|
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_DEL_CONTROL;
|
int nPresetIndex = 7; // 预置点值，从1开始
|
if(PTZControl(dwPTZCommand, 0, nPresetIndex, 0, 0, null)) {
|
System.out.println("DeletePreset success!");
|
} else {
|
System.err.println("DeletePreset Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 加入预置点到巡航
|
*/
|
public void AddToLoop() {
|
|
int dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_ADDTOLOOP;
|
int nTourGroup = 1; // 巡航线路(0-7)
|
int nPresetIndex = 7; // 预置点值，从1开始
|
if(PTZControl(dwPTZCommand, nTourGroup, nPresetIndex, 0, 0, null)) {
|
System.out.println("AddToLoop success!");
|
} else {
|
System.err.println("AddToLoop Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 删除巡航中预置点
|
*/
|
public void DeleteFromLoop() {
|
|
int dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_DELFROMLOOP;
|
int nTourGroup = 1; // 巡航线路(0-7)
|
int nPresetIndex = 7; // 预置点值，从1开始
|
if(PTZControl(dwPTZCommand, nTourGroup, nPresetIndex, 0, 0, null)) {
|
System.out.println("DeleteFromLoop success!");
|
} else {
|
System.err.println("DeleteFromLoop Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 清除巡航巡航线路
|
*/
|
public void ClearLoop() {
|
|
int dwPTZCommand = NetSDKLib.NET_EXTPTZ_ControlType.NET_EXTPTZ_CLOSELOOP;
|
int nTourGroup = 1; // 巡航线路(0-7)
|
if(PTZControl(dwPTZCommand, nTourGroup, 0, 0, 0, null)) {
|
System.out.println("ClearLoop success!");
|
} else {
|
System.err.println("ClearLoop Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 开始点间巡航
|
*/
|
public void StartTour() {
|
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_LOOP_CONTROL;
|
int nTourGroup = 1; // 巡航线路(0-7)
|
if(PTZControl(dwPTZCommand, nTourGroup, 0, 76, 0, null)) {
|
System.out.println("StartTour success!");
|
} else {
|
System.err.println("StartTour Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 停止点间巡航
|
*/
|
public void StopTour() {
|
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_POINT_LOOP_CONTROL;
|
int nTourGroup = 1; // 巡航线路(0-7)
|
if(PTZControl(dwPTZCommand, nTourGroup, 0, 96, 0, null)) {
|
System.out.println("StopTour success!");
|
} else {
|
System.err.println("StopTour Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
public void OpenLamp() {
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_LAMP_CONTROL;
|
int open = 0x01;
|
if(PTZControl(dwPTZCommand, open, 0, 0, 0, null)) {
|
System.out.println("OpenLamp success!");
|
} else {
|
System.err.println("OpenLamp Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
public void CloseLamp() {
|
int dwPTZCommand = NetSDKLib.NET_PTZ_ControlType.NET_PTZ_LAMP_CONTROL;
|
int close = 0x00;
|
if(PTZControl(dwPTZCommand, close, 0, 0, 0, null)) {
|
System.out.println("CloseLamp success!");
|
} else {
|
System.err.println("CloseLamp Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
public boolean PTZControl(int dwPTZCommand, int lParam1, int lParam2, int lParam3, int dwStop, Pointer param4) {
|
|
return netsdkApi.CLIENT_DHPTZControlEx2(loginHandle, nQueryChannel, dwPTZCommand, lParam1, lParam2, lParam3, dwStop,param4);
|
}
|
|
/**
|
* 热成像测温规则配置
|
*/
|
public void ConfigThermometryRule() {
|
|
String command = NetSDKLib.CFG_CMD_THERMOMETRY_RULE;
|
CFG_RADIOMETRY_RULE_INFO cfg = new CFG_RADIOMETRY_RULE_INFO();
|
|
if(ToolKits.GetDevConfig(loginHandle, nQueryChannel, command, cfg)) { // 获取
|
|
// PrintStruct.FIELD_NOT_PRINT = "stCoordinates nCoordinateCnt nSamplePeriod stAlarmSetting nAlarmSettingCnt stLocalParameters emAreaSubType";
|
// PrintStruct.print(cfg);
|
|
String []arrMeterType = {"未知", "点", "线", "区域"};
|
for (int i = 0; i < cfg.nCount; ++i) {
|
try {
|
System.out.printf("预置点编号:%-2d 规则编号:%-2d 名称:%s 测温模式:%s\n",
|
cfg.stRule[i].nPresetId,
|
cfg.stRule[i].nRuleId,
|
new String(cfg.stRule[i].szName, "GBK").trim(),
|
arrMeterType[cfg.stRule[i].nMeterType]);
|
}catch(Exception e) {
|
|
}
|
}
|
|
/*if(ToolKits.SetDevConfig(loginHandle, nQueryChannel, command, cfg)) {
|
System.out.println("设置热成像测温规则成功!");
|
} else {
|
System.err.println("设置热成像测温规则失败!" + ToolKits.getErrorCode());
|
}*/
|
} else {
|
System.err.println("获取热成像测温规则配置失败!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 温度统计配置
|
*/
|
public void ConfigTemperatureStatistics() {
|
|
String command = NetSDKLib.CFG_CMD_TEMP_STATISTICS;
|
CFG_TEMP_STATISTICS_INFO cfg = new CFG_TEMP_STATISTICS_INFO();
|
|
if(ToolKits.GetDevConfig(loginHandle, nQueryChannel, command, cfg)) { // 获取
|
PrintStruct.print(cfg);
|
if(ToolKits.SetDevConfig(loginHandle, nQueryChannel, command, cfg)) {
|
System.out.println("设置温度统计成功!");
|
} else {
|
System.err.println("设置温度统计失败!" + ToolKits.getErrorCode());
|
}
|
} else {
|
System.err.println("获取温度统计配置失败!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 热成像测温全局配置
|
*/
|
public void ConfigHeatImagingThermometry() {
|
|
String command = NetSDKLib.CFG_CMD_THERMOMETRY;
|
CFG_THERMOMETRY_INFO cfg = new CFG_THERMOMETRY_INFO();
|
|
if(ToolKits.GetDevConfig(loginHandle, nQueryChannel, command, cfg)) { // 获取
|
PrintStruct.print(cfg);
|
|
if(ToolKits.SetDevConfig(loginHandle, nQueryChannel, command, cfg)) {
|
System.out.println("设置热成像测温全局配置成功!");
|
} else {
|
System.err.println("设置热成像测温全局配置失败!" + ToolKits.getErrorCode());
|
}
|
} else {
|
System.err.println("获取热成像测温全局配置失败!" + ToolKits.getErrorCode());
|
}
|
}
|
|
// 获取远程设备的信息
|
public void GetCameraInfo() {
|
int []statusTable = new int[deviceinfo.byChanNum];
|
Arrays.fill(statusTable, -1); //初始化状态为-1
|
|
if (!getCameraState(statusTable)) {
|
System.out.println("获取状态信息失败！");
|
}
|
|
String []nameTable = new String[deviceinfo.byChanNum];
|
if(!getChannelName(nameTable)) {
|
System.out.println("获取通道名称失败！");
|
}
|
|
int cameraCount = deviceinfo.byChanNum; // 通道号个数
|
NetSDKLib.NET_MATRIX_CAMERA_INFO[] cameraInfo = new NetSDKLib.NET_MATRIX_CAMERA_INFO[cameraCount];
|
for(int i = 0; i < cameraCount; i++) {
|
cameraInfo[i] = new NetSDKLib.NET_MATRIX_CAMERA_INFO();
|
}
|
|
// 入参
|
NetSDKLib.NET_IN_MATRIX_GET_CAMERAS inMatrix = new NetSDKLib.NET_IN_MATRIX_GET_CAMERAS();
|
|
// 出参
|
NetSDKLib.NET_OUT_MATRIX_GET_CAMERAS outMatrix = new NetSDKLib.NET_OUT_MATRIX_GET_CAMERAS();
|
outMatrix.nMaxCameraCount = cameraCount;
|
outMatrix.pstuCameras = new Memory(cameraInfo[0].size() * cameraCount);
|
outMatrix.pstuCameras.clear(cameraInfo[0].size() * cameraCount);
|
|
ToolKits.SetStructArrToPointerData(cameraInfo, outMatrix.pstuCameras); // 将数组内存拷贝到Pointer
|
|
if(netsdkApi.CLIENT_MatrixGetCameras(loginHandle, inMatrix, outMatrix, 5000)) {
|
ToolKits.GetPointerDataToStructArr(outMatrix.pstuCameras, cameraInfo); // 将 Pointer 的内容 输出到 数组
|
String []arrStatusName = {"未知", "正在连接", "已连接", "未连接", "通道未配置,无信息", "通道有配置,但被禁用"};
|
int i = 0;
|
for(int j = 0; j < outMatrix.nRetCameraCount; j++) {
|
if(cameraInfo[j].bRemoteDevice == 0) { // 过滤远程设备
|
System.err.println("非远程设备过滤...");
|
continue;
|
}
|
|
int emConnectionState = statusTable[cameraInfo[j].nUniqueChannel];
|
|
if (emConnectionState == -1
|
|| emConnectionState == EM_CAMERA_STATE_TYPE.EM_CAMERA_STATE_TYPE_UNKNOWN
|
|| emConnectionState == EM_CAMERA_STATE_TYPE.EM_CAMERA_STATE_TYPE_EMPTY) { // 只显示能获取设备状态的
|
continue;
|
}
|
|
// System.out.println("————————————第 " + (++i) + " 个 远程设备————————————");
|
// PrintStruct.print(cameraInfo[j]);
|
|
|
try {
|
System.out.println("通道: " + cameraInfo[j].nUniqueChannel);
|
// System.out.println("通道名称: " + new String(cameraInfo[j].szName, "GBK"));
|
System.out.println("通道名称: " + nameTable[cameraInfo[j].nUniqueChannel]);
|
System.out.println("状态: " + arrStatusName[emConnectionState]);
|
System.out.println("Ip地址: " + new String(cameraInfo[j].stuRemoteDevice.szIp));
|
System.out.println("端口: " + cameraInfo[j].stuRemoteDevice.nPort);
|
System.out.println("设备名称: " + new String(cameraInfo[j].stuRemoteDevice.szDevName, "GBK"));
|
System.out.println("远程通道号: " + cameraInfo[j].nChannelID);
|
System.out.println("设备类型: " + new String(cameraInfo[j].stuRemoteDevice.szDevClass));
|
System.out.println("设备具体类型: " + new String(cameraInfo[j].stuRemoteDevice.szDevType));
|
// System.out.println("是否支持云台控制: " + getPtzEnable(cameraInfo[j].nUniqueChannel));
|
|
System.out.println();
|
}catch(Exception e) {
|
|
}
|
|
|
|
}
|
} else {
|
System.err.println("MatrixGetCameras Failed." + ToolKits.getErrorCode());
|
}
|
}
|
|
private boolean getCameraState(int []statusTable) {
|
int nQueryType = NetSDKLib.NET_QUERY_GET_CAMERA_STATE;
|
|
NET_CAMERA_STATE_INFO[] arrStatus = new NET_CAMERA_STATE_INFO[deviceinfo.byChanNum];
|
for(int i = 0; i < arrStatus.length; i++) {
|
arrStatus[i] = new NET_CAMERA_STATE_INFO();
|
}
|
|
// 入参
|
NET_IN_GET_CAMERA_STATEINFO stIn = new NET_IN_GET_CAMERA_STATEINFO();
|
stIn.bGetAllFlag = 1; // 全部
|
|
// 出参
|
NET_OUT_GET_CAMERA_STATEINFO stOut = new NET_OUT_GET_CAMERA_STATEINFO();
|
stOut.nMaxNum = deviceinfo.byChanNum;
|
stOut.pCameraStateInfo = new Memory(arrStatus[0].size() * deviceinfo.byChanNum);
|
stOut.pCameraStateInfo.clear(arrStatus[0].size() * deviceinfo.byChanNum);
|
ToolKits.SetStructArrToPointerData(arrStatus, stOut.pCameraStateInfo); // 将数组内存拷贝到Pointer
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(bRet) {
|
stOut.read();
|
ToolKits.GetPointerDataToStructArr(stOut.pCameraStateInfo, arrStatus); // 将Pointer拷贝到数组内存
|
for (int i = 0; i < stOut.nValidNum; ++i) {
|
if (arrStatus[i].nChannel >= 0 &&
|
arrStatus[i].nChannel < deviceinfo.byChanNum) {
|
statusTable[arrStatus[i].nChannel] = arrStatus[i].emConnectionState;
|
}
|
}
|
} else {
|
System.err.println("getCameraState Failed!" + ToolKits.getErrorCode());
|
}
|
|
return bRet;
|
}
|
|
public boolean getChannelName(String [] arrChannelName) {
|
int nChnCount = deviceinfo.byChanNum;
|
NetSDKLib.CFG_VIDEO_IN_INFO deviceInfo[] = new NetSDKLib.CFG_VIDEO_IN_INFO[nChnCount];
|
for (int i = 0; i < nChnCount; ++ i) {
|
deviceInfo[i] = new NetSDKLib.CFG_VIDEO_IN_INFO();
|
}
|
|
int realCount = ToolKits.GetDevConfig(loginHandle, -1, NetSDKLib.CFG_CMD_VIDEOIN, deviceInfo);
|
if (realCount <= 0) {
|
System.err.println("Get Video In Failed." + ToolKits.getErrorCode());
|
return false;
|
}
|
|
for(int j = 0; j < realCount; ++ j)
|
{
|
try {
|
arrChannelName[j] = new String(deviceInfo[j].szRemoteName, "GBK");
|
}catch(Exception e) {
|
System.err.println("获取通道名称失败 通道: " + j);
|
}
|
}
|
return true;
|
}
|
|
|
// 备用方案
|
public String getChannelName(int channel) {
|
String channelName = "";
|
NetSDKLib.AV_CFG_ChannelName channelTitleName = new NetSDKLib.AV_CFG_ChannelName();
|
if (ToolKits.GetDevConfig(loginHandle, channel, NetSDKLib.CFG_CMD_CHANNELTITLE, channelTitleName)) {
|
try {
|
channelName = new String(channelTitleName.szName, "GBK");
|
}catch(Exception e) {
|
System.err.println("getChannelName Failed!");
|
}
|
}else {
|
System.err.println("Get Channel Name Failed." + ToolKits.getErrorCode());
|
}
|
// System.out.println(channelName);
|
return channelName;
|
}
|
|
/**
|
* 设置摄像头显示源
|
*/
|
public void SetCameras() {
|
// 设置的显示源个数
|
int nCameraCount = 1;
|
|
// 显示源信息数组初始化
|
NET_MATRIX_CAMERA_INFO[] cameras = new NET_MATRIX_CAMERA_INFO[nCameraCount];
|
for(int i = 0; i < nCameraCount; i++) {
|
cameras[i] = new NET_MATRIX_CAMERA_INFO();
|
}
|
|
cameras[0].nUniqueChannel = nQueryChannel; // 挂载通道
|
cameras[0].nChannelID = 1; // 通道号
|
|
// try {
|
// String name = "上山打老虎"; // 名称无法自己设置？？
|
// System.arraycopy(name.getBytes("GBK"), 0, cameras[0].szName, 0, name.getBytes("GBK").length);
|
// } catch (UnsupportedEncodingException e) {
|
// e.printStackTrace();
|
// }
|
|
cameras[0].bRemoteDevice = 1;
|
|
String ip = "172.32.103.7";
|
int port = 37777;
|
String username = "admin";
|
String password = "admin12345";
|
|
|
cameras[0].stuRemoteDevice.bEnable = 1;
|
System.arraycopy(ip.getBytes(), 0, cameras[0].stuRemoteDevice.szIp, 0, ip.getBytes().length);
|
cameras[0].stuRemoteDevice.nPort = port;
|
System.arraycopy(username.getBytes(), 0, cameras[0].stuRemoteDevice.szUserEx, 0, username.getBytes().length);
|
System.arraycopy(password.getBytes(), 0, cameras[0].stuRemoteDevice.szPwdEx, 0, password.getBytes().length);
|
|
System.arraycopy(ip.getBytes(), 0, cameras[0].stuRemoteDevice.szDevName, 0, ip.getBytes().length);
|
|
/*
|
* 入参
|
*/
|
NET_IN_MATRIX_SET_CAMERAS stuIn = new NET_IN_MATRIX_SET_CAMERAS();
|
stuIn.nCameraCount = nCameraCount;
|
stuIn.pstuCameras = new Memory(cameras[0].size() * nCameraCount);
|
stuIn.pstuCameras.clear(cameras[0].size() * nCameraCount);
|
|
ToolKits.SetStructArrToPointerData(cameras, stuIn.pstuCameras); // 将数组内存拷贝到Pointer
|
|
/*
|
* 出参
|
*/
|
NET_OUT_MATRIX_SET_CAMERAS stuOut = new NET_OUT_MATRIX_SET_CAMERAS();
|
|
if(netsdkApi.CLIENT_MatrixSetCameras(loginHandle, stuIn, stuOut, 5000)) {
|
System.out.println("设置摄像头显示源成功！");
|
} else {
|
System.err.println("设置摄像头显示源失败！" + ToolKits.getErrorCode());
|
}
|
}
|
|
|
/**
|
* 删除摄像头显示源
|
*/
|
public void DeleteCameras() {
|
// 设置的显示源个数
|
int nCameraCount = 1;
|
|
// 显示源信息数组初始化
|
NET_MATRIX_CAMERA_INFO[] cameras = new NET_MATRIX_CAMERA_INFO[nCameraCount];
|
for(int i = 0; i < nCameraCount; i++) {
|
cameras[i] = new NET_MATRIX_CAMERA_INFO();
|
}
|
|
cameras[0].nUniqueChannel = nQueryChannel; // 挂载通道
|
cameras[0].nChannelID = 0; // 通道号
|
|
cameras[0].bRemoteDevice = 1;
|
cameras[0].stuRemoteDevice.bEnable = 0;
|
|
/*
|
* 入参
|
*/
|
NET_IN_MATRIX_SET_CAMERAS stuIn = new NET_IN_MATRIX_SET_CAMERAS();
|
stuIn.nCameraCount = nCameraCount;
|
stuIn.pstuCameras = new Memory(cameras[0].size() * nCameraCount);
|
stuIn.pstuCameras.clear(cameras[0].size() * nCameraCount);
|
|
ToolKits.SetStructArrToPointerData(cameras, stuIn.pstuCameras); // 将数组内存拷贝到Pointer
|
|
/*
|
* 出参
|
*/
|
NET_OUT_MATRIX_SET_CAMERAS stuOut = new NET_OUT_MATRIX_SET_CAMERAS();
|
|
if(netsdkApi.CLIENT_MatrixSetCameras(loginHandle, stuIn, stuOut, 5000)) {
|
System.out.println("删除摄像头显示源成功！");
|
} else {
|
System.err.println("删除摄像头显示源失败！" + ToolKits.getErrorCode());
|
}
|
}
|
|
public void GetRemoteDevice() {
|
int nChnCount = deviceinfo.byChanNum;
|
NetSDKLib.AV_CFG_RemoteDevice deviceInfo[] = new NetSDKLib.AV_CFG_RemoteDevice[nChnCount];
|
for (int i = 0; i < nChnCount; ++ i) {
|
deviceInfo[i] = new NetSDKLib.AV_CFG_RemoteDevice();
|
}
|
|
/// 获取服务器所有远程设备的信息
|
int realCount = ToolKits.GetDevConfig(loginHandle, -1, NetSDKLib.CFG_CMD_REMOTEDEVICE, deviceInfo);
|
if (realCount <= 0) {
|
System.err.println("Get Remote Device Failed." + ToolKits.getErrorCode());
|
return;
|
}
|
for(int j = 0; j < realCount; ++ j)
|
{
|
System.out.println("————————————第 " + (j+1) + " 个 远程设备————————————");
|
PrintStruct.print(deviceInfo[j]);
|
}
|
}
|
|
public void GetRadiometryCaps() {
|
int nType = NetSDKLib.NET_RADIOMETRY_CAPS;
|
|
// 入参
|
NET_IN_RADIOMETRY_GETCAPS stIn = new NET_IN_RADIOMETRY_GETCAPS();
|
stIn.nChannel = nQueryChannel;
|
|
// 出参
|
NET_OUT_RADIOMETRY_GETCAPS stOut = new NET_OUT_RADIOMETRY_GETCAPS();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_GetDevCaps(loginHandle, nType, stIn.getPointer(), stOut.getPointer(), 3000);
|
if(bRet) {
|
stOut.read();
|
PrintStruct.print(stOut);
|
} else {
|
System.err.println("GetDevCaps Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
public void cfgPTZTour()
|
{
|
CFG_PTZTOUR_INFO stuPTZTour = new CFG_PTZTOUR_INFO();
|
if (ToolKits.GetDevConfig(loginHandle, 0, NetSDKLib.CFG_CMD_PTZTOUR, stuPTZTour)) {
|
for (int i = 0 ; i < stuPTZTour.nCount; ++i) {
|
System.out.println("------------" + (i+1) + "----------------");
|
System.out.println("bEnable: " + stuPTZTour.stTours[i].bEnable);
|
try {
|
System.out.println("szName: " + new String(stuPTZTour.stTours[i].szName, "GBK").trim());
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
System.out.println("nPresetsNum: " + stuPTZTour.stTours[i].nPresetsNum);
|
|
// for (int j = 0 ; j < stuPTZTour.stTours[i].nPresetsNum; ++j) {
|
// PrintStruct.print(stuPTZTour.stTours[i].stPresets[j]);
|
// }
|
}
|
}else {
|
System.err.println("get ptzTour Failed!" + ToolKits.getErrorCode());
|
}
|
|
String name = "预置点名称1";
|
try {
|
System.arraycopy(name.getBytes("GBK"), 0, stuPTZTour.stTours[0].szName, 0, name.getBytes("GBK").length);
|
} catch (UnsupportedEncodingException e) {
|
// TODO Auto-generated catch block
|
e.printStackTrace();
|
}
|
|
if (!ToolKits.SetDevConfig(loginHandle, 0, NetSDKLib.CFG_CMD_PTZTOUR, stuPTZTour)) {
|
System.err.println("set ptzTour Failed!" + ToolKits.getErrorCode());
|
}
|
}
|
|
/**
|
* 获取云台支持能力
|
*/
|
public boolean getPtzEnable(int chn) {
|
IntByReference error = new IntByReference(0);
|
byte[] buffer = new byte[1024];
|
|
if (!netsdkApi.CLIENT_QueryNewSystemInfo(loginHandle,
|
NetSDKLib.CFG_CAP_CMD_PTZ_ENABLE,
|
chn,
|
buffer,
|
buffer.length,
|
error,
|
3000)) {
|
System.err.println("CLIENT_QueryNewSystemInfo Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
|
NetSDKLib.CFG_CAP_PTZ_ENABLEINFO ptzCap = new NetSDKLib.CFG_CAP_PTZ_ENABLEINFO();
|
|
ptzCap.write();
|
|
if (!configApi.CLIENT_ParseData(NetSDKLib.CFG_CAP_CMD_PTZ_ENABLE, buffer,
|
ptzCap.getPointer(), ptzCap.size(), null)) {
|
System.err.println("CLIENT_ParseData Failed!" + ToolKits.getErrorCode());
|
return false;
|
}
|
|
ptzCap.read();
|
System.out.println(ptzCap.bEnable);
|
return ptzCap.bEnable == 1;
|
}
|
|
/**
|
* 查询视频通道信息
|
*/
|
public void QueryVideoChnInfo() {
|
int nQueryType = NetSDKLib.NET_QUERY_VIDEOCHANNELSINFO;
|
|
// 入参
|
NET_IN_GET_VIDEOCHANNELSINFO stIn = new NET_IN_GET_VIDEOCHANNELSINFO();
|
stIn.emType = NET_VIDEO_CHANNEL_TYPE.NET_VIDEO_CHANNEL_TYPE_INPUT; // 默认
|
|
// 出参
|
NET_OUT_GET_VIDEOCHANNELSINFO stOut = new NET_OUT_GET_VIDEOCHANNELSINFO();
|
|
stIn.write();
|
stOut.write();
|
|
boolean bRet = netsdkApi.CLIENT_QueryDevInfo(loginHandle, nQueryType, stIn.getPointer(), stOut.getPointer(), null, 3000);
|
if(!bRet) {
|
System.err.println("查询视频通道信息失败!" + ToolKits.getErrorCode());
|
return;
|
}
|
|
stOut.read();
|
|
PrintStruct.print(stOut.stInputChannels);
|
}
|
|
public void RunTest()
|
{
|
System.out.println("Run Test");
|
CaseMenu menu = new CaseMenu();
|
|
menu.addItem(new CaseMenu.Item(this , "获取测温区域的参数值" , "RadiometryGetRandomRegionTemper"));
|
menu.addItem(new CaseMenu.Item(this , "订阅温度分布数据" , "RadiometryAttach"));
|
menu.addItem(new CaseMenu.Item(this , "开始获取热图数据" , "RadiometryFetch"));
|
menu.addItem(new CaseMenu.Item(this , "取消订阅温度分布数据" , "RadiometryDetach"));
|
|
menu.addItem(new CaseMenu.Item(this , "查询热成像预设信息" , "QueryPresetInfo"));
|
menu.addItem(new CaseMenu.Item(this , "查询热成像感兴趣区域信息" , "QueryOptRegion"));
|
menu.addItem(new CaseMenu.Item(this , "查询热成像外部系统信息" , "QueryExtSysInfo"));
|
menu.addItem(new CaseMenu.Item(this , "查询测温点的参数值" , "QueryPointTemper"));
|
menu.addItem(new CaseMenu.Item(this , "查询测温项的参数值" , "QueryGetTemper"));
|
|
menu.addItem(new CaseMenu.Item(this , "转至预置点" , "MovePreset"));
|
menu.addItem(new CaseMenu.Item(this , "加入预置点到巡航" , "AddToLoop"));
|
menu.addItem(new CaseMenu.Item(this , "删除巡航中预置点" , "DeleteFromLoop"));
|
menu.addItem(new CaseMenu.Item(this , "清除巡航巡航线路" , "ClearLoop"));
|
menu.addItem(new CaseMenu.Item(this , "开始点间巡航" , "StartTour"));
|
menu.addItem(new CaseMenu.Item(this , "停止点间巡航" , "StopTour"));
|
menu.addItem(new CaseMenu.Item(this , "开启雨刷" , "OpenLamp"));
|
menu.addItem(new CaseMenu.Item(this , "关闭雨刷" , "CloseLamp"));
|
|
menu.addItem(new CaseMenu.Item(this , "设置摄像头显示源" , "SetCameras"));
|
menu.addItem(new CaseMenu.Item(this , "删除摄像头显示源" , "DeleteCameras"));
|
menu.addItem(new CaseMenu.Item(this , "获取远程设备的信息" , "GetCameraInfo"));
|
|
menu.addItem(new CaseMenu.Item(this , "获取当前云台的预置点列表" , "GetPresetList"));
|
menu.addItem(new CaseMenu.Item(this , "设置预置点" , "SetPreset"));
|
menu.addItem(new CaseMenu.Item(this , "删除预置点" , "DeletePreset"));
|
|
menu.addItem(new CaseMenu.Item(this , "热成像测温规则配置" , "ConfigThermometryRule"));
|
menu.addItem(new CaseMenu.Item(this , "热成像摄像头属性配置" , "ConfigThermographyOptions"));
|
menu.addItem(new CaseMenu.Item(this , "温度统计配置" , "ConfigTemperatureStatistics"));
|
menu.addItem(new CaseMenu.Item(this , "热成像测温全局配置" , "ConfigHeatImagingThermometry"));
|
|
menu.addItem(new CaseMenu.Item(this , "获取设备能力" , "GetRadiometryCaps"));
|
|
menu.addItem(new CaseMenu.Item(this , "QueryVideoChnInfo" , "QueryVideoChnInfo"));
|
|
menu.run();
|
}
|
|
public static void main(String[]args)
|
{
|
Radiometry demo = new Radiometry();
|
|
demo.InitTest();
|
demo.RunTest();
|
demo.EndTest();
|
}
|
}
|
