修改厂内导航

src/main/java/com/steerinfo/inPlantNavigation/controller/IPMMSVertexController.java

@@ -2,6 +2,7 @@ package com.steerinfo.inPlantNavigation.controller;
 
 import com.steerinfo.dil.util.BaseRESTfulController;
 import com.steerinfo.framework.controller.RESTfulResult;
+import com.steerinfo.inPlantNavigation.exception.VertexAngEdgeException;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertex;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertexEdge;
 import com.steerinfo.inPlantNavigation.service.IIPMMSVertexEdgeService;
@@ -25,7 +26,7 @@ public class IPMMSVertexController extends BaseRESTfulController {
 
 
     @GetMapping("/getObtainTheOptimalPath")
-    public RESTfulResult getObtainTheOptimalPath(@RequestParam("startPoint") String startPoint,@RequestParam("endPoint")  String endPoint){
+    public RESTfulResult getObtainTheOptimalPath(@RequestParam("startPoint") String startPoint,@RequestParam("endPoint")  String endPoint) throws VertexAngEdgeException {
 
         Map<String, List<IPMMSVertexEdge>> vertexEdgeList= ipmmsVertexEdgeService.initVertexEdge();
         Map<String, IPMMSVertex> vertexList = ipmmsVertexService.initIPMMSVertex();
@@ -33,4 +34,16 @@ public class IPMMSVertexController extends BaseRESTfulController {
         return success(obtainTheOptimalPath);
     }
 
+    @GetMapping("/getObtainTheOptimalPathTest")
+    public RESTfulResult getObtainTheOptimalPathTest(@RequestParam("startPoint") String startPoint,@RequestParam("endPoint")  String endPoint) throws Exception{
+
+        Map<String, List<IPMMSVertexEdge>> vertexEdgeList= ipmmsVertexEdgeService.initVertexEdgeTest();
+        Map<String, IPMMSVertex> vertexList = ipmmsVertexService.initIPMSVertexTest();
+        ArrayList<IPMMSVertex> obtainTheOptimalPath= ipmmsVertexService.getObtainTheOptimalPath(startPoint,endPoint,vertexEdgeList,vertexList);
+        return success(obtainTheOptimalPath);
+    }
+    @GetMapping("/vertexTest")
+    public RESTfulResult vertexTest(){
+      return success(ipmmsVertexService.initIPMSVertexTest().values());
+    }
 }

src/main/java/com/steerinfo/inPlantNavigation/exception/VertexAngEdgeException.java

@@ -0,0 +1,12 @@
+package com.steerinfo.inPlantNavigation.exception;
+
+public class VertexAngEdgeException extends   Exception{
+    private String message;
+    public VertexAngEdgeException(){
+        super();
+    }
+    public VertexAngEdgeException(String message){
+        super(message);
+        this.message=message;
+    }
+}

src/main/java/com/steerinfo/inPlantNavigation/service/IIPMMSVertexEdgeService.java

@@ -8,4 +8,6 @@ import java.util.Map;
 
 public interface IIPMMSVertexEdgeService {
     Map<String, List<IPMMSVertexEdge>> initVertexEdge();
+
+    Map<String, List<IPMMSVertexEdge>> initVertexEdgeTest();
 }

src/main/java/com/steerinfo/inPlantNavigation/service/IIPMMSVertexService.java

@@ -1,5 +1,6 @@
 package com.steerinfo.inPlantNavigation.service;
 
+import com.steerinfo.inPlantNavigation.exception.VertexAngEdgeException;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertex;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertexEdge;
 
@@ -11,5 +12,7 @@ public interface IIPMMSVertexService {
     
     public Map<String, IPMMSVertex> initIPMMSVertex();
 
-    ArrayList<IPMMSVertex> getObtainTheOptimalPath(String startpoint,String endPoint,Map<String, List<IPMMSVertexEdge>> vertexEdgeList, Map<String, IPMMSVertex> vertexList);
+    Map<String, IPMMSVertex> initIPMSVertexTest();
+
+    ArrayList<IPMMSVertex> getObtainTheOptimalPath(String startpoint,String endPoint,Map<String, List<IPMMSVertexEdge>> vertexEdgeList, Map<String, IPMMSVertex> vertexList) throws VertexAngEdgeException;
 }

src/main/java/com/steerinfo/inPlantNavigation/service/impl/IPMMSVertexEdgeServiceImpl.java

@@ -88,4 +88,324 @@ public class IPMMSVertexEdgeServiceImpl implements IIPMMSVertexEdgeService {
 
         return vertexEdgeList;
     }
+
+    @Override
+    public Map<String, List<IPMMSVertexEdge>> initVertexEdgeTest() {
+        Map<String, List<IPMMSVertexEdge>> vertexEdgeList=new HashMap<>();
+
+        List<IPMMSVertexEdge> arrayList0=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge0=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge0.setVertexEdgeID(new BigDecimal(0));
+        ipmmsVertexList0Edge0.setWeigh(100);
+        ipmmsVertexList0Edge0.setOutVertexID(new BigDecimal(0));
+        ipmmsVertexList0Edge0.setInVertexID(new BigDecimal(1));
+        arrayList0.add(ipmmsVertexList0Edge0);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge1=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge1.setVertexEdgeID(new BigDecimal(1));
+        ipmmsVertexList0Edge1.setWeigh(150);
+        ipmmsVertexList0Edge1.setOutVertexID(new BigDecimal(0));
+        ipmmsVertexList0Edge1.setInVertexID(new BigDecimal(13));
+        arrayList0.add(ipmmsVertexList0Edge1);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge2=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge2.setVertexEdgeID(new BigDecimal(2));
+        ipmmsVertexList0Edge2.setWeigh(120);
+        ipmmsVertexList0Edge2.setOutVertexID(new BigDecimal(0));
+        ipmmsVertexList0Edge2.setInVertexID(new BigDecimal(14));
+        arrayList0.add(ipmmsVertexList0Edge2);
+
+        vertexEdgeList.put("0",arrayList0);
+
+        List<IPMMSVertexEdge> arrayList1=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge3=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge3.setVertexEdgeID(new BigDecimal(3));
+        ipmmsVertexList0Edge3.setWeigh(100);
+        ipmmsVertexList0Edge3.setOutVertexID(new BigDecimal(1));
+        ipmmsVertexList0Edge3.setInVertexID(new BigDecimal(0));
+        arrayList1.add(ipmmsVertexList0Edge3);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge4=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge4.setVertexEdgeID(new BigDecimal(4));
+        ipmmsVertexList0Edge4.setWeigh(150);
+        ipmmsVertexList0Edge4.setOutVertexID(new BigDecimal(1));
+        ipmmsVertexList0Edge4.setInVertexID(new BigDecimal(13));
+        arrayList1.add(ipmmsVertexList0Edge4);
+
+        vertexEdgeList.put("1",arrayList1);
+
+        List<IPMMSVertexEdge> arrayList2=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge5=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge5.setVertexEdgeID(new BigDecimal(5));
+        ipmmsVertexList0Edge5.setWeigh(600);
+        ipmmsVertexList0Edge5.setOutVertexID(new BigDecimal(2));
+        ipmmsVertexList0Edge5.setInVertexID(new BigDecimal(17));
+        arrayList2.add(ipmmsVertexList0Edge5);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge6=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge6.setVertexEdgeID(new BigDecimal(6));
+        ipmmsVertexList0Edge6.setWeigh(100);
+        ipmmsVertexList0Edge6.setOutVertexID(new BigDecimal(2));
+        ipmmsVertexList0Edge6.setInVertexID(new BigDecimal(15));
+        arrayList2.add(ipmmsVertexList0Edge6);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge7=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge7.setVertexEdgeID(new BigDecimal(7));
+        ipmmsVertexList0Edge7.setWeigh(400);
+        ipmmsVertexList0Edge7.setOutVertexID(new BigDecimal(2));
+        ipmmsVertexList0Edge7.setInVertexID(new BigDecimal(3));
+        arrayList2.add(ipmmsVertexList0Edge7);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge8=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge8.setVertexEdgeID(new BigDecimal(8));
+        ipmmsVertexList0Edge8.setWeigh(300);
+        ipmmsVertexList0Edge8.setOutVertexID(new BigDecimal(2));
+        ipmmsVertexList0Edge8.setInVertexID(new BigDecimal(16));
+        arrayList2.add(ipmmsVertexList0Edge8);
+
+        vertexEdgeList.put("2",arrayList2);
+
+        ArrayList<IPMMSVertexEdge> arrayList3=new ArrayList<>();
+        IPMMSVertexEdge ipmmsVertexList0Edge9=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge9.setVertexEdgeID(new BigDecimal(9));
+        ipmmsVertexList0Edge9.setWeigh(400);
+        ipmmsVertexList0Edge9.setOutVertexID(new BigDecimal(3));
+        ipmmsVertexList0Edge9.setInVertexID(new BigDecimal(2));
+        arrayList3.add(ipmmsVertexList0Edge9);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge10=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge10.setVertexEdgeID(new BigDecimal(10));
+        ipmmsVertexList0Edge10.setWeigh(500);
+        ipmmsVertexList0Edge10.setOutVertexID(new BigDecimal(3));
+        ipmmsVertexList0Edge10.setInVertexID(new BigDecimal(15));
+        arrayList3.add(ipmmsVertexList0Edge10);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge11=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge11.setVertexEdgeID(new BigDecimal(11));
+        ipmmsVertexList0Edge11.setWeigh(450);
+        ipmmsVertexList0Edge11.setOutVertexID(new BigDecimal(3));
+        ipmmsVertexList0Edge11.setInVertexID(new BigDecimal(17));
+        arrayList3.add(ipmmsVertexList0Edge11);
+
+        vertexEdgeList.put("3",arrayList3);
+
+
+        ArrayList<IPMMSVertexEdge> arrayList10=new ArrayList<>();
+        IPMMSVertexEdge ipmmsVertexList0Edge12=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge12.setVertexEdgeID(new BigDecimal(12));
+        ipmmsVertexList0Edge12.setWeigh(30);
+        ipmmsVertexList0Edge12.setOutVertexID(new BigDecimal(10));
+        ipmmsVertexList0Edge12.setInVertexID(new BigDecimal(11));
+        arrayList10.add(ipmmsVertexList0Edge12);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge13=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge13.setVertexEdgeID(new BigDecimal(13));
+        ipmmsVertexList0Edge13.setWeigh(300);
+        ipmmsVertexList0Edge13.setOutVertexID(new BigDecimal(10));
+        ipmmsVertexList0Edge13.setInVertexID(new BigDecimal(14));
+        arrayList10.add(ipmmsVertexList0Edge13);
+
+        vertexEdgeList.put("10",arrayList10);
+
+        ArrayList<IPMMSVertexEdge> arrayList11=new ArrayList<>();
+        IPMMSVertexEdge ipmmsVertexList0Edge14=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge14.setVertexEdgeID(new BigDecimal(14));
+        ipmmsVertexList0Edge14.setWeigh(250);
+        ipmmsVertexList0Edge14.setOutVertexID(new BigDecimal(11));
+        ipmmsVertexList0Edge14.setInVertexID(new BigDecimal(12));
+        arrayList11.add(ipmmsVertexList0Edge14);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge15=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge15.setVertexEdgeID(new BigDecimal(15));
+        ipmmsVertexList0Edge15.setWeigh(30);
+        ipmmsVertexList0Edge15.setOutVertexID(new BigDecimal(11));
+        ipmmsVertexList0Edge15.setInVertexID(new BigDecimal(10));
+        arrayList11.add(ipmmsVertexList0Edge15);
+
+        vertexEdgeList.put("11",arrayList11);
+
+        ArrayList<IPMMSVertexEdge> arrayList12=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge16=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge16.setVertexEdgeID(new BigDecimal(16));
+        ipmmsVertexList0Edge16.setWeigh(250);
+        ipmmsVertexList0Edge16.setOutVertexID(new BigDecimal(12));
+        ipmmsVertexList0Edge16.setInVertexID(new BigDecimal(11));
+        arrayList12.add(ipmmsVertexList0Edge16);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge17=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge17.setVertexEdgeID(new BigDecimal(17));
+        ipmmsVertexList0Edge17.setWeigh(300);
+        ipmmsVertexList0Edge17.setOutVertexID(new BigDecimal(12));
+        ipmmsVertexList0Edge17.setInVertexID(new BigDecimal(16));
+        arrayList12.add(ipmmsVertexList0Edge17);
+
+        vertexEdgeList.put("12",arrayList12);
+
+        ArrayList<IPMMSVertexEdge> arrayList13=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge18=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge18.setVertexEdgeID(new BigDecimal(18));
+        ipmmsVertexList0Edge18.setWeigh(50);
+        ipmmsVertexList0Edge18.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge18.setInVertexID(new BigDecimal(16));
+        arrayList13.add(ipmmsVertexList0Edge18);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge19=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge19.setVertexEdgeID(new BigDecimal(19));
+        ipmmsVertexList0Edge19.setWeigh(50);
+        ipmmsVertexList0Edge19.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge19.setInVertexID(new BigDecimal(14));
+        arrayList13.add(ipmmsVertexList0Edge19);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge20=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge20.setVertexEdgeID(new BigDecimal(20));
+        ipmmsVertexList0Edge20.setWeigh(1);
+        ipmmsVertexList0Edge20.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge20.setInVertexID(new BigDecimal(0));
+        arrayList13.add(ipmmsVertexList0Edge20);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge21=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge21.setVertexEdgeID(new BigDecimal(21));
+        ipmmsVertexList0Edge21.setWeigh(150);
+        ipmmsVertexList0Edge21.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge21.setInVertexID(new BigDecimal(1));
+        arrayList13.add(ipmmsVertexList0Edge21);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge22=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge22.setVertexEdgeID(new BigDecimal(22));
+        ipmmsVertexList0Edge22.setWeigh(50);
+        ipmmsVertexList0Edge22.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge22.setInVertexID(new BigDecimal(14));
+        arrayList13.add(ipmmsVertexList0Edge22);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge23=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge23.setVertexEdgeID(new BigDecimal(23));
+        ipmmsVertexList0Edge23.setWeigh(50);
+        ipmmsVertexList0Edge23.setOutVertexID(new BigDecimal(13));
+        ipmmsVertexList0Edge23.setInVertexID(new BigDecimal(16));
+        arrayList13.add(ipmmsVertexList0Edge23);
+
+        vertexEdgeList.put("13",arrayList13);
+
+
+        ArrayList<IPMMSVertexEdge> arrayList15=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge24=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge24.setVertexEdgeID(new BigDecimal(24));
+        ipmmsVertexList0Edge24.setWeigh(100);
+        ipmmsVertexList0Edge24.setOutVertexID(new BigDecimal(15));
+        ipmmsVertexList0Edge24.setInVertexID(new BigDecimal(2));
+        arrayList15.add(ipmmsVertexList0Edge24);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge25=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge25.setVertexEdgeID(new BigDecimal(25));
+        ipmmsVertexList0Edge25.setWeigh(500);
+        ipmmsVertexList0Edge25.setOutVertexID(new BigDecimal(15));
+        ipmmsVertexList0Edge25.setInVertexID(new BigDecimal(3));
+        arrayList15.add(ipmmsVertexList0Edge25);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge26=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge26.setVertexEdgeID(new BigDecimal(26));
+        ipmmsVertexList0Edge26.setWeigh(200);
+        ipmmsVertexList0Edge26.setOutVertexID(new BigDecimal(15));
+        ipmmsVertexList0Edge26.setInVertexID(new BigDecimal(16));
+        arrayList15.add(ipmmsVertexList0Edge26);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge27=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge27.setVertexEdgeID(new BigDecimal(27));
+        ipmmsVertexList0Edge27.setWeigh(900);
+        ipmmsVertexList0Edge27.setOutVertexID(new BigDecimal(15));
+        ipmmsVertexList0Edge27.setInVertexID(new BigDecimal(17));
+        arrayList15.add(ipmmsVertexList0Edge27);
+
+        vertexEdgeList.put("15",arrayList15);
+
+        ArrayList<IPMMSVertexEdge> arrayList16=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge28=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge28.setVertexEdgeID(new BigDecimal(28));
+        ipmmsVertexList0Edge28.setWeigh(300);
+        ipmmsVertexList0Edge28.setOutVertexID(new BigDecimal(16));
+        ipmmsVertexList0Edge28.setInVertexID(new BigDecimal(2));
+        arrayList16.add(ipmmsVertexList0Edge28);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge29=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge29.setVertexEdgeID(new BigDecimal(29));
+        ipmmsVertexList0Edge29.setWeigh(50);
+        ipmmsVertexList0Edge29.setOutVertexID(new BigDecimal(16));
+        ipmmsVertexList0Edge29.setInVertexID(new BigDecimal(13));
+        arrayList16.add(ipmmsVertexList0Edge29);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge30=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge30.setVertexEdgeID(new BigDecimal(30));
+        ipmmsVertexList0Edge30.setWeigh(200);
+        ipmmsVertexList0Edge30.setOutVertexID(new BigDecimal(16));
+        ipmmsVertexList0Edge30.setInVertexID(new BigDecimal(15));
+        arrayList16.add(ipmmsVertexList0Edge30);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge31=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge31.setVertexEdgeID(new BigDecimal(31));
+        ipmmsVertexList0Edge31.setWeigh(300);
+        ipmmsVertexList0Edge31.setOutVertexID(new BigDecimal(16));
+        ipmmsVertexList0Edge31.setInVertexID(new BigDecimal(12));
+        arrayList16.add(ipmmsVertexList0Edge31);
+
+        vertexEdgeList.put("16",arrayList16);
+
+        ArrayList<IPMMSVertexEdge> arrayList17=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge32=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge32.setVertexEdgeID(new BigDecimal(32));
+        ipmmsVertexList0Edge32.setWeigh(600);
+        ipmmsVertexList0Edge32.setOutVertexID(new BigDecimal(17));
+        ipmmsVertexList0Edge32.setInVertexID(new BigDecimal(2));
+        arrayList17.add(ipmmsVertexList0Edge32);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge33=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge33.setVertexEdgeID(new BigDecimal(33));
+        ipmmsVertexList0Edge33.setWeigh(450);
+        ipmmsVertexList0Edge33.setOutVertexID(new BigDecimal(17));
+        ipmmsVertexList0Edge33.setInVertexID(new BigDecimal(3));
+        arrayList17.add(ipmmsVertexList0Edge33);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge34=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge34.setVertexEdgeID(new BigDecimal(34));
+        ipmmsVertexList0Edge34.setWeigh(900);
+        ipmmsVertexList0Edge34.setOutVertexID(new BigDecimal(17));
+        ipmmsVertexList0Edge34.setInVertexID(new BigDecimal(15));
+        arrayList17.add(ipmmsVertexList0Edge34);
+
+        vertexEdgeList.put("17",arrayList17);
+
+
+        ArrayList<IPMMSVertexEdge> arrayList14=new ArrayList<>();
+
+        IPMMSVertexEdge ipmmsVertexList0Edge35=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge35.setVertexEdgeID(new BigDecimal(35));
+        ipmmsVertexList0Edge35.setWeigh(50);
+        ipmmsVertexList0Edge35.setOutVertexID(new BigDecimal(14));
+        ipmmsVertexList0Edge35.setInVertexID(new BigDecimal(13));
+        arrayList14.add(ipmmsVertexList0Edge35);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge36=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge36.setVertexEdgeID(new BigDecimal(36));
+        ipmmsVertexList0Edge36.setWeigh(120);
+        ipmmsVertexList0Edge36.setOutVertexID(new BigDecimal(14));
+        ipmmsVertexList0Edge36.setInVertexID(new BigDecimal(0));
+        arrayList14.add(ipmmsVertexList0Edge36);
+
+        IPMMSVertexEdge ipmmsVertexList0Edge37=new IPMMSVertexEdge();
+        ipmmsVertexList0Edge37.setVertexEdgeID(new BigDecimal(37));
+        ipmmsVertexList0Edge37.setWeigh(300);
+        ipmmsVertexList0Edge37.setOutVertexID(new BigDecimal(14));
+        ipmmsVertexList0Edge37.setInVertexID(new BigDecimal(10));
+        arrayList14.add(ipmmsVertexList0Edge37);
+
+        vertexEdgeList.put("14",arrayList14);
+        return vertexEdgeList;
+    }
 }

src/main/java/com/steerinfo/inPlantNavigation/service/impl/IPMMSVertexServiceImpl.java

@@ -1,5 +1,6 @@
 package com.steerinfo.inPlantNavigation.service.impl;
 
+import com.steerinfo.inPlantNavigation.exception.VertexAngEdgeException;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertex;
 import com.steerinfo.inPlantNavigation.model.IPMMSVertexEdge;
 import com.steerinfo.inPlantNavigation.service.IIPMMSVertexService;
@@ -15,63 +16,99 @@ public class IPMMSVertexServiceImpl implements IIPMMSVertexService {
 
 
     @Override
-    public ArrayList<IPMMSVertex> getObtainTheOptimalPath(String startpoint,String endPoint,Map<String, List<IPMMSVertexEdge>> vertexEdgeList, Map<String, IPMMSVertex> vertexList) {
+    public ArrayList<IPMMSVertex> getObtainTheOptimalPath(String startpoint,String endPoint,Map<String, List<IPMMSVertexEdge>> vertexEdgeList, Map<String, IPMMSVertex> vertexList) throws VertexAngEdgeException {
         //初始化数据
-        int[] startPoin=new int[]{0,-1};
+        String[] startPoin=new String[]{"0","-1"};
         //创建S战队（放入的是已经遍历过边的顶点）
         List<String> obtainTheOptimalPath=new ArrayList();
         //obtainTheOptimalPath.add(statpoint);
         //创建 dist[]  (起点到集合点中的最短路径) key：指向的点 new int[]{0,-1}; {权重、中间点}
-        HashMap<String,int[]> currentBestDinstance=new HashMap<>();
+        HashMap<String,String[]> currentBestDinstance=new HashMap<>();
         currentBestDinstance.put(startpoint,startPoin);
         while (obtainTheOptimalPath.size()!=vertexList.size()){
             // dist[]最小值
             String stringMinimumValue = getStringMinimumValue(currentBestDinstance, obtainTheOptimalPath);
-            //加入S战队
 
+            //加入S战队
             obtainTheOptimalPath.add(stringMinimumValue);
 
+            //判断是否有进入的边
+            if (island(currentBestDinstance,stringMinimumValue,vertexEdgeList)){
+                continue;
+            }
+            if (stringMinimumValue.equals("0")||stringMinimumValue.equals("13")){
+                System.out.println();
+            }
+
             //借东风
             List<IPMMSVertexEdge> ipmmsVertexEdges = vertexEdgeList.get(stringMinimumValue);
-                //遍历所有的边
+
+            //判断是否存在边
+            if (ipmmsVertexEdges==null){
+                continue;
+            }
+
+            //遍历所有的边
             for(IPMMSVertexEdge ipmmsVertexEdge :ipmmsVertexEdges){
                 //箭头出发点
                 BigDecimal outVertexID = ipmmsVertexEdge.getOutVertexID();
                 //到该点的最短路径
-                int[] starBestPath = currentBestDinstance.get(outVertexID.toString());
+                String[] starBestPath = currentBestDinstance.get(outVertexID.toString());
                 //被指向的顶点
                 BigDecimal inVertexID= ipmmsVertexEdge.getInVertexID();
-                int[] historyBestPaht = currentBestDinstance.get(inVertexID.toString());
+                String[] historyBestPaht = currentBestDinstance.get(inVertexID.toString());
+                if (starBestPath==null){
+                    throw new VertexAngEdgeException("这条边不存在！"+outVertexID.toString()+"->"+inVertexID.toString());
+                }else  if (!outVertexID.toString().equals(stringMinimumValue)){
+                    throw new VertexAngEdgeException(outVertexID+"->"+inVertexID+"不是顶点"+stringMinimumValue+"的边！");
+                }
                 //判断是否存在其路线到这个点的距离。如果不存在则将这条线路作为起点到该点最短路径、如果本条路线是最短路径需要替换最短路径
-                if(historyBestPaht==null||(starBestPath[0]+ipmmsVertexEdge.getWeigh())<historyBestPaht[0]){
-                    int distance=starBestPath[0]+ipmmsVertexEdge.getWeigh();
-                    int outVertex=outVertexID.intValue();
-                    int[] bestPath=new int[]{distance,outVertex};
+                if(historyBestPaht==null){
+                    String distance=starBestPath[0]+ipmmsVertexEdge.getWeigh();
+                    String outVertex=outVertexID.toString();
+                    String[] bestPath=new String[]{distance,outVertex};
                     currentBestDinstance.put(inVertexID.toString(),bestPath);
                 }
+//                else if ((starBestPath[0]+ipmmsVertexEdge.getWeigh())<historyBestPaht[0]){
+//                    //更新和此顶点有关的数据
+//                }
             }
         }
 
 
         return startPointToEndPointPaht(endPoint,currentBestDinstance,vertexList);
     }
+    //判断是否有进入这个顶点的边，如果没有这个顶点就是一个孤岛
+    public Boolean island(HashMap<String,String[]> currentBestDinstance,String stringMinimumValue,Map<String, List<IPMMSVertexEdge>> vertexEdgeList){
+        if(!currentBestDinstance.containsKey(stringMinimumValue)){
+            Collection<List<IPMMSVertexEdge>> values = vertexEdgeList.values();
+            for (List<IPMMSVertexEdge> vertexEdges : values){
+                for (IPMMSVertexEdge vertexEdge:vertexEdges){
+                    if (vertexEdge.getInVertexID().equals(stringMinimumValue))
+                        return false;
+                }
+            }
+            return  true;
+        }
+        return false;
+    }
     //通过所有最优解集合选择我们要的
-    public ArrayList<IPMMSVertex> startPointToEndPointPaht(String point,HashMap<String,int[]> currentBestDinstance,Map<String, IPMMSVertex> vertexList){
+    public ArrayList<IPMMSVertex> startPointToEndPointPaht(String point,HashMap<String,String[]> currentBestDinstance,Map<String, IPMMSVertex> vertexList){
         ArrayList<IPMMSVertex> obtainOptimalPath=new ArrayList();
-        int beforeDistance=100;
+        String beforeDistance="100";
         do {
-            int[] ints = currentBestDinstance.get(point);
+            String[] ints = currentBestDinstance.get(point);
             beforeDistance=ints[1];
             obtainOptimalPath.add(vertexList.get(point));
             point=String.valueOf(ints[1]);
         }
-        while (beforeDistance!=-1);
+        while (beforeDistance.equals("-1"));
         return obtainOptimalPath;
     }
 
-    public String getStringMinimumValue(HashMap<String,int[]> currentBestDinstance,List<String> obtainTheOptimalPath){
+    public String getStringMinimumValue(HashMap<String,String[]> currentBestDinstance,List<String> obtainTheOptimalPath){
 
-        HashMap<String,int[]> bestDinstance = (HashMap<String, int[]>) SerializationUtils.clone(currentBestDinstance);
+        HashMap<String,String[]> bestDinstance = (HashMap<String, String[]>) SerializationUtils.clone(currentBestDinstance);
 
         for (String item:obtainTheOptimalPath){
             if (bestDinstance.containsKey(item)){
@@ -82,15 +119,19 @@ public class IPMMSVertexServiceImpl implements IIPMMSVertexService {
         String vertex="";
         int minimumValue=100;
         for (String key :keys){
-            int[] value = currentBestDinstance.get(key);
-            if (minimumValue>value[1]){
-                minimumValue=value[1];
-                vertex=key;
-            }
+            String[] value = currentBestDinstance.get(key);
+//            if (minimumValue>value[1]){
+//                minimumValue=value[1];
+//                vertex=key;
+//            }
         }
         return vertex;
     }
 
+//    public BigDecimal getStrsValues(String,){
+//
+//    }
+
     public Map<String,IPMMSVertex> initIPMMSVertex(){
 
         Map<String,IPMMSVertex> IPMMSVertexList=new HashMap<>();
@@ -146,4 +187,136 @@ public class IPMMSVertexServiceImpl implements IIPMMSVertexService {
 //        IPMMSVertexList.put("4",ipmmsVertex5);
         return IPMMSVertexList;
     }
+
+    @Override
+    public Map<String,IPMMSVertex> initIPMSVertexTest(){
+        Map<String,IPMMSVertex> IPMMSVertexList=new HashMap<>();
+
+        IPMMSVertex ipmmsVertex0=new IPMMSVertex();
+        ipmmsVertex0.setVertexID(new BigDecimal(0));
+        ipmmsVertex0.setAddressName("1号汽车衡");
+        ipmmsVertex0.setLongitude(new BigDecimal(107.466049));
+        ipmmsVertex0.setLatitude(new BigDecimal(31.190349));
+        IPMMSVertexList.put("0",ipmmsVertex0);
+
+        IPMMSVertex ipmmsVertex1=new IPMMSVertex();
+        ipmmsVertex1.setVertexID(new BigDecimal(1));
+        ipmmsVertex1.setAddressName("东门");
+        ipmmsVertex1.setLongitude(new BigDecimal("107.467562"));
+        ipmmsVertex1.setLatitude(new BigDecimal("31.190679"));
+        IPMMSVertexList.put("1",ipmmsVertex1);
+
+        IPMMSVertex ipmmsVertex2=new IPMMSVertex();
+        ipmmsVertex2.setVertexID(new BigDecimal(2));
+        ipmmsVertex2.setAddressName("6号汽车衡");
+        ipmmsVertex2.setLongitude(new BigDecimal("107.462131"));
+        ipmmsVertex2.setLatitude(new BigDecimal("31.189882"));
+        IPMMSVertexList.put("2",ipmmsVertex2);
+
+        IPMMSVertex ipmmsVertex3=new IPMMSVertex();
+        ipmmsVertex3.setVertexID(new BigDecimal(3));
+        ipmmsVertex3.setAddressName("7号汽车衡");
+        ipmmsVertex3.setLongitude(new BigDecimal("107.45816"));
+        ipmmsVertex3.setLatitude(new BigDecimal("31.187067"));
+        IPMMSVertexList.put("3",ipmmsVertex3);
+
+        IPMMSVertex ipmmsVertex4=new IPMMSVertex();
+        ipmmsVertex4.setVertexID(new BigDecimal(4));
+        ipmmsVertex4.setAddressName("月亮湾门");
+        ipmmsVertex4.setLongitude(new BigDecimal("107.453282"));
+        ipmmsVertex4.setLatitude(new BigDecimal("31.191292"));
+        IPMMSVertexList.put("4",ipmmsVertex4);
+
+        IPMMSVertex ipmmsVertex5=new IPMMSVertex();
+        ipmmsVertex5.setVertexID(new BigDecimal(5));
+        ipmmsVertex5.setAddressName("11号和12号汽车衡");
+        ipmmsVertex5.setLongitude(new BigDecimal("107.453421"));
+        ipmmsVertex5.setLatitude(new BigDecimal("31.191476"));
+        IPMMSVertexList.put("5",ipmmsVertex5);
+
+        IPMMSVertex ipmmsVertex6=new IPMMSVertex();
+        ipmmsVertex6.setVertexID(new BigDecimal(6));
+        ipmmsVertex6.setAddressName("西门");
+        ipmmsVertex6.setLongitude(new BigDecimal("107.452733"));
+        ipmmsVertex6.setLatitude(new BigDecimal("31.188635"));
+        IPMMSVertexList.put("6",ipmmsVertex6);
+
+       /* IPMMSVertex ipmmsVertex7=new IPMMSVertex();
+        ipmmsVertex7.setVertexID(new BigDecimal(7));
+        ipmmsVertex7.setAddressName("泰昕门");
+        ipmmsVertex7.setLongitude(new BigDecimal("107.450807"));
+        ipmmsVertex7.setLatitude(new BigDecimal("31.183661"));
+        IPMMSVertexList.put("7",ipmmsVertex7);*/
+
+       /* IPMMSVertex ipmmsVertex8=new IPMMSVertex();
+        ipmmsVertex8.setVertexID(new BigDecimal(8));
+        ipmmsVertex8.setAddressName("9号汽车衡");
+        ipmmsVertex8.setLongitude(new BigDecimal("107.453046"));
+        ipmmsVertex8.setLatitude(new BigDecimal("31.185408"));
+        IPMMSVertexList.put("8",ipmmsVertex8);*/
+
+        IPMMSVertex ipmmsVertex9=new IPMMSVertex();
+        ipmmsVertex9.setVertexID(new BigDecimal(9));
+        ipmmsVertex9.setAddressName("4号汽车衡");
+        ipmmsVertex9.setLongitude(new BigDecimal("107.469043"));
+        ipmmsVertex9.setLatitude(new BigDecimal("31.186859"));
+        IPMMSVertexList.put("9",ipmmsVertex9);
+
+        IPMMSVertex ipmmsVertex10=new IPMMSVertex();
+        ipmmsVertex10.setVertexID(new BigDecimal(10));
+        ipmmsVertex10.setAddressName("桥东门");
+        ipmmsVertex10.setLongitude(new BigDecimal("107.469225"));
+        ipmmsVertex10.setLatitude(new BigDecimal("31.187363"));
+        IPMMSVertexList.put("10",ipmmsVertex10);
+
+        IPMMSVertex ipmmsVertex11=new IPMMSVertex();
+        ipmmsVertex11.setVertexID(new BigDecimal(11));
+        ipmmsVertex11.setAddressName("桥西门");
+        ipmmsVertex11.setLongitude(new BigDecimal("107.469209"));
+        ipmmsVertex11.setLatitude(new BigDecimal("31.187088"));
+        IPMMSVertexList.put("11",ipmmsVertex11);
+
+        IPMMSVertex ipmmsVertex12=new IPMMSVertex();
+        ipmmsVertex12.setVertexID(new BigDecimal(12));
+        ipmmsVertex12.setAddressName("3号汽车衡");
+        ipmmsVertex12.setLongitude(new BigDecimal("107.466479"));
+        ipmmsVertex12.setLatitude(new BigDecimal("31.186248"));
+        IPMMSVertexList.put("12",ipmmsVertex12);
+
+        IPMMSVertex ipmmsVertex13=new IPMMSVertex();
+        ipmmsVertex13.setVertexID(new BigDecimal(13));
+        ipmmsVertex13.setAddressName("2号汽车衡");
+        ipmmsVertex13.setLongitude(new BigDecimal("107.467274"));
+        ipmmsVertex13.setLatitude(new BigDecimal("31.189362"));
+        IPMMSVertexList.put("13",ipmmsVertex13);
+
+        IPMMSVertex ipmmsVertex14=new IPMMSVertex();
+        ipmmsVertex14.setVertexID(new BigDecimal(14));
+        ipmmsVertex14.setAddressName("小东门");
+        ipmmsVertex14.setLongitude(new BigDecimal("107.467983"));
+        ipmmsVertex14.setLatitude(new BigDecimal("31.189399"));
+        IPMMSVertexList.put("14",ipmmsVertex14);
+
+        IPMMSVertex ipmmsVertex15=new IPMMSVertex();
+        ipmmsVertex15.setVertexID(new BigDecimal(15));
+        ipmmsVertex15.setAddressName("5号汽车衡");
+        ipmmsVertex15.setLongitude(new BigDecimal("107.463176"));
+        ipmmsVertex15.setLatitude(new BigDecimal("31.189472"));
+        IPMMSVertexList.put("15",ipmmsVertex15);
+
+        IPMMSVertex ipmmsVertex16=new IPMMSVertex();
+        ipmmsVertex16.setVertexID(new BigDecimal(16));
+        ipmmsVertex16.setAddressName("10号汽车衡");
+        ipmmsVertex16.setLongitude(new BigDecimal("107.466647"));
+        ipmmsVertex16.setLatitude(new BigDecimal("31.189293"));
+        IPMMSVertexList.put("16",ipmmsVertex16);
+
+        IPMMSVertex ipmmsVertex17=new IPMMSVertex();
+        ipmmsVertex17.setVertexID(new BigDecimal(17));
+        ipmmsVertex17.setAddressName("8号汽车衡");
+        ipmmsVertex17.setLongitude(new BigDecimal("107.454598"));
+        ipmmsVertex17.setLatitude(new BigDecimal("31.188869"));
+        IPMMSVertexList.put("17",ipmmsVertex16);
+        return IPMMSVertexList;
+    }
 }

src/main/java/com/steerinfo/route/service/impl/RouteServiceImpl.java

@@ -851,18 +851,15 @@ public class RouteServiceImpl implements RouteService {
     public CurrentLocationResult getCurrentLocation(String capcityNumber) throws Exception {
         String json = zhongJiaoXingLu.vLastLocationV3(capcityNumber);
         CurrentLocationResult currentLocationResult = (CurrentLocationResult) DataConversionTool.jsonToBean(json, CurrentLocationResult.class);
-<<<<<<< HEAD
-        if (currentLocationResult.equals(1006)){
+
+        if (currentLocationResult.equals(1006)) {
             return null;
-=======
+        }
         if(currentLocationResult.getResult().getLat()!=null&&currentLocationResult.getResult().getLon()!=null){
             Double[] lngLon = LngLonUtil.gps84_To_Gcj02((Double.valueOf(currentLocationResult.getResult().getLat()) / 600000), (Double.valueOf(currentLocationResult.getResult().getLon()) / 600000));
             currentLocationResult.getResult().setLat(lngLon[0].toString());
             currentLocationResult.getResult().setLon(lngLon[1].toString());
->>>>>>> 8f52edecbb90f4859e5e95585c3a90a1a6731cf2
         }
         return currentLocationResult;
     }
-
-
 }