潘钊 / bsth_control · Commits

Commit 14e3a3109cbab5f34c03c43705043d809698dbe8

Authored by 徐烜
1 parent 3e48f68c
build: skipped

时刻表v2.7.15 

1、添加StrategyUtils控制类，控制策略的动态添加删除
2、修改paramadd.html模版，允许重新生成时刻表时，动态选择策略，下拉选择的策略名就是策略函数名，也是内部变量名
3、添加4组发车间隔策略供选择，以下4组
   AdjustTripS1.js 就是之前的第一种调整策略
   AdjustTripS2.js 严格匹配是否可以调整发车间隔（这个速度很慢，暂时不用）
   AdjustTripS3.js 相对于S1严格点，就是如果超出间隔范围，+/-1分钟
   AdjustTripS4.js 使用两阶段平衡，第一阶段使用S1方式平衡，第二阶段找出吃饭时间，周转时间不足的班次，向后拉停站时间补足
Inline Side-by-side
Showing 13 changed files with 4906 additions and 3987 deletions
src/main/resources/static/pages/base/timesmodel/gantt.html
  View file @14e3a31
... ... @@ -152,7 +152,11 @@
152 152 <script src="/pages/base/timesmodel/js/v2/core/InternalGroupObj.js"></script>
153 153 <script src="/pages/base/timesmodel/js/v2/core/InternalLpObj.js"></script>
154 154 <script src="/pages/base/timesmodel/js/v2/core/InternalScheduleObj.js"></script>
155   -<script src="/pages/base/timesmodel/js/v2/AdjustTripStrategy.js"></script>
  155 +<script src="/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS1.js"></script>
  156 +<script src="/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS2.js"></script>
  157 +<script src="/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS3.js"></script>
  158 +<script src="/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS4.js"></script>
  159 +<script src="/pages/base/timesmodel/js/v2/strategy/StrategyUtils.js"></script>
156 160 <script src="/pages/base/timesmodel/js/v2/main_v2.js"></script>
157 161 <script src="/pages/base/timesmodel/js/d3.relationshipgraph.js"></script>
158 162 <script src="/pages/base/timesmodel/js/errorinfo.js"></script>
... ...
src/main/resources/static/pages/base/timesmodel/js/d3.relationshipgraph.js
  View file @14e3a31
... ... @@ -321,7 +321,7 @@ $(&#39;.parambtn&#39;).on(&#39;click&#39;, function() {
321 321 $.get('/pages/base/timesmodel/paramadd.html', function(m){
322 322 $(pjaxContainer).append(m);
323 323 // 规定被选元素要触发的事件。可以使自定义事件（使用 bind() 函数来附加），或者任何标准事件。
324   - $('#paramadd_mobal').trigger('paramAddMobal.show', $_GlobalGraph);
  324 + $('#paramadd_mobal').trigger('paramAddMobal.show', Main_v2);
325 325 });
326 326 });
327 327  
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/ParameterObj.js
  View file @14e3a31
... ... @@ -372,6 +372,13 @@ var ParameterObj = function() {
372 372  
373 373 },
374 374  
  375 + //------------ 获取生成策略函数 ------------//
  376 + fnGetAdjustStrategyId : function() {
  377 + return _formMap.strategy || 'AdjustTripS1';
  378 + },
  379 +
  380 + // TODO：还有其他策略
  381 +
375 382 //------------ 获取首班末班时间 ------------//
376 383 /**
377 384 * 获取上行首班时间对象。
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalBcObj.js
  View file @14e3a31
... ... @@ -140,6 +140,9 @@ InternalBcObj.prototype.setArrTimeObj = function(oTime) {
140 140 InternalBcObj.prototype.getBcTime = function() {
141 141 return this._$_bcsj;
142 142 };
  143 +InternalBcObj.prototype.setBcTime = function(iTime) {
  144 + this._$_bcsj = iTime;
  145 +};
143 146 /**
144 147 * 获取停站时间。
145 148 * @returns int
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalLpObj.js
  View file @14e3a31
... ... @@ -855,113 +855,6 @@ InternalLpObj.prototype.fnAdjustBcInterval = function(iPeakAverStopTime, iTrough
855 855 };
856 856  
857 857 /**
858   - * 调整车次block的班次停站时间，如果不在范围内，调整成平均停站时间。
859   - * @param oParam {ParameterObj} 参数对象
860   - */
861   -InternalLpObj.prototype.fnAdjustBcTime = function(oParam) {
862   - // 获取车次链个数
863   - var iBcChainCount = this.fnGetBcChainCount();
864   -
865   - var i;
866   - var j;
867   - var oBcIndex;
868   - var iQIndex;
869   - var iBcIndex;
870   - var iBcCount;
871   - var oBc;
872   - var oNextBc;
873   -
874   - var iBcStopTime;
875   -
876   - var aRangeStopTime;
877   -
878   - for (i = 0; i < iBcChainCount; i++) {
879   - oBcIndex = this.fnGetBcChainInfo(i);
880   - iQIndex = oBcIndex["s_q"];
881   - iBcIndex = oBcIndex["s_b"];
882   - iBcCount = oBcIndex["bcount"];
883   -
884   - for (j = 0; j < iBcCount - 1; j++) {
885   - oBc = this.getBc(iQIndex, iBcIndex);
886   - oNextBc = this.getBc(
887   - iBcIndex == 0 ? iQIndex : iQIndex + 1,
888   - iBcIndex == 0 ? 1 : 0);
889   -
890   - if (oNextBc.fnIsFirstBc()) { // 如果同一路牌连续2个方向首站班次，都不做处理
891   - // 两个班次都是头班车，则停站时间不考虑范围，直接计算
892   - iBcStopTime = oNextBc.getFcTimeObj().diff(oBc.getArrTimeObj(), "m");
893   - oBc.setStopTime(iBcStopTime);
894   -
895   - } else {
896   - // 获取当前班次的停站时间范围
897   - aRangeStopTime = oParam.calcuTripLayoverTimeRange(
898   - oBc.getArrTimeObj(), oBc.isUp(), oBc.getBcTime()
899   - );
900   - // 获取当前班次停站时间
901   - iBcStopTime = oNextBc.getFcTimeObj().diff(oBc.getArrTimeObj(), "m");
902   -
903   - // 不改变当前班次的行驶时间，修正停站时间和下一个班次的发车时间和停站时间
904   - if (oBc.fnGetEatTime() > 0) {
905   - // 当前班次后有吃饭时间, 则没有停站时间了
906   - oBc.setStopTime(0);
907   - // 修改下一个班次的发车时间，到达时间
908   - oNextBc.setFcTimeObj(oParam.addMinute(
909   - oBc.getArrTimeObj(),
910   - oBc.fnGetEatTime())
911   - );
912   - oNextBc.setArrTimeObj(oParam.addMinute(
913   - oNextBc.getFcTimeObj(),
914   - oParam.calcuTravelTime(
915   - oNextBc.getFcTimeObj(),
916   - oNextBc.isUp())
917   - ));
918   - } else {
919   - if (iBcStopTime >= aRangeStopTime[0] && iBcStopTime<= aRangeStopTime[1]) {
920   - // 在范围内，重新设置以下停站时间
921   - oBc.setStopTime(iBcStopTime);
922   -
923   - } else if (iBcStopTime < aRangeStopTime[0]) {
924   - oBc.setStopTime(aRangeStopTime[0]);
925   - // 修改下一个班次的发车时间，到达时间
926   - oNextBc.setFcTimeObj(oParam.addMinute(
927   - oBc.getArrTimeObj(),
928   - oBc.getStopTime())
929   - );
930   - oNextBc.setArrTimeObj(oParam.addMinute(
931   - oNextBc.getFcTimeObj(),
932   - oParam.calcuTravelTime(
933   - oNextBc.getFcTimeObj(),
934   - oNextBc.isUp())
935   - ));
936   - } else {
937   - oBc.setStopTime(aRangeStopTime[1]);
938   - // 修改下一个班次的发车时间，到达时间
939   - oNextBc.setFcTimeObj(oParam.addMinute(
940   - oBc.getArrTimeObj(),
941   - oBc.getStopTime())
942   - );
943   - oNextBc.setArrTimeObj(oParam.addMinute(
944   - oNextBc.getFcTimeObj(),
945   - oParam.calcuTravelTime(
946   - oNextBc.getFcTimeObj(),
947   - oNextBc.isUp())
948   - ));
949   - }
950   - }
951   - }
952   -
953   -
954   - iBcIndex = iBcIndex == 0 ? 1 : 0;
955   - iQIndex = iBcIndex == 0 ? iQIndex + 1 : iQIndex;
956   -
957   - }
958   -
959   - // 最后一个班次停站时间为0
960   - this.getBc(iQIndex, iBcIndex).setStopTime(0);
961   - }
962   -};
963   -
964   -/**
965 858 * 返回指定班次的上一个班次。
966 859 * @param oBc {moment} 指定班次
967 860 * @returns {object} 上一个班次，如果没有，返回false
... ... @@ -1014,61 +907,104 @@ InternalLpObj.prototype.getPreBc = function(oBc) {
1014 907 };
1015 908  
1016 909 /**
1017   - * 是否能调整班次的发车时间。
1018   - * @param oBc 指定班次
1019   - * @param iStep 修正步长
1020   - * @param oParam 参数对象
  910 + * 通过修改layover时间，修正班次的发车，到达时间。
  911 + * 如果layover时间不符合范围要求，修改成平均时间。
  912 + * @param oParam {ParameterObj} 参数对象
1021 913 */
1022   -InternalLpObj.prototype.isModifyBcFcsj = function(oBc, iStep, oParam) {
1023   - // 获取车次链个数
1024   - var iBcChainCount = this.fnGetBcChainCount();
  914 +InternalLpObj.prototype.fnAdjustBcTime_layover = function(oParam) {
  915 + // 获取车次链个数（连班路牌1个，分班路牌2个）
  916 + var iBlockCount = this.fnGetBcChainCount();
1025 917  
1026 918 var i;
1027 919 var j;
1028   - var oBcIndex;
1029   - var iQIndex;
1030   - var iBcIndex;
1031   - var iBcCount;
1032   - var oPreBc;
  920 + var aTrip; // 每个block关联的trip列表
  921 + var trip; // 当前班次
  922 + var nextTrip; // 下一个班次
  923 + var layOverTime;
  924 + var aLayOverTimeRange;
1033 925  
1034   - var iBcStopTime;
  926 + var oBcIndex;
  927 + var iQIndex; // block开始第几圈缩影
  928 + var iBcIndex; // block开始第几个班次
  929 + var iBcCount; // block的trip数目
1035 930  
1036   - var aRangeStopTime;
1037 931  
1038   - for (i = 0; i < iBcChainCount; i++) {
  932 + for (i = 0; i < iBlockCount; i++) {
  933 + // 获取block关联的trip列表
1039 934 oBcIndex = this.fnGetBcChainInfo(i);
1040 935 iQIndex = oBcIndex["s_q"];
1041 936 iBcIndex = oBcIndex["s_b"];
1042 937 iBcCount = oBcIndex["bcount"];
1043 938  
1044   - oPreBc = this.getPreBc(oBc);
1045   -
1046   - // 如果是第一个班次
1047   - if (!oPreBc) {
1048   - if (oBc.fnIsFirstBc()) { // 如果是方向头班车
1049   - return false;
1050   - } else {
1051   - return true;
1052   - }
  939 + aTrip = [];
  940 + for (j = 0; j < iBcCount; j++) {
  941 + aTrip.push(this.getBc(iQIndex, iBcIndex));
  942 + iBcIndex = iBcIndex == 0 ? 1 : 0;
  943 + iQIndex = iBcIndex == 0 ? iQIndex + 1 : iQIndex;
1053 944 }
1054 945  
1055   - if (oPreBc.fnGetEatTime() > 0) { // 如果是吃饭班次，不能修改发车时间
1056   - return false;
  946 + if (aTrip.length < 2) {
  947 + // 两个trip一起处理，只有1个trip的block不处理
  948 + continue;
1057 949 }
  950 + // 迭代block，处理trip的发车，到达，停站时间
  951 + for (j = 0; j < aTrip.length - 1; j++) {
  952 + trip = aTrip[j];
  953 + nextTrip = aTrip[j + 1];
  954 +
  955 + if (trip.fnIsFirstBc() && nextTrip.fnIsFirstBc()) {
  956 + // 如果两个方向的首班车都在一个block上
  957 + // 则停站时间不考虑范围，直接发车时间-到达时间
  958 + layOverTime = nextTrip.getFcTimeObj().diff(trip.getArrTimeObj(), "m");
  959 + trip.setStopTime(layOverTime);
  960 + continue;
  961 + }
1058 962  
1059   - aRangeStopTime = oParam.calcuTripLayoverTimeRange(
1060   - oPreBc.getArrTimeObj(), oPreBc.isUp(), oPreBc.getBcTime()
1061   - );
1062   - iBcStopTime = oPreBc.getStopTime() + iStep;
1063   - if (iBcStopTime >= aRangeStopTime[0] && iBcStopTime <= aRangeStopTime[1]) {
1064   - return true;
1065   - } else {
1066   - return false;
1067   - }
  963 + //------------- 吃饭班次处理 -----------//
  964 + // 获取当前trip的layover的范围
  965 + aLayOverTimeRange = oParam.calcuTripLayoverTimeRange(
  966 + trip.getArrTimeObj(), trip.isUp(), trip.getBcTime()
  967 + );
  968 + // 重新计算当前班次layover时间
  969 + layOverTime = nextTrip.getFcTimeObj().diff(trip.getArrTimeObj(), "m");
  970 + if (trip.fnGetEatTime() > 0) {
  971 + // 如果当前班次layover是要吃饭的
  972 + // 则停站时间没有，变成吃饭时间
  973 + trip.setStopTime(0);
  974 + // 修改下一个班次的发车时间，到达时间
  975 + nextTrip.setFcTimeObj(oParam.addMinute(
  976 + trip.getArrTimeObj(),
  977 + trip.fnGetEatTime())
  978 + );
  979 + nextTrip.setBcTime(oParam.calcuTravelTime(nextTrip.getFcTimeObj(), nextTrip.isUp()));
  980 + nextTrip.setArrTimeObj(oParam.addMinute(nextTrip.getFcTimeObj(), nextTrip.getBcTime()));
  981 + continue;
  982 + }
1068 983  
  984 + //------------- 正常班次处理 -----------//
  985 + if (layOverTime < aLayOverTimeRange[0] || layOverTime > aLayOverTimeRange[1]) {
  986 + // 如果layover时间在范围之外，使用平均值
  987 + layOverTime = oParam.fnCalcuFixedStopNumber(
  988 + trip.getArrTimeObj(),
  989 + trip.isUp(),
  990 + oParam.calcuTravelTime(
  991 + trip.getFcTimeObj(),
  992 + trip.isUp())
  993 + );
1069 994  
1070   - }
  995 + trip.setStopTime(layOverTime);
  996 + nextTrip.setFcTimeObj(oParam.addMinute(
  997 + trip.getArrTimeObj(),
  998 + trip.getStopTime())
  999 + );
  1000 + nextTrip.setBcTime(oParam.calcuTravelTime(nextTrip.getFcTimeObj(), nextTrip.isUp()));
  1001 + nextTrip.setArrTimeObj(oParam.addMinute(nextTrip.getFcTimeObj(), nextTrip.getBcTime()));
  1002 + }
  1003 + }
  1004 + // 最后一个trip的layover时间为0
  1005 + aTrip[j].setStopTime(0);
1071 1006  
  1007 + }
1072 1008 };
1073 1009  
1074 1010 // TODO
... ... @@ -1081,4 +1017,3 @@ InternalLpObj.prototype.calcuLpBx = function() {
1081 1017  
1082 1018 };
1083 1019  
1084   -
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalScheduleObj.js
  View file @14e3a31
1   -/**
2   - * 内部行车计划对象。
3   - * @constructor
4   - */
5   -var InternalScheduleObj = function(paramObj, lpArray, factory) {
6   - // 参数对象
7   - var _paramObj = paramObj;
8   - // 外部的路牌数组
9   - var _lpArray = lpArray;
10   - // 工厂对象
11   - var _factory = factory;
12   -
13   - //------------------ 初始化方法1，以及计算关联的内部变量 -----------------//
14   - var _qIsUp; // 每一圈是上行开始还是下行开始
15   - var _qCount = 0; // 总的圈数
16   - var _internalLpArray = []; // 内部对象数组
17   - var _aBxDesc = [ // 各种班型描述（班型名称,平均工时,平均需要的班次数,平均工时）
18   - {'sType':'六工一休', 'fHoursV':6.66, 'fBcCount': 0, 'fAverTime': 0},
19   - {'sType':'五工一休', 'fHoursV':6.85, 'fBcCount': 0, 'fAverTime': 0},
20   - {'sType':'四工一休', 'fHoursV':7.14, 'fBcCount': 0, 'fAverTime': 0},
21   - {'sType':'三工一休', 'fHoursV':7.61, 'fBcCount': 0, 'fAverTime': 0},
22   - {'sType':'二工一休', 'fHoursV':8.57, 'fBcCount': 0, 'fAverTime': 0},
23   - {'sType':'一工一休', 'fHoursV':11.42, 'fBcCount': 0, 'fAverTime': 0},
24   - {'sType':'五工二休', 'fHoursV':7.99, 'fBcCount': 0, 'fAverTime': 0},
25   - {'sType':'无工休', 'fHoursV':5.43, 'fBcCount': 0, 'fAverTime': 0}
26   - ];
27   -
28   - var _fnInitFun1 = function() { // 初始化方法1
29   - console.log("//---------------- 行车计划，初始化方法1 start ----------------//");
30   -
31   - //----------------------- 1、确定上标线的方向，圈的方向 -------------------//
32   -
33   - // 确定_qIsUp，哪个方向的首班车晚就用哪个
34   - _qIsUp = _paramObj.getUpFirstDTimeObj().isBefore(
35   - _paramObj.getDownFirstDTimeObj()) ? false : true;
36   - // 上标线开始时间，就是方向的首班车时间
37   - var st = _qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
38   - // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
39   - var et;
40   - var et_IsUp;
41   - if (_paramObj.getUpLastDtimeObj().isBefore(
42   - _paramObj.getDownLastDTimeObj())) {
43   - et = _paramObj.getDownLastDTimeObj();
44   - et_IsUp = false;
45   - } else {
46   - et = _paramObj.getUpLastDtimeObj();
47   - et_IsUp = true;
48   - }
49   -
50   - //------------------------ 2、计算总共有多少圈 ------------------------//
51   -
52   - // 以开始时间，结束时间，构造上标线用连班班次发车时间
53   - var bcFcsjArrays = []; // 班次发车时间对象数组
54   - var bcArsjArrays = []; // 班次到达时间对象数组
55   - var isUp = _qIsUp; // 方向
56   - var bcCount = 1; // 班次数
57   -
58   - var _kssj = st; // 开始时间
59   - var _bcsj = paramObj.calcuTravelTime(_kssj, isUp); // 班次历时
60   - var _arrsj = paramObj.addMinute(_kssj, _bcsj); // 到达时间
61   - var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj); // 停站时间
62   -
63   - do {
64   - bcFcsjArrays.push(_kssj);
65   - bcArsjArrays.push(_arrsj);
66   -
67   - _kssj = paramObj.addMinute(_kssj, _bcsj + _stoptime);
68   - _bcsj = paramObj.calcuTravelTime(_kssj, isUp);
69   - _arrsj = paramObj.addMinute(_kssj, _bcsj);
70   - _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
71   -
72   - bcCount ++;
73   - isUp = !isUp;
74   - } while(_kssj.isBefore(et));
75   - bcCount--; // 因为先做do，所以总的班次要减1
76   - //if (bcCount > 0 && bcArsjArrays[bcCount - 1].isAfter(et)) {
77   - // // 如果最后一个班次的到达时间超过结束时间，也要去除
78   - // bcFcsjArrays.splice(bcCount - 1, 1);
79   - // bcArsjArrays.splice(bcCount - 1, 1);
80   - // bcCount--;
81   - //}
82   - var _qCount_p1 = Math.floor(bcCount / 2); // 2个班次一圈
83   - var _qCount_p2 = bcCount % 2; // 余下的1个班次也算一圈
84   -
85   - // 利用连班数组计算圈数
86   - _qCount = 1; // 前面加1圈，补中标线的班次
87   - _qCount += _qCount_p1;
88   - _qCount += _qCount_p2;
89   -
90   - // 计算最后是不是还要补一圈
91   - if (_qCount > 1) { // 总的圈数就1圈，没必要加了（其实是不可能的，除非参数里问题）
92   - if (_qCount_p2 == 0) { // 没有余下班次，整数圈数
93   - // 最后一个班次的方向一定和开始的方向相反，如：上-下,上-下,上-下，一共三圈，最后一个班次为下行
94   - // 判定最后一个班次的方向和上标线判定结束时间的班次方向是否一致
95   - if (!_qIsUp == et_IsUp) {
96   - // 一致不用加圈数
97   - } else {
98   - // 不一致需要加圈补最后一个结束时间班次
99   - _qCount ++;
100   - }
101   - } else {
102   - // 有余下的圈数，最后要不补的班次不管上行，下行都在这一圈里
103   - // 不需要在补圈数了
104   - }
105   - }
106   -
107   - //------------------------ 3、根据路牌数，圈数创建路牌对象 ----------------------//
108   -
109   - // 创建内部的路牌数组，并把之前的连班路牌添加进上标线路牌中
110   - var i;
111   - for (i = 0; i < _lpArray.length; i++) {
112   - _internalLpArray.push(new InternalLpObj(_lpArray[i], _qCount, _qIsUp));
113   - }
114   - // 初始化上标线，从第1圈开始
115   - _internalLpArray[0].initDataFromTimeToTime(bcFcsjArrays[0], et, _qIsUp, 1, _paramObj, _factory);
116   -
117   - // 以上标线为基础，计算各种班型工时对应的圈数、班次数
118   - var aBcArray = _internalLpArray[0].getBcArray();
119   - aBcArray[0].fnSetIsFirstBc(true); // 设置首班班次标识
120   -
121   - if (aBcArray.length % 2 != 0) { // 不能整除2，去除一个班次计算
122   - aBcArray.splice(aBcArray.length - 1, 1);
123   - }
124   -
125   - // 午饭吃饭时间
126   - var iLTime = _paramObj.fnGetLunchTime();
127   - // 晚饭吃饭时间
128   - var iDTime = _paramObj.fnGetDinnerTime();
129   - // 出场时间
130   - var iOutTime = _qIsUp ? _paramObj.getUpOutTime() : _paramObj.getDownOutTime();
131   - // 进场时间
132   - var iInTime = _qIsUp ? _paramObj.getDownInTime() : _paramObj.getUpInTime();
133   - // 例保时间
134   - var iBTime = _paramObj.getLbTime();
135   -
136   - var sum = 0; // 总班次时间
137   - for (i = 0; i < aBcArray.length; i++) {
138   - sum += aBcArray[i].getBcTime() + aBcArray[i].getStopTime();
139   - }
140   - sum += iLTime; // 加午饭时间
141   - sum += iDTime; // 加晚饭时间
142   - for (i = 0; i < _aBxDesc.length; i++) {
143   - _aBxDesc[i].fAverTime = sum / (aBcArray.length / 2); // 平均周转时间不算进出场，例保时间
144   -
145   - // 计算5休2的班次数（双进出场，4个例保）
146   - if (i == 6) {
147   - _aBxDesc[i].fQCount =
148   - (_aBxDesc[i].fHoursV * 60 - iOutTime * 2 - iInTime * 2 - iBTime * 4) /
149   - _aBxDesc[i].fAverTime;
150   - _aBxDesc[i].fBcCount = _aBxDesc[i].fQCount * 2;
151   - } else { // 进出场，2个例保
152   - _aBxDesc[i].fQCount =
153   - (_aBxDesc[i].fHoursV * 60 - iOutTime - iInTime - iBTime * 2) /
154   - _aBxDesc[i].fAverTime;
155   - _aBxDesc[i].fBcCount = _aBxDesc[i].fQCount * 2;
156   - }
157   - }
158   -
159   -
160   - // 在第一个班次之前再添加一个模拟班次，用于中标线的作用
161   - // 那一圈必定是低谷，而且圈索引0，班次索引1，暂时标记，最后删除
162   - var iXXTime = _qIsUp ? _paramObj.getDownTroughTime() : _paramObj.getUpTroughTime();
163   - var iFirstStopTime =
164   - _paramObj.fnCalcuFixedStopNumber(
165   - _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -10),
166   - _qIsUp,
167   - iXXTime
168   - );
169   - var oFlagBc = _factory.createBcObj( // 标记班次
170   - _internalLpArray[0],
171   - "normal",
172   - !_qIsUp,
173   - 1,
174   - _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -(iFirstStopTime + iXXTime)),
175   - _paramObj
176   - );
177   - console.log("ddfdfdf=" + (iFirstStopTime));
178   - console.log("ddfdfdf=" + (iXXTime));
179   - console.log("ttt ==" + oFlagBc.getFcTimeObj().format("HH:mm"));
180   - oFlagBc.fnSetDelFlag(true); // 标记了删除记号
181   -
182   - _internalLpArray[0].setBc(0, 1, oFlagBc);
183   -
184   - // 在最后一圈也补上一个或者2个模拟班次，暂时标记，最后需要删除
185   - var aMaxBcIndex = _internalLpArray[0].getMaxBcObjPosition();
186   - if (aMaxBcIndex[0] == _qCount - 1) { // 可能加半圈
187   - oFlagBc = _factory.createBcObj( // 标记班次
188   - _internalLpArray[0],
189   - "normal",
190   - !_qIsUp,
191   - 1,
192   - _paramObj.addMinute(
193   - _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
194   - _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
195   - _paramObj
196   - );
197   - oFlagBc.fnSetDelFlag(true); // 标记了删除记号
198   - _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
199   -
200   - } else { // 加完整的一圈
201   - oFlagBc = _factory.createBcObj( // 标记班次
202   - _internalLpArray[0],
203   - "normal",
204   - _qIsUp,
205   - 1,
206   - _paramObj.addMinute(
207   - _internalLpArray[0].getBc(_qCount - 2, 1).getArrTimeObj(),
208   - _internalLpArray[0].getBc(_qCount - 2, 1).getStopTime()),
209   - _paramObj
210   - );
211   - oFlagBc.fnSetDelFlag(true); // 标记了删除记号
212   - _internalLpArray[0].setBc(_qCount - 1, 0, oFlagBc);
213   -
214   - oFlagBc = _factory.createBcObj( // 标记班次
215   - _internalLpArray[0],
216   - "normal",
217   - !_qIsUp,
218   - 1,
219   - _paramObj.addMinute(
220   - _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
221   - _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
222   - _paramObj
223   - );
224   - oFlagBc.fnSetDelFlag(true); // 标记了删除记号
225   - _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
226   -
227   - }
228   -
229   - console.log("上行首班车时间:" + _paramObj.getUpFirstDTimeObj().format("HH:mm") +
230   - "上行末班车时间:" + _paramObj.getUpLastDtimeObj().format("HH:mm"));
231   - console.log("下行首班车时间:" + _paramObj.getDownFirstDTimeObj().format("HH:mm") +
232   - "下行末班车时间:" + _paramObj.getDownLastDTimeObj().format("HH:mm"));
233   - console.log("总共计算的圈数:" + _qCount);
234   - console.log("圈的方向isUP:" + _qIsUp);
235   - console.log("班型描述（以下）:");
236   - console.log(_aBxDesc);
237   - console.log("所有路牌间隔描述（以下）:");
238   - for (i = 0; i < _internalLpArray.length; i++) {
239   - console.log(_internalLpArray[i]._$_aVerticalIntervalTime);
240   - }
241   - console.log("//---------------- 行车计划，初始化方法1 end ----------------//");
242   -
243   - };
244   -
245   - //------------------ 初始化方法2，以及计算关联的内部变量 ----------------//
246   - var _approximate_zgfQIndex; // 预估早高峰车辆从第几圈开始全部发出
247   - var _approximate_zgfBIndex; // 预估早高峰车辆从第几圈第几个班次开始全部发出（上行或下行）
248   - var _approximate_wgfQIndex; // 预估晚高峰车辆从第几圈开始全部发出
249   - var _approximate_wgfBIndex; // 预估晚高峰车辆从第几圈第几个班次开始全部发出（上行或下行）
250   -
251   - var _fnInitFun2 = function() { // 初始化方法2
252   - console.log("//---------------- 行车计划，初始化方法2 start ----------------//");
253   -
254   - //------------------------ 1、计算车辆总数 ------------------------//
255   - // 是用高峰上行周转时间除以高峰平均间隔得到的
256   - // 这样算还算合理，车辆不多不少，待以后有新的算法再修正
257   - var iClCount = _paramObj.calcuClzx();
258   -
259   - //------------------------ 2、计算所有路牌的发车在各个圈中的间隔 --------------------//
260   - var i;
261   - var j;
262   - var iBindex = 1;
263   - var iZzsj;
264   - var oLp;
265   - var iC1;
266   - var iC2;
267   -
268   - for (i = 0; i < _qCount - 1; i++) {
269   - while (iBindex <= 1) {
270   - // 每圈每个方向的周转时间不一致，以上标线为主
271   - oLp = _internalLpArray[0];
272   - iZzsj = oLp.getBc(i + 1, iBindex).getFcTimeObj().diff(
273   - oLp.getBc(i, iBindex).getFcTimeObj(), "m"
274   - );
275   -
276   - iC1 = Math.floor(iZzsj / iClCount);
277   - iC2 = iZzsj % iClCount;
278   -
279   - for (j = 0; j < iClCount - iC2; j++) {
280   - oLp = _internalLpArray[j];
281   - oLp.fnSetVerticalIntervalTime(i, iBindex, iC1);
282   - }
283   -
284   - for (j = 0; j < iC2; j++) {
285   - oLp = _internalLpArray[iClCount - iC2 + j];
286   - oLp.fnSetVerticalIntervalTime(i, iBindex, iC1 + 1);
287   - }
288   -
289   - iBindex ++;
290   -
291   - }
292   - iBindex = 0;
293   - }
294   - // 最后一圈没有下一圈的参照，周转时间没发获取，由于都是低谷，所以使用倒数第二圈的间隔最为最后一圈的间隔
295   - for (i = 0; i < _internalLpArray.length; i++) {
296   - oLp = _internalLpArray[i];
297   - oLp.fnSetVerticalIntervalTime(_qCount - 1, 0, oLp.fnGetVerticalIntervalTime(_qCount - 2, 0));
298   - oLp.fnSetVerticalIntervalTime(_qCount - 1, 1, oLp.fnGetVerticalIntervalTime(_qCount - 2, 1));
299   - }
300   -
301   - //------------------------ 3、预估早高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
302   -
303   - // 以上标线为标准，查找离早高峰开始时间最近的班次作为早高峰开始班次
304   - // 以这个班次为早高峰起点，全部出车策略
305   - var qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
306   - _paramObj.getMPeakStartTimeObj(), true, true);
307   - var qIndex = qbcIndexArray[0]; // 第几圈
308   - var bIndex = qbcIndexArray[1]; // 第几个班次
309   -
310   - for (i = 1; i < _internalLpArray.length; i++) {
311   - _fnGenerateBcAndSetBc(i, qIndex, bIndex);
312   - }
313   -
314   - _approximate_zgfQIndex = qIndex;
315   - _approximate_zgfBIndex = bIndex;
316   -
317   - //------------------------ 4、预估晚高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
318   -
319   - // 以上标线为标准，查找离晚高峰开始时间最近的班次作为晚高峰开始班次
320   - // 以这个班次为早高峰起点，全部出车策略
321   - qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
322   - _paramObj.getEPeakStartTimeObj(), true, true);
323   - qIndex = qbcIndexArray[0]; // 第几圈
324   - bIndex = qbcIndexArray[1]; // 第几个班次
325   -
326   - for (i = 1; i < _internalLpArray.length; i++) {
327   - _fnGenerateBcAndSetBc(i, qIndex, bIndex);
328   - }
329   -
330   - _approximate_wgfQIndex = qIndex;
331   - _approximate_wgfBIndex = bIndex;
332   -
333   - console.log("早高峰周转时间(固定最大停战时间):" + _paramObj.calcuPeakZzsj() + "分钟");
334   - console.log("早高峰发车时间范围:" + _paramObj.getMPeakMinFcjx() + "分钟 --- " + _paramObj.getMPeakMaxFcjx() + "分钟");
335   - console.log("预估早高峰第" + _approximate_zgfQIndex + "(index)圈,第" + _approximate_zgfBIndex + "(index)班次车辆全部发出");
336   - console.log("预估晚高峰第" + _approximate_wgfQIndex + "(index)圈,第" + _approximate_wgfBIndex + "(index)班次车辆全部发出");
337   - console.log("//---------------- 行车计划，初始化方法2 end ----------------//");
338   - };
339   -
340   - //----------------------- 初始化方法3，计算连班分班的路牌分布 ----------------//
341   - var _iBx_lb_lpcount; // 连班路牌数
342   - var _iBx_5_2_fb_lpcount; // 5休2分班路牌数
343   - var _iBx_other_fb_lpcount; // 其他分班路牌数
344   -
345   - var _fnInitFun3 = function() { // 初始化方法3
346   - console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
347   -
348   - //--------------------- 1、计算分班连班班型车辆分布数 --------------------//
349   - // 总共车辆数（高峰最大车辆数）
350   - var iCls = _paramObj.calcuClzx();
351   - // 低谷最少配车（连班车数量）
352   - var iDgminpc = Math.round(_paramObj.calcuTroughZzsj() / _paramObj.getTroughMaxFcjx());
353   - // 加班车路牌数（做5休2的路牌数）
354   - var i_5_2_lpes = _paramObj.getJBLpes();
355   -
356   - // 做些简单的验证
357   - if (iCls < iDgminpc) {
358   - alert("总配车数小于低谷最小配车");
359   - throw "总配车数小于低谷最小配车";
360   - }
361   -
362   - if (iDgminpc < 2) {
363   - // alert("连班路牌小于2，办不到啊");
364   - // throw "连班路牌小于2，办不到啊";
365   - console.log("连班路牌小于2，则5休2之外的车辆数则为连班车辆数");
366   - iDgminpc = iCls - i_5_2_lpes;
367   - }
368   - if (iCls - iDgminpc < i_5_2_lpes) {
369   - // alert("总分班路牌数小于加班路牌数");
370   - // throw "总分班路牌数小于加班路牌数";
371   - console.log("总分班路牌数小于加班路牌数，则忽略其他分班路牌数");
372   - iDgminpc = iCls - i_5_2_lpes;
373   - }
374   -
375   - //// 修正连班路牌数，班次间隔大于20的，加1，直至班次间隔小于20
376   - //while(_paramObj.calcuPeakZzsj() / iDgminpc > 20) {
377   - // iDgminpc ++;
378   - //}
379   - _iBx_lb_lpcount = iDgminpc;
380   -
381   - _iBx_5_2_fb_lpcount = i_5_2_lpes;
382   - _iBx_other_fb_lpcount = iCls - _iBx_lb_lpcount - i_5_2_lpes;
383   -
384   - //------------------------ 2、利用间隔法计算连班路牌分布 --------------------//
385   - var i;
386   - var j;
387   - var iC1 = Math.floor(_internalLpArray.length / _iBx_lb_lpcount);
388   - var iC2 = _internalLpArray.length % _iBx_lb_lpcount;
389   - var iLpIndex;
390   -
391   - for (i = 0; i < _iBx_lb_lpcount - iC2; i++) {
392   - iLpIndex = i * iC1;
393   - _internalLpArray[iLpIndex].setBxLb(true);
394   - _internalLpArray[iLpIndex].setBxDesc("连班");
395   - }
396   - for (j = 0; j < iC2; j++) {
397   - iLpIndex = i * iC1 + j * (iC1 + 1);
398   - _internalLpArray[iLpIndex].setBxLb(true);
399   - _internalLpArray[iLpIndex].setBxDesc("连班");
400   - }
401   -
402   - //------------------------ 3、利用间隔法计算分班班型路牌分布 --------------------//
403   - // 获取分班路牌索引
404   - var aNotLbIndexes = [];
405   - for (i = 0; i < _internalLpArray.length; i++) {
406   - if (!_internalLpArray[i].isBxLb()) {
407   - aNotLbIndexes.push(i);
408   - }
409   - }
410   - // 先5休2分班
411   - iC1 = Math.floor(aNotLbIndexes.length / _iBx_5_2_fb_lpcount);
412   - iC2 = aNotLbIndexes.length % _iBx_5_2_fb_lpcount;
413   -
414   - for (i = 0; i < _iBx_5_2_fb_lpcount - iC2; i++) {
415   - iLpIndex = aNotLbIndexes[i * iC1];
416   - _internalLpArray[iLpIndex].setBxLb(false);
417   - _internalLpArray[iLpIndex].setBxFb(true);
418   - _internalLpArray[iLpIndex].setBxFb5_2(true);
419   - _internalLpArray[iLpIndex].setBxDesc("5休2分班");
420   - }
421   - for (i = 0; i < iC2; i++) {
422   - iLpIndex = aNotLbIndexes[_iBx_5_2_fb_lpcount - iC2 + i * (iC1 + 1)];
423   - _internalLpArray[iLpIndex].setBxLb(false);
424   - _internalLpArray[iLpIndex].setBxFb(true);
425   - _internalLpArray[iLpIndex].setBxFb5_2(true);
426   - _internalLpArray[iLpIndex].setBxDesc("5休2分班");
427   - }
428   - // 其他分班
429   - for (i = 0; i < aNotLbIndexes.length; i++) {
430   - iLpIndex = aNotLbIndexes[i];
431   - if (!_internalLpArray[iLpIndex].isBxFb5_2()) {
432   - _internalLpArray[iLpIndex].setBxLb(false);
433   - _internalLpArray[iLpIndex].setBxFb(true);
434   - _internalLpArray[iLpIndex].setBxFb5_2(false);
435   - _internalLpArray[iLpIndex].setBxDesc("其他分班");
436   - }
437   - }
438   -
439   - console.log("高峰周转时间:" + _paramObj.calcuPeakZzsj());
440   - console.log("连班路牌数:" + _iBx_lb_lpcount);
441   - console.log("5休2分班路牌数:" + _iBx_5_2_fb_lpcount);
442   - console.log("其他分班路牌数:" + _iBx_other_fb_lpcount);
443   - var aLbIndexes = [];
444   - for (i = 0; i < _internalLpArray.length; i++) {
445   - if (_internalLpArray[i].isBxLb()) {
446   - aLbIndexes.push(i);
447   - }
448   - }
449   - console.log("连班路牌indexes=" + aLbIndexes);
450   - var a_5_2_fbIndexes = [];
451   - for (i = 0; i < _internalLpArray.length; i++) {
452   - if (_internalLpArray[i].isBxFb() && _internalLpArray[i].isBxFb5_2()) {
453   - a_5_2_fbIndexes.push(i);
454   - }
455   - }
456   - console.log("5休2分班路牌indexes=" + a_5_2_fbIndexes);
457   - var a_other_fbIndexes = [];
458   - for (i = 0; i < _internalLpArray.length; i++) {
459   - if (_internalLpArray[i].isBxFb() && !_internalLpArray[i].isBxFb5_2()) {
460   - a_other_fbIndexes.push(i);
461   - }
462   - }
463   - console.log("其他分班路牌indexes=" + a_other_fbIndexes);
464   -
465   - console.log("//---------------- 行车计划，初始化方法3 end ----------------//");
466   - };
467   -
468   - //----------------------- 初始化方法4，计算中标线位置 -------------------------//
469   - var _iZbx_lpIndex; // 中标线对应第几个路牌
470   -
471   - var _fnInitFun4 = function() { // 初始化方法4
472   - console.log("//---------------- 行车计划，初始化方法4 start ----------------//");
473   -
474   - //---------------------------- 1、模拟一个中标线，使用临时路牌 ----------------------//
475   - // 构造中标线
476   - // 中标线开始时间，就是方向的首班车时间
477   - var oSt = !_qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
478   - // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
479   - // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
480   - var oEt;
481   - if (_paramObj.getUpLastDtimeObj().isBefore(
482   - _paramObj.getDownLastDTimeObj())) {
483   - oEt = _paramObj.getDownLastDTimeObj();
484   - } else {
485   - oEt = _paramObj.getUpLastDtimeObj();
486   - }
487   -
488   - var oTempLp = new InternalLpObj({lpNo: -999, lpName: "-999"}, _qCount, _qIsUp);
489   - oTempLp.initDataFromTimeToTime(
490   - oSt,
491   - oEt,
492   - !_qIsUp,
493   - 0,
494   - _paramObj,
495   - _factory
496   - );
497   -
498   - //------------------------ 2、找出中标线的早高峰班次，计算应该插在当前路牌数组的那个位置 ----------------//
499   - // 找出中标线对应的早高峰的班次对象
500   - var oZb_gf_bc = oTempLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
501   - //alert(oZb_gf_bc.getFcTimeObj().format("HH:mm"));
502   -
503   - // 把所有连班路牌高峰班次重新构造成一个一个的圈数组，计算对应中标线最近的是第几个路牌
504   - // 中标线和上标线一样在连班路牌上
505   - var aTempq = [];
506   - var oTempq;
507   - var oTempb;
508   - var i;
509   - var oLp;
510   -
511   - var aLbIndexes = []; // 连班的路牌索引
512   - for (i = 0; i < _internalLpArray.length; i++) {
513   - if (_internalLpArray[i].isBxLb()) {
514   - aLbIndexes.push(i);
515   - }
516   - }
517   -
518   - for (i = 0; i < aLbIndexes.length; i++) {
519   - oLp = _internalLpArray[aLbIndexes[i]];
520   -
521   - oTempb = oLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
522   - if (oTempb.isUp() == _qIsUp) {
523   - oTempq = new InternalGroupObj(oLp, _qIsUp, oTempb, undefined);
524   - } else {
525   - oTempq = new InternalGroupObj(oLp, _qIsUp, undefined, oTempb);
526   - }
527   - aTempq.push(oTempq);
528   -
529   - }
530   -
531   - var aTtindex = oTempLp.fnGetQBcIndexWithFcTimeFromGroupArray( // 找出最接近中标线的路牌索引
532   - oZb_gf_bc.getFcTimeObj(),
533   - aTempq,
534   - true,
535   - true
536   - );
537   -
538   - _iZbx_lpIndex = aLbIndexes[aTtindex[0]]; // 中标线放在第几个路牌
539   -
540   - oTempLp.getMinBcObj().fnSetIsFirstBc(true); // 设置首班班次标识
541   -
542   - if (_iZbx_lpIndex == 0) { // 如果中标线和上标线一致
543   - var oFirstBcIndexes = oTempLp.getMinBcObjPosition();
544   - var oFirstBc = oTempLp.getMinBcObj();
545   - oFirstBc.setLp(_internalLpArray[_iZbx_lpIndex]);
546   - oFirstBc.fnSetDelFlag(false);
547   - _internalLpArray[_iZbx_lpIndex].setBc(oFirstBcIndexes[0], oFirstBcIndexes[1], oFirstBc);
548   - } else {
549   - oTempLp.setLp(_lpArray[_iZbx_lpIndex]); // 设置原始路牌对象
550   - oTempLp._$_aVerticalIntervalTime = _internalLpArray[_iZbx_lpIndex]._$_aVerticalIntervalTime; // 设置纵向最小发车间隔
551   - oTempLp.setBxLb(_internalLpArray[_iZbx_lpIndex].isBxLb());
552   - oTempLp.setBxFb(_internalLpArray[_iZbx_lpIndex].isBxFb());
553   - oTempLp.setBxFb5_2(_internalLpArray[_iZbx_lpIndex].isBxFb5_2());
554   -
555   - // 修正除了第一个班次外，其余其他班次
556   - var iBcindex = 0;
557   - for (i = 1; i < _qCount; i++) {
558   - while (iBcindex <= 1) {
559   - if (oTempLp.getBc(i, iBcindex)) { // 替换存在的班次
560   - oTempLp.setBc(i, iBcindex, _fnGenerateBc(_iZbx_lpIndex, i, iBcindex));
561   - }
562   - iBcindex ++;
563   - }
564   - iBcindex = 0;
565   - }
566   -
567   - _internalLpArray[_iZbx_lpIndex] = oTempLp;
568   - }
569   -
570   - console.log("中标线对应第" + (_iZbx_lpIndex + 1) + "个路牌");
571   -
572   - console.log("//---------------- 行车计划，初始化方法4 end ----------------//");
573   - };
574   -
575   - //-------------------- 重要的内部方法 -----------------------//
576   - /**
577   - * 核心方法，利用路牌间隔纵向生成班次。
578   - * @param iLpindex 路牌索引
579   - * @param iQindex 圈索引
580   - * @param iBcindex 班次索引
581   - * @returns object InternalBcObj，失败 false
582   - */
583   - var _fnGenerateBc = function(iLpindex, iQindex, iBcindex) {
584   - // 以上标线为起始点，使用路牌在不同圈，班次索引的发车间隔，计算班次
585   - // 注意，发车间隔是指下一个班次应该距离当前班次间隔，是从下往上的
586   -
587   - // 1、参数验证
588   - if (iLpindex == 0) { // 上标线的班次不需要生成
589   - return false;
590   - }
591   -
592   - // 2、计算间隔
593   - var i;
594   - var oLp;
595   - var iTime = 0;
596   - for (i = 0; i < iLpindex; i++) {
597   - oLp = _internalLpArray[i];
598   - iTime += oLp.fnGetVerticalIntervalTime(iQindex, iBcindex);
599   - }
600   -
601   - // 3、生成班次
602   - var _oKsbc = _internalLpArray[0].getBc(iQindex, iBcindex);
603   - if (!_oKsbc) {
604   - return false;
605   - }
606   - var _oKssj = _paramObj.addMinute(_oKsbc.getFcTimeObj(), iTime);
607   - var _oBc = _factory.createBcObj(
608   - _internalLpArray[iLpindex],
609   - "normal", _oKsbc.isUp(),
610   - 1, _oKssj, _paramObj);
611   -
612   - return _oBc;
613   -
614   - };
615   -
616   - /**
617   - * 核心方法，在指定位置生成班次并添加到路牌指定位置中。
618   - * @param lpIndex 第几个路牌
619   - * @param qIndex 第几圈
620   - * @param bcIndex 第几个班次
621   - */
622   - var _fnGenerateBcAndSetBc = function(lpIndex, qIndex, bcIndex) {
623   - var _bcObj = _fnGenerateBc(lpIndex, qIndex, bcIndex);
624   - if (_bcObj) {
625   - _internalLpArray[lpIndex].setBc(qIndex, bcIndex, _bcObj);
626   - }
627   - };
628   -
629   - /**
630   - * 获取班次列表。
631   - * @param oIsUp 是否上行
632   - * @param oStartTime 开始时间对象
633   - * @returns [(InternalBcObj)]
634   - */
635   - var _fnGetBcList2 = function(oIsUp, oStartTime) {
636   - var i;
637   - var j;
638   - var oLp;
639   - var oBc;
640   - var aBc = [];
641   -
642   - for (j = 0; j < _qCount; j++) {
643   - for (i = 0; i < _internalLpArray.length; i++) {
644   - oLp = _internalLpArray[i];
645   - oBc = oLp.getBc(
646   - j,
647   - _qIsUp == oIsUp ? 0 : 1
648   - );
649   - if (oBc && oBc.getFcTimeObj().isAfter(oStartTime)) {
650   - aBc.push(oBc);
651   - }
652   - }
653   - }
654   -
655   - var aBcFcTime = [];
656   - for (i = 0; i < aBc.length; i++) {
657   - oBc = aBc[i];
658   - aBcFcTime.push(oBc.getFcTimeObj().format("HH:mm"));
659   - }
660   - console.log((oIsUp ? "上行班次列表：" : "下行班次列表：") + aBcFcTime.join(","));
661   -
662   - return aBc;
663   - };
664   -
665   - /**
666   - * 获取班次列表。
667   - * @param isUp boolean 是否上行
668   - * @returns [(InternalBcObj)]
669   - */
670   - var _fnGetBcList = function(isUp) {
671   - var i;
672   - var j;
673   - var oLp;
674   - var oBc;
675   - var aBc = [];
676   -
677   - for (j = 0; j < _qCount; j++) {
678   - for (i = 0; i < _internalLpArray.length; i++) {
679   - oLp = _internalLpArray[i];
680   - oBc = oLp.getBc(
681   - j,
682   - _qIsUp == isUp ? 0 : 1
683   - );
684   - if (oBc) {
685   - aBc.push(oBc);
686   - }
687   - }
688   - }
689   -
690   - var aBcFcTime = [];
691   - for (i = 0; i < aBc.length; i++) {
692   - oBc = aBc[i];
693   - aBcFcTime.push(oBc.getFcTimeObj().format("HH:mm"));
694   - }
695   - console.log((isUp ? "上行班次列表：" : "下行班次列表：") + aBcFcTime.join(","));
696   -
697   - return aBc;
698   - };
699   -
700   - /**
701   - * 查找离指定时间最近的前面的班次索引信息
702   - * @param timeObj 查找时间
703   - * @param isUp 是否上行
704   - * @returns [{路牌index},{圈index},{班次index}]
705   - */
706   - var _fnFindUpClosedBcIndexWithTime = function(timeObj, isUp) {
707   -
708   - var _lpObj;
709   - var _groupObj;
710   - var _bcObj;
711   - var _i;
712   - var _j;
713   - var timediff; // 时间差取绝对值
714   -
715   - var _lpIndex;
716   - var _up_qIndex;
717   - var _up_bIndex;
718   -
719   - for (_i = 0; _i < _qCount; _i++) {
720   - for (_j = 0; _j < _internalLpArray.length; _j++) {
721   - _lpObj = _internalLpArray[_j];
722   - _groupObj = _lpObj.getGroup(_i);
723   - _bcObj = isUp == _qIsUp ? _groupObj.getBc1() : _groupObj.getBc2();
724   - if (!_bcObj) { // 没有班次动态生成一个，可能生成不出的
725   - _bcObj = _fnGenerateBc(_j, _i, isUp == _qIsUp ? 0 : 1);
726   - }
727   - if (_bcObj) {
728   - if (timeObj.diff(_bcObj.getFcTimeObj()) >= 0) {
729   - if (!timediff) {
730   - timediff = timeObj.diff(_bcObj.getFcTimeObj());
731   - _lpIndex = _j;
732   - _up_qIndex = _i;
733   - _up_bIndex = isUp == _qIsUp ? 0 : 1;
734   - } else {
735   - if (timeObj.diff(_bcObj.getFcTimeObj()) < timediff) {
736   - timediff = timeObj.diff(_bcObj.getFcTimeObj());
737   - _lpIndex = _j;
738   - _up_qIndex = _i;
739   - _up_bIndex = isUp == _qIsUp ? 0 : 1;
740   - }
741   - }
742   - }
743   - }
744   - }
745   - }
746   -
747   - if (_lpIndex == undefined) {
748   - return false;
749   - }
750   -
751   - var bcindex = [];
752   - bcindex.push(_lpIndex);
753   - bcindex.push(_up_qIndex);
754   - bcindex.push(_up_bIndex);
755   -
756   - return bcindex;
757   - };
758   -
759   - /**
760   - * 查找离指定时间最近的后面的班次索引信息
761   - * @param timeObj 查找时间
762   - * @param isUp 是否上行
763   - * @returns [{路牌index},{圈index},{班次index}]
764   - */
765   - var _fnFindDownClosedBcIndexWithTime = function(timeObj, isUp) {
766   - var _lpObj;
767   - var _groupObj;
768   - var _bcObj;
769   - var _i;
770   - var _j;
771   - var timediff; // 时间差取绝对值
772   -
773   - var _lpIndex;
774   - var _down_qIndex;
775   - var _down_bIndex;
776   -
777   - var flag;
778   -
779   - for (_i = 0; _i < _qCount; _i++) {
780   - for (_j = 0; _j < _internalLpArray.length; _j++) {
781   - _lpObj = _internalLpArray[_j];
782   - _groupObj = _lpObj.getGroup(_i);
783   - // TODO：bug
784   - _bcObj = isUp == _qIsUp ? _groupObj.getBc1() : _groupObj.getBc2();
785   - if (!_bcObj) { // 没有班次动态生成一个，可能生成不出的
786   - _bcObj = _fnGenerateBc(_j, _i, isUp == _qIsUp ? 0 : 1);
787   - }
788   - if (_bcObj) {
789   - //console.log("timeobj -> bcobj diff flag " +
790   - // timeObj.format("HH:mm") + "->" +
791   - // _bcObj.getFcTimeObj().format("HH:mm") +
792   - // timeObj.diff(_bcObj.getFcTimeObj()) +
793   - // (timeObj.diff(_bcObj.getFcTimeObj()) <= 0)
794   - //);
795   -
796   - flag = (timeObj.diff(_bcObj.getFcTimeObj())) <= 0;
797   -
798   - if (flag) {
799   - if (!timediff) {
800   - timediff = timeObj.diff(_bcObj.getFcTimeObj());
801   - _lpIndex = _j;
802   - _down_qIndex = _i;
803   - _down_bIndex = isUp == _qIsUp ? 0 : 1;
804   - } else {
805   - if ((timeObj.diff(_bcObj.getFcTimeObj())) > timediff) {
806   - timediff = timeObj.diff(_bcObj.getFcTimeObj());
807   - _lpIndex = _j;
808   - _down_qIndex = _i;
809   - _down_bIndex = isUp == _qIsUp ? 0 : 1;
810   - }
811   - }
812   - }
813   - }
814   - }
815   - }
816   -
817   - if (_lpIndex == undefined) {
818   - return false;
819   - }
820   -
821   - var bcindex = [];
822   - bcindex.push(_lpIndex);
823   - bcindex.push(_down_qIndex);
824   - bcindex.push(_down_bIndex);
825   -
826   - return bcindex;
827   - };
828   -
829   - /**
830   - * 获取班次索引。
831   - * @param oBc 班次对象
832   - * @returns [{路牌索引},{圈索引},{班次索引}]
833   - */
834   - var _fnGetBcIndex = function(oBc) {
835   - // 路牌索引
836   - var i;
837   - var iLpIndex;
838   - for (i = 0; i < _internalLpArray.length; i++) {
839   - if (_internalLpArray[i]._$$_orign_lp_obj == oBc._$$_internal_lp_obj._$$_orign_lp_obj) {
840   - iLpIndex = i;
841   - break;
842   - }
843   - }
844   - // 圈索引
845   - var j;
846   - var iGroupIndex;
847   - var bFlag = false;
848   - for (i = 0; i < _internalLpArray.length; i++) {
849   - if (bFlag) {
850   - break;
851   - }
852   - for (j = 0; j < _qCount; j++) {
853   - if (_internalLpArray[i]._$_groupBcArray[j] == oBc._$$_internal_group_obj) {
854   - iGroupIndex = j;
855   - bFlag = true;
856   - break;
857   - }
858   - }
859   - }
860   - // 班次索引
861   - var iBcIndex = _qIsUp == oBc.isUp() ? 0 : 1;
862   -
863   - if (iLpIndex == undefined) {
864   - return null;
865   - } else {
866   - return [].concat(iLpIndex, iGroupIndex, iBcIndex);
867   - }
868   -
869   - };
870   -
871   - return {
872   - //------------- 布局初始化方法 ------------//
873   - /**
874   - * 初始化数据，使用标线初始化
875   - */
876   - fnInitDataWithBxLayout: function() {
877   - // 初始化布局1，构造上标线，计算圈数，把上标线数据放入第一个路牌中
878   - _fnInitFun1();
879   - // 初始化布局2，从上标线的某个班次开始，构造所有路牌的早高峰班次，晚高峰班次，计算路牌在各个圈中的间隔
880   - _fnInitFun2();
881   - // 初始化布局3，计算连班分班路牌分布
882   - _fnInitFun3();
883   - // 初始化布局4，计算中标线位置
884   - _fnInitFun4();
885   -
886   - },
887   -
888   - /**
889   - * 调整高峰班次，
890   - * 初始化生成早高峰，晚高峰班次并不准确，因为根据高峰时间段，并不在一个完整圈内，应该是在两个或多个圈之间
891   - * 当初始化定好布局后（上标线，中标线），然后确定每个路牌的班型（连班，分班，5休2分班）后
892   - * 然后重新计算框在高峰时间段内的班次索引，不足的添加，之前多加的删除（只删除分班路牌上的）
893   - * @param isZgf 是否早高峰
894   - * @param isUp 是否上行
895   - */
896   - fnAdjustGfbc : function(isZgf, isUp) {
897   - var oStartTime; // 开始时间
898   - var oEndTime; // 结束时间
899   - var aStartBcIndex; // 开始班次索引
900   - var aEndBcIndex; // 结束班次索引
901   -
902   - oStartTime = isZgf ? _paramObj.getMPeakStartTimeObj() : _paramObj.getEPeakStartTimeObj();
903   - oEndTime = isZgf ? _paramObj.getMPeakEndTimeObj() : _paramObj.getEPeakEndTimeObj();
904   -
905   - aStartBcIndex = _fnFindUpClosedBcIndexWithTime(oStartTime, isUp);
906   - aEndBcIndex = _fnFindDownClosedBcIndexWithTime(oEndTime, isUp);
907   -
908   - var iLpIndex;
909   - var iQIndex;
910   - var iBcIndex;
911   - var iQInternelCount; // 高峰时间段中间包含的圈数
912   - var i;
913   - var j;
914   -
915   - var oLp;
916   -
917   - if (aStartBcIndex && aEndBcIndex) {
918   - iLpIndex = aStartBcIndex[0];
919   - iQIndex = aStartBcIndex[1];
920   - iBcIndex = aStartBcIndex[2];
921   -
922   - // 处理头
923   - // 删除头部多余班次
924   - for (j = 0; j < iLpIndex; j++) {
925   - oLp = _internalLpArray[j];
926   - if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
927   - oLp.removeBc(iQIndex, iBcIndex);
928   - }
929   - }
930   -
931   - for (j = iLpIndex; j < _internalLpArray.length; j++) {
932   - oLp = _internalLpArray[j];
933   - if (!oLp.getBc(iQIndex, iBcIndex)) {
934   - _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
935   - }
936   - }
937   -
938   - // 处理中间
939   - iQInternelCount = aEndBcIndex[1] - aStartBcIndex[1] - 1;
940   - for (i = 1; i <= iQInternelCount; i++) {
941   -
942   - for (j = 0; j < _internalLpArray.length; j++) {
943   - oLp = _internalLpArray[j];
944   - if (!oLp.getBc(iQIndex + i, iBcIndex)) {
945   - _fnGenerateBcAndSetBc(j, iQIndex + i, iBcIndex);
946   - }
947   - }
948   -
949   - }
950   -
951   - // 处理尾部
952   - iLpIndex = aEndBcIndex[0];
953   - iQIndex = aEndBcIndex[1];
954   - iBcIndex = aEndBcIndex[2];
955   -
956   - // 删除尾部多余的班次
957   - for (j = iLpIndex; j < _internalLpArray.length; j++) {
958   - oLp = _internalLpArray[j];
959   - if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
960   - oLp.removeBc(iQIndex, iBcIndex);
961   - }
962   - }
963   -
964   - if (aStartBcIndex[1] != aEndBcIndex[1]) { // 指定时间范围跨圈
965   - for (j = 0; j < iLpIndex; j++) {
966   - oLp = _internalLpArray[j];
967   - if (!oLp.getBc(iQIndex, iBcIndex)) {
968   - _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
969   - }
970   - }
971   - } else {
972   - // 不跨圈，不用处理，处理头的时候已经加了
973   - }
974   -
975   - }
976   -
977   - },
978   -
979   - /**
980   - * 按照营运时间要求补充班次，
981   - * 早高峰7:45分以前出场运营，
982   - * 晚高峰16:10分以前出场运营
983   - */
984   - fnCalcuLpBc_yy: function() {
985   - // 补班次的时候，针对的是分班班型
986   - var i;
987   - var _oLp;
988   - var _oBc;
989   - var _aMinBcIndex;
990   - var _aMaxBcIndex;
991   -
992   - var _qIndex;
993   - var _bIndex;
994   -
995   - var _zgfCDate = _paramObj.toTimeObj("7:45");
996   - var _wgfCDate = _paramObj.toTimeObj("16:10");
997   - var _ccsj;
998   -
999   - for (i = 0; i < _internalLpArray.length; i++) {
1000   - _oLp = _internalLpArray[i];
1001   - if (_oLp.isBxFb()) { // 分班路牌
1002   - // 早高峰部分
1003   - _aMinBcIndex = _oLp.getMinBcObjPosition();
1004   - _qIndex = _aMinBcIndex[0];
1005   - _bIndex = _aMinBcIndex[1];
1006   - _oBc = _oLp.getBc(_qIndex, _bIndex);
1007   - if (_qIsUp) {
1008   - _ccsj = _bIndex == 0 ?
1009   - _paramObj.getUpOutTime() :
1010   - _paramObj.getDownOutTime();
1011   - } else {
1012   - _ccsj = _bIndex == 0 ?
1013   - _paramObj.getDownOutTime() :
1014   - _paramObj.getUpOutTime();
1015   - }
1016   - if (_zgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
1017   - _fnGenerateBcAndSetBc(
1018   - i,
1019   - _bIndex == 0 ? _qIndex - 1 : _qIndex,
1020   - _bIndex == 0 ? 1 : 0
1021   - )
1022   - }
1023   -
1024   - // 晚高峰部分
1025   - _aMaxBcIndex = _oLp.getMaxBcObjPosition();
1026   - _qIndex = _aMaxBcIndex[0];
1027   - _bIndex = _aMaxBcIndex[1];
1028   - _oBc = _oLp.getBc(
1029   - _bIndex == 0 ? _qIndex - 1 : _qIndex,
1030   - _bIndex == 0 ? 1 : 0
1031   - );
1032   - if (!_oBc) { // 前一个班次不存在，再判定加不加
1033   - _oBc = _oLp.getBc(_qIndex, _bIndex);
1034   - if (_qIsUp) {
1035   - _ccsj = _bIndex == 0 ?
1036   - _paramObj.getUpOutTime() :
1037   - _paramObj.getDownOutTime();
1038   - } else {
1039   - _ccsj = _bIndex == 0 ?
1040   - _paramObj.getDownOutTime() :
1041   - _paramObj.getUpOutTime();
1042   - }
1043   - if (_wgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
1044   - _fnGenerateBcAndSetBc(
1045   - i,
1046   - _bIndex == 0 ? _qIndex - 1 : _qIndex,
1047   - _bIndex == 0 ? 1 : 0
1048   - )
1049   - }
1050   - }
1051   - }
1052   - }
1053   - },
1054   -
1055   - /**
1056   - * 补充做5休2的班型班次。
1057   - * 1、确认5_2班型大致多少圈（小数点过.7进位）
1058   - * 2、获取当前5_2两端车次链的信息，每段的班次数目，还差几个班次没加
1059   - * 3、如果前面的车次链班次少，则从前面的车次链开始加
1060   - * 4、如果车次链班次数一样，从从后面的车次链开始加
1061   - * 5、加班次时都是往车次链前方加
1062   - * 6、如果前面车次链不能再加班次了，从后面车次链加
1063   - */
1064   - fnCalcuLpBx_5_2: function() {
1065   - // 计算做5休2班型所需的班次数
1066   - var iBxBcount = _aBxDesc[6].fBcCount;
1067   - if (iBxBcount - Math.floor(iBxBcount) > 0.7) {
1068   - iBxBcount = Math.floor(iBxBcount) + 1;
1069   - } else {
1070   - iBxBcount = Math.floor(iBxBcount);
1071   - }
1072   -
1073   - var i;
1074   - var j;
1075   - var oLp;
1076   - var iAddBcCount;
1077   - var oBcChain1;
1078   - var oBcChain2;
1079   - var iQindex;
1080   - var iBindex;
1081   -
1082   - for (i = 0; i < _internalLpArray.length; i++) {
1083   - oLp = _internalLpArray[i];
1084   - if (oLp.isBxFb5_2()) {
1085   - iAddBcCount = iBxBcount - oLp.getBcArray().length; // 需要添加的班次数
1086   - for (j = 1; j <= iAddBcCount; j++) {
1087   - oBcChain1 = oLp.fnGetBcChainInfo(0);
1088   - oBcChain2 = oLp.fnGetBcChainInfo(1);
1089   -
1090   - if (oBcChain1.bcount < oBcChain2.bcount) {
1091   - iQindex = oBcChain1.s_b == 0 ? oBcChain1.s_q - 1 : oBcChain1.s_q;
1092   - iBindex = oBcChain1.s_b == 0 ? 1 : 0;
1093   - // 往车次链往前不能加，就往后加
1094   - if (_fnGenerateBc(i, iQindex, iBindex)) {
1095   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1096   - } else {
1097   - iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
1098   - iBindex = oBcChain1.e_b == 0 ? 1 : 0;
1099   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1100   - }
1101   -
1102   - } else if (oBcChain1.bcount > oBcChain2.bcount) {
1103   - iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
1104   - iBindex = oBcChain2.s_b == 0 ? 1 : 0;
1105   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1106   - } else {
1107   - iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
1108   - iBindex = oBcChain2.s_b == 0 ? 1 : 0;
1109   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1110   - }
1111   - }
1112   - }
1113   - }
1114   -
1115   - },
1116   -
1117   - /**
1118   - * 补其他分班班型班次。
1119   - * 从车次链的后面开始加
1120   - */
1121   - fnCalcuLpBx_other: function() {
1122   - // TODO：根据上标线的首班时间确定班型，小于05:59的做一休一，否则做二休一
1123   - var oSt = _qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
1124   - var iBxIndex = 4;
1125   - if (oSt.isBefore(_paramObj.toTimeObj("05:59"))) {
1126   - iBxIndex = 5;
1127   - }
1128   - // 计算做5休2班型所需的班次数
1129   - var iQBcount = _aBxDesc[iBxIndex].fQCount;
1130   - var iBxBcount = Math.round(iQBcount) * 2;
1131   -
1132   - var i;
1133   - var j;
1134   - var oLp;
1135   - var iAddBcCount;
1136   - var oBcChain1;
1137   - var oBcChain2;
1138   - var iQindex;
1139   - var iBindex;
1140   -
1141   - for (i = 0; i < _internalLpArray.length; i++) {
1142   - oLp = _internalLpArray[i];
1143   - if (oLp.isBxFb() && !oLp.isBxFb5_2()) {
1144   - iAddBcCount = iBxBcount - oLp.getBcArray().length; // 需要添加的班次数
1145   - for (j = 1; j <= iAddBcCount; j++) {
1146   - oBcChain1 = oLp.fnGetBcChainInfo(0);
1147   - oBcChain2 = oLp.fnGetBcChainInfo(1);
1148   -
1149   - if (oBcChain1.bcount < oBcChain2.bcount) {
1150   - iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
1151   - iBindex = oBcChain1.e_b == 0 ? 1 : 0;
1152   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1153   - } else if (oBcChain1.bcount > oBcChain2.bcount) {
1154   - iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
1155   - iBindex = oBcChain2.e_b == 0 ? 1 : 0;
1156   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1157   - } else {
1158   - iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
1159   - iBindex = oBcChain2.e_b == 0 ? 1 : 0;
1160   - _fnGenerateBcAndSetBc(i, iQindex, iBindex);
1161   - }
1162   - }
1163   - }
1164   - }
1165   -
1166   - },
1167   -
1168   - /**
1169   - * 补充连班路牌班次。
1170   - * 1、上标线，中标线中间的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向上标线起始班次靠拢
1171   - * 2、中标线以下的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向中标线起始班次靠拢
1172   - */
1173   - fnCalcuLpBx_lb: function() {
1174   - // 补充连班的班次，参照上标线，中标线补充不足的班次
1175   -
1176   - var aLbLpindexes = []; // 除上标线，中标线的连班路牌索引
1177   - var i;
1178   - for (i = 0; i < _internalLpArray.length; i++) {
1179   - if (_internalLpArray[i].isBxLb() && i != 0 && i != _iZbx_lpIndex) {
1180   - aLbLpindexes.push(i);
1181   - }
1182   - }
1183   -
1184   - var oEndsj = // 结束时间
1185   - _paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj()) ?
1186   - _paramObj.getDownLastDTimeObj() :
1187   - _paramObj.getUpLastDtimeObj();
1188   -
1189   - var oLp;
1190   - var aMinbcPos;
1191   - var oBc;
1192   - var j;
1193   - var iTempBcIndex;
1194   -
1195   - // 1、从最小班次开始，往后补充班次
1196   - for (i = 0; i < aLbLpindexes.length; i++) {
1197   - oLp = _internalLpArray[aLbLpindexes[i]];
1198   -
1199   - // 最小班次索引
1200   - aMinbcPos = oLp.getMinBcObjPosition();
1201   - // 使用纵向分隔补充班次，从最小班次向后补
1202   - iTempBcIndex = aMinbcPos[1] == 0 ? 1 : 0;
1203   - j = iTempBcIndex == 0 ? aMinbcPos[0] + 1 : aMinbcPos[0];
1204   -
1205   - while (j < _qCount) {
1206   - while (iTempBcIndex <= 1) {
1207   - oBc = _fnGenerateBc(aLbLpindexes[i], j, iTempBcIndex);
1208   - if (oBc &&
1209   - oBc.getFcTimeObj().isBefore(oEndsj) ) {
1210   - oLp.setBc(j, iTempBcIndex, oBc);
1211   - }
1212   - iTempBcIndex++;
1213   - }
1214   - iTempBcIndex = 0;
1215   - j++;
1216   - }
1217   -
1218   - }
1219   -
1220   - // 2、上标线中标线之间的路牌，从最小的班次往前补充班次
1221   -
1222   - // 还要补充缺失的班次，差上标线几个班次要往前补上
1223   - var iBccount;
1224   - var iQindex;
1225   - var iBindex;
1226   - // 补上标线到中标线之间的连班路牌的班次
1227   - for (i = 0; i < aLbLpindexes.length; i++) {
1228   - if (aLbLpindexes[i] > 0 && aLbLpindexes[i] < _iZbx_lpIndex) {
1229   - oLp = _internalLpArray[aLbLpindexes[i]];
1230   - aMinbcPos = oLp.getMinBcObjPosition();
1231   - iQindex = aMinbcPos[0];
1232   - iBindex = aMinbcPos[1];
1233   - iBccount = (iQindex - 1) * 2 + iBindex; // 距离上标线起始站点差几个班次
1234   - for (j = 0; j < iBccount; j++) {
1235   - if (iBindex == 0) {
1236   - iQindex --;
1237   - iBindex = 1;
1238   - _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
1239   - } else if (iBindex == 1) {
1240   - iBindex --;
1241   - _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
1242   - }
1243   - }
1244   -
1245   - }
1246   -
1247   - }
1248   -
1249   - // 3、中标线之后的路牌，从最小的班次往前补充班次
1250   -
1251   - // 补中标线以下的连班路牌的班次
1252   - for (i = 0; i < aLbLpindexes.length; i++) {
1253   - if (aLbLpindexes[i] > _iZbx_lpIndex) {
1254   - oLp = _internalLpArray[aLbLpindexes[i]];
1255   - aMinbcPos = oLp.getMinBcObjPosition();
1256   - iQindex = aMinbcPos[0];
1257   - iBindex = aMinbcPos[1];
1258   - iBccount = (iQindex - 0) * 2 + iBindex - 1; // 距离上标线起始站点差几个班次
1259   - for (j = 0; j < iBccount; j++) {
1260   - if (iBindex == 0) {
1261   - iQindex --;
1262   - iBindex = 1;
1263   - _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
1264   - } else if (iBindex == 1) {
1265   - iBindex --;
1266   - _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
1267   - }
1268   - }
1269   - }
1270   - }
1271   -
1272   - },
1273   -
1274   - /**
1275   - * 计算末班车。
1276   - * 1、将上下行拉成上下行两个班次列表（包括标记班次）
1277   - * 2、分别找出离末班车发车时间最近的班次，并替换时间
1278   - * 3、删除之后的班次
1279   - */
1280   - fnCalcuLastBc: function() {
1281   - var i;
1282   - var iTimeDiff;
1283   - var iTempTime;
1284   - var aBc;
1285   - var oLastBcTime;
1286   - var oLastBcIsUp;
1287   - var iModifyIndex;
1288   -
1289   - // 查找末班车早的末班车时间和方向
1290   - if (_paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj())) {
1291   - oLastBcTime = _paramObj.getUpLastDtimeObj();
1292   - oLastBcIsUp = true;
1293   - } else {
1294   - oLastBcTime = _paramObj.getDownLastDTimeObj();
1295   - oLastBcIsUp = false;
1296   - }
1297   -
1298   - // 确定早的末班车时间
1299   - aBc = _fnGetBcList(oLastBcIsUp);
1300   - for (i = 0; i < aBc.length; i++) {
1301   - iTempTime = oLastBcTime.diff(aBc[i].getFcTimeObj(), "m");
1302   - if (iTimeDiff == undefined) {
1303   - iTimeDiff = iTempTime;
1304   - iModifyIndex = i;
1305   - } else if (Math.abs(iTempTime) <= Math.abs(iTimeDiff)) {
1306   - iTimeDiff = iTempTime;
1307   - iModifyIndex = i;
1308   - }
1309   - }
1310   - aBc[iModifyIndex].addMinuteToFcsj(iTimeDiff); // 替换成末班车时间
1311   - aBc[iModifyIndex].fnSetDelFlag(false);
1312   - aBc[iModifyIndex].fnSetIsLastBc(true);
1313   - for (i = iModifyIndex + 1; i < aBc.length; i++) { // 删除多余班次
1314   - _qIsUp == oLastBcIsUp ?
1315   - aBc[i]._$$_internal_group_obj.setBc1(undefined) :
1316   - aBc[i]._$$_internal_group_obj.setBc2(undefined);
1317   - }
1318   -
1319   - // 查找末班车晚的末班车时间和方向
1320   - if (_paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj())) {
1321   - oLastBcTime = _paramObj.getDownLastDTimeObj();
1322   - oLastBcIsUp = false;
1323   - } else {
1324   - oLastBcTime = _paramObj.getUpLastDtimeObj();
1325   - oLastBcIsUp = true;
1326   - }
1327   - // 确定晚的末班车时间
1328   - aBc = _fnGetBcList(oLastBcIsUp);
1329   - var oBc;
1330   - var aBcIndex;
1331   - var iLpIndex;
1332   - var iQIndex;
1333   - var iBcIndex;
1334   -
1335   - iTimeDiff = undefined;
1336   - for (i = 0; i < aBc.length; i++) {
1337   - oBc = aBc[i];
1338   - aBcIndex = _fnGetBcIndex(oBc);
1339   -
1340   - iLpIndex = aBcIndex[0];
1341   - iQIndex = aBcIndex[2] == 0 ? aBcIndex[1] -1 : aBcIndex[1];
1342   - iBcIndex = aBcIndex[2] == 0 ? 1 : 0;
1343   -
1344   - if (!_internalLpArray[iLpIndex].getBc(iQIndex, iBcIndex)) {
1345   - continue;
1346   - }
1347   -
1348   - iTempTime = oLastBcTime.diff(aBc[i].getFcTimeObj(), "m");
1349   - if (iTimeDiff == undefined) {
1350   - iTimeDiff = iTempTime;
1351   - iModifyIndex = i;
1352   - } else if (Math.abs(iTempTime) <= Math.abs(iTimeDiff)) {
1353   - iTimeDiff = iTempTime;
1354   - iModifyIndex = i;
1355   - }
1356   - }
1357   - aBc[iModifyIndex].addMinuteToFcsj(iTimeDiff); // 替换成末班车时间
1358   - aBc[iModifyIndex].fnSetDelFlag(false);
1359   - aBc[iModifyIndex].fnSetIsLastBc(true);
1360   - for (i = iModifyIndex + 1; i < aBc.length; i++) { // 删除多余班次
1361   - _qIsUp == oLastBcIsUp ?
1362   - aBc[i]._$$_internal_group_obj.setBc1(undefined) :
1363   - aBc[i]._$$_internal_group_obj.setBc2(undefined);
1364   - }
1365   -
1366   - },
1367   -
1368   - /**
1369   - * 添加吃饭班次。
1370   - */
1371   - fnCalcuEatBc: function() {
1372   - // 吃午饭时间范围，10:15 到 12:15
1373   - // 吃晚饭时间范围，18:00 到 19:00
1374   -
1375   - if (!_paramObj.fnIsEat()) {
1376   - return;
1377   - }
1378   -
1379   - // 午饭index
1380   - var aLEIndex;
1381   - // 晚饭index
1382   - var aDEIndex;
1383   -
1384   - console.log("吃饭");
1385   - // 所有吃饭都默认在一个方向，两个方向暂时不考虑
1386   - if (_paramObj.fnIsUpEat()) {
1387   - aLEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("10:15"), true, false);
1388   - aDEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("18:00"), true, false);
1389   - } else {
1390   - aLEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("10:15"), false, true);
1391   - aDEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("18:00"), false, true);
1392   - }
1393   -
1394   - // 午饭第几圈，第几个班次
1395   - var iLEQIndex = aLEIndex[0];
1396   - var iLEBIndex = aLEIndex[1];
1397   - // 晚饭第几圈，第几个班次
1398   - var iDEQIndex = aDEIndex[0];
1399   - var iDEBIndex = aDEIndex[1];
1400   -
1401   - // 注意，本模型只有连班才有吃饭
1402   -
1403   - var i;
1404   - var oLp;
1405   - var aLbIndex = []; // 连班班型的路牌索引
1406   - for (i = 0; i < _internalLpArray.length; i++) {
1407   - oLp = _internalLpArray[i];
1408   - if (oLp.isBxLb()) {
1409   - aLbIndex.push(i);
1410   - }
1411   - }
1412   -
1413   - var iLTime;
1414   - var iDtime;
1415   - var j;
1416   - for (i = 0; i < aLbIndex.length; i++) {
1417   - oLp = _internalLpArray[aLbIndex[i]];
1418   -
1419   - // 午饭
1420   - iLTime = oLp.fnAddEatBc(iLEQIndex, iLEBIndex, _factory, _paramObj);
1421   - // 晚饭
1422   - iDtime = oLp.fnAddEatBc(iDEQIndex, iDEBIndex, _factory, _paramObj);
1423   -
1424   - if (i == aLbIndex.length - 1) {
1425   - for (j = aLbIndex[i]; j < _internalLpArray.length; j++) {
1426   - oLp = _internalLpArray[j];
1427   - if (oLp.isBxFb()) { // 5休2班型不调整
1428   - // 修正午饭之后路牌班次的发车时间
1429   - oLp.fnAddMinuteToBcFcsj(iLEQIndex, iLEBIndex, iLTime);
1430   - oLp.fnAddMinuteToBcFcsj(iDEQIndex, iDEBIndex, iDtime);
1431   - }
1432   - }
1433   - } else {
1434   - for (j = aLbIndex[i]; j < aLbIndex[i + 1]; j++) {
1435   - oLp = _internalLpArray[j];
1436   - if (oLp.isBxFb()) {
1437   - // 修正午饭之后路牌班次的发车时间
1438   - oLp.fnAddMinuteToBcFcsj(iLEQIndex, iLEBIndex, iLTime);
1439   - oLp.fnAddMinuteToBcFcsj(iDEQIndex, iDEBIndex, iDtime);
1440   - }
1441   - }
1442   - }
1443   - }
1444   -
1445   - },
1446   -
1447   - /**
1448   - * 补每个路牌的其他班次（进出场，例保班次）。
1449   - */
1450   - fnCalcuOtherBc_: function() {
1451   - var i;
1452   - var _lpObj;
1453   - var _minBcIndex;
1454   - var _maxBcIndex;
1455   - var _minBc;
1456   - var _maxBc;
1457   - var _otherbc = [];
1458   - var _oFbbc;
1459   -
1460   - for (i = 0; i < _internalLpArray.length; i++) {
1461   - _lpObj = _internalLpArray[i];
1462   - _minBcIndex = _lpObj.getMinBcObjPosition();
1463   - _maxBcIndex = _lpObj.getMaxBcObjPosition();
1464   - _minBc = _lpObj.getBc(_minBcIndex[0], _minBcIndex[1]);
1465   - _maxBc = _lpObj.getBc(_maxBcIndex[0], _maxBcIndex[1]);
1466   -
1467   - _otherbc = [];
1468   - _otherbc.push(_factory.createBcObj(
1469   - _lpObj, "bd", true, 1,
1470   - _minBc.getFcTimeObj(),
1471   - _paramObj
1472   - ));
1473   - _otherbc.push(_factory.createBcObj(
1474   - _lpObj, "out", true, 1,
1475   - _minBc.getFcTimeObj(),
1476   - _paramObj
1477   - ));
1478   -
1479   - _maxBc.setArrTimeObj(_paramObj.addMinute(_maxBc.getFcTimeObj(), _maxBc.getBcTime()));
1480   - _maxBc.setStopTime(0);
1481   - _otherbc.push(_factory.createBcObj(
1482   - _lpObj, "in", true, 1,
1483   - _maxBc.getArrTimeObj(),
1484   - _paramObj
1485   - ));
1486   - _otherbc.push(_factory.createBcObj(
1487   - _lpObj, "lc", true, 1,
1488   - _maxBc.getArrTimeObj(),
1489   - _paramObj
1490   - ));
1491   -
1492   - // 5休2分班出场例保班次
1493   - if (_lpObj.isBxFb5_2()) {
1494   - _oFbbc = _lpObj.getBc(
1495   - _lpObj.fnGetBcChainInfo(1)["s_q"],
1496   - _lpObj.fnGetBcChainInfo(1)["s_b"]
1497   - );
1498   -
1499   - _otherbc.push(_factory.createBcObj(
1500   - _lpObj, "bd", true, 1,
1501   - _oFbbc.getFcTimeObj(),
1502   - _paramObj
1503   - ));
1504   - _otherbc.push(_factory.createBcObj(
1505   - _lpObj, "out", true, 1,
1506   - _oFbbc.getFcTimeObj(),
1507   - _paramObj
1508   - ));
1509   - }
1510   -
1511   - _lpObj.addOtherBcArray(_otherbc);
1512   - }
1513   -
1514   - },
1515   -
1516   - /**
1517   - * 补每个路牌的其他班次（进出场，例保班次）
1518   - * 所有的车次链前后都加进出场、报道班次
1519   - */
1520   - fnCalcuOtherBc: function() {
1521   - var i;
1522   - var j;
1523   - var iBcChainCount;
1524   - var oLp;
1525   - var aOtherBc;
1526   - var oStartBc;
1527   - var oEndBc;
1528   -
1529   - for (i = 0; i < _internalLpArray.length; i++) {
1530   - aOtherBc = [];
1531   - oLp = _internalLpArray[i];
1532   - iBcChainCount = oLp.fnGetBcChainCount();
1533   -
1534   - if (iBcChainCount == 1) { // 只有一个车次链，是连班班型
1535   - // 头部要添加出场，例保班次
1536   - oStartBc = oLp.getBc(
1537   - oLp.fnGetBcChainInfo(0)["s_q"],
1538   - oLp.fnGetBcChainInfo(0)["s_b"]
1539   - );
1540   - aOtherBc.push(_factory.createBcObj(
1541   - oLp, "bd", oStartBc.isUp(), 1,
1542   - oStartBc.getFcTimeObj(),
1543   - _paramObj
1544   - ));
1545   - aOtherBc.push(_factory.createBcObj(
1546   - oLp, "out", oStartBc.isUp(), 1,
1547   - oStartBc.getFcTimeObj(),
1548   - _paramObj
1549   - ));
1550   -
1551   - // 尾部需添加进场，例保班次
1552   - oEndBc = oLp.getBc(
1553   - oLp.fnGetBcChainInfo(0)["e_q"],
1554   - oLp.fnGetBcChainInfo(0)["e_b"]
1555   - );
1556   - oEndBc.fnSetIsLastBc(false); // 有可能最后一个班次是吃饭班次，重置
1557   - oEndBc.fnSetEatTime(0); // 有可能最后一个班次是吃饭班次，重置
1558   - aOtherBc.push(_factory.createBcObj(
1559   - oLp, "in", !oEndBc.isUp(), 1,
1560   - oEndBc.getArrTimeObj(),
1561   - _paramObj
1562   - ));
1563   - aOtherBc.push(_factory.createBcObj(
1564   - oLp, "lc", !oEndBc.isUp(), 1,
1565   - oEndBc.getArrTimeObj(),
1566   - _paramObj
1567   - ));
1568   - } else if (iBcChainCount == 2) { // 两个车次链，是分班班型
1569   - // 第一个车次链开头有出场，报到班次，车次链结尾只有进场班次
1570   - oStartBc = oLp.getBc(
1571   - oLp.fnGetBcChainInfo(0)["s_q"],
1572   - oLp.fnGetBcChainInfo(0)["s_b"]
1573   - );
1574   - aOtherBc.push(_factory.createBcObj(
1575   - oLp, "bd", oStartBc.isUp(), 1,
1576   - oStartBc.getFcTimeObj(),
1577   - _paramObj
1578   - ));
1579   - aOtherBc.push(_factory.createBcObj(
1580   - oLp, "out", oStartBc.isUp(), 1,
1581   - oStartBc.getFcTimeObj(),
1582   - _paramObj
1583   - ));
1584   -
1585   - oEndBc = oLp.getBc(
1586   - oLp.fnGetBcChainInfo(0)["e_q"],
1587   - oLp.fnGetBcChainInfo(0)["e_b"]
1588   - );
1589   - aOtherBc.push(_factory.createBcObj(
1590   - oLp, "in", !oEndBc.isUp(), 1,
1591   - oEndBc.getArrTimeObj(),
1592   - _paramObj
1593   - ));
1594   -
1595   - // 第二个车次链开头有出场，报到班次，车次链结尾有进场，报到班次
1596   - oStartBc = oLp.getBc(
1597   - oLp.fnGetBcChainInfo(1)["s_q"],
1598   - oLp.fnGetBcChainInfo(1)["s_b"]
1599   - );
1600   - aOtherBc.push(_factory.createBcObj(
1601   - oLp, "bd", oStartBc.isUp(), 1,
1602   - oStartBc.getFcTimeObj(),
1603   - _paramObj
1604   - ));
1605   - aOtherBc.push(_factory.createBcObj(
1606   - oLp, "out", oStartBc.isUp(), 1,
1607   - oStartBc.getFcTimeObj(),
1608   - _paramObj
1609   - ));
1610   -
1611   - oEndBc = oLp.getBc(
1612   - oLp.fnGetBcChainInfo(1)["e_q"],
1613   - oLp.fnGetBcChainInfo(1)["e_b"]
1614   - );
1615   - aOtherBc.push(_factory.createBcObj(
1616   - oLp, "in", !oEndBc.isUp(), 1,
1617   - oEndBc.getArrTimeObj(),
1618   - _paramObj
1619   - ));
1620   - aOtherBc.push(_factory.createBcObj(
1621   - oLp, "lc", !oEndBc.isUp(), 1,
1622   - oEndBc.getArrTimeObj(),
1623   - _paramObj
1624   - ));
1625   -
1626   -
1627   - } else {
1628   - // 2个车次链以上，暂时没有此班型
1629   - }
1630   -
1631   - oLp.addOtherBcArray(aOtherBc);
1632   - }
1633   - },
1634   -
1635   - /**
1636   - * 祛除上标线开头的删除标记的班次。
1637   - */
1638   - fnRemoveDelFirstFlagBc: function() {
1639   - var oLp = _internalLpArray[0];
1640   - var aMinBcIndex = oLp.getMinBcObjPosition();
1641   - if (oLp.getBc(aMinBcIndex[0], aMinBcIndex[1]).fnIsDelFlag()) {
1642   - oLp.removeBc(aMinBcIndex[0], aMinBcIndex[1]);
1643   - }
1644   - },
1645   - /**
1646   - * 祛除上标线结尾的删除标记的班次。
1647   - */
1648   - fnRemoveDelLastFlagBc: function() {
1649   - var oLp = _internalLpArray[0];
1650   - var aMaxBcIndex = oLp.getMaxBcObjPosition();
1651   - if (oLp.getBc(aMaxBcIndex[0], aMaxBcIndex[1]).fnIsDelFlag()) {
1652   - oLp.removeBc(aMaxBcIndex[0], aMaxBcIndex[1]);
1653   - }
1654   - },
1655   -
1656   - /**
1657   - * 调整路牌班次间隔（核准周转时间，停站时间）。
1658   - * @param iFre int 迭代次数
1659   - */
1660   - fnAdjustLpBcInterval: function(iFre) {
1661   - // if (iFre > 0) {
1662   - // for (var i = 0; i < _internalLpArray.length; i++) {
1663   - // _internalLpArray[i].fnAdjustBcInterval(
1664   - // this.fnCalcuAverPeakStopTime(),
1665   - // this.fnCalcuAverTroughStopTime(),
1666   - // _paramObj);
1667   - // }
1668   - //
1669   - // this.fnAdjustLpBcInterval(iFre - 1);
1670   - // }
1671   -
1672   - for (var i = 0; i < _internalLpArray.length; i++) {
1673   - _internalLpArray[i].fnAdjustBcTime(_paramObj);
1674   - }
1675   - },
1676   -
1677   - /**
1678   - * 调整班次间隔。
1679   - * @param bIsUp 是否上行
1680   - * @param oStartTime 开始时间对象
1681   - * @param iFre 迭代次数
1682   - */
1683   - fnAdjustBcInterval2_: function(bIsUp, oStartTime, iFre) {
1684   - if (iFre > 0) {
1685   - var aBc = _fnGetBcList2(bIsUp, oStartTime); // 指定方向的班次列表
1686   - aBc.sort(function(o1, o2) {
1687   - if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
1688   - return -1;
1689   - } else {
1690   - return 1;
1691   - }
1692   - });
1693   - var i;
1694   - var j;
1695   -
1696   - var iBcCountOfGroup = 3; // 3个班次取一次计算
1697   - var aBcOfGroup; // 3个班次列表
1698   - var aBcIntervalOfGroup; // 班次间隔列表，如：3个班次，2个间隔
1699   -
1700   - for (i = 0; i <= aBc.length - iBcCountOfGroup; i++) {
1701   - aBcOfGroup = [];
1702   - aBcIntervalOfGroup = [];
1703   - for (j = i; j < i + iBcCountOfGroup; j++) {
1704   - aBcOfGroup.push(aBc[j]);
1705   - }
1706   -
1707   - for (j = 0; j < aBcOfGroup.length; j++) {
1708   - if (j < aBcOfGroup.length - 1) {
1709   - aBcIntervalOfGroup.push(aBcOfGroup[j + 1].getFcTimeObj().diff(
1710   - aBcOfGroup[j].getFcTimeObj(), "m"));
1711   - }
1712   - }
1713   -
1714   - if (aBcIntervalOfGroup[0] < 19) {
1715   - aBcOfGroup[1].addMinuteToFcsj(1);
1716   - } else if (aBcIntervalOfGroup[0] > 20) {
1717   - aBcOfGroup[1].addMinuteToFcsj(-1);
1718   - } else {
1719   - if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
1720   - //continue;
1721   - } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
1722   - aBcOfGroup[1].addMinuteToFcsj(-1);
1723   - } else {
1724   - aBcOfGroup[1].addMinuteToFcsj(1);
1725   - }
1726   - }
1727   -
1728   - }
1729   -
1730   - this.fnAdjustBcInterval2(bIsUp, oStartTime, iFre - 1);
1731   - }
1732   - },
1733   -
1734   - /**
1735   - * 调整班次间隔（使用策略类）。
1736   - * @param oStartTime 开始时间对象
1737   - */
1738   - fnAdjustBcInterval: function(oStartTime) {
1739   - // 获取上行班次列表
1740   - var aUpBc = !oStartTime ? _fnGetBcList(true) : _fnGetBcList2(true, oStartTime); // 指定方向的班次列表
1741   - var aDownBc = !oStartTime ? _fnGetBcList(false) : _fnGetBcList2(false, oStartTime); // 指定方向的班次列表
1742   - // 使用策略类调用指定策略函数，注意 AdjustTripStrategy.js 导入
1743   - AdjustTripStrategy.sFn("ADJUST_TRIP")(aUpBc, aDownBc, this, _paramObj);
1744   -
1745   - },
1746   -
1747   - /**
1748   - * 调整班次间隔（平均间隔）。
1749   - * @param bIsUp 是否上行
1750   - * @param oStartTime 开始时间对象
1751   - */
1752   - fnAdjustBcInterval2_avg: function(bIsUp, oStartTime) {
1753   - var aBc = !oStartTime ? _fnGetBcList(bIsUp) : _fnGetBcList2(bIsUp, oStartTime); // 指定方向的班次列表
1754   - aBc.sort(function(o1, o2) {
1755   - if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
1756   - return -1;
1757   - } else {
1758   - return 1;
1759   - }
1760   - });
1761   -
1762   - if (aBc.length == 0) {
1763   - return;
1764   - }
1765   -
1766   - var j;
1767   - var iCount = aBc.length - 1;
1768   - var iC1 = Math.floor(aBc[aBc.length - 1].getFcTimeObj().diff(aBc[0].getFcTimeObj(), "m") / iCount);
1769   - var iC2 = aBc[aBc.length - 1].getFcTimeObj().diff(aBc[0].getFcTimeObj(), "m") % iCount;
1770   - var iTempTime;
1771   -
1772   - for (j = 0; j < iCount - iC2; j++) {
1773   - iTempTime = aBc[j + 1].getFcTimeObj().diff(aBc[j].getFcTimeObj(), "m");
1774   - aBc[j + 1].addMinuteToFcsj(iC1 - iTempTime);
1775   - }
1776   - for (j = 0; j < iC2; j++) {
1777   - iTempTime = aBc[iCount - iC2 + j + 1].getFcTimeObj().diff(aBc[iCount - iC2 + j].getFcTimeObj(), "m");
1778   - aBc[iCount - iC2 + j + 1].addMinuteToFcsj(iC1 + 1 - iTempTime);
1779   - }
1780   -
1781   - },
1782   -
1783   - /**
1784   - * 计算高峰平均停站时间。
1785   - */
1786   - fnCalcuAverPeakStopTime: function() {
1787   - var i;
1788   - var j;
1789   - var aBc;
1790   - var iBcCount = 0;
1791   - var iSum = 0;
1792   - for (i = 0; i < _internalLpArray.length; i++) {
1793   - aBc = _internalLpArray[i].getBcArray();
1794   -
1795   - for (j = 0; j < aBc.length; j++) {
1796   - if (!_paramObj.isTroughBc(aBc[j].getArrTimeObj())) {
1797   - iBcCount ++;
1798   - iSum += aBc[j].getStopTime();
1799   - }
1800   - }
1801   - }
1802   -
1803   - return Math.floor(iSum / iBcCount);
1804   - },
1805   -
1806   - /**
1807   - * 计算低谷平均停站时间。
1808   - */
1809   - fnCalcuAverTroughStopTime: function() {
1810   - var i;
1811   - var j;
1812   - var aBc;
1813   - var iBcCount = 0;
1814   - var iSum = 0;
1815   - for (i = 0; i < _internalLpArray.length; i++) {
1816   - aBc = _internalLpArray[i].getBcArray();
1817   - for (j = 0; j < aBc.length; j++) {
1818   - if (_paramObj.isTroughBc(aBc[j].getArrTimeObj())) {
1819   - iBcCount ++;
1820   - iSum += aBc[j].getStopTime();
1821   - }
1822   - }
1823   - }
1824   -
1825   - return Math.floor(iSum / iBcCount);
1826   - },
1827   -
1828   - //------------- 其他方法 -------------//
1829   - /**
1830   - * 返回内部路牌数据列表。
1831   - * @returns {Array}
1832   - */
1833   - fnGetLpArray: function() {
1834   - return _internalLpArray;
1835   - },
1836   -
1837   - /**
1838   - * 内部数据转化成显示用的班次数组。
1839   - */
1840   - fnToGanttBcArray: function() {
1841   - var aAllBc = [];
1842   - var aLpBc = [];
1843   - var aEatBc = [];
1844   - var oLp;
1845   - var i;
1846   - var j;
1847   -
1848   - for (i = 0; i < _internalLpArray.length; i++) {
1849   - oLp = _internalLpArray[i];
1850   - aLpBc = [];
1851   - aLpBc = aLpBc.concat(oLp.getOtherBcArray(), oLp.getBcArray());
1852   -
1853   - aEatBc = [];
1854   - // 根据班次的吃饭时间添加吃饭班次
1855   - for (j = 0; j < aLpBc.length; j++) {
1856   - if (aLpBc[j].fnGetEatTime() > 0) {
1857   - aEatBc.push(_factory.createBcObj(
1858   - oLp,
1859   - "cf",
1860   - !aLpBc[j].isUp(), // 和上一个班次方向相反
1861   - 1,
1862   - _paramObj.addMinute(aLpBc[j].getArrTimeObj(), aLpBc[j].getStopTime()), // 使用上一个班次的到达时间作为开始时间
1863   - _paramObj
1864   - ));
1865   - }
1866   - }
1867   - aLpBc = aLpBc.concat(aEatBc);
1868   -
1869   - // 按照发车时间排序
1870   - aLpBc.sort(function(o1, o2) {
1871   - if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
1872   - return -1;
1873   - } else {
1874   - return 1;
1875   - }
1876   - });
1877   -
1878   - // 重新赋值fcno
1879   - for (j = 0; j < aLpBc.length; j++) {
1880   - aLpBc[j].fnSetFcno(j + 1);
1881   - }
1882   -
1883   - aAllBc = aAllBc.concat(aLpBc);
1884   - }
1885   -
1886   - var aGanttBc = [];
1887   - for (i = 0; i < aAllBc.length; i++) {
1888   - aGanttBc.push(aAllBc[i].toGanttBcObj());
1889   - }
1890   -
1891   - return aGanttBc;
1892   - }
1893   -
1894   - };
1895   -
  1 +/**
  2 + * 内部行车计划对象。
  3 + * @constructor
  4 + */
  5 +var InternalScheduleObj = function(paramObj, lpArray, factory) {
  6 + // 参数对象
  7 + var _paramObj = paramObj;
  8 + // 外部的路牌数组
  9 + var _lpArray = lpArray;
  10 + // 工厂对象
  11 + var _factory = factory;
  12 +
  13 + //------------------ 初始化方法1，以及计算关联的内部变量 -----------------//
  14 + var _qIsUp; // 每一圈是上行开始还是下行开始
  15 + var _qCount = 0; // 总的圈数
  16 + var _internalLpArray = []; // 内部对象数组
  17 + var _aBxDesc = [ // 各种班型描述（班型名称,平均工时,平均需要的班次数,平均工时）
  18 + {'sType':'六工一休', 'fHoursV':6.66, 'fBcCount': 0, 'fAverTime': 0},
  19 + {'sType':'五工一休', 'fHoursV':6.85, 'fBcCount': 0, 'fAverTime': 0},
  20 + {'sType':'四工一休', 'fHoursV':7.14, 'fBcCount': 0, 'fAverTime': 0},
  21 + {'sType':'三工一休', 'fHoursV':7.61, 'fBcCount': 0, 'fAverTime': 0},
  22 + {'sType':'二工一休', 'fHoursV':8.57, 'fBcCount': 0, 'fAverTime': 0},
  23 + {'sType':'一工一休', 'fHoursV':11.42, 'fBcCount': 0, 'fAverTime': 0},
  24 + {'sType':'五工二休', 'fHoursV':7.99, 'fBcCount': 0, 'fAverTime': 0},
  25 + {'sType':'无工休', 'fHoursV':5.43, 'fBcCount': 0, 'fAverTime': 0}
  26 + ];
  27 +
  28 + var _fnInitFun1 = function() { // 初始化方法1
  29 + console.log("//---------------- 行车计划，初始化方法1 start ----------------//");
  30 +
  31 + //----------------------- 1、确定上标线的方向，圈的方向 -------------------//
  32 +
  33 + // 确定_qIsUp，哪个方向的首班车晚就用哪个
  34 + _qIsUp = _paramObj.getUpFirstDTimeObj().isBefore(
  35 + _paramObj.getDownFirstDTimeObj()) ? false : true;
  36 + // 上标线开始时间，就是方向的首班车时间
  37 + var st = _qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  38 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  39 + var et;
  40 + var et_IsUp;
  41 + if (_paramObj.getUpLastDtimeObj().isBefore(
  42 + _paramObj.getDownLastDTimeObj())) {
  43 + et = _paramObj.getDownLastDTimeObj();
  44 + et_IsUp = false;
  45 + } else {
  46 + et = _paramObj.getUpLastDtimeObj();
  47 + et_IsUp = true;
  48 + }
  49 +
  50 + //------------------------ 2、计算总共有多少圈 ------------------------//
  51 +
  52 + // 以开始时间，结束时间，构造上标线用连班班次发车时间
  53 + var bcFcsjArrays = []; // 班次发车时间对象数组
  54 + var bcArsjArrays = []; // 班次到达时间对象数组
  55 + var isUp = _qIsUp; // 方向
  56 + var bcCount = 1; // 班次数
  57 +
  58 + var _kssj = st; // 开始时间
  59 + var _bcsj = paramObj.calcuTravelTime(_kssj, isUp); // 班次历时
  60 + var _arrsj = paramObj.addMinute(_kssj, _bcsj); // 到达时间
  61 + var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj); // 停站时间
  62 +
  63 + do {
  64 + bcFcsjArrays.push(_kssj);
  65 + bcArsjArrays.push(_arrsj);
  66 +
  67 + _kssj = paramObj.addMinute(_kssj, _bcsj + _stoptime);
  68 + _bcsj = paramObj.calcuTravelTime(_kssj, isUp);
  69 + _arrsj = paramObj.addMinute(_kssj, _bcsj);
  70 + _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
  71 +
  72 + bcCount ++;
  73 + isUp = !isUp;
  74 + } while(_kssj.isBefore(et));
  75 + bcCount--; // 因为先做do，所以总的班次要减1
  76 + //if (bcCount > 0 && bcArsjArrays[bcCount - 1].isAfter(et)) {
  77 + // // 如果最后一个班次的到达时间超过结束时间，也要去除
  78 + // bcFcsjArrays.splice(bcCount - 1, 1);
  79 + // bcArsjArrays.splice(bcCount - 1, 1);
  80 + // bcCount--;
  81 + //}
  82 + var _qCount_p1 = Math.floor(bcCount / 2); // 2个班次一圈
  83 + var _qCount_p2 = bcCount % 2; // 余下的1个班次也算一圈
  84 +
  85 + // 利用连班数组计算圈数
  86 + _qCount = 1; // 前面加1圈，补中标线的班次
  87 + _qCount += _qCount_p1;
  88 + _qCount += _qCount_p2;
  89 +
  90 + // 计算最后是不是还要补一圈
  91 + if (_qCount > 1) { // 总的圈数就1圈，没必要加了（其实是不可能的，除非参数里问题）
  92 + if (_qCount_p2 == 0) { // 没有余下班次，整数圈数
  93 + // 最后一个班次的方向一定和开始的方向相反，如：上-下,上-下,上-下，一共三圈，最后一个班次为下行
  94 + // 判定最后一个班次的方向和上标线判定结束时间的班次方向是否一致
  95 + if (!_qIsUp == et_IsUp) {
  96 + // 一致不用加圈数
  97 + } else {
  98 + // 不一致需要加圈补最后一个结束时间班次
  99 + _qCount ++;
  100 + }
  101 + } else {
  102 + // 有余下的圈数，最后要不补的班次不管上行，下行都在这一圈里
  103 + // 不需要在补圈数了
  104 + }
  105 + }
  106 +
  107 + //------------------------ 3、根据路牌数，圈数创建路牌对象 ----------------------//
  108 +
  109 + // 创建内部的路牌数组，并把之前的连班路牌添加进上标线路牌中
  110 + var i;
  111 + for (i = 0; i < _lpArray.length; i++) {
  112 + _internalLpArray.push(new InternalLpObj(_lpArray[i], _qCount, _qIsUp));
  113 + }
  114 + // 初始化上标线，从第1圈开始
  115 + _internalLpArray[0].initDataFromTimeToTime(bcFcsjArrays[0], et, _qIsUp, 1, _paramObj, _factory);
  116 +
  117 + // 以上标线为基础，计算各种班型工时对应的圈数、班次数
  118 + var aBcArray = _internalLpArray[0].getBcArray();
  119 + aBcArray[0].fnSetIsFirstBc(true); // 设置首班班次标识
  120 +
  121 + if (aBcArray.length % 2 != 0) { // 不能整除2，去除一个班次计算
  122 + aBcArray.splice(aBcArray.length - 1, 1);
  123 + }
  124 +
  125 + // 午饭吃饭时间
  126 + var iLTime = _paramObj.fnGetLunchTime();
  127 + // 晚饭吃饭时间
  128 + var iDTime = _paramObj.fnGetDinnerTime();
  129 + // 出场时间
  130 + var iOutTime = _qIsUp ? _paramObj.getUpOutTime() : _paramObj.getDownOutTime();
  131 + // 进场时间
  132 + var iInTime = _qIsUp ? _paramObj.getDownInTime() : _paramObj.getUpInTime();
  133 + // 例保时间
  134 + var iBTime = _paramObj.getLbTime();
  135 +
  136 + var sum = 0; // 总班次时间
  137 + for (i = 0; i < aBcArray.length; i++) {
  138 + sum += aBcArray[i].getBcTime() + aBcArray[i].getStopTime();
  139 + }
  140 + sum += iLTime; // 加午饭时间
  141 + sum += iDTime; // 加晚饭时间
  142 + for (i = 0; i < _aBxDesc.length; i++) {
  143 + _aBxDesc[i].fAverTime = sum / (aBcArray.length / 2); // 平均周转时间不算进出场，例保时间
  144 +
  145 + // 计算5休2的班次数（双进出场，4个例保）
  146 + if (i == 6) {
  147 + _aBxDesc[i].fQCount =
  148 + (_aBxDesc[i].fHoursV * 60 - iOutTime * 2 - iInTime * 2 - iBTime * 4) /
  149 + _aBxDesc[i].fAverTime;
  150 + _aBxDesc[i].fBcCount = _aBxDesc[i].fQCount * 2;
  151 + } else { // 进出场，2个例保
  152 + _aBxDesc[i].fQCount =
  153 + (_aBxDesc[i].fHoursV * 60 - iOutTime - iInTime - iBTime * 2) /
  154 + _aBxDesc[i].fAverTime;
  155 + _aBxDesc[i].fBcCount = _aBxDesc[i].fQCount * 2;
  156 + }
  157 + }
  158 +
  159 +
  160 + // 在第一个班次之前再添加一个模拟班次，用于中标线的作用
  161 + // 那一圈必定是低谷，而且圈索引0，班次索引1，暂时标记，最后删除
  162 + var iXXTime = _qIsUp ? _paramObj.getDownTroughTime() : _paramObj.getUpTroughTime();
  163 + var iFirstStopTime =
  164 + _paramObj.fnCalcuFixedStopNumber(
  165 + _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -10),
  166 + _qIsUp,
  167 + iXXTime
  168 + );
  169 + var oFlagBc = _factory.createBcObj( // 标记班次
  170 + _internalLpArray[0],
  171 + "normal",
  172 + !_qIsUp,
  173 + 1,
  174 + _paramObj.addMinute(aBcArray[0].getFcTimeObj(), -(iFirstStopTime + iXXTime)),
  175 + _paramObj
  176 + );
  177 + console.log("ddfdfdf=" + (iFirstStopTime));
  178 + console.log("ddfdfdf=" + (iXXTime));
  179 + console.log("ttt ==" + oFlagBc.getFcTimeObj().format("HH:mm"));
  180 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  181 +
  182 + _internalLpArray[0].setBc(0, 1, oFlagBc);
  183 +
  184 + // 在最后一圈也补上一个或者2个模拟班次，暂时标记，最后需要删除
  185 + var aMaxBcIndex = _internalLpArray[0].getMaxBcObjPosition();
  186 + if (aMaxBcIndex[0] == _qCount - 1) { // 可能加半圈
  187 + oFlagBc = _factory.createBcObj( // 标记班次
  188 + _internalLpArray[0],
  189 + "normal",
  190 + !_qIsUp,
  191 + 1,
  192 + _paramObj.addMinute(
  193 + _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
  194 + _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
  195 + _paramObj
  196 + );
  197 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  198 + _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
  199 +
  200 + } else { // 加完整的一圈
  201 + oFlagBc = _factory.createBcObj( // 标记班次
  202 + _internalLpArray[0],
  203 + "normal",
  204 + _qIsUp,
  205 + 1,
  206 + _paramObj.addMinute(
  207 + _internalLpArray[0].getBc(_qCount - 2, 1).getArrTimeObj(),
  208 + _internalLpArray[0].getBc(_qCount - 2, 1).getStopTime()),
  209 + _paramObj
  210 + );
  211 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  212 + _internalLpArray[0].setBc(_qCount - 1, 0, oFlagBc);
  213 +
  214 + oFlagBc = _factory.createBcObj( // 标记班次
  215 + _internalLpArray[0],
  216 + "normal",
  217 + !_qIsUp,
  218 + 1,
  219 + _paramObj.addMinute(
  220 + _internalLpArray[0].getBc(_qCount - 1, 0).getArrTimeObj(),
  221 + _internalLpArray[0].getBc(_qCount - 1, 0).getStopTime()),
  222 + _paramObj
  223 + );
  224 + oFlagBc.fnSetDelFlag(true); // 标记了删除记号
  225 + _internalLpArray[0].setBc(_qCount - 1, 1, oFlagBc);
  226 +
  227 + }
  228 +
  229 + console.log("上行首班车时间:" + _paramObj.getUpFirstDTimeObj().format("HH:mm") +
  230 + "上行末班车时间:" + _paramObj.getUpLastDtimeObj().format("HH:mm"));
  231 + console.log("下行首班车时间:" + _paramObj.getDownFirstDTimeObj().format("HH:mm") +
  232 + "下行末班车时间:" + _paramObj.getDownLastDTimeObj().format("HH:mm"));
  233 + console.log("总共计算的圈数:" + _qCount);
  234 + console.log("圈的方向isUP:" + _qIsUp);
  235 + console.log("班型描述（以下）:");
  236 + console.log(_aBxDesc);
  237 + console.log("所有路牌间隔描述（以下）:");
  238 + for (i = 0; i < _internalLpArray.length; i++) {
  239 + console.log(_internalLpArray[i]._$_aVerticalIntervalTime);
  240 + }
  241 + console.log("//---------------- 行车计划，初始化方法1 end ----------------//");
  242 +
  243 + };
  244 +
  245 + //------------------ 初始化方法2，以及计算关联的内部变量 ----------------//
  246 + var _approximate_zgfQIndex; // 预估早高峰车辆从第几圈开始全部发出
  247 + var _approximate_zgfBIndex; // 预估早高峰车辆从第几圈第几个班次开始全部发出（上行或下行）
  248 + var _approximate_wgfQIndex; // 预估晚高峰车辆从第几圈开始全部发出
  249 + var _approximate_wgfBIndex; // 预估晚高峰车辆从第几圈第几个班次开始全部发出（上行或下行）
  250 +
  251 + var _fnInitFun2 = function() { // 初始化方法2
  252 + console.log("//---------------- 行车计划，初始化方法2 start ----------------//");
  253 +
  254 + //------------------------ 1、计算车辆总数 ------------------------//
  255 + // 是用高峰上行周转时间除以高峰平均间隔得到的
  256 + // 这样算还算合理，车辆不多不少，待以后有新的算法再修正
  257 + var iClCount = _paramObj.calcuClzx();
  258 +
  259 + //------------------------ 2、计算所有路牌的发车在各个圈中的间隔 --------------------//
  260 + var i;
  261 + var j;
  262 + var iBindex = 1;
  263 + var iZzsj;
  264 + var oLp;
  265 + var iC1;
  266 + var iC2;
  267 +
  268 + for (i = 0; i < _qCount - 1; i++) {
  269 + while (iBindex <= 1) {
  270 + // 每圈每个方向的周转时间不一致，以上标线为主
  271 + oLp = _internalLpArray[0];
  272 + iZzsj = oLp.getBc(i + 1, iBindex).getFcTimeObj().diff(
  273 + oLp.getBc(i, iBindex).getFcTimeObj(), "m"
  274 + );
  275 +
  276 + iC1 = Math.floor(iZzsj / iClCount);
  277 + iC2 = iZzsj % iClCount;
  278 +
  279 + for (j = 0; j < iClCount - iC2; j++) {
  280 + oLp = _internalLpArray[j];
  281 + oLp.fnSetVerticalIntervalTime(i, iBindex, iC1);
  282 + }
  283 +
  284 + for (j = 0; j < iC2; j++) {
  285 + oLp = _internalLpArray[iClCount - iC2 + j];
  286 + oLp.fnSetVerticalIntervalTime(i, iBindex, iC1 + 1);
  287 + }
  288 +
  289 + iBindex ++;
  290 +
  291 + }
  292 + iBindex = 0;
  293 + }
  294 + // 最后一圈没有下一圈的参照，周转时间没发获取，由于都是低谷，所以使用倒数第二圈的间隔最为最后一圈的间隔
  295 + for (i = 0; i < _internalLpArray.length; i++) {
  296 + oLp = _internalLpArray[i];
  297 + oLp.fnSetVerticalIntervalTime(_qCount - 1, 0, oLp.fnGetVerticalIntervalTime(_qCount - 2, 0));
  298 + oLp.fnSetVerticalIntervalTime(_qCount - 1, 1, oLp.fnGetVerticalIntervalTime(_qCount - 2, 1));
  299 + }
  300 +
  301 + //------------------------ 3、预估早高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
  302 +
  303 + // 以上标线为标准，查找离早高峰开始时间最近的班次作为早高峰开始班次
  304 + // 以这个班次为早高峰起点，全部出车策略
  305 + var qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
  306 + _paramObj.getMPeakStartTimeObj(), true, true);
  307 + var qIndex = qbcIndexArray[0]; // 第几圈
  308 + var bIndex = qbcIndexArray[1]; // 第几个班次
  309 +
  310 + for (i = 1; i < _internalLpArray.length; i++) {
  311 + _fnGenerateBcAndSetBc(i, qIndex, bIndex);
  312 + }
  313 +
  314 + _approximate_zgfQIndex = qIndex;
  315 + _approximate_zgfBIndex = bIndex;
  316 +
  317 + //------------------------ 4、预估晚高峰全部出车第几圈第几个班次全部出车，计算路牌之间的发车间隔 ------------------//
  318 +
  319 + // 以上标线为标准，查找离晚高峰开始时间最近的班次作为晚高峰开始班次
  320 + // 以这个班次为早高峰起点，全部出车策略
  321 + qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
  322 + _paramObj.getEPeakStartTimeObj(), true, true);
  323 + qIndex = qbcIndexArray[0]; // 第几圈
  324 + bIndex = qbcIndexArray[1]; // 第几个班次
  325 +
  326 + for (i = 1; i < _internalLpArray.length; i++) {
  327 + _fnGenerateBcAndSetBc(i, qIndex, bIndex);
  328 + }
  329 +
  330 + _approximate_wgfQIndex = qIndex;
  331 + _approximate_wgfBIndex = bIndex;
  332 +
  333 + console.log("早高峰周转时间(固定最大停战时间):" + _paramObj.calcuPeakZzsj() + "分钟");
  334 + console.log("早高峰发车时间范围:" + _paramObj.getMPeakMinFcjx() + "分钟 --- " + _paramObj.getMPeakMaxFcjx() + "分钟");
  335 + console.log("预估早高峰第" + _approximate_zgfQIndex + "(index)圈,第" + _approximate_zgfBIndex + "(index)班次车辆全部发出");
  336 + console.log("预估晚高峰第" + _approximate_wgfQIndex + "(index)圈,第" + _approximate_wgfBIndex + "(index)班次车辆全部发出");
  337 + console.log("//---------------- 行车计划，初始化方法2 end ----------------//");
  338 + };
  339 +
  340 + //----------------------- 初始化方法3，计算连班分班的路牌分布 ----------------//
  341 + var _iBx_lb_lpcount; // 连班路牌数
  342 + var _iBx_5_2_fb_lpcount; // 5休2分班路牌数
  343 + var _iBx_other_fb_lpcount; // 其他分班路牌数
  344 +
  345 + var _fnInitFun3 = function() { // 初始化方法3
  346 + console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
  347 +
  348 + //--------------------- 1、计算分班连班班型车辆分布数 --------------------//
  349 + // 总共车辆数（高峰最大车辆数）
  350 + var iCls = _paramObj.calcuClzx();
  351 + // 低谷最少配车（连班车数量）
  352 + var iDgminpc = Math.round(_paramObj.calcuTroughZzsj() / _paramObj.getTroughMaxFcjx());
  353 + // 加班车路牌数（做5休2的路牌数）
  354 + var i_5_2_lpes = _paramObj.getJBLpes();
  355 +
  356 + // 做些简单的验证
  357 + if (iCls < iDgminpc) {
  358 + alert("总配车数小于低谷最小配车");
  359 + throw "总配车数小于低谷最小配车";
  360 + }
  361 +
  362 + if (iDgminpc < 2) {
  363 + // alert("连班路牌小于2，办不到啊");
  364 + // throw "连班路牌小于2，办不到啊";
  365 + console.log("连班路牌小于2，则5休2之外的车辆数则为连班车辆数");
  366 + iDgminpc = iCls - i_5_2_lpes;
  367 + }
  368 + if (iCls - iDgminpc < i_5_2_lpes) {
  369 + // alert("总分班路牌数小于加班路牌数");
  370 + // throw "总分班路牌数小于加班路牌数";
  371 + console.log("总分班路牌数小于加班路牌数，则忽略其他分班路牌数");
  372 + iDgminpc = iCls - i_5_2_lpes;
  373 + }
  374 +
  375 + //// 修正连班路牌数，班次间隔大于20的，加1，直至班次间隔小于20
  376 + //while(_paramObj.calcuPeakZzsj() / iDgminpc > 20) {
  377 + // iDgminpc ++;
  378 + //}
  379 + _iBx_lb_lpcount = iDgminpc;
  380 +
  381 + _iBx_5_2_fb_lpcount = i_5_2_lpes;
  382 + _iBx_other_fb_lpcount = iCls - _iBx_lb_lpcount - i_5_2_lpes;
  383 +
  384 + //------------------------ 2、利用间隔法计算连班路牌分布 --------------------//
  385 + var i;
  386 + var j;
  387 + var iC1 = Math.floor(_internalLpArray.length / _iBx_lb_lpcount);
  388 + var iC2 = _internalLpArray.length % _iBx_lb_lpcount;
  389 + var iLpIndex;
  390 +
  391 + for (i = 0; i < _iBx_lb_lpcount - iC2; i++) {
  392 + iLpIndex = i * iC1;
  393 + _internalLpArray[iLpIndex].setBxLb(true);
  394 + _internalLpArray[iLpIndex].setBxDesc("连班");
  395 + }
  396 + for (j = 0; j < iC2; j++) {
  397 + iLpIndex = i * iC1 + j * (iC1 + 1);
  398 + _internalLpArray[iLpIndex].setBxLb(true);
  399 + _internalLpArray[iLpIndex].setBxDesc("连班");
  400 + }
  401 +
  402 + //------------------------ 3、利用间隔法计算分班班型路牌分布 --------------------//
  403 + // 获取分班路牌索引
  404 + var aNotLbIndexes = [];
  405 + for (i = 0; i < _internalLpArray.length; i++) {
  406 + if (!_internalLpArray[i].isBxLb()) {
  407 + aNotLbIndexes.push(i);
  408 + }
  409 + }
  410 + // 先5休2分班
  411 + iC1 = Math.floor(aNotLbIndexes.length / _iBx_5_2_fb_lpcount);
  412 + iC2 = aNotLbIndexes.length % _iBx_5_2_fb_lpcount;
  413 +
  414 + for (i = 0; i < _iBx_5_2_fb_lpcount - iC2; i++) {
  415 + iLpIndex = aNotLbIndexes[i * iC1];
  416 + _internalLpArray[iLpIndex].setBxLb(false);
  417 + _internalLpArray[iLpIndex].setBxFb(true);
  418 + _internalLpArray[iLpIndex].setBxFb5_2(true);
  419 + _internalLpArray[iLpIndex].setBxDesc("5休2分班");
  420 + }
  421 + for (i = 0; i < iC2; i++) {
  422 + iLpIndex = aNotLbIndexes[_iBx_5_2_fb_lpcount - iC2 + i * (iC1 + 1)];
  423 + _internalLpArray[iLpIndex].setBxLb(false);
  424 + _internalLpArray[iLpIndex].setBxFb(true);
  425 + _internalLpArray[iLpIndex].setBxFb5_2(true);
  426 + _internalLpArray[iLpIndex].setBxDesc("5休2分班");
  427 + }
  428 + // 其他分班
  429 + for (i = 0; i < aNotLbIndexes.length; i++) {
  430 + iLpIndex = aNotLbIndexes[i];
  431 + if (!_internalLpArray[iLpIndex].isBxFb5_2()) {
  432 + _internalLpArray[iLpIndex].setBxLb(false);
  433 + _internalLpArray[iLpIndex].setBxFb(true);
  434 + _internalLpArray[iLpIndex].setBxFb5_2(false);
  435 + _internalLpArray[iLpIndex].setBxDesc("其他分班");
  436 + }
  437 + }
  438 +
  439 + console.log("高峰周转时间:" + _paramObj.calcuPeakZzsj());
  440 + console.log("连班路牌数:" + _iBx_lb_lpcount);
  441 + console.log("5休2分班路牌数:" + _iBx_5_2_fb_lpcount);
  442 + console.log("其他分班路牌数:" + _iBx_other_fb_lpcount);
  443 + var aLbIndexes = [];
  444 + for (i = 0; i < _internalLpArray.length; i++) {
  445 + if (_internalLpArray[i].isBxLb()) {
  446 + aLbIndexes.push(i);
  447 + }
  448 + }
  449 + console.log("连班路牌indexes=" + aLbIndexes);
  450 + var a_5_2_fbIndexes = [];
  451 + for (i = 0; i < _internalLpArray.length; i++) {
  452 + if (_internalLpArray[i].isBxFb() && _internalLpArray[i].isBxFb5_2()) {
  453 + a_5_2_fbIndexes.push(i);
  454 + }
  455 + }
  456 + console.log("5休2分班路牌indexes=" + a_5_2_fbIndexes);
  457 + var a_other_fbIndexes = [];
  458 + for (i = 0; i < _internalLpArray.length; i++) {
  459 + if (_internalLpArray[i].isBxFb() && !_internalLpArray[i].isBxFb5_2()) {
  460 + a_other_fbIndexes.push(i);
  461 + }
  462 + }
  463 + console.log("其他分班路牌indexes=" + a_other_fbIndexes);
  464 +
  465 + console.log("//---------------- 行车计划，初始化方法3 end ----------------//");
  466 + };
  467 +
  468 + //----------------------- 初始化方法4，计算中标线位置 -------------------------//
  469 + var _iZbx_lpIndex; // 中标线对应第几个路牌
  470 +
  471 + var _fnInitFun4 = function() { // 初始化方法4
  472 + console.log("//---------------- 行车计划，初始化方法4 start ----------------//");
  473 +
  474 + //---------------------------- 1、模拟一个中标线，使用临时路牌 ----------------------//
  475 + // 构造中标线
  476 + // 中标线开始时间，就是方向的首班车时间
  477 + var oSt = !_qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  478 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  479 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  480 + var oEt;
  481 + if (_paramObj.getUpLastDtimeObj().isBefore(
  482 + _paramObj.getDownLastDTimeObj())) {
  483 + oEt = _paramObj.getDownLastDTimeObj();
  484 + } else {
  485 + oEt = _paramObj.getUpLastDtimeObj();
  486 + }
  487 +
  488 + var oTempLp = new InternalLpObj({lpNo: -999, lpName: "-999"}, _qCount, _qIsUp);
  489 + oTempLp.initDataFromTimeToTime(
  490 + oSt,
  491 + oEt,
  492 + !_qIsUp,
  493 + 0,
  494 + _paramObj,
  495 + _factory
  496 + );
  497 +
  498 + //------------------------ 2、找出中标线的早高峰班次，计算应该插在当前路牌数组的那个位置 ----------------//
  499 + // 找出中标线对应的早高峰的班次对象
  500 + var oZb_gf_bc = oTempLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
  501 + //alert(oZb_gf_bc.getFcTimeObj().format("HH:mm"));
  502 +
  503 + // 把所有连班路牌高峰班次重新构造成一个一个的圈数组，计算对应中标线最近的是第几个路牌
  504 + // 中标线和上标线一样在连班路牌上
  505 + var aTempq = [];
  506 + var oTempq;
  507 + var oTempb;
  508 + var i;
  509 + var oLp;
  510 +
  511 + var aLbIndexes = []; // 连班的路牌索引
  512 + for (i = 0; i < _internalLpArray.length; i++) {
  513 + if (_internalLpArray[i].isBxLb()) {
  514 + aLbIndexes.push(i);
  515 + }
  516 + }
  517 +
  518 + for (i = 0; i < aLbIndexes.length; i++) {
  519 + oLp = _internalLpArray[aLbIndexes[i]];
  520 +
  521 + oTempb = oLp.getBc(_approximate_zgfQIndex, _approximate_zgfBIndex);
  522 + if (oTempb.isUp() == _qIsUp) {
  523 + oTempq = new InternalGroupObj(oLp, _qIsUp, oTempb, undefined);
  524 + } else {
  525 + oTempq = new InternalGroupObj(oLp, _qIsUp, undefined, oTempb);
  526 + }
  527 + aTempq.push(oTempq);
  528 +
  529 + }
  530 +
  531 + var aTtindex = oTempLp.fnGetQBcIndexWithFcTimeFromGroupArray( // 找出最接近中标线的路牌索引
  532 + oZb_gf_bc.getFcTimeObj(),
  533 + aTempq,
  534 + true,
  535 + true
  536 + );
  537 +
  538 + _iZbx_lpIndex = aLbIndexes[aTtindex[0]]; // 中标线放在第几个路牌
  539 +
  540 + oTempLp.getMinBcObj().fnSetIsFirstBc(true); // 设置首班班次标识
  541 +
  542 + if (_iZbx_lpIndex == 0) { // 如果中标线和上标线一致
  543 + var oFirstBcIndexes = oTempLp.getMinBcObjPosition();
  544 + var oFirstBc = oTempLp.getMinBcObj();
  545 + oFirstBc.setLp(_internalLpArray[_iZbx_lpIndex]);
  546 + oFirstBc.fnSetDelFlag(false);
  547 + _internalLpArray[_iZbx_lpIndex].setBc(oFirstBcIndexes[0], oFirstBcIndexes[1], oFirstBc);
  548 + } else {
  549 + oTempLp.setLp(_lpArray[_iZbx_lpIndex]); // 设置原始路牌对象
  550 + oTempLp._$_aVerticalIntervalTime = _internalLpArray[_iZbx_lpIndex]._$_aVerticalIntervalTime; // 设置纵向最小发车间隔
  551 + oTempLp.setBxLb(_internalLpArray[_iZbx_lpIndex].isBxLb());
  552 + oTempLp.setBxFb(_internalLpArray[_iZbx_lpIndex].isBxFb());
  553 + oTempLp.setBxFb5_2(_internalLpArray[_iZbx_lpIndex].isBxFb5_2());
  554 +
  555 + // 修正除了第一个班次外，其余其他班次
  556 + var iBcindex = 0;
  557 + for (i = 1; i < _qCount; i++) {
  558 + while (iBcindex <= 1) {
  559 + if (oTempLp.getBc(i, iBcindex)) { // 替换存在的班次
  560 + oTempLp.setBc(i, iBcindex, _fnGenerateBc(_iZbx_lpIndex, i, iBcindex));
  561 + }
  562 + iBcindex ++;
  563 + }
  564 + iBcindex = 0;
  565 + }
  566 +
  567 + _internalLpArray[_iZbx_lpIndex] = oTempLp;
  568 + }
  569 +
  570 + console.log("中标线对应第" + (_iZbx_lpIndex + 1) + "个路牌");
  571 +
  572 + console.log("//---------------- 行车计划，初始化方法4 end ----------------//");
  573 + };
  574 +
  575 + //-------------------- 重要的内部方法 -----------------------//
  576 + /**
  577 + * 核心方法，利用路牌间隔纵向生成班次。
  578 + * @param iLpindex 路牌索引
  579 + * @param iQindex 圈索引
  580 + * @param iBcindex 班次索引
  581 + * @returns object InternalBcObj，失败 false
  582 + */
  583 + var _fnGenerateBc = function(iLpindex, iQindex, iBcindex) {
  584 + // 以上标线为起始点，使用路牌在不同圈，班次索引的发车间隔，计算班次
  585 + // 注意，发车间隔是指下一个班次应该距离当前班次间隔，是从下往上的
  586 +
  587 + // 1、参数验证
  588 + if (iLpindex == 0) { // 上标线的班次不需要生成
  589 + return false;
  590 + }
  591 +
  592 + // 2、计算间隔
  593 + var i;
  594 + var oLp;
  595 + var iTime = 0;
  596 + for (i = 0; i < iLpindex; i++) {
  597 + oLp = _internalLpArray[i];
  598 + iTime += oLp.fnGetVerticalIntervalTime(iQindex, iBcindex);
  599 + }
  600 +
  601 + // 3、生成班次
  602 + var _oKsbc = _internalLpArray[0].getBc(iQindex, iBcindex);
  603 + if (!_oKsbc) {
  604 + return false;
  605 + }
  606 + var _oKssj = _paramObj.addMinute(_oKsbc.getFcTimeObj(), iTime);
  607 + var _oBc = _factory.createBcObj(
  608 + _internalLpArray[iLpindex],
  609 + "normal", _oKsbc.isUp(),
  610 + 1, _oKssj, _paramObj);
  611 +
  612 + return _oBc;
  613 +
  614 + };
  615 +
  616 + /**
  617 + * 核心方法，在指定位置生成班次并添加到路牌指定位置中。
  618 + * @param lpIndex 第几个路牌
  619 + * @param qIndex 第几圈
  620 + * @param bcIndex 第几个班次
  621 + */
  622 + var _fnGenerateBcAndSetBc = function(lpIndex, qIndex, bcIndex) {
  623 + var _bcObj = _fnGenerateBc(lpIndex, qIndex, bcIndex);
  624 + if (_bcObj) {
  625 + _internalLpArray[lpIndex].setBc(qIndex, bcIndex, _bcObj);
  626 + }
  627 + };
  628 +
  629 + /**
  630 + * 获取班次列表。
  631 + * @param oIsUp 是否上行
  632 + * @param oStartTime 开始时间对象
  633 + * @returns [(InternalBcObj)]
  634 + */
  635 + var _fnGetBcList2 = function(oIsUp, oStartTime) {
  636 + var i;
  637 + var j;
  638 + var oLp;
  639 + var oBc;
  640 + var aBc = [];
  641 +
  642 + for (j = 0; j < _qCount; j++) {
  643 + for (i = 0; i < _internalLpArray.length; i++) {
  644 + oLp = _internalLpArray[i];
  645 + oBc = oLp.getBc(
  646 + j,
  647 + _qIsUp == oIsUp ? 0 : 1
  648 + );
  649 + if (oBc && oBc.getFcTimeObj().isAfter(oStartTime)) {
  650 + aBc.push(oBc);
  651 + }
  652 + }
  653 + }
  654 +
  655 + var aBcFcTime = [];
  656 + for (i = 0; i < aBc.length; i++) {
  657 + oBc = aBc[i];
  658 + aBcFcTime.push(oBc.getFcTimeObj().format("HH:mm"));
  659 + }
  660 + console.log((oIsUp ? "上行班次列表：" : "下行班次列表：") + aBcFcTime.join(","));
  661 +
  662 + return aBc;
  663 + };
  664 +
  665 + /**
  666 + * 获取班次列表。
  667 + * @param isUp boolean 是否上行
  668 + * @returns [(InternalBcObj)]
  669 + */
  670 + var _fnGetBcList = function(isUp) {
  671 + var i;
  672 + var j;
  673 + var oLp;
  674 + var oBc;
  675 + var aBc = [];
  676 +
  677 + for (j = 0; j < _qCount; j++) {
  678 + for (i = 0; i < _internalLpArray.length; i++) {
  679 + oLp = _internalLpArray[i];
  680 + oBc = oLp.getBc(
  681 + j,
  682 + _qIsUp == isUp ? 0 : 1
  683 + );
  684 + if (oBc) {
  685 + aBc.push(oBc);
  686 + }
  687 + }
  688 + }
  689 +
  690 + var aBcFcTime = [];
  691 + for (i = 0; i < aBc.length; i++) {
  692 + oBc = aBc[i];
  693 + aBcFcTime.push(oBc.getFcTimeObj().format("HH:mm"));
  694 + }
  695 + console.log((isUp ? "上行班次列表：" : "下行班次列表：") + aBcFcTime.join(","));
  696 +
  697 + return aBc;
  698 + };
  699 +
  700 + /**
  701 + * 查找离指定时间最近的前面的班次索引信息
  702 + * @param timeObj 查找时间
  703 + * @param isUp 是否上行
  704 + * @returns [{路牌index},{圈index},{班次index}]
  705 + */
  706 + var _fnFindUpClosedBcIndexWithTime = function(timeObj, isUp) {
  707 +
  708 + var _lpObj;
  709 + var _groupObj;
  710 + var _bcObj;
  711 + var _i;
  712 + var _j;
  713 + var timediff; // 时间差取绝对值
  714 +
  715 + var _lpIndex;
  716 + var _up_qIndex;
  717 + var _up_bIndex;
  718 +
  719 + for (_i = 0; _i < _qCount; _i++) {
  720 + for (_j = 0; _j < _internalLpArray.length; _j++) {
  721 + _lpObj = _internalLpArray[_j];
  722 + _groupObj = _lpObj.getGroup(_i);
  723 + _bcObj = isUp == _qIsUp ? _groupObj.getBc1() : _groupObj.getBc2();
  724 + if (!_bcObj) { // 没有班次动态生成一个，可能生成不出的
  725 + _bcObj = _fnGenerateBc(_j, _i, isUp == _qIsUp ? 0 : 1);
  726 + }
  727 + if (_bcObj) {
  728 + if (timeObj.diff(_bcObj.getFcTimeObj()) >= 0) {
  729 + if (!timediff) {
  730 + timediff = timeObj.diff(_bcObj.getFcTimeObj());
  731 + _lpIndex = _j;
  732 + _up_qIndex = _i;
  733 + _up_bIndex = isUp == _qIsUp ? 0 : 1;
  734 + } else {
  735 + if (timeObj.diff(_bcObj.getFcTimeObj()) < timediff) {
  736 + timediff = timeObj.diff(_bcObj.getFcTimeObj());
  737 + _lpIndex = _j;
  738 + _up_qIndex = _i;
  739 + _up_bIndex = isUp == _qIsUp ? 0 : 1;
  740 + }
  741 + }
  742 + }
  743 + }
  744 + }
  745 + }
  746 +
  747 + if (_lpIndex == undefined) {
  748 + return false;
  749 + }
  750 +
  751 + var bcindex = [];
  752 + bcindex.push(_lpIndex);
  753 + bcindex.push(_up_qIndex);
  754 + bcindex.push(_up_bIndex);
  755 +
  756 + return bcindex;
  757 + };
  758 +
  759 + /**
  760 + * 查找离指定时间最近的后面的班次索引信息
  761 + * @param timeObj 查找时间
  762 + * @param isUp 是否上行
  763 + * @returns [{路牌index},{圈index},{班次index}]
  764 + */
  765 + var _fnFindDownClosedBcIndexWithTime = function(timeObj, isUp) {
  766 + var _lpObj;
  767 + var _groupObj;
  768 + var _bcObj;
  769 + var _i;
  770 + var _j;
  771 + var timediff; // 时间差取绝对值
  772 +
  773 + var _lpIndex;
  774 + var _down_qIndex;
  775 + var _down_bIndex;
  776 +
  777 + var flag;
  778 +
  779 + for (_i = 0; _i < _qCount; _i++) {
  780 + for (_j = 0; _j < _internalLpArray.length; _j++) {
  781 + _lpObj = _internalLpArray[_j];
  782 + _groupObj = _lpObj.getGroup(_i);
  783 + // TODO：bug
  784 + _bcObj = isUp == _qIsUp ? _groupObj.getBc1() : _groupObj.getBc2();
  785 + if (!_bcObj) { // 没有班次动态生成一个，可能生成不出的
  786 + _bcObj = _fnGenerateBc(_j, _i, isUp == _qIsUp ? 0 : 1);
  787 + }
  788 + if (_bcObj) {
  789 + //console.log("timeobj -> bcobj diff flag " +
  790 + // timeObj.format("HH:mm") + "->" +
  791 + // _bcObj.getFcTimeObj().format("HH:mm") +
  792 + // timeObj.diff(_bcObj.getFcTimeObj()) +
  793 + // (timeObj.diff(_bcObj.getFcTimeObj()) <= 0)
  794 + //);
  795 +
  796 + flag = (timeObj.diff(_bcObj.getFcTimeObj())) <= 0;
  797 +
  798 + if (flag) {
  799 + if (!timediff) {
  800 + timediff = timeObj.diff(_bcObj.getFcTimeObj());
  801 + _lpIndex = _j;
  802 + _down_qIndex = _i;
  803 + _down_bIndex = isUp == _qIsUp ? 0 : 1;
  804 + } else {
  805 + if ((timeObj.diff(_bcObj.getFcTimeObj())) > timediff) {
  806 + timediff = timeObj.diff(_bcObj.getFcTimeObj());
  807 + _lpIndex = _j;
  808 + _down_qIndex = _i;
  809 + _down_bIndex = isUp == _qIsUp ? 0 : 1;
  810 + }
  811 + }
  812 + }
  813 + }
  814 + }
  815 + }
  816 +
  817 + if (_lpIndex == undefined) {
  818 + return false;
  819 + }
  820 +
  821 + var bcindex = [];
  822 + bcindex.push(_lpIndex);
  823 + bcindex.push(_down_qIndex);
  824 + bcindex.push(_down_bIndex);
  825 +
  826 + return bcindex;
  827 + };
  828 +
  829 + /**
  830 + * 获取班次索引。
  831 + * @param oBc 班次对象
  832 + * @returns [{路牌索引},{圈索引},{班次索引}]
  833 + */
  834 + var _fnGetBcIndex = function(oBc) {
  835 + // 路牌索引
  836 + var i;
  837 + var iLpIndex;
  838 + for (i = 0; i < _internalLpArray.length; i++) {
  839 + if (_internalLpArray[i]._$$_orign_lp_obj == oBc._$$_internal_lp_obj._$$_orign_lp_obj) {
  840 + iLpIndex = i;
  841 + break;
  842 + }
  843 + }
  844 + // 圈索引
  845 + var j;
  846 + var iGroupIndex;
  847 + var bFlag = false;
  848 + for (i = 0; i < _internalLpArray.length; i++) {
  849 + if (bFlag) {
  850 + break;
  851 + }
  852 + for (j = 0; j < _qCount; j++) {
  853 + if (_internalLpArray[i]._$_groupBcArray[j] == oBc._$$_internal_group_obj) {
  854 + iGroupIndex = j;
  855 + bFlag = true;
  856 + break;
  857 + }
  858 + }
  859 + }
  860 + // 班次索引
  861 + var iBcIndex = _qIsUp == oBc.isUp() ? 0 : 1;
  862 +
  863 + if (iLpIndex == undefined) {
  864 + return null;
  865 + } else {
  866 + return [].concat(iLpIndex, iGroupIndex, iBcIndex);
  867 + }
  868 +
  869 + };
  870 +
  871 + return {
  872 + //------------- 布局初始化方法 ------------//
  873 + /**
  874 + * 初始化数据，使用标线初始化
  875 + */
  876 + fnInitDataWithBxLayout: function() {
  877 + // 初始化布局1，构造上标线，计算圈数，把上标线数据放入第一个路牌中
  878 + _fnInitFun1();
  879 + // 初始化布局2，从上标线的某个班次开始，构造所有路牌的早高峰班次，晚高峰班次，计算路牌在各个圈中的间隔
  880 + _fnInitFun2();
  881 + // 初始化布局3，计算连班分班路牌分布
  882 + _fnInitFun3();
  883 + // 初始化布局4，计算中标线位置
  884 + _fnInitFun4();
  885 +
  886 + },
  887 +
  888 + /**
  889 + * 调整高峰班次，
  890 + * 初始化生成早高峰，晚高峰班次并不准确，因为根据高峰时间段，并不在一个完整圈内，应该是在两个或多个圈之间
  891 + * 当初始化定好布局后（上标线，中标线），然后确定每个路牌的班型（连班，分班，5休2分班）后
  892 + * 然后重新计算框在高峰时间段内的班次索引，不足的添加，之前多加的删除（只删除分班路牌上的）
  893 + * @param isZgf 是否早高峰
  894 + * @param isUp 是否上行
  895 + */
  896 + fnAdjustGfbc : function(isZgf, isUp) {
  897 + var oStartTime; // 开始时间
  898 + var oEndTime; // 结束时间
  899 + var aStartBcIndex; // 开始班次索引
  900 + var aEndBcIndex; // 结束班次索引
  901 +
  902 + oStartTime = isZgf ? _paramObj.getMPeakStartTimeObj() : _paramObj.getEPeakStartTimeObj();
  903 + oEndTime = isZgf ? _paramObj.getMPeakEndTimeObj() : _paramObj.getEPeakEndTimeObj();
  904 +
  905 + aStartBcIndex = _fnFindUpClosedBcIndexWithTime(oStartTime, isUp);
  906 + aEndBcIndex = _fnFindDownClosedBcIndexWithTime(oEndTime, isUp);
  907 +
  908 + var iLpIndex;
  909 + var iQIndex;
  910 + var iBcIndex;
  911 + var iQInternelCount; // 高峰时间段中间包含的圈数
  912 + var i;
  913 + var j;
  914 +
  915 + var oLp;
  916 +
  917 + if (aStartBcIndex && aEndBcIndex) {
  918 + iLpIndex = aStartBcIndex[0];
  919 + iQIndex = aStartBcIndex[1];
  920 + iBcIndex = aStartBcIndex[2];
  921 +
  922 + // 处理头
  923 + // 删除头部多余班次
  924 + for (j = 0; j < iLpIndex; j++) {
  925 + oLp = _internalLpArray[j];
  926 + if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
  927 + oLp.removeBc(iQIndex, iBcIndex);
  928 + }
  929 + }
  930 +
  931 + for (j = iLpIndex; j < _internalLpArray.length; j++) {
  932 + oLp = _internalLpArray[j];
  933 + if (!oLp.getBc(iQIndex, iBcIndex)) {
  934 + _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
  935 + }
  936 + }
  937 +
  938 + // 处理中间
  939 + iQInternelCount = aEndBcIndex[1] - aStartBcIndex[1] - 1;
  940 + for (i = 1; i <= iQInternelCount; i++) {
  941 +
  942 + for (j = 0; j < _internalLpArray.length; j++) {
  943 + oLp = _internalLpArray[j];
  944 + if (!oLp.getBc(iQIndex + i, iBcIndex)) {
  945 + _fnGenerateBcAndSetBc(j, iQIndex + i, iBcIndex);
  946 + }
  947 + }
  948 +
  949 + }
  950 +
  951 + // 处理尾部
  952 + iLpIndex = aEndBcIndex[0];
  953 + iQIndex = aEndBcIndex[1];
  954 + iBcIndex = aEndBcIndex[2];
  955 +
  956 + // 删除尾部多余的班次
  957 + for (j = iLpIndex; j < _internalLpArray.length; j++) {
  958 + oLp = _internalLpArray[j];
  959 + if (oLp.isBxFb() && oLp.getBc(iQIndex, iBcIndex)) {
  960 + oLp.removeBc(iQIndex, iBcIndex);
  961 + }
  962 + }
  963 +
  964 + if (aStartBcIndex[1] != aEndBcIndex[1]) { // 指定时间范围跨圈
  965 + for (j = 0; j < iLpIndex; j++) {
  966 + oLp = _internalLpArray[j];
  967 + if (!oLp.getBc(iQIndex, iBcIndex)) {
  968 + _fnGenerateBcAndSetBc(j, iQIndex, iBcIndex);
  969 + }
  970 + }
  971 + } else {
  972 + // 不跨圈，不用处理，处理头的时候已经加了
  973 + }
  974 +
  975 + }
  976 +
  977 + },
  978 +
  979 + /**
  980 + * 按照营运时间要求补充班次，
  981 + * 早高峰7:45分以前出场运营，
  982 + * 晚高峰16:10分以前出场运营
  983 + */
  984 + fnCalcuLpBc_yy: function() {
  985 + // 补班次的时候，针对的是分班班型
  986 + var i;
  987 + var _oLp;
  988 + var _oBc;
  989 + var _aMinBcIndex;
  990 + var _aMaxBcIndex;
  991 +
  992 + var _qIndex;
  993 + var _bIndex;
  994 +
  995 + var _zgfCDate = _paramObj.toTimeObj("7:45");
  996 + var _wgfCDate = _paramObj.toTimeObj("16:10");
  997 + var _ccsj;
  998 +
  999 + for (i = 0; i < _internalLpArray.length; i++) {
  1000 + _oLp = _internalLpArray[i];
  1001 + if (_oLp.isBxFb()) { // 分班路牌
  1002 + // 早高峰部分
  1003 + _aMinBcIndex = _oLp.getMinBcObjPosition();
  1004 + _qIndex = _aMinBcIndex[0];
  1005 + _bIndex = _aMinBcIndex[1];
  1006 + _oBc = _oLp.getBc(_qIndex, _bIndex);
  1007 + if (_qIsUp) {
  1008 + _ccsj = _bIndex == 0 ?
  1009 + _paramObj.getUpOutTime() :
  1010 + _paramObj.getDownOutTime();
  1011 + } else {
  1012 + _ccsj = _bIndex == 0 ?
  1013 + _paramObj.getDownOutTime() :
  1014 + _paramObj.getUpOutTime();
  1015 + }
  1016 + if (_zgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
  1017 + _fnGenerateBcAndSetBc(
  1018 + i,
  1019 + _bIndex == 0 ? _qIndex - 1 : _qIndex,
  1020 + _bIndex == 0 ? 1 : 0
  1021 + )
  1022 + }
  1023 +
  1024 + // 晚高峰部分
  1025 + _aMaxBcIndex = _oLp.getMaxBcObjPosition();
  1026 + _qIndex = _aMaxBcIndex[0];
  1027 + _bIndex = _aMaxBcIndex[1];
  1028 + _oBc = _oLp.getBc(
  1029 + _bIndex == 0 ? _qIndex - 1 : _qIndex,
  1030 + _bIndex == 0 ? 1 : 0
  1031 + );
  1032 + if (!_oBc) { // 前一个班次不存在，再判定加不加
  1033 + _oBc = _oLp.getBc(_qIndex, _bIndex);
  1034 + if (_qIsUp) {
  1035 + _ccsj = _bIndex == 0 ?
  1036 + _paramObj.getUpOutTime() :
  1037 + _paramObj.getDownOutTime();
  1038 + } else {
  1039 + _ccsj = _bIndex == 0 ?
  1040 + _paramObj.getDownOutTime() :
  1041 + _paramObj.getUpOutTime();
  1042 + }
  1043 + if (_wgfCDate.isBefore(_paramObj.addMinute(_oBc.getFcTimeObj(), -_ccsj))) {
  1044 + _fnGenerateBcAndSetBc(
  1045 + i,
  1046 + _bIndex == 0 ? _qIndex - 1 : _qIndex,
  1047 + _bIndex == 0 ? 1 : 0
  1048 + )
  1049 + }
  1050 + }
  1051 + }
  1052 + }
  1053 + },
  1054 +
  1055 + /**
  1056 + * 补充做5休2的班型班次。
  1057 + * 1、确认5_2班型大致多少圈（小数点过.7进位）
  1058 + * 2、获取当前5_2两端车次链的信息，每段的班次数目，还差几个班次没加
  1059 + * 3、如果前面的车次链班次少，则从前面的车次链开始加
  1060 + * 4、如果车次链班次数一样，从从后面的车次链开始加
  1061 + * 5、加班次时都是往车次链前方加
  1062 + * 6、如果前面车次链不能再加班次了，从后面车次链加
  1063 + */
  1064 + fnCalcuLpBx_5_2: function() {
  1065 + // 计算做5休2班型所需的班次数
  1066 + var iBxBcount = _aBxDesc[6].fBcCount;
  1067 + if (iBxBcount - Math.floor(iBxBcount) > 0.7) {
  1068 + iBxBcount = Math.floor(iBxBcount) + 1;
  1069 + } else {
  1070 + iBxBcount = Math.floor(iBxBcount);
  1071 + }
  1072 +
  1073 + var i;
  1074 + var j;
  1075 + var oLp;
  1076 + var iAddBcCount;
  1077 + var oBcChain1;
  1078 + var oBcChain2;
  1079 + var iQindex;
  1080 + var iBindex;
  1081 +
  1082 + for (i = 0; i < _internalLpArray.length; i++) {
  1083 + oLp = _internalLpArray[i];
  1084 + if (oLp.isBxFb5_2()) {
  1085 + iAddBcCount = iBxBcount - oLp.getBcArray().length; // 需要添加的班次数
  1086 + for (j = 1; j <= iAddBcCount; j++) {
  1087 + oBcChain1 = oLp.fnGetBcChainInfo(0);
  1088 + oBcChain2 = oLp.fnGetBcChainInfo(1);
  1089 +
  1090 + if (oBcChain1.bcount < oBcChain2.bcount) {
  1091 + iQindex = oBcChain1.s_b == 0 ? oBcChain1.s_q - 1 : oBcChain1.s_q;
  1092 + iBindex = oBcChain1.s_b == 0 ? 1 : 0;
  1093 + // 往车次链往前不能加，就往后加
  1094 + if (_fnGenerateBc(i, iQindex, iBindex)) {
  1095 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1096 + } else {
  1097 + iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
  1098 + iBindex = oBcChain1.e_b == 0 ? 1 : 0;
  1099 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1100 + }
  1101 +
  1102 + } else if (oBcChain1.bcount > oBcChain2.bcount) {
  1103 + iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
  1104 + iBindex = oBcChain2.s_b == 0 ? 1 : 0;
  1105 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1106 + } else {
  1107 + iQindex = oBcChain2.s_b == 0 ? oBcChain2.s_q - 1 : oBcChain2.s_q;
  1108 + iBindex = oBcChain2.s_b == 0 ? 1 : 0;
  1109 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1110 + }
  1111 + }
  1112 + }
  1113 + }
  1114 +
  1115 + },
  1116 +
  1117 + /**
  1118 + * 补其他分班班型班次。
  1119 + * 从车次链的后面开始加
  1120 + */
  1121 + fnCalcuLpBx_other: function() {
  1122 + // TODO：根据上标线的首班时间确定班型，小于05:59的做一休一，否则做二休一
  1123 + var oSt = _qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  1124 + var iBxIndex = 4;
  1125 + if (oSt.isBefore(_paramObj.toTimeObj("05:59"))) {
  1126 + iBxIndex = 5;
  1127 + }
  1128 + // 计算做5休2班型所需的班次数
  1129 + var iQBcount = _aBxDesc[iBxIndex].fQCount;
  1130 + var iBxBcount = Math.round(iQBcount) * 2;
  1131 +
  1132 + var i;
  1133 + var j;
  1134 + var oLp;
  1135 + var iAddBcCount;
  1136 + var oBcChain1;
  1137 + var oBcChain2;
  1138 + var iQindex;
  1139 + var iBindex;
  1140 +
  1141 + for (i = 0; i < _internalLpArray.length; i++) {
  1142 + oLp = _internalLpArray[i];
  1143 + if (oLp.isBxFb() && !oLp.isBxFb5_2()) {
  1144 + iAddBcCount = iBxBcount - oLp.getBcArray().length; // 需要添加的班次数
  1145 + for (j = 1; j <= iAddBcCount; j++) {
  1146 + oBcChain1 = oLp.fnGetBcChainInfo(0);
  1147 + oBcChain2 = oLp.fnGetBcChainInfo(1);
  1148 +
  1149 + if (oBcChain1.bcount < oBcChain2.bcount) {
  1150 + iQindex = oBcChain1.e_b == 0 ? oBcChain1.e_q : oBcChain1.e_q + 1;
  1151 + iBindex = oBcChain1.e_b == 0 ? 1 : 0;
  1152 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1153 + } else if (oBcChain1.bcount > oBcChain2.bcount) {
  1154 + iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
  1155 + iBindex = oBcChain2.e_b == 0 ? 1 : 0;
  1156 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1157 + } else {
  1158 + iQindex = oBcChain2.e_b == 0 ? oBcChain2.e_q : oBcChain2.e_q + 1;
  1159 + iBindex = oBcChain2.e_b == 0 ? 1 : 0;
  1160 + _fnGenerateBcAndSetBc(i, iQindex, iBindex);
  1161 + }
  1162 + }
  1163 + }
  1164 + }
  1165 +
  1166 + },
  1167 +
  1168 + /**
  1169 + * 补充连班路牌班次。
  1170 + * 1、上标线，中标线中间的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向上标线起始班次靠拢
  1171 + * 2、中标线以下的连班路牌班次从早高峰班次一直拉到底，从早高峰班次向中标线起始班次靠拢
  1172 + */
  1173 + fnCalcuLpBx_lb: function() {
  1174 + // 补充连班的班次，参照上标线，中标线补充不足的班次
  1175 +
  1176 + var aLbLpindexes = []; // 除上标线，中标线的连班路牌索引
  1177 + var i;
  1178 + for (i = 0; i < _internalLpArray.length; i++) {
  1179 + if (_internalLpArray[i].isBxLb() && i != 0 && i != _iZbx_lpIndex) {
  1180 + aLbLpindexes.push(i);
  1181 + }
  1182 + }
  1183 +
  1184 + var oEndsj = // 结束时间
  1185 + _paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj()) ?
  1186 + _paramObj.getDownLastDTimeObj() :
  1187 + _paramObj.getUpLastDtimeObj();
  1188 +
  1189 + var oLp;
  1190 + var aMinbcPos;
  1191 + var oBc;
  1192 + var j;
  1193 + var iTempBcIndex;
  1194 +
  1195 + // 1、从最小班次开始，往后补充班次
  1196 + for (i = 0; i < aLbLpindexes.length; i++) {
  1197 + oLp = _internalLpArray[aLbLpindexes[i]];
  1198 +
  1199 + // 最小班次索引
  1200 + aMinbcPos = oLp.getMinBcObjPosition();
  1201 + // 使用纵向分隔补充班次，从最小班次向后补
  1202 + iTempBcIndex = aMinbcPos[1] == 0 ? 1 : 0;
  1203 + j = iTempBcIndex == 0 ? aMinbcPos[0] + 1 : aMinbcPos[0];
  1204 +
  1205 + while (j < _qCount) {
  1206 + while (iTempBcIndex <= 1) {
  1207 + oBc = _fnGenerateBc(aLbLpindexes[i], j, iTempBcIndex);
  1208 + if (oBc &&
  1209 + oBc.getFcTimeObj().isBefore(oEndsj) ) {
  1210 + oLp.setBc(j, iTempBcIndex, oBc);
  1211 + }
  1212 + iTempBcIndex++;
  1213 + }
  1214 + iTempBcIndex = 0;
  1215 + j++;
  1216 + }
  1217 +
  1218 + }
  1219 +
  1220 + // 2、上标线中标线之间的路牌，从最小的班次往前补充班次
  1221 +
  1222 + // 还要补充缺失的班次，差上标线几个班次要往前补上
  1223 + var iBccount;
  1224 + var iQindex;
  1225 + var iBindex;
  1226 + // 补上标线到中标线之间的连班路牌的班次
  1227 + for (i = 0; i < aLbLpindexes.length; i++) {
  1228 + if (aLbLpindexes[i] > 0 && aLbLpindexes[i] < _iZbx_lpIndex) {
  1229 + oLp = _internalLpArray[aLbLpindexes[i]];
  1230 + aMinbcPos = oLp.getMinBcObjPosition();
  1231 + iQindex = aMinbcPos[0];
  1232 + iBindex = aMinbcPos[1];
  1233 + iBccount = (iQindex - 1) * 2 + iBindex; // 距离上标线起始站点差几个班次
  1234 + for (j = 0; j < iBccount; j++) {
  1235 + if (iBindex == 0) {
  1236 + iQindex --;
  1237 + iBindex = 1;
  1238 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1239 + } else if (iBindex == 1) {
  1240 + iBindex --;
  1241 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1242 + }
  1243 + }
  1244 +
  1245 + }
  1246 +
  1247 + }
  1248 +
  1249 + // 3、中标线之后的路牌，从最小的班次往前补充班次
  1250 +
  1251 + // 补中标线以下的连班路牌的班次
  1252 + for (i = 0; i < aLbLpindexes.length; i++) {
  1253 + if (aLbLpindexes[i] > _iZbx_lpIndex) {
  1254 + oLp = _internalLpArray[aLbLpindexes[i]];
  1255 + aMinbcPos = oLp.getMinBcObjPosition();
  1256 + iQindex = aMinbcPos[0];
  1257 + iBindex = aMinbcPos[1];
  1258 + iBccount = (iQindex - 0) * 2 + iBindex - 1; // 距离上标线起始站点差几个班次
  1259 + for (j = 0; j < iBccount; j++) {
  1260 + if (iBindex == 0) {
  1261 + iQindex --;
  1262 + iBindex = 1;
  1263 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1264 + } else if (iBindex == 1) {
  1265 + iBindex --;
  1266 + _fnGenerateBcAndSetBc(aLbLpindexes[i], iQindex, iBindex);
  1267 + }
  1268 + }
  1269 + }
  1270 + }
  1271 +
  1272 + },
  1273 +
  1274 + /**
  1275 + * 计算末班车。
  1276 + * 1、将上下行拉成上下行两个班次列表（包括标记班次）
  1277 + * 2、分别找出离末班车发车时间最近的班次，并替换时间
  1278 + * 3、删除之后的班次
  1279 + */
  1280 + fnCalcuLastBc: function() {
  1281 + var i;
  1282 + var iTimeDiff;
  1283 + var iTempTime;
  1284 + var aBc;
  1285 + var oLastBcTime;
  1286 + var oLastBcIsUp;
  1287 + var iModifyIndex;
  1288 +
  1289 + // 查找末班车早的末班车时间和方向
  1290 + if (_paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj())) {
  1291 + oLastBcTime = _paramObj.getUpLastDtimeObj();
  1292 + oLastBcIsUp = true;
  1293 + } else {
  1294 + oLastBcTime = _paramObj.getDownLastDTimeObj();
  1295 + oLastBcIsUp = false;
  1296 + }
  1297 +
  1298 + // 确定早的末班车时间
  1299 + aBc = _fnGetBcList(oLastBcIsUp);
  1300 + for (i = 0; i < aBc.length; i++) {
  1301 + iTempTime = oLastBcTime.diff(aBc[i].getFcTimeObj(), "m");
  1302 + if (iTimeDiff == undefined) {
  1303 + iTimeDiff = iTempTime;
  1304 + iModifyIndex = i;
  1305 + } else if (Math.abs(iTempTime) <= Math.abs(iTimeDiff)) {
  1306 + iTimeDiff = iTempTime;
  1307 + iModifyIndex = i;
  1308 + }
  1309 + }
  1310 + aBc[iModifyIndex].addMinuteToFcsj(iTimeDiff); // 替换成末班车时间
  1311 + aBc[iModifyIndex].fnSetDelFlag(false);
  1312 + aBc[iModifyIndex].fnSetIsLastBc(true);
  1313 + for (i = iModifyIndex + 1; i < aBc.length; i++) { // 删除多余班次
  1314 + _qIsUp == oLastBcIsUp ?
  1315 + aBc[i]._$$_internal_group_obj.setBc1(undefined) :
  1316 + aBc[i]._$$_internal_group_obj.setBc2(undefined);
  1317 + }
  1318 +
  1319 + // 查找末班车晚的末班车时间和方向
  1320 + if (_paramObj.getUpLastDtimeObj().isBefore(_paramObj.getDownLastDTimeObj())) {
  1321 + oLastBcTime = _paramObj.getDownLastDTimeObj();
  1322 + oLastBcIsUp = false;
  1323 + } else {
  1324 + oLastBcTime = _paramObj.getUpLastDtimeObj();
  1325 + oLastBcIsUp = true;
  1326 + }
  1327 + // 确定晚的末班车时间
  1328 + aBc = _fnGetBcList(oLastBcIsUp);
  1329 + var oBc;
  1330 + var aBcIndex;
  1331 + var iLpIndex;
  1332 + var iQIndex;
  1333 + var iBcIndex;
  1334 +
  1335 + iTimeDiff = undefined;
  1336 + for (i = 0; i < aBc.length; i++) {
  1337 + oBc = aBc[i];
  1338 + aBcIndex = _fnGetBcIndex(oBc);
  1339 +
  1340 + iLpIndex = aBcIndex[0];
  1341 + iQIndex = aBcIndex[2] == 0 ? aBcIndex[1] -1 : aBcIndex[1];
  1342 + iBcIndex = aBcIndex[2] == 0 ? 1 : 0;
  1343 +
  1344 + if (!_internalLpArray[iLpIndex].getBc(iQIndex, iBcIndex)) {
  1345 + continue;
  1346 + }
  1347 +
  1348 + iTempTime = oLastBcTime.diff(aBc[i].getFcTimeObj(), "m");
  1349 + if (iTimeDiff == undefined) {
  1350 + iTimeDiff = iTempTime;
  1351 + iModifyIndex = i;
  1352 + } else if (Math.abs(iTempTime) <= Math.abs(iTimeDiff)) {
  1353 + iTimeDiff = iTempTime;
  1354 + iModifyIndex = i;
  1355 + }
  1356 + }
  1357 + aBc[iModifyIndex].addMinuteToFcsj(iTimeDiff); // 替换成末班车时间
  1358 + aBc[iModifyIndex].fnSetDelFlag(false);
  1359 + aBc[iModifyIndex].fnSetIsLastBc(true);
  1360 + for (i = iModifyIndex + 1; i < aBc.length; i++) { // 删除多余班次
  1361 + _qIsUp == oLastBcIsUp ?
  1362 + aBc[i]._$$_internal_group_obj.setBc1(undefined) :
  1363 + aBc[i]._$$_internal_group_obj.setBc2(undefined);
  1364 + }
  1365 +
  1366 + },
  1367 +
  1368 + /**
  1369 + * 添加吃饭班次。
  1370 + */
  1371 + fnCalcuEatBc: function() {
  1372 + // 吃午饭时间范围，10:15 到 12:15
  1373 + // 吃晚饭时间范围，18:00 到 19:00
  1374 +
  1375 + if (!_paramObj.fnIsEat()) {
  1376 + return;
  1377 + }
  1378 +
  1379 + // 午饭index
  1380 + var aLEIndex;
  1381 + // 晚饭index
  1382 + var aDEIndex;
  1383 +
  1384 + console.log("吃饭");
  1385 + // 所有吃饭都默认在一个方向，两个方向暂时不考虑
  1386 + if (_paramObj.fnIsUpEat()) {
  1387 + aLEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("10:15"), true, false);
  1388 + aDEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("18:00"), true, false);
  1389 + } else {
  1390 + aLEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("10:15"), false, true);
  1391 + aDEIndex = _internalLpArray[0].getQBcIndexWithFcTime(_paramObj.toTimeObj("18:00"), false, true);
  1392 + }
  1393 +
  1394 + // 午饭第几圈，第几个班次
  1395 + var iLEQIndex = aLEIndex[0];
  1396 + var iLEBIndex = aLEIndex[1];
  1397 + // 晚饭第几圈，第几个班次
  1398 + var iDEQIndex = aDEIndex[0];
  1399 + var iDEBIndex = aDEIndex[1];
  1400 +
  1401 + // 注意，本模型只有连班才有吃饭
  1402 +
  1403 + var i;
  1404 + var oLp;
  1405 + var aLbIndex = []; // 连班班型的路牌索引
  1406 + for (i = 0; i < _internalLpArray.length; i++) {
  1407 + oLp = _internalLpArray[i];
  1408 + if (oLp.isBxLb()) {
  1409 + aLbIndex.push(i);
  1410 + }
  1411 + }
  1412 +
  1413 + var iLTime;
  1414 + var iDtime;
  1415 + var j;
  1416 + for (i = 0; i < aLbIndex.length; i++) {
  1417 + oLp = _internalLpArray[aLbIndex[i]];
  1418 +
  1419 + // 午饭
  1420 + iLTime = oLp.fnAddEatBc(iLEQIndex, iLEBIndex, _factory, _paramObj);
  1421 + // 晚饭
  1422 + iDtime = oLp.fnAddEatBc(iDEQIndex, iDEBIndex, _factory, _paramObj);
  1423 +
  1424 + if (i == aLbIndex.length - 1) {
  1425 + for (j = aLbIndex[i]; j < _internalLpArray.length; j++) {
  1426 + oLp = _internalLpArray[j];
  1427 + if (oLp.isBxFb()) { // 5休2班型不调整
  1428 + // 修正午饭之后路牌班次的发车时间
  1429 + oLp.fnAddMinuteToBcFcsj(iLEQIndex, iLEBIndex, iLTime);
  1430 + oLp.fnAddMinuteToBcFcsj(iDEQIndex, iDEBIndex, iDtime);
  1431 + }
  1432 + }
  1433 + } else {
  1434 + for (j = aLbIndex[i]; j < aLbIndex[i + 1]; j++) {
  1435 + oLp = _internalLpArray[j];
  1436 + if (oLp.isBxFb()) {
  1437 + // 修正午饭之后路牌班次的发车时间
  1438 + oLp.fnAddMinuteToBcFcsj(iLEQIndex, iLEBIndex, iLTime);
  1439 + oLp.fnAddMinuteToBcFcsj(iDEQIndex, iDEBIndex, iDtime);
  1440 + }
  1441 + }
  1442 + }
  1443 + }
  1444 +
  1445 + },
  1446 +
  1447 + /**
  1448 + * 补每个路牌的其他班次（进出场，例保班次）。
  1449 + */
  1450 + fnCalcuOtherBc_: function() {
  1451 + var i;
  1452 + var _lpObj;
  1453 + var _minBcIndex;
  1454 + var _maxBcIndex;
  1455 + var _minBc;
  1456 + var _maxBc;
  1457 + var _otherbc = [];
  1458 + var _oFbbc;
  1459 +
  1460 + for (i = 0; i < _internalLpArray.length; i++) {
  1461 + _lpObj = _internalLpArray[i];
  1462 + _minBcIndex = _lpObj.getMinBcObjPosition();
  1463 + _maxBcIndex = _lpObj.getMaxBcObjPosition();
  1464 + _minBc = _lpObj.getBc(_minBcIndex[0], _minBcIndex[1]);
  1465 + _maxBc = _lpObj.getBc(_maxBcIndex[0], _maxBcIndex[1]);
  1466 +
  1467 + _otherbc = [];
  1468 + _otherbc.push(_factory.createBcObj(
  1469 + _lpObj, "bd", true, 1,
  1470 + _minBc.getFcTimeObj(),
  1471 + _paramObj
  1472 + ));
  1473 + _otherbc.push(_factory.createBcObj(
  1474 + _lpObj, "out", true, 1,
  1475 + _minBc.getFcTimeObj(),
  1476 + _paramObj
  1477 + ));
  1478 +
  1479 + _maxBc.setArrTimeObj(_paramObj.addMinute(_maxBc.getFcTimeObj(), _maxBc.getBcTime()));
  1480 + _maxBc.setStopTime(0);
  1481 + _otherbc.push(_factory.createBcObj(
  1482 + _lpObj, "in", true, 1,
  1483 + _maxBc.getArrTimeObj(),
  1484 + _paramObj
  1485 + ));
  1486 + _otherbc.push(_factory.createBcObj(
  1487 + _lpObj, "lc", true, 1,
  1488 + _maxBc.getArrTimeObj(),
  1489 + _paramObj
  1490 + ));
  1491 +
  1492 + // 5休2分班出场例保班次
  1493 + if (_lpObj.isBxFb5_2()) {
  1494 + _oFbbc = _lpObj.getBc(
  1495 + _lpObj.fnGetBcChainInfo(1)["s_q"],
  1496 + _lpObj.fnGetBcChainInfo(1)["s_b"]
  1497 + );
  1498 +
  1499 + _otherbc.push(_factory.createBcObj(
  1500 + _lpObj, "bd", true, 1,
  1501 + _oFbbc.getFcTimeObj(),
  1502 + _paramObj
  1503 + ));
  1504 + _otherbc.push(_factory.createBcObj(
  1505 + _lpObj, "out", true, 1,
  1506 + _oFbbc.getFcTimeObj(),
  1507 + _paramObj
  1508 + ));
  1509 + }
  1510 +
  1511 + _lpObj.addOtherBcArray(_otherbc);
  1512 + }
  1513 +
  1514 + },
  1515 +
  1516 + /**
  1517 + * 补每个路牌的其他班次（进出场，例保班次）
  1518 + * 所有的车次链前后都加进出场、报道班次
  1519 + */
  1520 + fnCalcuOtherBc: function() {
  1521 + var i;
  1522 + var j;
  1523 + var iBcChainCount;
  1524 + var oLp;
  1525 + var aOtherBc;
  1526 + var oStartBc;
  1527 + var oEndBc;
  1528 +
  1529 + for (i = 0; i < _internalLpArray.length; i++) {
  1530 + aOtherBc = [];
  1531 + oLp = _internalLpArray[i];
  1532 + iBcChainCount = oLp.fnGetBcChainCount();
  1533 +
  1534 + if (iBcChainCount == 1) { // 只有一个车次链，是连班班型
  1535 + // 头部要添加出场，例保班次
  1536 + oStartBc = oLp.getBc(
  1537 + oLp.fnGetBcChainInfo(0)["s_q"],
  1538 + oLp.fnGetBcChainInfo(0)["s_b"]
  1539 + );
  1540 + aOtherBc.push(_factory.createBcObj(
  1541 + oLp, "bd", oStartBc.isUp(), 1,
  1542 + oStartBc.getFcTimeObj(),
  1543 + _paramObj
  1544 + ));
  1545 + aOtherBc.push(_factory.createBcObj(
  1546 + oLp, "out", oStartBc.isUp(), 1,
  1547 + oStartBc.getFcTimeObj(),
  1548 + _paramObj
  1549 + ));
  1550 +
  1551 + // 尾部需添加进场，例保班次
  1552 + oEndBc = oLp.getBc(
  1553 + oLp.fnGetBcChainInfo(0)["e_q"],
  1554 + oLp.fnGetBcChainInfo(0)["e_b"]
  1555 + );
  1556 + oEndBc.fnSetIsLastBc(false); // 有可能最后一个班次是吃饭班次，重置
  1557 + oEndBc.fnSetEatTime(0); // 有可能最后一个班次是吃饭班次，重置
  1558 + aOtherBc.push(_factory.createBcObj(
  1559 + oLp, "in", !oEndBc.isUp(), 1,
  1560 + oEndBc.getArrTimeObj(),
  1561 + _paramObj
  1562 + ));
  1563 + aOtherBc.push(_factory.createBcObj(
  1564 + oLp, "lc", !oEndBc.isUp(), 1,
  1565 + oEndBc.getArrTimeObj(),
  1566 + _paramObj
  1567 + ));
  1568 + } else if (iBcChainCount == 2) { // 两个车次链，是分班班型
  1569 + // 第一个车次链开头有出场，报到班次，车次链结尾只有进场班次
  1570 + oStartBc = oLp.getBc(
  1571 + oLp.fnGetBcChainInfo(0)["s_q"],
  1572 + oLp.fnGetBcChainInfo(0)["s_b"]
  1573 + );
  1574 + aOtherBc.push(_factory.createBcObj(
  1575 + oLp, "bd", oStartBc.isUp(), 1,
  1576 + oStartBc.getFcTimeObj(),
  1577 + _paramObj
  1578 + ));
  1579 + aOtherBc.push(_factory.createBcObj(
  1580 + oLp, "out", oStartBc.isUp(), 1,
  1581 + oStartBc.getFcTimeObj(),
  1582 + _paramObj
  1583 + ));
  1584 +
  1585 + oEndBc = oLp.getBc(
  1586 + oLp.fnGetBcChainInfo(0)["e_q"],
  1587 + oLp.fnGetBcChainInfo(0)["e_b"]
  1588 + );
  1589 + aOtherBc.push(_factory.createBcObj(
  1590 + oLp, "in", !oEndBc.isUp(), 1,
  1591 + oEndBc.getArrTimeObj(),
  1592 + _paramObj
  1593 + ));
  1594 +
  1595 + // 第二个车次链开头有出场，报到班次，车次链结尾有进场，报到班次
  1596 + oStartBc = oLp.getBc(
  1597 + oLp.fnGetBcChainInfo(1)["s_q"],
  1598 + oLp.fnGetBcChainInfo(1)["s_b"]
  1599 + );
  1600 + aOtherBc.push(_factory.createBcObj(
  1601 + oLp, "bd", oStartBc.isUp(), 1,
  1602 + oStartBc.getFcTimeObj(),
  1603 + _paramObj
  1604 + ));
  1605 + aOtherBc.push(_factory.createBcObj(
  1606 + oLp, "out", oStartBc.isUp(), 1,
  1607 + oStartBc.getFcTimeObj(),
  1608 + _paramObj
  1609 + ));
  1610 +
  1611 + oEndBc = oLp.getBc(
  1612 + oLp.fnGetBcChainInfo(1)["e_q"],
  1613 + oLp.fnGetBcChainInfo(1)["e_b"]
  1614 + );
  1615 + aOtherBc.push(_factory.createBcObj(
  1616 + oLp, "in", !oEndBc.isUp(), 1,
  1617 + oEndBc.getArrTimeObj(),
  1618 + _paramObj
  1619 + ));
  1620 + aOtherBc.push(_factory.createBcObj(
  1621 + oLp, "lc", !oEndBc.isUp(), 1,
  1622 + oEndBc.getArrTimeObj(),
  1623 + _paramObj
  1624 + ));
  1625 +
  1626 +
  1627 + } else {
  1628 + // 2个车次链以上，暂时没有此班型
  1629 + }
  1630 +
  1631 + oLp.addOtherBcArray(aOtherBc);
  1632 + }
  1633 + },
  1634 +
  1635 + /**
  1636 + * 祛除上标线开头的删除标记的班次。
  1637 + */
  1638 + fnRemoveDelFirstFlagBc: function() {
  1639 + var oLp = _internalLpArray[0];
  1640 + var aMinBcIndex = oLp.getMinBcObjPosition();
  1641 + if (oLp.getBc(aMinBcIndex[0], aMinBcIndex[1]).fnIsDelFlag()) {
  1642 + oLp.removeBc(aMinBcIndex[0], aMinBcIndex[1]);
  1643 + }
  1644 + },
  1645 + /**
  1646 + * 祛除上标线结尾的删除标记的班次。
  1647 + */
  1648 + fnRemoveDelLastFlagBc: function() {
  1649 + var oLp = _internalLpArray[0];
  1650 + var aMaxBcIndex = oLp.getMaxBcObjPosition();
  1651 + if (oLp.getBc(aMaxBcIndex[0], aMaxBcIndex[1]).fnIsDelFlag()) {
  1652 + oLp.removeBc(aMaxBcIndex[0], aMaxBcIndex[1]);
  1653 + }
  1654 + },
  1655 +
  1656 + /**
  1657 + * 调整路牌班次间隔（核准周转时间，停站时间）。
  1658 + * @param iFre int 迭代次数
  1659 + */
  1660 + fnAdjustLpBcInterval: function(iFre) {
  1661 + // if (iFre > 0) {
  1662 + // for (var i = 0; i < _internalLpArray.length; i++) {
  1663 + // _internalLpArray[i].fnAdjustBcInterval(
  1664 + // this.fnCalcuAverPeakStopTime(),
  1665 + // this.fnCalcuAverTroughStopTime(),
  1666 + // _paramObj);
  1667 + // }
  1668 + //
  1669 + // this.fnAdjustLpBcInterval(iFre - 1);
  1670 + // }
  1671 +
  1672 + for (var i = 0; i < _internalLpArray.length; i++) {
  1673 + _internalLpArray[i].fnAdjustBcTime_layover(_paramObj);
  1674 + }
  1675 + },
  1676 +
  1677 + /**
  1678 + * 调整班次间隔。
  1679 + * @param bIsUp 是否上行
  1680 + * @param oStartTime 开始时间对象
  1681 + * @param iFre 迭代次数
  1682 + */
  1683 + fnAdjustBcInterval2_: function(bIsUp, oStartTime, iFre) {
  1684 + if (iFre > 0) {
  1685 + var aBc = _fnGetBcList2(bIsUp, oStartTime); // 指定方向的班次列表
  1686 + aBc.sort(function(o1, o2) {
  1687 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  1688 + return -1;
  1689 + } else {
  1690 + return 1;
  1691 + }
  1692 + });
  1693 + var i;
  1694 + var j;
  1695 +
  1696 + var iBcCountOfGroup = 3; // 3个班次取一次计算
  1697 + var aBcOfGroup; // 3个班次列表
  1698 + var aBcIntervalOfGroup; // 班次间隔列表，如：3个班次，2个间隔
  1699 +
  1700 + for (i = 0; i <= aBc.length - iBcCountOfGroup; i++) {
  1701 + aBcOfGroup = [];
  1702 + aBcIntervalOfGroup = [];
  1703 + for (j = i; j < i + iBcCountOfGroup; j++) {
  1704 + aBcOfGroup.push(aBc[j]);
  1705 + }
  1706 +
  1707 + for (j = 0; j < aBcOfGroup.length; j++) {
  1708 + if (j < aBcOfGroup.length - 1) {
  1709 + aBcIntervalOfGroup.push(aBcOfGroup[j + 1].getFcTimeObj().diff(
  1710 + aBcOfGroup[j].getFcTimeObj(), "m"));
  1711 + }
  1712 + }
  1713 +
  1714 + if (aBcIntervalOfGroup[0] < 19) {
  1715 + aBcOfGroup[1].addMinuteToFcsj(1);
  1716 + } else if (aBcIntervalOfGroup[0] > 20) {
  1717 + aBcOfGroup[1].addMinuteToFcsj(-1);
  1718 + } else {
  1719 + if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  1720 + //continue;
  1721 + } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  1722 + aBcOfGroup[1].addMinuteToFcsj(-1);
  1723 + } else {
  1724 + aBcOfGroup[1].addMinuteToFcsj(1);
  1725 + }
  1726 + }
  1727 +
  1728 + }
  1729 +
  1730 + this.fnAdjustBcInterval2(bIsUp, oStartTime, iFre - 1);
  1731 + }
  1732 + },
  1733 +
  1734 + /**
  1735 + * 调整班次间隔（使用策略类）。
  1736 + * @param oStartTime 开始时间对象
  1737 + */
  1738 + fnAdjustBcInterval: function(oStartTime) {
  1739 + // 获取上行班次列表
  1740 + var aUpBc = !oStartTime ? _fnGetBcList(true) : _fnGetBcList2(true, oStartTime); // 指定方向的班次列表
  1741 + var aDownBc = !oStartTime ? _fnGetBcList(false) : _fnGetBcList2(false, oStartTime); // 指定方向的班次列表
  1742 + // 使用策略类调用指定策略函数，注意 AdjustTripStrategy.js 导入
  1743 + // console.log(StrategyUtils);
  1744 + eval("var _oFn = " + _paramObj.fnGetAdjustStrategyId() + ";");
  1745 + StrategyUtils.sConfig("ADJUST_TRIP", _oFn);
  1746 + StrategyUtils.sFn("ADJUST_TRIP")(aUpBc, aDownBc, this, _paramObj);
  1747 +
  1748 + },
  1749 +
  1750 + /**
  1751 + * 调整班次间隔（平均间隔）。
  1752 + * @param bIsUp 是否上行
  1753 + * @param oStartTime 开始时间对象
  1754 + */
  1755 + fnAdjustBcInterval2_avg: function(bIsUp, oStartTime) {
  1756 + var aBc = !oStartTime ? _fnGetBcList(bIsUp) : _fnGetBcList2(bIsUp, oStartTime); // 指定方向的班次列表
  1757 + aBc.sort(function(o1, o2) {
  1758 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  1759 + return -1;
  1760 + } else {
  1761 + return 1;
  1762 + }
  1763 + });
  1764 +
  1765 + if (aBc.length == 0) {
  1766 + return;
  1767 + }
  1768 +
  1769 + var j;
  1770 + var iCount = aBc.length - 1;
  1771 + var iC1 = Math.floor(aBc[aBc.length - 1].getFcTimeObj().diff(aBc[0].getFcTimeObj(), "m") / iCount);
  1772 + var iC2 = aBc[aBc.length - 1].getFcTimeObj().diff(aBc[0].getFcTimeObj(), "m") % iCount;
  1773 + var iTempTime;
  1774 +
  1775 + for (j = 0; j < iCount - iC2; j++) {
  1776 + iTempTime = aBc[j + 1].getFcTimeObj().diff(aBc[j].getFcTimeObj(), "m");
  1777 + aBc[j + 1].addMinuteToFcsj(iC1 - iTempTime);
  1778 + }
  1779 + for (j = 0; j < iC2; j++) {
  1780 + iTempTime = aBc[iCount - iC2 + j + 1].getFcTimeObj().diff(aBc[iCount - iC2 + j].getFcTimeObj(), "m");
  1781 + aBc[iCount - iC2 + j + 1].addMinuteToFcsj(iC1 + 1 - iTempTime);
  1782 + }
  1783 +
  1784 + },
  1785 +
  1786 + /**
  1787 + * 计算高峰平均停站时间。
  1788 + */
  1789 + fnCalcuAverPeakStopTime: function() {
  1790 + var i;
  1791 + var j;
  1792 + var aBc;
  1793 + var iBcCount = 0;
  1794 + var iSum = 0;
  1795 + for (i = 0; i < _internalLpArray.length; i++) {
  1796 + aBc = _internalLpArray[i].getBcArray();
  1797 +
  1798 + for (j = 0; j < aBc.length; j++) {
  1799 + if (!_paramObj.isTroughBc(aBc[j].getArrTimeObj())) {
  1800 + iBcCount ++;
  1801 + iSum += aBc[j].getStopTime();
  1802 + }
  1803 + }
  1804 + }
  1805 +
  1806 + return Math.floor(iSum / iBcCount);
  1807 + },
  1808 +
  1809 + /**
  1810 + * 计算低谷平均停站时间。
  1811 + */
  1812 + fnCalcuAverTroughStopTime: function() {
  1813 + var i;
  1814 + var j;
  1815 + var aBc;
  1816 + var iBcCount = 0;
  1817 + var iSum = 0;
  1818 + for (i = 0; i < _internalLpArray.length; i++) {
  1819 + aBc = _internalLpArray[i].getBcArray();
  1820 + for (j = 0; j < aBc.length; j++) {
  1821 + if (_paramObj.isTroughBc(aBc[j].getArrTimeObj())) {
  1822 + iBcCount ++;
  1823 + iSum += aBc[j].getStopTime();
  1824 + }
  1825 + }
  1826 + }
  1827 +
  1828 + return Math.floor(iSum / iBcCount);
  1829 + },
  1830 +
  1831 + //------------- 其他方法 -------------//
  1832 + /**
  1833 + * 返回内部路牌数据列表。
  1834 + * @returns {Array}
  1835 + */
  1836 + fnGetLpArray: function() {
  1837 + return _internalLpArray;
  1838 + },
  1839 +
  1840 + /**
  1841 + * 内部数据转化成显示用的班次数组。
  1842 + */
  1843 + fnToGanttBcArray: function() {
  1844 + var aAllBc = [];
  1845 + var aLpBc = [];
  1846 + var aEatBc = [];
  1847 + var oLp;
  1848 + var i;
  1849 + var j;
  1850 +
  1851 + for (i = 0; i < _internalLpArray.length; i++) {
  1852 + oLp = _internalLpArray[i];
  1853 + aLpBc = [];
  1854 + aLpBc = aLpBc.concat(oLp.getOtherBcArray(), oLp.getBcArray());
  1855 +
  1856 + aEatBc = [];
  1857 + // 根据班次的吃饭时间添加吃饭班次
  1858 + for (j = 0; j < aLpBc.length; j++) {
  1859 + if (aLpBc[j].fnGetEatTime() > 0) {
  1860 + aEatBc.push(_factory.createBcObj(
  1861 + oLp,
  1862 + "cf",
  1863 + !aLpBc[j].isUp(), // 和上一个班次方向相反
  1864 + 1,
  1865 + _paramObj.addMinute(aLpBc[j].getArrTimeObj(), aLpBc[j].getStopTime()), // 使用上一个班次的到达时间作为开始时间
  1866 + _paramObj
  1867 + ));
  1868 + }
  1869 + }
  1870 + aLpBc = aLpBc.concat(aEatBc);
  1871 +
  1872 + // 按照发车时间排序
  1873 + aLpBc.sort(function(o1, o2) {
  1874 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  1875 + return -1;
  1876 + } else {
  1877 + return 1;
  1878 + }
  1879 + });
  1880 +
  1881 + // 重新赋值fcno
  1882 + for (j = 0; j < aLpBc.length; j++) {
  1883 + aLpBc[j].fnSetFcno(j + 1);
  1884 + }
  1885 +
  1886 + aAllBc = aAllBc.concat(aLpBc);
  1887 + }
  1888 +
  1889 + var aGanttBc = [];
  1890 + for (i = 0; i < aAllBc.length; i++) {
  1891 + aGanttBc.push(aAllBc[i].toGanttBcObj());
  1892 + }
  1893 +
  1894 + return aGanttBc;
  1895 + }
  1896 +
  1897 + };
  1898 +
1896 1899 };
1897 1900 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/main_v2.js
  View file @14e3a31
1   -/**
2   - * 主类。
3   - */
4   -var Main_v2 = function() {
5   -
6   - // 内部工厂类
7   - var _factoryFun = function() {
8   - return {
9   - // 创建参数
10   - createParameterObj: function(formMap, dataMap) {
11   - var paramObj = ParameterObj();
12   - paramObj.wrap(formMap, dataMap);
13   - return paramObj;
14   - },
15   - // 创建班次对象
16   - createBcObj: function(lpObj, bcType, isUp, fcno, fcTimeObj, paramObj) {
17   - var _bclc = paramObj.calcuTravelLcNumber(isUp, bcType);
18   - var _fcsj = fcTimeObj;
19   - var _bcsj = paramObj.calcuTravelTime(_fcsj, isUp);
20   - var _arrsj = paramObj.addMinute(_fcsj, _bcsj);
21   - //var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
22   - var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, isUp, paramObj.calcuTravelTime(_fcsj, isUp));
23   - var _tccid = paramObj.getTTinfoId();
24   - var _ttinfoid = paramObj.getTTinfoId();
25   - var _xl = paramObj.getXlId();
26   - var _qdz = isUp ? paramObj.getUpQdzObj().id : paramObj.getDownQdzObj().id;
27   - var _zdz = isUp ? paramObj.getUpZdzObj().id : paramObj.getDownZdzObj().id;
28   -
29   - if (bcType == "bd") { // 早例保，传过来的发车时间是第一个班次的发车时间
30   - if (isUp) { // 上行
31   - _fcsj = paramObj.addMinute(
32   - _fcsj,
33   - -(paramObj.getUpOutTime() + paramObj.getLbTime()));
34   - _bcsj = paramObj.getLbTime();
35   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
36   - _stoptime = 0;
37   - } else { // 下行
38   - _fcsj = paramObj.addMinute(
39   - _fcsj,
40   - -(paramObj.getDownOutTime() + paramObj.getLbTime()));
41   - _bcsj = paramObj.getLbTime();
42   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
43   - _stoptime = 0;
44   - }
45   - } else if (bcType == "lc") { // 晚例保，传过来的发车时间是最后一个班次的到达时间
46   - if (isUp) { // 上行
47   - _fcsj = paramObj.addMinute(
48   - _fcsj,
49   - paramObj.getUpInTime());
50   - _bcsj = paramObj.getLbTime();
51   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
52   - _stoptime = 0;
53   - } else { // 下行
54   - _fcsj = paramObj.addMinute(
55   - _fcsj,
56   - paramObj.getDownInTime());
57   - _bcsj = paramObj.getLbTime();
58   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
59   - _stoptime = 0;
60   - }
61   - } else if (bcType == "out") { // 出场，传过来的发车时间是第一个班次的发车时间
62   - if (isUp) { // 上行
63   - _fcsj = paramObj.addMinute(
64   - _fcsj,
65   - -paramObj.getUpOutTime());
66   - _bcsj = paramObj.getUpOutTime();
67   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
68   - _stoptime = 0;
69   - } else { // 下行
70   - _fcsj = paramObj.addMinute(
71   - _fcsj,
72   - -paramObj.getDownOutTime());
73   - _bcsj = paramObj.getDownOutTime();
74   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
75   - _stoptime = 0;
76   - }
77   - } else if (bcType == "in") { // 进场，传过来的发车时间是最后一个班次的到达时间
78   - if (isUp) { // 上行
79   - _bcsj = paramObj.getUpInTime();
80   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
81   - _stoptime = 0;
82   - } else { // 下行
83   - _bcsj = paramObj.getDownInTime();
84   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
85   - _stoptime = 0;
86   - }
87   - } else if (bcType == "cf") { // 吃饭班次
88   - // 以13:00为分界，之前的为午饭，之后的为晚饭
89   - if (fcTimeObj.isBefore(paramObj.toTimeObj("13:00"))) {
90   - _bcsj = paramObj.fnGetLunchTime();
91   - } else {
92   - _bcsj = paramObj.fnGetDinnerTime();
93   - }
94   - _arrsj = paramObj.addMinute(_fcsj, _bcsj);
95   - _stoptime = 0;
96   - }
97   -
98   - var bcParamObj = {};
99   - bcParamObj.bcType = bcType; // 班次类型（normal，in_，out, bd, lc, cf等）
100   - bcParamObj.isUp = isUp; // boolean是否上下行
101   - bcParamObj.fcno = fcno; // 发车顺序号
102   - bcParamObj.fcTimeObj = _fcsj; // 发车时间对象
103   - bcParamObj.bclc = _bclc; // 班次里程
104   - bcParamObj.bcsj = _bcsj; // 班次历时
105   - bcParamObj.arrtime = _arrsj; // 到达时间对象
106   - bcParamObj.stoptime = _stoptime; // 停站时间
107   - bcParamObj.tccid = _tccid; // 停车场id
108   - bcParamObj.ttinfoid = _ttinfoid; // 时刻表id
109   - bcParamObj.xl = _xl; // 线路id
110   - bcParamObj.qdzid = _qdz; // 起点站id
111   - bcParamObj.zdzid = _zdz; // 终点站id
112   -
113   - return new InternalBcObj(lpObj, bcParamObj);
114   - }
115   - };
116   - };
117   - var _factory = _factoryFun();
118   -
119   - // 所有的时间使用moment.js计算
120   -
121   - var _paramObj; // 参数对象
122   -
123   - var _bxDesc = [ // 班型描述
124   - {'type':'六工一休','hoursV':6.66, 'minueV':'6:40', 'qcount': 0, 'avertime': 0},
125   - {'type':'五工一休','hoursV':6.85, 'minueV':'6:51', 'qcount': 0, 'avertime': 0},
126   - {'type':'四工一休','hoursV':7.14, 'minueV':'7:08', 'qcount': 0, 'avertime': 0},
127   - {'type':'三工一休','hoursV':7.61, 'minueV':'7:37', 'qcount': 0, 'avertime': 0},
128   - {'type':'二工一休','hoursV':8.57, 'minueV':'8:34', 'qcount': 0, 'avertime': 0},
129   - {'type':'一工一休','hoursV':11.42, 'minueV':'11:25', 'qcount': 0, 'avertime': 0},
130   - {'type':'五工二休','hoursV':7.99, 'minueV':'8:00', 'qcount': 0, 'avertime': 0},
131   - {'type':'无工休', 'hoursV':5.43, 'minueV':'5:43', 'qcount': 0, 'avertime': 0}
132   - ];
133   -
134   - var _funCalcuExportData_lpObjList = function(aInternalLpObj) {
135   - // 构造路牌对象
136   - var aLpObj = [];
137   - var i;
138   - var j;
139   - var z;
140   - var oInternalLp;
141   - var oInternalBc;
142   - var oInternalBc_temp;
143   - var oLp;
144   - var iZlc;
145   - var iYylc;
146   - var iKslc;
147   - var iZbc;
148   - var iZgs;
149   - var iYygs;
150   - var iYybc;
151   - for (i = 0; i < aInternalLpObj.length; i++) {
152   - oInternalLp = aInternalLpObj[i];
153   - iZlc = 0;
154   - iYylc = 0;
155   - iKslc = 0;
156   - iZgs = 0;
157   - iZbc = 0;
158   - iYygs = 0;
159   - iYybc = 0;
160   - oLp = {
161   - "lpname": oInternalLp.getLpName(), // 路牌名字
162   - "isUp": oInternalLp.isUp(), // 每圈的第一个班次是否上行
163   - "bcObjList": [], // 班次列表
164   - "groupCount": oInternalLp.fnGetGroupCount(), // 总圈数
165   - "zlc": 0, // 总里程
166   - "yylc": 0, // 营运里程
167   - "kslc": 0, // 空驶里程
168   - "zgs": 0, // 总工时
169   - "zbc": 0, // 总班次
170   - "yygs": 0, // 营运工时
171   - "yybc": 0, // 营运班次
172   - "stationRouteId1": 0, // 第一个班次起点站路由id
173   - "stationRouteId2": 0 // 第二个班次起点站路由id
174   - };
175   -
176   - // 将报到班次，进出场班次加到班次的时间上
177   - var iBcChainCount;
178   - var oStartBc;
179   - var oEndBc;
180   - var oTempBc;
181   - var aFcsj = [];
182   -
183   - iBcChainCount = oInternalLp.fnGetBcChainCount();
184   - if (iBcChainCount == 1) { // 单一车次链，连班班型
185   - oStartBc = oInternalLp.getBc(
186   - oInternalLp.fnGetBcChainInfo(0)["s_q"],
187   - oInternalLp.fnGetBcChainInfo(0)["s_b"]
188   - );
189   - oTempBc = _factory.createBcObj(
190   - oLp, "bd", oStartBc.isUp(), 1,
191   - oStartBc.getFcTimeObj(),
192   - _paramObj
193   - );
194   - aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
195   - oLp.bcObjList.push({ // 报到班次
196   - "bcsj": oTempBc.getBcTime(), // 班次时间
197   - "ssj": oTempBc.getStopTime(), // 停站时间
198   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
199   -
200   - "tccid": oTempBc._$_tccid, // 停车场id
201   - "qdzid": oTempBc._$_qdzid, // 起点站id
202   - "zdzid": oTempBc._$_zdzid, // 终点站id
203   -
204   - "isUp": oTempBc._$_isUp, // 是否上行
205   - "isFb": false, // 是否分班
206   -
207   - "bcType": oTempBc._$_bcType, // 班次类型
208   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
209   -
210   - "groupNo": -1, // 第几圈
211   - "groupBcNo": -1 // 圈里第几个班次
212   -
213   - });
214   -
215   - oTempBc = _factory.createBcObj(
216   - oLp, "out", oStartBc.isUp(), 1,
217   - oStartBc.getFcTimeObj(),
218   - _paramObj
219   - );
220   - aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
221   - aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
222   - oStartBc._$_fcsj_desc = aFcsj.join("");
223   -
224   - oLp.bcObjList.push({ // 出场班次
225   - "bcsj": oTempBc.getBcTime(), // 班次时间
226   - "ssj": oTempBc.getStopTime(), // 停站时间
227   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
228   -
229   - "tccid": oTempBc._$_tccid, // 停车场id
230   - "qdzid": oTempBc._$_qdzid, // 起点站id
231   - "zdzid": oTempBc._$_zdzid, // 终点站id
232   -
233   - "isUp": oTempBc._$_isUp, // 是否上行
234   - "isFb": false, // 是否分班
235   -
236   - "bcType": oTempBc._$_bcType, // 班次类型
237   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
238   -
239   - "groupNo": -1, // 第几圈
240   - "groupBcNo": -2 // 圈里第几个班次
241   -
242   - });
243   -
244   - aFcsj = [];
245   -
246   - oEndBc = oInternalLp.getBc(
247   - oInternalLp.fnGetBcChainInfo(0)["e_q"],
248   - oInternalLp.fnGetBcChainInfo(0)["e_b"]
249   - );
250   - aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
251   - oTempBc = _factory.createBcObj(
252   - oLp, "in", !oEndBc.isUp(), 1,
253   - oEndBc.getArrTimeObj(),
254   - _paramObj
255   - );
256   - aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
257   -
258   - oLp.bcObjList.push({ // 进场班次
259   - "bcsj": oTempBc.getBcTime(), // 班次时间
260   - "ssj": oTempBc.getStopTime(), // 停站时间
261   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
262   -
263   - "tccid": oTempBc._$_tccid, // 停车场id
264   - "qdzid": oTempBc._$_qdzid, // 起点站id
265   - "zdzid": oTempBc._$_zdzid, // 终点站id
266   -
267   - "isUp": oTempBc._$_isUp, // 是否上行
268   - "isFb": false, // 是否分班
269   -
270   - "bcType": oTempBc._$_bcType, // 班次类型
271   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
272   -
273   - "groupNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ?
274   - oInternalLp.fnGetBcChainInfo(0)["e_q"] :
275   - oInternalLp.fnGetBcChainInfo(0)["e_q"] + 1, // 第几圈
276   - "groupBcNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
277   -
278   - });
279   -
280   - oTempBc = _factory.createBcObj(
281   - oLp, "lc", !oEndBc.isUp(), 1,
282   - oEndBc.getArrTimeObj(),
283   - _paramObj
284   - );
285   - aFcsj.push("(离" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
286   - oLp.bcObjList.push({ // 离场班次
287   - "bcsj": oTempBc.getBcTime(), // 班次时间
288   - "ssj": oTempBc.getStopTime(), // 停站时间
289   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
290   -
291   - "tccid": oTempBc._$_tccid, // 停车场id
292   - "qdzid": oTempBc._$_qdzid, // 起点站id
293   - "zdzid": oTempBc._$_zdzid, // 终点站id
294   -
295   - "isUp": oTempBc._$_isUp, // 是否上行
296   - "isFb": false, // 是否分班
297   -
298   - "bcType": oTempBc._$_bcType, // 班次类型
299   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
300   -
301   - "groupNo": -2, // 第几圈
302   - "groupBcNo": -4 // 圈里第几个班次
303   -
304   - });
305   -
306   - oEndBc._$_fcsj_desc = aFcsj.join("");
307   -
308   - } else if (iBcChainCount == 2) { // 两个车次链，分班班型
309   - oStartBc = oInternalLp.getBc(
310   - oInternalLp.fnGetBcChainInfo(0)["s_q"],
311   - oInternalLp.fnGetBcChainInfo(0)["s_b"]
312   - );
313   - oTempBc = _factory.createBcObj(
314   - oLp, "bd", oStartBc.isUp(), 1,
315   - oStartBc.getFcTimeObj(),
316   - _paramObj
317   - );
318   - aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
319   - oLp.bcObjList.push({ // 报到班次
320   - "bcsj": oTempBc.getBcTime(), // 班次时间
321   - "ssj": oTempBc.getStopTime(), // 停站时间
322   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
323   -
324   - "tccid": oTempBc._$_tccid, // 停车场id
325   - "qdzid": oTempBc._$_qdzid, // 起点站id
326   - "zdzid": oTempBc._$_zdzid, // 终点站id
327   -
328   - "isUp": oTempBc._$_isUp, // 是否上行
329   - "isFb": false, // 是否分班
330   -
331   - "bcType": oTempBc._$_bcType, // 班次类型
332   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
333   -
334   - "groupNo": -1, // 第几圈
335   - "groupBcNo": -1 // 圈里第几个班次
336   -
337   - });
338   -
339   - oTempBc = _factory.createBcObj(
340   - oLp, "out", oStartBc.isUp(), 1,
341   - oStartBc.getFcTimeObj(),
342   - _paramObj
343   - );
344   - aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
345   - aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
346   - oStartBc._$_fcsj_desc = aFcsj.join("");
347   -
348   - oLp.bcObjList.push({ // 出场班次
349   - "bcsj": oTempBc.getBcTime(), // 班次时间
350   - "ssj": oTempBc.getStopTime(), // 停站时间
351   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
352   -
353   - "tccid": oTempBc._$_tccid, // 停车场id
354   - "qdzid": oTempBc._$_qdzid, // 起点站id
355   - "zdzid": oTempBc._$_zdzid, // 终点站id
356   -
357   - "isUp": oTempBc._$_isUp, // 是否上行
358   - "isFb": false, // 是否分班
359   -
360   - "bcType": oTempBc._$_bcType, // 班次类型
361   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
362   -
363   - "groupNo": -1, // 第几圈
364   - "groupBcNo": -2 // 圈里第几个班次
365   -
366   - });
367   -
368   - aFcsj = [];
369   -
370   - oEndBc = oInternalLp.getBc(
371   - oInternalLp.fnGetBcChainInfo(0)["e_q"],
372   - oInternalLp.fnGetBcChainInfo(0)["e_b"]
373   - );
374   - aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
375   - oTempBc = _factory.createBcObj(
376   - oLp, "in", !oEndBc.isUp(), 1,
377   - oEndBc.getArrTimeObj(),
378   - _paramObj
379   - );
380   - aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
381   - oLp.bcObjList.push({ // 进场班次
382   - "bcsj": oTempBc.getBcTime(), // 班次时间
383   - "ssj": oTempBc.getStopTime(), // 停站时间
384   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
385   -
386   - "tccid": oTempBc._$_tccid, // 停车场id
387   - "qdzid": oTempBc._$_qdzid, // 起点站id
388   - "zdzid": oTempBc._$_zdzid, // 终点站id
389   -
390   - "isUp": oTempBc._$_isUp, // 是否上行
391   - "isFb": true, // 是否分班
392   -
393   - "bcType": oTempBc._$_bcType, // 班次类型
394   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
395   -
396   - "groupNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ?
397   - oInternalLp.fnGetBcChainInfo(0)["e_q"] :
398   - oInternalLp.fnGetBcChainInfo(0)["e_q"] + 1, // 第几圈
399   - "groupBcNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
400   -
401   - });
402   - oEndBc._$_fcsj_desc = aFcsj.join("");
403   -
404   - aFcsj = [];
405   -
406   - oStartBc = oInternalLp.getBc(
407   - oInternalLp.fnGetBcChainInfo(1)["s_q"],
408   - oInternalLp.fnGetBcChainInfo(1)["s_b"]
409   - );
410   - oTempBc = _factory.createBcObj(
411   - oLp, "bd", oStartBc.isUp(), 1,
412   - oStartBc.getFcTimeObj(),
413   - _paramObj
414   - );
415   - aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
416   - oLp.bcObjList.push({ // 报到班次
417   - "bcsj": oTempBc.getBcTime(), // 班次时间
418   - "ssj": oTempBc.getStopTime(), // 停站时间
419   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
420   -
421   - "tccid": oTempBc._$_tccid, // 停车场id
422   - "qdzid": oTempBc._$_qdzid, // 起点站id
423   - "zdzid": oTempBc._$_zdzid, // 终点站id
424   -
425   - "isUp": oTempBc._$_isUp, // 是否上行
426   - "isFb": true, // 是否分班
427   -
428   - "bcType": oTempBc._$_bcType, // 班次类型
429   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
430   -
431   - "groupNo": oInternalLp.fnGetBcChainInfo(1)["s_q"] - 1, // 第几圈
432   - "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] // 圈里第几个班次
433   -
434   - });
435   -
436   - oTempBc = _factory.createBcObj(
437   - oLp, "out", oStartBc.isUp(), 1,
438   - oStartBc.getFcTimeObj(),
439   - _paramObj
440   - );
441   - oLp.bcObjList.push({ // 出场班次
442   - "bcsj": oTempBc.getBcTime(), // 班次时间
443   - "ssj": oTempBc.getStopTime(), // 停站时间
444   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
445   -
446   - "tccid": oTempBc._$_tccid, // 停车场id
447   - "qdzid": oTempBc._$_qdzid, // 起点站id
448   - "zdzid": oTempBc._$_zdzid, // 终点站id
449   -
450   - "isUp": oTempBc._$_isUp, // 是否上行
451   - "isFb": true, // 是否分班
452   -
453   - "bcType": oTempBc._$_bcType, // 班次类型
454   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
455   -
456   - "groupNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] == 0 ?
457   - oInternalLp.fnGetBcChainInfo(1)["s_q"] - 1 :
458   - oInternalLp.fnGetBcChainInfo(1)["s_q"], // 第几圈
459   - "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] == 0 ? 1 : 0 // 圈里第几个班次
460   -
461   - });
462   - aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
463   - aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
464   - oStartBc._$_fcsj_desc = aFcsj.join("");
465   -
466   - aFcsj = [];
467   -
468   - oEndBc = oInternalLp.getBc(
469   - oInternalLp.fnGetBcChainInfo(1)["e_q"],
470   - oInternalLp.fnGetBcChainInfo(1)["e_b"]
471   - );
472   - aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
473   - oTempBc = _factory.createBcObj(
474   - oLp, "in", !oEndBc.isUp(), 1,
475   - oEndBc.getArrTimeObj(),
476   - _paramObj
477   - );
478   - aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
479   -
480   - oLp.bcObjList.push({ // 进场班次
481   - "bcsj": oTempBc.getBcTime(), // 班次时间
482   - "ssj": oTempBc.getStopTime(), // 停站时间
483   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
484   -
485   - "tccid": oTempBc._$_tccid, // 停车场id
486   - "qdzid": oTempBc._$_qdzid, // 起点站id
487   - "zdzid": oTempBc._$_zdzid, // 终点站id
488   -
489   - "isUp": oTempBc._$_isUp, // 是否上行
490   - "isFb": false, // 是否分班
491   -
492   - "bcType": oTempBc._$_bcType, // 班次类型
493   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
494   -
495   - "groupNo": oInternalLp.fnGetBcChainInfo(1)["e_b"] == 0 ?
496   - oInternalLp.fnGetBcChainInfo(1)["e_q"] :
497   - oInternalLp.fnGetBcChainInfo(1)["e_q"] + 1, // 第几圈
498   - "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
499   -
500   - });
501   -
502   - oTempBc = _factory.createBcObj(
503   - oLp, "lc", !oEndBc.isUp(), 1,
504   - oEndBc.getArrTimeObj(),
505   - _paramObj
506   - );
507   -
508   - oLp.bcObjList.push({ // 离场班次
509   - "bcsj": oTempBc.getBcTime(), // 班次时间
510   - "ssj": oTempBc.getStopTime(), // 停站时间
511   - "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
512   -
513   - "tccid": oTempBc._$_tccid, // 停车场id
514   - "qdzid": oTempBc._$_qdzid, // 起点站id
515   - "zdzid": oTempBc._$_zdzid, // 终点站id
516   -
517   - "isUp": oTempBc._$_isUp, // 是否上行
518   - "isFb": false, // 是否分班
519   -
520   - "bcType": oTempBc._$_bcType, // 班次类型
521   - "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
522   -
523   - "groupNo": -2, // 第几圈
524   - "groupBcNo": -4 // 圈里第几个班次
525   -
526   - });
527   -
528   - aFcsj.push("(离" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
529   - oEndBc._$_fcsj_desc = aFcsj.join("");
530   -
531   - }
532   -
533   - for (j = 0; j < oInternalLp.fnGetGroupCount(); j++) {
534   - for (z = 0; z < 2; z++) {
535   - oInternalBc = oInternalLp.getBc(j, z);
536   - if (oInternalBc) {
537   - if (oInternalBc.fnGetEatTime() > 0) {
538   - // 吃饭班次是下一个班次开始吃，和本班次方向相反
539   - oInternalBc_temp = oInternalLp.getBc(
540   - z == 1 ? j + 1 : j,
541   - z == 1 ? 0 : 1);
542   -
543   - oInternalBc_temp._$_isRealEat = true;
544   - oInternalBc_temp._$_fcsj_desc = "(吃" + oInternalBc_temp.getFcTimeObj().format("HH:mm") + ")";
545   - }
546   -
547   - oLp.bcObjList.push({
548   - "bcsj": oInternalBc.getBcTime(), // 班次时间
549   - "ssj": oInternalBc.getStopTime(), // 停站时间
550   - "eatsj": oInternalBc.fnGetEatTime(), // 吃饭时间
551   -
552   - "tccid": oInternalBc._$_tccid, // 停车场id
553   - "qdzid": oInternalBc._$_qdzid, // 起点站id
554   - "zdzid": oInternalBc._$_zdzid, // 终点站id
555   -
556   - "isUp": oInternalBc._$_isUp, // 是否上行
557   -
558   - "bcType": oInternalBc._$_bcType, // 班次类型
559   - "fcsj": oInternalBc._$_isRealEat ?
560   - ("*" + oInternalBc._$_fcsjObj.format("HH:mm")) :
561   - oInternalBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
562   - "fcsjDesc" : oInternalBc._$_fcsj_desc || oInternalBc._$_fcsjObj.format("HH:mm"),
563   -
564   - "groupNo": j, // 第几圈
565   - "groupBcNo": z // 圈里第几个班次
566   -
567   - });
568   -
569   - // iZlc = 0;
570   - // iYylc = 0;
571   - // iKslc = 0;
572   - // iZgs = 0;
573   - // iZbc = 0;
574   - // iYygs = 0;
575   - // iYybc = 0;
576   -
577   - iZlc = iZlc +
578   - oInternalBc._$_bclc; // 里程
579   - iYylc = iYylc +
580   - oInternalBc._$_bclc; // 里程
581   - iYygs = iYygs +
582   - oInternalBc.getBcTime() + // 班次时间
583   - oInternalBc.getStopTime() + // 停站时间
584   - oInternalBc.fnGetEatTime(); // 吃饭时间
585   - iYybc = iYybc + 1;
586   -
587   - iZgs = iZgs +
588   - oInternalBc.getBcTime() + // 班次时间
589   - oInternalBc.getStopTime() + // 停站时间
590   - oInternalBc.fnGetEatTime(); // 吃饭时间
591   - iZbc = iZbc + 1;
592   -
593   - // 设置圈站点路由id
594   - if (oInternalBc.isUp() == oInternalLp.isUp()) { // 第一个班次
595   - if (oLp.stationRouteId1 == 0) {
596   - oLp.stationRouteId1 = oInternalBc._$_qdzid;
597   - }
598   - } else { // 第二个班次
599   - if (oLp.stationRouteId2 == 0) {
600   - oLp.stationRouteId2 = oInternalBc._$_qdzid;
601   - }
602   - }
603   -
604   - }
605   - }
606   -
607   - }
608   -
609   - for (z = 0; z < oInternalLp.getOtherBcArray().length; z++) {
610   - oInternalBc = oInternalLp.getOtherBcArray()[z];
611   - iKslc = iKslc +
612   - oInternalBc._$_bclc; // 里程
613   - iZlc = iZlc +
614   - oInternalBc._$_bclc; // 里程
615   - iZgs = iZgs +
616   - oInternalBc.getBcTime() + // 班次时间
617   - oInternalBc.getStopTime(); // 停站时间
618   - if (oInternalBc._$_bcType != "bd" &&
619   - oInternalBc._$_bcType != "lc" &&
620   - oInternalBc._$_bcType != "cf") {
621   - iZbc = iZbc + 1;
622   - }
623   - }
624   -
625   - oLp.zlc = iZlc;
626   - oLp.yylc = iYylc;
627   - oLp.kslc = iKslc;
628   - oLp.zgs = iZgs;
629   - oLp.zbc = iZbc;
630   - oLp.yygs = iYygs;
631   - oLp.yybc = iYybc;
632   - aLpObj.push(oLp);
633   - }
634   -
635   - return aLpObj;
636   - };
637   -
638   - var _funCalcuExportData_statInfoList = function(aInternalLpObj) {
639   - var countBc = 0, // 总班次
640   - serviceBc = 0, // 营运班次
641   - jcbc = 0, // 进场总班次.
642   - ccbc = 0, // 出场总班次.
643   - cfbc = 0, // 吃饭总班次.
644   - zwlbbc = 0, // 早晚例保总班次.
645   - countGs = 0.0, // 总工时
646   - servicesj = 0, // 营运班次总时间
647   - jcsj = 0.0, // 进场总时间.
648   - ccsj = 0.0, // 出场总时间.
649   - cfsj = 0.0, // 吃饭总时间.
650   - zwlbsj = 0.0, // 早晚例保总时间.
651   - ksBc = 0, // 空驶班次
652   - serviceLc = 0.0, // 营运里程
653   - ksLc = 0.0, // 空驶里程
654   - avgTzjx = 0.0, // 平均停站间隙
655   - gfServiceBc = 0, // 高峰营运班次
656   - dgServiceBc = 0, // 低谷营运班次
657   - gfAvgTzjx = 0.0, // 高峰平均停站间隙
658   - dgAvgTzjx = 0.0; // 低谷平均停站间隙
659   -
660   - var aAllBc = [];
661   - var oLp;
662   - var oBc;
663   - var i;
664   - var j;
665   -
666   - for (i = 0; i < aInternalLpObj.length; i++) {
667   - oLp = aInternalLpObj[i];
668   - for (j = 0; j < oLp.getBcArray().length; j++) {
669   - aAllBc.push(oLp.getBcArray()[j]);
670   - }
671   - for (j = 0; j < oLp.getOtherBcArray().length; j++) {
672   - aAllBc.push(oLp.getOtherBcArray()[j]);
673   - }
674   - }
675   -
676   - for (i = 0; i < aAllBc.length; i++) {
677   - oBc = aAllBc[i];
678   -
679   - if (oBc.getBcTime() > 0) {
680   - countBc = countBc + 1;
681   - countGs = countGs + oBc.getStopTime() + oBc.getBcTime();
682   - if (_paramObj.isTroughBc(oBc.getFcTimeObj())) {
683   - if (oBc._$_bcType == "normal") {
684   - dgServiceBc = dgServiceBc + 1;
685   - dgAvgTzjx = dgAvgTzjx + oBc.getStopTime();
686   - }
687   - } else {
688   - if (oBc._$_bcType == "normal") {
689   - gfServiceBc = gfServiceBc + 1;
690   - gfAvgTzjx = gfAvgTzjx + oBc.getStopTime();
691   - }
692   - }
693   -
694   - if (oBc._$_bcType == "normal") {
695   - serviceBc = serviceBc + 1;
696   - serviceLc = serviceLc + oBc._$_bclc;
697   - servicesj = servicesj + oBc.getBcTime();
698   - avgTzjx = avgTzjx + oBc.getStopTime();
699   -
700   - if (oBc.fnGetEatTime() > 0) {
701   - cfbc = cfbc + 1;
702   - cfsj = cfsj + oBc.fnGetEatTime();
703   - }
704   - } else if (oBc._$_bcType == "in") {
705   - jcbc = jcbc + 1;
706   - jcsj = jcsj + oBc.getBcTime();
707   - } else if (oBc._$_bcType == "out") {
708   - ccbc = ccbc + 1;
709   - ccsj = ccsj + oBc.getBcTime();
710   - } else if (oBc._$_bcType == "bd") {
711   - zwlbbc = zwlbbc + 1;
712   - zwlbsj = zwlbsj + oBc.getBcTime();
713   - } else if (oBc._$_bcType == "lc") {
714   - zwlbbc = zwlbbc + 1;
715   - zwlbsj = zwlbsj + oBc.getBcTime();
716   - }
717   - }
718   - }
719   -
720   - dgAvgTzjx = dgAvgTzjx / dgServiceBc;
721   - gfAvgTzjx = gfAvgTzjx / gfServiceBc;
722   - avgTzjx = avgTzjx / dgServiceBc;
723   -
724   - return [
725   - {'statItem': '总班次(包括进出场、吃饭时间、早晚例保、营运且班次时间大于零的班次)', 'statValue': countBc},
726   - {'statItem': '进场总班次(包括进场且班次时间大于零的班次)', 'statValue': jcbc},
727   - {'statItem': '出场总班次(包括进场且班次时间大于零的班次)', 'statValue': ccbc},
728   - {'statItem': '吃饭总班次(包括吃饭且班次时间大于零的班次)', 'statValue': cfbc},
729   - {'statItem': '早晚例保总班次(包括早晚例保且时间大于零的班次)', 'statValue': zwlbbc},
730   - {'statItem': '营运总班次(包括正常、区间、放大站且班次时间大于零班次)','statValue': serviceBc},
731   - {'statItem': '进场总时间(包括进场班次且班次时间大于零)', 'statValue': jcsj/60},
732   - {'statItem': '出场总时间(包括进场班次且班次时间大于零)', 'statValue': ccsj/60},
733   - {'statItem': '吃饭总时间(包括吃饭班次且班次时间大于零)', 'statValue': cfsj/60},
734   - {'statItem': '早晚例保总时间(包括早晚例保班次且时间大于零的)', 'statValue': zwlbsj/60},
735   - {'statItem': '营运班次总时间(包括正常、区间、放大站且班次时间大于零)', 'statValue': servicesj/60},
736   - {'statItem': '总工时(包括进出场、吃饭时间、早晚例保、营运班次时间)', 'statValue': countGs/60},
737   - {'statItem': '空驶班次(包括直放班次)', 'statValue': ksBc},
738   - {'statItem': '营运里程(包括正常、区间、放大站里程)', 'statValue': serviceLc},
739   - {'statItem': '空驶里程(包括直放里程)', 'statValue': ksLc},
740   - {'statItem': '平均停站时间(营运班次停站时间总和/营运总班次)', 'statValue': avgTzjx},
741   - {'statItem': '高峰营运班次(包括早晚高峰时段的正常、区间、放大站班次)', 'statValue': gfServiceBc},
742   - {'statItem': '低谷营运班次(包括低谷时段的正常、区间、放大站班次)', 'statValue': dgServiceBc},
743   - {'statItem': '高峰平均停站间隙(高峰营运班次停站时间总和/高峰营运班次总和)', 'statValue': gfAvgTzjx},
744   - {'statItem': '低谷平均停站间隙(低谷营运班次停站时间总和/低谷营运班次总和)', 'statValue': dgAvgTzjx},
745   - {'statItem': '综合评估', 'statValue': 3}
746   - ];
747   -
748   - };
749   -
750   - return {
751   - /**
752   - * 工厂对象，创建不同的对象。
753   - * @returns {{createParameterObj, createBcObj}}
754   - */
755   - getFactory: function() {
756   - return _factory;
757   - },
758   -
759   - /**
760   - * 使用发车间隔策略生成时刻表。
761   - * @param paramObj 参数对象
762   - * @param lpArray 路牌数组
763   - * @constructor
764   - */
765   - BXPplaceClassesTime03 : function(paramObj, lpArray) {
766   - // 参数对象
767   - _paramObj = paramObj;
768   -
769   - // 1、初始化行车计划
770   - var schedule = new InternalScheduleObj(_paramObj, lpArray, _factory);
771   - schedule.fnInitDataWithBxLayout();
772   - // 2、将连班路牌的班次补足
773   - schedule.fnCalcuLpBx_lb();
774   -
775   - // 3、修正针对初始化时生成的高峰班次，之前不足的补上，多余的删除
776   - schedule.fnAdjustGfbc(true, true); // 修正上行早高峰
777   - schedule.fnAdjustGfbc(true, false); // 修正下行早高峰
778   - schedule.fnAdjustGfbc(false, true); // 修正上行晚高峰
779   - schedule.fnAdjustGfbc(false, false); // 修正下行晚高峰
780   -
781   - // 6、补吃饭班次
782   - schedule.fnCalcuEatBc();
783   -
784   - // 4、按照车辆投入运营要求补充班次
785   - schedule.fnCalcuLpBc_yy();
786   -
787   - // 5、根据班型补充所有的不足班次
788   - schedule.fnCalcuLpBx_5_2();
789   - schedule.fnCalcuLpBx_other();
790   -
791   - // 7、祛除上标线开头有删除标记的班次
792   - schedule.fnRemoveDelFirstFlagBc();
793   -
794   - // 8、调整路牌班次间隔（使用平均停站时间）
795   - schedule.fnAdjustLpBcInterval(1);
796   -
797   - // 9、调整纵向班次间隔
798   - schedule.fnAdjustBcInterval(false);
799   -
800   - // 10、确定末班车
801   - schedule.fnCalcuLastBc();
802   -
803   - // 11、祛除上标线结尾有删除标记的班次
804   - schedule.fnRemoveDelLastFlagBc();
805   -
806   - // TODO：12、平均化指定时间后的班次列表间隔
807   - // schedule.fnAdjustBcInterval2_avg(true, _paramObj.toTimeObj("19:50"));
808   - // schedule.fnAdjustBcInterval2_avg(false, _paramObj.toTimeObj("19:50"));
809   -
810   - // 10、补进出场例保班次
811   - schedule.fnCalcuOtherBc();
812   -
813   - //-------------------- 输出ganut图上的班次，班型描述 ----------------------//
814   - // TODO：班型再议
815   - return {
816   - 'json':schedule.fnToGanttBcArray(),'bxrcgs':null,
817   - 'aInternalLpObj': schedule.fnGetLpArray()
818   - };
819   -
820   - },
821   - /**
822   - * 导出时刻表配置。
823   - * @param aInternalLpObj 内部路牌对象列表
824   - */
825   - exportDataConfig: function(aInternalLpObj) {
826   - $('.exportAddXls').on('click', function() {
827   - var aInfos = {
828   - "lpObjList": _funCalcuExportData_lpObjList(aInternalLpObj), // 路牌班次信息列表
829   - "statInfoList": _funCalcuExportData_statInfoList(aInternalLpObj) // 统计项目列表
830   - };
831   -
832   - console.log(aInfos);
833   -
834   - $(".exportAdd").addClass("disabled");
835   - $(".exportAddSpan").html("正在导出...");
836   -
837   - // 提交
838   - $.ajax({
839   - type: 'POST',
840   - url: "/tidc/exportDTDFile/xls",
841   - dataType: 'binary',
842   - contentType: "application/json",
843   - data: JSON.stringify(aInfos),
844   - success: function(data){
845   - Main_v2.downloadFile(data, "application/octet-stream", "时刻表信息.xls");
846   -
847   - $(".exportAdd").removeClass("disabled");
848   - $(".exportAddSpan").html(" 导出数据");
849   - },
850   - error: function(xhr, type){
851   - alert('错误：TODO');
852   -
853   - $(".exportAdd").removeClass("disabled");
854   - $(".exportAddSpan").html(" 导出数据");
855   - }
856   - });
857   - });
858   -
859   - $('.exportAddXlsx').on('click', function() {
860   - var aInfos = {
861   - "lpObjList": _funCalcuExportData_lpObjList(aInternalLpObj), // 路牌班次信息列表
862   - "statInfoList": _funCalcuExportData_statInfoList(aInternalLpObj) // 统计项目列表
863   - };
864   -
865   - console.log(aInfos);
866   -
867   - $(".exportAdd").addClass("disabled");
868   - $(".exportAddSpan").html("正在导出...");
869   -
870   - // 提交
871   - $.ajax({
872   - type: 'POST',
873   - url: "/tidc/exportDTDFile/xlsx",
874   - dataType: 'binary',
875   - contentType: "application/json",
876   - data: JSON.stringify(aInfos),
877   - success: function(data){
878   - Main_v2.downloadFile(data, "application/octet-stream", "时刻表信息.xlsx");
879   -
880   - $(".exportAdd").removeClass("disabled");
881   - $(".exportAddSpan").html(" 导出数据");
882   - },
883   - error: function(xhr, type){
884   - alert('错误：TODO');
885   -
886   - $(".exportAdd").removeClass("disabled");
887   - $(".exportAddSpan").html(" 导出数据");
888   - }
889   - });
890   - });
891   - },
892   -
893   - downloadFile: function (data, mimeType, fileName) {
894   - var success = false;
895   - var blob = new Blob([data], { type: mimeType });
896   - try {
897   - if (navigator.msSaveBlob)
898   - navigator.msSaveBlob(blob, fileName);
899   - else {
900   - // Try using other saveBlob implementations, if available
901   - var saveBlob = navigator.webkitSaveBlob || navigator.mozSaveBlob || navigator.saveBlob;
902   - if (saveBlob === undefined) throw "Not supported";
903   - saveBlob(blob, fileName);
904   - }
905   - success = true;
906   - } catch (ex) {
907   - console.log("saveBlob method failed with the following exception:");
908   - console.log(ex);
909   - }
910   -
911   - if (!success) {
912   - // Get the blob url creator
913   - var urlCreator = window.URL || window.webkitURL || window.mozURL || window.msURL;
914   - if (urlCreator) {
915   - // Try to use a download link
916   - var link = document.createElement('a');
917   - if ('download' in link) {
918   - // Try to simulate a click
919   - try {
920   - // Prepare a blob URL
921   - var url = urlCreator.createObjectURL(blob);
922   - link.setAttribute('href', url);
923   -
924   - // Set the download attribute (Supported in Chrome 14+ / Firefox 20+)
925   - link.setAttribute("download", fileName);
926   -
927   - // Simulate clicking the download link
928   - var event = document.createEvent('MouseEvents');
929   - event.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
930   - link.dispatchEvent(event);
931   - success = true;
932   -
933   - } catch (ex) {
934   - console.log("Download link method with simulated click failed with the following exception:");
935   - console.log(ex);
936   - }
937   - }
938   -
939   - if (!success) {
940   - // Fallback to window.location method
941   - try {
942   - // Prepare a blob URL
943   - // Use application/octet-stream when using window.location to force download
944   - var url = urlCreator.createObjectURL(blob);
945   - window.location = url;
946   - console.log("Download link method with window.location succeeded");
947   - success = true;
948   - } catch (ex) {
949   - console.log("Download link method with window.location failed with the following exception:");
950   - console.log(ex);
951   - }
952   - }
953   - }
954   - }
955   -
956   - if (!success) {
957   - // Fallback to window.open method
958   - console.log("No methods worked for saving the arraybuffer, using last resort window.open");
959   - window.open("", '_blank', '');
960   - }
961   - }
962   -
963   - };
964   -
965   -}();
  1 +/**
  2 + * 主类。
  3 + */
  4 +var Main_v2 = function() {
  5 +
  6 + // 内部工厂类
  7 + var _factoryFun = function() {
  8 + return {
  9 + // 创建参数
  10 + createParameterObj: function(formMap, dataMap) {
  11 + var paramObj = ParameterObj();
  12 + paramObj.wrap(formMap, dataMap);
  13 + return paramObj;
  14 + },
  15 + // 创建班次对象
  16 + createBcObj: function(lpObj, bcType, isUp, fcno, fcTimeObj, paramObj) {
  17 + var _bclc = paramObj.calcuTravelLcNumber(isUp, bcType);
  18 + var _fcsj = fcTimeObj;
  19 + var _bcsj = paramObj.calcuTravelTime(_fcsj, isUp);
  20 + var _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  21 + //var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, !isUp, _bcsj);
  22 + var _stoptime = paramObj.fnCalcuFixedStopNumber(_arrsj, isUp, paramObj.calcuTravelTime(_fcsj, isUp));
  23 + var _tccid = paramObj.getTTinfoId();
  24 + var _ttinfoid = paramObj.getTTinfoId();
  25 + var _xl = paramObj.getXlId();
  26 + var _qdz = isUp ? paramObj.getUpQdzObj().id : paramObj.getDownQdzObj().id;
  27 + var _zdz = isUp ? paramObj.getUpZdzObj().id : paramObj.getDownZdzObj().id;
  28 +
  29 + if (bcType == "bd") { // 早例保，传过来的发车时间是第一个班次的发车时间
  30 + if (isUp) { // 上行
  31 + _fcsj = paramObj.addMinute(
  32 + _fcsj,
  33 + -(paramObj.getUpOutTime() + paramObj.getLbTime()));
  34 + _bcsj = paramObj.getLbTime();
  35 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  36 + _stoptime = 0;
  37 + } else { // 下行
  38 + _fcsj = paramObj.addMinute(
  39 + _fcsj,
  40 + -(paramObj.getDownOutTime() + paramObj.getLbTime()));
  41 + _bcsj = paramObj.getLbTime();
  42 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  43 + _stoptime = 0;
  44 + }
  45 + } else if (bcType == "lc") { // 晚例保，传过来的发车时间是最后一个班次的到达时间
  46 + if (isUp) { // 上行
  47 + _fcsj = paramObj.addMinute(
  48 + _fcsj,
  49 + paramObj.getUpInTime());
  50 + _bcsj = paramObj.getLbTime();
  51 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  52 + _stoptime = 0;
  53 + } else { // 下行
  54 + _fcsj = paramObj.addMinute(
  55 + _fcsj,
  56 + paramObj.getDownInTime());
  57 + _bcsj = paramObj.getLbTime();
  58 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  59 + _stoptime = 0;
  60 + }
  61 + } else if (bcType == "out") { // 出场，传过来的发车时间是第一个班次的发车时间
  62 + if (isUp) { // 上行
  63 + _fcsj = paramObj.addMinute(
  64 + _fcsj,
  65 + -paramObj.getUpOutTime());
  66 + _bcsj = paramObj.getUpOutTime();
  67 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  68 + _stoptime = 0;
  69 + } else { // 下行
  70 + _fcsj = paramObj.addMinute(
  71 + _fcsj,
  72 + -paramObj.getDownOutTime());
  73 + _bcsj = paramObj.getDownOutTime();
  74 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  75 + _stoptime = 0;
  76 + }
  77 + } else if (bcType == "in") { // 进场，传过来的发车时间是最后一个班次的到达时间
  78 + if (isUp) { // 上行
  79 + _bcsj = paramObj.getUpInTime();
  80 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  81 + _stoptime = 0;
  82 + } else { // 下行
  83 + _bcsj = paramObj.getDownInTime();
  84 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  85 + _stoptime = 0;
  86 + }
  87 + } else if (bcType == "cf") { // 吃饭班次
  88 + // 以13:00为分界，之前的为午饭，之后的为晚饭
  89 + if (fcTimeObj.isBefore(paramObj.toTimeObj("13:00"))) {
  90 + _bcsj = paramObj.fnGetLunchTime();
  91 + } else {
  92 + _bcsj = paramObj.fnGetDinnerTime();
  93 + }
  94 + _arrsj = paramObj.addMinute(_fcsj, _bcsj);
  95 + _stoptime = 0;
  96 + }
  97 +
  98 + var bcParamObj = {};
  99 + bcParamObj.bcType = bcType; // 班次类型（normal，in_，out, bd, lc, cf等）
  100 + bcParamObj.isUp = isUp; // boolean是否上下行
  101 + bcParamObj.fcno = fcno; // 发车顺序号
  102 + bcParamObj.fcTimeObj = _fcsj; // 发车时间对象
  103 + bcParamObj.bclc = _bclc; // 班次里程
  104 + bcParamObj.bcsj = _bcsj; // 班次历时
  105 + bcParamObj.arrtime = _arrsj; // 到达时间对象
  106 + bcParamObj.stoptime = _stoptime; // 停站时间
  107 + bcParamObj.tccid = _tccid; // 停车场id
  108 + bcParamObj.ttinfoid = _ttinfoid; // 时刻表id
  109 + bcParamObj.xl = _xl; // 线路id
  110 + bcParamObj.qdzid = _qdz; // 起点站id
  111 + bcParamObj.zdzid = _zdz; // 终点站id
  112 +
  113 + return new InternalBcObj(lpObj, bcParamObj);
  114 + }
  115 + };
  116 + };
  117 + var _factory = _factoryFun();
  118 +
  119 + // 所有的时间使用moment.js计算
  120 +
  121 + var _paramObj; // 参数对象
  122 +
  123 + var _bxDesc = [ // 班型描述
  124 + {'type':'六工一休','hoursV':6.66, 'minueV':'6:40', 'qcount': 0, 'avertime': 0},
  125 + {'type':'五工一休','hoursV':6.85, 'minueV':'6:51', 'qcount': 0, 'avertime': 0},
  126 + {'type':'四工一休','hoursV':7.14, 'minueV':'7:08', 'qcount': 0, 'avertime': 0},
  127 + {'type':'三工一休','hoursV':7.61, 'minueV':'7:37', 'qcount': 0, 'avertime': 0},
  128 + {'type':'二工一休','hoursV':8.57, 'minueV':'8:34', 'qcount': 0, 'avertime': 0},
  129 + {'type':'一工一休','hoursV':11.42, 'minueV':'11:25', 'qcount': 0, 'avertime': 0},
  130 + {'type':'五工二休','hoursV':7.99, 'minueV':'8:00', 'qcount': 0, 'avertime': 0},
  131 + {'type':'无工休', 'hoursV':5.43, 'minueV':'5:43', 'qcount': 0, 'avertime': 0}
  132 + ];
  133 +
  134 + var _funCalcuExportData_lpObjList = function(aInternalLpObj) {
  135 + // 构造路牌对象
  136 + var aLpObj = [];
  137 + var i;
  138 + var j;
  139 + var z;
  140 + var oInternalLp;
  141 + var oInternalBc;
  142 + var oInternalBc_temp;
  143 + var oLp;
  144 + var iZlc;
  145 + var iYylc;
  146 + var iKslc;
  147 + var iZbc;
  148 + var iZgs;
  149 + var iYygs;
  150 + var iYybc;
  151 + for (i = 0; i < aInternalLpObj.length; i++) {
  152 + oInternalLp = aInternalLpObj[i];
  153 + iZlc = 0;
  154 + iYylc = 0;
  155 + iKslc = 0;
  156 + iZgs = 0;
  157 + iZbc = 0;
  158 + iYygs = 0;
  159 + iYybc = 0;
  160 + oLp = {
  161 + "lpname": oInternalLp.getLpName(), // 路牌名字
  162 + "isUp": oInternalLp.isUp(), // 每圈的第一个班次是否上行
  163 + "bcObjList": [], // 班次列表
  164 + "groupCount": oInternalLp.fnGetGroupCount(), // 总圈数
  165 + "zlc": 0, // 总里程
  166 + "yylc": 0, // 营运里程
  167 + "kslc": 0, // 空驶里程
  168 + "zgs": 0, // 总工时
  169 + "zbc": 0, // 总班次
  170 + "yygs": 0, // 营运工时
  171 + "yybc": 0, // 营运班次
  172 + "stationRouteId1": 0, // 第一个班次起点站路由id
  173 + "stationRouteId2": 0 // 第二个班次起点站路由id
  174 + };
  175 +
  176 + // 将报到班次，进出场班次加到班次的时间上
  177 + var iBcChainCount;
  178 + var oStartBc;
  179 + var oEndBc;
  180 + var oTempBc;
  181 + var aFcsj = [];
  182 +
  183 + iBcChainCount = oInternalLp.fnGetBcChainCount();
  184 + if (iBcChainCount == 1) { // 单一车次链，连班班型
  185 + oStartBc = oInternalLp.getBc(
  186 + oInternalLp.fnGetBcChainInfo(0)["s_q"],
  187 + oInternalLp.fnGetBcChainInfo(0)["s_b"]
  188 + );
  189 + oTempBc = _factory.createBcObj(
  190 + oLp, "bd", oStartBc.isUp(), 1,
  191 + oStartBc.getFcTimeObj(),
  192 + _paramObj
  193 + );
  194 + aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  195 + oLp.bcObjList.push({ // 报到班次
  196 + "bcsj": oTempBc.getBcTime(), // 班次时间
  197 + "ssj": oTempBc.getStopTime(), // 停站时间
  198 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  199 +
  200 + "tccid": oTempBc._$_tccid, // 停车场id
  201 + "qdzid": oTempBc._$_qdzid, // 起点站id
  202 + "zdzid": oTempBc._$_zdzid, // 终点站id
  203 +
  204 + "isUp": oTempBc._$_isUp, // 是否上行
  205 + "isFb": false, // 是否分班
  206 +
  207 + "bcType": oTempBc._$_bcType, // 班次类型
  208 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  209 +
  210 + "groupNo": -1, // 第几圈
  211 + "groupBcNo": -1 // 圈里第几个班次
  212 +
  213 + });
  214 +
  215 + oTempBc = _factory.createBcObj(
  216 + oLp, "out", oStartBc.isUp(), 1,
  217 + oStartBc.getFcTimeObj(),
  218 + _paramObj
  219 + );
  220 + aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  221 + aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
  222 + oStartBc._$_fcsj_desc = aFcsj.join("");
  223 +
  224 + oLp.bcObjList.push({ // 出场班次
  225 + "bcsj": oTempBc.getBcTime(), // 班次时间
  226 + "ssj": oTempBc.getStopTime(), // 停站时间
  227 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  228 +
  229 + "tccid": oTempBc._$_tccid, // 停车场id
  230 + "qdzid": oTempBc._$_qdzid, // 起点站id
  231 + "zdzid": oTempBc._$_zdzid, // 终点站id
  232 +
  233 + "isUp": oTempBc._$_isUp, // 是否上行
  234 + "isFb": false, // 是否分班
  235 +
  236 + "bcType": oTempBc._$_bcType, // 班次类型
  237 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  238 +
  239 + "groupNo": -1, // 第几圈
  240 + "groupBcNo": -2 // 圈里第几个班次
  241 +
  242 + });
  243 +
  244 + aFcsj = [];
  245 +
  246 + oEndBc = oInternalLp.getBc(
  247 + oInternalLp.fnGetBcChainInfo(0)["e_q"],
  248 + oInternalLp.fnGetBcChainInfo(0)["e_b"]
  249 + );
  250 + aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
  251 + oTempBc = _factory.createBcObj(
  252 + oLp, "in", !oEndBc.isUp(), 1,
  253 + oEndBc.getArrTimeObj(),
  254 + _paramObj
  255 + );
  256 + aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  257 +
  258 + oLp.bcObjList.push({ // 进场班次
  259 + "bcsj": oTempBc.getBcTime(), // 班次时间
  260 + "ssj": oTempBc.getStopTime(), // 停站时间
  261 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  262 +
  263 + "tccid": oTempBc._$_tccid, // 停车场id
  264 + "qdzid": oTempBc._$_qdzid, // 起点站id
  265 + "zdzid": oTempBc._$_zdzid, // 终点站id
  266 +
  267 + "isUp": oTempBc._$_isUp, // 是否上行
  268 + "isFb": false, // 是否分班
  269 +
  270 + "bcType": oTempBc._$_bcType, // 班次类型
  271 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  272 +
  273 + "groupNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ?
  274 + oInternalLp.fnGetBcChainInfo(0)["e_q"] :
  275 + oInternalLp.fnGetBcChainInfo(0)["e_q"] + 1, // 第几圈
  276 + "groupBcNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
  277 +
  278 + });
  279 +
  280 + oTempBc = _factory.createBcObj(
  281 + oLp, "lc", !oEndBc.isUp(), 1,
  282 + oEndBc.getArrTimeObj(),
  283 + _paramObj
  284 + );
  285 + aFcsj.push("(离" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  286 + oLp.bcObjList.push({ // 离场班次
  287 + "bcsj": oTempBc.getBcTime(), // 班次时间
  288 + "ssj": oTempBc.getStopTime(), // 停站时间
  289 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  290 +
  291 + "tccid": oTempBc._$_tccid, // 停车场id
  292 + "qdzid": oTempBc._$_qdzid, // 起点站id
  293 + "zdzid": oTempBc._$_zdzid, // 终点站id
  294 +
  295 + "isUp": oTempBc._$_isUp, // 是否上行
  296 + "isFb": false, // 是否分班
  297 +
  298 + "bcType": oTempBc._$_bcType, // 班次类型
  299 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  300 +
  301 + "groupNo": -2, // 第几圈
  302 + "groupBcNo": -4 // 圈里第几个班次
  303 +
  304 + });
  305 +
  306 + oEndBc._$_fcsj_desc = aFcsj.join("");
  307 +
  308 + } else if (iBcChainCount == 2) { // 两个车次链，分班班型
  309 + oStartBc = oInternalLp.getBc(
  310 + oInternalLp.fnGetBcChainInfo(0)["s_q"],
  311 + oInternalLp.fnGetBcChainInfo(0)["s_b"]
  312 + );
  313 + oTempBc = _factory.createBcObj(
  314 + oLp, "bd", oStartBc.isUp(), 1,
  315 + oStartBc.getFcTimeObj(),
  316 + _paramObj
  317 + );
  318 + aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  319 + oLp.bcObjList.push({ // 报到班次
  320 + "bcsj": oTempBc.getBcTime(), // 班次时间
  321 + "ssj": oTempBc.getStopTime(), // 停站时间
  322 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  323 +
  324 + "tccid": oTempBc._$_tccid, // 停车场id
  325 + "qdzid": oTempBc._$_qdzid, // 起点站id
  326 + "zdzid": oTempBc._$_zdzid, // 终点站id
  327 +
  328 + "isUp": oTempBc._$_isUp, // 是否上行
  329 + "isFb": false, // 是否分班
  330 +
  331 + "bcType": oTempBc._$_bcType, // 班次类型
  332 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  333 +
  334 + "groupNo": -1, // 第几圈
  335 + "groupBcNo": -1 // 圈里第几个班次
  336 +
  337 + });
  338 +
  339 + oTempBc = _factory.createBcObj(
  340 + oLp, "out", oStartBc.isUp(), 1,
  341 + oStartBc.getFcTimeObj(),
  342 + _paramObj
  343 + );
  344 + aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  345 + aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
  346 + oStartBc._$_fcsj_desc = aFcsj.join("");
  347 +
  348 + oLp.bcObjList.push({ // 出场班次
  349 + "bcsj": oTempBc.getBcTime(), // 班次时间
  350 + "ssj": oTempBc.getStopTime(), // 停站时间
  351 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  352 +
  353 + "tccid": oTempBc._$_tccid, // 停车场id
  354 + "qdzid": oTempBc._$_qdzid, // 起点站id
  355 + "zdzid": oTempBc._$_zdzid, // 终点站id
  356 +
  357 + "isUp": oTempBc._$_isUp, // 是否上行
  358 + "isFb": false, // 是否分班
  359 +
  360 + "bcType": oTempBc._$_bcType, // 班次类型
  361 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  362 +
  363 + "groupNo": -1, // 第几圈
  364 + "groupBcNo": -2 // 圈里第几个班次
  365 +
  366 + });
  367 +
  368 + aFcsj = [];
  369 +
  370 + oEndBc = oInternalLp.getBc(
  371 + oInternalLp.fnGetBcChainInfo(0)["e_q"],
  372 + oInternalLp.fnGetBcChainInfo(0)["e_b"]
  373 + );
  374 + aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
  375 + oTempBc = _factory.createBcObj(
  376 + oLp, "in", !oEndBc.isUp(), 1,
  377 + oEndBc.getArrTimeObj(),
  378 + _paramObj
  379 + );
  380 + aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  381 + oLp.bcObjList.push({ // 进场班次
  382 + "bcsj": oTempBc.getBcTime(), // 班次时间
  383 + "ssj": oTempBc.getStopTime(), // 停站时间
  384 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  385 +
  386 + "tccid": oTempBc._$_tccid, // 停车场id
  387 + "qdzid": oTempBc._$_qdzid, // 起点站id
  388 + "zdzid": oTempBc._$_zdzid, // 终点站id
  389 +
  390 + "isUp": oTempBc._$_isUp, // 是否上行
  391 + "isFb": true, // 是否分班
  392 +
  393 + "bcType": oTempBc._$_bcType, // 班次类型
  394 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  395 +
  396 + "groupNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ?
  397 + oInternalLp.fnGetBcChainInfo(0)["e_q"] :
  398 + oInternalLp.fnGetBcChainInfo(0)["e_q"] + 1, // 第几圈
  399 + "groupBcNo": oInternalLp.fnGetBcChainInfo(0)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
  400 +
  401 + });
  402 + oEndBc._$_fcsj_desc = aFcsj.join("");
  403 +
  404 + aFcsj = [];
  405 +
  406 + oStartBc = oInternalLp.getBc(
  407 + oInternalLp.fnGetBcChainInfo(1)["s_q"],
  408 + oInternalLp.fnGetBcChainInfo(1)["s_b"]
  409 + );
  410 + oTempBc = _factory.createBcObj(
  411 + oLp, "bd", oStartBc.isUp(), 1,
  412 + oStartBc.getFcTimeObj(),
  413 + _paramObj
  414 + );
  415 + aFcsj.push("(到" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  416 + oLp.bcObjList.push({ // 报到班次
  417 + "bcsj": oTempBc.getBcTime(), // 班次时间
  418 + "ssj": oTempBc.getStopTime(), // 停站时间
  419 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  420 +
  421 + "tccid": oTempBc._$_tccid, // 停车场id
  422 + "qdzid": oTempBc._$_qdzid, // 起点站id
  423 + "zdzid": oTempBc._$_zdzid, // 终点站id
  424 +
  425 + "isUp": oTempBc._$_isUp, // 是否上行
  426 + "isFb": true, // 是否分班
  427 +
  428 + "bcType": oTempBc._$_bcType, // 班次类型
  429 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  430 +
  431 + "groupNo": oInternalLp.fnGetBcChainInfo(1)["s_q"] - 1, // 第几圈
  432 + "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] // 圈里第几个班次
  433 +
  434 + });
  435 +
  436 + oTempBc = _factory.createBcObj(
  437 + oLp, "out", oStartBc.isUp(), 1,
  438 + oStartBc.getFcTimeObj(),
  439 + _paramObj
  440 + );
  441 + oLp.bcObjList.push({ // 出场班次
  442 + "bcsj": oTempBc.getBcTime(), // 班次时间
  443 + "ssj": oTempBc.getStopTime(), // 停站时间
  444 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  445 +
  446 + "tccid": oTempBc._$_tccid, // 停车场id
  447 + "qdzid": oTempBc._$_qdzid, // 起点站id
  448 + "zdzid": oTempBc._$_zdzid, // 终点站id
  449 +
  450 + "isUp": oTempBc._$_isUp, // 是否上行
  451 + "isFb": true, // 是否分班
  452 +
  453 + "bcType": oTempBc._$_bcType, // 班次类型
  454 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  455 +
  456 + "groupNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] == 0 ?
  457 + oInternalLp.fnGetBcChainInfo(1)["s_q"] - 1 :
  458 + oInternalLp.fnGetBcChainInfo(1)["s_q"], // 第几圈
  459 + "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["s_b"] == 0 ? 1 : 0 // 圈里第几个班次
  460 +
  461 + });
  462 + aFcsj.push("(出" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  463 + aFcsj.push("(" + oStartBc.getFcTimeObj().format("HH:mm") + ")");
  464 + oStartBc._$_fcsj_desc = aFcsj.join("");
  465 +
  466 + aFcsj = [];
  467 +
  468 + oEndBc = oInternalLp.getBc(
  469 + oInternalLp.fnGetBcChainInfo(1)["e_q"],
  470 + oInternalLp.fnGetBcChainInfo(1)["e_b"]
  471 + );
  472 + aFcsj.push("(" + oEndBc.getFcTimeObj().format("HH:mm") + ")");
  473 + oTempBc = _factory.createBcObj(
  474 + oLp, "in", !oEndBc.isUp(), 1,
  475 + oEndBc.getArrTimeObj(),
  476 + _paramObj
  477 + );
  478 + aFcsj.push("(进" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  479 +
  480 + oLp.bcObjList.push({ // 进场班次
  481 + "bcsj": oTempBc.getBcTime(), // 班次时间
  482 + "ssj": oTempBc.getStopTime(), // 停站时间
  483 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  484 +
  485 + "tccid": oTempBc._$_tccid, // 停车场id
  486 + "qdzid": oTempBc._$_qdzid, // 起点站id
  487 + "zdzid": oTempBc._$_zdzid, // 终点站id
  488 +
  489 + "isUp": oTempBc._$_isUp, // 是否上行
  490 + "isFb": false, // 是否分班
  491 +
  492 + "bcType": oTempBc._$_bcType, // 班次类型
  493 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  494 +
  495 + "groupNo": oInternalLp.fnGetBcChainInfo(1)["e_b"] == 0 ?
  496 + oInternalLp.fnGetBcChainInfo(1)["e_q"] :
  497 + oInternalLp.fnGetBcChainInfo(1)["e_q"] + 1, // 第几圈
  498 + "groupBcNo": oInternalLp.fnGetBcChainInfo(1)["e_b"] == 0 ? 1 : 0 // 圈里第几个班次
  499 +
  500 + });
  501 +
  502 + oTempBc = _factory.createBcObj(
  503 + oLp, "lc", !oEndBc.isUp(), 1,
  504 + oEndBc.getArrTimeObj(),
  505 + _paramObj
  506 + );
  507 +
  508 + oLp.bcObjList.push({ // 离场班次
  509 + "bcsj": oTempBc.getBcTime(), // 班次时间
  510 + "ssj": oTempBc.getStopTime(), // 停站时间
  511 + "eatsj": oTempBc.fnGetEatTime(), // 吃饭时间
  512 +
  513 + "tccid": oTempBc._$_tccid, // 停车场id
  514 + "qdzid": oTempBc._$_qdzid, // 起点站id
  515 + "zdzid": oTempBc._$_zdzid, // 终点站id
  516 +
  517 + "isUp": oTempBc._$_isUp, // 是否上行
  518 + "isFb": false, // 是否分班
  519 +
  520 + "bcType": oTempBc._$_bcType, // 班次类型
  521 + "fcsj": oTempBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  522 +
  523 + "groupNo": -2, // 第几圈
  524 + "groupBcNo": -4 // 圈里第几个班次
  525 +
  526 + });
  527 +
  528 + aFcsj.push("(离" + oTempBc.getFcTimeObj().format("HH:mm") + ")");
  529 + oEndBc._$_fcsj_desc = aFcsj.join("");
  530 +
  531 + }
  532 +
  533 + for (j = 0; j < oInternalLp.fnGetGroupCount(); j++) {
  534 + for (z = 0; z < 2; z++) {
  535 + oInternalBc = oInternalLp.getBc(j, z);
  536 + if (oInternalBc) {
  537 + if (oInternalBc.fnGetEatTime() > 0) {
  538 + // 吃饭班次是下一个班次开始吃，和本班次方向相反
  539 + oInternalBc_temp = oInternalLp.getBc(
  540 + z == 1 ? j + 1 : j,
  541 + z == 1 ? 0 : 1);
  542 +
  543 + oInternalBc_temp._$_isRealEat = true;
  544 + oInternalBc_temp._$_fcsj_desc = "(吃" + oInternalBc_temp.getFcTimeObj().format("HH:mm") + ")";
  545 + }
  546 +
  547 + oLp.bcObjList.push({
  548 + "bcsj": oInternalBc.getBcTime(), // 班次时间
  549 + "ssj": oInternalBc.getStopTime(), // 停站时间
  550 + "eatsj": oInternalBc.fnGetEatTime(), // 吃饭时间
  551 +
  552 + "tccid": oInternalBc._$_tccid, // 停车场id
  553 + "qdzid": oInternalBc._$_qdzid, // 起点站id
  554 + "zdzid": oInternalBc._$_zdzid, // 终点站id
  555 +
  556 + "isUp": oInternalBc._$_isUp, // 是否上行
  557 +
  558 + "bcType": oInternalBc._$_bcType, // 班次类型
  559 + "fcsj": oInternalBc._$_isRealEat ?
  560 + ("*" + oInternalBc._$_fcsjObj.format("HH:mm")) :
  561 + oInternalBc._$_fcsjObj.format("HH:mm"), // 发车时间描述
  562 + "fcsjDesc" : oInternalBc._$_fcsj_desc || oInternalBc._$_fcsjObj.format("HH:mm"),
  563 +
  564 + "groupNo": j, // 第几圈
  565 + "groupBcNo": z // 圈里第几个班次
  566 +
  567 + });
  568 +
  569 + // iZlc = 0;
  570 + // iYylc = 0;
  571 + // iKslc = 0;
  572 + // iZgs = 0;
  573 + // iZbc = 0;
  574 + // iYygs = 0;
  575 + // iYybc = 0;
  576 +
  577 + iZlc = iZlc +
  578 + oInternalBc._$_bclc; // 里程
  579 + iYylc = iYylc +
  580 + oInternalBc._$_bclc; // 里程
  581 + iYygs = iYygs +
  582 + oInternalBc.getBcTime() + // 班次时间
  583 + oInternalBc.getStopTime() + // 停站时间
  584 + oInternalBc.fnGetEatTime(); // 吃饭时间
  585 + iYybc = iYybc + 1;
  586 +
  587 + iZgs = iZgs +
  588 + oInternalBc.getBcTime() + // 班次时间
  589 + oInternalBc.getStopTime() + // 停站时间
  590 + oInternalBc.fnGetEatTime(); // 吃饭时间
  591 + iZbc = iZbc + 1;
  592 +
  593 + // 设置圈站点路由id
  594 + if (oInternalBc.isUp() == oInternalLp.isUp()) { // 第一个班次
  595 + if (oLp.stationRouteId1 == 0) {
  596 + oLp.stationRouteId1 = oInternalBc._$_qdzid;
  597 + }
  598 + } else { // 第二个班次
  599 + if (oLp.stationRouteId2 == 0) {
  600 + oLp.stationRouteId2 = oInternalBc._$_qdzid;
  601 + }
  602 + }
  603 +
  604 + }
  605 + }
  606 +
  607 + }
  608 +
  609 + for (z = 0; z < oInternalLp.getOtherBcArray().length; z++) {
  610 + oInternalBc = oInternalLp.getOtherBcArray()[z];
  611 + iKslc = iKslc +
  612 + oInternalBc._$_bclc; // 里程
  613 + iZlc = iZlc +
  614 + oInternalBc._$_bclc; // 里程
  615 + iZgs = iZgs +
  616 + oInternalBc.getBcTime() + // 班次时间
  617 + oInternalBc.getStopTime(); // 停站时间
  618 + if (oInternalBc._$_bcType != "bd" &&
  619 + oInternalBc._$_bcType != "lc" &&
  620 + oInternalBc._$_bcType != "cf") {
  621 + iZbc = iZbc + 1;
  622 + }
  623 + }
  624 +
  625 + oLp.zlc = iZlc;
  626 + oLp.yylc = iYylc;
  627 + oLp.kslc = iKslc;
  628 + oLp.zgs = iZgs;
  629 + oLp.zbc = iZbc;
  630 + oLp.yygs = iYygs;
  631 + oLp.yybc = iYybc;
  632 + aLpObj.push(oLp);
  633 + }
  634 +
  635 + return aLpObj;
  636 + };
  637 +
  638 + var _funCalcuExportData_statInfoList = function(aInternalLpObj) {
  639 + var countBc = 0, // 总班次
  640 + serviceBc = 0, // 营运班次
  641 + jcbc = 0, // 进场总班次.
  642 + ccbc = 0, // 出场总班次.
  643 + cfbc = 0, // 吃饭总班次.
  644 + zwlbbc = 0, // 早晚例保总班次.
  645 + countGs = 0.0, // 总工时
  646 + servicesj = 0, // 营运班次总时间
  647 + jcsj = 0.0, // 进场总时间.
  648 + ccsj = 0.0, // 出场总时间.
  649 + cfsj = 0.0, // 吃饭总时间.
  650 + zwlbsj = 0.0, // 早晚例保总时间.
  651 + ksBc = 0, // 空驶班次
  652 + serviceLc = 0.0, // 营运里程
  653 + ksLc = 0.0, // 空驶里程
  654 + avgTzjx = 0.0, // 平均停站间隙
  655 + gfServiceBc = 0, // 高峰营运班次
  656 + dgServiceBc = 0, // 低谷营运班次
  657 + gfAvgTzjx = 0.0, // 高峰平均停站间隙
  658 + dgAvgTzjx = 0.0; // 低谷平均停站间隙
  659 +
  660 + var aAllBc = [];
  661 + var oLp;
  662 + var oBc;
  663 + var i;
  664 + var j;
  665 +
  666 + for (i = 0; i < aInternalLpObj.length; i++) {
  667 + oLp = aInternalLpObj[i];
  668 + for (j = 0; j < oLp.getBcArray().length; j++) {
  669 + aAllBc.push(oLp.getBcArray()[j]);
  670 + }
  671 + for (j = 0; j < oLp.getOtherBcArray().length; j++) {
  672 + aAllBc.push(oLp.getOtherBcArray()[j]);
  673 + }
  674 + }
  675 +
  676 + for (i = 0; i < aAllBc.length; i++) {
  677 + oBc = aAllBc[i];
  678 +
  679 + if (oBc.getBcTime() > 0) {
  680 + countBc = countBc + 1;
  681 + countGs = countGs + oBc.getStopTime() + oBc.getBcTime();
  682 + if (_paramObj.isTroughBc(oBc.getFcTimeObj())) {
  683 + if (oBc._$_bcType == "normal") {
  684 + dgServiceBc = dgServiceBc + 1;
  685 + dgAvgTzjx = dgAvgTzjx + oBc.getStopTime();
  686 + }
  687 + } else {
  688 + if (oBc._$_bcType == "normal") {
  689 + gfServiceBc = gfServiceBc + 1;
  690 + gfAvgTzjx = gfAvgTzjx + oBc.getStopTime();
  691 + }
  692 + }
  693 +
  694 + if (oBc._$_bcType == "normal") {
  695 + serviceBc = serviceBc + 1;
  696 + serviceLc = serviceLc + oBc._$_bclc;
  697 + servicesj = servicesj + oBc.getBcTime();
  698 + avgTzjx = avgTzjx + oBc.getStopTime();
  699 +
  700 + if (oBc.fnGetEatTime() > 0) {
  701 + cfbc = cfbc + 1;
  702 + cfsj = cfsj + oBc.fnGetEatTime();
  703 + }
  704 + } else if (oBc._$_bcType == "in") {
  705 + jcbc = jcbc + 1;
  706 + jcsj = jcsj + oBc.getBcTime();
  707 + } else if (oBc._$_bcType == "out") {
  708 + ccbc = ccbc + 1;
  709 + ccsj = ccsj + oBc.getBcTime();
  710 + } else if (oBc._$_bcType == "bd") {
  711 + zwlbbc = zwlbbc + 1;
  712 + zwlbsj = zwlbsj + oBc.getBcTime();
  713 + } else if (oBc._$_bcType == "lc") {
  714 + zwlbbc = zwlbbc + 1;
  715 + zwlbsj = zwlbsj + oBc.getBcTime();
  716 + }
  717 + }
  718 + }
  719 +
  720 + dgAvgTzjx = dgAvgTzjx / dgServiceBc;
  721 + gfAvgTzjx = gfAvgTzjx / gfServiceBc;
  722 + avgTzjx = avgTzjx / dgServiceBc;
  723 +
  724 + return [
  725 + {'statItem': '总班次(包括进出场、吃饭时间、早晚例保、营运且班次时间大于零的班次)', 'statValue': countBc},
  726 + {'statItem': '进场总班次(包括进场且班次时间大于零的班次)', 'statValue': jcbc},
  727 + {'statItem': '出场总班次(包括进场且班次时间大于零的班次)', 'statValue': ccbc},
  728 + {'statItem': '吃饭总班次(包括吃饭且班次时间大于零的班次)', 'statValue': cfbc},
  729 + {'statItem': '早晚例保总班次(包括早晚例保且时间大于零的班次)', 'statValue': zwlbbc},
  730 + {'statItem': '营运总班次(包括正常、区间、放大站且班次时间大于零班次)','statValue': serviceBc},
  731 + {'statItem': '进场总时间(包括进场班次且班次时间大于零)', 'statValue': jcsj/60},
  732 + {'statItem': '出场总时间(包括进场班次且班次时间大于零)', 'statValue': ccsj/60},
  733 + {'statItem': '吃饭总时间(包括吃饭班次且班次时间大于零)', 'statValue': cfsj/60},
  734 + {'statItem': '早晚例保总时间(包括早晚例保班次且时间大于零的)', 'statValue': zwlbsj/60},
  735 + {'statItem': '营运班次总时间(包括正常、区间、放大站且班次时间大于零)', 'statValue': servicesj/60},
  736 + {'statItem': '总工时(包括进出场、吃饭时间、早晚例保、营运班次时间)', 'statValue': countGs/60},
  737 + {'statItem': '空驶班次(包括直放班次)', 'statValue': ksBc},
  738 + {'statItem': '营运里程(包括正常、区间、放大站里程)', 'statValue': serviceLc},
  739 + {'statItem': '空驶里程(包括直放里程)', 'statValue': ksLc},
  740 + {'statItem': '平均停站时间(营运班次停站时间总和/营运总班次)', 'statValue': avgTzjx},
  741 + {'statItem': '高峰营运班次(包括早晚高峰时段的正常、区间、放大站班次)', 'statValue': gfServiceBc},
  742 + {'statItem': '低谷营运班次(包括低谷时段的正常、区间、放大站班次)', 'statValue': dgServiceBc},
  743 + {'statItem': '高峰平均停站间隙(高峰营运班次停站时间总和/高峰营运班次总和)', 'statValue': gfAvgTzjx},
  744 + {'statItem': '低谷平均停站间隙(低谷营运班次停站时间总和/低谷营运班次总和)', 'statValue': dgAvgTzjx},
  745 + {'statItem': '综合评估', 'statValue': 3}
  746 + ];
  747 +
  748 + };
  749 +
  750 + return {
  751 + /**
  752 + * 工厂对象，创建不同的对象。
  753 + * @returns {{createParameterObj, createBcObj}}
  754 + */
  755 + getFactory: function() {
  756 + return _factory;
  757 + },
  758 +
  759 + /**
  760 + * 使用发车间隔策略生成时刻表。
  761 + * @param paramObj 参数对象
  762 + * @param lpArray 路牌数组
  763 + * @constructor
  764 + */
  765 + BXPplaceClassesTime03 : function(paramObj, lpArray) {
  766 + // 参数对象
  767 + _paramObj = paramObj;
  768 +
  769 + // 1、初始化行车计划
  770 + var schedule = new InternalScheduleObj(_paramObj, lpArray, _factory);
  771 + schedule.fnInitDataWithBxLayout();
  772 + // 2、将连班路牌的班次补足
  773 + schedule.fnCalcuLpBx_lb();
  774 +
  775 + // 3、修正针对初始化时生成的高峰班次，之前不足的补上，多余的删除
  776 + schedule.fnAdjustGfbc(true, true); // 修正上行早高峰
  777 + schedule.fnAdjustGfbc(true, false); // 修正下行早高峰
  778 + schedule.fnAdjustGfbc(false, true); // 修正上行晚高峰
  779 + schedule.fnAdjustGfbc(false, false); // 修正下行晚高峰
  780 +
  781 + // 6、补吃饭班次
  782 + schedule.fnCalcuEatBc();
  783 +
  784 + // 4、按照车辆投入运营要求补充班次
  785 + schedule.fnCalcuLpBc_yy();
  786 +
  787 + // 5、根据班型补充所有的不足班次
  788 + schedule.fnCalcuLpBx_5_2();
  789 + schedule.fnCalcuLpBx_other();
  790 +
  791 + // 7、祛除上标线开头有删除标记的班次
  792 + schedule.fnRemoveDelFirstFlagBc();
  793 +
  794 + // 8、调整路牌班次间隔（使用平均停站时间）
  795 + schedule.fnAdjustLpBcInterval(1);
  796 +
  797 + // 9、调整班次发车间隔
  798 + schedule.fnAdjustBcInterval(false);
  799 +
  800 + // 10、确定末班车
  801 + schedule.fnCalcuLastBc();
  802 +
  803 + // 11、祛除上标线结尾有删除标记的班次
  804 + schedule.fnRemoveDelLastFlagBc();
  805 +
  806 + // TODO：12、平均化指定时间后的班次列表间隔
  807 + // // schedule.fnAdjustBcInterval2_avg(true, _paramObj.toTimeObj("19:50"));
  808 + // // schedule.fnAdjustBcInterval2_avg(false, _paramObj.toTimeObj("19:50"));
  809 + //
  810 + // 10、补进出场例保班次
  811 + schedule.fnCalcuOtherBc();
  812 +
  813 + //-------------------- 输出ganut图上的班次，班型描述 ----------------------//
  814 + // TODO：班型再议
  815 + return {
  816 + 'json':schedule.fnToGanttBcArray(),'bxrcgs':null,
  817 + 'aInternalLpObj': schedule.fnGetLpArray()
  818 + };
  819 +
  820 + },
  821 + /**
  822 + * 导出时刻表配置。
  823 + * @param aInternalLpObj 内部路牌对象列表
  824 + */
  825 + exportDataConfig: function(aInternalLpObj) {
  826 + $('.exportAddXls').off('click');
  827 + $('.exportAddXlsx').off('click');
  828 +
  829 + $('.exportAddXls').on('click', function() {
  830 + var aInfos = {
  831 + "lpObjList": _funCalcuExportData_lpObjList(aInternalLpObj), // 路牌班次信息列表
  832 + "statInfoList": _funCalcuExportData_statInfoList(aInternalLpObj) // 统计项目列表
  833 + };
  834 +
  835 + console.log(aInfos);
  836 +
  837 + $(".exportAdd").addClass("disabled");
  838 + $(".exportAddSpan").html("正在导出...");
  839 +
  840 + // 提交
  841 + $.ajax({
  842 + type: 'POST',
  843 + url: "/tidc/exportDTDFile/xls",
  844 + dataType: 'binary',
  845 + contentType: "application/json",
  846 + data: JSON.stringify(aInfos),
  847 + success: function(data){
  848 + Main_v2.downloadFile(data, "application/octet-stream", "时刻表信息.xls");
  849 +
  850 + $(".exportAdd").removeClass("disabled");
  851 + $(".exportAddSpan").html(" 导出数据");
  852 + },
  853 + error: function(xhr, type){
  854 + alert('错误：TODO');
  855 +
  856 + $(".exportAdd").removeClass("disabled");
  857 + $(".exportAddSpan").html(" 导出数据");
  858 + }
  859 + });
  860 + });
  861 +
  862 + $('.exportAddXlsx').on('click', function() {
  863 + var aInfos = {
  864 + "lpObjList": _funCalcuExportData_lpObjList(aInternalLpObj), // 路牌班次信息列表
  865 + "statInfoList": _funCalcuExportData_statInfoList(aInternalLpObj) // 统计项目列表
  866 + };
  867 +
  868 + console.log(aInfos);
  869 +
  870 + $(".exportAdd").addClass("disabled");
  871 + $(".exportAddSpan").html("正在导出...");
  872 +
  873 + // 提交
  874 + $.ajax({
  875 + type: 'POST',
  876 + url: "/tidc/exportDTDFile/xlsx",
  877 + dataType: 'binary',
  878 + contentType: "application/json",
  879 + data: JSON.stringify(aInfos),
  880 + success: function(data){
  881 + Main_v2.downloadFile(data, "application/octet-stream", "时刻表信息.xlsx");
  882 +
  883 + $(".exportAdd").removeClass("disabled");
  884 + $(".exportAddSpan").html(" 导出数据");
  885 + },
  886 + error: function(xhr, type){
  887 + alert('错误：TODO');
  888 +
  889 + $(".exportAdd").removeClass("disabled");
  890 + $(".exportAddSpan").html(" 导出数据");
  891 + }
  892 + });
  893 + });
  894 + },
  895 +
  896 + downloadFile: function (data, mimeType, fileName) {
  897 + var success = false;
  898 + var blob = new Blob([data], { type: mimeType });
  899 + try {
  900 + if (navigator.msSaveBlob)
  901 + navigator.msSaveBlob(blob, fileName);
  902 + else {
  903 + // Try using other saveBlob implementations, if available
  904 + var saveBlob = navigator.webkitSaveBlob || navigator.mozSaveBlob || navigator.saveBlob;
  905 + if (saveBlob === undefined) throw "Not supported";
  906 + saveBlob(blob, fileName);
  907 + }
  908 + success = true;
  909 + } catch (ex) {
  910 + console.log("saveBlob method failed with the following exception:");
  911 + console.log(ex);
  912 + }
  913 +
  914 + if (!success) {
  915 + // Get the blob url creator
  916 + var urlCreator = window.URL || window.webkitURL || window.mozURL || window.msURL;
  917 + if (urlCreator) {
  918 + // Try to use a download link
  919 + var link = document.createElement('a');
  920 + if ('download' in link) {
  921 + // Try to simulate a click
  922 + try {
  923 + // Prepare a blob URL
  924 + var url = urlCreator.createObjectURL(blob);
  925 + link.setAttribute('href', url);
  926 +
  927 + // Set the download attribute (Supported in Chrome 14+ / Firefox 20+)
  928 + link.setAttribute("download", fileName);
  929 +
  930 + // Simulate clicking the download link
  931 + var event = document.createEvent('MouseEvents');
  932 + event.initMouseEvent('click', true, true, window, 1, 0, 0, 0, 0, false, false, false, false, 0, null);
  933 + link.dispatchEvent(event);
  934 + success = true;
  935 +
  936 + } catch (ex) {
  937 + console.log("Download link method with simulated click failed with the following exception:");
  938 + console.log(ex);
  939 + }
  940 + }
  941 +
  942 + if (!success) {
  943 + // Fallback to window.location method
  944 + try {
  945 + // Prepare a blob URL
  946 + // Use application/octet-stream when using window.location to force download
  947 + var url = urlCreator.createObjectURL(blob);
  948 + window.location = url;
  949 + console.log("Download link method with window.location succeeded");
  950 + success = true;
  951 + } catch (ex) {
  952 + console.log("Download link method with window.location failed with the following exception:");
  953 + console.log(ex);
  954 + }
  955 + }
  956 + }
  957 + }
  958 +
  959 + if (!success) {
  960 + // Fallback to window.open method
  961 + console.log("No methods worked for saving the arraybuffer, using last resort window.open");
  962 + window.open("", '_blank', '');
  963 + }
  964 + }
  965 +
  966 + };
  967 +
  968 +}();
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/strategy/StrategyUtils.js 0 → 100644
  View file @14e3a31
  1 +/**
  2 + * 策略工具类。
  3 + */
  4 +var StrategyUtils = (function() {
  5 + /**
  6 + * 内部策略配置封装类。
  7 + * @constructor
  8 + */
  9 + function InternalStrategy() {
  10 + // 策略函数对应，每个函数都由一个标识符号对应，类似配置函数
  11 + this._oSTRATIGIS = {
  12 + // ADJUST_TRIP表示调整发车间隔的策略，都放在strategy/adjust目录下
  13 + // 每种策略对应一个js文件，里面的变量名就是策略名
  14 + "ADJUST_TRIP": AdjustTripS1
  15 + };
  16 + }
  17 +
  18 + /**
  19 + * 返回策略函数
  20 + * @param str 标识
  21 + * @returns {function}
  22 + */
  23 + InternalStrategy.prototype.sFn = function(str) {
  24 + if (!this._oSTRATIGIS[str]) {
  25 + throw "指定标识" + str + "策略函数不存在！";
  26 + }
  27 + return this._oSTRATIGIS[str];
  28 + };
  29 + /**
  30 + * 替换策略配置
  31 + * @param str 策略函数标识
  32 + * @param fn 策略函数
  33 + */
  34 + InternalStrategy.prototype.sConfig = function(str, fn) {
  35 + this._oSTRATIGIS[str] = fn;
  36 + };
  37 +
  38 + return new InternalStrategy();
  39 +} ());
0 40 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/AdjustTripStrategy.js renamed to src/main/resources/static/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS1.js
  View file @14e3a31
1   -//------------------ 策略模块（以下） -----------------//
2   -
  1 +/**
  2 + * 发车间隔调整策略1。
  3 + * 不考虑停站，吃饭时间的问题，直接调整发车间隔
  4 + * 1、发车间隔调整规则：
  5 + * （1）、从班次列表头开始，连续取3个班次，获取2个间隔，根据中间班次的情况，调整它的发车时间
  6 + * （2）、如果中间班次在低谷，并且发车间隔大于晚高峰最大发车间隔，中间班次调整-1分钟
  7 + * （3）、如果第一个间隔与第二个间隔相差1分钟，不调整
  8 + * （4）、如果第一个间隔大于第二个间隔，则中间班次发车时间-1分钟
  9 + * （5）、如果第一个间隔小于第二个间隔，则中间班次发车时间+1分钟
  10 + * 2、使用方法
  11 + * （1）、上行班次列表平衡5次
  12 + * （2）、下行班次列表平衡5次
  13 + * （3）、路牌班次调整1次（调整停站时间，吃饭时间）
  14 + * （4）、上行班次列表平衡5次
  15 + * （5）、下行班次列表平衡5次
  16 + *
  17 + *
  18 + * TODO：存在的问题，待解决
  19 + * （1）、行驶时间还是不够，就是平衡的时候的停站时间不够，吃饭时间也不够
  20 + * （2）、发车间隔还是有问题，超出范围，添加多个发车间隔时间段
  21 + */
3 22 var AdjustTripS1 = (function() {
4 23  
5 24 function _f1(aBc, schedule, paramObj, fre) {
... ... @@ -138,47 +157,4 @@ var AdjustTripS1 = (function() {
138 157 }
139 158  
140 159 return f1;
141   -}());
142   -
143   -//------------------ 策略模块（以上） -----------------//
144   -
145   -
146   -
147   -
148   -
149   -// 调整班次策略类
150   -var AdjustTripStrategy = (function() {
151   -
152   - /**
153   - * 内部策略配置封装类。
154   - * @constructor
155   - */
156   - function InternalStrategy() {
157   - // 策略函数对应，每个函数都由一个标识符号对应，类似配置函数
158   - this._oSTRATIGIS = {
159   - "ADJUST_TRIP": AdjustTripS1
160   - };
161   - }
162   -
163   - /**
164   - * 返回策略函数
165   - * @param str 标识
166   - * @returns {function}
167   - */
168   - InternalStrategy.prototype.sFn = function(str) {
169   - if (!this._oSTRATIGIS[str]) {
170   - throw "指定标识" + str + "策略函数不存在！";
171   - }
172   - return this._oSTRATIGIS[str];
173   - };
174   - /**
175   - * 替换策略配置
176   - * @param str 策略函数标识
177   - * @param fn 策略函数
178   - */
179   - InternalStrategy.prototype.sConfig = function(str, fn) {
180   - this._oSTRATIGIS[str] = fn;
181   - };
182   -
183   - return new InternalStrategy();
184 160 }());
185 161 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS2.js 0 → 100644
  View file @14e3a31
  1 +/**
  2 + * 平衡车距策略2（太死板，速度慢，效果不佳啊，建议不使用）。
  3 + * 调整策略如下（有点像滤波器）：
  4 + * 1、从头开始，连续取3个班次，获取2个间隔，根据间隔的不同及其他规则，调整中间班次的发车时间
  5 + * 2、基本调整如下，
  6 + * (1)、如果2个间隔时间差1分钟，不调整
  7 + * (2)、如果第一个间隔在区间间隔范围外，调整发车时间1分钟到指定的边界
  8 + * (3)、如果第一个间隔大，调整中间班次发车时间-1分钟，如果调整后的间隔在区间间隔范围外，不调整
  9 + * (4)、如果第二个间隔大，调整中间班次发车时间+1分钟，如果调整后的间隔在区间间隔范围外，不调整
  10 + * 3、如果可调整，但是相关的停站时间无法满足，不调整
  11 + *
  12 + * 以1分钟调整，不停的迭代上述步骤
  13 + *
  14 + * 4、如果还有没有满足要求的班次，此时需要智能修改分班路牌头尾班次，删除，或这加入，然后再次迭代
  15 + */
  16 +var AdjustTripS2 = (function() {
  17 + var iBcCountOfGroup = 3; // 3个班次一次参与计算
  18 + var aBcOfGroup = [];
  19 + var aBcIntervalOfGroup = []; // 班次间隔列表，3个班次，2个间隔
  20 + var oBcFcTime; // 班次发车时间
  21 +
  22 + /**
  23 + * 按照规则计算班次列表。
  24 + * @param iStartIndex {int} 开始索引
  25 + * @param aBc {array} 班次列表
  26 + * @private
  27 + */
  28 + function _calcuBcGroup(iStartIndex, aBc) {
  29 + var i;
  30 + var j;
  31 +
  32 + aBcOfGroup = [];
  33 + aBcIntervalOfGroup = [];
  34 + for (i = iStartIndex; i <= aBc.length - iBcCountOfGroup; i++) {
  35 + for (j = i; j < i + iBcCountOfGroup; j++) {
  36 + aBcOfGroup.push(aBc[j]);
  37 + }
  38 +
  39 + for (j = 0; j < aBcOfGroup.length; j++) {
  40 + if (j < aBcOfGroup.length - 1) {
  41 + aBcIntervalOfGroup.push(
  42 + aBcOfGroup[j + 1].getFcTimeObj().diff(
  43 + aBcOfGroup[j].getFcTimeObj(), "m"));
  44 + }
  45 + }
  46 + }
  47 + }
  48 +
  49 + /**
  50 + * 排序班次列表。
  51 + * @param aBc {array} 班次列表
  52 + * @param isAsc {boolean} 是否升序
  53 + * @private
  54 + */
  55 + function _sortBc(aBc, isAsc) {
  56 + aBc.sort(function(o1, o2) {
  57 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  58 + return -1;
  59 + } else {
  60 + return 1;
  61 + }
  62 + });
  63 + }
  64 +
  65 + /**
  66 + * 是否可以调整班次发车时间。
  67 + * @param oLp {InternalLpObj} 路牌对象
  68 + * @param oBc {InternalBcObj} 班次对象
  69 + * @param oParam {ParameterObj} 参数对象
  70 + * @param iStep {int} 修正时间步长
  71 + * @private
  72 + */
  73 + function _isModifyBcFcsj(oLp, oBc, oParam, iStep) {
  74 + // 获取车次链个数
  75 + var iBcChainCount = oLp.fnGetBcChainCount();
  76 +
  77 + var i;
  78 + var j;
  79 + var oBcIndex;
  80 + var iQIndex;
  81 + var iBcIndex;
  82 + var iBcCount;
  83 + var oPreBc;
  84 +
  85 + var iBcStopTime;
  86 +
  87 + var aRangeStopTime;
  88 +
  89 + for (i = 0; i < iBcChainCount; i++) {
  90 + oBcIndex = oLp.fnGetBcChainInfo(i);
  91 + iQIndex = oBcIndex["s_q"];
  92 + iBcIndex = oBcIndex["s_b"];
  93 + iBcCount = oBcIndex["bcount"];
  94 +
  95 + oPreBc = oLp.getPreBc(oBc);
  96 +
  97 + // 如果是第一个班次
  98 + if (!oPreBc) {
  99 + if (oBc.fnIsFirstBc()) { // 如果是方向头班车
  100 + return false;
  101 + } else {
  102 + return true;
  103 + }
  104 + }
  105 +
  106 + if (oPreBc.fnGetEatTime() > 0) { // 如果是吃饭班次，不能修改发车时间
  107 + return false;
  108 + }
  109 +
  110 + aRangeStopTime = oParam.calcuTripLayoverTimeRange(
  111 + oPreBc.getArrTimeObj(), oPreBc.isUp(), oPreBc.getBcTime()
  112 + );
  113 + iBcStopTime = oPreBc.getStopTime() + iStep;
  114 + if (iBcStopTime >= aRangeStopTime[0] && iBcStopTime <= aRangeStopTime[1]) {
  115 + return true;
  116 + } else {
  117 + return false;
  118 + }
  119 +
  120 +
  121 + }
  122 + }
  123 +
  124 + /**
  125 + * 调整发车时间（调整当前班次后，需要处理后续路牌的所有班次）。
  126 + * @param olp {InternalLpObj} 路牌对象
  127 + * @param oBc {InternalBcObj} 班次对象
  128 + * @param iMin {int} 分钟
  129 + * @param oParam {ParameterObj} 参数对象
  130 + * @private
  131 + */
  132 + function _modifyFcsj(olp, oBc, iMin, oParam) {
  133 + oBc._$_fcsjObj.add(iMin, "m");
  134 + oBc.setArrTimeObj(oParam.addMinute(
  135 + oBc.getFcTimeObj(),
  136 + oParam.calcuTravelTime(
  137 + oBc.getFcTimeObj(),
  138 + oBc.isUp())
  139 + ));
  140 +
  141 + // 平衡当前路牌的所有班次时间（修正不准确的停站时间）
  142 + olp.fnAdjustBcTime_layover(oParam);
  143 + }
  144 +
  145 + /**
  146 + * 平衡车距内部方法。
  147 + * @param aBc {array} 班次列表
  148 + * @param aSchedule {InternalScheduleObj} 行车计划对象
  149 + * @param oParam {ParameterObj} 参数对象
  150 + * @param iFre {int} 递归次数
  151 + * @private
  152 + */
  153 + function _f1(aBc, aSchedule, oParam, iFre) {
  154 + if (iFre > 0) {
  155 + // 按照时间升序班次列表
  156 + _sortBc(aBc, true);
  157 +
  158 + var i;
  159 + for (i = 0; i <= aBc.length; i++) {
  160 + // 获取班次列表
  161 + _calcuBcGroup(i, aBc);
  162 +
  163 + if (aBcOfGroup.length > 0) {
  164 + // 获取中间预调整的班次时间
  165 + oBcFcTime = aBcOfGroup[1].getFcTimeObj();
  166 +
  167 + if (oParam.isMPeakBc(oBcFcTime)) { // 早高峰
  168 + if (aBcIntervalOfGroup[0] < oParam.getMPeakMinFcjx()) {
  169 + // +1分钟
  170 + if (_isModifyBcFcsj(
  171 + aBcOfGroup[1].getGroup().getLp(),
  172 + aBcOfGroup[1],
  173 + oParam,
  174 + 1
  175 + )) {
  176 + _modifyFcsj(
  177 + aBcOfGroup[1].getGroup().getLp(),
  178 + aBcOfGroup[1],
  179 + 1,
  180 + oParam
  181 + );
  182 + }
  183 + } else if (aBcIntervalOfGroup[0] > oParam.getMPeakMaxFcjx()) {
  184 + // -1分钟
  185 + if (_isModifyBcFcsj(
  186 + aBcOfGroup[1].getGroup().getLp(),
  187 + aBcOfGroup[1],
  188 + oParam,
  189 + -1
  190 + )) {
  191 + _modifyFcsj(
  192 + aBcOfGroup[1].getGroup().getLp(),
  193 + aBcOfGroup[1],
  194 + -1,
  195 + oParam
  196 + );
  197 + }
  198 + } else {
  199 + // -1或+1分钟
  200 + if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  201 + // 两个间隔相差1分钟，不处理
  202 + } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  203 + if (_isModifyBcFcsj(
  204 + aBcOfGroup[1].getGroup().getLp(),
  205 + aBcOfGroup[1],
  206 + oParam,
  207 + -1
  208 + )) {
  209 + _modifyFcsj(
  210 + aBcOfGroup[1].getGroup().getLp(),
  211 + aBcOfGroup[1],
  212 + -1,
  213 + oParam
  214 + );
  215 + }
  216 + } else {
  217 + if (_isModifyBcFcsj(
  218 + aBcOfGroup[1].getGroup().getLp(),
  219 + aBcOfGroup[1],
  220 + oParam,
  221 + +1
  222 + )) {
  223 + _modifyFcsj(
  224 + aBcOfGroup[1].getGroup().getLp(),
  225 + aBcOfGroup[1],
  226 + +1,
  227 + oParam
  228 + );
  229 + }
  230 + }
  231 +
  232 + }
  233 +
  234 + } else if (oParam.isEPeakBc(oBcFcTime)) { // 晚高峰
  235 + if (aBcIntervalOfGroup[0] < oParam.getEPeakMinFcjx()) {
  236 + // +1分钟
  237 + if (_isModifyBcFcsj(
  238 + aBcOfGroup[1].getGroup().getLp(),
  239 + aBcOfGroup[1],
  240 + oParam,
  241 + 1
  242 + )) {
  243 + _modifyFcsj(
  244 + aBcOfGroup[1].getGroup().getLp(),
  245 + aBcOfGroup[1],
  246 + 1,
  247 + oParam
  248 + );
  249 + }
  250 + } else if (aBcIntervalOfGroup[0] > oParam.getEPeakMaxFcjx()) {
  251 + // -1分钟
  252 + if (_isModifyBcFcsj(
  253 + aBcOfGroup[1].getGroup().getLp(),
  254 + aBcOfGroup[1],
  255 + oParam,
  256 + -1
  257 + )) {
  258 + _modifyFcsj(
  259 + aBcOfGroup[1].getGroup().getLp(),
  260 + aBcOfGroup[1],
  261 + -1,
  262 + oParam
  263 + );
  264 + }
  265 + } else {
  266 + // -1或+1分钟
  267 + if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  268 + // 两个间隔相差1分钟，不处理
  269 + } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  270 + if (_isModifyBcFcsj(
  271 + aBcOfGroup[1].getGroup().getLp(),
  272 + aBcOfGroup[1],
  273 + oParam,
  274 + -1
  275 + )) {
  276 + _modifyFcsj(
  277 + aBcOfGroup[1].getGroup().getLp(),
  278 + aBcOfGroup[1],
  279 + -1,
  280 + oParam
  281 + );
  282 + }
  283 + } else {
  284 + if (_isModifyBcFcsj(
  285 + aBcOfGroup[1].getGroup().getLp(),
  286 + aBcOfGroup[1],
  287 + oParam,
  288 + +1
  289 + )) {
  290 + _modifyFcsj(
  291 + aBcOfGroup[1].getGroup().getLp(),
  292 + aBcOfGroup[1],
  293 + +1,
  294 + oParam
  295 + );
  296 + }
  297 + }
  298 + }
  299 + } else { // 低谷
  300 + if (aBcIntervalOfGroup[0] < oParam.getTroughMinFcjx()) {
  301 + // +1分钟
  302 + if (_isModifyBcFcsj(
  303 + aBcOfGroup[1].getGroup().getLp(),
  304 + aBcOfGroup[1],
  305 + oParam,
  306 + 1
  307 + )) {
  308 + _modifyFcsj(
  309 + aBcOfGroup[1].getGroup().getLp(),
  310 + aBcOfGroup[1],
  311 + 1,
  312 + oParam
  313 + );
  314 + }
  315 + } else if (aBcIntervalOfGroup[0] > oParam.getTroughMaxFcjx()) {
  316 + // -1分钟
  317 + if (_isModifyBcFcsj(
  318 + aBcOfGroup[1].getGroup().getLp(),
  319 + aBcOfGroup[1],
  320 + oParam,
  321 + -1
  322 + )) {
  323 + _modifyFcsj(
  324 + aBcOfGroup[1].getGroup().getLp(),
  325 + aBcOfGroup[1],
  326 + -1,
  327 + oParam
  328 + );
  329 + }
  330 + } else {
  331 + // -1或+1分钟
  332 + if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  333 + // 两个间隔相差1分钟，不处理
  334 + } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  335 + if (_isModifyBcFcsj(
  336 + aBcOfGroup[1].getGroup().getLp(),
  337 + aBcOfGroup[1],
  338 + oParam,
  339 + -1
  340 + )) {
  341 + _modifyFcsj(
  342 + aBcOfGroup[1].getGroup().getLp(),
  343 + aBcOfGroup[1],
  344 + -1,
  345 + oParam
  346 + );
  347 + }
  348 + } else {
  349 + if (_isModifyBcFcsj(
  350 + aBcOfGroup[1].getGroup().getLp(),
  351 + aBcOfGroup[1],
  352 + oParam,
  353 + +1
  354 + )) {
  355 + _modifyFcsj(
  356 + aBcOfGroup[1].getGroup().getLp(),
  357 + aBcOfGroup[1],
  358 + +1,
  359 + oParam
  360 + );
  361 + }
  362 + }
  363 + }
  364 + }
  365 + }
  366 +
  367 + }
  368 +
  369 + // 递归迭代
  370 + _f1(aBc, aSchedule, oParam, iFre - 1);
  371 + }
  372 + }
  373 +
  374 + /**
  375 + * 主函数-返回的策略函数。
  376 + * @param aUpBc {array} 上行班次数组
  377 + * @param aDownBc {array} 下行班次数组
  378 + * @param oSchedule {InternalScheduleObj} 行车计划对象
  379 + * @param oParam {ParameterObj} 参数对象
  380 + */
  381 + function main(aUpBc, aDownBc, oSchedule, oParam) {
  382 + // TODO：以后这里可能需要检测参数的正确性
  383 +
  384 + _f1(aUpBc, oSchedule, oParam, 5);
  385 + _f1(aDownBc, oSchedule, oParam, 5);
  386 +
  387 + // oSchedule.fnAdjustLpBcInterval(1);
  388 +
  389 + // _f1(aUpBc, oSchedule, oParam, 5);
  390 + // _f1(aDownBc, oSchedule, oParam, 5);
  391 +
  392 + }
  393 +
  394 + return main;
  395 +}());
0 396 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS3.js 0 → 100644
  View file @14e3a31
  1 +/**
  2 + * 平衡车距策略3。
  3 + * 将逻辑拆成三个部分，做什么，是否能做，修正班次时间
  4 + * 不考虑停站，吃饭时间的问题，直接调整发车时间
  5 + * 1、发车间隔调整规则：
  6 + * （1）、从班次列表头开始，连续取3个班次，获取2个间隔，根据不通的条件调整中间班次的发车时间
  7 + * （2）、如果当前班次在指定时间段的发车间隔范围外，则小的+1，大的-1
  8 + * （3）、如果在范围内，但是下一个班次不在指定时间段内，不处理
  9 + * （4）、如果下一个班次也在指定时间段内，则左右平滑+1或-1
  10 + * 2、使用方法
  11 + * （1）、上行班次列表平衡5次
  12 + * （2）、下行班次列表平衡5次
  13 + *
  14 + */
  15 +var AdjustTripS3 = (function() {
  16 +
  17 + /**
  18 + * 排序班次列表。
  19 + * @param aBc {array} 班次列表
  20 + * @param isAsc {boolean} 是否升序
  21 + * @private
  22 + */
  23 + function _sortBc(aBc, isAsc) {
  24 + aBc.sort(function(o1, o2) {
  25 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  26 + return -1;
  27 + } else {
  28 + return 1;
  29 + }
  30 + });
  31 + }
  32 +
  33 + //--------------- 每个trip调整分为三步（以下）----------------//
  34 + // 1、做什么，返回需要调整的时间
  35 + function _whatToDo(aTripOfGroup, aTripIntervalOfGroup, paramObj) {
  36 + // 中间班次的发车时间，参与计算
  37 + var oTripFcTime = aTripOfGroup[1].getFcTimeObj();
  38 + var oNextTripFcTime = aTripOfGroup[2].getFcTimeObj()
  39 + if (paramObj.isMPeakBc(oTripFcTime)) { // 早高峰
  40 + if (aTripIntervalOfGroup[0] < paramObj.getMPeakMinFcjx()) {
  41 + // +1分钟
  42 + return 1;
  43 + } else if (aTripIntervalOfGroup[0] > paramObj.getMPeakMaxFcjx()) {
  44 + // -1分钟
  45 + return -1;
  46 + } else {
  47 + if (!paramObj.isMPeakBc(oNextTripFcTime)) {
  48 + // 下一个班次不是早高峰，不处理
  49 + } else {
  50 + // -1或+1分钟
  51 + if (Math.abs(aTripIntervalOfGroup[0] - aTripIntervalOfGroup[1]) <= 1) {
  52 + return 0;
  53 + } else if (aTripIntervalOfGroup[0] > aTripIntervalOfGroup[1]) {
  54 + return -1;
  55 + } else {
  56 + return 1;
  57 + }
  58 + }
  59 + }
  60 +
  61 + } else if (paramObj.isEPeakBc(oTripFcTime)) { // 晚高峰
  62 + if (aTripIntervalOfGroup[0] < paramObj.getEPeakMinFcjx()) {
  63 + // +1分钟
  64 + return 1;
  65 + } else if (aTripIntervalOfGroup[0] > paramObj.getEPeakMaxFcjx()) {
  66 + // -1分钟
  67 + return -1;
  68 + } else {
  69 + if (!paramObj.isEPeakBc(oNextTripFcTime)) {
  70 + // 下一个班次不是晚高峰，不处理
  71 + } else {
  72 + // -1或+1分钟
  73 + if (Math.abs(aTripIntervalOfGroup[0] - aTripIntervalOfGroup[1]) <= 1) {
  74 + return 0;
  75 + } else if (aTripIntervalOfGroup[0] > aTripIntervalOfGroup[1]) {
  76 + return -1;
  77 + } else {
  78 + return 1;
  79 + }
  80 + }
  81 + }
  82 + } else { // 低谷
  83 + if (aTripIntervalOfGroup[0] < paramObj.getTroughMinFcjx()) {
  84 + // +1分钟
  85 + return 1;
  86 + } else if (aTripIntervalOfGroup[0] > paramObj.getTroughMaxFcjx()) {
  87 + // -1分钟
  88 + return -1;
  89 + } else {
  90 + if (!paramObj.isTroughBc(oNextTripFcTime)) {
  91 + // 下一个班次不是低谷班次，不处理
  92 + } else {
  93 + // -1或+1分钟
  94 + if (Math.abs(aTripIntervalOfGroup[0] - aTripIntervalOfGroup[1]) <= 1) {
  95 + return 0;
  96 + } else if (aTripIntervalOfGroup[0] > aTripIntervalOfGroup[1]) {
  97 + return -1;
  98 + } else {
  99 + return 1;
  100 + }
  101 + }
  102 + }
  103 + }
  104 + }
  105 + // 2、是否能做，返回true/false
  106 + function _canDo(aTripOfGroup, iTime, paramObj) {
  107 + // TODO
  108 + return iTime != 0;
  109 + }
  110 + // 3、修正班次时间
  111 + function _do(aBc, iIndex, iTime, paramObj) {
  112 + // // 从当前班次开始，后续所有的班次都要调整
  113 + // var i;
  114 + // for (i = iIndex; i < aBc.length; i++) {
  115 + // aBc[i]._$_fcsjObj.add(iTime, "m");
  116 + // aBc[i].setArrTimeObj(paramObj.addMinute(
  117 + // aBc[i].getFcTimeObj(),
  118 + // paramObj.calcuTravelTime(
  119 + // aBc[i].getFcTimeObj(),
  120 + // aBc[i].isUp())
  121 + // ));
  122 + // }
  123 + aBc[iIndex]._$_fcsjObj.add(iTime, "m");
  124 + aBc[iIndex].setBcTime(paramObj.calcuTravelTime(
  125 + aBc[iIndex].getFcTimeObj(), aBc[iIndex].isUp()));
  126 + aBc[iIndex].setArrTimeObj(paramObj.addMinute(
  127 + aBc[iIndex].getFcTimeObj(), aBc[iIndex].getBcTime()));
  128 + }
  129 +
  130 + //--------------- 每个trip调整分为三步（以上）----------------//
  131 +
  132 + function _f1(aBc, schedule, paramObj, fre) {
  133 + if (fre > 0) {
  134 + // 生序排列班次
  135 + _sortBc(aBc, true);
  136 +
  137 + var i;
  138 + var j;
  139 + var k;
  140 +
  141 + var iTripCountOfGroup = 3; // 3个班次取一次计算
  142 + var aTripOfGroup; // 3个班次列表
  143 + var aTripIntervalOfGroup; // 班次间隔列表，如：3个班次，2个间隔
  144 + var iTime; // 调整的时间
  145 +
  146 + for (i = 0; i <= aBc.length - iTripCountOfGroup; i++) {
  147 + aTripOfGroup = [];
  148 + aTripIntervalOfGroup = [];
  149 + // 连续计算3个班次参与计算
  150 + for (j = i; j < i + iTripCountOfGroup; j++) {
  151 + aTripOfGroup.push(aBc[j]);
  152 + }
  153 + // 连续2个班次间隔参与计算
  154 + for (k = 0; k < aTripOfGroup.length; k++) {
  155 + if (k < aTripOfGroup.length - 1) {
  156 + aTripIntervalOfGroup.push(aTripOfGroup[k + 1].getFcTimeObj().diff(
  157 + aTripOfGroup[k].getFcTimeObj(), "m"));
  158 + }
  159 + }
  160 +
  161 + iTime = _whatToDo(aTripOfGroup, aTripIntervalOfGroup, paramObj);
  162 + if (_canDo(aTripOfGroup, iTime, paramObj)) {
  163 + _do(aBc, j - 2, iTime, paramObj);
  164 + }
  165 +
  166 + }
  167 +
  168 + _f1(aBc, schedule, paramObj, fre - 1);
  169 +
  170 + }
  171 + }
  172 +
  173 +
  174 +
  175 + /**
  176 + * 主函数-返回的策略函数。
  177 + * @param aUpBc {array} 上行班次数组
  178 + * @param aDownBc {array} 下行班次数组
  179 + * @param oSchedule {InternalScheduleObj} 行车计划对象
  180 + * @param oParam {ParameterObj} 参数对象
  181 + */
  182 + function main(aUpBc, aDownBc, oSchedule, oParam) {
  183 + // TODO：以后这里可能需要检测参数的正确性
  184 + _f1(aUpBc, oSchedule, oParam, 5);
  185 + _f1(aDownBc, oSchedule, oParam, 5);
  186 +
  187 + // oSchedule.fnAdjustLpBcInterval(1);
  188 +
  189 + // _f1(aUpBc, oSchedule, oParam, 5);
  190 + // _f1(aDownBc, oSchedule, oParam, 5);
  191 +
  192 + }
  193 +
  194 + return main;
  195 +
  196 +} ());
0 197 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/strategy/adjust/AdjustTripS4.js 0 → 100644
  View file @14e3a31
  1 +/**
  2 + * 发车间隔调整策略4.
  3 + * TODO：
  4 + *
  5 + */
  6 +var AdjustTripS4 = (function() {
  7 + function _f1(aBc, schedule, paramObj, fre) {
  8 + if (fre > 0) {
  9 + aBc.sort(function (o1, o2) {
  10 + if (o1.getFcTimeObj().isBefore(o2.getFcTimeObj())) {
  11 + return -1;
  12 + } else {
  13 + return 1;
  14 + }
  15 + });
  16 +
  17 + var i;
  18 + var j;
  19 +
  20 + var iBcCountOfGroup = 3; // 3个班次取一次计算
  21 + var aBcOfGroup; // 3个班次列表
  22 + var aBcIntervalOfGroup; // 班次间隔列表，如：3个班次，2个间隔
  23 + var oBcFcTime; // 班次发车时间
  24 +
  25 + for (i = 0; i <= aBc.length - iBcCountOfGroup; i++) {
  26 + aBcOfGroup = [];
  27 + aBcIntervalOfGroup = [];
  28 + for (j = i; j < i + iBcCountOfGroup; j++) {
  29 + aBcOfGroup.push(aBc[j]);
  30 + }
  31 +
  32 + for (j = 0; j < aBcOfGroup.length; j++) {
  33 + if (j < aBcOfGroup.length - 1) {
  34 + aBcIntervalOfGroup.push(aBcOfGroup[j + 1].getFcTimeObj().diff(
  35 + aBcOfGroup[j].getFcTimeObj(), "m"));
  36 + }
  37 + }
  38 +
  39 + // 判定规则
  40 + oBcFcTime = aBcOfGroup[1].getFcTimeObj();
  41 +
  42 + // 第一个班次发车时间不动，根据间隔，调整中间一个班次
  43 + // 如果3个班次2个间隔时间差1分钟，不调整
  44 + // 如果第一个间隔大，调整第二个班次往前1分钟
  45 + // 如果第二个间隔大，调整第二个班次往后1分钟
  46 +
  47 + if (paramObj.isTroughBc(oBcFcTime) &&
  48 + aBcIntervalOfGroup[0] > paramObj.getTroughMaxFcjx()) {
  49 +
  50 + // aBcOfGroup[1].addMinuteToFcsj(-1);
  51 +
  52 + // 判定是否能调整发车时间
  53 + // if (aBcOfGroup[1].getGroup().getLp().isModifyBcFcsj(aBcOfGroup[1], -1, _paramObj)) {
  54 + aBcOfGroup[1]._$_fcsjObj.add(-1, "m");
  55 + aBcOfGroup[1].setArrTimeObj(paramObj.addMinute(
  56 + aBcOfGroup[1].getFcTimeObj(),
  57 + paramObj.calcuTravelTime(
  58 + aBcOfGroup[1].getFcTimeObj(),
  59 + aBcOfGroup[1].isUp())
  60 + ));
  61 +
  62 + // }
  63 + }
  64 +
  65 + //else if (_paramObj.isMPeakBc(oBcFcTime) &&
  66 + // aBcIntervalOfGroup[0] < _paramObj.getMPeakMinFcjx()) {
  67 + // aBcOfGroup[1].addMinuteToFcsj(1);
  68 + //} else if (_paramObj.isMPeakBc(oBcFcTime) &&
  69 + // aBcIntervalOfGroup[0] > _paramObj.getMPeakMaxFcjx()) {
  70 + // aBcOfGroup[1].addMinuteToFcsj(-1);
  71 + //} else if (_paramObj.isEPeakBc(oBcFcTime) &&
  72 + // aBcIntervalOfGroup[0] < _paramObj.getEPeakMinFcjx()) {
  73 + // aBcOfGroup[1].addMinuteToFcsj(1);
  74 + //} else if (_paramObj.isEPeakBc(oBcFcTime) &&
  75 + // aBcIntervalOfGroup[0] > _paramObj.getEPeakMaxFcjx()) {
  76 + // aBcOfGroup[1].addMinuteToFcsj(-1);
  77 + //}
  78 +
  79 +
  80 + else {
  81 + if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  82 + //continue;
  83 + } else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  84 +
  85 +
  86 + // 判定是否能调整发车时间
  87 + // if (aBcOfGroup[1].getGroup().getLp().isModifyBcFcsj(aBcOfGroup[1], -1, _paramObj)) {
  88 + aBcOfGroup[1]._$_fcsjObj.add(-1, "m");
  89 + aBcOfGroup[1].setArrTimeObj(paramObj.addMinute(
  90 + aBcOfGroup[1].getFcTimeObj(),
  91 + paramObj.calcuTravelTime(
  92 + aBcOfGroup[1].getFcTimeObj(),
  93 + aBcOfGroup[1].isUp())
  94 + ));
  95 + // }
  96 +
  97 + // aBcOfGroup[1].addMinuteToFcsj(-1);
  98 + } else {
  99 + // aBcOfGroup[1].addMinuteToFcsj(1);
  100 +
  101 + // 判定是否能调整发车时间
  102 + // if (aBcOfGroup[1].getGroup().getLp().isModifyBcFcsj(aBcOfGroup[1], 1, _paramObj)) {
  103 + aBcOfGroup[1]._$_fcsjObj.add(1, "m");
  104 + aBcOfGroup[1].setArrTimeObj(paramObj.addMinute(
  105 + aBcOfGroup[1].getFcTimeObj(),
  106 + paramObj.calcuTravelTime(
  107 + aBcOfGroup[1].getFcTimeObj(),
  108 + aBcOfGroup[1].isUp())
  109 + ));
  110 + // }
  111 + }
  112 + }
  113 +
  114 + //if (Math.abs(aBcIntervalOfGroup[0] - aBcIntervalOfGroup[1]) <= 1) {
  115 + // //continue;
  116 + //} else if (aBcIntervalOfGroup[0] > aBcIntervalOfGroup[1]) {
  117 + // aBcOfGroup[1].addMinuteToFcsj(-1);
  118 + //} else {
  119 + // aBcOfGroup[1].addMinuteToFcsj(1);
  120 + //}
  121 +
  122 +
  123 + }
  124 +
  125 + _f1(aBc, schedule, paramObj, fre - 1);
  126 +
  127 + }
  128 + }
  129 +
  130 + // TODO
  131 +
  132 + /**
  133 + * 重新计算路牌班次的停站时间（负数有可能，表示周转时间不够）
  134 + * @param oLp
  135 + * @private
  136 + */
  137 + function _reCalcuStopTime(oLp) {
  138 + // 获取车次链个数（连班路牌1个，分班路牌2个）
  139 + var iBlockCount = oLp.fnGetBcChainCount();
  140 +
  141 + var i;
  142 + var j;
  143 + var aTrip; // 每个block关联的trip列表
  144 + var trip; // 当前班次
  145 + var nextTrip; // 下一个班次
  146 + var layOverTime;
  147 + var aLayOverTimeRange;
  148 +
  149 + var oBcIndex;
  150 + var iQIndex; // block开始第几圈缩影
  151 + var iBcIndex; // block开始第几个班次
  152 + var iBcCount; // block的trip数目
  153 +
  154 +
  155 + for (i = 0; i < iBlockCount; i++) {
  156 + // 获取block关联的trip列表
  157 + oBcIndex = oLp.fnGetBcChainInfo(i);
  158 + iQIndex = oBcIndex["s_q"];
  159 + iBcIndex = oBcIndex["s_b"];
  160 + iBcCount = oBcIndex["bcount"];
  161 +
  162 + aTrip = [];
  163 + for (j = 0; j < iBcCount; j++) {
  164 + aTrip.push(oLp.getBc(iQIndex, iBcIndex));
  165 + iBcIndex = iBcIndex == 0 ? 1 : 0;
  166 + iQIndex = iBcIndex == 0 ? iQIndex + 1 : iQIndex;
  167 + }
  168 +
  169 + if (aTrip.length < 2) {
  170 + // 两个trip一起处理，只有1个trip的block不处理
  171 + continue;
  172 + }
  173 + // 迭代block，处理trip的发车，到达，停站时间
  174 + for (j = 0; j < aTrip.length - 1; j++) {
  175 + trip = aTrip[j];
  176 + nextTrip = aTrip[j + 1];
  177 +
  178 + // 计算layover时间
  179 + layOverTime = nextTrip.getFcTimeObj().diff(trip.getArrTimeObj(), "m");
  180 + // 吃饭班次处理
  181 + if (trip.fnGetEatTime() > 0) { // 吃饭班次
  182 + trip.setStopTime(0);
  183 + // 吃饭班次的实际时间添加一个变量直接表示
  184 + trip._iEatTimeTemp = layOverTime;
  185 + } else { // 正常班次
  186 + trip.setStopTime(layOverTime);
  187 + }
  188 + }
  189 + // 最后一个trip的layover时间为0
  190 + aTrip[j].setStopTime(0);
  191 +
  192 + }
  193 + }
  194 +
  195 + function _f2(schedule) {
  196 + var j = 0;
  197 + var _aLp = schedule.fnGetLpArray();
  198 + for (j = 0; j < _aLp.length; j++) {
  199 + _reCalcuStopTime(_aLp[j]);
  200 + }
  201 + }
  202 +
  203 + /**
  204 + * 获取指定路牌班次后的所有班次集合（单一车次链）
  205 + * @param oBc
  206 + * @private
  207 + */
  208 + function _f3_getNextBcs(oBc) {
  209 + var oLp = oBc.getGroup().getLp();
  210 +
  211 + // 获取车次链个数
  212 + var iBcChainCount = oLp.fnGetBcChainCount();
  213 +
  214 + var i;
  215 + var j;
  216 + var oBcIndex;
  217 + var iQIndex;
  218 + var iBcIndex;
  219 + var iBcCount;
  220 + var _bFindCurrentBc = false;
  221 +
  222 + var _aNextBc = [];
  223 +
  224 + for (i = 0; i < iBcChainCount; i++) {
  225 + oBcIndex = oLp.fnGetBcChainInfo(i);
  226 + iQIndex = oBcIndex["s_q"];
  227 + iBcIndex = oBcIndex["s_b"];
  228 + iBcCount = oBcIndex["bcount"];
  229 +
  230 + if (_aNextBc.length > 0) { // 已经在上一个车次链中找到
  231 + break;
  232 + }
  233 +
  234 + for (j = 0; j < iBcCount - 1; j++) {
  235 + if (_bFindCurrentBc) {
  236 + _aNextBc.push(oLp.getBc(iQIndex, iBcIndex));
  237 + } else if (oBc.getFcTimeObj().format("HH:mm") ==
  238 + oLp.getBc(iQIndex, iBcIndex).getFcTimeObj().format("HH:mm")) {
  239 + _bFindCurrentBc = true;
  240 + }
  241 +
  242 + // 进入到下一圈
  243 + iBcIndex = iBcIndex == 0 ? 1 : 0;
  244 + iQIndex = iBcIndex == 0 ? iQIndex + 1 : iQIndex;
  245 + }
  246 +
  247 + }
  248 +
  249 + return _aNextBc;
  250 + }
  251 +
  252 + /**
  253 + * 调整班次数组中班次的发车时间和到达时间。
  254 + * @param aBc
  255 + * @param iTime
  256 + * @private
  257 + */
  258 + function _f3_adjustTime(aBc, iTime) {
  259 + // TODO：因为改动的时间比较少，直接修改时间，暂时不考虑周转时间的变化
  260 + for (var i = 0; i < aBc.length; i++) {
  261 + aBc[i]._$_fcsjObj.add(iTime, "m");
  262 + aBc[i]._$_arrtime.add(iTime, "m");
  263 + }
  264 + }
  265 +
  266 + function _f3(aBc) {
  267 + var i;
  268 + var oBc;
  269 + var aNextBc;
  270 + var iTime;
  271 +
  272 + for (i = 0; i < aBc.length; i++) {
  273 + oBc = aBc[i];
  274 + if (oBc.getStopTime() < 0) { // 停站时间小于0
  275 + iTime = Math.abs(oBc.getStopTime()) + 1;
  276 + aNextBc = _f3_getNextBcs(oBc);
  277 + _f3_adjustTime(aNextBc, iTime);
  278 + oBc.setStopTime(1);
  279 + }
  280 + if (oBc._iEatTimeTemp != undefined &&
  281 + oBc._iEatTimeTemp != oBc.fnGetEatTime()) { // 吃饭班次问题
  282 + iTime = oBc.fnGetEatTime() - oBc._iEatTimeTemp;
  283 + aNextBc = _f3_getNextBcs(oBc);
  284 + _f3_adjustTime(aNextBc, iTime);
  285 + }
  286 +
  287 + // TODO：
  288 + }
  289 + }
  290 +
  291 +
  292 + function f1(aUpBc, aDownBc, schedule, paramObj) {
  293 + // 1、调整纵向班次间隔
  294 + _f1(aUpBc, schedule, paramObj, 5);
  295 + _f1(aDownBc, schedule, paramObj, 5);
  296 +
  297 + schedule.fnAdjustLpBcInterval(1);
  298 +
  299 + _f1(aUpBc, schedule, paramObj, 5);
  300 + _f1(aDownBc, schedule, paramObj, 5);
  301 +
  302 + // 2、计算实际的停站时间
  303 + _f2(schedule);
  304 +
  305 + // 3、调整停站时间不够，吃饭时间不够的班次
  306 + _f3(aUpBc);
  307 + _f3(aDownBc);
  308 + }
  309 +
  310 + return f1;
  311 +
  312 +} ());
0 313 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/paramadd.html
  View file @14e3a31
1   -<!-- 统计数据 -->
2   -<style>
3   - .form-control:focus {
4   - border-color: #53ced9;
5   - }
6   - .tagsDiv {
7   - border: 1px solid #c2cad8;
8   - margin-left: 15px;
9   - padding: 4px 15px 4px 15px;
10   - width: 50%;
11   - }
12   -</style>
13   -<div class="modal fade" id="paramadd_mobal" tabindex="-1" role="basic" aria-hidden="true">
14   - <div class="modal-dialog" style="margin-left: 100px;">
15   - <div class="modal-content" style="width: 1000px;">
16   - <div class="modal-header">
17   - <button type="button" class="close" data-dismiss="modal" aria-hidden="true"></button>
18   - <h4 class="modal-title">参数数据 </h4>
19   - </div>
20   - <div class="modal-body">
21   - <form class="form-horizontal" id="param_form" action="/" method="POST" novalidate="novalidate">
22   - <div class="form-body">
23   - <div class="alert alert-danger display-hide">
24   - <button class="close" data-close="alert"></button>
25   - 您的输入有误，请检查下面的输入项
26   - </div>
27   - <div class="alert alert-success display-none">
28   - <button class="close" data-dismiss="alert"></button>
29   - 验证成功!
30   - </div>
31   -
32   - </div>
33   -
34   - <div class="tab-pane" id="ptab">
35   -
36   - </div>
37   - </form>
38   - </div>
39   -
40   - <div class="modal-footer">
41   - <button type="button" class="btn default" data-dismiss="modal">取消</button>
42   - <button type="button" class="btn btn-primary" id="paramnext">确定</button>
43   - </div>
44   -
45   - </div>
46   - </div>
47   -</div>
48   -
49   -<script type="text/html" id = "paramAdd_temp">
50   - <div class="form-group">
51   - <div class="col-md-6">
52   - <label class="control-label col-md-5">
53   - <span class="required"> * </span> 上行首班时间　:
54   - </label>
55   - <div class="col-md-5">
56   - <input type="text" class="form-control" name="startStationFirstTime" value="{{map.startStationFirstTime}}" id="startStationFirstTime_id"
57   - placeholder="请输入起始站首班时间">
58   - </div>
59   - </div>
60   - <div class="col-md-6">
61   - <label class="control-label col-md-5">
62   - <span class="required"> * </span> 上行末班时间　:
63   - </label>
64   - <div class="col-md-5">
65   - <input type="text" class="form-control" name="startStationEndTime" value="{{map.startStationEndTime}}" id="startStationEndTime_id"
66   - placeholder="请输入起始站末班时间">
67   - </div>
68   - </div>
69   - </div>
70   -
71   - <div class="form-group">
72   - <div class="col-md-6">
73   - <label class="control-label col-md-5">
74   - <span class="required"> * </span> 下行首班时间　:
75   - </label>
76   - <div class="col-md-5">
77   - <input type="text" class="form-control" name="endStationFirstTime" value="{{map.endStationFirstTime}}" id="endStationFirstTime_id"
78   - placeholder="请输入终点站首班时间">
79   - </div>
80   - </div>
81   - <div class="col-md-6">
82   - <label class="control-label col-md-5">
83   - <span class="required"> * </span> 下行末班时间　:
84   - </label>
85   - <div class="col-md-5">
86   - <input type="text" class="form-control" name="endStationEndTime" value="{{map.endStationEndTime}}" id="endStationEndTime_id"
87   - placeholder="请输入终点站末班时间">
88   - </div>
89   - </div>
90   - </div>
91   -
92   - <div class="form-group">
93   - <div class="col-md-6">
94   - <label class="control-label col-md-5">
95   - <span class="required"> * </span> 早高峰开始时间　:
96   - </label>
97   - <div class="col-md-5">
98   - <input type="text" class="form-control" name="earlyStartTime" value="{{map.earlyStartTime}}" id="earlyStartTime_id"
99   - placeholder="请输入早高峰开始时间">
100   - </div>
101   - </div>
102   - <div class="col-md-6">
103   - <label class="control-label col-md-5">
104   - <span class="required"> * </span> 早高峰结束时间　:
105   - </label>
106   - <div class="col-md-5">
107   - <input type="text" class="form-control" name="earlyEndTime" value="{{map.earlyEndTime}}" id="earlyEndTime_id"
108   - placeholder="请输入早高峰结束时间">
109   - </div>
110   - </div>
111   - </div>
112   -
113   - <div class="form-group">
114   - <div class="col-md-6">
115   - <label class="control-label col-md-5">
116   - <span class="required"> * </span> 晚高峰开始时间　:
117   - </label>
118   - <div class="col-md-5">
119   - <input type="text" class="form-control" name="lateStartTime" value="{{map.lateStartTime}}" id="lateStartTime_id"
120   - placeholder="请输入晚高峰开始时间">
121   - </div>
122   - </div>
123   - <div class="col-md-6">
124   - <label class="control-label col-md-5">
125   - <span class="required"> * </span> 晚高峰结束时间　:
126   - </label>
127   - <div class="col-md-5">
128   - <input type="text" class="form-control" name="lateEndTime" value="{{map.lateEndTime}}" id="lateEndTime_id"
129   - placeholder="请输入晚高峰结束时间">
130   - </div>
131   - </div>
132   - </div>
133   -
134   - <div class="form-group">
135   - <div class="col-md-6">
136   - <label class="control-label col-md-5">上行进场时间　　:
137   - </label>
138   - <div class="col-md-5">
139   - <input type="text" class="form-control" name="upInTimer" value="{{map.upInTimer}}" id="upInTimer_id"
140   - placeholder="请输入上行进场时间">
141   - </div>
142   - </div>
143   - <div class="col-md-6">
144   - <label class="control-label col-md-5">上行出场时间　　:
145   - </label>
146   - <div class="col-md-5">
147   - <input type="text" class="form-control" name="upOutTimer" value="{{map.upOutTimer}}" id="upOutTimer_id"
148   - placeholder="请输入上行出场时间">
149   - </div>
150   - </div>
151   - </div>
152   -
153   - <div class="form-group">
154   - <div class="col-md-6">
155   - <label class="control-label col-md-5">下行进场时间　　:
156   - </label>
157   - <div class="col-md-5">
158   - <input type="text" class="form-control" name="downInTimer" value="{{map.downInTimer}}" id="downInTimer_id"
159   - placeholder="请输入下行进场时间">
160   - </div>
161   - </div>
162   - <div class="col-md-6">
163   - <label class="control-label col-md-5">下行出场时间　　:
164   - </label>
165   - <div class="col-md-5">
166   - <input type="text" class="form-control" name="downOutTimer" value="{{map.downOutTimer}}" id="downOutTimer_id"
167   - placeholder="请输入下行出场时间">
168   - </div>
169   - </div>
170   - </div>
171   -
172   - <div class="form-group">
173   - <div class="col-md-6">
174   - <label class="control-label col-md-5">早高峰上行时间　:</label>
175   - <div class="col-md-5">
176   - <input type="text" class="form-control" name="earlyUpTime" value="{{map.earlyUpTime}}" id="earlyUpTime_id"
177   - placeholder="请输入早高峰上行时间">
178   - </div>
179   - </div>
180   - <div class="col-md-6">
181   - <label class="control-label col-md-5">早高峰下行时间　:</label>
182   - <div class="col-md-5">
183   - <input type="text" class="form-control" name="earlyDownTime" value="{{map.earlyDownTime}}" id="earlyDownTime_id"
184   - placeholder="请输入早高峰下行时间">
185   - </div>
186   - </div>
187   - </div>
188   -
189   - <div class="form-group">
190   - <div class="col-md-6">
191   - <label class="control-label col-md-5">晚高峰上行时间　:</label>
192   - <div class="col-md-5">
193   - <input type="text" class="form-control" name="lateUpTime" value="{{map.lateUpTime}}" id="lateUpTime_id"
194   - placeholder="请输入晚高峰上行时间">
195   - </div>
196   - </div>
197   - <div class="col-md-6">
198   - <label class="control-label col-md-5">晚高峰下行时间　:</label>
199   - <div class="col-md-5">
200   - <input type="text" class="form-control" name="lateDownTime" value="{{map.lateDownTime}}" id="lateDownTime_id"
201   - placeholder="请输入晚高峰下行时间">
202   - </div>
203   - </div>
204   - </div>
205   -
206   - <div class="form-group">
207   - <div class="col-md-6">
208   - <label class="control-label col-md-5">低谷上行时间　　:</label>
209   - <div class="col-md-5">
210   - <input type="text" class="form-control" name="troughUpTime" value="{{map.troughUpTime}}" id="troughUpTime_id"
211   - placeholder="请输入低谷上行时间">
212   - </div>
213   - </div>
214   - <div class="col-md-6">
215   - <label class="control-label col-md-5">低谷下行时间　　:</label>
216   - <div class="col-md-5">
217   - <input type="text" class="form-control" name="troughDownTime" value="{{map.troughDownTime}}" id="troughDownTime_id"
218   - placeholder="请输入低谷下行时间">
219   - </div>
220   - </div>
221   - </div>
222   -
223   - <div class="form-group">
224   - <div class="col-md-6">
225   - <label class="control-label col-md-5">
226   - <span class="required"> * </span> 线路规划类型　　:
227   - </label>
228   - <div class="col-md-5">
229   - <select name="linePlayType" class="form-control" id="linePlayType_id">
230   - <option value="">-- 请选择线路类型 --</option>
231   - <option value="0">双向</option>
232   - <option value="1">环线</option>
233   - </select>
234   - </div>
235   - </div>
236   - <div class="col-md-6">
237   - <label class="control-label col-md-5">吃饭地点　　　　:</label>
238   - <div class="col-md-5">
239   - <select type="text" class="form-control" name="cfdd" id="cfdd_id">
240   - <option value="">请选择...</option>
241   - <option value="0">{{map.startStationName}}</option>
242   - <option value="1">{{map.endStationName}}</option>
243   - <option value="allYes">起终点站都可以</option>
244   - </select>
245   - </div>
246   - </div>
247   - </div>
248   -
249   - <div class="form-group">
250   - <div class="col-md-6">
251   - <label class="control-label col-md-5">早晚例行保养　　:</label>
252   - <div class="col-md-5">
253   - <input type="text" class="form-control" name="lb" value="{{map.lb}}" id="lb_id"
254   - placeholder="请输入早晚例行保养">
255   - </div>
256   - </div>
257   - <div class="col-md-6">
258   - <label class="control-label col-md-5">停车场　　　　　:</label>
259   - <div class="col-md-5">
260   - <select name="carPark" class="form-control" id="carPark_id" style="width:100%"></select>
261   - </div>
262   - </div>
263   - </div>
264   -
265   -
266   - <div class="form-group">
267   - <div class="col-md-6">
268   - <label class="control-label col-md-5">工作餐午餐时间　:</label>
269   - <div class="col-md-5">
270   - <input type="text" class="form-control" name="workeLunch" value="{{map.workeLunch}}" id="workeLunch_id"
271   - placeholder="请输入工作餐午餐时间">
272   - </div>
273   - </div>
274   - <div class="col-md-6">
275   - <label class="control-label col-md-5">工作餐晚餐时间　:</label>
276   - <div class="col-md-5">
277   - <input type="text" class="form-control" name="workeDinner" value="{{map.workeDinner}}" id="workeDinner_id"
278   - placeholder="请输入工作餐晚餐时间">
279   - </div>
280   - </div>
281   - </div>
282   -
283   - <div class="form-group">
284   - <div class="col-md-6">
285   - <label class="control-label col-md-5"><span class="required"> * </span>早高峰发车间隔　:</label>
286   - <div class="col-md-3" style="padding-right: 0px;">
287   - <input type="text" class="form-control" name="zgffcjxmin" value="{{map.zgffcjxmin}}" id="zgffcjxmin_id"
288   - placeholder="最小间隔">
289   - </div>
290   - <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
291   - <div class="col-md-3" style="padding-left: 0px;">
292   - <input type="text" class="form-control" name="zgffcjxmax" value="{{map.zgffcjxmax}}" id="zgffcjxmax_id"
293   - placeholder="最大间隔">
294   - </div>
295   - </div>
296   - <div class="col-md-6">
297   - <label class="control-label col-md-5"><span class="required"> * </span>晚高峰发车间隔　:</label>
298   - <div class="col-md-3" style="padding-right: 0px;">
299   - <input type="text" class="form-control" name="wffcjxmin" value="{{map.wffcjxmin}}" id="wffcjxmin_id"
300   - placeholder="最小间隔">
301   - </div>
302   - <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
303   - <div class="col-md-3" style="padding-left: 0px;">
304   - <input type="text" class="form-control" name="wffcjxmax" value="{{map.wffcjxmax}}" id="wffcjxmax_id"
305   - placeholder="最大间隔">
306   - </div>
307   - </div>
308   - </div>
309   -
310   - <div class="form-group">
311   - <div class="col-md-6">
312   - <label class="control-label col-md-5"><span class="required"> * </span>低谷发车间隔　:</label>
313   - <div class="col-md-3" style="padding-right: 0px;">
314   - <input type="text" class="form-control" name="dgfcjxmin" value="{{map.dgfcjxmin}}" id="dgfcjxmin_id"
315   - placeholder="最小间隔">
316   - </div>
317   - <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
318   - <div class="col-md-3" style="padding-left: 0px;">
319   - <input type="text" class="form-control" name="dgfcjxmax" value="{{map.dgfcjxmax}}" id="dgfcjxmax_id"
320   - placeholder="最大间隔">
321   - </div>
322   - </div>
323   - <div class="col-md-6">
324   - <label class="control-label col-md-5"><span class="required"> * </span>建议加班路牌数　:</label>
325   - <div class="col-md-5">
326   - <input type="text" class="form-control" name="jbclcount" value="{{map.jbclcount}}" id="jbclcount_id"
327   - placeholder="为0表示是周末时刻表">
328   - </div>
329   - </div>
330   - </div>
331   -
332   - <div class="form-group">
333   - <div class="col-md-6">
334   - <label class="control-label col-md-5"><span class="required"> * </span>停站类型　:</label>
335   - <div class="col-md-5 tagsDiv">
336   - <div class="row" style="margin-left: 15px;">
337   - <input type="text" value="{{map.stt}}" name="stt" id="stoptype_tagsinput" style="display: none;">
338   - </div>
339   -
340   - <div class="row" style="margin-top: 10px;">
341   - <label class="control-label col-md-4">停站类型:</label>
342   - <div class="col-md-8">
343   - <select name="stopType" class="form-control" id="stopType_id">
344   - <option value="">-- 请选择停站类型 --</option>
345   - <option value="0">主站停站</option>
346   - <option value="1">双向停站</option>
347   - </select>
348   - </div>
349   - </div>
350   -
351   - <div class="row" style="margin-top: 10px;">
352   - <label class="control-label col-md-4">主站:</label>
353   - <div class="col-md-8">
354   - <select name="masterStop" class="form-control" id="masterStop_id">
355   - <option value="">请选择...</option>
356   - <option value="0">{{map.startStationName}}</option>
357   - <option value="1">{{map.endStationName}}</option>
358   - </select>
359   - </div>
360   - </div>
361   -
362   - <div class="row" style="margin-top: 10px;margin-left: 116px;">
363   - <a href="javascript:" class="btn red" id="stoptype_tagsinput_add">添加</a>
364   - </div>
365   - </div>
366   -
367   - </div>
368   -
369   - <div class="col-md-6">
370   - <label class="control-label col-md-5">
371   - <span class="required"> * </span> 建议高峰配车数　:</label>
372   - <div class="col-md-5">
373   - <input type="text" class="form-control" placeholder="车辆数" name="gfjypcs"
374   - id="gfjypcsInput" min="1" value="{{map.gfjypcs}}">
375   - </div>
376   - </div>
377   -
378   - </div>
379   -
380   - <!-- 隐藏字段-时间 -->
381   - <input type="hidden" name="skbName" value="{{map.skbName}}" id="skbName_id"/>
382   - <input type="hidden" name="skbmc" value="{{map.skbmc}}" id="skbmc_id"/>
383   - <input type="hidden" name="xlmc" value="{{map.xlmc}}" id="xlmc_id"/>
384   - <input type="hidden" name="lineName" value="{{map.lineName}}" id="lineName_id"/>
385   - <input type="hidden" name="lineVersion" value="{{map.lineVersion}}" id="lineVersion_id"/>
386   -
387   - <!-- 上下行行驶时间 -->
388   - <input type="hidden" name="upTravelTime" value="{{map.upTravelTime}}" id="upTravelTime_id"/>
389   - <input type="hidden" name="downTravelTime" value="{{map.downTravelTime}}" id="downTravelTime_id"/>
390   -
391   - <!-- 隐藏字段-里程 -->
392   - <!-- 上下行行驶里程 -->
393   - <input type="hidden" name="upMileage" value="{{map.upMileage}}" id="upMileage_id"/>
394   - <input type="hidden" name="downMileage" value="{{map.downMileage}}" id="downMileage_id"/>
395   - <!-- 上下行进场出场里程 -->
396   - <input type="hidden" name="upInMileage" value="{{map.upInMileage}}" id="upInMileage_id"/>
397   - <input type="hidden" name="downInMileage" value="{{map.downInMileage}}" id="downInMileage_id"/>
398   - <input type="hidden" name="upOutMileage" value="{{map.upOutMileage}}" id="upOutMileage_id"/>
399   - <input type="hidden" name="downOutMileage" value="{{map.downOutMileage}}" id="downOutMileage_id"/>
400   -
401   -
402   -</script>
403   -
404   -<script type="text/javascript">
405   - $('#paramadd_mobal').on('paramAddMobal.show', function(e, g_){
406   - // 加载延迟200毫秒显示mobal
407   - setTimeout(function(){$('#paramadd_mobal').modal({show : true,backdrop: 'static', keyboard: false});},200);
408   - var param = JSON.parse(window.localStorage.Gantt_AgursData);
409   -
410   - // 获取表单元素
411   - var form = $('#param_form');
412   - // 错误提示元素
413   - var paramAlert = $('.alert-danger', form);
414   - // 确定事件点击
415   - $('#paramnext').on('click', function() {
416   - form.submit();// 表单提交
417   - });
418   -
419   - // 表单验证
420   - form.validate({
421   - errorElement : 'span',
422   - errorClass : 'help-block help-block-error',
423   - focusInvalid : false,
424   - rules: {
425   - 'skbName' : {required : true,},// 时刻表名称,必填项.
426   - 'lineName' : {required : true,},// 线路名称,必填项.
427   - 'lineVersion': {required: true}, // 站点路由版本，必填项，
428   - 'startStationFirstTime' : {required : true}, // 起始站首班时间,必填项.
429   - 'startStationEndTime' : {required : true}, // 起始站末班时间 ,必填项.
430   - 'endStationFirstTime' : {required : true}, // 终点站首班时间 ,必填项.
431   - 'endStationEndTime' : {required : true}, // 终点站末班时间,必填项.
432   - 'earlyStartTime' : {required : true},// 早高峰开始时间,必填项 .
433   - 'earlyEndTime' : {required : true},// 早高峰结束时间,必填项 .
434   - 'lateStartTime' : {required : true},// 晚高峰开始时间,必填项 .
435   - 'lateEndTime' : {required : true},// 晚高峰结束时间,必填项.
436   - 'upInTimer' : {number : true},// 上行进场时间,必须为数字.
437   - 'upOutTimer' : {number : true},// 上行出场时间,必须为数字.
438   - 'downInTimer' : {number : true},// 下行进场时间,必须为数字.
439   - 'downOutTimer' : {number : true},// 下行出场时间,必须为数字.
440   - 'earlyUpTime' : {number : true},// 早高峰上行时间,必须为数字.
441   - 'earlyDownTime' : {number : true},// 早高峰下行时间,必须为数字.
442   - 'lateUpTime' : {number : true},// 晚高峰上行时间,必须为数字.
443   - 'lateDownTime' : {number : true},// 晚高峰下行时间,必须为数字.
444   - 'troughUpTime' : {number : true},// 低谷上行时间,必须为数字.
445   - 'troughDownTime' : {number : true},// 低谷下行时间,必须为数字.
446   - 'linePlayType' : {required : true},// 线路规划类型,必填项
447   - 'lb' : {number : true},// 早晚例行保养,必须为数字.
448   - 'workeLunch' : {number : true},// 工作餐午餐时间,必须为数字.
449   - 'workeDinner' : {number : true},// 工作餐晚餐时间,必须为数字.
450   - 'zgffcjxmin' : {required : true,number : true,digits: true},// 早高峰最小发车间隔.
451   - 'zgffcjxmax' : {required : true,number : true,digits: true},// 早高峰最大发车间隔.
452   - 'wffcjxmin' : {required : true,number : true,digits: true},// 晚高峰最小发车间隔.
453   - 'wffcjxmax' : {required : true,number : true,digits: true},// 晚高峰最大发车间隔.
454   - 'dgfcjxmin' : {required : true,number : true,digits: true},// 低谷最小发车间隔.
455   - 'dgfcjxmax' : {required : true,number : true,digits: true},// 低谷最大发车间隔.
456   - 'jbclcount': {required : true,number : true,digits: true}, // 建议加班车数
457   - 'upTravelTime' : {required : true,number : true},// 上行行驶时间,必填项、必须为整数.
458   - 'downTravelTime' : {required : true,number : true},// 下行行驶时间,必填项、必须为整数.
459   - 'upMileage' : {required : true,number : true},// 上行行驶里程,必填项、必须为整数.
460   - 'downMileage' : {required : true,number : true},// 下行行驶里程,必填项、必须为整数.
461   - 'upInMileage' : {number : true},// 上行进场里程,必须为数字.
462   - 'upOutMileage' : {number : true},// 上行出场里程,必须为数字.
463   - 'downInMileage' : {number : true},// 下行进场里程,必须为数字.
464   - 'downOutMileage' : {number : true}// 下行出场里程,必须为数字.
465   -
466   - // TODO
467   - },
468   - invalidHandler : function(event, validator) {
469   - paramAlert.show();
470   - App.scrollTo(paramAlert, -200);
471   - },
472   - highlight : function(element) {
473   - $(element).closest('.form-group').addClass('has-error');
474   - },
475   - unhighlight : function(element) {
476   - $(element).closest('.form-group').removeClass('has-error');
477   - },
478   - success : function(label) {
479   - label.closest('.form-group').removeClass('has-error');
480   - },
481   - submitHandler : function(f) {
482   - // 1、 获取表单内容,并序列化
483   - var fp = form.serializeJSON();
484   -
485   - console.log(fp);
486   -
487   - // 2、重新刷新表单数据
488   - var ganttMap = JSON.parse(window.localStorage.Gantt_AgursData);
489   - var key;
490   - for (key in fp) {
491   - if (ganttMap[key]) {
492   - if (ganttMap[key] != fp[key]) {
493   - ganttMap[key] = fp[key];
494   - }
495   - } else {
496   - ganttMap[key] = fp[key];
497   - }
498   - }
499   - window.localStorage.setItem("Gantt_AgursData",JSON.stringify(ganttMap));
500   -
501   - // TODO
502   - var pp = getParamObjAndDataMap();
503   - var paramObj = pp[0];
504   - var dataMap = pp[1];
505   - var csMap = getCSMap(paramObj);
506   - // console.log(graph);
507   - var data = Main_v2.BXPplaceClassesTime03(paramObj, csMap.maxCar);
508   - Main_v2.exportDataConfig(data.aInternalLpObj);
509   -
510   - // var data = obj.getDataArray();
511   - // // 2、 调整路牌对应的班次总数
512   - // updFormParams(params,data);
513   - // 删除图形.
514   - $('svg.svg-chart').remove();
515   - // 重新创建图形.
516   - var graph = d3.select('#ganttSvg').relationshipGraph(getGraphArgus(csMap, dataMap, data));
517   - // 根据数据重新渲染图形.
518   - graph.data(data.json);
519   - // 记录早操.并保存历史班次数据
520   - graph.addHistory();
521   - // 隐藏错误提示
522   - paramAlert.hide();
523   - // 隐藏 reladplus_mobal 弹出层
524   - $('#paramadd_mobal').modal('hide');
525   - layer.msg('成功!');
526   - }
527   - });
528   -
529   -
530   - // 当模态框对用户可见时触发（将等待 CSS 过渡效果完成）。
531   - $('#paramadd_mobal').on('show.bs.modal', function () {
532   - // TODO
533   - // 把数据填充到模版中
534   - // var tbodyHtml = template('countAdd_temp',{list:countDate});
535   - // // 把渲染好的模版html文本追加到表格中
536   - // $('#datatable_countadd tbody').html(tbodyHtml);
537   - var htmldata = template('paramAdd_temp', {map : param});
538   - $('#ptab').html(htmldata);
539   -
540   - // 线路规划类型
541   - $('#linePlayType_id').val(param.linePlayType);
542   - // 吃饭地点
543   - $get('/stationroute/all', {
544   - 'line.id_eq': param.lineName.split('_')[0],
545   - 'destroy_eq': 0,
546   - 'versions_eq': param.lineVersion},
547   - function(result) {
548   - var opt = [];
549   - opt.push('<option value="">请选择...</option>');
550   - $.each(result, function(i, d) {
551   - if (d.stationMark == 'B' && d.directions == 0) {
552   - opt.push("<option value='0'>" + d.stationName + "</option>");
553   - } else if (d.stationMark == 'E' && d.directions == 0) {
554   - opt.push("<option value='1'>" + d.stationName + "</option>");
555   - }
556   - });
557   - initTagsinput(opt.join(","));
558   -
559   - opt.push("<option value='allYes'>起终点站都可以</option>");
560   - $('#cfdd_id').html(opt.join(""));
561   - $('#cfdd_id').val(param.cfdd);
562   -
563   - }
564   - );
565   - // 停车场
566   - $get('/carpark/all',null, function(cd) {
567   - var opt = [];
568   - opt.push('<option value="">请选择...</option><optgroup label="停车场">');
569   - var $_len = cd.length;
570   - if($_len > 0) {
571   - $.each(cd, function(i, d){
572   - opt.push('<option value="'+d.parkCode+'">'+d.parkName+'</option>');
573   - });
574   - }
575   - opt.push('</optgroup>');
576   - $('#carPark_id').html(opt.join(",")).select2();
577   - $('#carPark_id').select2("val", param.carPark);
578   - });
579   -
580   - // 上下行首末班日期控件
581   - $('#startStationFirstTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
582   - $('#startStationEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
583   - $('#endStationFirstTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
584   - $('#endStationEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
585   -
586   - // 早高峰晚高峰日期控件
587   - $('#earlyStartTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
588   - $('#earlyEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
589   - $('#lateStartTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
590   - $('#lateEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
591   -
592   - });
593   - });
594   -
595   - function initTagsinput(htmlStr) {
596   - $('#masterStop_id').html(htmlStr);
597   -
598   - var elt = $('#stoptype_tagsinput');
599   - var value = elt.val();
600   - var stoptype = value.split("/")[0];
601   - var masterstop = value.split("/")[1];
602   -
603   - $('#stopType_id').val(stoptype);
604   - $('#masterStop_id').val(masterstop);
605   -
606   - elt.tagsinput({
607   - tagClass: function(item) {
608   - return 'label label-danger label-important';
609   - },
610   - itemValue: 'value',
611   - itemText: 'text'
612   - });
613   -
614   - $('#stoptype_tagsinput').on('beforeItemAdd', function(event) {
615   - // TODO：这里可以做一些逻辑判定
616   - });
617   -
618   - $('#stoptype_tagsinput_add').on('click', function(){
619   - var stoptype = $("#stopType_id").val();
620   - var masterstop = $("#masterStop_id").val();
621   - var masterstop_text = $("#masterStop_id option:selected").text();
622   -
623   - if (stoptype && stoptype != "") {
624   - if (stoptype == "0" && masterstop && masterstop != "") {
625   - elt.tagsinput('add', {
626   - "value": stoptype + '/' + masterstop,
627   - "text": "主站停站" + "/" + masterstop_text
628   - });
629   - } else {
630   - elt.tagsinput('add', {
631   - "value": 1,
632   - "text": "双向停站"
633   - });
634   - }
635   - }
636   - });
637   -
638   - if (stoptype && stoptype != "") {
639   - elt.tagsinput('add', {
640   - "value": stoptype + '/' + masterstop,
641   - "text":
642   - $("#stopType_id option:selected").text() + "/" +
643   - $("#masterStop_id option:selected").text()
644   - });
645   - }
646   -
647   - }
648   -
649   - function getMinDate(d1,d2) {
650   - // 1、定义返回字符串.
651   - var str = '';
652   - // 2、判断时间大小.
653   - if(strToTime(d1)>strToTime(d2))
654   - str = d2;
655   - else
656   - str = d1;
657   - // 3、返回最小时间(字符串).
658   - return str;
659   - }
660   -
661   - function strToTime(t) {
662   - var d = new Date();
663   - if(t) {
664   - var _str = t.split(':');
665   - d.setHours(parseInt(_str[0]));
666   - d.setMinutes(parseInt(_str[1]));
667   - }
668   - return d;
669   - }
670   -
671   - function getMaxDate(d1,d2) {
672   - // 1、定义返回时间字符串.
673   - var str = '';
674   - // 2、判断时间大小.
675   - if(strToTime(d1)>strToTime(d2))
676   - str = d1;
677   - else
678   - str = d2;
679   - // 3、返回一个最大时间(字符串).
680   - return str;
681   - }
682   -
683   - function getEndDate(date) {
684   - var lastEndDate = Date.now();
685   - if (date) {
686   - var str = date.replace(/-/g,"/");
687   - lastEndDate = new Date(str);
688   - }
689   - // Wed Oct 26 2016 00:00:00 GMT+0800 (中国标准时间)
690   - return lastEndDate;
691   - }
692   -
693   - function formatPairing(v1,v2) {
694   - v1 = v1 == '' ? 0 : parseInt(v1);
695   - v2 = v2 == ''? 0 : parseInt(v2) ;
696   - return [v1,v2];
697   - }
698   -
699   - function qzdz(zd1,zd2) {
700   - return [zd1,zd2];
701   - }
702   -
703   - function formatksjssj(gp) {
704   - return [{'kssj':gp.startStationFirstTime,'jssj':gp.startStationEndTime},{'kssj':gp.endStationFirstTime,'jssj':gp.endStationEndTime}];
705   - }
706   -
707   - function getsd(st,ed) {
708   - return [{'st':st,'ed':ed}];
709   - }
710   -
711   - function getDateTime(time) {
712   - var dateTime = new Date();
713   - var timeArr;
714   - if(time !=null && time !='' && typeof(time) !='undefined') {
715   - timeArr = time.split(':');
716   - dateTime.setHours(parseInt(timeArr[0]));
717   - dateTime.setMinutes(parseInt(timeArr[1]));
718   - }
719   - return dateTime;
720   - }
721   -
722   - function getYAxisCarArray(len) {
723   - var array = new Array();
724   - if(len>0) {
725   - for(var y = 0; y<len; y++) {
726   - array.push({lp:null,lpNo:y+1, parent :y+1, lpName:y+1,lpType:'普通路牌'});//添加一个路牌对象
727   - };
728   - }
729   - return array;
730   - }
731   -
732   - function getylp(arr) {
733   - var ra = new Array(),name = new Array();
734   - for(var i = 0 ; i<arr.length;i++) {
735   - ra.push(arr[i].lpNo);
736   - name.push(arr[i].lpName);
737   - }
738   - return {'lpNoA':ra,'lpNameA':name,};
739   - }
740   -
741   - function getParamObjAndDataMap() {
742   - var map = JSON.parse(window.localStorage.Gantt_AgursData);
743   - // seMap
744   - var seMap = {'s': map.linePlayType == '1' ? map.startStationFirstTime : getMinDate(map.startStationFirstTime,map.endStationFirstTime),
745   - 'e': map.linePlayType == '1' ? map.startStationEndTime : getMaxDate(map.startStationEndTime,map.endStationEndTime)};
746   - // dirA
747   - var dirA = ['relationshipGraph-up', 'relationshipGraph-down'];
748   - // bcTypeArr
749   - var bcTypeArr = {
750   - 'bd': 'bd', 'out': 'out', 'normal': 'normal', 'cf': 'cf', 'in_': 'in', 'lc': 'lc',
751   - 'major': 'major', 'venting': 'venting', 'region': 'region'
752   - };
753   - // seDate
754   - var newDate = new Date();
755   - var kssj = d3.time.hour.offset(getEndDate(
756   - newDate.getFullYear()+ "-" +
757   - (newDate.getMonth()+1) + "-" +
758   - newDate.getDate() + ' ' +
759   - seMap.s.split(':')[0] + ':00'),-1);
760   -
761   - var year = '' , month = '',dt = '';
762   - if(newDate.getDate()+1>31)
763   - dt = '01';
764   - else
765   - dt = newDate.getDate()+1;
766   - if(newDate.getMonth()+1>12)
767   - month = '01';
768   - else if(newDate.getDate()+1>31)
769   - month = newDate.getMonth()+2;
770   - else
771   - month = newDate.getMonth()+1;
772   - if(newDate.getMonth()+1>12)
773   - year = newDate.getFullYear()+1;
774   - else
775   - year = newDate.getFullYear();
776   - var jssj = getEndDate(year + '-' + month + '-' + dt + ' ' + '00:00');
777   - seDate = {'kssj' : kssj, 'jssj' : jssj};
778   -
779   - // dataMap
780   - var dataMap = {'jcsjArr' : formatPairing(map.upInTimer,map.downInTimer),// 进场里程。[下标0代表上；下标1代表下]
781   - 'ccsjArr' : formatPairing(map.upOutTimer,map.downOutTimer),// 出场时间。[下标0代表上；下标1代表下]
782   - 'jclcArr' : formatPairing(map.upInMileage,map.downInMileage),// 进场里程。[下标0代表上；下标1代表下]
783   - 'cclcArr' : formatPairing(map.upOutMileage,map.downOutMileage),// 出场里程。[下标0代表上；下标1代表下]
784   - 'pcxssjArr' : formatPairing(map.upTravelTime,map.downTravelTime),// 平常行驶时间。[下标0代表上；下标1代表下]
785   - 'gfxxsjArr' : formatPairing(map.lateUpTime=='' ? map.upTravelTime : map.lateUpTime,
786   - map.lateDownTime=='' ? map.downTravelTime : map.lateDownTime),// 高峰行驶时间。[下标0代表上；下标1代表下]
787   - 'dgxxsjArr' : formatPairing(map.troughUpTime=='' ? map.upTravelTime : map.troughUpTime,
788   - map.troughDownTime=='' ? map.downTravelTime : map.troughDownTime),// 低谷行驶时间。[下标0代表上；下标1代表下]
789   - 'pcxslcArr' : formatPairing(map.upMileage,map.downMileage),// 行驶里程。[下标0代表上；下标1代表下]
790   - 'qdzArr' : qzdz(map.up_s.split('_')[0],map.down_s.split('_')[0]),// 起始站。[下标0代表上；下标1代表下]
791   - 'zdzArr':qzdz(map.up_s.split('_')[1],map.down_s.split('_')[1]),// 终点站。[下标0代表上；下标1代表下]
792   - 'zwcArr' : formatPairing(map.workeLunch,map.workeDinner),// 午晚餐时间。[下标0代表午；下标1代表晚]
793   - 'smbcsjArr' : formatksjssj(map), // 起终点站首末班车时间.[下标0代表起始站的首末班车时间；下标1代表终点站的首末班车时间]
794   - 'zgfsjd' : getsd(getDateTime(map.earlyStartTime),
795   - getDateTime(map.earlyEndTime)), // 早高峰时间段
796   - 'wgfsjd' : getsd(getDateTime(map.lateStartTime),
797   - getDateTime(map.lateEndTime)),// 晚高峰时间段
798   - 'gfzjsjd' : getsd(getDateTime(map.earlyEndTime),
799   - getDateTime(map.lateStartTime)),//高峰之间时间段.
800   - 'wgfzhsjd' : getsd(getDateTime(map.lateEndTime),
801   - getDateTime(seMap.e)),// 晚高峰之后时间段
802   - 'zgfzqsjd': getsd(getDateTime(seMap.s),
803   - getDateTime(map.earlyStartTime)),//早高峰之前时间段.
804   - 'dira' : dirA,// 方向集合 [下标0代表上；下标1代表下]
805   - 'bcTypeArr' : bcTypeArr,// 班次类型
806   - 'lbsj' : map.lb=='' ? 0:parseInt(map.lb),// 例保时间.
807   - // 'minztjx' : parseInt(gatps.mixstopTime), // 最小停站时间.
808   - // 'ztjxA' : BaseFun.formatPairing(gatps.upStopTime,gatps.downStopTime), // 停站时间.
809   - // 'maxztjx' : parseInt(gatps.maxstopTime), // 最大停站时间.
810   - 'gftzsj': formatPairing(map.gfupStopTime,map.gfdownStopTime),// 高峰停站时间.
811   - 'dgtzsj' : formatPairing(map.dgupStopTime,map.dgdownStopTime),// 低谷停站时间.
812   - 'dgmaxtzsj' : parseInt(map.dgmaxtzsj),// 低谷最大停站时间.
813   - 'dgmaxfcjx' : parseInt(map.dgmaxfcjx),// 低谷最大发车间隙.
814   - 'map' : map,
815   - 'zzsj':map.zzsj,// 周转时间.
816   - };
817   -
818   - var _paramObj = Main_v2.getFactory().createParameterObj(map, dataMap);
819   - map.clzs = _paramObj.calcuClzx();
820   - return [_paramObj, dataMap];
821   -
822   - }
823   -
824   - function getCSMap(parmObj) {
825   - var map = JSON.parse(window.localStorage.Gantt_AgursData);
826   - return {'gattA':null,
827   - 'fcjx': {'gffcjx': Math.round(parmObj.calcuPeakZzsj()/parmObj.calcuClzx()) ,
828   - 'dgfcjx': Math.round(parmObj.calcuTroughZzsj()/parmObj.calcuClzx()),
829   - 'dgmaxfcjx' : parseInt(map.dgmaxfcjx)},
830   - 'maxCar':getYAxisCarArray(parseInt(parmObj.calcuClzx()))};
831   - }
832   -
833   - function getGraphArgus(CSMap, dataMap, data) {
834   - // TODO
835   - var map = JSON.parse(window.localStorage.Gantt_AgursData);
836   - var sxsj = parseInt(map.upTravelTime);// 上行时间.
837   -
838   - // seMap
839   - var seMap = {'s': map.linePlayType == '1' ? map.startStationFirstTime : getMinDate(map.startStationFirstTime,map.endStationFirstTime),
840   - 'e': map.linePlayType == '1' ? map.startStationEndTime : getMaxDate(map.startStationEndTime,map.endStationEndTime)};
841   -
842   - // seDate
843   - var newDate = new Date();
844   - var kssj = d3.time.hour.offset(getEndDate(
845   - newDate.getFullYear()+ "-" +
846   - (newDate.getMonth()+1) + "-" +
847   - newDate.getDate() + ' ' +
848   - seMap.s.split(':')[0] + ':00'),-1);
849   -
850   - var year = '' , month = '',dt = '';
851   - if(newDate.getDate()+1>31)
852   - dt = '01';
853   - else
854   - dt = newDate.getDate()+1;
855   - if(newDate.getMonth()+1>12)
856   - month = '01';
857   - else if(newDate.getDate()+1>31)
858   - month = newDate.getMonth()+2;
859   - else
860   - month = newDate.getMonth()+1;
861   - if(newDate.getMonth()+1>12)
862   - year = newDate.getFullYear()+1;
863   - else
864   - year = newDate.getFullYear();
865   - var jssj = getEndDate(year + '-' + month + '-' + dt + ' ' + '00:00');
866   - seDate = {'kssj' : kssj, 'jssj' : jssj};
867   -
868   -
869   - var bs = sxsj > 40 ? 4 : 2;
870   - var MULTIPLE = Math.round(105/sxsj) >3 ? Math.round(90/sxsj) : Math.round(90/sxsj) *bs;
871   - var VALUEKEYNAME = 'Worldwide Gross' ,
872   - DXHOURS = 24,MINUTE = 60,WIDTH = DXHOURS*MINUTE,MARGINLEFT = 380,HEIGHT = CSMap.maxCar.length*60 + 240,
873   - MARGINBOTTOM = 240,OFFSETX = 90,OFFSETY = 180,OFFSETUPY = 120,OFFSETDOWNY = 60,
874   - STARTDATETIME = seDate.kssj ,ENDDATETIME = seDate.jssj ,TASKTYPES =CSMap.maxCar ,TICKFORMAT ='%H:%M' ,SHOWTOOLTIPS = true;
875   - var dx_time = seDate.jssj.getTime() - seDate.kssj.getTime() ;
876   - // 计算出相差天数
877   - var days=Math.floor(dx_time/(24*3600*1000));
878   - // 计算出小时数
879   - var leave1=dx_time%(24*3600*1000); //计算天数后剩余的毫秒数
880   - var hours=Math.floor(leave1/(3600*1000));
881   - DXHOURS = days*24+hours;
882   - WIDTH = DXHOURS*MINUTE*MULTIPLE;
883   - // debugger;
884   - var lpsplitA = getylp(CSMap.maxCar);
885   -
886   - var sxsj = parseInt(map.upTravelTime);// 上行时间.
887   - var xxsj = parseInt(map.downTravelTime);// 下行时间.
888   - var stopAraay = [{
889   - 'sxsj':sxsj,// 上行时间.
890   - 'xxsj':xxsj,// 下行时间.
891   - 'zzsj':map.zzsj,// 周转时间.
892   - 'wcsj':parseInt(map.workeLunch),// 午餐时间.
893   - 'wcsj':parseInt(map.workeDinner),// 晚餐时间.
894   - 'zgfsxsj':map.earlyUpTime==''? sxsj : parseInt(map.earlyUpTime),// 早高峰上行行驶时间.
895   - 'zgfxxsj':map.earlyDownTime=='' ? xxsj : parseInt(map.earlyDownTime),// 早高峰下行行驶时间.
896   - 'wgfsxsj':map.lateUpTime=='' ? sxsj : parseInt(map.lateUpTime),// 晚高峰上行行驶时间.
897   - 'wgfxxsj':map.lateDownTime== '' ? xxsj: parseInt(map.lateDownTime),// 晚高峰下行行驶时间.
898   - 'sxjcsj':map.upInTimer == '' ? 0 : parseInt(map.upInTimer),// 上行进场时间.
899   - 'sxccsj':map.upOutTimer == '' ? 0 : parseInt(map.upOutTimer),// 上行出场时间.
900   - 'xxjcsj':map.downInTimer =='' ? 0 : parseInt(map.downInTimer),// 下行进场时间.
901   - 'xxccsj':map.downOutTimer =='' ? 0 : parseInt(map.downOutTimer),// 下行进场时间.
902   - 'sxjclc':map.upInMileage==''? 0 : parseInt(map.upInMileage),// 上行进场里程.
903   - 'sxcclc':map.upOutMileage==''? 0:parseInt(map.upOutMileage),// 上行出场里程.
904   - 'xxjclc':map.downInMileage==''? 0 : parseInt(map.downInMileage),// 下行进场里程.
905   - 'xxcclc':map.downOutMileage==''?0:parseInt(map.downOutMileage),// 下行出场里程.
906   - 'lbsj': map.lb==''? 0 : parseInt(map.lb) // 例保时间.
907   - }];
908   -
909   - var args = {
910   - 'valueKeyName': VALUEKEYNAME,
911   - 'hours' : DXHOURS,
912   - 'dxHours' : 24 - DXHOURS,
913   - 'multiple': MULTIPLE,
914   - 'width':WIDTH,
915   - 'widtMargin':MARGINLEFT,
916   - 'height':HEIGHT,
917   - 'heightMargin':MARGINBOTTOM,
918   - 'offsetX':OFFSETX,
919   - 'offsetY':OFFSETY,
920   - 'downDy':OFFSETDOWNY,
921   - 'upDy':OFFSETUPY,
922   - 'timeDomainStart' :STARTDATETIME,
923   - 'timeDomainEnd' : ENDDATETIME,
924   - 'startStr':'' + STARTDATETIME,
925   - 'endStr': '' +ENDDATETIME,
926   - 'taskTypes': TASKTYPES,
927   - 'lpNoA':lpsplitA.lpNoA,
928   - 'lpNameA':lpsplitA.lpNameA,
929   - 'tickFormat': TICKFORMAT,
930   - 'stopAraay' : stopAraay,
931   - 'dataMap':dataMap,
932   - 'showTooltips': SHOWTOOLTIPS,
933   - 'bxrcgs':data.bxrcgs
934   - }
935   - return args;
936   - }
  1 +<!-- 统计数据 -->
  2 +<style>
  3 + .form-control:focus {
  4 + border-color: #53ced9;
  5 + }
  6 + .tagsDiv {
  7 + border: 1px solid #c2cad8;
  8 + margin-left: 15px;
  9 + padding: 4px 15px 4px 15px;
  10 + width: 50%;
  11 + }
  12 +</style>
  13 +<div class="modal fade" id="paramadd_mobal" tabindex="-1" role="basic" aria-hidden="true">
  14 + <div class="modal-dialog" style="margin-left: 100px;">
  15 + <div class="modal-content" style="width: 1000px;">
  16 + <div class="modal-header">
  17 + <button type="button" class="close" data-dismiss="modal" aria-hidden="true"></button>
  18 + <h4 class="modal-title">参数数据 </h4>
  19 + </div>
  20 + <div class="modal-body">
  21 + <form class="form-horizontal" id="param_form" action="/" method="POST" novalidate="novalidate">
  22 + <div class="form-body">
  23 + <div class="alert alert-danger display-hide">
  24 + <button class="close" data-close="alert"></button>
  25 + 您的输入有误，请检查下面的输入项
  26 + </div>
  27 + <div class="alert alert-success display-none">
  28 + <button class="close" data-dismiss="alert"></button>
  29 + 验证成功!
  30 + </div>
  31 +
  32 + </div>
  33 +
  34 + <div class="tab-pane" id="ptab">
  35 +
  36 + </div>
  37 + </form>
  38 + </div>
  39 +
  40 + <div class="modal-footer">
  41 + <button type="button" class="btn default" data-dismiss="modal" id="paramcancel">
  42 + <span class="paramcancelSpan">取消</span>
  43 + </button>
  44 + <button type="button" class="btn btn-primary" id="paramnext">
  45 + <span class="paramnextSpan">确定</span>
  46 + </button>
  47 + </div>
  48 +
  49 + </div>
  50 + </div>
  51 +</div>
  52 +
  53 +<script type="text/html" id = "paramAdd_temp">
  54 + <div class="form-group">
  55 + <div class="col-md-6">
  56 + <label class="control-label col-md-5">
  57 + <span class="required"> * </span> 上行首班时间　:
  58 + </label>
  59 + <div class="col-md-5">
  60 + <input type="text" class="form-control" name="startStationFirstTime" value="{{map.startStationFirstTime}}" id="startStationFirstTime_id"
  61 + placeholder="请输入起始站首班时间">
  62 + </div>
  63 + </div>
  64 + <div class="col-md-6">
  65 + <label class="control-label col-md-5">
  66 + <span class="required"> * </span> 上行末班时间　:
  67 + </label>
  68 + <div class="col-md-5">
  69 + <input type="text" class="form-control" name="startStationEndTime" value="{{map.startStationEndTime}}" id="startStationEndTime_id"
  70 + placeholder="请输入起始站末班时间">
  71 + </div>
  72 + </div>
  73 + </div>
  74 +
  75 + <div class="form-group">
  76 + <div class="col-md-6">
  77 + <label class="control-label col-md-5">
  78 + <span class="required"> * </span> 下行首班时间　:
  79 + </label>
  80 + <div class="col-md-5">
  81 + <input type="text" class="form-control" name="endStationFirstTime" value="{{map.endStationFirstTime}}" id="endStationFirstTime_id"
  82 + placeholder="请输入终点站首班时间">
  83 + </div>
  84 + </div>
  85 + <div class="col-md-6">
  86 + <label class="control-label col-md-5">
  87 + <span class="required"> * </span> 下行末班时间　:
  88 + </label>
  89 + <div class="col-md-5">
  90 + <input type="text" class="form-control" name="endStationEndTime" value="{{map.endStationEndTime}}" id="endStationEndTime_id"
  91 + placeholder="请输入终点站末班时间">
  92 + </div>
  93 + </div>
  94 + </div>
  95 +
  96 + <div class="form-group">
  97 + <div class="col-md-6">
  98 + <label class="control-label col-md-5">
  99 + <span class="required"> * </span> 早高峰开始时间　:
  100 + </label>
  101 + <div class="col-md-5">
  102 + <input type="text" class="form-control" name="earlyStartTime" value="{{map.earlyStartTime}}" id="earlyStartTime_id"
  103 + placeholder="请输入早高峰开始时间">
  104 + </div>
  105 + </div>
  106 + <div class="col-md-6">
  107 + <label class="control-label col-md-5">
  108 + <span class="required"> * </span> 早高峰结束时间　:
  109 + </label>
  110 + <div class="col-md-5">
  111 + <input type="text" class="form-control" name="earlyEndTime" value="{{map.earlyEndTime}}" id="earlyEndTime_id"
  112 + placeholder="请输入早高峰结束时间">
  113 + </div>
  114 + </div>
  115 + </div>
  116 +
  117 + <div class="form-group">
  118 + <div class="col-md-6">
  119 + <label class="control-label col-md-5">
  120 + <span class="required"> * </span> 晚高峰开始时间　:
  121 + </label>
  122 + <div class="col-md-5">
  123 + <input type="text" class="form-control" name="lateStartTime" value="{{map.lateStartTime}}" id="lateStartTime_id"
  124 + placeholder="请输入晚高峰开始时间">
  125 + </div>
  126 + </div>
  127 + <div class="col-md-6">
  128 + <label class="control-label col-md-5">
  129 + <span class="required"> * </span> 晚高峰结束时间　:
  130 + </label>
  131 + <div class="col-md-5">
  132 + <input type="text" class="form-control" name="lateEndTime" value="{{map.lateEndTime}}" id="lateEndTime_id"
  133 + placeholder="请输入晚高峰结束时间">
  134 + </div>
  135 + </div>
  136 + </div>
  137 +
  138 + <div class="form-group">
  139 + <div class="col-md-6">
  140 + <label class="control-label col-md-5">上行进场时间　　:
  141 + </label>
  142 + <div class="col-md-5">
  143 + <input type="text" class="form-control" name="upInTimer" value="{{map.upInTimer}}" id="upInTimer_id"
  144 + placeholder="请输入上行进场时间">
  145 + </div>
  146 + </div>
  147 + <div class="col-md-6">
  148 + <label class="control-label col-md-5">上行出场时间　　:
  149 + </label>
  150 + <div class="col-md-5">
  151 + <input type="text" class="form-control" name="upOutTimer" value="{{map.upOutTimer}}" id="upOutTimer_id"
  152 + placeholder="请输入上行出场时间">
  153 + </div>
  154 + </div>
  155 + </div>
  156 +
  157 + <div class="form-group">
  158 + <div class="col-md-6">
  159 + <label class="control-label col-md-5">下行进场时间　　:
  160 + </label>
  161 + <div class="col-md-5">
  162 + <input type="text" class="form-control" name="downInTimer" value="{{map.downInTimer}}" id="downInTimer_id"
  163 + placeholder="请输入下行进场时间">
  164 + </div>
  165 + </div>
  166 + <div class="col-md-6">
  167 + <label class="control-label col-md-5">下行出场时间　　:
  168 + </label>
  169 + <div class="col-md-5">
  170 + <input type="text" class="form-control" name="downOutTimer" value="{{map.downOutTimer}}" id="downOutTimer_id"
  171 + placeholder="请输入下行出场时间">
  172 + </div>
  173 + </div>
  174 + </div>
  175 +
  176 + <div class="form-group">
  177 + <div class="col-md-6">
  178 + <label class="control-label col-md-5">早高峰上行时间　:</label>
  179 + <div class="col-md-5">
  180 + <input type="text" class="form-control" name="earlyUpTime" value="{{map.earlyUpTime}}" id="earlyUpTime_id"
  181 + placeholder="请输入早高峰上行时间">
  182 + </div>
  183 + </div>
  184 + <div class="col-md-6">
  185 + <label class="control-label col-md-5">早高峰下行时间　:</label>
  186 + <div class="col-md-5">
  187 + <input type="text" class="form-control" name="earlyDownTime" value="{{map.earlyDownTime}}" id="earlyDownTime_id"
  188 + placeholder="请输入早高峰下行时间">
  189 + </div>
  190 + </div>
  191 + </div>
  192 +
  193 + <div class="form-group">
  194 + <div class="col-md-6">
  195 + <label class="control-label col-md-5">晚高峰上行时间　:</label>
  196 + <div class="col-md-5">
  197 + <input type="text" class="form-control" name="lateUpTime" value="{{map.lateUpTime}}" id="lateUpTime_id"
  198 + placeholder="请输入晚高峰上行时间">
  199 + </div>
  200 + </div>
  201 + <div class="col-md-6">
  202 + <label class="control-label col-md-5">晚高峰下行时间　:</label>
  203 + <div class="col-md-5">
  204 + <input type="text" class="form-control" name="lateDownTime" value="{{map.lateDownTime}}" id="lateDownTime_id"
  205 + placeholder="请输入晚高峰下行时间">
  206 + </div>
  207 + </div>
  208 + </div>
  209 +
  210 + <div class="form-group">
  211 + <div class="col-md-6">
  212 + <label class="control-label col-md-5">低谷上行时间　　:</label>
  213 + <div class="col-md-5">
  214 + <input type="text" class="form-control" name="troughUpTime" value="{{map.troughUpTime}}" id="troughUpTime_id"
  215 + placeholder="请输入低谷上行时间">
  216 + </div>
  217 + </div>
  218 + <div class="col-md-6">
  219 + <label class="control-label col-md-5">低谷下行时间　　:</label>
  220 + <div class="col-md-5">
  221 + <input type="text" class="form-control" name="troughDownTime" value="{{map.troughDownTime}}" id="troughDownTime_id"
  222 + placeholder="请输入低谷下行时间">
  223 + </div>
  224 + </div>
  225 + </div>
  226 +
  227 + <div class="form-group">
  228 + <div class="col-md-6">
  229 + <label class="control-label col-md-5">
  230 + <span class="required"> * </span> 线路规划类型　　:
  231 + </label>
  232 + <div class="col-md-5">
  233 + <select name="linePlayType" class="form-control" id="linePlayType_id">
  234 + <option value="">-- 请选择线路类型 --</option>
  235 + <option value="0">双向</option>
  236 + <option value="1">环线</option>
  237 + </select>
  238 + </div>
  239 + </div>
  240 + <div class="col-md-6">
  241 + <label class="control-label col-md-5">吃饭地点　　　　:</label>
  242 + <div class="col-md-5">
  243 + <select type="text" class="form-control" name="cfdd" id="cfdd_id">
  244 + <option value="">请选择...</option>
  245 + <option value="0">{{map.startStationName}}</option>
  246 + <option value="1">{{map.endStationName}}</option>
  247 + <option value="allYes">起终点站都可以</option>
  248 + </select>
  249 + </div>
  250 + </div>
  251 + </div>
  252 +
  253 + <div class="form-group">
  254 + <div class="col-md-6">
  255 + <label class="control-label col-md-5">早晚例行保养　　:</label>
  256 + <div class="col-md-5">
  257 + <input type="text" class="form-control" name="lb" value="{{map.lb}}" id="lb_id"
  258 + placeholder="请输入早晚例行保养">
  259 + </div>
  260 + </div>
  261 + <div class="col-md-6">
  262 + <label class="control-label col-md-5">停车场　　　　　:</label>
  263 + <div class="col-md-5">
  264 + <select name="carPark" class="form-control" id="carPark_id" style="width:100%"></select>
  265 + </div>
  266 + </div>
  267 + </div>
  268 +
  269 +
  270 + <div class="form-group">
  271 + <div class="col-md-6">
  272 + <label class="control-label col-md-5">工作餐午餐时间　:</label>
  273 + <div class="col-md-5">
  274 + <input type="text" class="form-control" name="workeLunch" value="{{map.workeLunch}}" id="workeLunch_id"
  275 + placeholder="请输入工作餐午餐时间">
  276 + </div>
  277 + </div>
  278 + <div class="col-md-6">
  279 + <label class="control-label col-md-5">工作餐晚餐时间　:</label>
  280 + <div class="col-md-5">
  281 + <input type="text" class="form-control" name="workeDinner" value="{{map.workeDinner}}" id="workeDinner_id"
  282 + placeholder="请输入工作餐晚餐时间">
  283 + </div>
  284 + </div>
  285 + </div>
  286 +
  287 + <div class="form-group">
  288 + <div class="col-md-6">
  289 + <label class="control-label col-md-5"><span class="required"> * </span>早高峰发车间隔　:</label>
  290 + <div class="col-md-3" style="padding-right: 0px;">
  291 + <input type="text" class="form-control" name="zgffcjxmin" value="{{map.zgffcjxmin}}" id="zgffcjxmin_id"
  292 + placeholder="最小间隔">
  293 + </div>
  294 + <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
  295 + <div class="col-md-3" style="padding-left: 0px;">
  296 + <input type="text" class="form-control" name="zgffcjxmax" value="{{map.zgffcjxmax}}" id="zgffcjxmax_id"
  297 + placeholder="最大间隔">
  298 + </div>
  299 + </div>
  300 + <div class="col-md-6">
  301 + <label class="control-label col-md-5"><span class="required"> * </span>晚高峰发车间隔　:</label>
  302 + <div class="col-md-3" style="padding-right: 0px;">
  303 + <input type="text" class="form-control" name="wffcjxmin" value="{{map.wffcjxmin}}" id="wffcjxmin_id"
  304 + placeholder="最小间隔">
  305 + </div>
  306 + <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
  307 + <div class="col-md-3" style="padding-left: 0px;">
  308 + <input type="text" class="form-control" name="wffcjxmax" value="{{map.wffcjxmax}}" id="wffcjxmax_id"
  309 + placeholder="最大间隔">
  310 + </div>
  311 + </div>
  312 + </div>
  313 +
  314 + <div class="form-group">
  315 + <div class="col-md-6">
  316 + <label class="control-label col-md-5"><span class="required"> * </span>低谷发车间隔　:</label>
  317 + <div class="col-md-3" style="padding-right: 0px;">
  318 + <input type="text" class="form-control" name="dgfcjxmin" value="{{map.dgfcjxmin}}" id="dgfcjxmin_id"
  319 + placeholder="最小间隔">
  320 + </div>
  321 + <div class="col-md-1" style="padding-top: 10px; font-size: 85%;">至</div>
  322 + <div class="col-md-3" style="padding-left: 0px;">
  323 + <input type="text" class="form-control" name="dgfcjxmax" value="{{map.dgfcjxmax}}" id="dgfcjxmax_id"
  324 + placeholder="最大间隔">
  325 + </div>
  326 + </div>
  327 + <div class="col-md-6">
  328 + <label class="control-label col-md-5"><span class="required"> * </span>建议加班路牌数　:</label>
  329 + <div class="col-md-5">
  330 + <input type="text" class="form-control" name="jbclcount" value="{{map.jbclcount}}" id="jbclcount_id"
  331 + placeholder="为0表示是周末时刻表">
  332 + </div>
  333 + </div>
  334 + </div>
  335 +
  336 + <div class="form-group">
  337 + <div class="col-md-6">
  338 + <label class="control-label col-md-5"><span class="required"> * </span>停站类型　:</label>
  339 + <div class="col-md-5 tagsDiv">
  340 + <div class="row" style="margin-left: 15px;">
  341 + <input type="text" value="{{map.stt}}" name="stt" id="stoptype_tagsinput" style="display: none;">
  342 + </div>
  343 +
  344 + <div class="row" style="margin-top: 10px;">
  345 + <label class="control-label col-md-4">停站类型:</label>
  346 + <div class="col-md-8">
  347 + <select name="stopType" class="form-control" id="stopType_id">
  348 + <option value="">-- 请选择停站类型 --</option>
  349 + <option value="0">主站停站</option>
  350 + <option value="1">双向停站</option>
  351 + </select>
  352 + </div>
  353 + </div>
  354 +
  355 + <div class="row" style="margin-top: 10px;">
  356 + <label class="control-label col-md-4">主站:</label>
  357 + <div class="col-md-8">
  358 + <select name="masterStop" class="form-control" id="masterStop_id">
  359 + <option value="">请选择...</option>
  360 + <option value="0">{{map.startStationName}}</option>
  361 + <option value="1">{{map.endStationName}}</option>
  362 + </select>
  363 + </div>
  364 + </div>
  365 +
  366 + <div class="row" style="margin-top: 10px;margin-left: 116px;">
  367 + <a href="javascript:" class="btn red" id="stoptype_tagsinput_add">添加</a>
  368 + </div>
  369 + </div>
  370 +
  371 + </div>
  372 +
  373 + <div class="col-md-6">
  374 + <div class="form-group">
  375 + <label class="control-label col-md-5">
  376 + <span class="required"> * </span> 建议高峰配车数　:</label>
  377 + <div class="col-md-5">
  378 + <input type="text" class="form-control" placeholder="车辆数" name="gfjypcs"
  379 + id="gfjypcsInput" min="1" value="{{map.gfjypcs}}">
  380 + </div>
  381 + </div>
  382 + <div class="form-group">
  383 + <label class="control-label col-md-5">
  384 + <span class="required"> * </span> 生成策略　　:
  385 + </label>
  386 + <div class="col-md-5">
  387 + <select name="strategy" class="form-control" id="strategy_id">
  388 + <option value="AdjustTripS1" selected>AdjustTripS1</option>
  389 + <option value="AdjustTripS2" disabled>AdjustTripS2</option>
  390 + <option value="AdjustTripS3">AdjustTripS3</option>
  391 + <option value="AdjustTripS4">AdjustTripS4</option>
  392 + </select>
  393 + </div>
  394 + </div>
  395 + </div>
  396 +
  397 +
  398 + </div>
  399 +
  400 +
  401 + <!-- 隐藏字段-时间 -->
  402 + <input type="hidden" name="skbName" value="{{map.skbName}}" id="skbName_id"/>
  403 + <input type="hidden" name="skbmc" value="{{map.skbmc}}" id="skbmc_id"/>
  404 + <input type="hidden" name="xlmc" value="{{map.xlmc}}" id="xlmc_id"/>
  405 + <input type="hidden" name="lineName" value="{{map.lineName}}" id="lineName_id"/>
  406 + <input type="hidden" name="lineVersion" value="{{map.lineVersion}}" id="lineVersion_id"/>
  407 +
  408 + <!-- 上下行行驶时间 -->
  409 + <input type="hidden" name="upTravelTime" value="{{map.upTravelTime}}" id="upTravelTime_id"/>
  410 + <input type="hidden" name="downTravelTime" value="{{map.downTravelTime}}" id="downTravelTime_id"/>
  411 +
  412 + <!-- 隐藏字段-里程 -->
  413 + <!-- 上下行行驶里程 -->
  414 + <input type="hidden" name="upMileage" value="{{map.upMileage}}" id="upMileage_id"/>
  415 + <input type="hidden" name="downMileage" value="{{map.downMileage}}" id="downMileage_id"/>
  416 + <!-- 上下行进场出场里程 -->
  417 + <input type="hidden" name="upInMileage" value="{{map.upInMileage}}" id="upInMileage_id"/>
  418 + <input type="hidden" name="downInMileage" value="{{map.downInMileage}}" id="downInMileage_id"/>
  419 + <input type="hidden" name="upOutMileage" value="{{map.upOutMileage}}" id="upOutMileage_id"/>
  420 + <input type="hidden" name="downOutMileage" value="{{map.downOutMileage}}" id="downOutMileage_id"/>
  421 +
  422 +
  423 +</script>
  424 +
  425 +<script type="text/javascript">
  426 + $('#paramadd_mobal').on('paramAddMobal.show', function(e, mainFun){
  427 +
  428 + var _mainFun = mainFun;
  429 +
  430 + // 加载延迟200毫秒显示mobal
  431 + setTimeout(function(){$('#paramadd_mobal').modal({show : true,backdrop: 'static', keyboard: false});},200);
  432 + var param = JSON.parse(window.localStorage.Gantt_AgursData);
  433 +
  434 + // 获取表单元素
  435 + var form = $('#param_form');
  436 + // 错误提示元素
  437 + var paramAlert = $('.alert-danger', form);
  438 + // 确定事件点击
  439 + $('#paramnext').on('click', function() {
  440 + $("#paramcancel").addClass("disabled");
  441 + $("#paramnext").addClass("disabled");
  442 + $(".paramnextSpan").html("正在生成...");
  443 +
  444 + setTimeout(function() {
  445 + form.submit();// 表单提交
  446 + }, 500);
  447 +
  448 + // $("#paramnext").removeClass("disabled");
  449 + // $("#paramnext").html("确定");
  450 + });
  451 +
  452 + // 表单验证
  453 + form.validate({
  454 + errorElement : 'span',
  455 + errorClass : 'help-block help-block-error',
  456 + focusInvalid : false,
  457 + rules: {
  458 + 'skbName' : {required : true,},// 时刻表名称,必填项.
  459 + 'lineName' : {required : true,},// 线路名称,必填项.
  460 + 'lineVersion': {required: true}, // 站点路由版本，必填项，
  461 + 'startStationFirstTime' : {required : true}, // 起始站首班时间,必填项.
  462 + 'startStationEndTime' : {required : true}, // 起始站末班时间 ,必填项.
  463 + 'endStationFirstTime' : {required : true}, // 终点站首班时间 ,必填项.
  464 + 'endStationEndTime' : {required : true}, // 终点站末班时间,必填项.
  465 + 'earlyStartTime' : {required : true},// 早高峰开始时间,必填项 .
  466 + 'earlyEndTime' : {required : true},// 早高峰结束时间,必填项 .
  467 + 'lateStartTime' : {required : true},// 晚高峰开始时间,必填项 .
  468 + 'lateEndTime' : {required : true},// 晚高峰结束时间,必填项.
  469 + 'upInTimer' : {number : true},// 上行进场时间,必须为数字.
  470 + 'upOutTimer' : {number : true},// 上行出场时间,必须为数字.
  471 + 'downInTimer' : {number : true},// 下行进场时间,必须为数字.
  472 + 'downOutTimer' : {number : true},// 下行出场时间,必须为数字.
  473 + 'earlyUpTime' : {number : true},// 早高峰上行时间,必须为数字.
  474 + 'earlyDownTime' : {number : true},// 早高峰下行时间,必须为数字.
  475 + 'lateUpTime' : {number : true},// 晚高峰上行时间,必须为数字.
  476 + 'lateDownTime' : {number : true},// 晚高峰下行时间,必须为数字.
  477 + 'troughUpTime' : {number : true},// 低谷上行时间,必须为数字.
  478 + 'troughDownTime' : {number : true},// 低谷下行时间,必须为数字.
  479 + 'linePlayType' : {required : true},// 线路规划类型,必填项
  480 + 'lb' : {number : true},// 早晚例行保养,必须为数字.
  481 + 'workeLunch' : {number : true},// 工作餐午餐时间,必须为数字.
  482 + 'workeDinner' : {number : true},// 工作餐晚餐时间,必须为数字.
  483 + 'zgffcjxmin' : {required : true,number : true,digits: true},// 早高峰最小发车间隔.
  484 + 'zgffcjxmax' : {required : true,number : true,digits: true},// 早高峰最大发车间隔.
  485 + 'wffcjxmin' : {required : true,number : true,digits: true},// 晚高峰最小发车间隔.
  486 + 'wffcjxmax' : {required : true,number : true,digits: true},// 晚高峰最大发车间隔.
  487 + 'dgfcjxmin' : {required : true,number : true,digits: true},// 低谷最小发车间隔.
  488 + 'dgfcjxmax' : {required : true,number : true,digits: true},// 低谷最大发车间隔.
  489 + 'jbclcount': {required : true,number : true,digits: true}, // 建议加班车数
  490 + 'upTravelTime' : {required : true,number : true},// 上行行驶时间,必填项、必须为整数.
  491 + 'downTravelTime' : {required : true,number : true},// 下行行驶时间,必填项、必须为整数.
  492 + 'upMileage' : {required : true,number : true},// 上行行驶里程,必填项、必须为整数.
  493 + 'downMileage' : {required : true,number : true},// 下行行驶里程,必填项、必须为整数.
  494 + 'upInMileage' : {number : true},// 上行进场里程,必须为数字.
  495 + 'upOutMileage' : {number : true},// 上行出场里程,必须为数字.
  496 + 'downInMileage' : {number : true},// 下行进场里程,必须为数字.
  497 + 'downOutMileage' : {number : true}, // 下行出场里程,必须为数字.
  498 +
  499 + 'strategy' : {required : true} // 生成策略标识
  500 +
  501 + // TODO
  502 + },
  503 + invalidHandler : function(event, validator) {
  504 + paramAlert.show();
  505 + App.scrollTo(paramAlert, -200);
  506 + },
  507 + highlight : function(element) {
  508 + $(element).closest('.form-group').addClass('has-error');
  509 + },
  510 + unhighlight : function(element) {
  511 + $(element).closest('.form-group').removeClass('has-error');
  512 + },
  513 + success : function(label) {
  514 + label.closest('.form-group').removeClass('has-error');
  515 + },
  516 + submitHandler : function(f) {
  517 + // 1、 获取表单内容,并序列化
  518 + var fp = form.serializeJSON();
  519 +
  520 + console.log(fp);
  521 +
  522 + // 2、重新刷新表单数据
  523 + var ganttMap = JSON.parse(window.localStorage.Gantt_AgursData);
  524 + var key;
  525 + for (key in fp) {
  526 + if (ganttMap[key]) {
  527 + if (ganttMap[key] != fp[key]) {
  528 + ganttMap[key] = fp[key];
  529 + }
  530 + } else {
  531 + ganttMap[key] = fp[key];
  532 + }
  533 + }
  534 + window.localStorage.setItem("Gantt_AgursData",JSON.stringify(ganttMap));
  535 +
  536 + // TODO
  537 + var pp = getParamObjAndDataMap();
  538 + var paramObj = pp[0];
  539 + var dataMap = pp[1];
  540 + var csMap = getCSMap(paramObj);
  541 + // console.log(graph);
  542 +
  543 + var data = _mainFun.BXPplaceClassesTime03(paramObj, csMap.maxCar);
  544 + _mainFun.exportDataConfig(data.aInternalLpObj);
  545 +
  546 + // var data = obj.getDataArray();
  547 + // // 2、 调整路牌对应的班次总数
  548 + // updFormParams(params,data);
  549 + // 删除图形.
  550 + $('svg.svg-chart').remove();
  551 + // 重新创建图形.
  552 + var graph = d3.select('#ganttSvg').relationshipGraph(getGraphArgus(csMap, dataMap, data));
  553 + // 根据数据重新渲染图形.
  554 + graph.data(data.json);
  555 + // 记录早操.并保存历史班次数据
  556 + graph.addHistory();
  557 + // 隐藏错误提示
  558 + paramAlert.hide();
  559 + // 隐藏 reladplus_mobal 弹出层
  560 + $('#paramadd_mobal').modal('hide');
  561 + layer.msg('成功!');
  562 + }
  563 + });
  564 +
  565 +
  566 + // 当模态框对用户可见时触发（将等待 CSS 过渡效果完成）。
  567 + $('#paramadd_mobal').on('show.bs.modal', function () {
  568 + // TODO
  569 + // 把数据填充到模版中
  570 + // var tbodyHtml = template('countAdd_temp',{list:countDate});
  571 + // // 把渲染好的模版html文本追加到表格中
  572 + // $('#datatable_countadd tbody').html(tbodyHtml);
  573 + var htmldata = template('paramAdd_temp', {map : param});
  574 + $('#ptab').html(htmldata);
  575 +
  576 + // 线路规划类型
  577 + $('#linePlayType_id').val(param.linePlayType);
  578 + // 策略类型
  579 + $('#strategy_id').val(param.strategy || "AdjustTripS1");
  580 + // 吃饭地点
  581 + $get('/stationroute/all', {
  582 + 'line.id_eq': param.lineName.split('_')[0],
  583 + 'destroy_eq': 0,
  584 + 'versions_eq': param.lineVersion},
  585 + function(result) {
  586 + var opt = [];
  587 + opt.push('<option value="">请选择...</option>');
  588 + $.each(result, function(i, d) {
  589 + if (d.stationMark == 'B' && d.directions == 0) {
  590 + opt.push("<option value='0'>" + d.stationName + "</option>");
  591 + } else if (d.stationMark == 'E' && d.directions == 0) {
  592 + opt.push("<option value='1'>" + d.stationName + "</option>");
  593 + }
  594 + });
  595 + initTagsinput(opt.join(","));
  596 +
  597 + opt.push("<option value='allYes'>起终点站都可以</option>");
  598 + $('#cfdd_id').html(opt.join(""));
  599 + $('#cfdd_id').val(param.cfdd);
  600 +
  601 + }
  602 + );
  603 + // 停车场
  604 + $get('/carpark/all',null, function(cd) {
  605 + var opt = [];
  606 + opt.push('<option value="">请选择...</option><optgroup label="停车场">');
  607 + var $_len = cd.length;
  608 + if($_len > 0) {
  609 + $.each(cd, function(i, d){
  610 + opt.push('<option value="'+d.parkCode+'">'+d.parkName+'</option>');
  611 + });
  612 + }
  613 + opt.push('</optgroup>');
  614 + $('#carPark_id').html(opt.join(",")).select2();
  615 + $('#carPark_id').select2("val", param.carPark);
  616 + });
  617 +
  618 + // 上下行首末班日期控件
  619 + $('#startStationFirstTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  620 + $('#startStationEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  621 + $('#endStationFirstTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  622 + $('#endStationEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  623 +
  624 + // 早高峰晚高峰日期控件
  625 + $('#earlyStartTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  626 + $('#earlyEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  627 + $('#lateStartTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  628 + $('#lateEndTime_id').datetimepicker({format : 'HH:mm',locale: 'zh-cn'});
  629 +
  630 + });
  631 +
  632 +
  633 +
  634 + //--------------------- 其他方法 ------------------------//
  635 +
  636 + function initTagsinput(htmlStr) {
  637 + $('#masterStop_id').html(htmlStr);
  638 +
  639 + var elt = $('#stoptype_tagsinput');
  640 + var value = elt.val();
  641 + var stoptype = value.split("/")[0];
  642 + var masterstop = value.split("/")[1];
  643 +
  644 + $('#stopType_id').val(stoptype);
  645 + $('#masterStop_id').val(masterstop);
  646 +
  647 + elt.tagsinput({
  648 + tagClass: function(item) {
  649 + return 'label label-danger label-important';
  650 + },
  651 + itemValue: 'value',
  652 + itemText: 'text'
  653 + });
  654 +
  655 + $('#stoptype_tagsinput').on('beforeItemAdd', function(event) {
  656 + // TODO：这里可以做一些逻辑判定
  657 + });
  658 +
  659 + $('#stoptype_tagsinput_add').on('click', function(){
  660 + var stoptype = $("#stopType_id").val();
  661 + var masterstop = $("#masterStop_id").val();
  662 + var masterstop_text = $("#masterStop_id option:selected").text();
  663 +
  664 + if (stoptype && stoptype != "") {
  665 + if (stoptype == "0" && masterstop && masterstop != "") {
  666 + elt.tagsinput('add', {
  667 + "value": stoptype + '/' + masterstop,
  668 + "text": "主站停站" + "/" + masterstop_text
  669 + });
  670 + } else {
  671 + elt.tagsinput('add', {
  672 + "value": 1,
  673 + "text": "双向停站"
  674 + });
  675 + }
  676 + }
  677 + });
  678 +
  679 + if (stoptype && stoptype != "") {
  680 + elt.tagsinput('add', {
  681 + "value": stoptype + '/' + masterstop,
  682 + "text":
  683 + $("#stopType_id option:selected").text() + "/" +
  684 + $("#masterStop_id option:selected").text()
  685 + });
  686 + }
  687 +
  688 + }
  689 +
  690 + function getMinDate(d1,d2) {
  691 + // 1、定义返回字符串.
  692 + var str = '';
  693 + // 2、判断时间大小.
  694 + if(strToTime(d1)>strToTime(d2))
  695 + str = d2;
  696 + else
  697 + str = d1;
  698 + // 3、返回最小时间(字符串).
  699 + return str;
  700 + }
  701 +
  702 + function strToTime(t) {
  703 + var d = new Date();
  704 + if(t) {
  705 + var _str = t.split(':');
  706 + d.setHours(parseInt(_str[0]));
  707 + d.setMinutes(parseInt(_str[1]));
  708 + }
  709 + return d;
  710 + }
  711 +
  712 + function getMaxDate(d1,d2) {
  713 + // 1、定义返回时间字符串.
  714 + var str = '';
  715 + // 2、判断时间大小.
  716 + if(strToTime(d1)>strToTime(d2))
  717 + str = d1;
  718 + else
  719 + str = d2;
  720 + // 3、返回一个最大时间(字符串).
  721 + return str;
  722 + }
  723 +
  724 + function getEndDate(date) {
  725 + var lastEndDate = Date.now();
  726 + if (date) {
  727 + var str = date.replace(/-/g,"/");
  728 + lastEndDate = new Date(str);
  729 + }
  730 + // Wed Oct 26 2016 00:00:00 GMT+0800 (中国标准时间)
  731 + return lastEndDate;
  732 + }
  733 +
  734 + function formatPairing(v1,v2) {
  735 + v1 = v1 == '' ? 0 : parseInt(v1);
  736 + v2 = v2 == ''? 0 : parseInt(v2) ;
  737 + return [v1,v2];
  738 + }
  739 +
  740 + function qzdz(zd1,zd2) {
  741 + return [zd1,zd2];
  742 + }
  743 +
  744 + function formatksjssj(gp) {
  745 + return [{'kssj':gp.startStationFirstTime,'jssj':gp.startStationEndTime},{'kssj':gp.endStationFirstTime,'jssj':gp.endStationEndTime}];
  746 + }
  747 +
  748 + function getsd(st,ed) {
  749 + return [{'st':st,'ed':ed}];
  750 + }
  751 +
  752 + function getDateTime(time) {
  753 + var dateTime = new Date();
  754 + var timeArr;
  755 + if(time !=null && time !='' && typeof(time) !='undefined') {
  756 + timeArr = time.split(':');
  757 + dateTime.setHours(parseInt(timeArr[0]));
  758 + dateTime.setMinutes(parseInt(timeArr[1]));
  759 + }
  760 + return dateTime;
  761 + }
  762 +
  763 + function getYAxisCarArray(len) {
  764 + var array = new Array();
  765 + if(len>0) {
  766 + for(var y = 0; y<len; y++) {
  767 + array.push({lp:null,lpNo:y+1, parent :y+1, lpName:y+1,lpType:'普通路牌'});//添加一个路牌对象
  768 + };
  769 + }
  770 + return array;
  771 + }
  772 +
  773 + function getylp(arr) {
  774 + var ra = new Array(),name = new Array();
  775 + for(var i = 0 ; i<arr.length;i++) {
  776 + ra.push(arr[i].lpNo);
  777 + name.push(arr[i].lpName);
  778 + }
  779 + return {'lpNoA':ra,'lpNameA':name,};
  780 + }
  781 +
  782 + function getParamObjAndDataMap() {
  783 + var map = JSON.parse(window.localStorage.Gantt_AgursData);
  784 + // seMap
  785 + var seMap = {'s': map.linePlayType == '1' ? map.startStationFirstTime : getMinDate(map.startStationFirstTime,map.endStationFirstTime),
  786 + 'e': map.linePlayType == '1' ? map.startStationEndTime : getMaxDate(map.startStationEndTime,map.endStationEndTime)};
  787 + // dirA
  788 + var dirA = ['relationshipGraph-up', 'relationshipGraph-down'];
  789 + // bcTypeArr
  790 + var bcTypeArr = {
  791 + 'bd': 'bd', 'out': 'out', 'normal': 'normal', 'cf': 'cf', 'in_': 'in', 'lc': 'lc',
  792 + 'major': 'major', 'venting': 'venting', 'region': 'region'
  793 + };
  794 + // seDate
  795 + var newDate = new Date();
  796 + var kssj = d3.time.hour.offset(getEndDate(
  797 + newDate.getFullYear()+ "-" +
  798 + (newDate.getMonth()+1) + "-" +
  799 + newDate.getDate() + ' ' +
  800 + seMap.s.split(':')[0] + ':00'),-1);
  801 +
  802 + var year = '' , month = '',dt = '';
  803 + if(newDate.getDate()+1>31)
  804 + dt = '01';
  805 + else
  806 + dt = newDate.getDate()+1;
  807 + if(newDate.getMonth()+1>12)
  808 + month = '01';
  809 + else if(newDate.getDate()+1>31)
  810 + month = newDate.getMonth()+2;
  811 + else
  812 + month = newDate.getMonth()+1;
  813 + if(newDate.getMonth()+1>12)
  814 + year = newDate.getFullYear()+1;
  815 + else
  816 + year = newDate.getFullYear();
  817 + var jssj = getEndDate(year + '-' + month + '-' + dt + ' ' + '00:00');
  818 + seDate = {'kssj' : kssj, 'jssj' : jssj};
  819 +
  820 + // dataMap
  821 + var dataMap = {'jcsjArr' : formatPairing(map.upInTimer,map.downInTimer),// 进场里程。[下标0代表上；下标1代表下]
  822 + 'ccsjArr' : formatPairing(map.upOutTimer,map.downOutTimer),// 出场时间。[下标0代表上；下标1代表下]
  823 + 'jclcArr' : formatPairing(map.upInMileage,map.downInMileage),// 进场里程。[下标0代表上；下标1代表下]
  824 + 'cclcArr' : formatPairing(map.upOutMileage,map.downOutMileage),// 出场里程。[下标0代表上；下标1代表下]
  825 + 'pcxssjArr' : formatPairing(map.upTravelTime,map.downTravelTime),// 平常行驶时间。[下标0代表上；下标1代表下]
  826 + 'gfxxsjArr' : formatPairing(map.lateUpTime=='' ? map.upTravelTime : map.lateUpTime,
  827 + map.lateDownTime=='' ? map.downTravelTime : map.lateDownTime),// 高峰行驶时间。[下标0代表上；下标1代表下]
  828 + 'dgxxsjArr' : formatPairing(map.troughUpTime=='' ? map.upTravelTime : map.troughUpTime,
  829 + map.troughDownTime=='' ? map.downTravelTime : map.troughDownTime),// 低谷行驶时间。[下标0代表上；下标1代表下]
  830 + 'pcxslcArr' : formatPairing(map.upMileage,map.downMileage),// 行驶里程。[下标0代表上；下标1代表下]
  831 + 'qdzArr' : qzdz(map.up_s.split('_')[0],map.down_s.split('_')[0]),// 起始站。[下标0代表上；下标1代表下]
  832 + 'zdzArr':qzdz(map.up_s.split('_')[1],map.down_s.split('_')[1]),// 终点站。[下标0代表上；下标1代表下]
  833 + 'zwcArr' : formatPairing(map.workeLunch,map.workeDinner),// 午晚餐时间。[下标0代表午；下标1代表晚]
  834 + 'smbcsjArr' : formatksjssj(map), // 起终点站首末班车时间.[下标0代表起始站的首末班车时间；下标1代表终点站的首末班车时间]
  835 + 'zgfsjd' : getsd(getDateTime(map.earlyStartTime),
  836 + getDateTime(map.earlyEndTime)), // 早高峰时间段
  837 + 'wgfsjd' : getsd(getDateTime(map.lateStartTime),
  838 + getDateTime(map.lateEndTime)),// 晚高峰时间段
  839 + 'gfzjsjd' : getsd(getDateTime(map.earlyEndTime),
  840 + getDateTime(map.lateStartTime)),//高峰之间时间段.
  841 + 'wgfzhsjd' : getsd(getDateTime(map.lateEndTime),
  842 + getDateTime(seMap.e)),// 晚高峰之后时间段
  843 + 'zgfzqsjd': getsd(getDateTime(seMap.s),
  844 + getDateTime(map.earlyStartTime)),//早高峰之前时间段.
  845 + 'dira' : dirA,// 方向集合 [下标0代表上；下标1代表下]
  846 + 'bcTypeArr' : bcTypeArr,// 班次类型
  847 + 'lbsj' : map.lb=='' ? 0:parseInt(map.lb),// 例保时间.
  848 + // 'minztjx' : parseInt(gatps.mixstopTime), // 最小停站时间.
  849 + // 'ztjxA' : BaseFun.formatPairing(gatps.upStopTime,gatps.downStopTime), // 停站时间.
  850 + // 'maxztjx' : parseInt(gatps.maxstopTime), // 最大停站时间.
  851 + 'gftzsj': formatPairing(map.gfupStopTime,map.gfdownStopTime),// 高峰停站时间.
  852 + 'dgtzsj' : formatPairing(map.dgupStopTime,map.dgdownStopTime),// 低谷停站时间.
  853 + 'dgmaxtzsj' : parseInt(map.dgmaxtzsj),// 低谷最大停站时间.
  854 + 'dgmaxfcjx' : parseInt(map.dgmaxfcjx),// 低谷最大发车间隙.
  855 + 'map' : map,
  856 + 'zzsj':map.zzsj,// 周转时间.
  857 + };
  858 +
  859 + var _paramObj = _mainFun.getFactory().createParameterObj(map, dataMap);
  860 + map.clzs = _paramObj.calcuClzx();
  861 + return [_paramObj, dataMap];
  862 +
  863 + }
  864 +
  865 + function getCSMap(parmObj) {
  866 + var map = JSON.parse(window.localStorage.Gantt_AgursData);
  867 + return {'gattA':null,
  868 + 'fcjx': {'gffcjx': Math.round(parmObj.calcuPeakZzsj()/parmObj.calcuClzx()) ,
  869 + 'dgfcjx': Math.round(parmObj.calcuTroughZzsj()/parmObj.calcuClzx()),
  870 + 'dgmaxfcjx' : parseInt(map.dgmaxfcjx)},
  871 + 'maxCar':getYAxisCarArray(parseInt(parmObj.calcuClzx()))};
  872 + }
  873 +
  874 + function getGraphArgus(CSMap, dataMap, data) {
  875 + // TODO
  876 + var map = JSON.parse(window.localStorage.Gantt_AgursData);
  877 + var sxsj = parseInt(map.upTravelTime);// 上行时间.
  878 +
  879 + // seMap
  880 + var seMap = {'s': map.linePlayType == '1' ? map.startStationFirstTime : getMinDate(map.startStationFirstTime,map.endStationFirstTime),
  881 + 'e': map.linePlayType == '1' ? map.startStationEndTime : getMaxDate(map.startStationEndTime,map.endStationEndTime)};
  882 +
  883 + // seDate
  884 + var newDate = new Date();
  885 + var kssj = d3.time.hour.offset(getEndDate(
  886 + newDate.getFullYear()+ "-" +
  887 + (newDate.getMonth()+1) + "-" +
  888 + newDate.getDate() + ' ' +
  889 + seMap.s.split(':')[0] + ':00'),-1);
  890 +
  891 + var year = '' , month = '',dt = '';
  892 + if(newDate.getDate()+1>31)
  893 + dt = '01';
  894 + else
  895 + dt = newDate.getDate()+1;
  896 + if(newDate.getMonth()+1>12)
  897 + month = '01';
  898 + else if(newDate.getDate()+1>31)
  899 + month = newDate.getMonth()+2;
  900 + else
  901 + month = newDate.getMonth()+1;
  902 + if(newDate.getMonth()+1>12)
  903 + year = newDate.getFullYear()+1;
  904 + else
  905 + year = newDate.getFullYear();
  906 + var jssj = getEndDate(year + '-' + month + '-' + dt + ' ' + '00:00');
  907 + seDate = {'kssj' : kssj, 'jssj' : jssj};
  908 +
  909 +
  910 + var bs = sxsj > 40 ? 4 : 2;
  911 + var MULTIPLE = Math.round(105/sxsj) >3 ? Math.round(90/sxsj) : Math.round(90/sxsj) *bs;
  912 + var VALUEKEYNAME = 'Worldwide Gross' ,
  913 + DXHOURS = 24,MINUTE = 60,WIDTH = DXHOURS*MINUTE,MARGINLEFT = 380,HEIGHT = CSMap.maxCar.length*60 + 240,
  914 + MARGINBOTTOM = 240,OFFSETX = 90,OFFSETY = 180,OFFSETUPY = 120,OFFSETDOWNY = 60,
  915 + STARTDATETIME = seDate.kssj ,ENDDATETIME = seDate.jssj ,TASKTYPES =CSMap.maxCar ,TICKFORMAT ='%H:%M' ,SHOWTOOLTIPS = true;
  916 + var dx_time = seDate.jssj.getTime() - seDate.kssj.getTime() ;
  917 + // 计算出相差天数
  918 + var days=Math.floor(dx_time/(24*3600*1000));
  919 + // 计算出小时数
  920 + var leave1=dx_time%(24*3600*1000); //计算天数后剩余的毫秒数
  921 + var hours=Math.floor(leave1/(3600*1000));
  922 + DXHOURS = days*24+hours;
  923 + WIDTH = DXHOURS*MINUTE*MULTIPLE;
  924 + // debugger;
  925 + var lpsplitA = getylp(CSMap.maxCar);
  926 +
  927 + var sxsj = parseInt(map.upTravelTime);// 上行时间.
  928 + var xxsj = parseInt(map.downTravelTime);// 下行时间.
  929 + var stopAraay = [{
  930 + 'sxsj':sxsj,// 上行时间.
  931 + 'xxsj':xxsj,// 下行时间.
  932 + 'zzsj':map.zzsj,// 周转时间.
  933 + 'wcsj':parseInt(map.workeLunch),// 午餐时间.
  934 + 'wcsj':parseInt(map.workeDinner),// 晚餐时间.
  935 + 'zgfsxsj':map.earlyUpTime==''? sxsj : parseInt(map.earlyUpTime),// 早高峰上行行驶时间.
  936 + 'zgfxxsj':map.earlyDownTime=='' ? xxsj : parseInt(map.earlyDownTime),// 早高峰下行行驶时间.
  937 + 'wgfsxsj':map.lateUpTime=='' ? sxsj : parseInt(map.lateUpTime),// 晚高峰上行行驶时间.
  938 + 'wgfxxsj':map.lateDownTime== '' ? xxsj: parseInt(map.lateDownTime),// 晚高峰下行行驶时间.
  939 + 'sxjcsj':map.upInTimer == '' ? 0 : parseInt(map.upInTimer),// 上行进场时间.
  940 + 'sxccsj':map.upOutTimer == '' ? 0 : parseInt(map.upOutTimer),// 上行出场时间.
  941 + 'xxjcsj':map.downInTimer =='' ? 0 : parseInt(map.downInTimer),// 下行进场时间.
  942 + 'xxccsj':map.downOutTimer =='' ? 0 : parseInt(map.downOutTimer),// 下行进场时间.
  943 + 'sxjclc':map.upInMileage==''? 0 : parseInt(map.upInMileage),// 上行进场里程.
  944 + 'sxcclc':map.upOutMileage==''? 0:parseInt(map.upOutMileage),// 上行出场里程.
  945 + 'xxjclc':map.downInMileage==''? 0 : parseInt(map.downInMileage),// 下行进场里程.
  946 + 'xxcclc':map.downOutMileage==''?0:parseInt(map.downOutMileage),// 下行出场里程.
  947 + 'lbsj': map.lb==''? 0 : parseInt(map.lb) // 例保时间.
  948 + }];
  949 +
  950 + var args = {
  951 + 'valueKeyName': VALUEKEYNAME,
  952 + 'hours' : DXHOURS,
  953 + 'dxHours' : 24 - DXHOURS,
  954 + 'multiple': MULTIPLE,
  955 + 'width':WIDTH,
  956 + 'widtMargin':MARGINLEFT,
  957 + 'height':HEIGHT,
  958 + 'heightMargin':MARGINBOTTOM,
  959 + 'offsetX':OFFSETX,
  960 + 'offsetY':OFFSETY,
  961 + 'downDy':OFFSETDOWNY,
  962 + 'upDy':OFFSETUPY,
  963 + 'timeDomainStart' :STARTDATETIME,
  964 + 'timeDomainEnd' : ENDDATETIME,
  965 + 'startStr':'' + STARTDATETIME,
  966 + 'endStr': '' +ENDDATETIME,
  967 + 'taskTypes': TASKTYPES,
  968 + 'lpNoA':lpsplitA.lpNoA,
  969 + 'lpNameA':lpsplitA.lpNameA,
  970 + 'tickFormat': TICKFORMAT,
  971 + 'stopAraay' : stopAraay,
  972 + 'dataMap':dataMap,
  973 + 'showTooltips': SHOWTOOLTIPS,
  974 + 'bxrcgs':data.bxrcgs
  975 + };
  976 + return args;
  977 + }
  978 +
  979 +
  980 +
  981 + });
  982 +
937 983 </script>
938 984 \ No newline at end of file
... ...