Navigate黑客松物联网行为分析分析和逻辑

给定一些json数据，是电动车的行为数据。主要是GPS相关的数据。

例如：

{"devId":"87AECCA3","timestamp":1539075913,"latitude":30.18781,"longitude":120.19133333333333,"satellite":8,"hdop":0.97,"altitude":11.2,"speed":0.0,"direction":137.35}
{"devId":"CD7FDC41","timestamp":1539076207,"latitude":30.1904,"longitude":120.19162833333333,"satellite":13,"hdop":0.82,"altitude":10.1,"speed":0.0,"direction":192.58}

给定一个红绿灯，让判断这个数据中包含的小车对象在路口的行为是等待还是行动，行动的话第一是不是闯红灯，第二闯红灯是左拐还是右拐还是直行。

另外两个问题是上高架和画轨迹的问题，在高架上和下目前主要是通过精确的高度过滤得到。画图主要是上传到百度的鹰视里面去看一下基本的轨迹。略微实现了一点点的绑路的拟合。

但是重点是路口行为的判断。拿到数据之后首先过滤一下重复的数据，然后找到同一个对象的数据，然后按照时间序列拍一下队。

其次根据路口坐标就可以用三角函数判断旋转的角度和方向。辅助的话还设定四个线段。以路口为中心，左右方向，上下方向和斜着的两个方向。

如果移动轨迹和这四条有限长度的线段有相交的话也是可以判断行动的方式是直行左拐还是右拐。

其实数据还应该进一步过滤一下，在路口附近的最近的点才作为起始点和终点。其实终点越远越准确，但是起始点决定了这次行为是否闯红灯。还可以进一步的按照一定限度去过滤。

 

import java.awt.image.DataBufferDouble;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Map.Entry;
import java.util.Scanner;
import java.util.stream.Collectors;

import org.eclipse.paho.client.mqttv3.MqttException;
import org.json.JSONException;
import org.json.JSONObject;

public class LambdaTest01 {

    //决赛之前，一定把握坐标问题和时间戳问题的转换
    
    
    // 测试路口的wgs坐标点，需要转换成最终bd坐标系才可以使用
    public static final double InterSectionLat = 30.189142;
    public static final double InterSectionLng = 120.191689;
    // 测试路口的bd坐标系
    public static double testInterSectionLat = 30.192505146716269;
    public static  double testInterSectionLng = 120.20282651800267;
    // {"x":120.20282651800267,"y":30.192505146716269}]}
//    // 决赛路口的bd坐标点，不需要转换就可以使用
    public static final double finalinterSectionLat = 30.192811;
    public static final double finalInterSectionLng = 120.213632;
    // 相交前置条件
    public static boolean x_collection = false;
    public static boolean y_collection = false;
    public static boolean xy_collection = false;
    public static boolean yx_collection = false;
    public static boolean red_green=false;//红灯true,路灯false
    public static boolean stop_beyond=false;//等待为true,其他false,
    public static int  left_right=0;//左转-1,右转1,直行0
    boolean test_or_final=true;
    //测试数据路口红路灯数据
    static long test1_1_timestamp=1538969853;
    static int test1_1_greengap=34;
    static int test1_1_redgap=86;
    static long test2_1_timestamp=1538968687;
    static int test2_1_greengap=86;
    static int test2_1_redgap=34;
    static long test3_1_timestamp=1538979847;
    static int test3_1_greengap=22;
    static int test3_1_redgap=98;
    static long test4_1_timestamp=1538968653;
    static int test4_1_greengap=34;
    static int test4_1_redgap=86;
    static long test5_1_timestamp=1538979869;
    static int test5_1_greengap=98;
    static int test5_1_redgap=22;
    static long test6_1_timestamp=1538968653;
    static int test6_1_greengap=34;
    static int test6_1_redgap=86;
    //决赛数据的路口红绿灯数据

