Skip to content

M
map-parent
Commit 7e976f2b by YANGYANG
Options

车辆徘徊 和 活动区域接口提交

parent eac80a6e
Showing with 456 additions and 3 deletions
common/common_utils/src/main/java/com/founder/commonutils/carEntity/TrackYstldResultCountSort.java 0 → 100644
package com.founder.commonutils.carEntity;
/**
* Created by Founder on 2019/6/27.
* 轨迹疑似停留点实体表
*/
public class TrackYstldResultCountSort implements Comparable<TrackYstldResultCountSort>{
private String x;//经度
private String y;//纬度
private String tlsjStr;//停留时间差
private int tlsj;
private int count;//停留次数
private String address;//地址
private long kssj;//开始时间时间戳
public long getKssj() {
return kssj;
}
public void setKssj(long kssj) {
this.kssj = kssj;
}
public String getY() {
return y;
}
public void setY(String y) {
this.y = y;
}
public String getX() {
return x;
}
public void setX(String x) {
this.x = x;
}
public String getTlsjStr() {
return tlsjStr;
}
public void setTlsjStr(String tlsjStr) {
this.tlsjStr = tlsjStr;
}
public int getTlsj() {
return tlsj;
}
public void setTlsj(int tlsj) {
this.tlsj = tlsj;
}
public int getCount() {
return count;
}
public void setCount(int count) {
this.count = count;
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
@Override
public int compareTo(TrackYstldResultCountSort o) { //重写Comparable接口的compareTo方法，
return o.getCount()-this.getCount();// 根据次数降序排列，升序修改相减顺序即可
}
}
common/common_utils/src/main/java/com/founder/commonutils/util/DataUtil.java
package com.founder.commonutils.util;
import com.founder.commonutils.carEntity.CarReceiving;
import com.founder.commonutils.peopleEntity.FaceSearchResult;
import java.text.DateFormat;
......@@ -55,6 +56,36 @@ public class DataUtil {
}
return lists;
}
//数据批量 方法
public static List<List<CarReceiving>> cpldata(List<CarReceiving> list, int limit) throws Exception {
long start = System.currentTimeMillis();
int size = list.size();
//特殊处理
if(limit==0){
limit=1;
}
long threadNum = size / limit;
int startnum = 0;
int endnum = 0;
List<List<CarReceiving>> lists = new ArrayList<>();
for (int i = 0; i < threadNum + 1; i++) {
startnum = i * limit;
endnum = ((i + 1) * limit);
if (startnum > list.size()) {
break;
}
if (endnum > list.size()) {
endnum = list.size();
}
if (startnum == endnum) {
break;
}
List<CarReceiving> pllist = list.subList(startnum, endnum); //从fromIndex（包含），到toIndex（不包含）
lists.add(pllist);
}
return lists;
}
/*public static List<List<CameraFaceResult>> plCameraFaceResult(List<CameraFaceResult> list, int limit) throws Exception {
long start = System.currentTimeMillis();
int size = list.size();
......
serviceapi/carapi/src/main/java/com/founder/carapi/controller/CarController.java
......@@ -61,6 +61,15 @@ public class CarController {
return result;
}
//区域徘徊 -结果展示（徘徊次数3次以上）
@OperLog(message = "车辆徘徊接口",operation = OperationType.QUERY)
@ApiOperation(value = "车辆徘徊接口")
@PostMapping("/carOneAreaInfoTrampResultThread")
public MapRestResult carOneAreaInfoTrampResultThread (@RequestBody AreaInfo areaInfo) throws Exception {
MapRestResult xzxtRestResult=carService.OneAreaInfoTrampResultThread(areaInfo);
return xzxtRestResult;
}
//轨迹疑似停留点
@ApiOperation(value = "轨迹疑似停留点")
@PostMapping("/getTrackYstld")
......@@ -74,6 +83,13 @@ public class CarController {
return carService.getTrackYsljd(track);
}
//轨迹疑似活动区域
@ApiOperation(value = "轨迹疑似活动区域")
@PostMapping("/getTrackYshdqy")
public MapRestResult getTrackYshdqy(@RequestBody TrackYsModelCondition track){
return carService.getTrackYshdqy(track);
}
@ApiOperation(value = "车碰撞结果获取")
@PostMapping("/getRegionalsResult")
public MapRestResult getRegionalsResult(@RequestBody TbStRegionalstaskresult tbStRegionalstaskresult) throws Exception {
......
serviceapi/carapi/src/main/java/com/founder/carapi/mapper/xml/RegInfoMapper.xml
......@@ -198,8 +198,9 @@
task_Object as taskObject,
to_char(djsj,'yyyy-mm-dd hh24:mi:ss') as djsj,
fsr_Xm as fsrXm,
carNum as carNum
FROM tb_st_regionals_task
carNum as carNum,
(select count(*) from tb_st_regionals_results r where t.task_id = r.task_id) as counts
FROM tb_st_regionals_task t
where 1=1
<if test="startTime != null and startTime != ''">and DJSJ <![CDATA[>=]]> TO_DATE(#{ startTime , jdbcType=VARCHAR },'yyyy-MM-dd')</if>
<if test="endTime != null and endTime != ''">and DJSJ <![CDATA[<]]> (TO_DATE(#{ endTime , jdbcType=VARCHAR },'yyyy-MM-dd')+1)</if>
......
serviceapi/carapi/src/main/java/com/founder/carapi/service/CarService.java
......@@ -33,4 +33,7 @@ public interface CarService {
MapRestResult getRegionalsResultFl(TbStRegionalstaskresult tbStRegionalstaskresult) throws Exception;
MapRestResult getTrackYshdqy(TrackYsModelCondition track);
MapRestResult OneAreaInfoTrampResultThread (AreaInfo areaInfo) throws Exception;
}
serviceapi/carapi/src/main/java/com/founder/carapi/service/impl/CarServiceImpl.java
......@@ -21,6 +21,7 @@ import com.founder.commonutils.util.KeyUtil;
import com.founder.commonutils.util.StringUtil;
import org.apache.commons.lang.StringUtils;
import org.apache.poi.ss.usermodel.DateUtil;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
......@@ -962,7 +963,7 @@ public class CarServiceImpl implements CarService {
return MapRestResult.build(200, "翻译时间：" + (System.currentTimeMillis() - start), sucesslistAll.size());
}
//4.1 保存结果表（通过单个卡口编号获取结果）（当前时间段被卡口抓拍到的车牌号）-----------------------
//4.1 保存结果表 时空碰撞和车辆徘徊调用（通过单个卡口编号获取结果）（当前时间段被卡口抓拍到的车牌号）-----------------------
public Map<String, List<CarKkInfo>> carInfoSaveResultPz(List<CarKkInfo> carKkInfos) {
Map<String, List<CarKkInfo>> map = new HashMap<>();
//保存数据
......@@ -1412,7 +1413,172 @@ public class CarServiceImpl implements CarService {
}
return resultList;
}
//轨迹疑似活动区域,时间差最长的前五条数据，抓取次数最长的前五条数据，去掉重复以后返回剩余数据
@Override
public MapRestResult getTrackYshdqy(TrackYsModelCondition track) {
List<TrackYstldResult> resultList = new ArrayList<>();
List<TrackYstldResultCountSort> resultCountList = new ArrayList<>();
List<TrackYstldResult> newList = new ArrayList<>();
List<TrackYstldResultCountSort> newListCountSort = new ArrayList<>();
//String returnStr=track.getReturnStr();
/* returnStr="[{\"address\":\"3-ELH\",\"j\":\"106.4925739883\",\"timestamp\":1561935002000,\"w\":\"29.74344713447\"},\n" +
"{\"address\":\"3-ELH\",\"j\":\"106.4925739883\",\"timestamp\":1561935012000,\"w\":\"29.74344713447\"},\n" +
"{\"address\":\"1-ELH\",\"j\":\"106.45259118310\",\"timestamp\":1561935022000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"1-ELH\",\"j\":\"106.45259118310\",\"timestamp\":1561935032000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"3-ELH\",\"j\":\"106.4825731883\",\"timestamp\":1561935032000,\"w\":\"29.74344113447\"},\n" +
"{\"address\":\"3-ELH\",\"j\":\"106.4825731883\",\"timestamp\":1561935042000,\"w\":\"29.74344113447\"},\n" +
"{\"address\":\"4-ELH\",\"j\":\"106.45259118312\",\"timestamp\":1561935032000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"4-ELH\",\"j\":\"106.45259118312\",\"timestamp\":1561935052000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"6-ELH\",\"j\":\"106.45259118313\",\"timestamp\":1561935032000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"6-ELH\",\"j\":\"106.45259118313\",\"timestamp\":1561935042000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"6-ELH\",\"j\":\"106.45259118313\",\"timestamp\":1561935052000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"7-ELH\",\"j\":\"106.45259118314\",\"timestamp\":1561935032000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"7-ELH\",\"j\":\"106.45259118314\",\"timestamp\":1561935042000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"7-ELH\",\"j\":\"106.45259118314\",\"timestamp\":1561935052000,\"w\":\"29.723466680975\"},\n" +
"{\"address\":\"7-ELH\",\"j\":\"106.45259118314\",\"timestamp\":1561935062000,\"w\":\"29.723466680975\"}]";*/
//if (!StringUtils.isEmpty(returnStr)) {
//JSONArray jsonArrays = JSONArray.parseArray(returnStr);//地图传的轨迹数据
if (track.getReturnStr().size() == 0) {
return MapRestResult.build(200, "轨迹疑似活动区域查询", "");
}
final int[] beginIndex = {0};//下标
final int[] endIndex = {0};
List<String> list = new ArrayList<>();//下标list
//因为取回的轨迹数据没有排序，所以先把data数据取回，进行一个时间的升序在进行下面的推算
//begin 取回data，放到list
// List<TrackYstldCondition> listSort=jsonArrays.toJavaList(TrackYstldCondition.class);//jsonarray转list
List<TrackYstldCondition> listSort=track.getReturnStr();//jsonarray转list
//取回轨迹，把经纬度为空的排除掉20200619 begin
Iterator<TrackYstldCondition> listSortIterator = listSort.iterator();
while (listSortIterator.hasNext()){//循环修改newlist里的值
TrackYstldCondition obj = listSortIterator.next();
if(obj.getX()==null || obj.getY()==null){
listSortIterator.remove();
}
}
//取回轨迹，把经纬度为空的排除掉20200619 end
Collections.sort(listSort);//时间戳升序
String ceshi = JSON.toJSONString(listSort);
System.out.println("排序:"+ceshi);
//end
final String[] oldjw={""};
IntStream.range(0, listSort.size()).forEach(i -> {
TrackYstldCondition obj = listSort.get(i);
String jw = obj.getX() + "," + obj.getY().toString();
//比较我每一条和上一条一不一样，一样则endindex++，不一样则beginindex++,第一条除外
if (!jw.equals(oldjw[0])) {
if (i != 0 && endIndex[0] > beginIndex[0]) {
//存储这些下标，统一返回结果
list.add(beginIndex[0] + "," + endIndex[0]);
}
beginIndex[0] = i;
} else {
endIndex[0] = i;
}
oldjw[0]=obj.getX() + "," + obj.getY().toString();
});
if (listSort.size() > 0 && endIndex[0] > beginIndex[0]) {
list.add(beginIndex[0] + "," + endIndex[0]);
}
String ceshi1 = JSON.toJSONString(list);
System.out.println("测试下标:"+ceshi1);
IntStream.range(0, list.size()).forEach(i -> {
String[] index = list.get(i).split(",");
TrackYstldCondition obj1 = listSort.get(Integer.parseInt(index[0]));
TrackYstldCondition obj2 = listSort.get(Integer.parseInt(index[1]));
TrackYstldResult vo = new TrackYstldResult();
vo.setX(obj1.getX().toString());
vo.setY(obj1.getY().toString());
vo.setAddress(obj1.getAddress());
long jssj = obj2.getTimestamp()*1000;//秒转毫秒 chent20200511
long kssj = obj1.getTimestamp()*1000;//秒转毫秒 chent20200511
long tlsj = jssj - kssj;
vo.setTlsj((int) tlsj);
vo.setCount(Integer.parseInt(index[1]) - Integer.parseInt(index[0]) + 1);
vo.setKssj(obj1.getTimestamp()*1000);//秒转毫秒 chent20200511
if((int) tlsj!=0){
resultList.add(vo);
}
//count 降序使用list
TrackYstldResultCountSort voCount = new TrackYstldResultCountSort();
voCount.setX(obj1.getX().toString());
voCount.setY(obj1.getY().toString());
voCount.setAddress(obj1.getAddress());
voCount.setTlsj((int) tlsj);
voCount.setCount(Integer.parseInt(index[1]) - Integer.parseInt(index[0]) + 1);
voCount.setKssj(obj1.getTimestamp()*1000);//秒转毫秒 chent20200511
if((int) tlsj!=0) {
resultCountList.add(voCount);
}
});
// }
Collections.sort(resultList);//时间戳降序
//去重复
List<TrackYstldResult> removeList= removeDuplicate(resultList);
System.out.println("活动区域停留时间最长去重复:"+JSON.toJSONString(removeList));
//取出停留时间最长的前5条
if (removeList.size() >= 5) {
newList = removeList.subList(0, 5);//不包含第二个参数，所以截取5个
} else {
newList = removeList;
}
System.out.println("停留时间最长前五:"+JSON.toJSONString(newList));
//次数降序
Collections.sort(resultCountList);//次数降序
//去重复
List<TrackYstldResultCountSort> removeCountList= removeDuplicateCount(resultCountList);
System.out.println("活动区域抓取次数最大去重复:"+JSON.toJSONString(removeCountList));
//取出次数最大的前5条
if (removeCountList.size() >= 5) {
newListCountSort = removeCountList.subList(0, 5);//不包含第二个参数，所以截取5个
} else {
newListCountSort = removeCountList;
}
System.out.println("抓取次数最多前五:"+JSON.toJSONString(newListCountSort));
//去重复
// newList= removeDuplicate(newList);
// newListCountSort= removeDuplicateCount(newListCountSort);
//取两个list的交集，
for(int i = 0 ; i <newList.size() ; i ++ ) {
Iterator<TrackYstldResultCountSort> resultIterator = newListCountSort.iterator();
while (resultIterator.hasNext()){
TrackYstldResultCountSort r = resultIterator.next();
if(newList.get(i).getX().equals(r.getX())&&newList.get(i).getY().equals(r.getY())){
newList.get(i).setCount(r.getCount());
newList.get(i).setIsAll("1");
resultIterator.remove();
}
}
}
if(newListCountSort.size()>0){
for(int i=0;i<newListCountSort.size();i++){
TrackYstldResultCountSort entity=newListCountSort.get(i);
TrackYstldResult obj=new TrackYstldResult();
BeanUtils.copyProperties(entity,obj);
newList.add(obj);
}
}
Iterator<TrackYstldResult> resultIterator = newList.iterator();
while (resultIterator.hasNext()){//循环修改newlist里的值
TrackYstldResult obj = resultIterator.next();
obj.setTlsjStr(DataUtil.dateStr(obj.getTlsj()));
}
//把list转为json字符串
String resultStr = JSON.toJSONString(newList);
System.out.println(resultStr);
return MapRestResult.build(200, "轨迹疑似活动区域查询", resultStr);
}
// 车辆碰撞结果查询
public MapRestResult getRegionalsResult(TbStRegionalstaskresult tbStRegionalstaskresult) throws Exception {
List<Map<String, Map<String, String>>> list = new ArrayList<>();
......@@ -1573,4 +1739,164 @@ public class CarServiceImpl implements CarService {
}
return MapRestResult.build(200, "分类信息", resluts);
}
public List<TrackYstldResultCountSort> removeDuplicateCount(List<TrackYstldResultCountSort> resultList){
for ( int i = 0 ; i < resultList.size() - 1 ; i ++ ) {
for ( int j = resultList.size() - 1 ; j > i; j -- ) {
if (resultList.get(j).getX().equals(resultList.get(i).getX())&&resultList.get(j).getY().equals(resultList.get(i).getY())) {
resultList.remove(j);
}
}
}
return resultList;
}
// 车辆时空区域徘徊-车出现次数>3--------------------------------------------------------------------
public MapRestResult OneAreaInfoTrampResultThread(AreaInfo areaInfo) throws Exception {
long start = System.currentTimeMillis();
//卡口编号处理 START------------------------------------------------------------------------------
//code分割
List<CarReceiving> carReceivinglist = new ArrayList<>();
String task_id=KeyUtil.getUUIDKey("RW");
if(areaInfo.getCodes()!=null&&!areaInfo.getCodes().isEmpty()){
String[] code = new String[0];
if( areaInfo.getCodes().contains(",")) {
code = areaInfo.getCodes().split(",");
}else{
code[0]=areaInfo.getCodes();
}
//数据填充
Arrays.stream(code).forEach(p -> {
CarReceiving carReceiving = new CarReceiving();
carReceiving.setObjectValue(p);//卡口编号
carReceiving.setKssj(areaInfo.getStartTime());
carReceiving.setJssj(areaInfo.getEndTime());
carReceiving.setObjectType("02");//02 代表卡口编号
// 处理同时不走任务的时空回溯和时空徘徊
if(areaInfo.getTaskId()!=null&&!areaInfo.getTaskId().isEmpty()){
carReceiving.setTaskId(areaInfo.getTaskId());
}else{
carReceiving.setTaskId(task_id);
}
carReceiving.setRegion(areaInfo.getRegion());
carReceivinglist.add(carReceiving);
});
}
//卡口编号处理 END-------------------------------------------------------------------------------------
//全局公共参数 START-------------------------------------------------------------------------------------
//获取所有卡口的全量数据
List<CarKkInfo> sucesslistall = new ArrayList<>();
//根据ObjectValue去空后的数据
List<CarKkInfo> sucesslistnotnull = new ArrayList<>();
//大于三次的车数据
List<CarKkInfo> paihuaiList = new ArrayList<>();
ExecutorService executorService = Executors.newCachedThreadPool();//按需分配线程池
//全局公共参数 END-------------------------------------------------------------------------------------
//-------------------------------获取卡口数据-----------------------
List<List<CarReceiving>> cpllist = new ArrayList<>();
float number = carReceivinglist.size() / 3;
int flnum = (int) Math.ceil(number);
System.out.println("数据批量值为=========================" + flnum);
cpllist = DataUtil.cpldata(carReceivinglist, flnum);
System.out.println("批量分流=======================================");
CompletableFuture[] cfs3 = cpllist.stream()
.map(carKkInfo -> CompletableFuture.supplyAsync(() ->
//1 获取卡口全量数据
carInfoResults(carKkInfo), executorService)
//----------1、结果----------------------
.handle((t, throwable) -> {
if (throwable != null) {//翻译处理
System.out.println("获取全量数据失败==============" + throwable);
return t;
}
if (t.size() > 0) {
System.out.println("====获取全量数据结果成功==============" + t.size());
t.stream().forEach(m->{
if(!m.getObjectValue().equals("11111111")){
sucesslistall.add(m);
}else{
System.out.println("车牌号:"+m.getObjectValue());
}
});
}
return t;
})
).toArray(CompletableFuture[]::new);
CompletableFuture.allOf(cfs3).join();
System.out.println( "====时间==============" + (System.currentTimeMillis() - start));
System.out.println( "===所有数据量==============" + sucesslistall.size());
//-------------------------------获取卡口数据-----------------------
//如果获取数据为0
if (sucesslistall.size() > 0) {
//sucesslistnotnull=sucesslistall;
//大于三次的车
Map<String,List<CarKkInfo>> map=new HashMap<>();
List<CarReceiving> lists=new ArrayList<>();
List<CarKkInfo> alllists=new ArrayList<>();
List<CarKkInfo> savealllists=new ArrayList<>();
//if(sucesslistnotnull != null && !sucesslistnotnull.isEmpty()){
map=sucesslistall.stream().collect(Collectors.groupingBy(CarKkInfo::getObjectValue));
map.entrySet().forEach(t->{
System.out.println(t.getKey()+"====分组数据==============" +t.getValue().size()+"====数据==============");
//重复次数
if(t.getValue().size()>=3){
CarReceiving carReceiving=new CarReceiving();
carReceiving.setObjectValue(t.getKey());
carReceiving.setLists(t.getValue());
lists.add(carReceiving);
alllists.addAll(t.getValue());
//保存
sucesslistall.stream().forEach(p->{
if(p.getObjectValue().equals(t.getKey())){
savealllists.add(p);
}
});
}
});
//保存
//-------------------------------保存卡口数据-----------------------
//数据保存批量list
List<List<CarKkInfo>> pllist = new ArrayList<>();
//卡口数据保存成功list
List<CarKkInfo> savelist = new ArrayList<>();
float number1 = savealllists.size() / 100;
int flnum1 = (int) Math.ceil(number1);
System.out.println("数据批量值为=========================" + flnum1);
try {
pllist = DataUtil.pldata(savealllists, flnum1);
} catch (Exception e) {
e.printStackTrace();
}
System.out.println("批量分流=======================================");
//2.1保存所有卡口的全量数据----------------------------------
CompletableFuture[] cfs1 = pllist.stream()
.map(carKkInfos -> CompletableFuture.supplyAsync(() ->
//1.进行保存
carInfoSaveResultPz(carKkInfos), executorService)
//----------1、结果---------------------
//map.put("sucesslist",sucesslist);
//map.put("errorlist",errorlist);
//----------1、结果----------------------
.handle((m, throwable) -> {
if (throwable != null) {//保存处理
System.out.println("有" + m.get("errorlist").size() + "条数据保存失败==============" + throwable);
return m;
}
System.out.println("有" + m.get("sucesslist").size() + "条数据保存成功==============");
savelist.addAll(m.get("sucesslist"));
return m;
})
).toArray(CompletableFuture[]::new);
CompletableFuture.allOf(cfs1).join();
//-------------------------------保存卡口数据-----------------------
System.out.println("====分组数据==============" +lists.size());
return MapRestResult.build(lists.size(), task_id, lists);
} else {
return MapRestResult.build(200, "卡口数据为空", "");
}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment