Merge remote-tracking branch 'origin/master'

signal-optimize-service/src/main/java/net/wanji/opt/dao/mapper/GreenChartSchemeHistMapper.java

+package net.wanji.opt.dao.mapper;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import net.wanji.opt.entity.GreenChartSchemeHist;
+
+/**
+ * @author duanruiming
+ * @date 2025/04/10 11:32
+ */
+public interface GreenChartSchemeHistMapper extends BaseMapper<GreenChartSchemeHist> {
+}

signal-optimize-service/src/main/java/net/wanji/opt/dto/GreenBeltChartDTO.java

@@ -24,5 +24,5 @@ public class GreenBeltChartDTO {
     private Map<String, List<List<Double>>> backCrossRedTimesMap;
     private Map<String, List<List<Double>>> crossGreenTimesMap;
     private Map<String, List<List<Double>>> backCrossGreenTimesMap;
-    private List<Map<String, List<Double>>> greenwaveStartGroup;
+    private List<Map<String, List<List<Double>>>> greenwaveStartGroup;
 }

signal-optimize-service/src/main/java/net/wanji/opt/entity/GreenChartSchemeHist.java

+package net.wanji.opt.entity;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import com.fasterxml.jackson.annotation.JsonFormat;
+import io.swagger.annotations.ApiModelProperty;
+import lombok.Data;
+
+import java.util.Date;
+
+/**
+ * @author duanruiming
+ * @date 2025/04/10 11:28
+ */
+@Data
+@TableName("t_green_chart_scheme_hist")
+public class GreenChartSchemeHist {
+    @TableId(value = "id", type = IdType.AUTO)
+    private Long id;
+
+    @TableField("green_id")
+    private Integer greenId;
+
+    @TableField("green_chart")
+    private String greenChart;
+
+    @TableField("scheme_detail")
+    private String schemeDetail;
+
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    @TableField("gmt_create")
+    private Date gmtCreate;
+    @JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    @TableField("gmt_modified")
+    private Date gmtModified;
+}

signal-optimize-service/src/main/java/net/wanji/opt/servicev2/judgeanalysis/AnalysisGreenCongestionPeriodService.java

@@ -8,6 +8,7 @@ import java.util.List;
 
 public interface AnalysisGreenCongestionPeriodService {
     public void selectCountByCongestionPeriod() throws ParseException;
+    public void selectCountByLandData() throws ParseException;
 
     GreenReportProblemOverallAnalysisResult selectListByWeek(Integer year, Integer week, String ids);
 

signal-optimize-service/src/main/java/net/wanji/opt/servicev2/judgeanalysis/impl/AnalysisGreenCongestionPeriodServiceImpl.java

 package net.wanji.opt.servicev2.judgeanalysis.impl;
 
+import com.alibaba.cloud.commons.lang.StringUtils;
+import com.github.pagehelper.util.StringUtil;
 import net.wanji.databus.dao.entity.GreenwaveInfoPO;
 import net.wanji.databus.dao.mapper.GreenwaveInfoMapper;
 import net.wanji.opt.common.enums.*;
@@ -8,6 +10,7 @@ import net.wanji.opt.controllerv2.report.vo.*;
 import net.wanji.opt.dao.mapper.judgeanalysis.AnalysisGreenCongestionPeriodMapper;
 import net.wanji.opt.dao.mapper.report.GreenWaveCrossRidMapper;
 import net.wanji.opt.entity.judgeanalysis.AnalysisGreenCongestionPeriod;
+import net.wanji.opt.entity.judgeanalysis.laneDataHist;
 import net.wanji.opt.entity.report.GreenWaveCrossRidInfo;
 import net.wanji.opt.servicev2.judgeanalysis.AnalysisGreenCongestionPeriodService;
 import org.apache.commons.collections.CollectionUtils;
@@ -487,6 +490,13 @@ public class AnalysisGreenCongestionPeriodServiceImpl implements AnalysisGreenCo
         queue.offer(temp);
     }
 
+    public void enqueue(LinkedList<laneDataHist> queue, laneDataHist temp) {
+        if (queue.size() >= 2) {
+            queue.poll();
+        }
+        queue.offer(temp);
+    }
+
     public Integer isMoning(String date) throws ParseException {
         DateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
         Date temp = fmt.parse(date);
@@ -497,4 +507,130 @@ public class AnalysisGreenCongestionPeriodServiceImpl implements AnalysisGreenCo
             return 2;
         }
     }