    /**
     * 传递进去路径，解析json行并保存到arraylist中
     * 
     * @param filelocation
     * @return
     * @throws JSONException
     * @throws IOException
     */
    @SuppressWarnings("resource")
    public static List<ObjectProperty> file2ObjectList(String filelocation) throws JSONException, IOException {

        File file = new File(filelocation);
        // C:\\java_path\\workspace\\HelloWorld\\src\\iot.json
        BufferedReader reader = null;
        String temp = null;
        int line = 1;
        reader = new BufferedReader(new FileReader(file));
        List<ObjectProperty> objectProperties = new ArrayList<ObjectProperty>();
        while ((temp = reader.readLine()) != null) {
            // System.out.println(line+":"+temp);
            line++;
            if (temp.equals("close") || temp.length() <= 20)
                continue;
            JSONObject my_json = new JSONObject(temp);
            String devId = my_json.getString("devId");
            // System.out.println(devId);
            long timestamp = my_json.getLong("timestamp");
            // System.out.println(timestamp);
            double latitude = my_json.getDouble("latitude");
            // System.out.println(latitude);
            double longitude = my_json.getDouble("longitude");
            // System.out.println(longitude);
            int satellite = my_json.getInt("satellite");
            // System.out.println(satellite);
            double hdop = my_json.getDouble("hdop");
            // System.out.println(hdop);
            double altitude = my_json.getDouble("altitude");
            // System.out.println(altitude);
            double speed = my_json.getDouble("speed");
            // System.out.println(speed);
            double direction = my_json.getDouble("direction");
            // System.out.println(direction);
            ObjectProperty e = new ObjectProperty(devId, timestamp, latitude, longitude, satellite, hdop, altitude,
                    speed, direction);
            objectProperties.add(e);
        }
        return objectProperties;
    }

    /**
     * 传递进去list对象，出来不重复的list对象
     * 
     * @param objectProperties
     * @return
     */
    public static List<ObjectProperty> removeDuplicate(List<ObjectProperty> objectProperties) {
        // 第一种方法，用contains方法循环去寻找 重写equals方法
        // List tempList=new ArrayList();
        // for (ObjectProperty objectProperty : objectProperties) {
        // if(!tempList.contains(objectProperty))
        // tempList.add(objectProperty);
        // }
        // return tempList;
        // 第二种方法，使用set直接去hash去重 重写euqals和hashset方法
        HashSet<ObjectProperty> hashSet = new HashSet<>(objectProperties);
        objectProperties.clear();
        objectProperties.addAll(hashSet);
        return objectProperties;

    }

    /**
     * 传递list对象和devID得到其中符合条件的对象的个数
     * 
     * @param objectProperties
     * @param devID
     * @return
     */
    public static int ListCount(List<ObjectProperty> objectProperties, String devID) {
        int count = 0;
        for (ObjectProperty objectProperty : objectProperties) {
            if (objectProperty.devId.equals(devID))
                count++;
        }
        return count;
    }

    /**
     * 打印一下list中的元素
     * 
     * @param objectProperties
     */
    public static void print(List<ObjectProperty> objectProperties) {
        for (ObjectProperty objectProperty : objectProperties) {
            System.out.println(objectProperty.toString());
        }
    }

    /**
     * 传递进去list对象，取出第一列对象作为list返回
     * 
     * @param objectProperties
     * @param Porperty
     * @return
     */
    public static List<String> findColume(List<ObjectProperty> objectProperties, String Porperty) {
        List<String> neededList = new ArrayList<>();
        for (ObjectProperty objectProperty : objectProperties) {
            if (Porperty.equals(Porperty))
                neededList.add(objectProperty.getDevId());
        }
        return neededList;
    }

    public static List<ObjectProperty> no_stop(List<ObjectProperty> objectProperties) {
        List<ObjectProperty> result = new ArrayList<>();
        for (ObjectProperty objectProperty : objectProperties) {
            if (objectProperty.getSpeed() != 0) {
                result.add(objectProperty);
            }
        }
        return result;
    }

