优化

‘liusuyi’

2023-06-30 a38cb5bb3898f8996321df8f8d537ea18f4af71f

 ard-work/src/main/java/com/ruoyi/alarm/globalAlarm/service/impl/GlobalAlarmServiceImpl.java

@@ -5,8 +5,11 @@
import com.ruoyi.alarm.cameraAlarm.mapper.ArdAlarmCameraMapper;
import com.ruoyi.alarm.globalAlarm.domain.GlobalAlarmCondition;
import com.ruoyi.alarm.globalAlarm.domain.GlobalAlarmData;
import com.ruoyi.alarm.globalAlarm.domain.GuidePriorityQueue;
import com.ruoyi.alarm.globalAlarm.domain.GuideTask;
import com.ruoyi.alarm.globalAlarm.service.IGlobalAlarmService;
import com.ruoyi.alarm.radarAlarm.domain.ArdAlarmRadar;
import com.ruoyi.alarm.radarAlarm.domain.RadarAlarmData;
import com.ruoyi.alarm.radarAlarm.mapper.ArdAlarmRadarMapper;
import com.ruoyi.alarm.stealAlarm.domain.ArdAlarmStealelec;
import com.ruoyi.alarm.stealAlarm.mapper.ArdAlarmStealelecMapper;
@@ -21,6 +24,7 @@
import com.ruoyi.common.core.redis.RedisCache;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.constant.CamPriority;
import com.ruoyi.utils.tools.ArdTool;
import com.ruoyi.utils.tools.GisTool;
import com.ruoyi.common.utils.uuid.IdUtils;
@@ -39,6 +43,7 @@
import javax.annotation.Resource;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.concurrent.PriorityBlockingQueue;
import java.util.stream.Collectors;


@@ -52,20 +57,21 @@
@Service
@Slf4j(topic = "mqtt")
public class GlobalAlarmServiceImpl implements IGlobalAlarmService {
    //region 依赖注入
    @Resource
    ArdAlarmRadarMapper ardAlarmRadarMapper;
    private ArdAlarmRadarMapper ardAlarmRadarMapper;
    @Resource
    ArdAlarmStealelecMapper ardAlarmStealelecMapper;
    private ArdAlarmStealelecMapper ardAlarmStealelecMapper;
    @Resource
    ArdAlarmTubeMapper ardAlarmTubeMapper;
    private ArdAlarmTubeMapper ardAlarmTubeMapper;
    @Resource
    ArdAlarmCameraMapper ardAlarmCameraMapper;
    private ArdAlarmCameraMapper ardAlarmCameraMapper;
    @Resource
    ArdTubesMapper ardTubesMapper;
    private ArdTubesMapper ardTubesMapper;
    @Resource
    ArdAlarmpointsWellMapper ardAlarmpointsWellMapper;
    private ArdAlarmpointsWellMapper ardAlarmpointsWellMapper;
    @Resource
    ArdTubesDetailsMapper ardTubesDetailsMapper;
    private ArdTubesDetailsMapper ardTubesDetailsMapper;
    @Resource
    private ISysConfigService configService;
    @Resource
@@ -74,6 +80,36 @@
    private IHikClientService hikClientService;
    @Resource
    private RedisCache redisCache;
    @Resource
    private QueueManager queueManager;
    //endregion