+
+    public void selectCountByLandData() throws ParseException {
+        LocalDate currentDate = LocalDate.now();
+        // 获取本周一的日期
+        LocalDate mondayOfThisWeek = currentDate.with(TemporalAdjusters.previousOrSame(DayOfWeek.MONDAY));
+        // 获取上周一的日期
+        LocalDate todayOfWeek = mondayOfThisWeek.plusDays(-7);
+        //获取上周日的日期
+        LocalDate endOfWeek = mondayOfThisWeek.plusDays(-1);
+        WeekFields weekFields = WeekFields.of(Locale.getDefault());
+        //获取上周的周数
+        int Number = todayOfWeek.get(weekFields.weekOfYear());
+        int year = currentDate.getYear();
+        String weekNumber = String.valueOf(year) + String.valueOf(Number);
+        //循环7天处理数据
+        for (int i = 0; i < 7; i++) {
+            LocalDate date = todayOfWeek.plusDays(i);
+            //获取干线数据
+            List<laneDataHist> laneList = analysisGreenCongestionPeriodMapper.selectGreenTrafficHist(date.toString().replaceAll("-",""));
+            LinkedList<laneDataHist> queue = new LinkedList<>();
+            LinkedList<laneDataHist> queueCorss = new LinkedList<>();
+            List<laneDataHist> list = new ArrayList<>();
+            String greenId = "";
+            String roadDirection = "";
+            String startTime = "";
+            String endTime = "";
+            Double trafficThreshold = 0.0;
+            for(laneDataHist temp : laneList){
+                if(temp.getGreenId().equals(greenId)){
+                    if(queue.size() == 2){
+                        //判断流量是否大于阀值
+                        if(trafficThreshold < temp.getTrafficIndex() && com.github.pagehelper.util.StringUtil.isEmpty(startTime)){
+                            startTime = temp.getStartTime();
+                            list.add(temp);
+                        } else if( temp.getTrafficIndex() < trafficThreshold &&
+                                queue.getFirst().getTrafficIndex() < trafficThreshold &&
+                                queue.getLast().getTrafficIndex() < trafficThreshold &&
+                                !com.github.pagehelper.util.StringUtil.isEmpty(startTime)  ){
+                            if(list.size() < 10){
+                                startTime = "";
+                                list.clear();
+                                enqueue(queue,temp);
+                                continue;
+                            }
+                            endTime = queue.getFirst().getStartTime();
+                            //查询流量数据，循环处理list中的数据找出最大值，并算出平均值
+                            List<laneDataHist> crossFlowList = analysisGreenCongestionPeriodMapper.selectCrossFlow(date.toString().replaceAll("-",""),
+                                    temp.getCrossId(),startTime,endTime);
+                            List<laneDataHist> list1 = new ArrayList<>();
+                            Integer maxFlow = 0;
+                            Integer sumFlow = 0;
+                            if(CollectionUtils.isNotEmpty(crossFlowList)) {
+                                for (laneDataHist temp1 : crossFlowList) {
+                                    if (queueCorss.size() < 2) {
+                                        enqueue(queueCorss, temp1);
+                                    } else {
+                                        Integer flow = (temp1.getFlow() + queueCorss.getFirst().getFlow() + queueCorss.getLast().getFlow()) * 4 ;
+                                        temp1.setFlowHour(flow);
+                                        list1.add(temp1);
+                                        enqueue(queueCorss, temp1);
+                                    }
+                                }
+
+                                maxFlow = list1.get(0).getFlowHour();
+                                sumFlow = list1.get(0).getFlowHour();
+                            }
+                            Integer avgFlow = 0;
+                            for(int a = 0 ; a < list1.size(); a ++){
+                                if(a == list1.size() - 1){
+                                    Double avg = Math.ceil((double) sumFlow / list1.size());
+                                    avgFlow = Integer.valueOf(avg.intValue()) ;
+                                    continue;
+                                }
+                                if(list1.get(a + 1).getFlowHour() > maxFlow){
+                                    maxFlow = list1.get(a + 1).getFlowHour();
+                                }
+                                sumFlow = sumFlow + list1.get(a + 1).getFlowHour();
+                            }
+                            //写入数据
+                            Map<String,Object> map = new HashMap<>();
+                            map.put("startTime",startTime);
+                            map.put("endTime",endTime);
+                            map.put("weekNumber",weekNumber);
+                            map.put("weekDay",i + 1);
+                            map.put("roadDirection",roadDirection);
+                            map.put("peakType",isMoning(startTime));
+                            map.put("weekStartTime",todayOfWeek);
+                            map.put("weekEndTime",endOfWeek);
+                            map.put("maxFlow",maxFlow);
+                            map.put("avgFlow",avgFlow);
+                            map.put("greenId",temp.getGreenId());
+                            map.put("trafficThreshold",trafficThreshold);
+                            analysisGreenCongestionPeriodMapper.insertLaneDataHist(map);
+                            //清空数据
+                            startTime = "";
+                            endTime = "";
+                            list.clear();
+                        }else {
+                            if(!StringUtil.isEmpty(startTime)) {
+                                list.add(temp);
+                            }
+                        }
+                    }
+                    enqueue(queue,temp);
+                }else {
+                    queue.clear();
+                    list.clear();
+                    greenId = temp.getGreenId();
+                    roadDirection = temp.getRoadDirection();
+                    //计算该干线交通指数阈值，取一天的9点至16点30之间交通指数倒序的90%的数值为动态阈值
+                    List<laneDataHist> greenTrafficList = analysisGreenCongestionPeriodMapper.selectGreenTrafficThreshold(date.toString().replaceAll("-",""),greenId,roadDirection);
+                    if(greenTrafficList.get(9).getTrafficIndex() <= 1.5) {
+                        trafficThreshold = 1.5;
+                    }else {
+                        trafficThreshold = greenTrafficList.get(9).getTrafficIndex();
+                    }
+                    startTime = "";
+                    endTime = "";
+                    enqueue(queue,temp);
+                }
+            }
+
+            //计算平峰
+
+        }
+    }
 }