    /**
     * 处理路口行为的主要算法
     * @param id
     * @param objectProperties
     * @param i
     * @throws IOException
     */
    public static void MainAlgo(String id, List<ObjectProperty> objectProperties,int i) throws IOException {
        System.out.println(
                "================================当前的处理的devId是：" + id + "===========================================");
        System.out.println("当前的devId的点有这么多个：" + objectProperties.size());
        // objectProperties=no_stop(objectProperties);
        // System.err.println("当前的devId运动的点有这么多个："+objectProperties.size());
        System.out.println("首先进行按照timestamp的排序；");
        Collections.sort(objectProperties, Comparator.comparing(ObjectProperty::getTimestamp));
        System.out.println("排序完成后 ");System.out.println("当前的devId对应的各个点的属性：");print(objectProperties);

        long start_time=objectProperties.get(0).getTimestamp();
        long stop_time=objectProperties.get(objectProperties.size()-1).getTimestamp();
        System.out.println("start_time="+start_time);
        System.out.println("stop_time="+stop_time);
        RedGreenClass redGreenClass=getCurrentCrossTimestamp(i);
        long current_cross_timestamp=redGreenClass.getTimestamp();
        long red_gap=redGreenClass.getRed();
        long green_gap=redGreenClass.getGreed();
        if((start_time-current_cross_timestamp)%(red_gap+green_gap)<=green_gap)
            red_green=false;
        else if((start_time-current_cross_timestamp)%(red_gap+green_gap)>green_gap)
            red_green=true;
        long duration=stop_time-start_time;
        System.out.println("经过路口的时长是：duration="+duration);
//        long distance=current_cross_timestamp-start_time;
//        System.out.println("当前路口距离红路灯开始的时间，负的才是正常的：distance="+distance);
        
        
        /// 对一个对象的起始数据点进行操作
        // 第一部分判断这个点是不是没动
        // 第二部分，判断有没有过路行为
        // 第三部分，分析往那个方向过的，左右，直，回三种情况
        // 第四部分，结合红绿灯输出时候违规
        System.out.println("----------------------------------");
        System.out.println("WGS坐标从第一个点到最后一个点的旋转角度：");
        double x1 = objectProperties.get(0).getLatitude();
        double y1 = objectProperties.get(0).getLongitude();
        double x2 = objectProperties.get(objectProperties.size() - 1).getLatitude();
        double y2 = objectProperties.get(objectProperties.size() - 1).getLongitude();
        System.out.println(y1 + "," + x1);
        System.out.println(y2 + "," + x2);
        double direction = DirectionClass.directionTurned(x1, y1, x2, y2);
        boolean wise_reverse = DirectionClass.wise_anti(x1, y1, x2, y2);
        System.out.println("旋转的角度" + direction);

        System.out.println("BD坐标从第一个点到最后一个点的旋转角度：");
        Lon_Lat_Class c_start = BaiDuMapApi.FilterLocationFromResult(BaiDuMapApi.WGS2BD09(y1, x1));
        Lon_Lat_Class c_stop = BaiDuMapApi.FilterLocationFromResult(BaiDuMapApi.WGS2BD09(y2, x2));
        double x11 = c_start.getLatitude();
        double y11 = c_start.getLongitude();
        double x22 = c_stop.getLatitude();
        double y22 = c_stop.getLongitude();
        System.out.println(y11 + "," + x11);
        System.out.println(y22 + "," + x22);
        double direction_bd = DirectionClass.directionTurned_bd(x11, y11, x22, y22);
        boolean wise_reverse_bd = DirectionClass.wise_anti_bd(x11, y11, x22, y22);
        System.out.println("旋转的角度" + direction_bd);

        System.out.println("***************************");
        boolean cross_or_not = lengthConvert.testIntersection(c_start, c_stop);
        System.out.println("***************************");

        
        if (cross_or_not) {
            // 发生了相交
            stop_beyond=false;//不等待
            if (direction_bd >= 45 && direction_bd <= 135) {
                // 发生了转弯
                if (wise_reverse_bd) {
                    left_right=-1;
                    System.out.println("向左转");
                } else if (!wise_reverse_bd) {
                    left_right=1;
                    System.out.println("向右转");
                }
            } else if (direction_bd >= 135 && direction_bd <= 180) {
                // 发生了直行行为
                left_right=0;
                System.out.println("直行");
            }else {
                stop_beyond=true;
                System.out.println("运动等待");
            }
        } else if (!cross_or_not) {
            // 没有相交，就是静止等待
            stop_beyond=true;
            System.out.println("等待");
        }
        System.out.println("@@@总结如下：");
        if(stop_beyond)
            System.out.println("当前对象等待");
        else {
            if(red_green=false) {
                System.out.println("当前对象红灯行为");
                if(left_right==-1) System.out.println("左拐");
                if(left_right==0) System.out.println("直行");
                if(left_right==1) System.out.println("右拐");
            }else if (red_green=true)
            {
                System.out.println("当前对象绿灯行为");
                if(left_right==-1) System.out.println("左拐");
                if(left_right==0) System.out.println("直行");
                if(left_right==1) System.out.println("右拐");
            }
        }
        System.out.println("================================当前的处理的devId是：" + id + "==========处理结束============================");

        // 将给出的wgs坐标转化为bd坐标
        // Lon_Lat_Class
        // lon_Lat_Class=BaiDuMapApi.FilterLocationFromResult(BaiDuMapApi.WGS2BD09(InterSectionLat,
        // InterSectionLng));

        // 对一个对象中的所有的数据点进行过滤，暂时注销
        // Lon_Lat_Class lon_Lat_Class=new
        // Lon_Lat_Class(testInterSectionLng,testInterSectionLat);
        // for (ObjectProperty objectProperty : objectProperties) {
        // Lon_Lat_Class
        // currentLocation=BaiDuMapApi.FilterLocationFromResult(BaiDuMapApi.WGS2BD09(objectProperty.getLongitude(),
        // objectProperty.getLatitude()));
        // Double currentLat=currentLocation.getLatitude();
        // Double currentLon=currentLocation.getLongitude();
        // Double CentralLat=lon_Lat_Class.getLatitude();
        // Double CentralLon=lon_Lat_Class.getLongitude();
        // Double dis2Intersection=lengthConvert.getDistance(CentralLat, CentralLon,
        // currentLat, currentLon);
        // System.out.println(CentralLon+","+CentralLat);
        // System.out.println(currentLon+","+currentLat);
        // System.out.println("计算两个坐标之间的差距是："+dis2Intersection);
        // }
        // System.out.println();
        //
    }

