潘钊 / bsth_control · Commits

Commit 3e44b0cacd4b603e836f26a73f86a95a34b06d4b

Authored by 徐烜
1 parent a9a85907

时刻表v2.2 

1、纵向间隔明细到每圈每个方向上都有间隔，间隔表示下一个路牌距离当前路牌的间隔，从下而上
2、纵向添加班次的时候，全部以上标线的班次为开始点计算
3、中标线必须在连班路牌上
4、分隔发计算各种班型的路牌，直接分隔，不用之前的比率分隔
Inline Side-by-side
Showing 5 changed files with 724 additions and 598 deletions
src/main/resources/static/pages/base/timesmodel/js/v2/ParameterObj.js
  View file @3e44b0c
... ... @@ -896,163 +896,186 @@ var ParameterObj = function() {
896 896  
897 897 /**
898 898 * 获取固定的停站时间（固定停站时间都是选的最大值）
899   - * @param timeObj 时间对象
900   - * @param isUp 是否上行
901   - * @returns number
  899 + * @param oTimeObj 时间对象
  900 + * @param bIsUp 是否上行
  901 + * @param iXXTime 行驶时间
  902 + * @returns int 停站时间
902 903 */
903   - calcuFixedStopNumber: function(timeObj, isUp) {
  904 + fnCalcuFixedStopNumber: function(oTimeObj, bIsUp, iXXTime) {
904 905 _validInternal(); // 验证
905   - var paramObj = this;
  906 + var oParam = this;
  907 +
  908 + var iPeakStopTime; // 高峰停站时间
  909 + var iTroughStopTime; // 低谷停站时间
  910 + var iSecondaryStopTime; // 副站停站时间
906 911  
907   - var peakStopTime; // 高峰停站时间
908   - var troughStopTime; // 低谷停站时间
909   - var secondaryStopTime; // 副站停站时间
  912 + var iXXTime_temp;
910 913  
911 914 // 双向停站
912   - if (paramObj.isTwoWayStop()) {
913   - if (isUp) { // 上行
914   - if (this.isMPeakBc(timeObj)) { // 早高峰
915   - peakStopTime = Math.floor(paramObj.getUpMPeakTime() * 0.1); // 行驶时间的10%
916   - if (peakStopTime < 3) { // 不少于3分钟
917   - peakStopTime = 3;
  915 + if (oParam.isTwoWayStop()) {
  916 + if (bIsUp) { // 上行
  917 + if (this.isMPeakBc(oTimeObj)) { // 早高峰
  918 + iXXTime_temp = iXXTime == undefined ? oParam.getUpMPeakTime() : iXXTime;
  919 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  920 + if (iPeakStopTime < 3) { // 不少于3分钟
  921 + iPeakStopTime = 3;
918 922 }
919   - return peakStopTime;
920   - } else if (this.isEPeakBc(timeObj)) { // 晚高峰
921   - peakStopTime = Math.floor(paramObj.getUpEPeakTime() * 0.1); // 行驶时间的10%
922   - if (peakStopTime < 3) { // 不少于3分钟
923   - peakStopTime = 3;
  923 + return iPeakStopTime;
  924 + } else if (this.isEPeakBc(oTimeObj)) { // 晚高峰
  925 + iXXTime_temp = iXXTime == undefined ? oParam.getUpEPeakTime() : iXXTime;
  926 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  927 + if (iPeakStopTime < 3) { // 不少于3分钟
  928 + iPeakStopTime = 3;
924 929 }
925   - return peakStopTime;
  930 + return iPeakStopTime;
926 931 } else { // 低谷
927   - if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
928   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
929   - if (troughStopTime < 10) { // 不少于10分钟
930   - troughStopTime = 10;
  932 + if (this.isTroughBeforMPeakStartBc(oTimeObj)) { // 早高峰开始前
  933 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  934 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  935 + if (iTroughStopTime < 10) { // 不少于10分钟
  936 + iTroughStopTime = 10;
931 937 }
932   - return troughStopTime;
933   - } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
934   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
935   - if (troughStopTime < 10) { // 不少于10分钟
936   - troughStopTime = 10;
  938 + return iTroughStopTime;
  939 + } else if (this.isTroughAfterEPeakEndBc(oTimeObj)) { // 晚高峰结束后
  940 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  941 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  942 + if (iTroughStopTime < 10) { // 不少于10分钟
  943 + iTroughStopTime = 10;
937 944 }
938   - return troughStopTime;
  945 + return iTroughStopTime;
939 946 } else { // 早高峰，晚高峰之间
940   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.15); // 行驶时间15%
941   - if (troughStopTime < 10) { // 不少于10分钟
942   - troughStopTime = 10;
  947 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  948 + iTroughStopTime = Math.floor(iXXTime_temp * 0.15); // 行驶时间15%
  949 + if (iTroughStopTime < 10) { // 不少于10分钟
  950 + iTroughStopTime = 10;
943 951 }
944   - return troughStopTime;
  952 + return iTroughStopTime;
945 953 }
946 954 }
947 955 } else { // 下行
948   - if (this.isMPeakBc(timeObj)) { // 早高峰
949   - peakStopTime = Math.floor(paramObj.getDownMPeakTime() * 0.1); // 行驶时间的10%
950   - if (peakStopTime < 3) { // 不少于3分钟
951   - peakStopTime = 3;
  956 + if (this.isMPeakBc(oTimeObj)) { // 早高峰
  957 + iXXTime_temp = iXXTime == undefined ? oParam.getDownMPeakTime() : iXXTime;
  958 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  959 + if (iPeakStopTime < 3) { // 不少于3分钟
  960 + iPeakStopTime = 3;
952 961 }
953   - return peakStopTime;
954   - } else if (this.isEPeakBc(timeObj)) { // 晚高峰
955   - peakStopTime = Math.floor(paramObj.getDownEPeakTime() * 0.1); // 行驶时间的10%
956   - if (peakStopTime < 3) { // 不少于3分钟
957   - peakStopTime = 3;
  962 + return iPeakStopTime;
  963 + } else if (this.isEPeakBc(oTimeObj)) { // 晚高峰
  964 + iXXTime_temp = iXXTime == undefined ? oParam.getDownEPeakTime() : iXXTime;
  965 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  966 + if (iPeakStopTime < 3) { // 不少于3分钟
  967 + iPeakStopTime = 3;
958 968 }
959   - return peakStopTime;
  969 + return iPeakStopTime;
960 970 } else { // 低谷
961   - if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
962   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
963   - if (troughStopTime < 10) { // 不少于10分钟
964   - troughStopTime = 10;
  971 + if (this.isTroughBeforMPeakStartBc(oTimeObj)) { // 早高峰开始前
  972 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  973 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  974 + if (iTroughStopTime < 10) { // 不少于10分钟
  975 + iTroughStopTime = 10;
965 976 }
966   - return troughStopTime;
967   - } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
968   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
969   - if (troughStopTime < 10) { // 不少于10分钟
970   - troughStopTime = 10;
  977 + return iTroughStopTime;
  978 + } else if (this.isTroughAfterEPeakEndBc(oTimeObj)) { // 晚高峰结束后
  979 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  980 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  981 + if (iTroughStopTime < 10) { // 不少于10分钟
  982 + iTroughStopTime = 10;
971 983 }
972   - return troughStopTime;
  984 + return iTroughStopTime;
973 985 } else { // 早高峰，晚高峰之间
974   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.15); // 行驶时间15%
975   - if (troughStopTime < 10) { // 不少于10分钟
976   - troughStopTime = 10;
  986 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  987 + iTroughStopTime = Math.floor(iXXTime_temp * 0.15); // 行驶时间15%
  988 + if (iTroughStopTime < 10) { // 不少于10分钟
  989 + iTroughStopTime = 10;
977 990 }
978   - return troughStopTime;
  991 + return iTroughStopTime;
979 992 }
980 993 }
981 994 }
982 995 } else { // 主站停站
983   - if (isUp == paramObj.isUpOneWayStop()) {
984   - if (isUp) { // 上行
985   - if (this.isMPeakBc(timeObj)) { // 早高峰
986   - peakStopTime = Math.floor(paramObj.getUpMPeakTime() * 0.1); // 行驶时间的10%
987   - if (peakStopTime < 3) { // 不少于3分钟
988   - peakStopTime = 3;
  996 + if (bIsUp == oParam.isUpOneWayStop()) {
  997 + if (bIsUp) { // 上行
  998 + if (this.isMPeakBc(oTimeObj)) { // 早高峰
  999 + iXXTime_temp = iXXTime == undefined ? oParam.getUpMPeakTime() : iXXTime;
  1000 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  1001 + if (iPeakStopTime < 3) { // 不少于3分钟
  1002 + iPeakStopTime = 3;
989 1003 }
990   - return peakStopTime;
991   - } else if (this.isEPeakBc(timeObj)) { // 晚高峰
992   - peakStopTime = Math.floor(paramObj.getUpEPeakTime() * 0.1); // 行驶时间的10%
993   - if (peakStopTime < 3) { // 不少于3分钟
994   - peakStopTime = 3;
  1004 + return iPeakStopTime;
  1005 + } else if (this.isEPeakBc(oTimeObj)) { // 晚高峰
  1006 + iXXTime_temp = iXXTime == undefined ? oParam.getUpEPeakTime() : iXXTime;
  1007 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  1008 + if (iPeakStopTime < 3) { // 不少于3分钟
  1009 + iPeakStopTime = 3;
995 1010 }
996   - return peakStopTime;
  1011 + return iPeakStopTime;
997 1012 } else { // 低谷
998   - if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
999   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
1000   - if (troughStopTime < 10) { // 不少于10分钟
1001   - troughStopTime = 10;
  1013 + if (this.isTroughBeforMPeakStartBc(oTimeObj)) { // 早高峰开始前
  1014 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  1015 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  1016 + if (iTroughStopTime < 10) { // 不少于10分钟
  1017 + iTroughStopTime = 10;
1002 1018 }
1003   - return troughStopTime;
1004   - } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
1005   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
1006   - if (troughStopTime < 10) { // 不少于10分钟
1007   - troughStopTime = 10;
  1019 + return iTroughStopTime;
  1020 + } else if (this.isTroughAfterEPeakEndBc(oTimeObj)) { // 晚高峰结束后
  1021 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  1022 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  1023 + if (iTroughStopTime < 10) { // 不少于10分钟
  1024 + iTroughStopTime = 10;
1008 1025 }
1009   - return troughStopTime;
  1026 + return iTroughStopTime;
1010 1027 } else { // 早高峰，晚高峰之间
1011   - troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.15); // 行驶时间15%
1012   - if (troughStopTime < 10) { // 不少于10分钟
1013   - troughStopTime = 10;
  1028 + iXXTime_temp = iXXTime == undefined ? oParam.getUpTroughTime() : iXXTime;
  1029 + iTroughStopTime = Math.floor(iXXTime_temp * 0.15); // 行驶时间15%
  1030 + if (iTroughStopTime < 10) { // 不少于10分钟
  1031 + iTroughStopTime = 10;
1014 1032 }
1015   - return troughStopTime;
  1033 + return iTroughStopTime;
1016 1034 }
1017 1035 }
1018 1036 } else { // 下行
1019   - if (this.isMPeakBc(timeObj)) { // 早高峰
1020   - peakStopTime = Math.floor(paramObj.getDownMPeakTime() * 0.1); // 行驶时间的10%
1021   - if (peakStopTime < 3) { // 不少于3分钟
1022   - peakStopTime = 3;
  1037 + if (this.isMPeakBc(oTimeObj)) { // 早高峰
  1038 + iXXTime_temp = iXXTime == undefined ? oParam.getDownMPeakTime() : iXXTime;
  1039 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  1040 + if (iPeakStopTime < 3) { // 不少于3分钟
  1041 + iPeakStopTime = 3;
1023 1042 }
1024   - return peakStopTime;
1025   - } else if (this.isEPeakBc(timeObj)) { // 晚高峰
1026   - peakStopTime = Math.floor(paramObj.getDownEPeakTime() * 0.1); // 行驶时间的10%
1027   - if (peakStopTime < 3) { // 不少于3分钟
1028   - peakStopTime = 3;
  1043 + return iPeakStopTime;
  1044 + } else if (this.isEPeakBc(oTimeObj)) { // 晚高峰
  1045 + iXXTime_temp = iXXTime == undefined ? oParam.getDownEPeakTime() : iXXTime;
  1046 + iPeakStopTime = Math.floor(iXXTime_temp * 0.1); // 行驶时间的10%
  1047 + if (iPeakStopTime < 3) { // 不少于3分钟
  1048 + iPeakStopTime = 3;
1029 1049 }
1030   - return peakStopTime;
  1050 + return iPeakStopTime;
1031 1051 } else { // 低谷
1032   - if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
1033   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
1034   - if (troughStopTime < 10) { // 不少于10分钟
1035   - troughStopTime = 10;
  1052 + if (this.isTroughBeforMPeakStartBc(oTimeObj)) { // 早高峰开始前
  1053 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  1054 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  1055 + if (iTroughStopTime < 10) { // 不少于10分钟
  1056 + iTroughStopTime = 10;
1036 1057 }
1037   - return troughStopTime;
1038   - } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
1039   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
1040   - if (troughStopTime < 10) { // 不少于10分钟
1041   - troughStopTime = 10;
  1058 + return iTroughStopTime;
  1059 + } else if (this.isTroughAfterEPeakEndBc(oTimeObj)) { // 晚高峰结束后
  1060 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  1061 + iTroughStopTime = Math.floor(iXXTime_temp * 0.2); // 行驶时间20%
  1062 + if (iTroughStopTime < 10) { // 不少于10分钟
  1063 + iTroughStopTime = 10;
1042 1064 }
1043   - return troughStopTime;
  1065 + return iTroughStopTime;
1044 1066 } else { // 早高峰，晚高峰之间
1045   - troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.15); // 行驶时间15%
1046   - if (troughStopTime < 10) { // 不少于10分钟
1047   - troughStopTime = 10;
  1067 + iXXTime_temp = iXXTime == undefined ? oParam.getDownTroughTime() : iXXTime;
  1068 + iTroughStopTime = Math.floor(iXXTime_temp * 0.15); // 行驶时间15%
  1069 + if (iTroughStopTime < 10) { // 不少于10分钟
  1070 + iTroughStopTime = 10;
1048 1071 }
1049   - return troughStopTime;
  1072 + return iTroughStopTime;
1050 1073 }
1051 1074 }
1052 1075 }
1053 1076 } else { // 副站停战，2到3分钟
1054   - secondaryStopTime = 3;
1055   - return secondaryStopTime; // 直接返回3分钟
  1077 + iSecondaryStopTime = 3;
  1078 + return iSecondaryStopTime; // 直接返回3分钟
1056 1079 }
1057 1080 }
1058 1081  
... ... @@ -1138,9 +1161,9 @@ var ParameterObj = function() {
1138 1161 var _time = paramObj.getMPeakStartTimeObj();
1139 1162 var _zzsj = // 早高峰上行行驶时间+停站时间+早高峰下行行驶时间+停站时间
1140 1163 this.calcuTravelTime(_time, true) +
1141   - this.calcuFixedStopNumber(_time, true) +
  1164 + this.fnCalcuFixedStopNumber(_time, true) +
1142 1165 this.calcuTravelTime(_time, false) +
1143   - this.calcuFixedStopNumber(_time, false);
  1166 + this.fnCalcuFixedStopNumber(_time, false);
1144 1167 return _zzsj;
1145 1168 },
1146 1169  
... ... @@ -1156,9 +1179,9 @@ var ParameterObj = function() {
1156 1179 var _time = this.addMinute(paramObj.getMPeakStartTimeObj(), -1); // 使用任意一个低谷时间
1157 1180 var _zzsj = // 低谷上行行驶时间+停站时间+低谷下行行驶时间+停站时间
1158 1181 this.calcuTravelTime(_time, true) +
1159   - this.calcuFixedStopNumber(_time, true) +
  1182 + this.fnCalcuFixedStopNumber(_time, true) +
1160 1183 this.calcuTravelTime(_time, false) +
1161   - this.calcuFixedStopNumber(_time, false);
  1184 + this.fnCalcuFixedStopNumber(_time, false);
1162 1185  
1163 1186 return _zzsj;
1164 1187 },
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalBcObj.js
  View file @3e44b0c
... ... @@ -38,10 +38,21 @@ var InternalBcObj = function(
38 38 this._$_qdzid = otherParamObj.qdzid; // 起点站id
39 39 this._$_zdzid = otherParamObj.zdzid; // 终点站id
40 40  
  41 + // 标记参数，这个班次用于计算，最后必须删除
  42 + this._$_bDelFlag = false;
  43 +
41 44 };
42 45  
43 46 //------------------- get/set 方法 -------------------//
44 47  
  48 +InternalBcObj.prototype.fnSetDelFlag = function(bFlag) {
  49 + this._$_bDelFlag = bFlag;
  50 +};
  51 +
  52 +InternalBcObj.prototype.fnIsDelFlag = function() {
  53 + return this._$_bDelFlag;
  54 +};
  55 +
45 56 /**
46 57 * 设置路牌对象。
47 58 * @param lpObj InternalLpObj路牌对象
... ... @@ -86,6 +97,13 @@ InternalBcObj.prototype.getArrTimeObj = function() {
86 97 return this._$_arrtime;
87 98 };
88 99 /**
  100 + * 设置到达时间。
  101 + * @param oTime
  102 + */
  103 +InternalBcObj.prototype.setArrTimeObj = function(oTime) {
  104 + this._$_arrtime = oTime;
  105 +};
  106 +/**
89 107 * 获取班次时间。
90 108 * @returns int
91 109 */
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalLpObj.js
  View file @3e44b0c
... ... @@ -12,11 +12,6 @@ var InternalLpObj = function(
12 12  
13 13 this._$_isUp = isUp;
14 14  
15   - // 距离上一个路牌的最小发车间隔时间
16   - // 用于纵向添加班次的时候使用
17   - // 默认第一个路牌为0
18   - this._$_minVerticalIntervalTime = 0;
19   -
20 15 // 路牌的圈数，注意每个路牌的圈数都是一致的，
21 16 // 但并不是每一圈都有值
22 17 // 第1圈从上标线开始
... ... @@ -32,7 +27,23 @@ var InternalLpObj = function(
32 27 this, this._$_isUp, undefined, undefined);
33 28 }
34 29  
35   - // 班型的相关变量
  30 + // 距离上一个路牌的最小发车间隔时间
  31 + // 用于纵向添加班次的时候使用
  32 + // 默认第一个路牌为0
  33 + this._$_minVerticalIntervalTime = 0;
  34 +
  35 + // 详细记录每圈每个方向上的发车间隔时间
  36 + // 第一维度表示圈数，第二维度表示第一个方向，第二个方向
  37 + // 第一个方向是否上行由 _$_isUp 决定
  38 + // 这里的间隔表示下一个路牌上的班次距离本路牌的班次发车时间间隔
  39 + // 如果当前是最后一个路牌，表示第一个路牌的下一圈同方向班次距离本班次的间隔
  40 + this._$_aVerticalIntervalTime = new Array(this._$_qCount);
  41 + var i;
  42 + for (i = 0; i < this._$_aVerticalIntervalTime.length; i++) {
  43 + this._$_aVerticalIntervalTime[i] = new Array(2);
  44 + }
  45 +
  46 + // 班型的相关变量
36 47 this._$_bx_isLb = false; // 是否连班
37 48 this._$_bx_isfb = false; // 是否分班
38 49 this._$_bx_isfb_5_2 = false; // 是否5休2分班
... ... @@ -171,6 +182,25 @@ InternalLpObj.prototype.getVerticalMinIntervalTime = function() {
171 182 return this._$_minVerticalIntervalTime;
172 183 };
173 184  
  185 +/**
  186 + * 设置纵向发车间隔。
  187 + * @param iQindex 圈index
  188 + * @param iBindex 班次index
  189 + * @param iTime 间隔时间
  190 + */
  191 +InternalLpObj.prototype.fnSetVerticalIntervalTime = function(iQindex, iBindex, iTime) {
  192 + this._$_aVerticalIntervalTime[iQindex][iBindex] = iTime;
  193 +};
  194 +
  195 +/**
  196 + * 返回纵向发车间隔。
  197 + * @param iQindex 圈index
  198 + * @param iBindex 班次index
  199 + */
  200 +InternalLpObj.prototype.fnGetVerticalIntervalTime = function(iQindex, iBindex) {
  201 + return this._$_aVerticalIntervalTime[iQindex][iBindex];
  202 +};
  203 +
174 204 //-------------------- 班次操作方法（查询，统计，删除） -----------------------//
175 205  
176 206 /**
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalScheduleObj.js
  View file @3e44b0c
... ... @@ -25,7 +25,8 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
25 25 {'sType':'无工休', 'fHoursV':5.43, 'fBcCount': 0, 'fAverTime': 0}
26 26 ];
27 27  
28   - var _initFun1 = function() { // 初始化方法1
  28 + var _fnInitFun1 = function() { // 初始化方法1
  29 + console.log("//---------------- 行车计划，初始化方法1 start ----------------//");
29 30  
30 31 //----------------------- 1、确定上标线的方向，圈的方向 -------------------//
31 32  
... ... @@ -57,7 +58,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
57 58 var _kssj = st; // 开始时间
58 59 var _bcsj = paramObj.calcuTravelTime(_kssj, isUp); // 班次历时
59 60 var _arrsj = paramObj.addMinute(_kssj, _bcsj); // 到达时间
60   - var _stoptime = paramObj.calcuFixedStopNumber(_arrsj, !isUp); // 停站时间
  61 + var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj); // 停站时间
61 62  
62 63 do {
63 64 bcFcsjArrays.push(_kssj);
... ... @@ -66,7 +67,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
66 67 _kssj = paramObj.addMinute(_kssj, _bcsj + _stoptime);
67 68 _bcsj = paramObj.calcuTravelTime(_kssj, isUp);
68 69 _arrsj = paramObj.addMinute(_kssj, _bcsj);
69   - _stoptime = paramObj.calcuFixedStopNumber(_arrsj, !isUp);
  70 + _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
70 71  
71 72 bcCount ++;
72 73 isUp = !isUp;
... ... @@ -135,8 +136,71 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
135 136 _aBxDesc[i].fBcCount = ((_aBxDesc[i].fHoursV * 60) / _aBxDesc[i].fAverTime) * 2;
136 137 }
137 138  
  139 + // 在第一个班次之前再添加一个模拟班次，用于中标线的作用
  140 + // 那一圈必定是低谷，而且圈索引0，班次索引1，暂时标记，最后删除
  141 + var iFirstStopTime =
  142 + _paramObj.fnCalcuFixedStopNumber(
  143 + _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -10),
  144 + _qIsUp
  145 + );
  146 + var iXXTime = _qIsUp ? _paramObj.getDownTroughTime() : _paramObj.getUpTroughTime();
  147 + var oFlagBc = _factory.createBcObj( // 标记班次
  148 + _internalLpArray[0],
  149 + "normal",
  150 + !_qIsUp,
  151 + 1,
  152 + _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -(iFirstStopTime + iXXTime)),
  153 + _paramObj
  154 + );
  155 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  156 +
  157 + _internalLpArray[0].setBc(0, 1, oFlagBc);
  158 +
  159 + // 在最后一圈也补上一个或者2个模拟班次，暂时标记，最后需要删除
  160 + var aMaxBcIndex = _internalLpArray[0].getMaxBcObjPosition();
  161 + if (aMaxBcIndex[0] == _qCount - 1) { // 可能加半圈
  162 + oFlagBc = _factory.createBcObj( // 标记班次
  163 + _internalLpArray[0],
  164 + "normal",
  165 + !_qIsUp,
  166 + 1,
  167 + _paramObj.addMinute(
  168 + _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
  169 + _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
  170 + _paramObj
  171 + );
  172 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  173 + _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
  174 +
  175 + } else { // 加完整的一圈
  176 + oFlagBc = _factory.createBcObj( // 标记班次
  177 + _internalLpArray[0],
  178 + "normal",
  179 + _qIsUp,
  180 + 1,
  181 + _paramObj.addMinute(
  182 + _internalLpArray[0].getBc(_qCount - 2, 1).getArrTimeObj(),
  183 + _internalLpArray[0].getBc(_qCount - 2, 1).getStopTime()),
  184 + _paramObj
  185 + );
  186 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  187 + _internalLpArray[0].setBc(_qCount - 1, 0, oFlagBc);
  188 +
  189 + oFlagBc = _factory.createBcObj( // 标记班次
  190 + _internalLpArray[0],
  191 + "normal",
  192 + !_qIsUp,
  193 + 1,
  194 + _paramObj.addMinute(
  195 + _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
  196 + _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
  197 + _paramObj
  198 + );
  199 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  200 + _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
  201 +
  202 + }
138 203  
139   - console.log("//---------------- 行车计划，初始化方法1 start ----------------//");
140 204 console.log("上行首班车时间:" + _paramObj.getUpFirstDTimeObj().format("HH:mm") +
141 205 "上行末班车时间:" + _paramObj.getUpLastDtimeObj().format("HH:mm"));
142 206 console.log("下行首班车时间:" + _paramObj.getDownFirstDTimeObj().format("HH:mm") +
... ... @@ -145,6 +209,10 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
145 209 console.log("圈的方向isUP:" + _qIsUp);
146 210 console.log("班型描述（以下）:");
147 211 console.log(_aBxDesc);
  212 + console.log("所有路牌间隔描述（以下）:");
  213 + for (i = 0; i < _internalLpArray.length; i++) {
  214 + console.log(_internalLpArray[i]._$_aVerticalIntervalTime);
  215 + }
148 216 console.log("//---------------- 行车计划，初始化方法1 end ----------------//");
149 217  
150 218 };
... ... @@ -155,12 +223,57 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
155 223 var _approximate_wgfQIndex; // 预估晚高峰车辆从第几圈开始全部发出
156 224 var _approximate_wgfBIndex; // 预估晚高峰车辆从第几圈第几个班次开始全部发出（上行或下行）
157 225  
158   - // 同一圈同一方向班次发车间隔的最小值
159   - // 注意：这个值就是用来添加班次的时间增加单位，在后面相关的方法里会具体说明
160   - var _qbcMinIntervalValue;
  226 + var _fnInitFun2 = function() { // 初始化方法2
  227 + console.log("//---------------- 行车计划，初始化方法2 start ----------------//");
  228 +
  229 + //------------------------ 1、计算车辆总数 ------------------------//
  230 + // 是用高峰上行周转时间除以高峰平均间隔得到的
  231 + // 这样算还算合理，车辆不多不少，待以后有新的算法再修正
  232 + var iClCount = _paramObj.calcuClzx();
161 233  
162   - var _initFun2 = function() { // 初始化方法2
163   - //------------------------ 1、预估早高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
  234 + //------------------------ 2、计算所有路牌的发车在各个圈中的间隔 --------------------//
  235 + var i;
  236 + var j;
  237 + var iBindex = 1;
  238 + var iZzsj;
  239 + var oLp;
  240 + var iC1;
  241 + var iC2;
  242 +
  243 + for (i = 0; i < _qCount - 1; i++) {
  244 + while (iBindex <= 1) {
  245 + // 每圈每个方向的周转时间不一致，以上标线为主
  246 + oLp = _internalLpArray[0];
  247 + iZzsj = oLp.getBc(i + 1, iBindex).getFcTimeObj().diff(
  248 + oLp.getBc(i, iBindex).getFcTimeObj(), "m"
  249 + );
  250 +
  251 + iC1 = Math.floor(iZzsj / iClCount);
  252 + iC2 = iZzsj % iClCount;
  253 +
  254 + for (j = 0; j < iClCount - iC2; j++) {
  255 + oLp = _internalLpArray[j];
  256 + oLp.fnSetVerticalIntervalTime(i, iBindex, iC1);
  257 + }
  258 +
  259 + for (j = 0; j < iC2; j++) {
  260 + oLp = _internalLpArray[iClCount - iC2 + j];
  261 + oLp.fnSetVerticalIntervalTime(i, iBindex, iC1 + 1);
  262 + }
  263 +
  264 + iBindex ++;
  265 +
  266 + }
  267 + iBindex = 0;
  268 + }
  269 + // 最后一圈没有下一圈的参照，周转时间没发获取，由于都是低谷，所以使用倒数第二圈的间隔最为最后一圈的间隔
  270 + for (i = 0; i < _internalLpArray.length; i++) {
  271 + oLp = _internalLpArray[i];
  272 + oLp.fnSetVerticalIntervalTime(_qCount - 1, 0, oLp.fnGetVerticalIntervalTime(_qCount - 2, 0));
  273 + oLp.fnSetVerticalIntervalTime(_qCount - 1, 1, oLp.fnGetVerticalIntervalTime(_qCount - 2, 1));
  274 + }
  275 +
  276 + //------------------------ 3、预估早高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
164 277  
165 278 // 以上标线为标准，查找离早高峰开始时间最近的班次作为早高峰开始班次
166 279 // 以这个班次为早高峰起点，全部出车策略
... ... @@ -168,46 +281,15 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
168 281 _paramObj.getMPeakStartTimeObj(), true, true);
169 282 var qIndex = qbcIndexArray[0]; // 第几圈
170 283 var bIndex = qbcIndexArray[1]; // 第几个班次
171   - var startbc = _internalLpArray[0].getBc(qIndex, bIndex);
172   -
173   - // 计算早高峰
174   - var _clCount = _paramObj.calcuClzx();
175   - var _c1 = Math.floor(_paramObj.calcuPeakZzsj() / _clCount);
176   - var _c2 = _paramObj.calcuPeakZzsj() % _clCount;
177   - var _kssj = startbc.getFcTimeObj();
178 284  
179   - var i;
180   - for (i = 2; i <= _clCount - _c2; i++) {
181   - _kssj = _paramObj.addMinute(_kssj, _c1);
182   - _internalLpArray[i - 1].setBc(
183   - qIndex,
184   - bIndex,
185   - _factory.createBcObj(
186   - _internalLpArray[i - 1],
187   - "normal", startbc.isUp(),
188   - 1, _kssj, paramObj)
189   - );
190   - // 使用早高峰的发车间隔最为路牌纵向最小发车间隔，不能整除的话，小的放在前面的路牌
191   - _internalLpArray[i - 1].setVerticalMinIntervalTime(_c1);
192   - }
193   - for (i = 1; i <= _c2; i++) {
194   - _kssj = _paramObj.addMinute(_kssj, _c1 + 1);
195   - _internalLpArray[_clCount - _c2 + i - 1].setBc(
196   - qIndex,
197   - bIndex,
198   - _factory.createBcObj(
199   - _internalLpArray[_clCount - _c2 + i - 1],
200   - "normal", startbc.isUp(),
201   - 1, _kssj, paramObj)
202   - );
203   - // 使用早高峰的发车间隔最为路牌纵向最小发车间隔，，不能整除的话，大的放在后面的路牌
204   - _internalLpArray[_clCount - _c2 + i - 1].setVerticalMinIntervalTime(_c1 + 1);
  285 + for (i = 1; i < _internalLpArray.length; i++) {
  286 + _fnGenerateBcAndSetBc(i, qIndex, bIndex);
205 287 }
206 288  
207 289 _approximate_zgfQIndex = qIndex;
208 290 _approximate_zgfBIndex = bIndex;
209 291  
210   - //------------------------ 2、预估晚高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
  292 + //------------------------ 4、预估晚高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
211 293  
212 294 // 以上标线为标准，查找离晚高峰开始时间最近的班次作为晚高峰开始班次
213 295 // 以这个班次为早高峰起点，全部出车策略
... ... @@ -215,73 +297,163 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
215 297 _paramObj.getEPeakStartTimeObj(), true, true);
216 298 qIndex = qbcIndexArray[0]; // 第几圈
217 299 bIndex = qbcIndexArray[1]; // 第几个班次
218   - startbc = _internalLpArray[0].getBc(qIndex, bIndex);
219   -
220   - // 计算晚高峰
221   - _clCount = _paramObj.calcuClzx();
222   - _c1 = Math.floor(_paramObj.calcuPeakZzsj() / _clCount);
223   - _c2 = _paramObj.calcuPeakZzsj() % _clCount;
224   - _kssj = startbc.getFcTimeObj();
225   -
226   - for (i = 2; i <= _clCount - _c2; i++) {
227   - _kssj = _paramObj.addMinute(_kssj, _c1);
228   - _internalLpArray[i - 1].setBc(
229   - qIndex,
230   - bIndex,
231   - _factory.createBcObj(
232   - _internalLpArray[i - 1],
233   - "normal", startbc.isUp(),
234   - 1, _kssj, _paramObj)
235   - );
236   - }
237   - for (i = 1; i <= _c2; i++) {
238   - _kssj = _paramObj.addMinute(_kssj, _c1 + 1);
239   - _internalLpArray[_clCount - _c2 + i - 1].setBc(
240   - qIndex,
241   - bIndex,
242   - _factory.createBcObj(
243   - _internalLpArray[_clCount - _c2 + i - 1],
244   - "normal", startbc.isUp(),
245   - 1, _kssj, _paramObj)
246   - );
  300 +
  301 + for (i = 1; i < _internalLpArray.length; i++) {
  302 + _fnGenerateBcAndSetBc(i, qIndex, bIndex);
247 303 }
248 304  
249 305 _approximate_wgfQIndex = qIndex;
250 306 _approximate_wgfBIndex = bIndex;
251   - _qbcMinIntervalValue = _c1;
252 307  
253   - console.log("//---------------- 行车计划，初始化方法2 start ----------------//");
254 308 console.log("早高峰周转时间(固定最大停战时间):" + _paramObj.calcuPeakZzsj() + "分钟");
255 309 console.log("早高峰发车时间范围:" + _paramObj.getMPeakMinFcjx() + "分钟 --- " + _paramObj.getMPeakMaxFcjx() + "分钟");
256 310 console.log("预估早高峰第" + _approximate_zgfQIndex + "(index)圈,第" + _approximate_zgfBIndex + "(index)班次车辆全部发出");
257 311 console.log("预估晚高峰第" + _approximate_wgfQIndex + "(index)圈,第" + _approximate_wgfBIndex + "(index)班次车辆全部发出");
258   - console.log("预估同圈同方向班次最小间隔:" + _qbcMinIntervalValue + "分钟");
259 312 console.log("//---------------- 行车计划，初始化方法2 end ----------------//");
260 313 };
261 314  
262   - //----------------------- 初始化方法3，以及计算关联的内部变量 ----------------//
263   - var _zbx_lpIndex; // 中标线对应第几个路牌
  315 + //----------------------- 初始化方法3，计算连班分班的路牌分布 ----------------//
  316 + var _iBx_lb_lpcount; // 连班路牌数
  317 + var _iBx_5_2_fb_lpcount; // 5休2分班路牌数
  318 + var _iBx_other_fb_lpcount; // 其他分班路牌数
264 319  
265   - var _initFun3 = function() { // 初始化方法3
266   - //---------------------------- 1、模拟一个中标线，使用临时路牌 ----------------------//
  320 + var _fnInitFun3 = function() { // 初始化方法3
  321 + console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
  322 +
  323 + //--------------------- 1、计算分班连班班型车辆分布数 --------------------//
  324 + // 总共车辆数（高峰最大车辆数）
  325 + var iCls = _paramObj.calcuClzx();
  326 + // 低谷最少配车（连班车数量）
  327 + var iDgminpc = Math.round(_paramObj.calcuTroughZzsj() / _paramObj.getTroughMaxFcjx());
  328 + // 加班车路牌数（做5休2的路牌数）
  329 + var i_5_2_lpes = _paramObj.getJBLpes();
  330 +
  331 + // 做些简单的验证
  332 + if (iCls < iDgminpc) {
  333 + alert("总配车数小于低谷最小配车");
  334 + throw "总配车数小于低谷最小配车";
  335 + }
  336 + if (iDgminpc < 2) {
  337 + alert("连班路牌小于2，办不到啊");
  338 + throw "连班路牌小于2，办不到啊";
  339 + }
  340 + if (iCls - iDgminpc < i_5_2_lpes) {
  341 + alert("总分班路牌数小于加班路牌数");
  342 + throw "总分班路牌数小于加班路牌数";
  343 + }
267 344  
  345 + _iBx_lb_lpcount = iDgminpc;
  346 + _iBx_5_2_fb_lpcount = i_5_2_lpes;
  347 + _iBx_other_fb_lpcount = iCls - iDgminpc - i_5_2_lpes;
  348 +
  349 + //------------------------ 2、利用间隔法计算连班路牌分布 --------------------//
  350 + var i;
  351 + var j;
  352 + var iC1 = Math.floor(_internalLpArray.length / _iBx_lb_lpcount);
  353 + var iC2 = _internalLpArray.length % _iBx_lb_lpcount;
  354 + var iLpIndex;
  355 +
  356 + for (i = 0; i < _iBx_lb_lpcount - iC2; i++) {
  357 + iLpIndex = i * iC1;
  358 + _internalLpArray[iLpIndex].setBxLb(true);
  359 + _internalLpArray[iLpIndex].setBxDesc("连班");
  360 + }
  361 + for (j = 0; j < iC2; j++) {
  362 + iLpIndex = i * iC1 + j * (iC1 + 1);
  363 + _internalLpArray[iLpIndex].setBxLb(true);
  364 + _internalLpArray[iLpIndex].setBxDesc("连班");
  365 + }
  366 +
  367 + //------------------------ 3、利用间隔法计算分班班型路牌分布 --------------------//
  368 + // 获取分班路牌索引
  369 + var aNotLbIndexes = [];
  370 + for (i = 0; i < _internalLpArray.length; i++) {
  371 + if (!_internalLpArray[i].isBxLb()) {
  372 + aNotLbIndexes.push(i);
  373 + }
  374 + }
  375 + // 先5休2分班
  376 + iC1 = Math.floor(aNotLbIndexes.length / _iBx_5_2_fb_lpcount);
  377 + iC2 = aNotLbIndexes.length % _iBx_5_2_fb_lpcount;
  378 +
  379 + for (i = 0; i < _iBx_5_2_fb_lpcount - iC2; i++) {
  380 + iLpIndex = aNotLbIndexes[i * iC1];
  381 + _internalLpArray[iLpIndex].setBxLb(false);
  382 + _internalLpArray[iLpIndex].setBxFb(true);
  383 + _internalLpArray[iLpIndex].setBxFb5_2(true);
  384 + _internalLpArray[iLpIndex].setBxDesc("5休2分班");
  385 + }
  386 + for (i = 0; i < iC2; i++) {
  387 + iLpIndex = aNotLbIndexes[_iBx_lb_lpcount - iC2 + i * (iC1 + 1)];
  388 + _internalLpArray[iLpIndex].setBxLb(false);
  389 + _internalLpArray[iLpIndex].setBxFb(true);
  390 + _internalLpArray[iLpIndex].setBxFb5_2(true);
  391 + _internalLpArray[iLpIndex].setBxDesc("5休2分班");
  392 + }
  393 + // 其他分班
  394 + for (i = 0; i < aNotLbIndexes.length; i++) {
  395 + iLpIndex = aNotLbIndexes[i];
  396 + if (!_internalLpArray[iLpIndex].isBxFb5_2()) {
  397 + _internalLpArray[iLpIndex].setBxLb(false);
  398 + _internalLpArray[iLpIndex].setBxFb(true);
  399 + _internalLpArray[iLpIndex].setBxFb5_2(false);
  400 + _internalLpArray[iLpIndex].setBxDesc("其他分班");
  401 + }
  402 + }
  403 +
  404 +
  405 + console.log("连班路牌数:" + _iBx_lb_lpcount);
  406 + console.log("5休2分班路牌数:" + _iBx_5_2_fb_lpcount);
  407 + console.log("其他分班路牌数:" + _iBx_other_fb_lpcount);
  408 + var aLbIndexes = [];
  409 + for (i = 0; i < _internalLpArray.length; i++) {
  410 + if (_internalLpArray[i].isBxLb()) {
  411 + aLbIndexes.push(i);
  412 + }
  413 + }
  414 + console.log("连班路牌indexes=" + aLbIndexes);
  415 + var a_5_2_fbIndexes = [];
  416 + for (i = 0; i < _internalLpArray.length; i++) {
  417 + if (_internalLpArray[i].isBxFb() && _internalLpArray[i].isBxFb5_2()) {
  418 + a_5_2_fbIndexes.push(i);
  419 + }
  420 + }
  421 + console.log("5休2分班路牌indexes=" + a_5_2_fbIndexes);
  422 + var a_other_fbIndexes = [];
  423 + for (i = 0; i < _internalLpArray.length; i++) {
  424 + if (_internalLpArray[i].isBxFb() && !_internalLpArray[i].isBxFb5_2()) {
  425 + a_other_fbIndexes.push(i);
  426 + }
  427 + }
  428 + console.log("其他分班路牌indexes=" + a_other_fbIndexes);
  429 +
  430 + console.log("//---------------- 行车计划，初始化方法3 end ----------------//");
  431 + };
  432 +
  433 + //----------------------- 初始化方法4，计算中标线位置 -------------------------//
  434 + var _iZbx_lpIndex; // 中标线对应第几个路牌
  435 +
  436 + var _fnInitFun4 = function() { // 初始化方法4
  437 + console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
  438 +
  439 + //---------------------------- 1、模拟一个中标线，使用临时路牌 ----------------------//
268 440 // 构造中标线
269 441 // 中标线开始时间，就是方向的首班车时间
270   - var st = !_qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  442 + var oSt = !_qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
271 443 // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
272 444 // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
273   - var et;
  445 + var oEt;
274 446 if (_paramObj.getUpLastDtimeObj().isBefore(
275 447 _paramObj.getDownLastDTimeObj())) {
276   - et = _paramObj.getDownLastDTimeObj();
  448 + oEt = _paramObj.getDownLastDTimeObj();
277 449 } else {
278   - et = _paramObj.getUpLastDtimeObj();
  450 + oEt = _paramObj.getUpLastDtimeObj();
279 451 }
280 452  
281   - var tempLpObj = new InternalLpObj({lpNo: -999, lpName: "-999"}, _qCount, _qIsUp);
282   - tempLpObj.initDataFromTimeToTime(
283   - st,
284   - et,
  453 + var oTempLp = new InternalLpObj({lpNo: -999, lpName: "-999"}, _qCount, _qIsUp);
  454 + oTempLp.initDataFromTimeToTime(
  455 + oSt,
  456 + oEt,
285 457 !_qIsUp,
286 458 0,
287 459 _paramObj,
... ... @@ -289,109 +461,125 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
289 461 );
290 462  
291 463 //------------------------ 2、找出中标线的早高峰班次，计算应该插在当前路牌数组的那个位置 ----------------//
292   - // TODO：中标线的早高峰发车班次，和插入位置的早高分班次的时间会有误差的
293   - // TODO：这里是直接把中标线班次覆盖，没有根据误差调整，以后改
294   -
295 464 // 找出中标线对应的早高峰的班次对象
296   - var _zb_bcobj = tempLpObj.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
  465 + var oZb_gf_bc = oTempLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
297 466  
298   - // 把所有高峰班次重新构造成一个一个的圈数组，计算对应中标线最近的是第几个路牌
299   - var _tempq_array = [];
300   - var _temp_group;
301   - var _temp_bc;
  467 + // 把所有连班路牌高峰班次重新构造成一个一个的圈数组，计算对应中标线最近的是第几个路牌
  468 + // 中标线和上标线一样在连班路牌上
  469 + var aTempq = [];
  470 + var oTempq;
  471 + var oTempb;
302 472 var i;
  473 + var oLp;
  474 +
  475 + var aLbIndexes = []; // 连班的路牌索引
303 476 for (i = 0; i < _internalLpArray.length; i++) {
304   - _temp_bc = _internalLpArray[i].getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
305   - if (_temp_bc.isUp() == _qIsUp) {
306   - _temp_group = new InternalGroupObj(_internalLpArray[i], _qIsUp, _temp_bc, undefined);
  477 + if (_internalLpArray[i].isBxLb()) {
  478 + aLbIndexes.push(i);
  479 + }
  480 + }
  481 +
  482 + for (i = 0; i < aLbIndexes.length; i++) {
  483 + oLp = _internalLpArray[aLbIndexes[i]];
  484 +
  485 + oTempb = oLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
  486 + if (oTempb.isUp() == _qIsUp) {
  487 + oTempq = new InternalGroupObj(oLp, _qIsUp, oTempb, undefined);
307 488 } else {
308   - _temp_group = new InternalGroupObj(_internalLpArray[i], _qIsUp, undefined, _temp_bc);
  489 + oTempq = new InternalGroupObj(oLp, _qIsUp, undefined, oTempb);
309 490 }
310   - _tempq_array.push(_temp_group);
  491 + aTempq.push(oTempq);
  492 +
311 493 }
312 494  
313   - var _ttindex_ = tempLpObj.getgetQBcIndexWithFcTimeFromGroupArray(
314   - _zb_bcobj.getFcTimeObj(),
315   - _tempq_array,
  495 + var aTtindex = oTempLp.getgetQBcIndexWithFcTimeFromGroupArray(
  496 + oZb_gf_bc.getFcTimeObj(),
  497 + aTempq,
316 498 true,
317 499 true
318 500 );
319   - _zbx_lpIndex = _ttindex_[0]; // 中标线放在第几个路牌
320   - tempLpObj.setLp(_lpArray[_zbx_lpIndex]); // 设置原始路牌对象
321   - tempLpObj.setVerticalMinIntervalTime( // 设置纵向最小发车间隔
322   - _internalLpArray[_zbx_lpIndex].getVerticalMinIntervalTime()
323   - );
324 501  
325   - // 注意：因为中标线很横向创建的，而高峰的替换路牌的班次班次是纵向间隔创建的
326   - // 做法1：直接把中标线数据替换到指定路牌位置
327   - // TODO：由初始化方法1，初始化方法2得到的2个高峰的班次会被中标线对应班次覆盖
328   - // TODO：目前使用中标线的班次覆盖，以后相互动态调整
329   - // _internalLpArray[_zbx_lpIndex] = tempLpObj;
  502 + _iZbx_lpIndex = aLbIndexes[aTtindex[0]]; // 中标线放在第几个路牌
  503 + oTempLp.setLp(_lpArray[_iZbx_lpIndex]); // 设置原始路牌对象
  504 + oTempLp._$_aVerticalIntervalTime = _internalLpArray[_iZbx_lpIndex]._$_aVerticalIntervalTime; // 设置纵向最小发车间隔
  505 + oTempLp.setBxLb(_internalLpArray[_iZbx_lpIndex].isBxLb());
  506 + oTempLp.setBxFb(_internalLpArray[_iZbx_lpIndex].isBxFb());
  507 + oTempLp.setBxFb5_2(_internalLpArray[_iZbx_lpIndex].isBxFb5_2());
330 508  
331   - // 做法2：将中标线除头班次外所有班次用间隔法重新创建替换
332   - var iTempIndex = 0;
  509 + // 修正除了第一个班次外，其余其他班次
  510 + var iBcindex = 0;
333 511 for (i = 1; i < _qCount; i++) {
334   - while (iTempIndex <= 1) {
335   - _temp_bc = tempLpObj.getBc(i, iTempIndex);
336   - if (_temp_bc) { // 中标线存在此路牌，才替换
337   - tempLpObj.setBc(
338   - i, iTempIndex,
339   - _generateBc(_zbx_lpIndex, i , iTempIndex)
340   - );
  512 + while (iBcindex <= 1) {
  513 + if (oTempLp.getBc(i, iBcindex)) { // 替换存在的班次
  514 + oTempLp.setBc(i, iBcindex, _fnGenerateBc(_iZbx_lpIndex, i, iBcindex));
341 515 }
342   -
343   - iTempIndex ++;
  516 + iBcindex ++;
344 517 }
345   - iTempIndex = 0;
346   -
  518 + iBcindex = 0;
347 519 }
348   - _internalLpArray[_zbx_lpIndex] = tempLpObj;
349 520  
350   - console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
351   - console.log("中标线对应第" + (_zbx_lpIndex + 1) + "个路牌");
352   - console.log("//---------------- 行车计划，初始化方法3 end ----------------//");
  521 + _internalLpArray[_iZbx_lpIndex] = oTempLp;
353 522  
354   - };
  523 + console.log("中标线对应第" + (_iZbx_lpIndex + 1) + "个路牌");
355 524  
356   - //----------------------- 初始化方法4，以及计算关联的内部变量 ----------------//
357   - var _bx_lb_lpcount; // 连班路牌数
358   - var _bx_5_2_fb_lpcount; // 5休2分班路牌数
359   - var _bx_other_fb_lpcount; // 其他分班路牌数
  525 + console.log("//---------------- 行车计划，初始化方法4 end ----------------//");
  526 + };
360 527  
361   - var _initFun4 = function() { // 初始化方法4
362   - // 总共车辆数（高峰最大车辆数）
363   - var cls = _paramObj.calcuClzx();
364   - // 低谷最少配车（连班车数量）
365   - var dgminpc = Math.round(_paramObj.calcuTroughZzsj() / _paramObj.getTroughMaxFcjx());
366   - // 加班车路牌数（做5休2的路牌数）
367   - var _5_2_lpes = _paramObj.getJBLpes();
  528 + //-------------------- 重要的内部方法 -----------------------//
  529 + /**
  530 + * 核心方法，利用路牌间隔纵向生成班次。
  531 + * @param iLpindex 路牌索引
  532 + * @param iQindex 圈索引
  533 + * @param iBcindex 班次索引
  534 + * @returns object InternalBcObj，失败 false
  535 + */
  536 + var _fnGenerateBc = function(iLpindex, iQindex, iBcindex) {
  537 + // 以上标线为起始点，使用路牌在不同圈，班次索引的发车间隔，计算班次
  538 + // 注意，发车间隔是指下一个班次应该距离当前班次间隔，是从下往上的
368 539  
369   - // 做些简单的验证
370   - if (cls < dgminpc) {
371   - alert("总配车数小于低谷最小配车");
372   - throw "总配车数小于低谷最小配车";
  540 + // 1、参数验证
  541 + if (iLpindex == 0) { // 上标线的班次不需要生成
  542 + return false;
373 543 }
374   - if (dgminpc < 2) {
375   - alert("连班路牌小于2，办不到啊");
376   - throw "连班路牌小于2，办不到啊";
  544 +
  545 + // 2、计算间隔
  546 + var i;
  547 + var oLp;
  548 + var iTime = 0;
  549 + for (i = 0; i < iLpindex; i++) {
  550 + oLp = _internalLpArray[i];
  551 + iTime += oLp.fnGetVerticalIntervalTime(iQindex, iBcindex);
377 552 }
378   - if (cls - dgminpc < _5_2_lpes) {
379   - alert("总分班路牌数小于加班路牌数");
380   - throw "总分班路牌数小于加班路牌数";
  553 +
  554 + // 3、生成班次
  555 + var _oKsbc = _internalLpArray[0].getBc(iQindex, iBcindex);
  556 + if (!_oKsbc) {
  557 + return false;
381 558 }
  559 + var _oKssj = _paramObj.addMinute(_oKsbc.getFcTimeObj(), iTime);
  560 + var _oBc = _factory.createBcObj(
  561 + _internalLpArray[iLpindex],
  562 + "normal", _oKsbc.isUp(),
  563 + 1, _oKssj, _paramObj);
382 564  
383   - _bx_lb_lpcount = dgminpc;
384   - _bx_5_2_fb_lpcount = _5_2_lpes;
385   - _bx_other_fb_lpcount = cls - dgminpc - _5_2_lpes;
  565 + return _oBc;
386 566  
387   - console.log("//---------------- 行车计划，初始化方法4 start ----------------//");
388   - console.log("连班路牌数:" + _bx_lb_lpcount);
389   - console.log("5休2分班路牌数:" + _bx_5_2_fb_lpcount);
390   - console.log("其他分班路牌数:" + _bx_other_fb_lpcount);
391   - console.log("//---------------- 行车计划，初始化方法4 end ----------------//");
392 567 };
393 568  
394   - //-------------------- 重要的内部方法 -----------------------//
  569 + /**
  570 + * 核心方法，在指定位置生成班次并添加到路牌指定位置中。
  571 + * @param lpIndex 第几个路牌
  572 + * @param qIndex 第几圈
  573 + * @param bcIndex 第几个班次
  574 + */
  575 + var _fnGenerateBcAndSetBc = function(lpIndex, qIndex, bcIndex) {
  576 + var _bcObj = _fnGenerateBc(lpIndex, qIndex, bcIndex);
  577 + if (_bcObj) {
  578 + _internalLpArray[lpIndex].setBc(qIndex, bcIndex, _bcObj);
  579 + }
  580 + };
  581 +
  582 +
395 583 /**
396 584 * 在指定位置生成班次（内部重要方法）。
397 585 * @param lpIndex 第几个路牌
... ... @@ -594,15 +782,15 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
594 782 /**
595 783 * 初始化数据，使用标线初始化
596 784 */
597   - initDataWithBxLayout: function() {
  785 + fnInitDataWithBxLayout: function() {
598 786 // 初始化布局1，构造上标线，计算圈数，把上标线数据放入第一个路牌中
599   - _initFun1();
600   - // 初始化布局2，从上标线的某个班次开始，构造所有路牌的早高峰班次，晚高峰班次
601   - _initFun2();
602   - // 初始化布局3，构造中标线，根据高峰班次，将中标线放入合适的路牌中
603   - _initFun3();
604   - // 初始化4，计算连班，分班相关路牌数
605   - _initFun4();
  787 + _fnInitFun1();
  788 + // 初始化布局2，从上标线的某个班次开始，构造所有路牌的早高峰班次，晚高峰班次，计算路牌在各个圈中的间隔
  789 + _fnInitFun2();
  790 + // 初始化布局3，计算连班分班路牌分布
  791 + _fnInitFun3();
  792 + // 初始化布局4，计算中标线位置
  793 + _fnInitFun4();
606 794  
607 795 },
608 796  
... ... @@ -614,75 +802,75 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
614 802 * @param isZgf 是否早高峰
615 803 * @param isUp 是否上行
616 804 */
617   - adjustGfbc : function(isZgf, isUp) {
618   - var startTime; // 开始时间
619   - var endTime; // 结束时间
620   - var startBcIndex; // 开始班次索引
621   - var endBcIndex; // 结束班次索引
622   -
623   - startTime = isZgf ? _paramObj.getMPeakStartTimeObj() : _paramObj.getEPeakStartTimeObj();
624   - endTime = isZgf ? _paramObj.getMPeakEndTimeObj() : _paramObj.getEPeakEndTimeObj();
625   -
626   - startBcIndex = _findUpClosedBcIndexWithTime(startTime, isUp);
627   - endBcIndex = _findDownClosedBcIndexWithTime(endTime, isUp);
628   -
629   - var _lpIndex;
630   - var _qIndex;
631   - var _bcIndex;
632   - var _qInternelCount; // 高峰时间段中间包含的圈数
  805 + fnAdjustGfbc : function(isZgf, isUp) {
  806 + var oStartTime; // 开始时间
  807 + var oEndTime; // 结束时间
  808 + var iStartBcIndex; // 开始班次索引
  809 + var iEndBcIndex; // 结束班次索引
  810 +
  811 + oStartTime = isZgf ? _paramObj.getMPeakStartTimeObj() : _paramObj.getEPeakStartTimeObj();
  812 + oEndTime = isZgf ? _paramObj.getMPeakEndTimeObj() : _paramObj.getEPeakEndTimeObj();
  813 +
  814 + aStartBcIndex = _findUpClosedBcIndexWithTime(oStartTime, isUp);
  815 + aEndBcIndex = _findDownClosedBcIndexWithTime(oEndTime, isUp);
  816 +
  817 + var iLpIndex;
  818 + var iQIndex;
  819 + var iBcIndex;
  820 + var iQInternelCount; // 高峰时间段中间包含的圈数
633 821 var i;
634 822 var j;
635 823  
636   - var _lp;
  824 + var oLp;
637 825  
638   - if (startBcIndex && endBcIndex) {
639   - _lpIndex = startBcIndex[0];
640   - _qIndex = startBcIndex[1];
641   - _bcIndex = startBcIndex[2];
  826 + if (aStartBcIndex && aEndBcIndex) {
  827 + iLpIndex = aStartBcIndex[0];
  828 + iQIndex = aStartBcIndex[1];
  829 + iBcIndex = aStartBcIndex[2];
642 830  
643 831 // 处理头
644 832 // 删除头部多余班次
645   - for (j = 0; j < _lpIndex; j++) {
646   - _lp = _internalLpArray[j];
647   - if (_lp.isBxFb() && _lp.getBc(_qIndex, _bcIndex)) {
648   - _lp.removeBc(_qIndex, _bcIndex);
  833 + for (j = 0; j < iLpIndex; j++) {
  834 + oLp = _internalLpArray[j];
  835 + if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
  836 + oLp.removeBc(iQIndex, iBcIndex);
649 837 }
650 838 }
651 839  
652   - for (j = _lpIndex; j < _internalLpArray.length; j++) {
653   - _lp = _internalLpArray[j];
654   - if (!_lp.getBc(_qIndex, _bcIndex)) {
655   - _generateBcAndSetBc(j, _qIndex, _bcIndex);
  840 + for (j = iLpIndex; j < _internalLpArray.length; j++) {
  841 + oLp = _internalLpArray[j];
  842 + if (!oLp.getBc(iQIndex, iBcIndex)) {
  843 + _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
656 844 }
657 845 }
658 846  
659 847 // 处理中间
660   - _qInternelCount = endBcIndex[1] - startBcIndex[1] - 1;
661   - for (i = 1; i <= _qInternelCount; i++) {
662   - _lp = _internalLpArray[_qIndex + i];
663   - if (!_lp.getBc(_qIndex + i, _bcIndex)) {
664   - _generateBcAndSetBc(i, _qIndex + i, _bcIndex);
  848 + iQInternelCount = aEndBcIndex[1] - aStartBcIndex[1] - 1;
  849 + for (i = 1; i <= iQInternelCount; i++) {
  850 + oLp = _internalLpArray[iQIndex + i];
  851 + if (!oLp.getBc(iQIndex + i, iBcIndex)) {
  852 + _fnGenerateBcAndSetBc(i, iQIndex + i, iBcIndex);
665 853 }
666 854 }
667 855  
668 856 // 处理尾部
669   - _lpIndex = endBcIndex[0];
670   - _qIndex = endBcIndex[1];
671   - _bcIndex = endBcIndex[2];
  857 + iLpIndex = aEndBcIndex[0];
  858 + iQIndex = aEndBcIndex[1];
  859 + iBcIndex = aEndBcIndex[2];
672 860  
673 861 // 删除尾部多余的班次
674   - for (j = _lpIndex; j < _internalLpArray.length; j++) {
675   - _lp = _internalLpArray[j];
676   - if (_lp.isBxFb() && _lp.getBc(_qIndex, _bcIndex)) {
677   - _lp.removeBc(_qIndex, _bcIndex);
  862 + for (j = iLpIndex; j < _internalLpArray.length; j++) {
  863 + oLp = _internalLpArray[j];
  864 + if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
  865 + oLp.removeBc(iQIndex, iBcIndex);
678 866 }
679 867 }
680 868  
681   - if (startBcIndex[1] != endBcIndex[1]) { // 指定时间范围跨圈
682   - for (j = 0; j < _lpIndex; j++) {
683   - _lp = _internalLpArray[j];
684   - if (!_lp.getBc(_qIndex, _bcIndex)) {
685   - _generateBcAndSetBc(j, _qIndex, _bcIndex);
  869 + if (aStartBcIndex[1] != aEndBcIndex[1]) { // 指定时间范围跨圈
  870 + for (j = 0; j < iLpIndex; j++) {
  871 + oLp = _internalLpArray[j];
  872 + if (!oLp.getBc(iQIndex, iBcIndex)) {
  873 + _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
686 874 }
687 875 }
688 876 } else {
... ... @@ -698,7 +886,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
698 886 * 早高峰7:45分以前出场运营，
699 887 * 晚高峰16:10分以前出场运营
700 888 */
701   - calcuLpBc_yy: function() {
  889 + fnCalcuLpBc_yy: function() {
702 890 // 补班次的时候，针对的是分班班型
703 891 var i;
704 892 var _oLp;
... ... @@ -731,7 +919,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
731 919 _paramObj.getUpOutTime();
732 920 }
733 921 if (_zgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
734   - _generateBcAndSetBc(
  922 + _fnGenerateBcAndSetBc(
735 923 i,
736 924 _bIndex == 0 ? _qIndex - 1 : _qIndex,
737 925 _bIndex == 0 ? 1 : 0
... ... @@ -758,7 +946,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
758 946 _paramObj.getUpOutTime();
759 947 }
760 948 if (_wgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
761   - _generateBcAndSetBc(
  949 + _fnGenerateBcAndSetBc(
762 950 i,
763 951 _bIndex == 0 ? _qIndex - 1 : _qIndex,
764 952 _bIndex == 0 ? 1 : 0
... ... @@ -778,7 +966,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
778 966 * 5、加班次时都是往车次链前方加
779 967 * 6、如果前面车次链不能再加班次了，从后面车次链加
780 968 */
781   - calcuLpBx_5_2: function() {
  969 + fnCalcuLpBx_5_2: function() {
782 970 // 计算做5休2班型所需的班次数
783 971 var iBxBcount = _aBxDesc[6].fBcCount;
784 972 if (iBxBcount - Math.floor(iBxBcount) > 0.7) {
... ... @@ -808,22 +996,22 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
808 996 iQindex = oBcChain1.s_b == 0 ? oBcChain1.s_q - 1 : oBcChain1.s_q;
809 997 iBindex = oBcChain1.s_b == 0 ? 1 : 0;
810 998 // 往车次链往前不能加，就往后加
811   - if (_generateBc(i, iQindex, iBindex)) {
812   - _generateBcAndSetBc(i, iQindex, iBindex);
  999 + if (_fnGenerateBc(i, iQindex, iBindex)) {
  1000 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
813 1001 } else {
814 1002 iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
815 1003 iBindex = oBcChain1.e_b == 0 ? 1 : 0;
816   - _generateBcAndSetBc(i, iQindex, iBindex);
  1004 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
817 1005 }
818 1006  
819 1007 } else if (oBcChain1.bcount > oBcChain2.bcount) {
820 1008 iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
821 1009 iBindex = oBcChain2.s_b == 0 ? 1 : 0;
822   - _generateBcAndSetBc(i, iQindex, iBindex);
  1010 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
823 1011 } else {
824 1012 iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
825 1013 iBindex = oBcChain2.s_b == 0 ? 1 : 0;
826   - _generateBcAndSetBc(i, iQindex, iBindex);
  1014 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
827 1015 }
828 1016 }
829 1017 }
... ... @@ -835,7 +1023,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
835 1023 * 补其他分班班型班次。
836 1024 * 从车次链的后面开始加
837 1025 */
838   - calcuLpBx_other: function() {
  1026 + fnCalcuLpBx_other: function() {
839 1027 // TODO：暂时使用做2休1的班型
840 1028 // 计算做5休2班型所需的班次数
841 1029 var iBxBcount = _aBxDesc[4].fBcCount;
... ... @@ -865,15 +1053,15 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
865 1053 if (oBcChain1.bcount < oBcChain2.bcount) {
866 1054 iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
867 1055 iBindex = oBcChain1.e_b == 0 ? 1 : 0;
868   - _generateBcAndSetBc(i, iQindex, iBindex);
  1056 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
869 1057 } else if (oBcChain1.bcount > oBcChain2.bcount) {
870 1058 iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
871 1059 iBindex = oBcChain2.e_b == 0 ? 1 : 0;
872   - _generateBcAndSetBc(i, iQindex, iBindex);
  1060 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
873 1061 } else {
874 1062 iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
875 1063 iBindex = oBcChain2.e_b == 0 ? 1 : 0;
876   - _generateBcAndSetBc(i, iQindex, iBindex);
  1064 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
877 1065 }
878 1066 }
879 1067 }
... ... @@ -886,255 +1074,106 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
886 1074 * 1、上标线，中标线中间的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向上标线起始班次靠拢
887 1075 * 2、中标线以下的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向中标线起始班次靠拢
888 1076 */
889   - calcuLpBx_lb: function() {
  1077 + fnCalcuLpBx_lb: function() {
890 1078 // 补充连班的班次，参照上标线，中标线补充不足的班次
891   - var _zgffcsj; // 早高峰发车时间
892   - var _etsj = // 结束时间
  1079 +
  1080 + var aLbLpindexes = []; // 除上标线，中标线的连班路牌索引
  1081 + var i;
  1082 + for (i = 0; i < _internalLpArray.length; i++) {
  1083 + if (_internalLpArray[i].isBxLb() && i != 0 && i != _iZbx_lpIndex) {
  1084 + aLbLpindexes.push(i);
  1085 + }
  1086 + }
  1087 +
  1088 + var oEndsj = // 结束时间
893 1089 _paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj()) ?
894 1090 _paramObj.getDownLastDTimeObj() :
895 1091 _paramObj.getUpLastDtimeObj();
896 1092  
897   - var _lp;
898   - var _minbcPos;
899   - var _bcObj;
900   - var i;
  1093 + var oLp;
  1094 + var aMinbcPos;
  1095 + var oBc;
901 1096 var j;
902 1097 var iTempBcIndex;
903   - for (i = 0; i < _internalLpArray.length; i++) {
904   - _lp = _internalLpArray[i];
905   - if (_lp.isBxLb() && i != 0 && i != _zbx_lpIndex) {
906   - _minbcPos = _lp.getMinBcObjPosition();
907   -
908   - // 使用纵向分隔补充班次
909   - iTempBcIndex = _minbcPos[1] == 0 ? 1 : 0;
910   - j = iTempBcIndex == 0 ? _minbcPos[0] + 1 : _minbcPos[0];
911   - for (; j < _qCount; j++) {
912   - while (iTempBcIndex <= 1) {
913   - _bcObj = _generateBc(i, j, iTempBcIndex);
914   - if (_bcObj && _bcObj.getFcTimeObj().isBefore(_etsj) && _bcObj.getArrTimeObj().isBefore(_etsj)) {
915   - _lp.setBc(j, iTempBcIndex, _bcObj);
916   - }
917 1098  
918   - iTempBcIndex++;
  1099 + // 1、从最小班次开始，往后补充班次
  1100 + for (i = 0; i < aLbLpindexes.length; i++) {
  1101 + oLp = _internalLpArray[aLbLpindexes[i]];
  1102 +
  1103 + // 最小班次索引
  1104 + aMinbcPos = oLp.getMinBcObjPosition();
  1105 + // 使用纵向分隔补充班次，从最小班次向后补
  1106 + iTempBcIndex = aMinbcPos[1] == 0 ? 1 : 0;
  1107 + j = iTempBcIndex == 0 ? aMinbcPos[0] + 1 : aMinbcPos[0];
  1108 +
  1109 + while (j < _qCount) {
  1110 + while (iTempBcIndex <= 1) {
  1111 + oBc = _fnGenerateBc(aLbLpindexes[i], j, iTempBcIndex);
  1112 + if (oBc &&
  1113 + oBc.getFcTimeObj().isBefore(oEndsj) &&
  1114 + oBc.getArrTimeObj().isBefore(oEndsj)) {
  1115 + oLp.setBc(j, iTempBcIndex, oBc);
919 1116 }
920   - iTempBcIndex = 0;
921   -
  1117 + iTempBcIndex++;
922 1118 }
923   -
924   - //_bcObj = _lp.getBc(_minbcPos[0], _minbcPos[1]);
925   -
926   - //_zgffcsj = _bcObj.getFcTimeObj();
927   - //// 重新初始化连班班型班次
928   - //_lp.initDataFromTimeToTime(
929   - // _zgffcsj,
930   - // _etsj,
931   - // _bcObj.isUp(),
932   - // _minbcPos[0],
933   - // _paramObj,
934   - // _factory
935   - //);
  1119 + iTempBcIndex = 0;
  1120 + j++;
936 1121 }
  1122 +
937 1123 }
938 1124  
  1125 + // 2、上标线中标线之间的路牌，从最小的班次往前补充班次
  1126 +
939 1127 // 还要补充缺失的班次，差上标线几个班次要往前补上
940   - var _bccount;
941   - var _qIndex;
942   - var _bIndex;
  1128 + var iBccount;
  1129 + var iQindex;
  1130 + var iBindex;
943 1131 // 补上标线到中标线之间的连班路牌的班次
944   - for (i = 0; i < _zbx_lpIndex; i++) {
945   - _lp = _internalLpArray[i];
946   - if (_lp.isBxLb() && i != 0 && i != _zbx_lpIndex) {
947   - _minbcPos = _lp.getMinBcObjPosition();
948   - _qIndex = _minbcPos[0];
949   - _bIndex = _minbcPos[1];
950   - _bccount = (_qIndex - 1) * 2 + _bIndex; // 距离上标线起始站点差几个班次
951   - for (j = 0; j < _bccount; j++) {
952   - if (_bIndex == 0) {
953   - _qIndex --;
954   - _bIndex = 1;
955   - _generateBcAndSetBc(i, _qIndex, _bIndex);
956   - } else if (_bIndex == 1) {
957   - _bIndex --;
958   - _generateBcAndSetBc(i, _qIndex, _bIndex);
  1132 + for (i = 0; i < aLbLpindexes.length; i++) {
  1133 + if (aLbLpindexes[i] > 0 && aLbLpindexes[i] < _iZbx_lpIndex) {
  1134 + oLp = _internalLpArray[aLbLpindexes[i]];
  1135 + aMinbcPos = oLp.getMinBcObjPosition();
  1136 + iQindex = aMinbcPos[0];
  1137 + iBindex = aMinbcPos[1];
  1138 + iBccount = (iQindex - 1) * 2 + iBindex; // 距离上标线起始站点差几个班次
  1139 + for (j = 0; j < iBccount; j++) {
  1140 + if (iBindex == 0) {
  1141 + iQindex --;
  1142 + iBindex = 1;
  1143 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1144 + } else if (iBindex == 1) {
  1145 + iBindex --;
  1146 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
959 1147 }
960 1148 }
961   - }
962   - }
963   - // 补中标线以下的连班路牌的班次
964   - for (i = _zbx_lpIndex; i < _internalLpArray.length; i++) {
965   - _lp = _internalLpArray[i];
966   - if (_lp.isBxLb() && i != 0 && i != _zbx_lpIndex) {
967   - _minbcPos = _lp.getMinBcObjPosition();
968   - _qIndex = _minbcPos[0];
969   - _bIndex = _minbcPos[1];
970   - _bccount = (_qIndex - 0) * 2 + _bIndex - 1; // 距离上标线起始站点差几个班次
971   - for (j = 0; j < _bccount; j++) {
972   - if (_bIndex == 0) {
973   - _qIndex --;
974   - _bIndex = 1;
975   - _generateBcAndSetBc(i, _qIndex, _bIndex);
976   - } else if (_bIndex == 1) {
977   - _bIndex --;
978   - _generateBcAndSetBc(i, _qIndex, _bIndex);
979   - }
980   - }
981   - }
982   - }
983   -
984   - },
985   -
986   - /**
987   - * 计算每个路牌的班型及工时对应的圈数。
988   - * 1、将连班，分班路牌分配到各个路牌上（分隔法），上标线，中标线上连班路牌
989   - * 2、确定班型的工时，其中连班路牌的工时由上标线，中标线确定好了，5休2路牌工时也确定了，
990   - * 其余分班路牌的工时由高峰低谷最大，最小发车间隔计算
991   - */
992   - calcuLpBx_fg: function() {
993   - // 间隔法
994   -
995   - //--------------------------- 1、间隔法分隔连班路牌 ----------------------//
996   -
997   - // 除去上标线，中标线的连班路牌个数
998   - var _lblbcount = _bx_lb_lpcount - 2;
999   - // 计算由标线隔开的两个区域的路牌数比率
1000   - var _p1 = (_zbx_lpIndex + 1) / (_internalLpArray.length + 1);
1001   - var _p2 = (_internalLpArray.length - _zbx_lpIndex) / (_internalLpArray.length + 1);
1002   - var _p1_lpcount = _lblbcount * _p1;
1003   - var _p2_lpcount = _lblbcount * _p2;
1004   - if (parseInt(_p1_lpcount) != _p1_lpcount) { // 没有整除
1005   - _p1_lpcount = Math.floor(_p1_lpcount);
1006   - _p2_lpcount = Math.floor(_p2_lpcount) + 1;
1007   - }
1008 1149  
1009   - // 设定第一个区域的连班路牌
1010   - var i;
1011   - var _count = _p1_lpcount + 1;
1012   - var _c1 = Math.floor(_zbx_lpIndex / _count);
1013   - var _c2 = _zbx_lpIndex % _count;
1014   - var _c2_start_index;
1015   - for (i = 1; i <= _count - _c2; i++) {
1016   - _internalLpArray[(i - 1) * _c1].setBxLb(true);
1017   - _internalLpArray[(i - 1) * _c1].setBxDesc("连班");
1018   - _c2_start_index = (i - 1) * _c1;
1019   - }
1020   - for (i = 1; i <= _c2; i++) {
1021   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxLb(true);
1022   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxDesc("连班");
1023   - }
1024   -
1025   - // 设定第二个区域的连班路牌
1026   - _count = _p2_lpcount + 1;
1027   - _c1 = Math.floor((_internalLpArray.length - _zbx_lpIndex - 1) / _count);
1028   - _c2 = (_internalLpArray.length - _zbx_lpIndex - 1) % _count;
1029   - for (i = 1; i <= _count - _c2; i++) {
1030   - _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxLb(true);
1031   - _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxFb(false);
1032   - _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxFb5_2(false);
1033   - _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxDesc("连班");
1034   - _c2_start_index = (i - 1) * _c1 + _zbx_lpIndex;
1035   - }
1036   - for (i = 1; i <= _c2; i++) {
1037   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxLb(true);
1038   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxFb(false);
1039   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxFb5_2(false);
1040   - _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxDesc("连班");
1041   - }
1042   -
1043   - //---------------------------- 2、分隔法，分隔分班路牌 -------------------------//
1044   -
1045   - // 设定分班路牌
1046   - var notlbIndexes = []; // 去除连班的路牌index列表
1047   - for (i = 0; i < _internalLpArray.length; i++) {
1048   - if (!_internalLpArray[i].isBxLb()) {
1049   - notlbIndexes.push(i);
1050   - }
1051   - }
1052   - // 获取离中标线最近的分班路牌索引
1053   - var _temp_fg_index;
1054   - for (i = 0; i < notlbIndexes.length; i++) {
1055   - if (notlbIndexes[i] == _zbx_lpIndex - 1) {
1056   - _temp_fg_index = i;
1057   - break;
1058 1150 }
1059   - }
1060 1151  
1061   - // 使用上面的分隔比率，分隔其他班型
1062   - _p1_lpcount = _bx_5_2_fb_lpcount * _p1;
1063   - _p2_lpcount = _bx_5_2_fb_lpcount * _p2;
1064   - if (parseInt(_p1_lpcount) != _p1_lpcount) { // 没有整除
1065   - _p1_lpcount = Math.floor(_p1_lpcount);
1066   - _p2_lpcount = Math.floor(_p2_lpcount) + 1;
1067   - }
1068   - // 第一个区域
1069   - _count = _p1_lpcount;
1070   - _c1 = Math.floor(_temp_fg_index / _count);
1071   - _c2 = _temp_fg_index % _count;
1072   - for (i = 1; i <= _count - _c2; i++) {
1073   - _internalLpArray[notlbIndexes[(i - 1) * _c1]].setBxLb(false);
1074   - _internalLpArray[notlbIndexes[(i - 1) * _c1]].setBxFb(true);
1075   - _internalLpArray[notlbIndexes[(i - 1) * _c1]].setBxFb5_2(true);
1076   - _internalLpArray[notlbIndexes[(i - 1) * _c1]].setBxDesc("5休2分班");
1077   - _c2_start_index = (i - 1) * _c1;
1078   - }
1079   - for (i = 1; i <= _c2; i++) {
1080   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxLb(false);
1081   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxFb(true);
1082   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxFb5_2(true);
1083   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxDesc("5休2分班");
1084   - }
1085   - // 第二个区域
1086   - _count = _p2_lpcount;
1087   - _c1 = Math.floor((notlbIndexes.length - _temp_fg_index - 1) / _count);
1088   - _c2 = (notlbIndexes.length - _temp_fg_index - 1) % _count;
1089   - for (i = 1; i <= _count - _c2; i++) {
1090   - _internalLpArray[notlbIndexes[(i - 1) * _c1 + _temp_fg_index + 1]].setBxLb(false);
1091   - _internalLpArray[notlbIndexes[(i - 1) * _c1 + _temp_fg_index + 1]].setBxFb(true);
1092   - _internalLpArray[notlbIndexes[(i - 1) * _c1 + _temp_fg_index + 1]].setBxFb5_2(true);
1093   - _internalLpArray[notlbIndexes[(i - 1) * _c1 + _temp_fg_index + 1]].setBxDesc("5休2分班");
1094   - _c2_start_index = (i - 1) * _c1 + _temp_fg_index + 1;
1095   - }
1096   - for (i = 1; i <= _c2; i++) {
1097   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxLb(false);
1098   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxFb(true);
1099   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxFb5_2(true);
1100   - _internalLpArray[notlbIndexes[_c2_start_index + i * (_c1 + 1)]].setBxDesc("5休2分班");
1101 1152 }
1102 1153  
1103   - //-------------------------- 3、余下班次就是5休2类型 ----------------------//
1104   -
1105   - for (i = 0; i < notlbIndexes.length; i++) {
1106   - if (!_internalLpArray[notlbIndexes[i]].isBxFb5_2()) {
1107   - _internalLpArray[notlbIndexes[i]].setBxLb(false);
1108   - _internalLpArray[notlbIndexes[i]].setBxFb(true);
1109   - _internalLpArray[notlbIndexes[i]].setBxFb5_2(false);
1110   - _internalLpArray[notlbIndexes[i]].setBxDesc("其他分班");
1111   - }
1112   - }
  1154 + // 3、中标线之后的路牌，从最小的班次往前补充班次
1113 1155  
1114   - // 测试打印
1115   - var lbIndexes = [];
1116   - for (i = 0; i < _internalLpArray.length; i++) {
1117   - if (_internalLpArray[i].isBxLb()) {
1118   - lbIndexes.push(i);
1119   - }
1120   - }
1121   - console.log("连班路牌indexes=" + lbIndexes);
1122   -
1123   - var _other_fbIndexes = [];
1124   - for (i = 0; i < _internalLpArray.length; i++) {
1125   - if (_internalLpArray[i].isBxFb() && !_internalLpArray[i].isBxFb5_2()) {
1126   - _other_fbIndexes.push(i);
  1156 + // 补中标线以下的连班路牌的班次
  1157 + for (i = 0; i < aLbLpindexes.length; i++) {
  1158 + if (aLbLpindexes[i] > _iZbx_lpIndex) {
  1159 + oLp = _internalLpArray[aLbLpindexes[i]];
  1160 + aMinbcPos = oLp.getMinBcObjPosition();
  1161 + iQindex = aMinbcPos[0];
  1162 + iBindex = aMinbcPos[1];
  1163 + iBccount = (iQindex - 0) * 2 + iBindex - 1; // 距离上标线起始站点差几个班次
  1164 + for (j = 0; j < iBccount; j++) {
  1165 + if (iBindex == 0) {
  1166 + iQindex --;
  1167 + iBindex = 1;
  1168 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1169 + } else if (iBindex == 1) {
  1170 + iBindex --;
  1171 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1172 + }
  1173 + }
1127 1174 }
1128 1175 }
1129   - console.log("其他分班路牌indexes=" + _other_fbIndexes);
1130 1176  
1131   - var _5_2_fbIndexes = [];
1132   - for (i = 0; i < _internalLpArray.length; i++) {
1133   - if (_internalLpArray[i].isBxFb() && _internalLpArray[i].isBxFb5_2()) {
1134   - _5_2_fbIndexes.push(i);
1135   - }
1136   - }
1137   - console.log("5休2分班路牌indexes=" + _5_2_fbIndexes);
1138 1177 },
1139 1178  
1140 1179 /**
... ... @@ -1143,7 +1182,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1143 1182 * 2、从后往前找到与这个班次最匹配的班次的位置（第几个路牌，第几圈，第几个班次），然后覆盖
1144 1183 * 3、从第2步找的位置，往上找与另一个末班车匹配的班次位置，然后覆盖
1145 1184 */
1146   - calcuLastBc: function() {
  1185 + fnCalcuLastBc: function() {
1147 1186 //-------------------- 1、确定末班车早的方向，时间 -----------------------//
1148 1187 var _oLastTime;
1149 1188 var _bLastIsUp;
... ... @@ -1191,7 +1230,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1191 1230 if (_oLp.isBxLb()) {
1192 1231 _oBc = _oLp.getBc(_aBcIndex[1], _aBcIndex[2]);
1193 1232 if (_oBc == undefined) {
1194   - _oBc = _generateBc(i, _aBcIndex[1], _aBcIndex[2]);
  1233 + _oBc = _fnGenerateBc(i, _aBcIndex[1], _aBcIndex[2]);
1195 1234 }
1196 1235 _aBcIndexes.push({
1197 1236 lpIndex: i,
... ... @@ -1240,7 +1279,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1240 1279 _oBcIndex_find.bcIndex == 0 ? 1 : 0
1241 1280 );
1242 1281 if (_oBc == undefined) {
1243   - _oBc = _generateBc(
  1282 + _oBc = _fnGenerateBc(
1244 1283 i,
1245 1284 _oBcIndex_find.bcIndex == 0 ? _oBcIndex_find.qIndex : _oBcIndex_find.qIndex + 1,
1246 1285 _oBcIndex_find.bcIndex == 0 ? 1 : 0
... ... @@ -1294,7 +1333,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1294 1333 /**
1295 1334 * 添加吃饭班次。
1296 1335 */
1297   - calcuEatBc: function() {
  1336 + fnCalcuEatBc: function() {
1298 1337 // 吃午饭时间范围，10:15 到 12:15
1299 1338 // 吃晚饭时间范围，18:00 到 19:00
1300 1339  
... ... @@ -1349,7 +1388,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1349 1388 if (i == aLbIndex.length - 1) {
1350 1389 for (j = aLbIndex[i]; j < _internalLpArray.length; j++) {
1351 1390 oLp = _internalLpArray[j];
1352   - if (oLp.isBxFb()) {
  1391 + if (oLp.isBxFb()) { // 5休2班型不调整
1353 1392 // 修正午饭之后路牌班次的发车时间
1354 1393 oLp.fnAddMinuteToBcFcsj(iLEQIndex, iLEBIndex, iLTime);
1355 1394 oLp.fnAddMinuteToBcFcsj(iDEQIndex, iDEBIndex, iDtime);
... ... @@ -1372,7 +1411,7 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1372 1411 /**
1373 1412 * 补每个路牌的其他班次（进出场，例保班次）。
1374 1413 */
1375   - calcuOtherBc: function() {
  1414 + fnCalcuOtherBc: function() {
1376 1415 var i;
1377 1416 var _lpObj;
1378 1417 var _minBcIndex;
... ... @@ -1399,6 +1438,8 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1399 1438 _minBc.getFcTimeObj(),
1400 1439 _paramObj
1401 1440 ));
  1441 +
  1442 + _maxBc.setArrTimeObj(_paramObj.addMinute(_maxBc.getFcTimeObj(), _maxBc.getBcTime()));
1402 1443 _maxBc.setStopTime(0);
1403 1444 _otherbc.push(_factory.createBcObj(
1404 1445 _lpObj, "in", true, 1,
... ... @@ -1417,6 +1458,20 @@ var InternalScheduleObj = function(paramObj, lpArray, factory) {
1417 1458 },
1418 1459  
1419 1460 /**
  1461 + * 祛除上标线有删除标记的班次。
  1462 + */
  1463 + fnRemoveDelFlagBc: function() {
  1464 + var oLp = _internalLpArray[0];
  1465 + var aMinBcIndex = oLp.getMinBcObjPosition();
  1466 + oLp.removeBc(aMinBcIndex[0], aMinBcIndex[1]);
  1467 +
  1468 + var aMaxBcIndex = oLp.getMaxBcObjPosition();
  1469 + if (oLp.getBc(aMaxBcIndex[0], aMaxBcIndex[1]).fnIsDelFlag()) {
  1470 + oLp.removeBc(aMaxBcIndex[0], aMaxBcIndex[1]);
  1471 + }
  1472 + },
  1473 +
  1474 + /**
1420 1475 * 调整班次纵向间隔（发车时间调整）。
1421 1476 * 1、只调整分班班次的发车时间
1422 1477 * 2、调整每两个连班之间的分班班次组
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/main_v2.js
  View file @3e44b0c
... ... @@ -18,7 +18,7 @@ var Main_v2 = function() {
18 18 var _fcsj = fcTimeObj;
19 19 var _bcsj = paramObj.calcuTravelTime(_fcsj, isUp);
20 20 var _arrsj = paramObj.addMinute(_fcsj, _bcsj);
21   - var _stoptime = paramObj.calcuFixedStopNumber(_arrsj, !isUp);
  21 + var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
22 22 var _tccid = paramObj.getTTinfoId();
23 23 var _ttinfoid = paramObj.getTTinfoId();
24 24 var _xl = paramObj.getXlId();
... ... @@ -151,38 +151,38 @@ var Main_v2 = function() {
151 151  
152 152 // 1、初始化行车计划
153 153 var schedule = new InternalScheduleObj(_paramObj, lpArray, _factory);
154   - schedule.initDataWithBxLayout();
155   - // 2、计算每个路牌的班型及对应工时
156   - schedule.calcuLpBx_fg();
157   - // 3、将连班路牌的班次补足
158   - schedule.calcuLpBx_lb();
  154 + schedule.fnInitDataWithBxLayout();
  155 + // 2、将连班路牌的班次补足
  156 + schedule.fnCalcuLpBx_lb();
159 157  
160   - // 4、修正针对初始化时生成的高峰班次，之前不足的补上，多余的删除
161   - schedule.adjustGfbc(true, true); // 修正上行早高峰
162   - schedule.adjustGfbc(true, false); // 修正下行早高峰
163   - schedule.adjustGfbc(false, true); // 修正上行晚高峰
164   - schedule.adjustGfbc(false, false); // 修正下行晚高峰
  158 + // 3、修正针对初始化时生成的高峰班次，之前不足的补上，多余的删除
  159 + schedule.fnAdjustGfbc(true, true); // 修正上行早高峰
  160 + schedule.fnAdjustGfbc(true, false); // 修正下行早高峰
  161 + schedule.fnAdjustGfbc(false, true); // 修正上行晚高峰
  162 + schedule.fnAdjustGfbc(false, false); // 修正下行晚高峰
165 163  
166   - // 5、按照车辆投入运营要求补充班次
167   - schedule.calcuLpBc_yy();
  164 + // 4、按照车辆投入运营要求补充班次
  165 + schedule.fnCalcuLpBc_yy();
168 166  
169   - // 6、根据班型补充所有的不足班次
170   - schedule.calcuLpBx_5_2();
171   - schedule.calcuLpBx_other();
  167 + // 5、根据班型补充所有的不足班次
  168 + schedule.fnCalcuLpBx_5_2();
  169 + schedule.fnCalcuLpBx_other();
172 170  
173   - // 7、补吃饭班次
174   - schedule.calcuEatBc();
  171 + // 6、补吃饭班次
  172 + schedule.fnCalcuEatBc();
  173 +
  174 + // 7、祛除有删除标记的班次
  175 + schedule.fnRemoveDelFlagBc();
175 176  
176 177 // 8、调整纵向班次间隔
177 178 schedule.fnAdjust_vertical_bc_interval();
178 179 // TODO：横向调整
179 180  
180 181 // 9、确定末班车
181   - schedule.calcuLastBc();
182   -
  182 + schedule.fnCalcuLastBc();
183 183  
184 184 // 10、补进出场例保班次
185   - schedule.calcuOtherBc();
  185 + schedule.fnCalcuOtherBc();
186 186  
187 187 //-------------------- 输出ganut图上的班次，班型描述 ----------------------//
188 188 var gBcData = schedule.fnToGanttBcArray();
... ...