增加：坐标引导俯仰角度修正

liusuyi

2024-06-22 06a1c6004cef3290089a4b629006088a1a5e87a0

 ard-work/src/main/java/com/ruoyi/device/camera/service/impl/CameraSdkServiceImpl.java

@@ -1,23 +1,37 @@
package com.ruoyi.device.camera.service.impl;



import com.ruoyi.alarm.global.domain.GuidePoint;

import com.ruoyi.alarmpoints.well.domain.ArdAlarmpointsWell;

import com.ruoyi.alarmpoints.well.domain.ArdWellGuideCamera;

import com.ruoyi.alarmpoints.well.service.IArdAlarmpointsWellService;

import com.ruoyi.common.annotation.SdkOperate;

import com.ruoyi.common.constant.CacheConstants;

import com.ruoyi.common.core.domain.AjaxResult;

import com.ruoyi.common.core.redis.RedisCache;

import com.ruoyi.common.utils.SecurityUtils;

import com.ruoyi.common.utils.StringUtils;

import com.ruoyi.device.camera.domain.ArdCameras;

import com.ruoyi.device.camera.domain.CameraCmd;

import com.ruoyi.device.camera.service.IArdCamerasService;

import com.ruoyi.device.camera.service.ICameraSdkService;

import com.ruoyi.utils.sdk.dhsdk.service.IDhClientService;

import com.ruoyi.utils.sdk.hiksdk.service.IHikClientService;

import com.ruoyi.device.camera.factory.CameraSDK;

import com.ruoyi.device.camera.factory.CameraSDKFactory;

import com.ruoyi.device.noguidezone.domain.ArdCameraNoGuideZone;

import com.ruoyi.device.noguidezone.service.IArdCameraNoGuideZoneService;

import com.ruoyi.device.terrain.domain.ArdTerrainMark;

import com.ruoyi.device.terrain.service.IArdTerrainMarkService;

import com.ruoyi.utils.gis.GisUtil;

import com.ruoyi.utils.gis.Point;

import com.ruoyi.utils.sdk.common.GlobalVariable;

import com.ruoyi.utils.tools.ArdTool;

import lombok.extern.slf4j.Slf4j;

import org.springframework.boot.ApplicationArguments;

import org.springframework.boot.ApplicationRunner;

import org.springframework.stereotype.Service;



import javax.annotation.Resource;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.*;

import java.util.stream.Collectors;