    private static RedGreenClass getCurrentCrossTimestamp(int i) {
        RedGreenClass redGreenClass=new RedGreenClass();
        if(i==1){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test1_1_greengap);
            redGreenClass.setRed(test1_1_redgap);
        }
        if(i==2){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test2_1_greengap);
            redGreenClass.setRed(test2_1_redgap);
        }
        if(i==3){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test3_1_greengap);
            redGreenClass.setRed(test3_1_redgap);
        }
        if(i==4){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test4_1_greengap);
            redGreenClass.setRed(test4_1_redgap);
        }
        if(i==5){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test5_1_greengap);
            redGreenClass.setRed(test5_1_redgap);
        }
        if(i==6){
            redGreenClass.setTimestamp(test1_1_timestamp);
            redGreenClass.setGreed(test6_1_greengap);
            redGreenClass.setRed(test6_1_redgap);
        }
        return redGreenClass;
    }

    @SuppressWarnings({ "unused", "rawtypes", "unchecked" })
    public static void main(String[] args) throws IOException, MqttException, InterruptedException {
        
        // List<ObjectProperty>
        // objectProperties=file2ObjectList("C:\\java_path\\workspace\\HelloWorld\\src\\iot.json");
        Scanner scanner=new Scanner(System.in);
        System.out.println("请输入是正式比赛:final还是测试的数据:test,之后按回车:");
        String test_final=scanner.nextLine();
        System.out.println("你的选择是："+test_final);
        System.out.println("请输入要测试的数据组数1-10中的数字选一个：");
        int i=scanner.nextInt();
        if(test_final.equals("final")) {
            testInterSectionLat=finalinterSectionLat;
            testInterSectionLng=finalInterSectionLng;
            long test1_1_timestamp=1540000360;
            int test1_1_greengap=82;
            int test1_1_redgap=38;
            long test2_1_timestamp=1540000360;
            int test2_1_greengap=82;
            int test2_1_redgap=38;
            long test3_1_timestamp=1540000360;
            int test3_1_greengap=82;
            int test3_1_redgap=38;
            long test4_1_timestamp=1540000360;
            int test4_1_greengap=82;
            int test4_1_redgap=38;
            long test5_1_timestamp=1540000360;
            int test5_1_greengap=82;
            int test5_1_redgap=38;
            long test6_1_timestamp=1540000360;
            int test6_1_greengap=38;
            int test6_1_redgap=82;

            
        }
        
        long time=System.currentTimeMillis()/1000;
        System.out.println("---从mqtt端订阅一个主题---");
        MQTT_Client_Receive.Topics2Files(i, test_final,time);
            
        String location="D:\\"+i+"_"+time+".json";
        System.out.println("---从文件"+location+"创建一个list---");
        List<ObjectProperty> objectProperties = file2ObjectList(location);
        // System.out.print("---包含指定性质CD8ADC41元素的list的数目：");
        // System.out.println(ListCount(objectProperties, "CD8ADC41"));

        System.out.println();
        System.out.println("---当前文件中包含的数据的条目个数为：" + objectProperties.size() + "---");
        System.out.println("---删除list中重复的元素---");
        objectProperties = removeDuplicate(objectProperties);
        System.out.println("---删除list中重复的元素完成---");
        System.out.println("---当前文件中包含的数据的条目的个数为：" + objectProperties.size() + "---");
        System.out.println();
        // 将取出的数据按照id进行分开
        Map<String, List<ObjectProperty>> groupBy = objectProperties.stream()
                .collect(Collectors.groupingBy(ObjectProperty::getDevId));
        System.out.println("----当前文件中的对象有多少个" + groupBy.keySet().size() + "---");
        
        if(i<=6) {
            System.out.println("处理红路灯");
            GreenRedProcess();
        }
        
        Set set = groupBy.entrySet();
        for (Iterator iterator = set.iterator(); iterator.hasNext();) {
            Map.Entry entry = (Entry) iterator.next();
            if(i<=6) {
                MainAlgo((String) entry.getKey(), (List<ObjectProperty>) entry.getValue(),i);// 调用路口行为主要的处理函数
            // System.out.println(entry.getKey()+"->"+entry.getValue());
            }else if(i==7||i==8) {
                MainAlgoForHight((String)entry.getKey(),(List<ObjectProperty>)entry.getValue(),i);
            }else if(i==9||i==10) {
                MainAlgoForDrawMap((String)entry.getKey(),(List<ObjectProperty>)entry.getValue(),i);
            }
        }

        // System.out.println(groupBy);
        // 单独把第一列拉出来
        List<String> firstList = findColume(objectProperties, "devId");
        // firstList.stream().collect(Collectors.groupingBy(firstList.))

        // System.out.print("---包含指定性质CD8ADC41元素的list的数目：");
        // System.out.println(ListCount(objectProperties, "CD8ADC41"));
        // System.out.print("---包含指定性质CD8ADC42元素的list的数目:");
        // System.out.println(ListCount(objectProperties, "CD8ADC42"));

    }

    private static void MainAlgoForDrawMap(String id, List<ObjectProperty> objectProperties,int i) {
        
    }

    private static void MainAlgoForHight(String id, List<ObjectProperty> objectProperties,int i) {
        System.out.println("================================当前的处理的devId是：" + id + "===========================================");
        System.out.println("当前的devId的点有这么多个：" + objectProperties.size());
        // objectProperties=no_stop(objectProperties);
        // System.err.println("当前的devId运动的点有这么多个："+objectProperties.size());
        System.out.println("首先进行按照timestamp的排序；");
        Collections.sort(objectProperties, Comparator.comparing(ObjectProperty::getTimestamp));
        System.out.println("排序完成后 ");System.out.println("当前的devId对应的各个点的属性：");print(objectProperties);
        
        
    }

    private static void GreenRedProcess() {
        
    }

}