精华内容
下载资源
问答
  • 我们有个项目是用来查询车辆轨迹,在某个市的每条主要道路的十字路口都安装了采集设备,车辆经过时会采集到车辆信息,包括车牌号码、采集时间、采集经纬度。平均每天有1亿条采集数据。现在我的需求是按车牌号和...
  • 随着基于移动互联网的车辆导航技术的发展和应用,基于车辆轨迹的信号控制交叉口交通运行状态评价和方案优化逐渐成为研究热点。针对以往研究在稀疏车辆轨迹(一个周期内采样车辆少甚至无采样车辆的情形)的条件下排队...
  • -topic elk 5,查看elasticsearch是否接受到数据 数据都已经上来本次模拟了2万条数据 一会测试下1000千万数据下的查询 六、后续 整体的业务流程是定位数据采集程序采集进入围栏内的车辆定位数据实时传递至kafka集群...

    在这里插入图片描述

    一、搭建zookeeper:
    1,zookeeper镜像采用wurstmeister/zookeeper:latest拉取zookeeper镜像
    docker pull wurstmeister/zookeeper
    在这里插入图片描述

    2,启动zookeeper
    docker run -d --name zookeeper -p 2181:2181 -t wurstmeister/zookeeper
    在这里插入图片描述

    3,查看zookeeper启动日志
    docker logs -f zookeeper
    在这里插入图片描述

    4,查看zookeeper安装路径
    docker exec zookeeper pwd
    在这里插入图片描述

    5,查看zookeeper运行状态
    docker exec zookeeper bin/zkServer.sh status
    在这里插入图片描述

    6,zookeeper搭建完成
    二、搭建kafka:
    1,kafka镜像采用wurstmeister/kafka:latest 拉取kafka镜像
    docker pull wurstmeister/kafka
    在这里插入图片描述

    2,启动kafka
    docker run -d --name kafka
    –env KAFKA_ADVERTISED_HOST_NAME=localhost
    –env KAFKA_ZOOKEEPER_CONNECT=172.21.0.11:2181
    –env KAFKA_ADVERTISED_LISTENERS=PLAINTEXT://172.21.0.11:9092
    –env KAFKA_LISTENERS=PLAINTEXT://0.0.0.0:9092
    –env KAFKA_HEAP_OPTS="-Xmx256M -Xms128M"
    –net=host wurstmeister/kafka
    在这里插入图片描述

    3,查看kafka启动日志
    docker logs -f kafka
    在这里插入图片描述

    4,查看kafka版本
    docker exec kafka find / -name *kafka_* | head -1 | grep -o ‘\kafka[^\n]*’
    在这里插入图片描述

    5,kafka搭建完成
    三、搭建logstash
    1,logstash镜像采用logstash:7.9.1拉取logstash镜像
    docker pull logstash:7.9.1
    在这里插入图片描述2,启动logstash
    docker run -d --restart=always --privileged=true
    -p 5044:5044 --name logstash
    -v /root/elk/logstash/config/logstash.yml:/usr/share/logstash/config/logstash.yml
    -v /data/elk/logstash/conf.d/:/usr/share/logstash/conf.d/
    logstash:7.9.1
    在这里插入图片描述3,查看启动日志
    docker exec -it logstash /bin/bash
    4,进入容器
    docker exec -it -u root logstash /bin/bash
    5,找到配置文件修改
    在这里插入图片描述input{
    kafka{
    bootstrap_servers => “172.21.0.11:9092” #kafka地址
    auto_offset_reset => “earliest” #消息读取位置
    topics => [“oracle_test”] #kafka中topic名称,记得创建该topic
    group_id => “logstash” #默认为“logstash”
    codec => “json” #与Shipper端output配置项一致
    consumer_threads => 3 #消费的线程数
    max_poll_records => “2000”
    decorate_events => true #在输出消息的时候回输出自身的信息,包括:消费消息的大小、topic来源以及consumer的group信息。
    }
    }
    output {
    kafka {
    topic_id => “elk”
    bootstrap_servers => “172.21.0.11:9092”
    }
    elasticsearch {
    user => elastic
    password => zOhEjICix5EQBw1Jaxlkcw9i
    hosts => [“https://aws.found.io:9243”]
    index => “logstash-%{+YYYY.MM.dd}”
    }
    }

    6.重启logstash
    docker restart logstash
    四、搭建elasticsearch
    在这里插入图片描述本次elasticsearch采用的是云端官方的服务elasticsearch cloud集群配置是三个节点
    节点1:4 GB RAM
    节点2:1 GB RAM
    节点3:4 GB RAM

    1,集群环境健康检查
    在这里插入图片描述2,查询全部索引
    在这里插入图片描述五、模拟业务环境
    1,进入kafka
    docker exec -it kafka /bin/bash
    2,打开生产者console
    ./kafka-console-producer.sh --broker-list 172.21.0.11:9092 --topic oracle_test
    3,测试数据是从生产库上下载了一会定位数据
    在这里插入图片描述4,logstash的out我配置了个两个通道一个是到elasticsearch,一个是到kafka的另一个topic
    查询测试topic是否接受到数据
    docker exec kafka kafka-console-consumer.sh --bootstrap-server 172.21.0.11:9092 --from-beginning --topic elk
    在这里插入图片描述
    5,查看elasticsearch是否接受到数据
    在这里插入图片描述在这里插入图片描述
    数据都已经上来本次模拟了2万条数据 一会测试下1000千万数据下的查询
    六、后续
    整体的业务流程是定位数据采集程序采集进入围栏内的车辆定位数据实时传递至kafka集群通过管道进入elasticsearch然后供实时查询分析

    展开全文
  • 在之前的轨迹系列中,我们详细的对单个轨迹展示进行了研究,涉及到GPS对接协议、轨迹存储、轨迹纠正算法、前端轨迹展示。 但是,实际项目中还会有另一类需求:假设武汉市洪山区有300辆警车,在大厅的大屏幕上需要...

    文章版权由作者李晓晖和博客园共有,若转载请于明显处标明出处:http://www.cnblogs.com/naaoveGIS/

    1. 背景

    在之前的轨迹系列中,我们详细的对单个轨迹展示进行了研究,涉及到GPS对接协议、轨迹存储、轨迹纠正算法、前端轨迹展示。

    但是,实际项目中还会有另一类需求:假设武汉市洪山区有300辆警车,在大厅的大屏幕上需要知道所有警车的实时轨迹。这个需求用我们之前的单轨迹展示架构是没法支撑的。

    此时,我们需要对我们的架构以及前端展示方式进行重构。

    2.架构设计的几点思考

    a.采用websocket方案重构:传统的前端定时拉取信息方式不足以支撑实时的数据获取,并且向后台不断发送请求获取所有车辆实时轨迹会对服务器造成十分巨大的压力。

    b.GPS接收后直接通过socket推送:避免先入库再读取方式。

    c.GPS进行实时的坐标转换和基于路网的纠正:多轨迹展示中,如果GPS在道路上偏移,会使展示效果格外混乱,所以这里必须进行轨迹的实时纠正。而如何高效的进行轨迹纠正也是一个十分重要的步骤,后篇我们再一起讨论。

    d.前端多轨迹展示的编写:目前百度地图在echarts3中有一个北京公交轨迹展示示例。但是实际项目中,我们是内网的本地地图。这里需要对echarts3中引用百度地图bMap的源码部分进行修改,然后集成至前端框架中。

    3.具体实现

    3.1WebSocket架构

    3.1.1后台

    引入javax.websocket-api-1.1.jar,在tomcat7以后,lib中自带websocketapi.jar。

    编写通信类,比较重要的方法为:

    a. Session  与某个客户端的连接会话,需要通过它来给客户端发送数据

    b. onOpen连接建立成功调用的方法

    c.onClose 连接关闭调用的方法

    d. onMessage 收到客户端消息后调用的方法

    e. onError 发生错误时调用

    f.sendMessage 发送消息

     

    3.1.2前端

    在HTML5中内置有一些API,用于响应应用程序发起的请求。类似于后台的方法,其基本API语句如下:

    创建对象,var ws = new WebSocket(url,name); url为WebSocket服务器的地址,name为发起握手的协议名称,为可选择项。

    发送文本消息,ws.send(msg);msg为文本消息,对于其他类型的可以通过二进制形式发送。

    接收消息,ws.onmessage = (function(){...})();

    错误处理,ws.onerror = (function(){...})();

    关闭连接,ws.close();

    3.2echarts3改写

     

    针对bMap.js的改写为最重要的改写

     

    改写后,在设置参数的options中引入对应改写的地图即可:

     

     

    4.成果展示

     

                      

                            -----欢迎转载,但保留版权,请于明显处标明出处:http://www.cnblogs.com/naaoveGIS/

                                                                                  如果您觉得本文确实帮助了您,可以微信扫一扫,进行小额的打赏和鼓励,谢谢 ^_^

                                                                                                                                                

     

                                      

    展开全文
  • 蚁群算法求解有时间窗约束的车辆路径问题matlab程序 1 简介 带时间窗的车辆路径问题(VRPTW)一般描述为从某一物流配送中心出发,用多台车辆向多个顾客送货,车辆完成配送任务后返回配送中心。 已知每个顾客的位置...

    蚁群算法求解有时间窗约束的车辆路径问题matlab程序

    1 简介

    带时间窗的车辆路径问题(VRPTW)一般描述为从某一物流配送中心出发用多台车辆向多个顾客送货车辆完成配送任务后返回配送中心 已知每个顾客的位置与需求量 每台车的容量一定 将货物送到顾客手中需要满足一定的时间约束 要求合理安排行车路线使目标函数得到优化 对该问题的研究引起了广大学者的关注 它是有容量约束车辆路径问题的扩展 NP难题 求解算法可分为精确算法与启发式算法当顾客点数目较多时 使用精确算法很难在可接受的时间内求得全局最优解 因此 用启发式算法在可接受的时间内求得问题的满意解成为研究的重要方向

    蚁群算法是由Dorigo等首先提出来的 它的基本思想是利用一群人工蚂蚁的协作来寻找优化问题的较优解 每只蚂蚁根据问题所给的准则 从被选中的初始状态出发建立一个可行解或部分解 各个蚂蚁间通过信息素交换信息 从而达到相互协作的目的蚁群算法的思想已被应用到各个研究领域 并取得了大量的研究成果 而在VRPTW方面的研究则较少

    2 有时间窗的车辆路径问题

    为简化问题的描述,需要在构建模型前做一些基本的假设和约束:

        (1) 假设物流运输车辆状况相同;

        (2) 单车运载力要大于单个客户需求量,且每条路线上的客户需求总量不大于单车最大运载力;

        (3) 配送中心能够满足所有客户需求,无缺货;

        (4) 车辆完成配送后直接返回配送中心;

    (5) 每条路径长度不超过单车最大行程;

    (6) 车辆要在时间窗内到达相应客户点,否则会产生惩罚成本;

     

    向客户配送货物有时间限制,在此采用软时间窗的限制方法进行处理, 即对客户需求的货物在一定的时间范围内到达,若未能按时到达,则将对物流配送企业给予一定的罚金。则因不在时间窗内将产品送到客户点而产生的处罚成本用C5表示,公式如下所示:

        

    其中:分别表示车辆早于和晚于时间窗将货物卸下而带来的损失成本。为车辆到达客户 j 的时刻,为车辆在客户 j 处等待的时间。

    3 问题求解

    蚁群算法(Ant Colony Algorithm)可以很好地解决 VRP,因为该算法在满足各需求点的时间窗约束的前提下采用动态信息策略, 以保证在每次搜索中每只蚂蚁都对搜索做出贡献, 

    最快地找到最优解或满意解。简单来说,此算法是一种源于自然界中生物世界新的仿生类随机型、智能多主体搜索算法,它吸收了昆虫王国中蚂蚁的行为特性,通过其内在的搜索机制,在一系列困难的路径优化问题求解中取得了成效。所以本文打算通过 MATLAB 强大的计算功能编写蚁群算法程序来深入研究冷链物流路径优化问题。

    基本蚁群算法的思路如下:

    Begin

    初始化:

    Nc    0;Nc为迭代次数)

    对各边弧(i,j;

            常数c;(较小的正数)    0;

         Ca    L;ca为车辆的剩余载重量)

         Cb    N;Cb为车辆的剩余行驶距离)

     读入其他输入参数;

     Loop:

         将初始点放入当前的解集中;

         While(不满足停机准则)do

         begin

         对每只蚂蚁k;

             按照剩余载重量,剩余行驶路径长和转移概率选择顶点j;

             将蚂蚁k从顶点i转移到顶点j;

             将顶点i放在当前的解集中;

         end

         当所有的城市都放在解集中,就记录蚂蚁的个数M    k;

         利用局部搜索机制来优化路径;

         然后计算每只蚂蚁的目标函数值;

         并计算当前的最好解;

         For k   1toM do

         begin

             对各边(i,j,计算:;(增加的信息素)

         end

             对各边(i,j,计算:;(轨迹更新)

             对各边(i,j,;

             ;

             Nc<预定的迭代次数,则go to Loop;

         End 

    部分程序
    %     Author:    怡宝2号			博士猿工作室
    %     Use:       用蚁群算法求解有容量限制、时间窗限制的车辆路径问题;
    %                坐标视自己的具体情况而定。
    %     Illustrate:输入变量(must):     
    %                              coordinate:要求的相应点的坐标,第一行是点的横坐标,第二行是点的纵坐标
    %                                demand(1*n),n表示工厂的个数;t表示各个工厂要求运送的货物的重量
    %                                LimitW:每辆车限制的载重量
    %       Can—changed parameter: m:蚁群的规模
    %                                MAXGEN:蚁群的最大迭代代数
    %                               
    %                  输出:        bestpop:最短路程对应的路径
    %                                trace :最短路程
    %				  remark:    如有疑问请咨询qq:778961303
    clc
    clear all
    close all
    format compact
    
    %蚁群参数初始化
    Alpha = 1;        %求解选择下一个城市的概率
    Beta = 5;         %求解选择下一个城市的概率
    Rho = 0.75;       %信息素的全局更新
    Q = 200;          %信息素增加强度系数
    Elite = 1;        %精英蚂蚁数量
    
    m = 40;           %每一代有40只蚂蚁
    MAXGEN = 100;     %最大迭代代数
    Prab = 0.05;      %伪随机选择概率
    
    %读取初始数据,初始化成本函数的参数
    [F,C,P,ZETA1,ZETA2,THETA,R,S,ELTAT,COSTP,V,BETA,OMEGA1,OMEGA2,coordinate,demand,ET,LT,ST,speed, LimitW] = initial();          
    
    %求各个客户点之间的距离
    [Distance n] = CalculateD(coordinate);      %n为客户数量,包括配送中心
    
    Eta=1./Distance;        %Eta为启发因子,离散模型设为距离的倒数
    Tau=ones(n,n);          %Tau为信息素矩阵,行:前一个城市的标号;列:后一个城市的标号。
    Tabu=zeros(m,n+20);     %存储并记录路径的生成
    
    bestpop = zeros(MAXGEN,n+20);       %每代最优的蚂蚁
    trace = zeros(MAXGEN,1);            %每代最小的成本
    
    %迭代寻优开始开始
    load = 0;               %初始化载重
    NC=1;                   %迭代计数器 
    while NC<=MAXGEN
        
        Tabu(:,1)=1;        %每只蚂蚁都是从仓库(及节点1)开始出发
        
        %精英保留策略
        start = 1;
        if 2<=NC
            start = Elite + 1;
        end
        
        for i=start:m
            visited=Tabu(i,:);
            visited=visited(visited>0);
            to_visit=setdiff(1:n,visited);         %在集合论中,to_visit = (1:n) - visited
            
            actualST = zeros(n,1);                 %实际服务时间,初始化,一只蚂蚁初始化一次
            actualST(1) = ET(1);                   %对初始点的服务时间,初始化
            j=1;
            while j<=n
                if ~isempty(to_visit)              %判断所有客户点是否送完
                    %计算接下来要参观的其他城市的概率
                    for k=1:length(to_visit)
                        [Tij actualST] = CalculateT( visited(end) , to_visit(k) ,actualST,Distance,ST,speed);            %计算从客户i到达客户j的时间
                        VC = CalculateVC( visited(end) , to_visit , actualST , Distance , ST, speed, LT);                 %计算从客户i到下一个客户的潜在客户
                        x(k)=(Tau(visited(end),to_visit(k))^Alpha)*(Eta(visited(end),to_visit(k))^Beta)*...
                             1/( abs(Tij-ET(to_visit(k))) + abs(Tij-LT(to_visit(k))) )*VC;
                    end
                    
                    %伪随机选择,选择下一个城市
                    temp_pra=rand;
                    if temp_pra<Prab                %如果满足伪随机选择概率,直接选择概率最大的,这样收敛更快
                        Select=find(max(x));
                    else
                        x=x/(sum(x));               %用轮盘赌法选择下一个城市
                        xcum=cumsum(x); 
                        Select=find(xcum>=rand);
                    end                
                    
                    %计算车的载重
                    if isempty(Select)              %如果选不了下一个城市了,就回到1点
                        Select=1;
                        load=load+demand(Select);   %select=1;t(select)=0
                    else
                        load=load+demand(to_visit(Select(1)));       %select表示城市标号,to_visit(select)才表示城市
                    end
                    
                    %判断载重是否超限,并对路径表修改
                    if load>W                  %判断车是否超载,超载就回到原地
                        Select=1;
                        j=j-1;                      %j表示参观了的城市,参观的城市-1
                        load=0;                     %车辆的载重归零
                        Tabu(i,length(visited)+1)=Select(1);      %给车辆的路径信息赋值,及回到原点,要参观的客户赋值为1.
                    else
                        Tabu(i,length(visited)+1)=to_visit(Select(1));
                    end
                    
                end
                
                %对访问过的客户,和待访问的客户初始化
                visited=Tabu(i,:);
                visited=visited(visited>0);                  %已经拜访过的客户
                to_visit=setdiff(1:n,visited);
                x=[];
                if visited(end)~=1
                    Tabu(i,1:(length(visited)+1))=[visited,1];
                end
                j = j+1;
                j;
            end
            %1只蚂蚁配送路线完成
            load = 0;
        end
        %m只蚂蚁路线安排完成
        
        %计算m只蚂蚁的个体适应度
        L=zeros(m,1);               %共有m只蚂蚁
        for i=1:m 
            temp=Tabu(i,:); 
            route=temp(temp>0);     %每只蚂蚁的路径
        end
        
        %精英保留策略
        [ex index] = sort(L,'ascend');
        index = index(1:Elite);
        temp = Tabu(index,:);
        tempL = L(index);
        Tabu(1:Elite,:) = temp;
        L(1:Elite) = tempL;
        
        [mintrace index] = min(L);  %最小的成本
        temp = Tabu(index(1),:);    %最小成本对应的蚂蚁
        trace(NC) = mintrace;       %保存每代的最小成本和最小蚂蚁
        bestpop(NC,:) = temp;
        
        %更新信息素
        Delta_Tau=zeros(n,n);
        for i=1:m
            temp=Tabu(i,:); 
            route=temp(temp>0);
            for j=1:(length(route)-1) 
                Delta_Tau(route(j),route(j+1))=Delta_Tau(route(j),route(j+1))+Q/L(i);
            end
            Delta_Tau(route(n),route(1))=Delta_Tau(route(n),route(1))+Q/L(i);
        end
    %     %信息素更新
    %     Delta_Tau=zeros(n,n); 
    %     for i=1:m 
    %         temp=Tabu(i,:); 
    %         route=temp(temp>0);
    %         for j=1:(length(route)-1) 
    %             Delta_Tau(route(j),route(j+1))=Delta_Tau(route(j),route(j+1))+Q/L(i);
    %         end
    %     end
    %     Tau=(1-Rho).*Tau+Delta_Tau;
        
        %路径清零,载荷清零
        temp=zeros(m-Elite,n+20); 
        Tabu(Elite+1:m,:) = temp;
        load=0;    
        
        disp(['共迭代',num2str(MAXGEN),'次,现在为:',num2str(NC)]);
    %     NC
        NC = NC + 1;
    end
    
    %绘制寻优迭代图
    figure()
    plot(trace)
    plot(trace,'--b',...
        'LineWidth',2);
    grid off
    xlabel('迭代次数数')
    ylabel('成本')
    title('成本变化','fontsize',16)
    
    %显示路径
    [mintrace index] = min(trace);              %最小成本
    route = bestpop(index,:);                   %最小成本的路径
    route = route( route>0 );
    p=num2str(route(1));
    for i=2:length(route)
        p=[p,'->',num2str(route(i))];
    end
    display(['求解的最优路径为:',num2str(p)]);
    display(['1代表物流中心']);
    disp(['最小的成本代价为:',num2str(min(trace))]);
    
    %绘制最小成本的路径
    figure();
    DrawRoute(coordinate,route)
    
    %				  remark:    如有疑问请咨询qq:778961303

    结果





    展开全文
  • HBase 存储船舶轨迹方案 背景:项目需求要存储三个月的船舶轨迹数据,并且能够根据时间段快速查询单艘船的轨迹数据。船舶数据4~5万,5分钟记录一次轨迹。 1、环境基础:已经安装部署完成hbase 集群环境 ,安装部署...

    HBase 存储船舶轨迹方案

    背景:项目需求要存储三个月的船舶轨迹数据,并且能够根据时间段快速查询单艘船的轨迹数据。船舶数据4~5万,5分钟记录一次轨迹。

    1、环境基础:已经安装部署完成hbase 集群环境 ,安装部署链接: https://blog.csdn.net/weixin_41352552/article/details/109851768.

    2、运用 springboot 集成hbase,使用定时器从redis中循环取出船舶点插入hbase,轨迹数量达到1千万。

    1、目录架构

    在这里插入图片描述

    2、引入相关依赖 pom.xml 文件

    <dependency>
                <groupId>org.apache.hbase</groupId>
                <artifactId>hbase-client</artifactId>
                <version>1.3.0</version>
                <exclusions>
                    <exclusion>
                        <groupId>org.slf4j</groupId>
                        <artifactId>slf4j-log4j12</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>log4j</groupId>
                        <artifactId>log4j</artifactId>
                    </exclusion>
                    <exclusion>
                        <groupId>javax.servlet</groupId>
                        <artifactId>servlet-api</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-common</artifactId>
                <version>2.6.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-mapreduce-client-core</artifactId>
                <version>2.6.0</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-mapreduce-client-common</artifactId>
                <version>2.6.0</version>
            </dependency>
            <dependency>
                <groupId>org.springframework.data</groupId>
                <artifactId>spring-data-hadoop</artifactId>
                <version>2.5.0.RELEASE</version>
            </dependency>
    
            <dependency>
                <groupId>org.apache.hadoop</groupId>
                <artifactId>hadoop-hdfs</artifactId>
                <version>2.6.0</version>
            </dependency>
    

    3、hbase连接配置

    在application.properties 文件中添加以下配置

    ################################HBASE 配置##########################################
            
    hbase.zookeeper.quorum=master:2181,slave1:2181 # hbase集群的ip+端口
    

    HBaseConn 连接配置

    @Component
    public class HBaseConn {
    
        @Value("${hbase.zookeeper.quorum}")
        private String zookeeperQuorum;
    
        private static final HBaseConn INSTANCE = new HBaseConn();
        private static Configuration configuration;
        private static Connection connection;
    
        private HBaseConn() {
            try {
                if (configuration == null) {
                    configuration = HBaseConfiguration.create();
                    configuration.set("hbase.zookeeper.quorum", zookeeperQuorum);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        private Connection getConnection() {
            if (connection == null || connection.isClosed()) {
                try {
                    connection = ConnectionFactory.createConnection(configuration);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
            return connection;
        }
    
        public static Connection getHBaseConn() {
            return INSTANCE.getConnection();
        }
    
        public static Configuration getConfiguration() {
            return configuration;
        }
    
        public static void closeConn() {
            if (connection != null) {
                try {
                    connection.close();
                } catch (IOException ioe) {
                    ioe.printStackTrace();
                }
            }
        }
    
      public static Table getTable(String tableName) throws IOException {
        return INSTANCE.getConnection().getTable(TableName.valueOf(tableName));
      }
    }
    

    HBaseUtil Hbase的工具包

    public class HBaseUtil {
    
        /**
         * 创建HBase表.
         *
         * @param tableName 表名
         * @param cfs       列族的数组
         * @return 是否创建成功 boolean
         */
        public static boolean createTable(String tableName, String[] cfs) {
            try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {
                if (admin.tableExists(tableName)) {
                    return false;
                }
                HTableDescriptor tableDescriptor = new HTableDescriptor(TableName.valueOf(tableName));
                String nameAsString = tableDescriptor.getNameAsString();
                System.out.println(nameAsString);
                Arrays.stream(cfs).forEach(cf -> {
                    HColumnDescriptor columnDescriptor = new HColumnDescriptor(cf);
                    columnDescriptor.setMaxVersions(1);
                    tableDescriptor.addFamily(columnDescriptor);
                });
                admin.createTable(tableDescriptor);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return true;
        }
    
    
        /**
         * 删除hbase表.
         *
         * @param tableName 表名
         * @return 是否删除成功 boolean
         */
        public static boolean deleteTable(String tableName) {
            try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {
                admin.disableTable(tableName);
                admin.deleteTable(tableName);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return true;
        }
    
        /**
         * hbase插入一条数据.
         *
         * @param tableName 表名
         * @param rowKey    唯一标识
         * @param cfName    列族名
         * @param qualifier 列标识
         * @param data      数据
         * @return 是否插入成功 boolean
         */
        public static boolean putRow(String tableName, String rowKey, String cfName, String qualifier,
                                     String data) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Put put = new Put(Bytes.toBytes(rowKey));
                put.addColumn(Bytes.toBytes(cfName), Bytes.toBytes(qualifier), Bytes.toBytes(data));
                table.put(put);
            } catch (IOException ioe) {
                ioe.printStackTrace();
                return false;
            }
            return true;
        }
    
        /**
         * 插入多条数据
         *
         * @param tableName the table name
         * @param puts      the puts
         * @return the boolean
         */
        public static boolean putRows(String tableName, List<Put> puts) {
            try (Table table = HBaseConn.getTable(tableName)) {
                table.put(puts);
            } catch (IOException ioe) {
                ioe.printStackTrace();
                return false;
            }
            return true;
        }
    
        /**
         * 获取单条数据.
         *
         * @param tableName 表名
         * @param rowKey    唯一标识
         * @return 查询结果 row
         */
        public static Result getRow(String tableName, String rowKey) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Get get = new Get(Bytes.toBytes(rowKey));
                return table.get(get);
            } catch (IOException ioe) {
                ioe.printStackTrace();
                return null;
            }
        }
    
    
        /**
         * 获取数据
         *
         * @param tableName  the table name
         * @param rowKey     the row key
         * @param filterList the filter list
         * @return the row
         */
        public static Result getRow(String tableName, String rowKey, FilterList filterList) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Get get = new Get(Bytes.toBytes(rowKey));
                get.setFilter(filterList);
                return table.get(get);
            } catch (IOException ioe) {
                ioe.printStackTrace();
                return null;
            }
        }
    
        /**
         * 检索数据..
         *
         * @param tableName the table name
         * @return the scanner
         */
        public static ResultScanner getScanner(String tableName) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Scan scan = new Scan();
                scan.setCaching(1000);
                return table.getScanner(scan);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return null;
        }
    
        /**
         * 批量检索数据.
         *
         * @param tableName   表名
         * @param startRowKey 起始RowKey
         * @param endRowKey   终止RowKey
         * @return ResultScanner实例 scanner
         */
        public static ResultScanner getScanner(String tableName, String startRowKey, String endRowKey) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Scan scan = new Scan();
                scan.setStartRow(Bytes.toBytes(startRowKey));
                scan.setStopRow(Bytes.toBytes(endRowKey));
                scan.setCaching(1000);
                return table.getScanner(scan);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return null;
        }
    
        /**
         * Gets scanner.
         *
         * @param tableName   the table name
         * @param startRowKey the start row key
         * @param endRowKey   the end row key
         * @param filterList  the filter list
         * @return the scanner
         */
        public static ResultScanner getScanner(String tableName, String startRowKey, String endRowKey,
                                               FilterList filterList) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Scan scan = new Scan();
                scan.setStartRow(Bytes.toBytes(startRowKey));
                scan.setStopRow(Bytes.toBytes(endRowKey));
                scan.setFilter(filterList);
                scan.setCaching(1000);
                return table.getScanner(scan);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return null;
        }
    
        /**
         * HBase删除一行记录.
         *
         * @param tableName 表名
         * @param rowKey    唯一标识
         * @return 是否删除成功 boolean
         */
        public static boolean deleteRow(String tableName, String rowKey) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Delete delete = new Delete(Bytes.toBytes(rowKey));
                table.delete(delete);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return true;
        }
    
        /**
         * Delete column family boolean.
         *
         * @param tableName the table name
         * @param cfName    the cf name
         * @return the boolean
         */
        public static boolean deleteColumnFamily(String tableName, String cfName) {
            try (HBaseAdmin admin = (HBaseAdmin) HBaseConn.getHBaseConn().getAdmin()) {
                admin.deleteColumn(tableName, cfName);
            } catch (Exception e) {
                e.printStackTrace();
            }
            return true;
        }
    
        /**
         * Delete qualifier boolean.
         *
         * @param tableName the table name
         * @param rowKey    the row key
         * @param cfName    the cf name
         * @param qualifier the qualifier
         * @return the boolean
         */
        public static boolean deleteQualifier(String tableName, String rowKey, String cfName,
                                              String qualifier) {
            try (Table table = HBaseConn.getTable(tableName)) {
                Delete delete = new Delete(Bytes.toBytes(rowKey));
                delete.addColumn(Bytes.toBytes(cfName), Bytes.toBytes(qualifier));
                table.delete(delete);
            } catch (IOException ioe) {
                ioe.printStackTrace();
            }
            return true;
        }
    
        /**
         * 利用协处理器进行全表count统计
         *
         * @param tableName the tableName
         * @return the long
         */
        public static Long countRowsWithCoprocessor(String tableName) {
            try (Table table = HBaseConn.getTable(tableName);
                 Connection hBaseConn = HBaseConn.getHBaseConn();
                 Admin admin = hBaseConn.getAdmin()) {
                TableName name = table.getName();
                HTableDescriptor descriptor = admin.getTableDescriptor(name);
                String coprocessorClass = "org.apache.hadoop.hbase.coprocessor.AggregateImplementation";
                if (!descriptor.hasCoprocessor(coprocessorClass)) {
                    admin.disableTable(name);
                    descriptor.addCoprocessor(coprocessorClass);
                    admin.modifyTable(name, descriptor);
                    admin.enableTable(name);
                }
                //计时
                StopWatch stopWatch = new StopWatch();
                stopWatch.start();
                Scan scan = new Scan();
                AggregationClient aggregationClient = new AggregationClient(HBaseConn.getConfiguration());
                Long count = aggregationClient.rowCount(name, new LongColumnInterpreter(), scan);
                stopWatch.stop();
                System.out.println("RowCount:" + count + ",全表count统计耗时:" + stopWatch.getTotalTimeMillis());
                return count;
            } catch (Throwable ioe) {
                ioe.printStackTrace();
            }
            return 0L;
        }
    }
    

    HBaseController 测试HBase 的controller

    @RestController
    @RequestMapping("/hbase")
    public class HBaseController {
    
        @Resource
        private RedisUtils redisUtils;
    
        /**
         * 插入轨迹数据
         * @return return
         */
        @GetMapping("/saveShipPoint")
        public String saveShipPoint() {
            // 从redis中取出船舶轨迹点数据
            List<Object> list = redisUtils.getMaster().getValuesFromPattern("SHIP1:*");
            if (list == null) {
                return null;
            }
            List<Put> putList = new ArrayList<>(list.size()*2);
            list.forEach(e->{// 循环遍历
                JSONObject data = JSONObject.parseObject(e.toString());
                String shipNumber = data.getString("shipNumber");
                String shipName = data.getString("shipName");
                String longitude = data.getString("longitude");
                String latitude = data.getString("latitude");
                if(!StringUtils.isEmpty(shipNumber) && !StringUtils.isEmpty(shipName)
                    && longitude!=null && latitude!=null){
                    // 行键 船舶唯一标识9位码+当前时间
                    Put put = new Put(Bytes.toBytes(shipNumber+"-"+System.currentTimeMillis()));
                    // 船舶九位码
                    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("shipNumber"), Bytes.toBytes(shipNumber));
                    // 船舶名称(中文)
                    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("shipName"), Bytes.toBytes(shipName));
                    // 经度
                    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("longitude"), Bytes.toBytes(longitude));
                    // 纬度
                    put.addColumn(Bytes.toBytes("info"), Bytes.toBytes("latitude"), Bytes.toBytes(latitude));
                    //put插入数据
                    putList.add(put);
                }
            });
    
            if (!CollectionUtils.isEmpty(putList)) {
                // 插入ship表中
                HBaseUtil.putRows("ship", putList);
            }
            return  "OK";
        }
    
    
        /**
         * 获取ship表中的记录总数
         * @return ship表中的记录总数
         */
        @GetMapping("/count")
        public Long getShipCount() {
            return HBaseUtil.countRowsWithCoprocessor("ship");
        }
    
    
        /**
         * 根据时间段查询船舶轨迹
         * @return re
         */
        @GetMapping("/find")
        public String find() {//1605843004000 1605843184000 1605843124000
            // 使用行键前缀过滤器
            Filter filter = new PrefixFilter(Bytes.toBytes("413790328-"));
            FilterList filterList = new FilterList(FilterList.Operator.MUST_PASS_ALL, Collections.singletonList(filter));
            // 添加时间段条件
            ResultScanner scanner = HBaseUtil
                    .getScanner("ship", "413790328-1605841204000", "413790328-1605856498271", filterList);
            AtomicInteger i = new AtomicInteger();
            // 获取到对应的船舶轨迹list
            if (scanner != null) {
                scanner.forEach(result -> {
                    i.getAndIncrement();
                    System.out.println("rowkey=" + Bytes.toString(result.getRow()));
                    System.out.println("fileName=" + Bytes.toString(result.getValue(Bytes.toBytes("info"), Bytes.toBytes("shipName"))));
                });
                System.out.println("一共获取数据:"+ i.get());
                // 关闭scanner连接
                scanner.close();
            }
            return "OK"+i.get();
        }
    
        /**
         * 创建表
         * @return ship表
         */
        @GetMapping("/createShipTable")
        public Boolean createShipTable() {
            return HBaseUtil.createTable("ship", new String[]{"info"});
        }
    }
    

    ShipSchedule 定时器

    @Component
    @Slf4j
    public class ShipSchedule {
    
    
        @Resource
        HBaseController hBaseController;
    
        // 定时存入轨迹数据
        //@Scheduled(cron = "0/10 * * * * ? ")
        public void saveShipPoint(){
            hBaseController.saveShipPoint();
        }
    }
    

    redis中的测试数据(2万6)
    在这里插入图片描述

    实现步骤

    1、访问createShipTable方法创建ship表
    在这里插入图片描述

    2、启动定时器 运行saveShipPoint方法,保存船舶得轨迹测试数据(数量达到1000W,大概持续运行一个小时)

    3、访问getShipCount方法获取表的总记录数(全表计算用时比较长)
    在这里插入图片描述

    4、访问find方法根据时间段查询船舶轨迹(查询速度达到毫秒级70ms)
    在这里插入图片描述
    5、轨迹数据表可以按天创建每天创建一个ship+日期表(如ship20201122、ship20201123等)。

    展开全文
  • 轨迹记录是现在交通运输发展的今天必不可少的一项技术,从卫星上天得那一刻,运输管控等TMS类似就注定诞生! 百度知道告诉我们GPS定位不准原因: https://jingyan.baidu.com/article/48a42057084f9fa9242504de.html  ...
  • 智慧环卫车辆监控管理系统方案

    千次阅读 2020-05-25 11:50:36
    智慧环卫车辆监控管理系统方案 1系统架构设计方案 1.1系统构成 该系统主要分为三部分:车载终端部分、通信网络部分和监控调度指挥中心部分。 如下图: 1.2车载终端部分构成图 车载终端部分主要由2G/3G...
  • 该课题为基于帧差法的运动车辆目标跟踪,配备一个GUI界面,可实现统计车辆数量,运动轨迹,和统计车辆数量和车流量以及速度等。后期可开发成判断道路是否拥挤等课题。可定制关于违章检测,车辆车型,车标等识别。
  • 百度智能云AI产品研发部讲师天团倾力打造零门槛AI开发实训营,系列直播课覆盖图像分割、物体检测、图像分类、目标跟踪、结构化文字识别、时序预测等多个技术方向,精选无人驾驶道路场景解析、视频流车辆跟踪计数、...
  •  解决了数据源问题,接下来问题就是数据往哪里存的问题,在android系统中实现数据持久化通常有一下几个解决方案, 3.1 SharedPreferences 适用与存储一些app的配置信息,例如缓存用户登录的用户名,密码等信息...
  • 人员定位及轨迹管理方案

    千次阅读 2021-03-03 09:32:02
    华星智控精准定位系统,可以精准定位室内外人员、物资、车辆的位置,定位精度优于30厘米。 要被定为的目标对象需要佩戴有源的定位标签,在需要定位的室内或者室外安装定位基站,就可以实现对人员、物资的精确定位...
  • 在此之前, 制作过GPRS+GPS实时获取卫星坐标上传服务器, 显示轨迹的例子, 但很不幸地, 因未考虑车辆输出电流过大的问题, 测试几天后GPRS因电流过大烧(炸)了。 停滞了一段时间后, 正巧碰上DFRobot开展Bluno beetle免费...
  • 物联网应用中实时定位与轨迹回放的解决方案 – Redis的典型运用(转载) 物联网应用中实时定位与轨迹回放的解决方案 – Redis的典型运用(转载) 2015年11月14日| by: nbboy| Category: 系统设计, 缓存设计, 高性能...
  • 上篇文章提到了车辆轨迹回放主要有两个方案:一种是通过标记点moveAlong()的方法,另一种是PathSimplifier是一个轨迹展示组件;上篇使用了标记点的方法,这篇就来使用PathSimplifier的轨迹展示的方法,同样的效果...
  • 针对VANETs中车辆移动的相对速度较高,网络拓扑结构频繁变化,传统WSN和MANET中的位置验证方案不再适用于VANETs,提出基于车辆的运动轨迹位置验证方案,采用最小二乘法对车辆进行连续定位跟踪,并绘制其行驶路线,与邻居...
  • 深兰科技DeepBlueAI 团队包揽了首届GigaVision挑战赛“行人和车辆检测”和“多目标追踪”两个赛道的冠军。 过去十年中,行人检测、跟踪、动作识别、异常检测、属性识别等以人为中心的计算机视觉分析任务引起了人们的...
  • 个人认为LBS是移动互联网最主要的特征之一,自己以前没做过地图有关的项目,看到网上也没有完整有关地图的项目,就想起模仿一下摩拜单车app,我这个小项目包括附近车辆、规划路径、行驶距离、行驶轨迹记录、轨迹回放...
  • 出租车车辆监控方案

    2014-12-22 20:52:38
    GPS功能可将接收到的全球卫星定位系统GPS(Global Position System)的定位信息通过无线网络传输系统定时发送至出租车调度管理中心,车辆调度管理人员在监控中心可获取出租车车辆的行驶轨迹、速度和方向等信息,...
  • 本文提出了一种轨迹监控策略,同时进行换道轨迹规划和监控轨迹规划,在前者未能规划出轨迹或者规划超时,系统将以监控轨迹作为输出,保证车辆换道的稳定性和可行性。为满足车辆运动约束以及实时性要求,将采用基于B...
  • 在越来越多的可视化需求中,对空间信息的展示,逐渐的由静转为动,通过还原一些真实的时空信息,如历史行车轨迹,渔船打捞作业,特种车辆运行轨迹回放等可以直观的查看时空分布规律,它是一种越来越重要的展示形式...
  • 车辆视图大数据深度联网应用平台充分发挥人工智能、深度学习、计算机视觉等前沿技术在图像分析处理领域的专业优势,针对治安防控业务应用层对实时监控、快速检索、轨迹追踪、预测预警等方面的深度需求,依托各地已...
  • 车辆管理系统

    千次阅读 2017-12-08 10:30:50
    随着社会经济的发展,使用车辆的人越来越多...针对这种状况,很多企业集团提出了车辆管理系统建设要求,希望通过系统建设实现有效的车辆基础信息管理、车辆调度管理、车辆费用成本管理、车辆行车轨迹的监控。根据众多大
  • 车辆监控管理系统是利用全球定位技术、通过无线数据传输,并 配合计算机软件(MIS)实现对车辆的各项静态和动态信息进行管理。 车辆监控管理系统的组成:包括车载设备,监控管理中心,无线通信网络。 车载监控终端...
  • 本范例主要展示GPS轨迹回放,颜色方案、速度、模式均可根据用户需求自由选择。
  • 处理的业务有: 某地点的过车次数 某辆车的行车轨迹(通过给定的时间范围和车辆的电子车牌(EID),重现车辆轨迹。解决方案方案一,将该车辆所有轨迹信息提取出来,时间排序,然后按照规定范围获取数据,但是当数据...
  • 光流法运动目标检测

    万次阅读 2019-05-21 10:07:11
    ,运动物体检测广泛应用于视频安全监控、车辆检测等方面。 常用的目标跟踪方法有: 背景差法 :将一幅图作为背景,让后和每一帧对比;就是用原图像减去背景模型,剩下的就是前景图像,即运动目标,缺点是一...
  • 轨迹时空数据存储对比分析

    千次阅读 2019-03-09 16:15:06
    最近有一批车辆轨迹数据需要用postgresql管理起来。数据格式相对比较简单,就是一堆csv文件,每行一个点,包括x,y,t和其他的一些速度,方向属性信息。 方案对比 能想到的最简答的方法就是把csv映射到数据库的表...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,508
精华内容 1,803
关键字:

方案车辆轨迹