signal-optimize-service/src/main/java/net/wanji/opt/task/HisenseGreenChartTask.java

@@ -14,9 +14,11 @@ import net.wanji.opt.cache.GreenCrossDirInfoCache;
 import net.wanji.opt.common.CommonUtils;
 import net.wanji.opt.common.RedisUtils;
 import net.wanji.opt.common.enums.GreenBeltDirEnum;
+import net.wanji.opt.dao.mapper.GreenChartSchemeHistMapper;
 import net.wanji.opt.dto.GreenBeltChartDTO;
 import net.wanji.opt.dto.RingPhaseInfoDTO;
 import net.wanji.opt.dto.SchemeGreenDirGreenTimeDTO;
+import net.wanji.opt.entity.GreenChartSchemeHist;
 import org.jetbrains.annotations.NotNull;
 import org.springframework.context.annotation.Profile;
 import org.springframework.scheduling.annotation.Scheduled;
@@ -41,6 +43,8 @@ public class HisenseGreenChartTask {
     private RedisUtils redisUtils;
     @Resource
     private GreenwaveRealtimeMapper greenwaveRealtimeMapper;
+    @Resource
+    private GreenChartSchemeHistMapper greenChartSchemeHistMapper;
 
 
     //@Scheduled(fixedRate = 10 * 60 * 1000, initialDelay = 1 * 60 * 1000)
@@ -52,6 +56,7 @@ public class HisenseGreenChartTask {
             // 绿波路口数据
             List<GreenCrossDirDTO> greenCrossDirCache = GreenCrossDirInfoCache.greenCrossDirCache;
             List<SchemeGreenDirGreenTimeDTO> schemeGreenDirGreenTimeDTOS = getSchemeGreenDirGreenTimeDTOS(greenCrossDirCache);
+            Map<Integer, List<SchemeGreenDirGreenTimeDTO>> greenSchemeRingPhaseMap = new HashMap<>(10);
             if (!CollectionUtils.isEmpty(greenCrossDirCache) && !CollectionUtils.isEmpty(schemeGreenDirGreenTimeDTOS)) {
                 // 将海信方案环相位转成map形式
                 HashMap<String, SchemeGreenDirGreenTimeDTO> greenDirGreenTimeMap = new HashMap<>();
@@ -59,11 +64,29 @@ public class HisenseGreenChartTask {
                     String crossId = dto.getCrossId();
                     Integer dir = dto.getDir();
                     greenDirGreenTimeMap.put(CommonUtils.getStrJoin(crossId, String.valueOf(dir)), dto);
+                    // 存储海信方案环图信息
+                    for (GreenCrossDirDTO greenCrossDirDTO : greenCrossDirCache) {
+                        Integer greenId = greenCrossDirDTO.getGreenId();
+                        String greenCrossId = greenCrossDirDTO.getCrossId();
+                        if (StringUtils.equalsIgnoreCase(greenCrossId, crossId)) {
+                            List<SchemeGreenDirGreenTimeDTO> list1 = greenSchemeRingPhaseMap.get(greenId);
+                            if (CollectionUtils.isEmpty(list1)) {
+                                List<SchemeGreenDirGreenTimeDTO> list2 = new ArrayList<>();
+                                list2.add(dto);
+                                greenSchemeRingPhaseMap.put(greenId, list2);
+                            } else {
+                                list1.add(dto);
+                                greenSchemeRingPhaseMap.put(greenId, list1);
+                            }
+                        }
+                    }
                 }
 
                 // 1.根据绿波带长度和速度计算行程时间
                 // 2.根据相位差，行程时间，海信环图计算绿灯红灯点位 正向 crossRedTimesMap 反向backCrossRedTimesMap
-                Map<Integer, List<GreenCrossDirDTO>> greenMap = greenCrossDirCache.stream().collect(Collectors.groupingBy(GreenCrossDirDTO::getGreenId));
+                //Map<Integer, List<GreenCrossDirDTO>> greenMap = greenCrossDirCache.stream().collect(Collectors.groupingBy(GreenCrossDirDTO::getGreenId));
+                // todo 测试只需要绿波编号1
+                Map<Integer, List<GreenCrossDirDTO>> greenMap = greenCrossDirCache.stream().filter(po -> Objects.equals(1, po.getGreenId())).collect(Collectors.groupingBy(GreenCrossDirDTO::getGreenId));
                 List<GreenBeltChartDTO> greenBeltChartDTOS = new ArrayList<>();
                 for (Map.Entry<Integer, List<GreenCrossDirDTO>> entry : greenMap.entrySet()) {
                     GreenBeltChartDTO greenBeltChartDTO = new GreenBeltChartDTO();
@@ -90,7 +113,7 @@ public class HisenseGreenChartTask {
                     Double backTravelTime = getTravelTime(realTimeMap, greenId, indexOutDir, totalDistance);
                     Map<String, List<List<Double>>> backCrossRedTimesMap = new LinkedHashMap<>();
                     Map<String, List<List<Double>>> backCrossGreenTimesMap = new LinkedHashMap<>();
-                    getCrossRedTimeMap(mapper, greenDirGreenTimeMap, backValue, indexOutDir, backTravelTime, backOffsets, backDistances, crossGreenTimesMap, backCrossGreenTimesMap);
+                    getCrossRedTimeMap(mapper, greenDirGreenTimeMap, backValue, indexOutDir, backTravelTime, backOffsets, backDistances, backCrossRedTimesMap, backCrossGreenTimesMap);
                     greenBeltChartDTO.setGreenId(greenId);
                     greenBeltChartDTO.setDir(indexDir);
                     greenBeltChartDTO.setBackDir(indexOutDir);
@@ -108,15 +131,21 @@ public class HisenseGreenChartTask {
                 }
 
                 // 3.计算每两个路口绿灯开始、结束时间
+                List<GreenBeltChartDTO> results = new ArrayList<>();
                 for (Map.Entry<Integer, List<GreenCrossDirDTO>> entry : greenMap.entrySet()) {
+                    List<Map<String, List<List<Double>>>> greenwaveStartGroup = new ArrayList<>();
                     Integer greenId = entry.getKey();
                     List<GreenCrossDirDTO> value = entry.getValue();
                     if (!CollectionUtils.isEmpty(value)) {
                         for (int i = 0; i < value.size(); i++) {
+                            Map<String, List<List<Double>>> greenStartMap = new LinkedHashMap<>();
+                            List<List<Double>> firstGreenStartList = new ArrayList<>();
+                            List<List<Double>> secondGreenStartList = new ArrayList<>();
+
                             GreenCrossDirDTO firstDto = value.get(i);
                             String firstCrossId = firstDto.getCrossId();
                             Integer inDir = firstDto.getInDir();
-                            if (i < value.size()) {
+                            if (i + 1 < value.size()) {
                                 GreenCrossDirDTO secondDto = value.get(i + 1);
                                 String secondCrossId = secondDto.getCrossId();
                                 for (GreenBeltChartDTO greenBeltChartDTO : greenBeltChartDTOS) {
@@ -133,29 +162,68 @@ public class HisenseGreenChartTask {
                                         // 第一个路口循环绿灯开始时间
                                         for (int i1 = 0; i1 < firstList.size(); i1++) {
                                             List<Double> greenStartEnd = firstList.get(i1);
-                                            for (int i2 = 0; i2 < greenStartEnd.size(); i2++) {
+                                            int index = 0;
+                                            //for (int i2 = 0; i2 < greenStartEnd.size(); i2++) {
                                                 Double greenStart = greenStartEnd.get(0);
                                                 Double greenEnd = greenStartEnd.get(1);
+                                                Double start = 0.0;
+                                                Double end = 0.0;
+                                                Double start2 = 0.0;
+                                                Double end2 = 0.0;
                                                 for (int j = greenStart.intValue(); j <= greenEnd.intValue(); j++) {
                                                     int firstStartPoint = j + travelTime.intValue();
-                                                }
+                                                    for (int i3 = 0; i3 < secondList.size(); i3++) {
+                                                        List<Double> greenStartEnd2 = secondList.get(i3);
+                                                        Double greenStart2 = greenStartEnd2.get(0);
+                                                        Double greenEnd2 = greenStartEnd2.get(1);
 
-                                            }
-                                        }
+                                                        if (greenStart <= j && j <= greenEnd
+                                                                && greenStart2 <= firstStartPoint && firstStartPoint <= greenEnd2) {
 
+                                                            if (index == 0) {
+                                                                start = j * 1.0;
+                                                                start2 = firstStartPoint * 1.0;
+                                                            } else  {
+                                                                    Double tempEnd = j * 1.0;
+                                                                    end = end > tempEnd ? end : tempEnd;
+                                                                    Double tempEnd2 = firstStartPoint * 1.0;
+                                                                    end2 = end2 > tempEnd2 ? end2 : tempEnd2;
+                                                            }
+                                                            ++index;
+                                                        }
+                                                    }
+                                                }
+                                                firstGreenStartList.add(Arrays.asList(start, end));
+                                                secondGreenStartList.add(Arrays.asList(start2, end2));
+                                            //}
+                                        }
                                     }
+                                    greenStartMap.put(firstCrossId, firstGreenStartList);
+                                    greenStartMap.put(secondCrossId, secondGreenStartList);
                                 }
                             }
-
+                            greenwaveStartGroup.add(greenStartMap);
                         }
                     }
+                    greenBeltChartDTOS.forEach(item -> {
+                        if (Objects.equals(greenId, item.getGreenId())) {
+                            item.setGreenwaveStartGroup(greenwaveStartGroup);
+                            results.add(item);
+                        }
+                    });
                 }
-
-                log.error("绿波实体参数：{}", mapper.writeValueAsString(greenBeltChartDTOS));
-
-
+                for (GreenBeltChartDTO result : results) {
+                    Integer greenId = result.getGreenId();
+                    List<SchemeGreenDirGreenTimeDTO> list = greenSchemeRingPhaseMap.get(greenId);
+                    GreenChartSchemeHist greenChartSchemeHist = new GreenChartSchemeHist();
+                    greenChartSchemeHist.setGreenId(greenId);
+                    greenChartSchemeHist.setGreenChart(mapper.writeValueAsString(result));
+                    greenChartSchemeHist.setSchemeDetail(mapper.writeValueAsString(list));
+                    greenChartSchemeHistMapper.insert(greenChartSchemeHist);
+                }
+                log.debug("绿波图实体参数：{}", mapper.writeValueAsString(results));
+                log.debug("绿波路口方案环图信息：{}", mapper.writeValueAsString(greenSchemeRingPhaseMap));
             }
-            log.error("=================");
         } catch (Exception e) {
             log.error("通过海信方案处理绿波波定时任务失败：{}", e);
             //throw new RuntimeException(e);
@@ -198,6 +266,9 @@ public class HisenseGreenChartTask {
             Integer redEndTime = cycleLen - greenEndTime;
             // 通过行程时间计算周期数量
             double cycleSum = Math.floor(travelTime / cycleLen);
+            if (cycleSum < 1) {
+                cycleSum = 1;
+            }
             for (int i = 0; i < cycleSum; i++) {
                 Double cycleIndex = i * Double.valueOf(cycleLen);
                 // 多个周期后，需要在最后补充的时间

signal-optimize-service/src/main/resources/mapper/GreenChartSchemeHistMapper.xml

+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
+<mapper namespace="net.wanji.opt.dao.mapper.GreenChartSchemeHistMapper">
+
+</mapper>