#

lsh

2024-07-12 ab43a814da847a9e533732191b4ed54c01b95d09

 src/main/java/com/zy/asrs/utils/RouteUtils.java

@@ -4,19 +4,40 @@
import java.util.List;
import static java.util.stream.Collectors.toList;
import com.zy.core.enums.RouteCollectCountType;
import springfox.documentation.spring.web.json.Json;

/**
 * Created by Monkey D. Luffy on 2023/7/18
 */
public class RouteUtils {

    public static final List<Integer> MERGE_STA_NO_One = new ArrayList<Integer>() {{
        add(116);add(117);
    }};

    public static final List<Integer> MERGE_STA_NO_TWO = new ArrayList<Integer>() {{
        add(113);add(123);add(114);add(1142);
    }};

    public static final List<Integer> MERGE_STA_NO_THREE = new ArrayList<Integer>() {{
        add(107);add(118);add(108);add(119);
    }};

    public static final List<Integer> MERGE_STA_NO_FOUR = new ArrayList<Integer>() {{
        add(110);add(120);add(111);add(121);
    }};

    public static final List<Integer> MERGE_STA_NO_FIVE = new ArrayList<Integer>() {{
        add(113);add(123);add(114);add(1142);
    }};

//    正序
    public static final List<Integer> TRACK_POSITION_POSITIVE_SEQUENCE = new ArrayList<Integer>() {{
        add(101);add(102);add(104);add(105);add(107);add(118);add(108);add(119);add(110);add(120);add(111);add(121);add(113);add(114);add(116);add(117);
        add(101);add(102);add(104);add(122);add(105);add(107);add(118);add(108);add(119);add(110);add(120);add(111);add(121);add(113);add(123);add(114);add(1142);add(116);add(117);
    }};
//    反序
    public static final List<Integer> TRACK_POSITION_REVERSE_SEQUENCE = new ArrayList<Integer>() {{
        add(117);add(116);add(114);add(113);add(121);add(111);add(120);add(110);add(119);add(108);add(118);add(107);add(105);add(104);add(102);add(101);
        add(117);add(116);add(1142);add(114);add(123);add(113);add(121);add(111);add(120);add(110);add(119);add(108);add(118);add(107);add(105);add(122);add(104);add(102);add(101);
    }};

    public static String zerofill(String msg, Integer count){
@@ -32,6 +53,30 @@
            return msgBuilder.toString();
        }
    }
    /*
     * 获取干涉最远站点
     * */
    public static Integer RouteIndexFarMas(int rgvNo,Integer staNo){
        List<Integer> staFall = new ArrayList<>();
        if (MERGE_STA_NO_One.contains(staNo)){
            staFall = MERGE_STA_NO_One;
        }else if (MERGE_STA_NO_TWO.contains(staNo)){
            staFall = MERGE_STA_NO_TWO;
        }else if (MERGE_STA_NO_THREE.contains(staNo)){
            staFall = MERGE_STA_NO_THREE;
        }else if (MERGE_STA_NO_FOUR.contains(staNo)){
            staFall = MERGE_STA_NO_FOUR;
        }else {
            return staNo;
        }

        int indexNo = 0;
        if (rgvNo==1){
            indexNo=staFall.size()-1;
        }
        return staFall.get(indexNo);
    }


    // 获取当前小车未行走的路线集合
    public static List<Integer> getRoute(Integer groupStart,Integer groupEnd){
@@ -61,6 +106,125 @@
            return null;
        }
        return result;
    }

    /*
    * 获取最远站点
    * */
    public static Integer RouteIndexFarMas(Integer a,Integer b,Integer c,Integer d){
        int ia = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(a);
        int ib = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(b);
        int ic = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(c);
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        if (id==0){
            if (ia>ib){
                if (ia>ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib>ic){
                    return b;
                }else {
                    return c;
                }
            }
        }else {
            if (ia<ib){
                if (ia<ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib<ic){
                    return b;
                }else {
                    return c;
                }
            }
        }
    }

    /*
     * 获取最远站点
     * a:当前位置
     * b:开始位置
     * c:结束位置
     * d:锁开始位置
     * */
    public static Integer RouteIndexFarMasNew(Integer a,Integer b,Integer c,Integer d){
        int ia = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(a);
        int ib = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(b);
        int ic = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(c);
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        if (id==0){
            if (ia>ib){
                if (ia>ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib>ic){
                    return b;
                }else {
                    return c;
                }
            }
        }else {
            if (ia<ib){
                if (ia<ic){
                    return a;
                }else {
                    return c;
                }
            }else {
                if (ib<ic){
                    return b;
                }else {
                    return c;
                }
            }
        }
    }

    public static Integer[] RouteIndexFarArr(Integer a,Integer b,Integer c,Integer d){
        int ia = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(a);
        int ib = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(b);
        int ic = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(c);
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        return new Integer[]{ia,ib,ic,id};
    }

    /*
     * a  小车当前位置
     * b  小车任务开始位置
     * c  小车任务结束位置
     * d  小车初始位置
     * 获取最大路径差值
     * */
    public static List<Integer>  RouteMapCurrentFar(Integer a,Integer b,Integer c,Integer d){
        Integer farStn = RouteIndexFarMas(a, b, c, d);
        return getRouteIntersection(TRACK_POSITION_POSITIVE_SEQUENCE,getRoute(farStn, d), RouteCollectCountType.DIFFERENCESET);
    }

    public static List<Integer>  RouteMapCurrentFar(Integer farStn,Integer d){
        return getRouteIntersection(TRACK_POSITION_POSITIVE_SEQUENCE,getRoute(farStn, d), RouteCollectCountType.DIFFERENCESET);
    }

    /*
    * 另一台小车最远位置
    * */
    public static Integer RouteMapOtherFarStnNo(List<Integer> routeDIFF,Integer d){
        int id = TRACK_POSITION_POSITIVE_SEQUENCE.indexOf(d);
        if (id==0){
            return routeDIFF.get(0);
        }else {
            int size = routeDIFF.size();
            return routeDIFF.get(size-1);
        }
    }

    //是否有交集