/**

@@ -32,48 +46,62 @@
    @Resource

    private IArdCamerasService ardCamerasService;

    @Resource

    IHikClientService hikClientService;

    private RedisCache redisCache;

    @Resource

    IDhClientService dhClientService;

    private CameraSDKFactory cameraSDKFactory;

    @Resource

    RedisCache redisCache;

    private IArdAlarmpointsWellService ardAlarmpointsWellService;

    @Resource

    private IArdCameraNoGuideZoneService ardCameraNoGuideZoneService;

    @Resource

    private IArdTerrainMarkService ardTerrainMarkService;



    /**

     * 启动线程方法，用于执行初始化登录相机的逻辑

     *

     * @param args 命令行参数

     */

    @Override

    public void run(ApplicationArguments args) throws Exception {

    public void run(ApplicationArguments args) {

        try {

            List<ArdCameras> ardCameras = ardCamerasService.selectArdCamerasListNoDataScope(new ArdCameras());

            for (ArdCameras camera : ardCameras) {

                if ("1".equals(camera.getFactory())) {

                    hikClientService.login(camera);

                } else if ("2".equals(camera.getFactory())) {

                    dhClientService.login(camera);

                }

                asyncLogin(camera);

            }

        } catch (Exception ex) {

            log.error("初始化登录相机异常：" + ex.getMessage());

        }

    }



    //登录

    //同步登录

    @Override

    public Boolean login(ArdCameras ardCamera) {

        boolean result = false;

    public AjaxResult login(ArdCameras ardCamera) {

        try {

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    hikClientService.login(ardCamera);

                    result = true;

                } else if (factory.equals("2")) {

                    dhClientService.login(ardCamera);

                    result = true;

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.login(ardCamera);//同步登录

        } catch (Exception ex) {

            log.error("登录异常：" + ex.getMessage());

            return false;

            return AjaxResult.error("登录异常：" + ex.getMessage());

        }

        return result;

    }



    @Override

    public AjaxResult asyncLogin(ArdCameras ardCamera) {

        try {

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.asyncLogin(ardCamera);//异步登录

        } catch (Exception ex) {

            log.error("登录异常：" + ex.getMessage());

            return AjaxResult.error("登录异常：" + ex.getMessage());

        }

    }



    //注销

@@ -84,11 +112,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.logout(cameraId);

                } else if (factory.equals("2")) {

                    result = dhClientService.logout(cameraId);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                result = cameraSDK.logout(cameraId);

            }

        } catch (Exception ex) {

            log.error("注销异常：" + ex.getMessage());

@@ -106,11 +131,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    onLine = hikClientService.isOnLine(cmd);

                } else if (factory.equals("2")) {

                    onLine = dhClientService.isOnLine(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                onLine = cameraSDK.isOnLine(cmd);

            }

            return onLine;

        } catch (Exception ex) {

@@ -120,111 +142,88 @@
    }



    //云台控制

    @SdkOperate

    @Override

    public boolean pTZControl(CameraCmd cmd) {

        try {

            boolean result = false;

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.pTZControlWithSpeed(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.pTZControl(cmd);

                }

            }

            return result;

        } catch (Exception ex) {

            log.error("ptz控制异常：" + ex.getMessage());

            return false;

    public AjaxResult pTZControl(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();

        ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

        if (ardCamera == null) {

            AjaxResult.warn("设备不存在");

        }

        String factory = ardCamera.getFactory();

        CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

        return cameraSDK.pTZControl(cmd);

    }



    //设置聚焦值

    @Override

    public boolean setFocusPos(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult setFocusPos(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setFocusPos(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setFocusPos(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.setFocusPos(cmd);

        } catch (Exception ex) {

            log.error("设置聚焦值异常：" + ex.getMessage());



            return AjaxResult.error("设置聚焦值异常：" + ex.getMessage());

        }

        return result;

    }



    //获取聚焦值

    @Override

    public int getFocusPos(CameraCmd cmd) {

        int result = 0;

    public AjaxResult getFocusPos(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getFocusPos(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.getFocusPos(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.getFocusPos(cmd);

        } catch (Exception ex) {

            log.error("获取聚焦值异常：" + ex.getMessage());

            return AjaxResult.error("获取聚焦值异常:" + ex.getMessage());

        }

        return result;

    }



    //设置预置位

    @Override

    public boolean setPreset(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult setPreset(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setPreset(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setPreset(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.setPreset(cmd);

        } catch (Exception ex) {

            log.error("设置预置位异常：" + ex.getMessage());

            return AjaxResult.error("设置预置位异常" + ex.getMessage());

        }

        return result;

    }



    //调用预置位

    @Override

    public boolean gotoPreset(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult gotoPreset(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.gotoPreset(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.gotoPreset(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.gotoPreset(cmd);

        } catch (Exception ex) {

            log.error("调用预置位异常：" + ex.getMessage());

            return AjaxResult.error("调用预置位异常" + ex.getMessage());

        }

        return result;

    }



    //获取码流压缩参数

@@ -234,14 +233,12 @@
        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getVideoCompressionCfg(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getVideoCompressionCfg(cmd);

                }

            if (ardCamera == null) {

                return new HashMap<>();

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            map = cameraSDK.getVideoCompressionCfg(cmd);

        } catch (Exception ex) {

            log.error("获取码流压缩参数异常：" + ex.getMessage());

        }

@@ -250,158 +247,149 @@


    //透雾开关

    @Override

    public boolean controlDefogcfg(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult controlDefogcfg(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlDefogcfg(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.controlDefogcfg(cmd);

        } catch (Exception ex) {

            log.error("操控透雾异常：" + ex.getMessage());

            return AjaxResult.error("操控透雾异常" + ex.getMessage());

        }

        return result;

    }



    //红外开关

    @Override

    public boolean controlInfrarecfg(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult controlInfrarecfg(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlInfrarecfg(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.controlInfrarecfg(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.controlInfrarecfg(cmd);

        } catch (Exception ex) {

            log.error("操控红外异常：" + ex.getMessage());

            return AjaxResult.error("操控红外异常:" + ex.getMessage());

        }

        return result;

    }



    //手动/自动聚焦

    @Override

    public boolean controlFocusMode(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult controlFocusMode(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlFocusMode(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.controlFocusMode(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.controlFocusMode(cmd);

        } catch (Exception ex) {

            log.error("操控聚焦模式异常：" + ex.getMessage());

            return AjaxResult.error("操控聚焦模式异常:" + ex.getMessage());

        }

        return result;

    }



    //获取聚焦模式

    @Override

    public String getFocusMode(CameraCmd cmd) {

        String result = "";

    public AjaxResult getFocusMode(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getFocusMode(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.getFocusMode(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.getFocusMode(cmd);

        } catch (Exception ex) {

            log.error("获取聚焦模式异常：" + ex.getMessage());

            return AjaxResult.error("获取聚焦模式异常：" + ex.getMessage());

        }

        return result;

    }



    //云台加热

    @Override

    public boolean controlPTHeateRpwron(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult controlPTHeateRpwron(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlPTHeateRpwron(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.controlPTHeateRpwron(cmd);

        } catch (Exception ex) {

            log.error("操控云台加热异常：" + ex.getMessage());

            return AjaxResult.error("操控云台加热异常:" + ex.getMessage());

        }

        return result;

    }



    //镜头加热

    @Override

    public boolean controlCameraDeicing(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult controlCameraDeicing(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.controlCameraDeicing(cmd);

                } else if (factory.equals("2")) {

                    //不支持

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.controlCameraDeicing(cmd);

        } catch (Exception ex) {

            log.error("操控云台加热异常：" + ex.getMessage());

            return AjaxResult.error("操控云台加热异常：" + ex.getMessage());

        }

        return result;

    }



    //获取云台锁定信息

    @Override

    public int getPTZLockInfo(CameraCmd cmd) {

        int result = 99;

    public AjaxResult getPTZLockInfo(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.getPTZLockInfo(cmd);

                } else if (factory.equals("2")) {



                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.getPTZLockInfo(cmd);

        } catch (Exception ex) {

            log.error("获取云台锁定信息异常：" + ex.getMessage());

            log.error("获取云台锁定信息异常:" + ex.getMessage());

            return AjaxResult.error("获取云台锁定信息异常:" + ex.getMessage());

        }

        return result;

    }



    //本地抓图

    @Override

    public String captureJPEGPicture(CameraCmd cmd) {

        return null;

    public AjaxResult localCapture(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.localCapture(cmd);

        } catch (Exception ex) {

            log.error("手动抓图异常:" + ex.getMessage());

            return AjaxResult.error("手动抓图异常:" + ex.getMessage());

        }

    }



    //抓图

    @SdkOperate

    @Override

    public String picCutCate(CameraCmd cmd) {

        String url = "";

@@ -413,13 +401,8 @@
            if (ardCamera != null) {

                //获取摄像头工厂

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    //调用hikClientService的picCutCate方法

                    url = hikClientService.picCutCate(cmd);

                } else if (factory.equals("2")) {

                    //调用dhClientService的picCutCate方法

                    url = dhClientService.picCutCate(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                url = cameraSDK.picCutCate(cmd);

            }

        } catch (Exception ex) {

            log.error("抓图异常：" + ex.getMessage());

@@ -429,108 +412,303 @@


    //获取ptz

    @Override

    public Map<String, Object> getPtz(CameraCmd cmd) {

    public AjaxResult getPtz(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getPtz(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getPtz(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            String gdtype = ardCamera.getGdtype();

            if (gdtype.equals("1")) {

                return cameraSDK.getPtzHigh(cmd);

            } else {

                return cameraSDK.getPtz(cmd);

            }

        } catch (Exception ex) {

            log.error("获取ptz异常：" + ex.getMessage());

            return AjaxResult.error("获取ptz异常：" + ex.getMessage());

        }

        return map;

    }



    //获取ptz范围

    @Override

    public Map<String, Object> getPtzScope(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();

    public AjaxResult getPtzScope(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getPtzScope(cmd);

                } else if (factory.equals("2")) {



                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.getPtzScope(cmd);

        } catch (Exception ex) {

            log.error("获取ptz范围异常：" + ex.getMessage());

            return AjaxResult.error("获取ptz范围异常：" + ex.getMessage());

        }

        return map;

    }



    //设置ptz

    @SdkOperate

    @Override

    public boolean setPtz(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult setPtz(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setPtz(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setPtz(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(ardCamera.getFactory());

            String gdtype = ardCamera.getGdtype();

            if (gdtype.equals("1")) {

                //大光电使用高精度ptz设置

                return cameraSDK.setPtzHigh(cmd);

            } else {

                return cameraSDK.setPtz(cmd);

            }

        } catch (Exception ex) {

            log.error("设置ptz异常：" + ex.getMessage());

            return AjaxResult.error("设置ptz异常:" + ex.getMessage());

        }

        return result;

    }



    //设置零方位角

    @SdkOperate

    @Override

    public boolean setZeroPtz(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult setZeroPtz(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.setZeroPtz(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.setZeroPtz(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.setZeroPtz(cmd);

        } catch (Exception ex) {

            log.error("设置零方位角异常：" + ex.getMessage());

            return AjaxResult.error("设置零方位角异常：" + ex.getMessage());

        }

        return result;

    }



    //引导指向目标

    @SdkOperate

    @Override

    public boolean guideTargetPosition(CameraCmd cmd) {

        boolean result = false;

    public AjaxResult guideTargetPosition(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.guideTargetPosition(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.guideTargetPosition(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.guideTargetPosition(cmd);

        } catch (Exception ex) {

            log.error("引导指向目标异常:" + ex.getMessage());

            return AjaxResult.error("引导指向目标异常:" + ex.getMessage());

        }

    }



    /**

     * @return

     * @Author 刘苏义

     * @Description 修正俯仰值（根据相机ID获取500米范围内的地形参数集合，计算平均值加上T值）

     * @Date 2024/6/22 11:16

     * @Param

     */

    @Override

    public Double correctPitch(CameraCmd cmd) {

        Double pitchAngle = 0.0;

        try {

            double[] targetPositions = cmd.getTargetPosition();

            ArdTerrainMark ardTerrainMark = new ArdTerrainMark();

            ardTerrainMark.setCameraId(cmd.getCameraId());

            List<ArdTerrainMark> ardTerrainMarks = ardTerrainMarkService.selectArdTerrainMarkList(ardTerrainMark);

            //过滤500米范围内的集合

            ardTerrainMarks = ardTerrainMarks.stream().filter(n -> GisUtil.getDistance(targetPositions, new double[]{n.getLongitude(), n.getLatitude(), n.getAltitude()}) <= 500).collect(Collectors.toList());

            //计算T平均值

            OptionalDouble averageT = ardTerrainMarks.stream().mapToDouble(ArdTerrainMark::getT).average();

            // 输出

            if (averageT.isPresent()) {

                pitchAngle = averageT.getAsDouble();

                log.debug("修正俯仰值：" + pitchAngle);

            }

        } catch (Exception ex) {

            log.error("引导指向目标异常：" + ex.getMessage());

            log.error("修正俯仰值异常：" + ex.getMessage());



        }

        return pitchAngle;

    }



    //引导指向井

    @Override

    public AjaxResult guideTargetWell(CameraCmd cmd) {



        //按日夜切换配置获取相机通道

        Integer chanNo = ArdTool.getChannelBydayNightTime(redisCache.getCacheObject("sys_config:dayNightTime"));

        cmd.setChanNo(chanNo);



        //获取井

        ArdAlarmpointsWell well = ardAlarmpointsWellService.selectArdAlarmpointsWellById(cmd.getWellId());

        if (well == null) {

            return AjaxResult.warn("井不存在");

        }

        GuidePoint guidePoint = new GuidePoint().setLongitude(well.getLongitude()).setLatitude(well.getLatitude());

        cmd.setTargetPosition(new double[]{guidePoint.getLongitude(), guidePoint.getLatitude()});



        //获取井配置的引导相机列表

        List<ArdWellGuideCamera> ardWellGuideCameraList = well.getArdWellGuideCameraList();

        if (ardWellGuideCameraList != null && ardWellGuideCameraList.size() > 0) {

            //获取相机和井的距离进行排序，取出最近的一个相机

            Map<String, Double> distanceMap = new HashMap<>();

            for (ArdWellGuideCamera ardWellGuideCamera : ardWellGuideCameraList) {

                ArdCameras cameras = ardCamerasService.selectArdCamerasById(ardWellGuideCamera.getCameraId());

                if (cameras == null) {

                    continue;

                }

                double[] targetPosition = new double[]{well.getLongitude(), well.getLatitude()};

                double[] camPosition = new double[]{cameras.getLongitude(), cameras.getLatitude()};

                double distance = GisUtil.getDistance(targetPosition, camPosition);

                distanceMap.put(ardWellGuideCamera.getCameraId(), distance);//存入缓存map

            }

            //从缓存里取出距离最近相机ID

            String cameraId = ArdTool.getKeyByMinValue(distanceMap);

            cmd.setCameraId(cameraId);

            //获取最近相机的对象

            Optional<ArdWellGuideCamera> first = ardWellGuideCameraList.stream().filter(s -> s.getCameraId().equals(cameraId)).findFirst();

            if (first.isPresent()) {

                ArdWellGuideCamera ardWellGuideCamera = first.get();

                Map<String, Double> ptzMap = null;

                //通过通道获取预置位

                switch (chanNo) {

                    case 1:

                        if (ardWellGuideCamera.getP1() != null) {

                            ptzMap = new HashMap<>();

                            ptzMap.put("p" , ardWellGuideCamera.getP1());

                            ptzMap.put("t" , ardWellGuideCamera.getT1());

                            ptzMap.put("z" , ardWellGuideCamera.getZ1());

                        }

                        break;

                    case 2:

                        if (ardWellGuideCamera.getP2() != null) {

                            ptzMap = new HashMap<>();

                            ptzMap.put("p" , ardWellGuideCamera.getP2());

                            ptzMap.put("t" , ardWellGuideCamera.getT2());

                            ptzMap.put("z" , ardWellGuideCamera.getZ2());

                        }

                        break;



                }

                //引导

                if (ptzMap != null) {

                    //使用ptz引导

                    cmd.setPtzMap(ptzMap);

                    return setPtz(cmd);

                }

            }



        }

        log.debug("未找到ptz引导相机,查找最近相机");



        //从附近相机找最近的一个相机

        String cameraId = getCameraByNear(new double[]{well.getLongitude(), well.getLatitude()});

        cmd.setCameraId(cameraId);

        if ("".equals(cameraId)) {

            return AjaxResult.warn("未找到引导相机");

        }

        //判断禁引区

        if (isInPolygon(cameraId, new Double[]{well.getLongitude(), well.getLatitude()})) {

            return AjaxResult.warn("井位置属于相机禁止引导区域");

        }

        //按井坐标开始引导

        if (!guideTargetPosition(cmd).get("code").equals(200)) {

            return AjaxResult.warn("井坐标引导失败" , "cameraId:" + cameraId);

        }

        return AjaxResult.success("井坐标引导成功" , "cameraId:" + cameraId);



    }



    /**

     * 获取最近距离的光电

     * 1-相机在线

     * 2-开启报警引导功能

     * 3-配置了最大可视距离

     */

    private String getCameraByNear(double[] targetPosition) {

        String minDistanceCameraId = "";

        try {

            //获取所有大光电

            List<Object> Objects = redisCache.getListKey(CacheConstants.CAMERA_LIST_KEY);

            //统计所有大光电可视范围内与报警点的距离

            Map<String, Double> distanceMap = new HashMap<>();

            for (Object obj : Objects) {

                ArdCameras camera = (ArdCameras) obj;



                if (!GlobalVariable.loginMap.containsKey(camera.getId())) {

                    log.debug("该光电未登录");

                    continue;

                }

                if (camera.getCamMaxVisibleDistance() == null) {

                    log.debug("该光电未配置最大可视距离");

                    continue;

                }

                if (camera.getCamAlarmGuideEnable().equals(0)) {

                    log.debug("该光电未开启报警引导");

                    continue;

                }



                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};

                double distance = GisUtil.getDistance(targetPosition, camPosition);

                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {

                    distanceMap.put(camera.getId(), distance);

                    if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {

                        camera.setCamAlarmGuideEnable(0);

                    }

                }

            }

            if (distanceMap.size() > 0) {

                log.debug("尝试查找最近光电");

                //获取距离字典中最近的一个相机ID

                minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);

                log.debug("查找到最近光电:" + minDistanceCameraId);

            }

        } catch (Exception ex) {

            log.error("获取附近开启报警引导功能光电异常:" + ex.getMessage());

        }

        return minDistanceCameraId;

    }



    //判断相机和引导位置是否在禁止引导区域

    public boolean isInPolygon(String cameraId, Double[] targetPosition) {

        boolean result = false;

        //拦截手动引导

        ArdCameraNoGuideZone ardCameraNoGuideZone = new ArdCameraNoGuideZone();

        ardCameraNoGuideZone.setCameraId(cameraId);

        ardCameraNoGuideZone.setEnabled("1");

        //获取当前相机的禁引可视域列表

        List<ArdCameraNoGuideZone> ardCameraNoGuideZones = ardCameraNoGuideZoneService.selectArdCameraNoGuideZoneList(ardCameraNoGuideZone);

        if (ardCameraNoGuideZones.size() > 0) {

            //获取到当前相机的坐标集合

            for (ArdCameraNoGuideZone zone : ardCameraNoGuideZones) {

                String[] parts = zone.getPoi().split(",");

                List<Point> pointList = new ArrayList<>();

                for (int i = 0; i < parts.length; i += 3) {

                    Point point = new Point();

                    point.setLongitude(Double.valueOf(parts[i]));

                    point.setLatitude(Double.valueOf(parts[i + 1]));

                    pointList.add(point);

                }

                double lon = targetPosition[0];

                double lat = targetPosition[1];

                Point targetPoint = new Point(lon, lat);

                //判断引导目标是否在坐标集合组成的多边形内

                boolean inPolygon = GisUtil.isInPolygon(targetPoint, pointList);

                if (inPolygon) {

                    result = inPolygon;

                }

            }

        }

        return result;

    }

@@ -545,14 +723,17 @@
     */

    @Override

    @SdkOperate

    public boolean controlLock(CameraCmd cmd) {

    public AjaxResult controlLock(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();//申请锁的相机

        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);

        if (ardCameras == null) {

            return AjaxResult.warn("设备不存在");

        }

        Date now = new Date();

        now.setTime(now.getTime() + cmd.getExpired() * 1000);

        ardCameras.setOperatorExpired(now);//设置当前过期时间

        ardCamerasService.updateArdCameras(ardCameras);

        return true;

        return AjaxResult.success("操控锁定成功");

    }



    /**

@@ -564,10 +745,13 @@
     * @修改人和其它信息

     */

    @Override

    public boolean controlUnLock(CameraCmd cmd) {

    public AjaxResult controlUnLock(CameraCmd cmd) {

        String cameraId = cmd.getCameraId();//申请解锁的相机

        String operator = cmd.getOperator();//申请者

        ArdCameras ardCameras = ardCamerasService.selectArdCamerasById(cameraId);

        if (ardCameras == null) {

            return AjaxResult.warn("设备不存在");

        }

        if (ardCameras.getOperatorId().equals(operator)) {

            //如果解锁相机的当前用户是申请者，则清空该相机的过期时间

            ardCameras.setOperatorExpired(null);

@@ -576,9 +760,9 @@
                log.debug(cameraId + "--解锁成功");

            }

        }

        return true;

    }



        return AjaxResult.success("操控解锁成功");

    }



    //录像

    @SdkOperate

@@ -590,11 +774,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    url = hikClientService.record(cmd);

                } else if (factory.equals("2")) {

                    url = dhClientService.record(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                url = cameraSDK.record(cmd);

            }

        } catch (Exception ex) {

            log.error("录像异常：" + ex.getMessage());

@@ -611,11 +792,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.recordStart(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.recordStart(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                result = cameraSDK.recordStart(cmd);

            }

        } catch (Exception ex) {

            log.error("开始录像异常：" + ex.getMessage());

@@ -632,11 +810,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    url = hikClientService.recordStopToMinio(cmd);

                } else if (factory.equals("2")) {

                    url = dhClientService.recordStopToMinio(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                url = cameraSDK.recordStopToMinio(cmd);

            }

        } catch (Exception ex) {

            log.error("停止录像异常：" + ex.getMessage());

@@ -653,11 +828,8 @@
            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    result = hikClientService.recordStopNotToMinio(cmd);

                } else if (factory.equals("2")) {

                    result = dhClientService.recordStopNotToMinio(cmd);

                }

                CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

                result = cameraSDK.recordStopNotToMinio(cmd);

            }

        } catch (Exception ex) {

            log.error("停止录像异常：" + ex.getMessage());

@@ -667,24 +839,55 @@


    //获取相机架设参数

    @Override

    public Map<String, Object> getGisInfo(CameraCmd cmd) {

        Map<String, Object> map = new HashMap<>();

    public AjaxResult getGisInfo(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera != null) {

                String factory = ardCamera.getFactory();

                if (factory.equals("1")) {

                    map = hikClientService.getGisInfo(cmd);

                } else if (factory.equals("2")) {

                    map = dhClientService.getGisInfo(cmd);

                }

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.getGisInfo(cmd);

        } catch (Exception ex) {

            log.error("获取相机架设参数异常：" + ex.getMessage());

            return AjaxResult.error("获取相机架设参数异常：" + ex.getMessage());

        }

        return map;

    }



    //本地录像开始

    @Override

    public AjaxResult localRecordStart(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.localRecordStart(cmd);

        } catch (Exception ex) {

            log.error("本地录像开始异常：" + ex.getMessage());

            return AjaxResult.error("本地录像开始异常：" + ex.getMessage());

        }

    }



    //本地录像停止

    @Override

    public AjaxResult localRecordStop(CameraCmd cmd) {

        try {

            String cameraId = cmd.getCameraId();

            ArdCameras ardCamera = redisCache.getCacheObject(CacheConstants.CAMERA_LIST_KEY + cameraId);

            if (ardCamera == null) {

                return AjaxResult.warn("设备不存在");

            }

            String factory = ardCamera.getFactory();

            CameraSDK cameraSDK = cameraSDKFactory.createCameraSDK(factory);

            return cameraSDK.localRecordStop(cmd);

        } catch (Exception ex) {

            log.error("本地录像停止异常：" + ex.getMessage());

            return AjaxResult.error("本地录像停止异常：" + ex.getMessage());

        }

    }

}