    /**
     * @描述 查询所有报警的当前数量
     * @参数 []
     * @返回值 java.util.Map<java.lang.String, java.lang.Integer>
     * @创建人 刘苏义
     * @创建时间 2023/6/13 16:30
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> selectAlarmLogsCount() {
        Map<String, Object> map = new HashMap<>();
        Map<String, Integer> countMap = new HashMap<>();
        String refreshTime = configService.selectConfigByKey("refreshTime");
        int count1001 = ardAlarmStealelecMapper.selectCountByStartTime(refreshTime);
        countMap.put("1001", count1001);
        int count1002 = ardAlarmCameraMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1002", count1002);
        int count1003 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime, "运动目标检测");
        countMap.put("1003", count1003);
        int count1004 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime, "热源检测");
        countMap.put("1004", count1004);
        int count1014 = ardAlarmTubeMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1014", count1014);
        map.put("20000", countMap);
        return map;
    }

    /**
     * @描述 按条件查询报警
@@ -119,7 +155,7 @@
                        })
                        .collect(Collectors.toList());
            case 1003:
                List<ArdAlarmRadar> ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime,"运动目标检测");
                List<ArdAlarmRadar> ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime, "运动目标检测");
                return ardAlarmRadars.stream()
                        .map(ardAlarmRadar -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
@@ -134,7 +170,7 @@
                        })
                        .collect(Collectors.toList());
            case 1004:
                ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime,"热源检测");
                ardAlarmRadars = ardAlarmRadarMapper.selectListAllByCommand(refreshTime, "热源检测");
                return ardAlarmRadars.stream()
                        .map(ardAlarmRadar -> {
                            GlobalAlarmData globalAlarmData = new GlobalAlarmData()
@@ -170,256 +206,13 @@
    }

    /**
     * @描述 按条件更新查看时间
     * @参数 [condition]
     * @描述 历史报警查询
     * @参数 [command, beginTime, endTime, pageNum, pageSize]
     * @返回值 java.lang.Object
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:48
     * @创建时间 2023/6/28 13:30
     * @修改人和其它信息
     */
    @Override
    public Object updateAlarmViewTime(GlobalAlarmCondition condition) {
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        switch (condition.getCommand()) {
            case 1001:
                ArdAlarmStealelec ardAlarmStealelec = ardAlarmStealelecMapper.selectByPrimaryKey(condition.getId());
                if (StringUtils.isNotNull(ardAlarmStealelec)) {
                    String describe = ardAlarmStealelec.getDescribe();
                    String startTime = fmt.format(ardAlarmStealelec.getStartTime());
                    int i = ardAlarmStealelecMapper.updateViewTimeByDescribe(describe, startTime, DateUtils.getTime());
                    return ardAlarmStealelec;
                }
            case 1014:
                ArdAlarmTube ardAlarmTube = ardAlarmTubeMapper.selectArdAlarmTubeById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmTube)) {
                    String tubeId = ardAlarmTube.getTubeId();
                    String alarmTime = fmt.format(ardAlarmTube.getAlarmTime());
                    int i = ardAlarmTubeMapper.updateViewTimeByTubeId(tubeId, alarmTime, DateUtils.getTime());
                    return ardAlarmTube;
                }
            default:
                return null;
        }
    }

    /**
     * @描述 异步处理接收的报警
     * @参数 [topic, message]
     * @返回值 void
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:46
     * @修改人和其它信息
     */
    @Override
    @Async("alarmExecutor")
    public void receiveAlarm(String topic, String message) {
        try {
            String simpleUUID = IdUtils.simpleUUID();
            switch (topic) {
                case "stealelec":
                    //region 处理盗电报警
                    ArdAlarmStealelec ardAlarmStealelec = JSONObject.parseObject(message, ArdAlarmStealelec.class);
                    ArdAlarmpointsWell well = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(ardAlarmStealelec.getDescribe());
                    if (well != null) {
                        ardAlarmStealelec.setLongitude(well.getLongitude());
                        ardAlarmStealelec.setLatitude(well.getLatitude());
                        ardAlarmStealelec.setAltitude(well.getAltitude());
                    }
                    ArdAlarmStealelec existe = ardAlarmStealelecMapper.selectByPrimaryKey(ardAlarmStealelec.getId());
                    if (StringUtils.isNotNull(existe)) {
                        return;
                    }
                    int aas = ardAlarmStealelecMapper.insertArdAlarmStealelec(ardAlarmStealelec);
                    if (aas > 0) {
                        log.info("stealelec入库成功：" + ardAlarmStealelec);
                        //引导录像
                        CameraCmd cmd = new CameraCmd();
                        cmd.setRecordBucketName("record");
                        cmd.setRecordObjectName("stealelec");
                        cmd.setOperator("sys_steal_elec");
                        cmd.setExpired(30);
                        cmd.setTargetPosition(new double[]{well.getLongitude(), well.getLatitude(), well.getAltitude()});
                        String url = guideCamera(cmd);
                        if (StringUtils.isNotEmpty(url)) {
                            //更新录像
                            ardAlarmStealelec.setRecordUrl(url);
                            ardAlarmStealelecMapper.updateArdAlarmStealelec(ardAlarmStealelec);
                        }
                    }
                    //endregion
                    break;
                case "tube":
                    //region 处理管线泄露报警
                    ArdAlarmTube ardAlarmTube = JSONObject.parseObject(message, ArdAlarmTube.class);
                    ardAlarmTube.setId(simpleUUID);
                    ArdTubesDetails atd = new ArdTubesDetails();
                    atd.setReelNumber(ardAlarmTube.getTubeId());
                    List<ArdTubesDetails> ardTubesDetails = ardTubesDetailsMapper.selectArdTubesDetailsList(atd);
                    if (ardTubesDetails.size() > 0) {
                        String tubeId = ardTubesDetails.get(0).getTubeId();
                        ArdTubes ardTubes = ardTubesMapper.selectArdTubesById(tubeId);
                        ardAlarmTube.setTubeName(ardTubes.getName());
                        ardAlarmTube.setColor(ardTubes.getColor());
                        ardAlarmTube.setPipeDiameter(ardTubes.getPipeDiameter());
                        ardAlarmTube.setTubeType(ardTubes.getType());
                        GeoPoint geoPoint = TubeTools.CalculateCoordinates(ardTubesDetails, ardAlarmTube.getPosition());
                        if (StringUtils.isNotNull(geoPoint)) {
                            ardAlarmTube.setLongitude(geoPoint.getLongitude());
                            ardAlarmTube.setLatitude(geoPoint.getLatitude());
                            ardAlarmTube.setAltitude(geoPoint.getAltitude());
                        }
                    }
                    int aat = ardAlarmTubeMapper.insertArdAlarmTube(ardAlarmTube);
                    if (aat > 0) {
                        log.debug("tube入库成功：" + ardAlarmTube);
                        //引导录像
                        CameraCmd cmd = new CameraCmd();
                        cmd.setRecordBucketName("record");
                        cmd.setRecordObjectName("tube");
                        cmd.setOperator("sys_tube_leak");
                        cmd.setExpired(30);
                        cmd.setTargetPosition(new double[]{ardAlarmTube.getLongitude(), ardAlarmTube.getLatitude(), ardAlarmTube.getAltitude()});
                        String url = guideCamera(cmd);
                        //更新录像
                        if (StringUtils.isNotEmpty(url)) {
                            ardAlarmTube.setRecordUrl(url);
                            ardAlarmTubeMapper.updateArdAlarmTube(ardAlarmTube);
                        }
                    }
                    //endregion
                    break;
                case "camera":
                    //region 处理通用光电报警
                    ArdAlarmCamera ardAlarmCamera = JSONObject.parseObject(message, ArdAlarmCamera.class);
                    ardAlarmCamera.setId(simpleUUID);
                    int aac = ardAlarmCameraMapper.insertArdAlarmCamera(ardAlarmCamera);
                    if (aac > 0) {
                        log.debug("camera入库成功：" + ardAlarmCamera);
                        //引导录像
                        CameraCmd cmd = new CameraCmd();
                        cmd.setRecordBucketName("record");
                        cmd.setRecordObjectName("camera");
                        cmd.setOperator("sys_camera");
                        cmd.setExpired(30);
                        cmd.setTargetPosition(new double[]{ardAlarmCamera.getLongitude(), ardAlarmCamera.getLatitude()});
                        String url = guideCamera(cmd);
                        //更新录像
                        if (StringUtils.isNotEmpty(url)) {
                            ardAlarmCamera.setRecordUrl(url);
                            ardAlarmCameraMapper.updateArdAlarmCamera(ardAlarmCamera);
                        }
                    }
                    //endregion
                    break;
                case "radar":
                    //region 处理雷达报警
                    ArdAlarmRadar ardAlarmRadar = JSONObject.parseObject(message, ArdAlarmRadar.class);
                    ardAlarmRadar.setId(simpleUUID);
                    int aar = ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);
                    if (aar > 0) {
                        log.debug("radar入库成功：" + ardAlarmRadar);
                    }
                    //endregion
                    break;
            }
        } catch (Exception ex) {
            log.error("接收报警异常:" + ex.getMessage());
        }
    }

    /**
     * @描述 引导最近的大光电指向目标
     * @参数 [targetPosition]
     * @返回值 java.lang.String
     * @创建人 刘苏义
     * @创建时间 2023/6/15 11:55
     * @修改人和其它信息
     */
    private String guideCamera(CameraCmd cmd) {
        String url = "";
        try {
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            //获取所有大光电
            List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
            //统计所有大光电可视范围内与报警点的距离
            Map<String, Double> distanceMap = new HashMap<>();
            Map<String, Integer> guideMap = new HashMap<>();
            for (ArdCameras camera : ardCamerasList) {
                double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
                double distance = GisTool.getDistance(cmd.getTargetPosition(), camPosition);
                if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                    distanceMap.put(camera.getId(), distance);
                    if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
                        camera.setCamAlarmGuideEnable(0);
                    }
                    guideMap.put(camera.getId(), camera.getCamAlarmGuideEnable());
                }
            }
            if (distanceMap.size() > 0) {
                log.debug("尝试查找最近光电");
                //获取距离字典中最近的一个相机ID
                String minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
                log.debug("查找到最近光电:" + minDistanceCameraId + "，尝试引导");
                if (guideMap.get(minDistanceCameraId).equals(0)) {
                    log.debug("该光电未开启报警引导");
                    return "";
                }
                //引导光电
                cmd.setCameraId(minDistanceCameraId);
                cmd.setChannelNum(ArdTool.getChannelBydayNightTime(dayNightTime));
                boolean guideRes = hikClientService.guideTargetPosition(cmd);
                if (guideRes) {
                    log.debug("引导成功，尝试录像");
                    hikClientService.controlLock(cmd);//上锁
                    cmd.setEnable(true);//开始录像
                    hikClientService.recordToMinio(cmd);//开始录像
                    GlobalVariable.threadMap.put(minDistanceCameraId, Thread.currentThread().getName());//将相机id与当前处理线程名称绑定
                    Thread.sleep(cmd.getExpired() * 1000);//录像时长
                    String thread = GlobalVariable.threadMap.get(minDistanceCameraId);
                    String currentThread = Thread.currentThread().getName();
                    //判断相机绑定线程是否是当前线程，如果是，停止录像，如果不是，说明相机被其他线程抢占，不停止录像
                    if (thread.equals(currentThread)) {
                        cmd.setEnable(false);//停止录像
                        cmd.setUploadMinio(true);//上传minio
                        url = hikClientService.recordToMinio(cmd);//停止录像返回url
                    }
                }
            } else {
                log.debug("未查找到最近光电");
            }
        } catch (Exception ex) {
            log.error("引导异常:" + ex.getMessage());
        }
        return url;
    }

    /**
     * @描述 查询所有报警的当前数量
     * @参数 []
     * @返回值 java.util.Map<java.lang.String, java.lang.Integer>
     * @创建人 刘苏义
     * @创建时间 2023/6/13 16:30
     * @修改人和其它信息
     */
    @Override
    public Map<String, Object> selectAlarmLogsCount() {
        Map<String, Object> map = new HashMap<>();
        Map<String, Integer> countMap = new HashMap<>();
        String refreshTime = configService.selectConfigByKey("refreshTime");
        int count1001 = ardAlarmStealelecMapper.selectCountByStartTime(refreshTime);
        countMap.put("1001", count1001);
        int count1002 = ardAlarmCameraMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1002", count1002);
        int count1003 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime,"运动目标检测");
        countMap.put("1003", count1003);
        int count1004 = ardAlarmRadarMapper.selectCountByAlarmTime(refreshTime,"热源检测");
        countMap.put("1004", count1004);
        int count1014 = ardAlarmTubeMapper.selectCountByAlarmTime(refreshTime);
        countMap.put("1014", count1014);
        map.put("20000", countMap);
        return map;
    }

    @Override
    public Object selectAlarmList(Integer command, String beginTime, String endTime, Integer pageNum, Integer pageSize) {
        Map<String, Object> params = new HashMap<>();
@@ -467,26 +260,301 @@
        return null;
    }

    public static void main(String[] args) {
        // 给定坐标 A
        double Ax = 0;
        double Ay = 0;
    /**
     * @描述 按条件更新查看时间
     * @参数 [condition]
     * @返回值 java.lang.Object
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:48
     * @修改人和其它信息
     */
    @Override
    public Object updateAlarmViewTime(GlobalAlarmCondition condition) {
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        switch (condition.getCommand()) {
            case 1001:
                ArdAlarmStealelec ardAlarmStealelec = ardAlarmStealelecMapper.selectByPrimaryKey(condition.getId());
                if (StringUtils.isNotNull(ardAlarmStealelec)) {
                    String describe = ardAlarmStealelec.getDescribe();
                    String startTime = fmt.format(ardAlarmStealelec.getStartTime());
                    int i = ardAlarmStealelecMapper.updateViewTimeByDescribe(describe, startTime, DateUtils.getTime());
                    return ardAlarmStealelec;
                }
            case 1014:
                ArdAlarmTube ardAlarmTube = ardAlarmTubeMapper.selectArdAlarmTubeById(condition.getId());
                if (StringUtils.isNotNull(ardAlarmTube)) {
                    String tubeId = ardAlarmTube.getTubeId();
                    String alarmTime = fmt.format(ardAlarmTube.getAlarmTime());
                    int i = ardAlarmTubeMapper.updateViewTimeByTubeId(tubeId, alarmTime, DateUtils.getTime());
                    return ardAlarmTube;
                }
            default:
                return null;
        }
    }

        // 给定角度（以度为单位）
        double angle = 45;
    /**
     * @描述 异步处理接收的报警
     * @参数 [topic, message]
     * @返回值 void
     * @创建人 刘苏义
     * @创建时间 2023/6/15 15:46
     * @修改人和其它信息
     */
    @Override
    @Async("alarmExecutor")
    public void receiveAlarm(String topic, String message) {
        try {
            switch (topic) {
                case "stealelec":
                    //region 处理盗电报警
                    ArdAlarmStealelec ardAlarmStealelec = JSONObject.parseObject(message, ArdAlarmStealelec.class);
                    ArdAlarmStealelec isExiste = ardAlarmStealelecMapper.selectByPrimaryKey(ardAlarmStealelec.getId());
                    if (StringUtils.isNull(isExiste)) {
                        int aas = ardAlarmStealelecMapper.insertArdAlarmStealelec(ardAlarmStealelec);
                        if (aas > 0) {
                            log.info("stealelec入库成功：" + ardAlarmStealelec);
                        }
                    }
                    //endregion
                    break;
                case "tube":
                    //region 处理管线泄露报警
                    ArdAlarmTube ardAlarmTube = JSONObject.parseObject(message, ArdAlarmTube.class);
                    ardAlarmTube.setId(IdUtils.simpleUUID());
                    ArdTubesDetails atd = new ArdTubesDetails();
                    atd.setReelNumber(ardAlarmTube.getTubeId());
                    List<ArdTubesDetails> ardTubesDetails = ardTubesDetailsMapper.selectArdTubesDetailsList(atd);
                    if (ardTubesDetails.size() > 0) {
                        String tubeId = ardTubesDetails.get(0).getTubeId();
                        ArdTubes ardTubes = ardTubesMapper.selectArdTubesById(tubeId);
                        ardAlarmTube.setTubeName(ardTubes.getName());
                        ardAlarmTube.setColor(ardTubes.getColor());
                        ardAlarmTube.setPipeDiameter(ardTubes.getPipeDiameter());
                        ardAlarmTube.setTubeType(ardTubes.getType());
                        GeoPoint geoPoint = TubeTools.CalculateCoordinates(ardTubesDetails, ardAlarmTube.getPosition());
                        if (StringUtils.isNotNull(geoPoint)) {
                            ardAlarmTube.setLongitude(geoPoint.getLongitude());
                            ardAlarmTube.setLatitude(geoPoint.getLatitude());
                            ardAlarmTube.setAltitude(geoPoint.getAltitude());
                        }
                    }
                    int aat = ardAlarmTubeMapper.insertArdAlarmTube(ardAlarmTube);
                    if (aat > 0) {
                        log.debug("tube入库成功：" + ardAlarmTube);
                        String nearbyCamera = getNearbyCamera(new double[]{ardAlarmTube.getLongitude(), ardAlarmTube.getLatitude()});
                        if (StringUtils.isNotEmpty(nearbyCamera)) {
                            messagesEnqueued(nearbyCamera, ardAlarmTube.getId(), "sys_tube_leak", ardAlarmTube.getAlarmTime(), 1,1);
                        }
                    }
                    //endregion
                    break;
                case "camera":
                    //region 处理通用光电报警
                    ArdAlarmCamera ardAlarmCamera = JSONObject.parseObject(message, ArdAlarmCamera.class);
                    ardAlarmCamera.setId(IdUtils.simpleUUID());

        // 给定距离
        double distance = 1.414;
                    int aac = ardAlarmCameraMapper.insertArdAlarmCamera(ardAlarmCamera);
                    if (aac > 0) {
                        log.debug("camera入库成功：" + ardAlarmCamera);
                    }
                    //endregion
                    break;
                case "radar":
                    //region 处理雷达报警
                    RadarAlarmData radarAlarmData = JSONObject.parseObject(message, RadarAlarmData.class);
                    List<ArdAlarmRadar> ardAlarmRadars = radarAlarmData.getArdAlarmRadars();
                    for (ArdAlarmRadar ardAlarmRadar : ardAlarmRadars) {
                        String uuid = IdUtils.simpleUUID();
                        ardAlarmRadar.setId(uuid);
                        ardAlarmRadar.setAlarmTime(radarAlarmData.getAlarmTime());
                        String name = ardAlarmRadar.getName() + "(" + radarAlarmData.getRadarName() + ")";
                        ardAlarmRadar.setName(name);
                        ardAlarmRadar.setCreateTime(new Date());
                        String alarmType = "";
                        switch (ardAlarmRadar.getAlarmType()) {
                            case "运动目标检测":
                                alarmType = "sys_radar_move";
                                break;
                            case "热源检测":
                                alarmType = "sys_radar_fire";
                                break;
                        }
                        //判断当前报警点5分钟内是否已引导
                        ardAlarmRadar.setGuideFlag(1);
                        ArdAlarmRadar AlarmRadar = ardAlarmRadarMapper.getArdAlarmRadarWithGuide(ardAlarmRadar);
                        if (StringUtils.isNull(AlarmRadar)) {
                            //5分钟内未引导直接入库
                            ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);
                            //获取雷达所在塔上的大光电
                            String cameraIdWithTower = ardAlarmRadarMapper.getCameraByRadar(radarAlarmData.getRadarId());
                            if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
                                //入队列待引导
                                messagesEnqueued(cameraIdWithTower, uuid, alarmType, ardAlarmRadar.getAlarmTime(), 1,1);
                            }
                        } else {
                            //5分钟内有引导
                            ardAlarmRadar.setGuideFlag(0);
                            int count = ardAlarmRadarMapper.getArdAlarmRadarWithNotGuide(ardAlarmRadar, AlarmRadar.getCreateTime());
                            //未引导超过3次，直接入库入队
                            if (count >= 3) {
                                ardAlarmRadar.setGuideFlag(1);
                                ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);

        // 将角度转换为弧度
        double radians = Math.toRadians(angle);
                                //获取雷达所在塔上的大光电
                                String cameraIdWithTower = ardAlarmRadarMapper.getCameraByRadar(radarAlarmData.getRadarId());
                                if (StringUtils.isNotNull(cameraIdWithTower) && StringUtils.isNotEmpty(cameraIdWithTower)) {
                                    //如果雷达塔上有光电
                                    messagesEnqueued(cameraIdWithTower, uuid, alarmType, ardAlarmRadar.getAlarmTime(), count,1);
                                }
                                //获取报警点关联的大光电
                                ArdAlarmpointsWell ardAlarmpointsWell = ardAlarmpointsWellMapper.selectArdAlarmpointsWellByWellId(ardAlarmRadar.getName());
                                if(StringUtils.isNotNull(ardAlarmpointsWell) && StringUtils.isNotEmpty(ardAlarmpointsWell.getCameraId()))
                                {
                                    String cameraId = ardAlarmpointsWell.getCameraId();
                                    //如果报警点关联了光电
                                    messagesEnqueued(cameraId, uuid, alarmType, ardAlarmRadar.getAlarmTime(), count,1);
                                }
                            } else {
                                //未引导未超过3次，直接入库
                                ardAlarmRadarMapper.insertArdAlarmRadar(ardAlarmRadar);
                            }
                        }
                    }
                    //endregion
                    break;
            }
            GuidePriorityQueue.printPriorityQueue();//打印队列
        } catch (Exception ex) {
            log.error("接收报警异常:" + ex.getMessage());
        }
    }

        // 计算 B 坐标
        double Bx = Ax + distance * Math.cos(radians);
        double By = Ay + distance * Math.sin(radians);

        // 输出结果
        System.out.println("坐标 B: (" + Bx + ", " + By + ")");
    /**
     * 消息入队
     */
    private void messagesEnqueued(String cameraId, String alarmId, String alarmType, Date alarmTime, Integer num, Integer recordSn) {

        GuideTask guideTask = new GuideTask();
        /*配置相机ID*/
        guideTask.setCameraId(cameraId);
        /*根据配置时间配置通道*/
        String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
        Integer channel = ArdTool.getChannelBydayNightTime(dayNightTime);
        guideTask.setChanNum(channel);
        /*配置报警ID*/
        guideTask.setAlarmId(alarmId);
        /*配置报警时间*/
        SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        guideTask.setAlarmTime(fmt.format(alarmTime));
        /*配置报警优先级*/
        Integer priority = CamPriority.priorityMap.get(alarmType);
        guideTask.setPriority(priority);
        /*配置报警次数*/
        guideTask.setNum(num);
        /*配置录像存储位置*/
        guideTask.setRecordSn(recordSn);
        /*消息入队*/
        queueManager.addTaskToQueue(cameraId, guideTask);
//        PriorityBlockingQueue<GuideTask> priorityBlockingQueue = GuidePriorityQueue.cameraQueueMap.get(guideTask.getCameraId());
//        priorityBlockingQueue.add(guideTask);
    }

    /**
     * 查找附近开启报警引导功能光电
     */
    private String getNearbyCamera(double[] targetPosition) {
        String minDistanceCameraId = "";
        //获取所有大光电
        List<ArdCameras> ardCamerasList = ardCamerasMapper.selectArdCamerasList(new ArdCameras("1"));
        //统计所有大光电可视范围内与报警点的距离
        Map<String, Double> distanceMap = new HashMap<>();
        Map<String, Integer> guideMap = new HashMap<>();
        for (ArdCameras camera : ardCamerasList) {
            double[] camPosition = new double[]{camera.getLongitude(), camera.getLatitude()};
            double distance = GisTool.getDistance(targetPosition, camPosition);
            if (distance != 0.0 && distance <= camera.getCamMaxVisibleDistance()) {
                distanceMap.put(camera.getId(), distance);
                if (StringUtils.isNull(camera.getCamAlarmGuideEnable())) {
                    camera.setCamAlarmGuideEnable(0);
                }
                guideMap.put(camera.getId(), camera.getCamAlarmGuideEnable());
            }
        }
        if (distanceMap.size() > 0) {
            log.debug("尝试查找最近光电");
            //获取距离字典中最近的一个相机ID
            minDistanceCameraId = ArdTool.getKeyByMinValue(distanceMap);
            log.debug("查找到最近光电:" + minDistanceCameraId);
            if (guideMap.get(minDistanceCameraId).equals(0)) {
                log.debug("该光电未开启报警引导");
                return " ";
            }
        }
        return minDistanceCameraId;
    }

    /**
     * @描述 引导最近的大光电指向目标
     * @参数 [cmd]
     * @返回值 boolean
     * @创建人 刘苏义
     * @创建时间 2023/6/28 16:34
     * @修改人和其它信息
     */
    private boolean guideCamera(CameraCmd cmd) {
        try {
            String dayNightTime = redisCache.getCacheObject("sys_config:dayNightTime");
            String nearbyCamera = getNearbyCamera(cmd.getTargetPosition());
            if (StringUtils.isNotEmpty(nearbyCamera)) {
                //引导光电
                cmd.setCameraId(nearbyCamera);
                cmd.setChannelNum(ArdTool.getChannelBydayNightTime(dayNightTime));
                boolean guideRes = hikClientService.guideTargetPosition(cmd);
                return guideRes;
            } else {
                log.debug("未查找到最近光电");
                return false;
            }
        } catch (
                Exception ex) {
            log.error("引导异常:" + ex.getMessage());
            return false;
        }

    }

    /**
     * @描述 报警录像
     * @参数 [cmd]
     * @返回值 java.lang.String
     * @创建人 刘苏义
     * @创建时间 2023/6/28 16:33
     * @修改人和其它信息
     */
    private String alarmToRecord(CameraCmd cmd) {
        String url = "";
        try {
            log.debug("引导成功，尝试录像");
            String cameraId = cmd.getCameraId();
            hikClientService.controlLock(cmd);//上锁
            cmd.setEnable(true);//开始录像
            hikClientService.recordToMinio(cmd);//开始录像
            GlobalVariable.threadMap.put(cameraId, Thread.currentThread().getName());//将相机id与当前处理线程名称绑定
            Thread.sleep(cmd.getExpired() * 1000);//录像时长
            String thread = GlobalVariable.threadMap.get(cameraId);
            String currentThread = Thread.currentThread().getName();
            //判断相机绑定线程是否是当前线程，如果是，停止录像，如果不是，说明相机被其他线程抢占，不停止录像
            if (thread.equals(currentThread)) {
                cmd.setEnable(false);//停止录像
                cmd.setUploadMinio(true);//上传minio
                url = hikClientService.recordToMinio(cmd);//停止录像返回url
            }
        } catch (Exception ex) {
            log.error("录像异常:" + ex.getMessage());
        }
        return url;
    }

}