@@ -109,6 +273,12 @@
        return !getRouteBoolean(routeCurrent, routeOther);  //是否有交集
    }

    public static List<Integer> RouteAutoBoolean(Integer a,Integer b,Integer c){
        return getRouteIntersection(getRoute(a, c), getRoute(b, c), RouteCollectCountType.DEDUPLICATIONUNION);
    }



    public static void main(String[] arge){
        List<Integer> routeCurrent = getRoute(104, 119);  //获取当前小车路径
        List<Integer> routeOther = getRoute(117, 118);  //获取其它小车路径
@@ -131,6 +301,140 @@
        System.out.println("路径去重并集：\t"+routeIntersection3);

        System.out.println(RouteAutoBoolean(101,104,119,114,116,120,true));

        List<Integer> routeDIFF = RouteMapCurrentFar(114, 104, 119, 117);
        System.out.println("当前路径最大集合：\t"+ routeDIFF);

        Integer routeFarOther= RouteMapOtherFarStnNo(routeDIFF,117);
        System.out.println("另一台小车最远站点：\t"+routeFarOther);


        Integer[] integers = RouteIndexFarArr(114, 104, 119, 101);
        for (Integer integer:integers){
            System.out.println(integer);
        }
    }

    public static short RgvPosSta(Integer rgvId,Short posId){
        switch (rgvId){
            case 1:
                return RgvPosStaOne(posId);
            case 2:
                return RgvPosStaTwo(posId);
            default:
                return 1;
        }
    }

    public static short RgvPosStaOne(Short posId){
        switch (posId.intValue()){
            case 1:
            case 2:
                return 102;
            case 3:
            case 4:
                return 122;
            case 5:
            case 6:
                return 105;
            case 7:
            case 8:
                return 118;
            case 9:
            case 10:
            case 11:
                return 119;
            case 12:
            case 13:
            case 14:
                return 110;
            case 15:
                return 120;
            case 16:
            case 17:
            case 18:
                return 111;
            case 19:
                return 121;
            case 20:
            case 21:
            case 22:
                return 113;
            case 23:
            case 24:
                return 123;
            case 25:
                return 114;
            case 26:
            case 27:
                return 1142;
            case 28:
                return 116;
            default:
                return 1142;
        }
    }

    public static short RgvPosStaTwo(Short posId){
        switch (posId.intValue()){
            case 1:
                return 116;
            case 2:
                return 1142;
            case 3:
            case 4:
                return 114;
            case 5:
                return 123;
            case 6:
            case 7:
            case 8:
                return 113;
            case 9:
            case 10:
                return 121;
            case 11:
            case 12:
            case 13:
            case 14:
                return 120;
            case 15:
                return 110;
            case 16:
            case 17:
            case 18:
                return 119;
            case 19:
                return 108;
            case 20:
            case 21:
            case 22:
                return 107;
            case 23:
            case 24:
                return 105;
            case 25:
            case 26:
            case 27:
            case 28:
                return 104;
            default:
                return 104;
        }
    }

    public static Integer CrnStaEnd(Integer endSta,Integer souSta) {
        switch (souSta) {
            case 100:
            case 103:
            case 106:
            case 109:
            case 112:
            case 115:
                return souSta + 1;
            default:
                return endSta;
        }
    }

}