潘钊 / bsth_control · Commits

Commit e16f191f4c47cf5d75f24bc31c292abe35fb8187

Authored by 徐烜
1 parent fc3393ec

timetable v2 update1

Inline Side-by-side
Showing 15 changed files with 2491 additions and 31 deletions
src/main/resources/static/index.html
  View file @e16f191
... ... @@ -61,9 +61,9 @@
61 61 href="/metronic_v4.5.4/plugins/bootstrap-datetimepicker-2/css/bootstrap-datetimepicker.min.css"
62 62 rel="stylesheet" type="text/css" />
63 63 <!-- table 表格控件 -->
64   -<link rel="stylesheet"
65   - href="http://api.map.baidu.com/library/DrawingManager/1.4/src/DrawingManager_min.css"
66   - type="text/css" />
  64 +<!--<link rel="stylesheet"-->
  65 + <!--href="http://api.map.baidu.com/library/DrawingManager/1.4/src/DrawingManager_min.css"-->
  66 + <!--type="text/css" />-->
67 67 <link href="/metronic_v4.5.4/plugins/bootstrap-tagsinput/bootstrap-tagsinput.css" rel="stylesheet" type="text/css"/>
68 68 <!-- handsontable样式 -->
69 69 <link rel="stylesheet"
... ... @@ -612,24 +612,24 @@ tr.row-active td {
612 612  
613 613 <!-- 地图相关 -->
614 614 <!-- 百度 -->
615   - <script
616   - src="http://api.map.baidu.com/api?v=2.0&ak=IGGrr4UjwIYzatoCRFKEL8sT"
617   - data-exclude=1></script>
618   - <script
619   - src="http://api.map.baidu.com/library/TrafficControl/1.4/src/TrafficControl_min.js"
620   - data-exclude=1></script>
621   - <script type="text/javascript"
622   - src="http://api.map.baidu.com/library/DrawingManager/1.4/src/DrawingManager_min.js"
623   - data-exclude=1></script>
624   - <script type="text/javascript"
625   - src="http://api.map.baidu.com/library/RichMarker/1.2/src/RichMarker_min.js "
626   - data-exclude=1></script>
  615 + <!--<script-->
  616 + <!--src="http://api.map.baidu.com/api?v=2.0&ak=IGGrr4UjwIYzatoCRFKEL8sT"-->
  617 + <!--data-exclude=1></script>-->
  618 + <!--<script-->
  619 + <!--src="http://api.map.baidu.com/library/TrafficControl/1.4/src/TrafficControl_min.js"-->
  620 + <!--data-exclude=1></script>-->
  621 + <!--<script type="text/javascript"-->
  622 + <!--src="http://api.map.baidu.com/library/DrawingManager/1.4/src/DrawingManager_min.js"-->
  623 + <!--data-exclude=1></script>-->
  624 + <!--<script type="text/javascript"-->
  625 + <!--src="http://api.map.baidu.com/library/RichMarker/1.2/src/RichMarker_min.js "-->
  626 + <!--data-exclude=1></script>-->
627 627 <script src="/assets/js/baidu/TextIconOverlay.js" data-exclude=1></script>
628 628 <script src="/assets/js/baidu//MarkerClusterer.js" data-exclude=1></script>
629 629 <!-- 高德 -->
630   - <script
631   - src="http://webapi.amap.com/maps?v=1.3&key=16cb1c5043847e09ef9edafdd77befda"
632   - data-exclude=1></script>
  630 + <!--<script-->
  631 + <!--src="http://webapi.amap.com/maps?v=1.3&key=16cb1c5043847e09ef9edafdd77befda"-->
  632 + <!--data-exclude=1></script>-->
633 633  
634 634 <script src="/real_control_v2/assets/plugins/perfect-scrollbar/perfect-scrollbar.jquery.js" merge="plugins"></script>
635 635  
... ...
src/main/resources/static/pages/base/timesmodel/gantt.html
  View file @e16f191
... ... @@ -119,10 +119,12 @@
119 119 <script src="/pages/base/timesmodel/js/raty/lib/jquery.raty.js"></script>
120 120 <script src="/pages/base/timesmodel/js/ContextJS/js/context.js"></script>
121 121 <script src="/pages/base/timesmodel/js/base-fun.js"></script>
122   -<script src="/pages/base/timesmodel/js/strategy/StrategyUtils.js"></script>
123   -<script src="/pages/base/timesmodel/js/strategy/BcObj.js"></script>
124   -<script src="/pages/base/timesmodel/js/strategy/ParameterObj.js"></script>
125   -<script src="/pages/base/timesmodel/js/strategy/strategy-headway.js"></script>
  122 +<script src="/pages/base/timesmodel/js/v2/ParameterObj.js"></script>
  123 +<script src="/pages/base/timesmodel/js/v2/core/InternalBcObj.js"></script>
  124 +<script src="/pages/base/timesmodel/js/v2/core/InternalGroupBcObj.js"></script>
  125 +<script src="/pages/base/timesmodel/js/v2/core/InternalLpObj.js"></script>
  126 +<script src="/pages/base/timesmodel/js/v2/core/InternalScheduleObj.js"></script>
  127 +<script src="/pages/base/timesmodel/js/v2/main_v2.js"></script>
126 128 <script src="/pages/base/timesmodel/js/d3.relationshipgraph.js"></script>
127 129 <script src="/pages/base/timesmodel/js/errorinfo.js"></script>
128 130 <script src="/pages/base/timesmodel/js/gantt.js"></script>
129 131 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/d3.relationshipgraph.js
  View file @e16f191
... ... @@ -400,7 +400,7 @@ $(&#39;.editlp&#39;).on(&#39;click&#39;,function() {
400 400 {'name':'营运班次总时间(包括正常、区间、放大站且班次时间大于零)','value':parseFloat((servicesj/60).toFixed(2)) + ' 小时'},
401 401 {'name':'总工时(包括进出场、吃饭时间、早晚例保、营运班次时间)','value': parseFloat((countGs/60).toFixed(2)) + ' 小时'},
402 402 {'name':'空驶班次(包括直放班次)','value':ksBc},
403   - {'name':'营运里程(包括正常、区间、放大站里程)','value':serviceLc + ' 公里'},
  403 + {'name':'营运里程(包括正常、区间、放大站里程)','value':Number(serviceLc).toFixed(3) + ' 公里'},
404 404 {'name':'空驶里程(包括直放里程)','value':ksLc + ' 公里'},
405 405 {'name':'平均停站时间(营运班次停站时间总和/营运总班次)','value':parseInt(avgTzjx) + ' 分钟' },
406 406 {'name':'高峰营运班次(包括早晚高峰时段的正常、区间、放大站班次)','value':gfServiceBc},
... ...
src/main/resources/static/pages/base/timesmodel/js/gantt.js
  View file @e16f191
... ... @@ -62,9 +62,8 @@
62 62 map.fcjx = CSMap.fcjx;
63 63 }else if (map.baseRes == '2') {
64 64 // TODO：之后可能有新的参数加入
65   - _paramObj = StrategyUtils.getFactory().createParameterObj(map, dataMap);
66   -
67   - map.clzs = StrategyUtils.calcuClzx(_paramObj);
  65 + _paramObj = Main_v2.getFactory().createParameterObj(map, dataMap);
  66 + map.clzs = _paramObj.calcuClzx();
68 67 CSMap = getMaxCarAndStopSpace1(map);
69 68  
70 69 }
... ... @@ -84,7 +83,7 @@
84 83 // TODO：绘制gantt图表
85 84 // TODO：var seDate = getksjssj(null,seMap.s); 关联参数必须设置
86 85 // TODO：CSMap.maxCar 之后要设定一下的
87   - data = StrategyHeadway.BXPplaceClassesTime03(_paramObj, CSMap.maxCar);
  86 + data = Main_v2.BXPplaceClassesTime03(_paramObj, CSMap.maxCar);
88 87 }
89 88  
90 89 }else {
... ...
src/main/resources/static/pages/base/timesmodel/js/strategy/BcObjMatrix.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 班次对象矩阵（二维数组）。
  3 + * @param paramObj 参数对象
  4 + * @constructor
  5 + */
  6 +var BcObjMatrix = function(paramObj) {
  7 + // 内部参数
  8 + var _paramObj = paramObj;
  9 +
  10 + var lpObj = function() { // 路牌对象
  11 + return {
  12 + bxType: 6, // 班型描述，默认做5休2
  13 + qArray: [] // 圈对象数组，一圈二个班次
  14 + };
  15 + }
  16 +};
0 17 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/strategy/RelatedObjes.js 0 → 100644
  View file @e16f191
  1 +// 相关的内部对象
  2 +/**
  3 + * 班次类型对象（最后转换成显示用bc对象）
  4 + * @param bcType 班次类型（normal，in，out等）
  5 + * @param isUp boolean 是否上行
  6 + * @param lp 路牌编号
  7 + * @param fcno 发车编号
  8 + * @param fcTimeObj 发车时间对象
  9 + * @param paramObj 参数对象
  10 + * @returns 班次对象
  11 + */
  12 +var BcObj = function(bcType, isUp, lp, fcno, fcTimeObj, paramObj) {
  13 +
  14 + //---------- 内部属性 ----------//
  15 + var _bcType = bcType; // 班次类型（normal，in，out等）
  16 + var _isUp = isUp; // true表示上行，false表示下行
  17 + var _lp = lp; // 路牌
  18 + var _fcno = fcno; // 发车顺序号
  19 +
  20 + // 计算的属性，TODO：还有其他属性
  21 + // 上标线里属于第几圈（本班次方向和标线方向一致，才有意义）
  22 + var qCount;
  23 +
  24 + // 班次里程
  25 + var _bclc = StrategyUtils.calcuTravelLcNumber(_isUp, _bcType, paramObj);
  26 + // 发车时间
  27 + var _fcsjObj = moment(fcTimeObj);
  28 + // 班次时间
  29 + var _bcsj = StrategyUtils.calcuTravelTime(_fcsjObj, _isUp, paramObj);
  30 + // 到达时间
  31 + var _arrsj = StrategyUtils.addMinute(_fcsjObj, _bcsj);
  32 + // 到达后的停站时间（使用到达时间判定）
  33 + var _stopTime = StrategyUtils.calcuFixedStopNumber(_arrsj, !_isUp, paramObj);
  34 +
  35 + return {
  36 + /**
  37 + * 是否上行。
  38 + * @returns boolean
  39 + */
  40 + isUp: function() {
  41 + return _isUp;
  42 + },
  43 + /**
  44 + * 获取发车时间。
  45 + * @returns {*|moment.Moment}
  46 + */
  47 + getFcTimeObj: function() {
  48 + return _fcsjObj;
  49 + },
  50 + /**
  51 + * 获取班次时间。
  52 + */
  53 + getBcTime: function() {
  54 + return _bcsj;
  55 + },
  56 + /**
  57 + * 获取停站时间。
  58 + * @returns {*}
  59 + */
  60 + getStopTime: function() {
  61 + return _stopTime;
  62 + },
  63 +
  64 + /**
  65 + * 转换成显示用班次对象。
  66 + */
  67 + toGanttBcObj: function() {
  68 + var _bcObj = {
  69 + parent: _lp,
  70 + lpNo: _lp,
  71 + lp: null,
  72 + lpName: _lp,
  73 + lpType: '普通路牌',
  74 + bcType: _bcType,
  75 + fcno: _fcno,
  76 + isfb: 0,
  77 + isSwitchXl: null,
  78 + bz: null
  79 + };
  80 +
  81 + // 线路上下行
  82 + _bcObj.xlDir = _isUp ? "relationshipGraph-up" : "relationshipGraph-down";
  83 +
  84 + // 里程
  85 + _bcObj.jhlc = _bclc;
  86 +
  87 + // 停车场
  88 + _bcObj.tcc = paramObj.getTccId();
  89 +
  90 + // 时刻表
  91 + _bcObj.ttinfo = paramObj.getTTinfoId();
  92 +
  93 + // 线路
  94 + _bcObj.xl = paramObj.getXlId();
  95 +
  96 + // 起点站、终点站
  97 + _bcObj.qdz = _isUp ? paramObj.getUpQdzObj().id : paramObj.getDownQdzObj().id;
  98 + _bcObj.zdz = _isUp ? paramObj.getUpZdzObj().id : paramObj.getDownZdzObj().id;
  99 +
  100 + // 发车时间，行驶时间，到达时间，停站时间
  101 + _bcObj.fcsj = _fcsjObj.format("HH:mm");
  102 + _bcObj.bcsj = _bcsj;
  103 + _bcObj.ARRIVALTIME = _arrsj.format("HH:mm");
  104 + _bcObj.STOPTIME = _stopTime;
  105 +
  106 + return _bcObj;
  107 + }
  108 + };
  109 +};
0 110 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/strategy/StrategyUtils.js
  View file @e16f191
... ... @@ -39,7 +39,32 @@ var StrategyUtils = function() {
39 39 },
40 40 // 创建班次对象
41 41 createBcObj: function(bcType, isUp, lp, fcno, fcTimeObj, paramObj) {
42   - return BcObj(bcType, isUp, lp, fcno, fcTimeObj, paramObj);
  42 + var _bclc = StrategyUtils.calcuTravelLcNumber(isUp, bcType, paramObj);
  43 + var _bcsj = StrategyUtils.calcuTravelTime(fcTimeObj, isUp, paramObj);
  44 + var _arrsj = StrategyUtils.addMinute(fcTimeObj, _bcsj);
  45 + var _stoptime = StrategyUtils.calcuFixedStopNumber(_arrsj, !isUp, paramObj);
  46 + var _tccid = paramObj.getTTinfoId();
  47 + var _ttinfoid = paramObj.getTTinfoId();
  48 + var _xl = paramObj.getXlId();
  49 + var _qdz = isUp ? paramObj.getUpQdzObj().id : paramObj.getDownQdzObj().id;
  50 + var _zdz = isUp ? paramObj.getUpZdzObj().id : paramObj.getDownZdzObj().id;
  51 +
  52 + return new InternalBcObj(
  53 + bcType, // 班次类型（normal，in，out等）
  54 + isUp, // boolean是否上下行
  55 + lp, // 路牌标识符
  56 + fcno, // 发车顺序号
  57 + fcTimeObj, // 发车时间对象
  58 + _bclc, // 班次里程
  59 + _bcsj, // 班次历时
  60 + _arrsj, // 到达时间对象
  61 + _stoptime, // 停站时间
  62 + _tccid, // 停车场id
  63 + _ttinfoid, // 时刻表id
  64 + _xl, // 线路id
  65 + _qdz, // 起点站id
  66 + _zdz // 终点站id
  67 + );
43 68 }
44 69 };
45 70 };
... ...
src/main/resources/static/pages/base/timesmodel/js/strategy/core/InternalBcObj.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 内部班次对象。
  3 + * @constructor
  4 + */
  5 +var InternalBcObj = function(
  6 + bcType, // 班次类型（normal，in，out等）
  7 + isUp, // boolean是否上下行
  8 + lp, // 路牌标识符
  9 + fcno, // 发车顺序号
  10 + fcTimeObj, // 发车时间对象
  11 + bclc, // 班次里程
  12 + bcsj, // 班次历时
  13 + arrtime, // 到达时间对象
  14 + stoptime, // 停站时间
  15 + tccid, // 停车场id
  16 + ttinfoid, // 时刻表id
  17 + xl, // 线路id
  18 + qdzid, // 起点站id
  19 + zdzid // 终点站id
  20 +) {
  21 + // 属性重新复制一遍，加前缀 _$_ 表示内部属性，不要直接访问k
  22 + // 外部函数使用 prototype 方式
  23 + this._$_bcType = bcType;
  24 + this._$_isUp = isUp;
  25 + this._$_lp = lp;
  26 + this._$_fcno = fcno;
  27 + this._$_fcsjObj = moment(fcTimeObj);
  28 + this._$_bclc = bclc;
  29 + this._$_bcsj = bcsj;
  30 + this._$_arrtime = arrtime;
  31 + this._$_stoptime = stoptime;
  32 + this._$_tccid = tccid;
  33 + this._$_ttinfoid = ttinfoid;
  34 + this._$_xlid = xl;
  35 + this._$_qdzid = qdzid;
  36 + this._$_zdzid = zdzid;
  37 +
  38 +};
  39 +
  40 +/**
  41 + * 是否上行。
  42 + * @returns boolean
  43 + */
  44 +InternalBcObj.prototype.isUp = function() {
  45 + return this._$_isUp;
  46 +};
  47 +/**
  48 + * 获取发车时间。
  49 + * @returns {*|moment.Moment}
  50 + */
  51 +InternalBcObj.prototype.getFcTimeObj = function() {
  52 + return this._$_fcsjObj;
  53 +};
  54 +/**
  55 + * 获取班次时间。
  56 + * @returns int
  57 + */
  58 +InternalBcObj.prototype.getBcTime = function() {
  59 + return this._$_bcsj;
  60 +};
  61 +/**
  62 + * 获取停站时间。
  63 + * @returns int
  64 + */
  65 +InternalBcObj.prototype.getStopTime = function() {
  66 + return this._$_stoptime;
  67 +};
  68 +/**
  69 + * 转换成显示用班次对象。
  70 + * @returns {{}}
  71 + */
  72 +InternalBcObj.prototype.toGanttBcObj = function() {
  73 + var _bcObj = {
  74 + parent: this._$_lp,
  75 + lpNo: this._$_lp,
  76 + lp: null,
  77 + lpName: this._$_lp,
  78 + lpType: '普通路牌',
  79 + bcType: this._$_bcType,
  80 + fcno: this._$_fcno,
  81 + isfb: 0,
  82 + isSwitchXl: null,
  83 + bz: null
  84 + };
  85 +
  86 + // 线路上下行
  87 + _bcObj.xlDir = this._$_isUp ? "relationshipGraph-up" : "relationshipGraph-down";
  88 +
  89 + // 里程
  90 + _bcObj.jhlc = this._$_bclc;
  91 +
  92 + // 停车场
  93 + _bcObj.tcc = this._$_tccid;
  94 +
  95 + // 时刻表
  96 + _bcObj.ttinfo = this._$_ttinfoid;
  97 +
  98 + // 线路
  99 + _bcObj.xl = this._$_xlid;
  100 +
  101 + // 起点站、终点站
  102 + _bcObj.qdz = this._$_qdzid;
  103 + _bcObj.zdz = this._$_zdzid;
  104 +
  105 + // 发车时间，行驶时间，到达时间，停站时间
  106 + _bcObj.fcsj = this._$_fcsjObj.format("HH:mm");
  107 + _bcObj.bcsj = this._$_bcsj;
  108 + _bcObj.ARRIVALTIME = this._$_arrtime;
  109 + _bcObj.STOPTIME = this._$_stoptime;
  110 +
  111 + return _bcObj;
  112 +};
  113 +
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/ParameterObj.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 参数对象。
  3 + *
  4 + * @constructor
  5 + */
  6 +var ParameterObj = function() {
  7 + // 内部保存的form参数及其他参数
  8 + var _formMap;
  9 + var _dataMap;
  10 + var _validInternal = function() {
  11 + if (!_formMap) {
  12 + alert("formMap为空！");
  13 + throw "formMap为空！";
  14 + }
  15 + if (!_dataMap) {
  16 + alert("dataMap为空！");
  17 + throw "dataMap为空！";
  18 + }
  19 + };
  20 +
  21 + // 计算行驶时间对象
  22 + var _travelTimeObj_fun = function() {
  23 + var upMoningPeakTravelTime =
  24 + isNaN(_formMap.earlyUpTime) || parseInt(_formMap.earlyUpTime) == 0 ?
  25 + parseInt(_formMap.upTravelTime) :
  26 + parseInt(_formMap.earlyUpTime);
  27 + var downMoningPeakTravelTime =
  28 + isNaN(_formMap.earlyDownTime) || parseInt(_formMap.earlyDownTime) == 0 ?
  29 + parseInt(_formMap.downTravelTime) :
  30 + parseInt(_formMap.earlyDownTime);
  31 + var upEveningPeakTravelTime =
  32 + isNaN(_formMap.lateUpTime) || parseInt(_formMap.lateUpTime) == 0 ?
  33 + parseInt(_formMap.upTravelTime) :
  34 + parseInt(_formMap.lateUpTime);
  35 + var downEveningPeakTravelTime =
  36 + isNaN(_formMap.lateDownTime) || parseInt(_formMap.lateDownTime) == 0 ?
  37 + parseInt(_formMap.downTravelTime) :
  38 + parseInt(_formMap.lateDownTime);
  39 + var upTroughTravelTime =
  40 + isNaN(_formMap.troughUpTime) || parseInt(_formMap.troughUpTime) == 0 ?
  41 + parseInt(_formMap.upTravelTime) :
  42 + parseInt(_formMap.troughUpTime);
  43 + var downTroughTravelTime =
  44 + isNaN(_formMap.troughDownTime) || parseInt(_formMap.troughDownTime) == 0 ?
  45 + parseInt(_formMap.downTravelTime) :
  46 + parseInt(_formMap.troughDownTime);
  47 +
  48 + return { // TODO：暂时获取标准信息，之后改成历史数据，可能需要使用promise封装
  49 + "moningpeak": [
  50 + upMoningPeakTravelTime,
  51 + downMoningPeakTravelTime
  52 + ],
  53 + "eveningpeak": [
  54 + upEveningPeakTravelTime,
  55 + downEveningPeakTravelTime
  56 + ],
  57 + "trough": [
  58 + upTroughTravelTime,
  59 + downTroughTravelTime
  60 + ]
  61 + }
  62 + };
  63 + var _travelTimeObj;
  64 +
  65 + // 计算行驶里程对象
  66 + var _travelLcObj_fun = function() {
  67 + return [
  68 + { // 上行里程
  69 + "normalLc": isNaN(_formMap.upMileage) ? 0 : parseFloat(_formMap.upMileage),
  70 + "inLc": isNaN(_formMap.upInMileage) ? 0 : parseFloat(_formMap.upInMileage),
  71 + "outLc": isNaN(_formMap.upOutMileage) ? 0 : parseFloat(_formMap.upOutMileage)
  72 + },
  73 + { // 下行里程
  74 + "normalLc": isNaN(_formMap.downMileage) ? 0 : parseFloat(_formMap.downMileage),
  75 + "inLc": isNaN(_formMap.downInMileage) ? 0 : parseFloat(_formMap.downInMileage),
  76 + "outLc": isNaN(_formMap.downOutMileage) ? 0 : parseFloat(_formMap.downOutMileage)
  77 + }
  78 + ];
  79 + };
  80 + var _travelLcObj;
  81 +
  82 + // 计算首班车，末班车行驶时间字符串
  83 + var _firstLastDepartureTimeStrObj_fun = function() {
  84 + return {
  85 + up: { // 上行
  86 + firstVehicleDepartureTimeStr: _formMap.startStationFirstTime,
  87 + lastVehicleDepartureTimeStr: _formMap.startStationEndTime
  88 + },
  89 + down: { // 下行
  90 + firstVehicleDepartureTimeStr: _formMap.endStationFirstTime,
  91 + lastVehicleDepartureTimeStr: _formMap.endStationEndTime
  92 + }
  93 + };
  94 + };
  95 + var _firstLastDepartureTimeStrObj;
  96 +
  97 + // 计算时间段划分对象
  98 + var _timeIntervalObj_fun = function() {
  99 + return {
  100 + moningPeakTimeStrs: {
  101 + start: _formMap.earlyStartTime,
  102 + end: _formMap.earlyEndTime
  103 + },
  104 + eveningPeakTimeStrs: {
  105 + start: _formMap.lateStartTime,
  106 + end: _formMap.lateEndTime
  107 + }
  108 +
  109 + // TODO：其他时间段以后再加
  110 + };
  111 + };
  112 + var _timeIntervalObj;
  113 +
  114 + // 计算各个时段的发车间隙
  115 + var _fcjxIntervalObj_fun = function() {
  116 + var _rtn = {
  117 + mpeakfcjx : {}, // 早高峰
  118 + epeakfcjx : {}, // 晚高峰
  119 + troughfcjx: {} //低谷
  120 + };
  121 + var _fcjx = [];
  122 + var i = 0;
  123 +
  124 + // TODO：这里只有3个间隔，以后加其他的
  125 + // 1、早高峰间隙
  126 + // 2、晚高峰间隙
  127 + // 3、低谷
  128 +
  129 + _rtn.mpeakfcjx.min = parseInt(_formMap.zgffcjxmin);
  130 + _rtn.mpeakfcjx.max = parseInt(_formMap.zgffcjxmax);
  131 +
  132 + _rtn.epeakfcjx.min = parseInt(_formMap.wffcjxmin);
  133 + _rtn.epeakfcjx.max = parseInt(_formMap.wffcjxmax);
  134 +
  135 + _rtn.troughfcjx.min = parseInt(_formMap.dgfcjxmin);
  136 + _rtn.troughfcjx.max = parseInt(_formMap.dgfcjxmax);
  137 +
  138 + // 做一些逻辑检查
  139 + if (_rtn.mpeakfcjx.min > _rtn.mpeakfcjx.max) {
  140 + alert("早高峰最小间隔大于最大间隔");
  141 + throw "早高峰最小间隔大于最大间隔";
  142 + }
  143 + if (_rtn.epeakfcjx.min > _rtn.epeakfcjx.max) {
  144 + alert("晚高峰最小间隔大于最大间隔");
  145 + throw "晚高峰最小间隔大于最大间隔";
  146 + }
  147 + if (_rtn.troughfcjx.min > _rtn.troughfcjx.max) {
  148 + alert("低谷最小间隔大于最大间隔");
  149 + throw "低谷最小间隔大于最大间隔";
  150 + }
  151 +
  152 +
  153 + return _rtn;
  154 + };
  155 + var _fcjxIntervalObj;
  156 +
  157 + // 获取停站类型
  158 + var _stopTypeObj_fun = function() {
  159 + var isMasterStop = false; // 是否主站停
  160 + var isMasterUpStop = false; // 主站停是否上行站点
  161 + if (_formMap) {
  162 + var fm_temp = _formMap.stt.split("/");
  163 + if (fm_temp.length == 1) { // 双向停站
  164 + isMasterStop = false;
  165 + } else {
  166 + isMasterStop = true;
  167 + if (fm_temp[1] == "0") {
  168 + isMasterUpStop = true;
  169 + } else {
  170 + isMasterUpStop = false;
  171 + }
  172 + }
  173 + } else {
  174 + throw "停站类型没有选择！";
  175 + }
  176 +
  177 + return {
  178 + isMasterStop: isMasterStop,
  179 + isMasterUpStop: isMasterUpStop
  180 + }
  181 + };
  182 + var _stopTypeObj;
  183 +
  184 + // 计算线路对象
  185 + var _xlObj_fun = function() {
  186 + return { // TODO：其他属性再议
  187 + xl: {
  188 + id: _formMap.lineName.split('_')[0]
  189 + }
  190 + };
  191 + };
  192 + var _xlObj;
  193 +
  194 + // 计算停车场对象
  195 + var _parkObj_fun = function() {
  196 + return { // TODO：其他属性再议
  197 + park: {
  198 + id: _formMap.tcc_id
  199 + }
  200 + };
  201 + };
  202 + var _parkObj;
  203 +
  204 + // 计算时刻表对象
  205 + var _ttInfoObj_fun = function() {
  206 + return { // TODO：其他属性再议
  207 + ttinfo: {
  208 + id: _formMap.skbName
  209 + }
  210 + };
  211 + };
  212 + var _ttInfoObj;
  213 +
  214 + // 计算起点站终点站对象
  215 + var _startEndStopObj_fun = function() {
  216 + return { // TODO：其他属性再议
  217 + up: {
  218 + qdz: { // 起点站
  219 + id: _dataMap.qdzArr[0]
  220 + },
  221 + zdz: { // 终点站
  222 + id: _dataMap.zdzArr[0]
  223 + }
  224 + },
  225 + down: {
  226 + qdz: { // 起点站
  227 + id: _dataMap.qdzArr[1]
  228 + },
  229 + zdz: { // 终点站
  230 + id: _dataMap.zdzArr[1]
  231 + }
  232 + }
  233 +
  234 + };
  235 + };
  236 + var _startEndStopObj;
  237 +
  238 + var date_wrap_prefix = "2000-01-01 "; // 包装日期的前缀
  239 + var date_wrap_format = "YYYY-MM-DD HH:mm"; // 日期格式
  240 + /**
  241 + * 将时间包装成日期，方便计算。
  242 + * @param timeStr 时间格式，如 06:30
  243 + * @returns moment对象
  244 + */
  245 + var _wrapTimeFun = function(timeStr) {
  246 + return moment(
  247 + date_wrap_prefix + timeStr,
  248 + date_wrap_format
  249 + );
  250 + };
  251 + /**
  252 + * 添加时间（注意，返回一个新的moment对象，此方法是immutable）
  253 + * @param timeObj moment 对象
  254 + * @param time 时间
  255 + * @param type 时间单位
  256 + * @returns 重新创建一个moment返回
  257 + */
  258 + var _addTimeFun = function(timeObj, time, type) {
  259 + var _timeObj = moment(timeObj); // clone
  260 + _timeObj.add(time, type);
  261 + return _timeObj;
  262 + };
  263 +
  264 + return {
  265 +
  266 + /**
  267 + * 包装外部参数。
  268 + * @param formMap
  269 + * @param dataMap
  270 + */
  271 + wrap: function(formMap, dataMap) {
  272 + _formMap = formMap;
  273 + _dataMap = dataMap;
  274 +
  275 + _validInternal(); // 验证
  276 +
  277 + // 首班车，末班车行驶时间字符串
  278 + _firstLastDepartureTimeStrObj = _firstLastDepartureTimeStrObj_fun();
  279 + // 行驶时间对象
  280 + _travelTimeObj = _travelTimeObj_fun();
  281 + // 行驶里程对象
  282 + _travelLcObj = _travelLcObj_fun();
  283 + // 时间段划分对象
  284 + _timeIntervalObj = _timeIntervalObj_fun();
  285 + // 各个时段的发车间隙
  286 + _fcjxIntervalObj = _fcjxIntervalObj_fun();
  287 + // 停站类型
  288 + _stopTypeObj = _stopTypeObj_fun();
  289 + // 线路对象
  290 + _xlObj = _xlObj_fun();
  291 + // 停车场对象
  292 + _parkObj = _parkObj_fun();
  293 + // 时刻表对象
  294 + _ttInfoObj = _ttInfoObj_fun();
  295 + // 起点站终点站对象
  296 + _startEndStopObj = _startEndStopObj_fun();
  297 +
  298 + // TODO：其他再议
  299 +
  300 + },
  301 +
  302 + //------------ 获取首班末班时间 ------------//
  303 + /**
  304 + * 获取上行首班时间对象。
  305 + * @param sobj 策略对象（HeadwayObj）
  306 + * @return moment obj
  307 + */
  308 + getUpFirstDTimeObj: function() {
  309 + _validInternal(); // 验证
  310 + return this.toTimeObj(
  311 + _firstLastDepartureTimeStrObj.up.firstVehicleDepartureTimeStr
  312 + );
  313 + },
  314 + /**
  315 + * 获取上行末班时间对象。
  316 + * @return moment obj
  317 + */
  318 + getUpLastDtimeObj: function() {
  319 + _validInternal(); // 验证
  320 + return this.toTimeObj(
  321 + _firstLastDepartureTimeStrObj.up.lastVehicleDepartureTimeStr
  322 + );
  323 + },
  324 + /**
  325 + * 获取下行首班时间对象。
  326 + * @return moment obj
  327 + */
  328 + getDownFirstDTimeObj: function() {
  329 + _validInternal(); // 验证
  330 + return this.toTimeObj(
  331 + _firstLastDepartureTimeStrObj.down.firstVehicleDepartureTimeStr
  332 + );
  333 + },
  334 + /**
  335 + * 获取下行末班时间对象。
  336 + * @return moment obj
  337 + */
  338 + getDownLastDTimeObj: function() {
  339 + _validInternal(); // 验证
  340 + return this.toTimeObj(
  341 + _firstLastDepartureTimeStrObj.down.lastVehicleDepartureTimeStr
  342 + );
  343 + },
  344 +
  345 + //-------------- 获取行驶时间 ----------------//
  346 + /**
  347 + * 获取上行早高峰行驶时间。
  348 + * @returns int number
  349 + */
  350 + getUpMPeakTime: function() {
  351 + _validInternal(); // 验证
  352 + return _travelTimeObj.moningpeak[0];
  353 + },
  354 + /**
  355 + * 获取上行晚高峰行驶时间。
  356 + * @returns int number
  357 + */
  358 + getUpEPeakTime: function() {
  359 + _validInternal(); // 验证
  360 + return _travelTimeObj.eveningpeak[0];
  361 + },
  362 + /**
  363 + * 获取上行低谷行驶时间。
  364 + * @returns int number
  365 + */
  366 + getUpTroughTime: function() {
  367 + _validInternal(); // 验证
  368 + return _travelTimeObj.trough[0];
  369 + },
  370 + /**
  371 + * 获取下行早高峰行驶时间。
  372 + * @returns int number
  373 + */
  374 + getDownMPeakTime: function() {
  375 + _validInternal(); // 验证
  376 + return _travelTimeObj.moningpeak[1];
  377 + },
  378 + /**
  379 + * 获取下行晚高峰行驶时间。
  380 + * @returns int number
  381 + */
  382 + getDownEPeakTime: function() {
  383 + _validInternal(); // 验证
  384 + return _travelTimeObj.eveningpeak[1];
  385 + },
  386 + /**
  387 + * 获取下行低谷行驶时间。
  388 + * @returns int number
  389 + */
  390 + getDownTroughTime: function() {
  391 + _validInternal(); // 验证
  392 + return _travelTimeObj.trough[1];
  393 + },
  394 +
  395 + //---------------- 获取行驶里程 -----------------//
  396 + /**
  397 + * 获取上行normal班次里程。
  398 + * @returns number
  399 + */
  400 + getUpNormalLc: function() {
  401 + _validInternal(); // 验证
  402 + return _travelLcObj[0].normalLc;
  403 + },
  404 + /**
  405 + * 获取上行进场班次类型。
  406 + * @returns number
  407 + */
  408 + getUpInLc: function() {
  409 + _validInternal(); // 验证
  410 + return _travelLcObj[0].inLc;
  411 + },
  412 + /**
  413 + * 获取上行出场班次类型。
  414 + * @returns number
  415 + */
  416 + getUpOutLc: function() {
  417 + _validInternal(); // 验证
  418 + return _travelLcObj[0].outLc;
  419 + },
  420 + /**
  421 + * 获取下行normal班次类型。
  422 + * @returns number
  423 + */
  424 + getDownNormalLc: function() {
  425 + _validInternal(); // 验证
  426 + return _travelLcObj[1].normalLc;
  427 + },
  428 + /**
  429 + * 获取下行进场班次类型。
  430 + * @returns number
  431 + */
  432 + getDownInLc: function() {
  433 + _validInternal(); // 验证
  434 + return _travelLcObj[1].inLc;
  435 + },
  436 + /**
  437 + * 获取下行出场班次类型。
  438 + * @returns number
  439 + */
  440 + getDownOutLc: function() {
  441 + _validInternal(); // 验证
  442 + return _travelLcObj[1].outLc;
  443 + },
  444 +
  445 + //---------------- 获取时间段信息 --------------//
  446 + /**
  447 + * 获取早高峰开始时间对象。
  448 + * @returns moment obj
  449 + */
  450 + getMPeakStartTimeObj: function() {
  451 + _validInternal(); // 验证
  452 + return this.toTimeObj(
  453 + _timeIntervalObj.moningPeakTimeStrs.start
  454 + );
  455 + },
  456 + /**
  457 + * 获取早高峰结束时间对象。
  458 + * @returns moment obj
  459 + */
  460 + getMPeakEndTimeObj: function() {
  461 + _validInternal(); // 验证
  462 + return this.toTimeObj(
  463 + _timeIntervalObj.moningPeakTimeStrs.end
  464 + );
  465 + },
  466 + /**
  467 + * 获取晚高峰开始时间对象。
  468 + * @returns moment obj
  469 + */
  470 + getEPeakStartTimeObj: function() {
  471 + _validInternal(); // 验证
  472 + return this.toTimeObj(
  473 + _timeIntervalObj.eveningPeakTimeStrs.start
  474 + );
  475 + },
  476 + /**
  477 + * 获取晚高峰结束时间对象。
  478 + * @returns moment obj
  479 + */
  480 + getEPeakEndTimeObj: function() {
  481 + _validInternal(); // 验证
  482 + return this.toTimeObj(
  483 + _timeIntervalObj.eveningPeakTimeStrs.end
  484 + );
  485 + },
  486 +
  487 + //----------------- 获取发车间隙（TODO：以后通过客流估算）-----------------//
  488 + /**
  489 + * 获取早高峰最小发车间隙。
  490 + * @returns int
  491 + */
  492 + getMPeakMinFcjx: function() {
  493 + _validInternal(); // 验证
  494 + return _fcjxIntervalObj.mpeakfcjx.min;
  495 + },
  496 + /**
  497 + * 获取早高峰最大发车间隙。
  498 + * @returns int
  499 + */
  500 + getMPeakMaxFcjx: function() {
  501 + _validInternal(); // 验证
  502 + return _fcjxIntervalObj.mpeakfcjx.max;
  503 + },
  504 + /**
  505 + * 获取晚高峰最小发车间隙。
  506 + * @returns int
  507 + */
  508 + getEPeakMinFcjx: function() {
  509 + _validInternal(); // 验证
  510 + return _fcjxIntervalObj.epeakfcjx.min;
  511 + },
  512 + /**
  513 + * 获取晚高峰最小发车间隙。
  514 + * @returns int
  515 + */
  516 + getEPeakMaxFcjx: function() {
  517 + _validInternal(); // 验证
  518 + return _fcjxIntervalObj.epeakfcjx.max;
  519 + },
  520 + /**
  521 + * 获取低谷最小发车间隙。
  522 + * @returns int
  523 + */
  524 + getTroughMinFcjx: function() {
  525 + _validInternal(); // 验证
  526 + return _fcjxIntervalObj.troughfcjx.min;
  527 + },
  528 + /**
  529 + * 获取低谷最大发车间隙。
  530 + * @returns int
  531 + */
  532 + getTroughMaxFcjx: function() {
  533 + _validInternal(); // 验证
  534 + return _fcjxIntervalObj.troughfcjx.max;
  535 + },
  536 +
  537 + //----------------- 获取停站方式 -------------------//
  538 + /**
  539 + * 是否双向停站。
  540 + * @returns {boolean}
  541 + */
  542 + isTwoWayStop: function() {
  543 + _validInternal(); // 验证
  544 + return !_stopTypeObj.isMasterStop;
  545 + },
  546 + /**
  547 + * 是否上行单向停站。
  548 + * @returns {boolean}
  549 + */
  550 + isUpOneWayStop: function() {
  551 + _validInternal(); // 验证
  552 + return _stopTypeObj.isMasterStop && _stopTypeObj.isMasterUpStop;
  553 + },
  554 + /**
  555 + * 是否下行单向停站。
  556 + * @returns {boolean}
  557 + */
  558 + isDownOneWayStop: function() {
  559 + _validInternal(); // 验证
  560 + return _stopTypeObj.isMasterStop && (!_stopTypeObj.isMasterUpStop);
  561 + },
  562 +
  563 + //----------------- 获取高峰配车数、加班路牌数 ----------------//
  564 + /**
  565 + * 获取高峰建议配车数（TODO：参照一下）。
  566 + * @returns {Number|*}
  567 + */
  568 + getAdvicePeakClzs: function() {
  569 + _validInternal(); // 验证
  570 + return parseInt(_formMap.gfjypcs);
  571 + },
  572 + /**
  573 + * 获取加班路牌数（5休2路牌的个数）。
  574 + * @returns {Number|*}
  575 + */
  576 + getJBLpes: function() {
  577 + _validInternal(); // 验证
  578 + return parseInt(_formMap.jbclcount);
  579 + },
  580 +
  581 + //----------------- 获取关联数据信息 -----------------//
  582 + /**
  583 + * 获取线路id。
  584 + */
  585 + getXlId: function() {
  586 + _validInternal(); // 验证
  587 + return _xlObj.xl.id;
  588 + },
  589 + /**
  590 + * 获取停车场id。
  591 + */
  592 + getTccId: function() {
  593 + _validInternal(); // 验证
  594 + return _parkObj.park.id;
  595 + },
  596 + /**
  597 + * 获取时刻表id。
  598 + */
  599 + getTTinfoId: function() {
  600 + _validInternal(); // 验证
  601 + return _ttInfoObj.ttinfo.id;
  602 + },
  603 + /**
  604 + * 获取上行起点站对象。
  605 + * @returns {{id: *}}
  606 + */
  607 + getUpQdzObj: function() {
  608 + _validInternal(); // 验证
  609 + return {
  610 + id: _startEndStopObj.up.qdz.id
  611 + };
  612 + },
  613 + /**
  614 + * 获取上行终点站对象。
  615 + * @returns {{id: *}}
  616 + */
  617 + getUpZdzObj: function() {
  618 + _validInternal(); // 验证
  619 + return {
  620 + id: _startEndStopObj.up.zdz.id
  621 + };
  622 + },
  623 + /**
  624 + * 获取下行起点站对象。
  625 + * @returns {{id: *}}
  626 + */
  627 + getDownQdzObj: function() {
  628 + _validInternal(); // 验证
  629 + return {
  630 + id: _startEndStopObj.down.qdz.id
  631 + };
  632 + },
  633 + /**
  634 + * 获取下行终点站对象。
  635 + * @returns {{id: *}}
  636 + */
  637 + getDownZdzObj: function() {
  638 + _validInternal(); // 验证
  639 + return {
  640 + id: _startEndStopObj.down.zdz.id
  641 + };
  642 + },
  643 +
  644 + //-------------- 时间操作 ------------//
  645 + /**
  646 + * 通过字符串创建时间对象。
  647 + * @param timeStr 时间字符串
  648 + * @returns {moment对象}
  649 + */
  650 + toTimeObj: function(timeStr) {
  651 + _validInternal(); // 验证
  652 + return _wrapTimeFun(timeStr);
  653 + },
  654 + /**
  655 + * 增加分钟。
  656 + * @param timeObj 时间对象
  657 + * @param minute 分钟
  658 + * @returns {重新创建一个moment返回}
  659 + */
  660 + addMinute: function(timeObj, minute) {
  661 + _validInternal(); // 验证
  662 + return _addTimeFun(timeObj, minute, "m");
  663 + },
  664 +
  665 + //-------------- 时间业务操作 ------------//
  666 + /**
  667 + * 判定某个班次是否是早高峰班次。
  668 + * @param timeObj 班次时间
  669 + * @returns true false
  670 + */
  671 + isMPeakBc: function(timeObj) {
  672 + _validInternal(); // 验证
  673 + var paramObj = this;
  674 + // 早高峰开始时间
  675 + var st = paramObj.getMPeakStartTimeObj();
  676 + // 早高峰结束时间
  677 + var et = paramObj.getMPeakEndTimeObj();
  678 + // 包装日期
  679 + return timeObj.isBetween(st, et, null, "[]");
  680 + },
  681 + /**
  682 + * 判定某个班次是否是晚高峰班次。
  683 + * @param timeObj 班次时间
  684 + * @returns true false
  685 + */
  686 + isEPeakBc: function(timeObj) {
  687 + _validInternal(); // 验证
  688 + var paramObj = this;
  689 + // 晚高峰开始时间
  690 + var st = paramObj.getEPeakStartTimeObj();
  691 + // 晚高峰结束时间
  692 + var et = paramObj.getEPeakEndTimeObj();
  693 + // 包装日期
  694 + return timeObj.isBetween(st, et, null, "[]");
  695 + },
  696 + /**
  697 + * 判定某个班次是否是低谷班次。
  698 + * @param timeObj 班次时间
  699 + * @returns true false
  700 + */
  701 + isTroughBc: function(timeObj) {
  702 + _validInternal(); // 验证
  703 + var paramObj = this;
  704 + return (
  705 + !this.isMPeakBc(timeObj) &&
  706 + !this.isEPeakBc(timeObj)
  707 + );
  708 + },
  709 + /**
  710 + * 判定某个低谷班次是否在早高峰开始之前。
  711 + * @param timeObj 班次时间
  712 + * @returns true false
  713 + */
  714 + isTroughBeforMPeakStartBc: function(timeObj) {
  715 + _validInternal(); // 验证
  716 + var paramObj = this;
  717 + // 早高峰开始时间
  718 + var st = paramObj.getMPeakStartTimeObj();
  719 + // 包装日期
  720 + return timeObj.isBefore(st);
  721 + },
  722 + /**
  723 + * 判定某个低谷班次是否在晚高峰结束之后。
  724 + * @param timeObj 班次时间
  725 + * @returns true false
  726 + */
  727 + isTroughAfterEPeakEndBc: function(timeObj) {
  728 + _validInternal(); // 验证
  729 + var paramObj = this;
  730 + // 晚高峰结束时间
  731 + var et = paramObj.getEPeakEndTimeObj();
  732 + // 包装日期
  733 + return timeObj.isAfter(et);
  734 + },
  735 +
  736 + /**
  737 + * 获取固定的停站时间（固定停站时间都是选的最大值）
  738 + * @param timeObj 时间对象
  739 + * @param isUp 是否上行
  740 + * @returns number
  741 + */
  742 + calcuFixedStopNumber: function(timeObj, isUp) {
  743 + _validInternal(); // 验证
  744 + var paramObj = this;
  745 +
  746 + var peakStopTime; // 高峰停站时间
  747 + var troughStopTime; // 低谷停站时间
  748 + var secondaryStopTime; // 副站停站时间
  749 +
  750 + // 双向停站
  751 + if (paramObj.isTwoWayStop()) {
  752 + if (isUp) { // 上行
  753 + if (this.isMPeakBc(timeObj)) { // 早高峰
  754 + peakStopTime = Math.floor(paramObj.getUpMPeakTime() * 0.1); // 行驶时间的10%
  755 + if (peakStopTime < 3) { // 不少于3分钟
  756 + peakStopTime = 3;
  757 + }
  758 + return peakStopTime;
  759 + } else if (this.isEPeakBc(timeObj)) { // 晚高峰
  760 + peakStopTime = Math.floor(paramObj.getUpEPeakTime() * 0.1); // 行驶时间的10%
  761 + if (peakStopTime < 3) { // 不少于3分钟
  762 + peakStopTime = 3;
  763 + }
  764 + return peakStopTime;
  765 + } else { // 低谷
  766 + if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
  767 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
  768 + if (troughStopTime < 10) { // 不少于10分钟
  769 + troughStopTime = 10;
  770 + }
  771 + return troughStopTime;
  772 + } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
  773 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
  774 + if (troughStopTime < 10) { // 不少于10分钟
  775 + troughStopTime = 10;
  776 + }
  777 + return troughStopTime;
  778 + } else { // 早高峰，晚高峰之间
  779 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.15); // 行驶时间15%
  780 + if (troughStopTime < 10) { // 不少于10分钟
  781 + troughStopTime = 10;
  782 + }
  783 + return troughStopTime;
  784 + }
  785 + }
  786 + } else { // 下行
  787 + if (this.isMPeakBc(timeObj)) { // 早高峰
  788 + peakStopTime = Math.floor(paramObj.getDownMPeakTime() * 0.1); // 行驶时间的10%
  789 + if (peakStopTime < 3) { // 不少于3分钟
  790 + peakStopTime = 3;
  791 + }
  792 + return peakStopTime;
  793 + } else if (this.isEPeakBc(timeObj)) { // 晚高峰
  794 + peakStopTime = Math.floor(paramObj.getDownEPeakTime() * 0.1); // 行驶时间的10%
  795 + if (peakStopTime < 3) { // 不少于3分钟
  796 + peakStopTime = 3;
  797 + }
  798 + return peakStopTime;
  799 + } else { // 低谷
  800 + if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
  801 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
  802 + if (troughStopTime < 10) { // 不少于10分钟
  803 + troughStopTime = 10;
  804 + }
  805 + return troughStopTime;
  806 + } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
  807 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
  808 + if (troughStopTime < 10) { // 不少于10分钟
  809 + troughStopTime = 10;
  810 + }
  811 + return troughStopTime;
  812 + } else { // 早高峰，晚高峰之间
  813 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.15); // 行驶时间15%
  814 + if (troughStopTime < 10) { // 不少于10分钟
  815 + troughStopTime = 10;
  816 + }
  817 + return troughStopTime;
  818 + }
  819 + }
  820 + }
  821 + } else { // 主站停站
  822 + if (isUp == paramObj.isUpOneWayStop()) {
  823 + if (isUp) { // 上行
  824 + if (this.isMPeakBc(timeObj)) { // 早高峰
  825 + peakStopTime = Math.floor(paramObj.getUpMPeakTime() * 0.1); // 行驶时间的10%
  826 + if (peakStopTime < 3) { // 不少于3分钟
  827 + peakStopTime = 3;
  828 + }
  829 + return peakStopTime;
  830 + } else if (this.isEPeakBc(timeObj)) { // 晚高峰
  831 + peakStopTime = Math.floor(paramObj.getUpEPeakTime() * 0.1); // 行驶时间的10%
  832 + if (peakStopTime < 3) { // 不少于3分钟
  833 + peakStopTime = 3;
  834 + }
  835 + return peakStopTime;
  836 + } else { // 低谷
  837 + if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
  838 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
  839 + if (troughStopTime < 10) { // 不少于10分钟
  840 + troughStopTime = 10;
  841 + }
  842 + return troughStopTime;
  843 + } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
  844 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.2); // 行驶时间20%
  845 + if (troughStopTime < 10) { // 不少于10分钟
  846 + troughStopTime = 10;
  847 + }
  848 + return troughStopTime;
  849 + } else { // 早高峰，晚高峰之间
  850 + troughStopTime = Math.floor(paramObj.getUpTroughTime() * 0.15); // 行驶时间15%
  851 + if (troughStopTime < 10) { // 不少于10分钟
  852 + troughStopTime = 10;
  853 + }
  854 + return troughStopTime;
  855 + }
  856 + }
  857 + } else { // 下行
  858 + if (this.isMPeakBc(timeObj)) { // 早高峰
  859 + peakStopTime = Math.floor(paramObj.getDownMPeakTime() * 0.1); // 行驶时间的10%
  860 + if (peakStopTime < 3) { // 不少于3分钟
  861 + peakStopTime = 3;
  862 + }
  863 + return peakStopTime;
  864 + } else if (this.isEPeakBc(timeObj)) { // 晚高峰
  865 + peakStopTime = Math.floor(paramObj.getDownEPeakTime() * 0.1); // 行驶时间的10%
  866 + if (peakStopTime < 3) { // 不少于3分钟
  867 + peakStopTime = 3;
  868 + }
  869 + return peakStopTime;
  870 + } else { // 低谷
  871 + if (this.isTroughBeforMPeakStartBc(timeObj)) { // 早高峰开始前
  872 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
  873 + if (troughStopTime < 10) { // 不少于10分钟
  874 + troughStopTime = 10;
  875 + }
  876 + return troughStopTime;
  877 + } else if (this.isTroughAfterEPeakEndBc(timeObj)) { // 晚高峰结束后
  878 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.2); // 行驶时间20%
  879 + if (troughStopTime < 10) { // 不少于10分钟
  880 + troughStopTime = 10;
  881 + }
  882 + return troughStopTime;
  883 + } else { // 早高峰，晚高峰之间
  884 + troughStopTime = Math.floor(paramObj.getDownTroughTime() * 0.15); // 行驶时间15%
  885 + if (troughStopTime < 10) { // 不少于10分钟
  886 + troughStopTime = 10;
  887 + }
  888 + return troughStopTime;
  889 + }
  890 + }
  891 + }
  892 + } else { // 副站停战，2到3分钟
  893 + secondaryStopTime = 3;
  894 + return secondaryStopTime; // 直接返回3分钟
  895 + }
  896 + }
  897 +
  898 + },
  899 +
  900 + /**
  901 + * 获取行驶时间。
  902 + * @param timeObj 班次时间字符串
  903 + * @param isUp 是否上行
  904 + */
  905 + calcuTravelTime: function(timeObj, isUp) {
  906 + _validInternal(); // 验证
  907 + var paramObj = this;
  908 +
  909 + if (isUp) {
  910 + if (this.isMPeakBc(timeObj)) {
  911 + return paramObj.getUpMPeakTime();
  912 + } else if (this.isEPeakBc(timeObj)) {
  913 + return paramObj.getUpEPeakTime();
  914 + } else {
  915 + return paramObj.getUpTroughTime();
  916 + }
  917 + } else {
  918 + if (this.isMPeakBc(timeObj)) {
  919 + return paramObj.getDownMPeakTime();
  920 + } else if (this.isEPeakBc(timeObj)) {
  921 + return paramObj.getDownEPeakTime();
  922 + } else {
  923 + return paramObj.getDownTroughTime();
  924 + }
  925 + }
  926 + },
  927 +
  928 + /**
  929 + * 获取行驶里程。
  930 + * @param isUp 是否上行
  931 + * @param bcType 班次类型
  932 + */
  933 + calcuTravelLcNumber: function(isUp, bcType) {
  934 + _validInternal(); // 验证
  935 + var paramObj = this;
  936 +
  937 + if (isUp) {
  938 + if (bcType == "in") {
  939 + return paramObj.getUpInLc();
  940 + } else if (bcType == "out") {
  941 + return paramObj.getUpOutLc();
  942 + } else {
  943 + // 基本班次类型，暂时不考虑区间等其他班次类型
  944 + // 暂时不考虑高峰低谷里程的区分
  945 + return paramObj.getUpNormalLc();
  946 + }
  947 + } else {
  948 + if (bcType == "in") {
  949 + return paramObj.getDownInLc();
  950 + } else if (bcType == "out") {
  951 + return paramObj.getDownOutLc();
  952 + } else {
  953 + // 基本班次类型，暂时不考虑区间等其他班次类型
  954 + // 暂时不考虑高峰低谷里程的区分
  955 + return paramObj.getDownNormalLc();
  956 + }
  957 + }
  958 + },
  959 +
  960 + /**
  961 + * 计算高峰周转时间。
  962 + * @returns 周转时间
  963 + */
  964 + calcuPeakZzsj: function() {
  965 + _validInternal(); // 验证
  966 + var paramObj = this;
  967 +
  968 + // 使用早高峰的周转时间
  969 + var _time = paramObj.getMPeakStartTimeObj();
  970 + var _zzsj = // 早高峰上行行驶时间+停站时间+早高峰下行行驶时间+停站时间
  971 + this.calcuTravelTime(_time, true) +
  972 + this.calcuFixedStopNumber(_time, true) +
  973 + this.calcuTravelTime(_time, false) +
  974 + this.calcuFixedStopNumber(_time, false);
  975 + return _zzsj;
  976 + },
  977 +
  978 + /**
  979 + * 计算低谷周转时间。
  980 + * @returns 周转时间
  981 + */
  982 + calcuTroughZzsj: function() {
  983 + _validInternal(); // 验证
  984 + var paramObj = this;
  985 +
  986 + // 使用低谷的周转时间
  987 + var _time = this.addMinute(paramObj.getMPeakStartTimeObj(), -1); // 使用任意一个低谷时间
  988 + var _zzsj = // 低谷上行行驶时间+停站时间+低谷下行行驶时间+停站时间
  989 + this.calcuTravelTime(_time, true) +
  990 + this.calcuFixedStopNumber(_time, true) +
  991 + this.calcuTravelTime(_time, false) +
  992 + this.calcuFixedStopNumber(_time, false);
  993 +
  994 + return _zzsj;
  995 + },
  996 +
  997 + /**
  998 + * 计算车辆总数。
  999 + * @returns 车辆数
  1000 + */
  1001 + calcuClzx: function() {
  1002 + _validInternal(); // 验证
  1003 + var paramObj = this;
  1004 +
  1005 + // 使用早高峰平均间隔
  1006 + var _fcjx_avg = Math.floor((paramObj.getMPeakMinFcjx() + paramObj.getMPeakMaxFcjx()) / 2);
  1007 + return Math.round(this.calcuPeakZzsj() / _fcjx_avg);
  1008 + }
  1009 +
  1010 + };
  1011 +};
0 1012 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalBcObj.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 内部班次对象。
  3 + * @constructor
  4 + */
  5 +var InternalBcObj = function(
  6 + bcType, // 班次类型（normal，in，out等）
  7 + isUp, // boolean是否上下行
  8 + lp, // 路牌标识符
  9 + fcno, // 发车顺序号
  10 + fcTimeObj, // 发车时间对象
  11 + bclc, // 班次里程
  12 + bcsj, // 班次历时
  13 + arrtime, // 到达时间对象
  14 + stoptime, // 停站时间
  15 + tccid, // 停车场id
  16 + ttinfoid, // 时刻表id
  17 + xl, // 线路id
  18 + qdzid, // 起点站id
  19 + zdzid // 终点站id
  20 +) {
  21 + // 属性重新复制一遍，加前缀 _$_ 表示内部属性，不要直接访问k
  22 + // 外部函数使用 prototype 方式
  23 + this._$_bcType = bcType;
  24 + this._$_isUp = isUp;
  25 + this._$_lp = lp;
  26 + this._$_fcno = fcno;
  27 + this._$_fcsjObj = moment(fcTimeObj);
  28 + this._$_bclc = bclc;
  29 + this._$_bcsj = bcsj;
  30 + this._$_arrtime = arrtime;
  31 + this._$_stoptime = stoptime;
  32 + this._$_tccid = tccid;
  33 + this._$_ttinfoid = ttinfoid;
  34 + this._$_xlid = xl;
  35 + this._$_qdzid = qdzid;
  36 + this._$_zdzid = zdzid;
  37 +
  38 +};
  39 +
  40 +/**
  41 + * 设置路牌标号。
  42 + * @param lpNo
  43 + */
  44 +InternalBcObj.prototype.setLp = function(lpNo) {
  45 + this._$_lp = lpNo;
  46 +};
  47 +
  48 +/**
  49 + * 是否上行。
  50 + * @returns boolean
  51 + */
  52 +InternalBcObj.prototype.isUp = function() {
  53 + return this._$_isUp;
  54 +};
  55 +/**
  56 + * 获取发车时间。
  57 + * @returns {*|moment.Moment}
  58 + */
  59 +InternalBcObj.prototype.getFcTimeObj = function() {
  60 + return this._$_fcsjObj;
  61 +};
  62 +/**
  63 + * 获取到达时间。
  64 + * @returns {*|moment.Moment}
  65 + */
  66 +InternalBcObj.prototype.getArrTimeObj = function() {
  67 + return this._$_arrtime;
  68 +};
  69 +/**
  70 + * 获取班次时间。
  71 + * @returns int
  72 + */
  73 +InternalBcObj.prototype.getBcTime = function() {
  74 + return this._$_bcsj;
  75 +};
  76 +/**
  77 + * 获取停站时间。
  78 + * @returns int
  79 + */
  80 +InternalBcObj.prototype.getStopTime = function() {
  81 + return this._$_stoptime;
  82 +};
  83 +/**
  84 + * 转换成显示用班次对象。
  85 + * @returns {{}}
  86 + */
  87 +InternalBcObj.prototype.toGanttBcObj = function() {
  88 + var _bcObj = {
  89 + parent: this._$_lp,
  90 + lpNo: this._$_lp,
  91 + lp: null,
  92 + lpName: this._$_lp,
  93 + lpType: '普通路牌',
  94 + bcType: this._$_bcType,
  95 + fcno: this._$_fcno,
  96 + isfb: 0,
  97 + isSwitchXl: null,
  98 + bz: null
  99 + };
  100 +
  101 + // 线路上下行
  102 + _bcObj.xlDir = this._$_isUp ? "relationshipGraph-up" : "relationshipGraph-down";
  103 +
  104 + // 里程
  105 + _bcObj.jhlc = this._$_bclc;
  106 +
  107 + // 停车场
  108 + _bcObj.tcc = this._$_tccid;
  109 +
  110 + // 时刻表
  111 + _bcObj.ttinfo = this._$_ttinfoid;
  112 +
  113 + // 线路
  114 + _bcObj.xl = this._$_xlid;
  115 +
  116 + // 起点站、终点站
  117 + _bcObj.qdz = this._$_qdzid;
  118 + _bcObj.zdz = this._$_zdzid;
  119 +
  120 + // 发车时间，行驶时间，到达时间，停站时间
  121 + _bcObj.fcsj = this._$_fcsjObj.format("HH:mm");
  122 + _bcObj.bcsj = this._$_bcsj;
  123 + _bcObj.ARRIVALTIME = this._$_arrtime.format("HH:mm");
  124 + _bcObj.STOPTIME = this._$_stoptime;
  125 +
  126 + return _bcObj;
  127 +};
  128 +
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalGroupBcObj.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 内部圈对象（一圈2个班次），圈是以上行计算，还是下行计算，由上标线决定
  3 + * 如果上标线是上行开始，则圈的第一个班次是上行，第二个班次是下行
  4 + * 一定是从第1圈开始，第0圈表示中标线的第一个班次，是下行班次，则第0圈的上行班次就是空的。
  5 + * @constructor
  6 + */
  7 +var InternalGroupBcObj = function(
  8 + isUp, // 是否上行，就是圈以上行开始，还是下行开始
  9 + bc1, // 第一班次
  10 + bc2 // 第二个班次
  11 +) {
  12 + this._$_isUp = isUp;
  13 +
  14 + this._$_internalBcArray = [];
  15 + this._$_internalBcArray.push(bc1);
  16 + this._$_internalBcArray.push(bc2);
  17 +};
  18 +
  19 +InternalGroupBcObj.prototype.getBc1 = function() {
  20 + return this._$_internalBcArray[0];
  21 +};
  22 +InternalGroupBcObj.prototype.getBc2 = function() {
  23 + return this._$_internalBcArray[1];
  24 +};
  25 +
  26 +InternalGroupBcObj.prototype.setBc1 = function(bc) {
  27 + this._$_internalBcArray[0] = bc;
  28 +};
  29 +InternalGroupBcObj.prototype.setBc2 = function(bc) {
  30 + this._$_internalBcArray[1] = bc;
  31 +};
  32 +InternalGroupBcObj.prototype.setLp = function(lp) {
  33 + var bc1 = this._$_internalBcArray[0];
  34 + var bc2 = this._$_internalBcArray[1];
  35 + if (bc1) {
  36 + bc1.setLp(lp);
  37 + }
  38 + if (bc2) {
  39 + bc2.setLp(lp);
  40 + }
  41 +};
0 42 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalLpObj.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 内部路牌对象。
  3 + * @constructor
  4 + */
  5 +var InternalLpObj = function(
  6 + lp, // 路牌编号
  7 + qCount, // 总共多少圈
  8 + isUp // 圈是以上行开始还是下行开始
  9 +) {
  10 + this._$_lp = lp;
  11 + this._$_isUp = isUp;
  12 +
  13 + // 距离上一个路牌的最小发车间隔时间
  14 + // 用于纵向添加班次的时候使用
  15 + // 默认第一个路牌为0
  16 + this._$_minVerticalIntervalTime = 0;
  17 +
  18 + // 路牌的圈数，注意每个路牌的圈数都是一致的，
  19 + // 但并不是每一圈都有值
  20 + // 第1圈从上标线开始
  21 + // 第0圈表示中标线的第一个班次组成的半圈
  22 + // 有多少圈根据最终迭代的结果来看
  23 + this._$_qCount = qCount;
  24 + // 保存的是 InternalGroupBcObj 对象
  25 + this._$_groupBcArray = new Array(qCount);
  26 +
  27 + var i;
  28 + for (i = 0; i < this._$_qCount; i++) {
  29 + this._$_groupBcArray[i] = new InternalGroupBcObj(
  30 + this._$_isUp, undefined, undefined);
  31 + }
  32 +
  33 + // 班型的相关变量
  34 + this._$_bx_isLb = false; // 是否连班
  35 + this._$_bx_isfb = false; // 是否分班
  36 + this._$_bx_isfb_5_2 = false; // 是否5休2分班
  37 +
  38 + // TODO：
  39 +
  40 +};
  41 +
  42 +InternalLpObj.prototype.setBxFb5_2 = function(fb) {
  43 + this._$_bx_isfb_5_2 = fb;
  44 +};
  45 +InternalLpObj.prototype.isBxFb5_2 = function() {
  46 + return this._$_bx_isfb_5_2;
  47 +};
  48 +InternalLpObj.prototype.setBxLb = function(lb) {
  49 + this._$_bx_isLb = lb;
  50 +};
  51 +InternalLpObj.prototype.isBxLb = function() {
  52 + return this._$_bx_isLb;
  53 +};
  54 +
  55 +InternalLpObj.prototype.setBxFb = function(fb) {
  56 + this._$_bx_isfb = fb;
  57 +};
  58 +InternalLpObj.prototype.isBxFb = function() {
  59 + return this._$_bx_isfb;
  60 +};
  61 +
  62 +/**
  63 + * 设置纵向最小发车间隔时间。
  64 + * @param v
  65 + */
  66 +InternalLpObj.prototype.setVerticalMinIntervalTime = function(v) {
  67 + // 第一个路牌，都为0
  68 + this._$_minVerticalIntervalTime = v;
  69 +};
  70 +/**
  71 + * 获取纵向最小发车间隔时间。
  72 + * @returns {number|*}
  73 + */
  74 +InternalLpObj.prototype.getVerticalMinIntervalTime = function() {
  75 + return this._$_minVerticalIntervalTime;
  76 +};
  77 +
  78 +/**
  79 + * 返回总共班次数。
  80 + */
  81 +InternalLpObj.prototype.getBcCount = function() {
  82 + var i;
  83 + var group;
  84 + var bccount = 0;
  85 + for (i = 0; i < this._$_groupBcArray.length; i++) {
  86 + group = this._$_groupBcArray[i];
  87 + if (group) {
  88 + if (group.getBc1()) {
  89 + bccount += 1;
  90 + }
  91 + if (group.getBc2()) {
  92 + bccount += 1;
  93 + }
  94 + }
  95 + }
  96 +
  97 + return bccount;
  98 +};
  99 +
  100 +// TODO
  101 +
  102 +/**
  103 + *
  104 + *
  105 + */
  106 +InternalLpObj.prototype.calcuLpBx = function() {
  107 +
  108 +};
  109 +
  110 +/**
  111 + * 返回班次列表，过滤空的班次，将所有存在的班次连成连续的对象数组返回。
  112 + * @returns arrays (InternalBcObj)
  113 + */
  114 +InternalLpObj.prototype.getBcArray = function() {
  115 + var bcArray = [];
  116 + var i;
  117 + var group;
  118 + for (i = 0; i < this._$_groupBcArray.length; i++) {
  119 + group = this._$_groupBcArray[i];
  120 + if (group) {
  121 + group.getBc1() ? bcArray.push(group.getBc1()) : "";
  122 + group.getBc2() ? bcArray.push(group.getBc2()) : "";
  123 + }
  124 + }
  125 +
  126 + return bcArray;
  127 +};
  128 +
  129 +/**
  130 + * 从指定开始时间到结束时间创建不间断班次（连班），并初始化路牌
  131 + * 注意，之前有班次会删除后再创建。
  132 + * @param startTime 开始时间
  133 + * @param endTime 结束时间
  134 + * @param isUp 第一个班次是上行还是下行
  135 + * @param fromQ 从第几圈开始加入
  136 + * @param paramObj 参数对象
  137 + * @param factory 工厂对象
  138 + */
  139 +InternalLpObj.prototype.initDataFromTimeToTime = function(
  140 + startTime,
  141 + endTime,
  142 + isUp,
  143 + fromQ,
  144 + paramObj,
  145 + factory) {
  146 +
  147 + var bcData = []; // 班次数组
  148 + var bcObj;
  149 + var kssj = startTime;
  150 + var fcno = 1; // 发车顺序号
  151 + var bcCount = 1; // 班次数
  152 + do {
  153 + bcObj = factory.createBcObj(
  154 + "normal", isUp, this._$_lp, fcno, kssj, paramObj);
  155 + bcData.push(bcObj);
  156 +
  157 + kssj = paramObj.addMinute(kssj, bcObj.getBcTime() + bcObj.getStopTime());
  158 + fcno ++;
  159 + bcCount ++;
  160 + isUp = !isUp;
  161 + } while(kssj.isBefore(endTime));
  162 + bcCount--;
  163 +
  164 + if (bcCount > 0 && bcData[bcCount - 1].getArrTimeObj().isAfter(endTime)) {
  165 + // 如果最后一个班次的到达时间超过结束时间，也要去除
  166 + bcData.splice(bcCount - 1, 1);
  167 + }
  168 +
  169 + this.initDataFromLbBcArray(bcData, fromQ);
  170 +
  171 +};
  172 +
  173 +/**
  174 + * 使用连班的班次数组初始化路牌。
  175 + * @param bcArray 连班班次数组
  176 + * @param fromQ 从第几圈开始加入
  177 + */
  178 +InternalLpObj.prototype.initDataFromLbBcArray = function(
  179 + bcArray,
  180 + fromQ
  181 +) {
  182 + // 第一班次是上行还是下行
  183 + var isUp = bcArray[0].isUp();
  184 +
  185 + if (bcArray.length > 0 && fromQ < this._$_qCount) {
  186 + // 构造圈数
  187 + if (isUp != this._$_isUp) {
  188 + // 如果方向不一致，意味着第一个班次是半圈
  189 + // 加半圈，并加在bc2上
  190 + this._$_groupBcArray[fromQ] =
  191 + new InternalGroupBcObj(
  192 + this._$_isUp,
  193 + undefined,
  194 + bcArray.slice(0, 1)[0]
  195 + );
  196 + bcArray.splice(0, 1);
  197 + fromQ ++;
  198 + }
  199 +
  200 + var qCount1 = Math.floor(bcArray.length / 2); // 需要添加多少圈
  201 + var qCount2 = bcArray.length % 2; // 最后是否有半圈
  202 +
  203 + while (fromQ < this._$_qCount) {
  204 + if (qCount1 > 0) {
  205 + this._$_groupBcArray[fromQ] =
  206 + new InternalGroupBcObj(
  207 + this._$_isUp,
  208 + bcArray.slice(0, 1)[0],
  209 + bcArray.slice(1, 2)[0]
  210 + );
  211 + bcArray.splice(0, 2);
  212 + qCount1 --;
  213 + } else if (qCount2 > 0) {
  214 + // 加半圈，并加在bc1上
  215 + this._$_groupBcArray[fromQ] =
  216 + new InternalGroupBcObj(
  217 + this._$_isUp,
  218 + bcArray.slice(0, 1)[0],
  219 + undefined
  220 + );
  221 + } else {
  222 + break;
  223 + }
  224 +
  225 + fromQ ++;
  226 + }
  227 + }
  228 +};
  229 +
  230 +/**
  231 + * 获取班次。
  232 + * @param qIndex 第几圈
  233 + * @param bcIndex 第几个班次
  234 + */
  235 +InternalLpObj.prototype.getBc = function(qIndex, bcIndex) {
  236 + var group = this._$_groupBcArray[qIndex];
  237 + var bc;
  238 + if (bcIndex == 0) {
  239 + bc = group.getBc1();
  240 + } else if (bcIndex == 1) {
  241 + bc = group.getBc2();
  242 + }
  243 + return bc;
  244 +};
  245 +
  246 +/**
  247 + * 再具体位置设置班次。
  248 + * @param qIndex 第几圈
  249 + * @param bcIndex 第几个班次
  250 + * @param bc 班次对象
  251 + */
  252 +InternalLpObj.prototype.setBc = function(qIndex, bcIndex, bc) {
  253 + var group = this._$_groupBcArray[qIndex];
  254 + if (bcIndex == 0) {
  255 + group.setBc1(bc);
  256 + } else if (bcIndex == 1) {
  257 + group.setBc2(bc);
  258 + }
  259 +};
  260 +
  261 +/**
  262 + * 设置班次的路牌编号。
  263 + * @param lpNo
  264 + */
  265 +InternalLpObj.prototype.setLp = function(lpNo) {
  266 + var i;
  267 + var group;
  268 + for (i = 0; i < this._$_groupBcArray.length; i++) {
  269 + group = this._$_groupBcArray[i];
  270 + if (group) {
  271 + group.setLp(lpNo);
  272 + }
  273 + }
  274 +};
  275 +
  276 +/**
  277 + * 使用指定时间匹配返回离之最近的第几圈第几个班次，
  278 + * 使用时间差的绝度值，比较，取最小的
  279 + * 如果有两个一样的时间差，取比fctime大的时间
  280 + * @param fctime 比较用时间
  281 + * @param groupArray 圈数组
  282 + * @returns [{第几圈},{第几个班次}]
  283 + */
  284 +InternalLpObj.prototype.getgetQBcIndexWithFcTimeFromGroupArray = function(
  285 + fctime, groupArray
  286 +) {
  287 + var i;
  288 + var timediff; // 时间差取绝对值
  289 + var qIndex;
  290 + var bcIndex;
  291 +
  292 + var group;
  293 + var bc1time;
  294 + var bc2time;
  295 +
  296 + var tempdiff;
  297 + for (i = 0; i < this._$_qCount; i++) {
  298 + group = groupArray[i];
  299 + if (group) {
  300 + if (group.getBc1()) {
  301 + bc1time = group.getBc1().getFcTimeObj();
  302 + tempdiff = Math.abs(bc1time.diff(fctime));
  303 +
  304 + if (!timediff) {
  305 + timediff = Math.abs(tempdiff);
  306 + qIndex = i;
  307 + bcIndex = 0;
  308 + } else {
  309 + if (tempdiff < timediff) {
  310 + timediff = tempdiff;
  311 + qIndex = i;
  312 + bcIndex = 0;
  313 + } if (Math.abs(tempdiff) == timediff) {
  314 + if (bc1time.isBefore(fctime)) {
  315 + timediff = tempdiff;
  316 + qIndex = i;
  317 + bcIndex = 0;
  318 + }
  319 +
  320 + }
  321 + }
  322 + }
  323 +
  324 + if (group.getBc2()) {
  325 + bc2time = group.getBc2().getFcTimeObj();
  326 + tempdiff = Math.abs(bc2time.diff(fctime));
  327 +
  328 + if (!timediff) {
  329 + timediff = Math.abs(tempdiff);
  330 + qIndex = i;
  331 + bcIndex = 1;
  332 + } else {
  333 + if (tempdiff < timediff) {
  334 + timediff = tempdiff;
  335 + qIndex = i;
  336 + bcIndex = 1;
  337 + } if (Math.abs(tempdiff) == timediff) {
  338 + if (bc2time.isBefore(fctime)) {
  339 + timediff = tempdiff;
  340 + qIndex = i;
  341 + bcIndex = 1;
  342 + }
  343 +
  344 + }
  345 + }
  346 + }
  347 + }
  348 + }
  349 +
  350 + var rst = [];
  351 + rst.push(qIndex);
  352 + rst.push(bcIndex);
  353 +
  354 + return rst;
  355 +};
  356 +
  357 +/**
  358 + * 使用指定时间匹配返回离之最近的第几圈第几个班次，
  359 + * 使用时间差的绝度值，比较，取最小的
  360 + * 如果有两个一样的时间差，取比fctime大的时间
  361 + * @param fctime 比较用时间
  362 + * @returns [{第几圈},{第几个班次}]
  363 + */
  364 +InternalLpObj.prototype.getQBcIndexWithFcTime = function(
  365 + fctime
  366 +) {
  367 + return this.getgetQBcIndexWithFcTimeFromGroupArray(fctime, this._$_groupBcArray);
  368 +};
  369 +
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/core/InternalScheduleObj.js 0 → 100644
  View file @e16f191
  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 +
  18 + var _initFun1 = function() { // 初始化方法1
  19 + // 确定_qIsUp，哪个方向的首班车晚就用哪个
  20 + _qIsUp = _paramObj.getUpFirstDTimeObj().isBefore(
  21 + _paramObj.getDownFirstDTimeObj()) ? false : true;
  22 + // 上标线开始时间，就是方向的首班车时间
  23 + var st = _qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  24 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  25 + var et;
  26 + var et_IsUp;
  27 + if (_paramObj.getUpLastDtimeObj().isBefore(
  28 + _paramObj.getDownLastDTimeObj())) {
  29 + et = _paramObj.getDownLastDTimeObj();
  30 + et_IsUp = false;
  31 + } else {
  32 + et = _paramObj.getUpLastDtimeObj();
  33 + et_IsUp = true;
  34 + }
  35 +
  36 + // 以开始时间，结束时间，构造上标线用连班班次
  37 + var bcData = []; // 班次数组
  38 + var bcObj;
  39 + var isUp = _qIsUp; // 方向
  40 + var kssj = st;
  41 + var fcno = 1; // 发车顺序号
  42 + var bcCount = 1; // 班次数
  43 + do {
  44 + bcObj = _factory.createBcObj(
  45 + "normal", isUp, _lpArray[0].lpNo, fcno, kssj, paramObj);
  46 + bcData.push(bcObj);
  47 +
  48 + kssj = paramObj.addMinute(kssj, bcObj.getBcTime() + bcObj.getStopTime());
  49 + fcno ++;
  50 + bcCount ++;
  51 + isUp = !isUp;
  52 + } while(kssj.isBefore(et));
  53 + bcCount--; // 因为先做do，所以总的班次要减1
  54 + if (bcCount > 0 && bcData[bcCount - 1].getArrTimeObj().isAfter(et)) {
  55 + // 如果最后一个班次的到达时间超过结束时间，也要去除
  56 + bcData.splice(bcCount - 1, 1);
  57 + bcCount--;
  58 + }
  59 + var _qCount_p1 = Math.floor(bcCount / 2); // 2个班次一圈
  60 + var _qCount_p2 = bcCount % 2; // 余下的1个班次也算一圈
  61 +
  62 + // 利用连班数组计算圈数
  63 + _qCount = 1; // 前面加1圈，补中标线的班次
  64 + _qCount += _qCount_p1;
  65 + _qCount += _qCount_p2;
  66 +
  67 + // 计算最后是不是还要补一圈
  68 + if (_qCount > 1) { // 总的圈数就1圈，没必要加了（其实是不可能的，除非参数里问题）
  69 + if (_qCount_p2 == 0) { // 没有余下班次，整数圈数
  70 + // 最后一个班次的方向一定和开始的方向相反，如：上-下,上-下,上-下，一共三圈，最后一个班次为下行
  71 + // 判定最后一个班次的方向和上标线判定结束时间的班次方向是否一致
  72 + if (!_qIsUp == et_IsUp) {
  73 + // 一致不用加圈数
  74 + } else {
  75 + // 不一致需要加圈补最后一个结束时间班次
  76 + _qCount ++;
  77 + }
  78 + } else {
  79 + // 有余下的圈数，最后要不补的班次不管上行，下行都在这一圈里
  80 + // 不需要在补圈数了
  81 + }
  82 + }
  83 +
  84 + // 创建内部的路牌数组，并把之前的连班路牌添加进上标线路牌中
  85 + var i;
  86 + for (i = 0; i < _lpArray.length; i++) {
  87 + _internalLpArray.push(
  88 + new InternalLpObj(_lpArray[i].lpNo, _qCount, _qIsUp));
  89 + }
  90 + _internalLpArray[0].initDataFromLbBcArray(bcData, 1); // 上标线从第1圈开始放班次
  91 +
  92 + console.log("//---------------- 行车计划，初始化方法1 start ----------------//");
  93 + console.log("上行首班车时间:" + _paramObj.getUpFirstDTimeObj().format("HH:mm") +
  94 + "上行末班车时间:" + _paramObj.getUpLastDtimeObj().format("HH:mm"));
  95 + console.log("下行首班车时间:" + _paramObj.getDownFirstDTimeObj().format("HH:mm") +
  96 + "下行末班车时间:" + _paramObj.getDownLastDTimeObj().format("HH:mm"));
  97 + console.log("总共计算的圈数:" + _qCount);
  98 + console.log("圈的方向isUP:" + _qIsUp);
  99 + console.log("//---------------- 行车计划，初始化方法1 end ----------------//");
  100 +
  101 + };
  102 +
  103 + //------------------ 初始化方法2，以及计算关联的内部变量 ----------------//
  104 + var _zgfQIndex; // 早高峰车辆从第几圈开始全部发出
  105 + var _zgfBIndex; // 早高峰车辆从第几圈第几个班次全部发出
  106 + var _wgfQIndex; // 晚高峰车辆从第几圈开始全部发出
  107 + var _wgfBIndex; // 晚高峰车辆从第几圈第几个班次全部发出
  108 +
  109 + // 同一圈同一方向班次发车间隔的最小值
  110 + // 注意：这个值就是用来添加班次的时间增加单位，在后面相关的方法里会具体说明
  111 + var _qbcMinIntervalValue;
  112 +
  113 + var _initFun2 = function() { // 初始化方法2
  114 + // 以上标线为标准，查找离早高峰开始时间最近的班次作为早高峰开始班次
  115 + // 以这个班次为早高峰起点，全部出车策略
  116 + var qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
  117 + _paramObj.getMPeakStartTimeObj());
  118 + var qIndex = qbcIndexArray[0]; // 第几圈
  119 + var bIndex = qbcIndexArray[1]; // 第几个班次
  120 + var startbc = _internalLpArray[0].getBc(qIndex, bIndex);
  121 +
  122 + // 计算早高峰
  123 + var _clCount = _paramObj.calcuClzx();
  124 + var _c1 = Math.floor(_paramObj.calcuPeakZzsj() / _clCount);
  125 + var _c2 = _paramObj.calcuPeakZzsj() % _clCount;
  126 + var _kssj = startbc.getFcTimeObj();
  127 +
  128 + var i;
  129 + for (i = 2; i <= _clCount - _c2; i++) {
  130 + _kssj = _paramObj.addMinute(_kssj, _c1);
  131 + _internalLpArray[i - 1].setBc(
  132 + qIndex,
  133 + bIndex,
  134 + _factory.createBcObj(
  135 + "normal", startbc.isUp(),
  136 + _lpArray[i - 1].lpNo,
  137 + 1, _kssj, paramObj)
  138 + );
  139 + // 使用早高峰的发车间隔最为路牌纵向最小发车间隔
  140 + _internalLpArray[i - 1].setVerticalMinIntervalTime(_c1);
  141 + }
  142 + for (i = 1; i <= _c2; i++) {
  143 + _kssj = _paramObj.addMinute(_kssj, _c1 + 1);
  144 + _internalLpArray[_clCount - _c2 + i - 1].setBc(
  145 + qIndex,
  146 + bIndex,
  147 + _factory.createBcObj(
  148 + "normal", startbc.isUp(),
  149 + _lpArray[_clCount - _c2 + i - 1].lpNo,
  150 + 1, _kssj, paramObj)
  151 + );
  152 + // 使用早高峰的发车间隔最为路牌纵向最小发车间隔
  153 + _internalLpArray[_clCount - _c2 + i - 1].setVerticalMinIntervalTime(_c1);
  154 + }
  155 +
  156 + _zgfQIndex = qIndex;
  157 + _zgfBIndex = bIndex;
  158 +
  159 + // 以上标线为标准，查找离晚高峰开始时间最近的班次作为晚高峰开始班次
  160 + // 以这个班次为早高峰起点，全部出车策略
  161 + qbcIndexArray = _internalLpArray[0].getQBcIndexWithFcTime(
  162 + _paramObj.getEPeakStartTimeObj());
  163 + qIndex = qbcIndexArray[0]; // 第几圈
  164 + bIndex = qbcIndexArray[1]; // 第几个班次
  165 + startbc = _internalLpArray[0].getBc(qIndex, bIndex);
  166 +
  167 + // 计算晚高峰
  168 + _clCount = _paramObj.calcuClzx();
  169 + _c1 = Math.floor(_paramObj.calcuPeakZzsj() / _clCount);
  170 + _c2 = _paramObj.calcuPeakZzsj() % _clCount;
  171 + _kssj = startbc.getFcTimeObj();
  172 +
  173 + for (i = 2; i <= _clCount - _c2; i++) {
  174 + _kssj = _paramObj.addMinute(_kssj, _c1);
  175 + _internalLpArray[i - 1].setBc(
  176 + qIndex,
  177 + bIndex,
  178 + _factory.createBcObj(
  179 + "normal", startbc.isUp(),
  180 + _lpArray[i - 1].lpNo,
  181 + 1, _kssj, _paramObj)
  182 + );
  183 + }
  184 + for (i = 1; i <= _c2; i++) {
  185 + _kssj = _paramObj.addMinute(_kssj, _c1 + 1);
  186 + _internalLpArray[_clCount - _c2 + i - 1].setBc(
  187 + qIndex,
  188 + bIndex,
  189 + _factory.createBcObj(
  190 + "normal", startbc.isUp(),
  191 + _lpArray[_clCount - _c2 + i - 1].lpNo,
  192 + 1, _kssj, _paramObj)
  193 + );
  194 + }
  195 +
  196 + _wgfQIndex = qIndex;
  197 + _wgfBIndex = bIndex;
  198 + _qbcMinIntervalValue = _c1;
  199 +
  200 + console.log("//---------------- 行车计划，初始化方法2 start ----------------//");
  201 + console.log("早高峰第" + _zgfQIndex + "(index)圈,第" + _zgfBIndex + "(index)班次车辆全部发出");
  202 + console.log("晚高峰第" + _wgfQIndex + "(index)圈,第" + _wgfBIndex + "(index)班次车辆全部发出");
  203 + console.log("同圈同方向班次最小间隔(分钟):" + _qbcMinIntervalValue);
  204 + console.log("//---------------- 行车计划，初始化方法2 end ----------------//");
  205 + };
  206 +
  207 + //----------------------- 初始化方法3，以及计算关联的内部变量 ----------------//
  208 + var _zbx_lpIndex; // 中标线对应第几个路牌
  209 +
  210 + var _initFun3 = function() { // 初始化方法3
  211 + // 构造中标线
  212 + // 中标线开始时间，就是方向的首班车时间
  213 + var st = !_qIsUp ? _paramObj.getUpFirstDTimeObj() : _paramObj.getDownFirstDTimeObj();
  214 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  215 + // 上标线结束时间，使用最晚的末班车时间，结束时间的班次方向
  216 + var et;
  217 + if (_paramObj.getUpLastDtimeObj().isBefore(
  218 + _paramObj.getDownLastDTimeObj())) {
  219 + et = _paramObj.getDownLastDTimeObj();
  220 + } else {
  221 + et = _paramObj.getUpLastDtimeObj();
  222 + }
  223 +
  224 + var tempLpObj = new InternalLpObj(-999, _qCount, _qIsUp);
  225 + tempLpObj.initDataFromTimeToTime(
  226 + st,
  227 + et,
  228 + !_qIsUp,
  229 + 0,
  230 + _paramObj,
  231 + _factory
  232 + );
  233 +
  234 + // 找出中标线对应的早高峰的班次对象
  235 + var _zb_bcobj = tempLpObj.getBc(_zgfQIndex, _zgfBIndex);
  236 +
  237 + // 把所有高峰班次重新构造成一个一个的圈数组，计算对应中标线最近的是第几个路牌
  238 + var _tempq_array = [];
  239 + var _temp_group;
  240 + var _temp_bc;
  241 + var i;
  242 + for (i = 0; i < _internalLpArray.length; i++) {
  243 + _temp_bc = _internalLpArray[i].getBc(_zgfQIndex, _zgfBIndex);
  244 + if (_temp_bc.isUp() == _qIsUp) {
  245 + _temp_group = new InternalGroupBcObj(_qIsUp, _temp_bc, undefined);
  246 + } else {
  247 + _temp_group = new InternalGroupBcObj(_qIsUp, undefined, _temp_bc);
  248 + }
  249 + _tempq_array.push(_temp_group);
  250 + }
  251 +
  252 + var _ttindex_ = tempLpObj.getgetQBcIndexWithFcTimeFromGroupArray(
  253 + _zb_bcobj.getFcTimeObj(),
  254 + _tempq_array
  255 + );
  256 + _zbx_lpIndex = _ttindex_[0]; // 中标线放在第几个路牌
  257 + tempLpObj.setLp(_lpArray[_zbx_lpIndex].lpNo);
  258 + tempLpObj.setVerticalMinIntervalTime( // 设置纵向最小发车间隔
  259 + _internalLpArray[_zbx_lpIndex].getVerticalMinIntervalTime()
  260 + );
  261 +
  262 + // 注意：这里直接把中标线数据替换到指定路牌位置
  263 + // TODO：由初始化方法1，初始化方法2得到的2个高峰的班次会被中标线对应班次覆盖
  264 + // TODO：目前使用中标线的班次覆盖，以后相互动态调整
  265 +
  266 + _internalLpArray[_zbx_lpIndex] = tempLpObj;
  267 +
  268 + console.log("//---------------- 行车计划，初始化方法3 start ----------------//");
  269 + console.log("中标线对应第" + (_zbx_lpIndex + 1) + "个路牌");
  270 + console.log("//---------------- 行车计划，初始化方法3 end ----------------//");
  271 +
  272 + };
  273 +
  274 + //----------------------- 初始化方法4，以及计算关联的内部变量 ----------------//
  275 + var _bx_lb_lpcount; // 连班路牌数
  276 + var _bx_5_2_fb_lpcount; // 5休2分班路牌数
  277 + var _bx_other_fb_lpcount; // 其他分班路牌数
  278 +
  279 + var _initFun4 = function() { // 初始化方法4
  280 + // 总共车辆数（高峰最大车辆数）
  281 + var cls = _paramObj.calcuClzx();
  282 + // 低谷最少配车（连班车数量）
  283 + var dgminpc = Math.round(_paramObj.calcuTroughZzsj() / _paramObj.getTroughMaxFcjx());
  284 + // 加班车路牌数（做5休2的路牌数）
  285 + var _5_2_lpes = _paramObj.getJBLpes();
  286 +
  287 + // 做些简单的验证
  288 + if (cls < dgminpc) {
  289 + alert("总配车数小于低谷最小配车");
  290 + throw "总配车数小于低谷最小配车";
  291 + }
  292 + if (dgminpc < 2) {
  293 + alert("连班路牌小于2，办不到啊");
  294 + throw "连班路牌小于2，办不到啊";
  295 + }
  296 + if (cls - dgminpc < _5_2_lpes) {
  297 + alert("总分班路牌数小于加班路牌数");
  298 + throw "总分班路牌数小于加班路牌数";
  299 + }
  300 +
  301 + _bx_lb_lpcount = dgminpc;
  302 + _bx_5_2_fb_lpcount = _5_2_lpes;
  303 + _bx_other_fb_lpcount = cls - dgminpc - _5_2_lpes;
  304 +
  305 + console.log("//---------------- 行车计划，初始化方法4 start ----------------//");
  306 + console.log("连班路牌数:" + _bx_lb_lpcount);
  307 + console.log("5休2分班路牌数:" + _bx_5_2_fb_lpcount);
  308 + console.log("其他分班路牌数:" + _bx_other_fb_lpcount);
  309 + console.log("//---------------- 行车计划，初始化方法4 end ----------------//");
  310 + };
  311 +
  312 +
  313 + return {
  314 + //------------- 布局初始化方法 ------------//
  315 + /**
  316 + * 初始化数据，使用标线初始化
  317 + */
  318 + initDataWithBxLayout: function() {
  319 + // 初始化布局1，构造上标线，计算圈数，把上标线数据放入第一个路牌中
  320 + _initFun1();
  321 + // 初始化布局2，从上标线的某个班次开始，构造所有路牌的早高峰班次，晚高峰班次
  322 + _initFun2();
  323 + // 初始化布局3，构造中标线，根据高峰班次，将中标线放入合适的路牌中
  324 + _initFun3();
  325 + // 初始化4，计算连班，分班相关路牌数
  326 + _initFun4();
  327 +
  328 + // 测试添加班次
  329 + //this._generateBc(8, 1, 0);
  330 + //this._generateBc(10, 1, 0);
  331 + //this._generateBc(11, 1, 0);
  332 + //this._generateBc(12, 1, 0);
  333 + //this._generateBc(13, 1, 0);
  334 + //this._generateBc(14, 1, 0);
  335 + //this._generateBc(15, 1, 0);
  336 + //this._generateBc(16, 1, 0);
  337 + //this._generateBc(17, 1, 0);
  338 + //this._generateBc(18, 1, 0);
  339 + //
  340 + //this._generateBc(10, 1, 1);
  341 + //this._generateBc(11, 1, 1);
  342 + //this._generateBc(12, 1, 1);
  343 + //this._generateBc(13, 1, 1);
  344 + //this._generateBc(14, 1, 1);
  345 + //this._generateBc(15, 1, 1);
  346 + //this._generateBc(16, 1, 1);
  347 + //this._generateBc(17, 1, 1);
  348 + //this._generateBc(18, 1, 1);
  349 +
  350 + // TODO：
  351 +
  352 + // 测试时间判定
  353 + //console.log("班次出车时间：" + _internalLpArray[0].getQBcIndexWithFcTime(
  354 + // _paramObj.getMPeakStartTimeObj()
  355 + // ));
  356 +
  357 + //// 测试画中标线，第6个路牌的位置，下行中标
  358 + //_internalLpArray[7].initDataFromTimeToTime(
  359 + // _paramObj.getDownFirstDTimeObj(),
  360 + // _paramObj.getUpLastDtimeObj(),
  361 + // false,
  362 + // 0,
  363 + // _paramObj,
  364 + // _factory
  365 + //);
  366 +
  367 + },
  368 +
  369 + // TODO：
  370 +
  371 + /**
  372 + * 计算每个路牌的班型及工时对应的圈数。
  373 + * 1、将连班，分班路牌分配到各个路牌上（分隔法），上标线，中标线上连班路牌
  374 + * 2、确定班型的工时，其中连班路牌的工时由上标线，中标线确定好了，5休2路牌工时也确定了，
  375 + * 其余分班路牌的工时由高峰低谷最大，最小发车间隔计算
  376 + */
  377 + calcuLpBx_fg: function() {
  378 + // 间隔法
  379 + // 除去上标线，中标线的连班路牌个数
  380 + var _lblbcount = _bx_lb_lpcount - 2;
  381 + // 计算由标线隔开的两个区域的路牌数比率
  382 + var _p1 = (_zbx_lpIndex + 1) / (_internalLpArray.length + 1);
  383 + var _p2 = (_internalLpArray.length - _zbx_lpIndex) / (_internalLpArray.length + 1);
  384 + var _p1_lpcount = _lblbcount * _p1;
  385 + var _p2_lpcount = _lblbcount * _p2;
  386 + if (parseInt(_p1_lpcount) != _p1_lpcount) { // 没有整除
  387 + _p1_lpcount = Math.floor(_p1_lpcount);
  388 + _p2_lpcount = Math.floor(_p2_lpcount) + 1;
  389 + }
  390 +
  391 + // 设定第一个区域的连班路牌
  392 + var i;
  393 + var _count = _p1_lpcount + 1;
  394 + var _c1 = Math.floor(_zbx_lpIndex / _count);
  395 + var _c2 = _zbx_lpIndex % _count;
  396 + var _c2_start_index;
  397 + for (i = 1; i <= _count - _c2; i++) {
  398 + _internalLpArray[(i - 1) * _c1].setBxLb(true);
  399 + _c2_start_index = (i - 1) * _c1;
  400 + }
  401 + for (i = 1; i <= _c2; i++) {
  402 + _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxLb(true);
  403 + }
  404 +
  405 + // 设定第二个区域的连班路牌
  406 + _count = _p2_lpcount + 1;
  407 + _c1 = Math.floor((_internalLpArray.length - _zbx_lpIndex - 1) / _count);
  408 + _c2 = (_internalLpArray.length - _zbx_lpIndex - 1) % _count;
  409 + for (i = 1; i <= _count - _c2; i++) {
  410 + _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxLb(true);
  411 + _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxFb(false);
  412 + _internalLpArray[(i - 1) * _c1 + _zbx_lpIndex].setBxFb5_2(false);
  413 + _c2_start_index = (i - 1) * _c1 + _zbx_lpIndex;
  414 + }
  415 + for (i = 1; i <= _c2; i++) {
  416 + _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxLb(true);
  417 + _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxFb(false);
  418 + _internalLpArray[_c2_start_index + i * (_c1 + 1)].setBxFb5_2(false);
  419 + }
  420 +
  421 + // 设定分班路牌
  422 + var notlbIndexes = []; // 去除连班的路牌index列表
  423 + for (i = 0; i < _internalLpArray.length; i++) {
  424 + if (!_internalLpArray[i].isBxLb()) {
  425 + notlbIndexes.push(i);
  426 + }
  427 + }
  428 + // 先把全部放置分班路牌，在全部放置5休2路牌
  429 + for (i = 0; i < _bx_other_fb_lpcount; i++) {
  430 + _internalLpArray[notlbIndexes[i]].setBxFb(false);
  431 + _internalLpArray[notlbIndexes[i]].setBxFb(true);
  432 + _internalLpArray[notlbIndexes[i]].setBxFb5_2(false);
  433 + }
  434 + while (i < _bx_other_fb_lpcount + _bx_5_2_fb_lpcount) {
  435 + _internalLpArray[notlbIndexes[i]].setBxFb(false);
  436 + _internalLpArray[notlbIndexes[i]].setBxFb(true);
  437 + _internalLpArray[notlbIndexes[i]].setBxFb5_2(true);
  438 +
  439 + i++;
  440 + }
  441 +
  442 + // 测试打印
  443 + var lbIndexes = [];
  444 + for (i = 0; i < _internalLpArray.length; i++) {
  445 + if (_internalLpArray[i].isBxLb()) {
  446 + lbIndexes.push(i);
  447 + }
  448 + }
  449 + console.log("连班路牌indexes=" + lbIndexes);
  450 +
  451 + var _other_fbIndexes = [];
  452 + for (i = 0; i < _internalLpArray.length; i++) {
  453 + if (_internalLpArray[i].isBxFb() && !_internalLpArray[i].isBxFb5_2()) {
  454 + _other_fbIndexes.push(i);
  455 + }
  456 + }
  457 + console.log("其他分班路牌indexes=" + _other_fbIndexes);
  458 +
  459 + var _5_2_fbIndexes = [];
  460 + for (i = 0; i < _internalLpArray.length; i++) {
  461 + if (_internalLpArray[i].isBxFb() && _internalLpArray[i].isBxFb5_2()) {
  462 + _5_2_fbIndexes.push(i);
  463 + }
  464 + }
  465 + console.log("5休2分班路牌indexes=" + _5_2_fbIndexes);
  466 + },
  467 +
  468 + /**
  469 + * 在指定位置生成班次（内部重要方法）。
  470 + * @param lpIndex 第几个路牌
  471 + * @param qIndex 第几圈
  472 + * @param bcIndex 第几个班次
  473 + */
  474 + _generateBc: function(lpIndex, qIndex, bcIndex) {
  475 + // 在初始化布局后使用，否则没有参照班次加不了
  476 + // 初始化布局后，相当于把时刻表比作一个围棋棋盘，行为路牌数，列为圈数
  477 + // 上标线，中标线，早晚高峰已经布局在棋盘上，其余的空格可以创建班次
  478 +
  479 + // 这个生成班次是以上一班次时间，以发车间隔为基础添加的，纵向加
  480 + // 和生成标线时那种一直往后加班次时不一样，那种是以前一个班次为基础，横向加
  481 +
  482 + // 1、生成的班次以同一圈同一个方向里离它最早的班次的发车时间为基础
  483 + // 2、以每个路牌的纵向最小发车间隔时间为计算发车间隔
  484 + // 3、如果班次发车时间越界不管，有其余方法排除这种情况
  485 +
  486 + // 1、查找同圈同方向里最近的班次，找不到报错（因为有标线存在是不可能找不到的）
  487 + var _i;
  488 + var _bcObj;
  489 + for (_i = lpIndex - 1; _i >= 0; _i--) {
  490 + _bcObj = _internalLpArray[_i].getBc(qIndex, bcIndex);
  491 + if (_bcObj) {
  492 + break;
  493 + }
  494 + }
  495 + if (!_bcObj) {
  496 + alert("无法在指定位置生成班次");
  497 + throw "无法在路牌index=" + lpIndex + ",圈index=" + qIndex + ",班次index=" + bcIndex + "生成班次";
  498 + }
  499 +
  500 + // 2、计算发车间隔
  501 + var _intervalTime = 0;
  502 + for (_i = _i + 1; _i <= lpIndex; _i++) {
  503 + _intervalTime += _internalLpArray[_i].getVerticalMinIntervalTime();
  504 + }
  505 +
  506 + // 3、计算班次并添加班次
  507 + var _kssj = _paramObj.addMinute(_bcObj.getFcTimeObj(), _intervalTime);
  508 + _bcObj = _factory.createBcObj(
  509 + "normal", _bcObj.isUp(),
  510 + _lpArray[lpIndex].lpNo,
  511 + 1, _kssj, _paramObj);
  512 +
  513 + _internalLpArray[lpIndex].setBc(qIndex, bcIndex, _bcObj);
  514 +
  515 + // TODO：这种添加班次的方法，可能造成相邻班次的停站时间问题
  516 + // TODO：主要是由于中标线的问题，但是误差不会很大，
  517 + // TODO：后面有方法直接调整停站时间（所谓的平滑过度时间）
  518 + },
  519 +
  520 + //------------- 其他方法 -------------//
  521 + /**
  522 + * 内部数据转化成显示用的班次数组。
  523 + */
  524 + toGanttBcArray: function() {
  525 + var bcData = [];
  526 + var i;
  527 + var lpObj;
  528 + for (i = 0; i < _internalLpArray.length; i++) {
  529 + lpObj = _internalLpArray[i];
  530 + bcData = bcData.concat(lpObj.getBcArray());
  531 + }
  532 +
  533 + var ganttBcData = [];
  534 + for (i = 0; i < bcData.length; i++) {
  535 + ganttBcData.push(bcData[i].toGanttBcObj());
  536 + }
  537 +
  538 + return ganttBcData;
  539 + }
  540 +
  541 + // TODO：
  542 + };
  543 +};
0 544 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/js/v2/main_v2.js 0 → 100644
  View file @e16f191
  1 +/**
  2 + * 主类。
  3 + */
  4 +var Main_v2 = function() {
  5 + // 内部工厂类
  6 + var _factoryFun = function() {
  7 + return {
  8 + // 创建参数
  9 + createParameterObj: function(formMap, dataMap) {
  10 + var paramObj = ParameterObj();
  11 + paramObj.wrap(formMap, dataMap);
  12 + return paramObj;
  13 + },
  14 + // 创建班次对象
  15 + createBcObj: function(bcType, isUp, lp, fcno, fcTimeObj, paramObj) {
  16 + var _bclc = paramObj.calcuTravelLcNumber(isUp, bcType);
  17 + var _bcsj = paramObj.calcuTravelTime(fcTimeObj, isUp);
  18 + var _arrsj = paramObj.addMinute(fcTimeObj, _bcsj);
  19 + var _stoptime = paramObj.calcuFixedStopNumber(_arrsj, !isUp);
  20 + var _tccid = paramObj.getTTinfoId();
  21 + var _ttinfoid = paramObj.getTTinfoId();
  22 + var _xl = paramObj.getXlId();
  23 + var _qdz = isUp ? paramObj.getUpQdzObj().id : paramObj.getDownQdzObj().id;
  24 + var _zdz = isUp ? paramObj.getUpZdzObj().id : paramObj.getDownZdzObj().id;
  25 +
  26 + return new InternalBcObj(
  27 + bcType, // 班次类型（normal，in，out等）
  28 + isUp, // boolean是否上下行
  29 + lp, // 路牌标识符
  30 + fcno, // 发车顺序号
  31 + fcTimeObj, // 发车时间对象
  32 + _bclc, // 班次里程
  33 + _bcsj, // 班次历时
  34 + _arrsj, // 到达时间对象
  35 + _stoptime, // 停站时间
  36 + _tccid, // 停车场id
  37 + _ttinfoid, // 时刻表id
  38 + _xl, // 线路id
  39 + _qdz, // 起点站id
  40 + _zdz // 终点站id
  41 + );
  42 + }
  43 + };
  44 + };
  45 + var _factory = _factoryFun();
  46 +
  47 + // 所有的时间使用moment.js计算
  48 +
  49 + var _paramObj; // 参数对象
  50 +
  51 + var _bxDesc = [ // 班型描述
  52 + {'type':'六工一休','hoursV':6.66, 'minueV':'6:40', 'qcount': 0, 'avertime': 0},
  53 + {'type':'五工一休','hoursV':6.85, 'minueV':'6:51', 'qcount': 0, 'avertime': 0},
  54 + {'type':'四工一休','hoursV':7.14, 'minueV':'7:08', 'qcount': 0, 'avertime': 0},
  55 + {'type':'三工一休','hoursV':7.61, 'minueV':'7:37', 'qcount': 0, 'avertime': 0},
  56 + {'type':'二工一休','hoursV':8.57, 'minueV':'8:34', 'qcount': 0, 'avertime': 0},
  57 + {'type':'一工一休','hoursV':11.42, 'minueV':'11:25', 'qcount': 0, 'avertime': 0},
  58 + {'type':'五工二休','hoursV':7.99, 'minueV':'8:00', 'qcount': 0, 'avertime': 0},
  59 + {'type':'无工休', 'hoursV':5.43, 'minueV':'5:43', 'qcount': 0, 'avertime': 0}
  60 + ];
  61 +
  62 + return {
  63 + /**
  64 + * 工厂对象，创建不同的对象。
  65 + * @returns {{createParameterObj, createBcObj}}
  66 + */
  67 + getFactory: function() {
  68 + return _factory;
  69 + },
  70 +
  71 + /**
  72 + * 使用发车间隔策略生成时刻表。
  73 + * @param paramObj 参数对象
  74 + * @param lpArray 路牌数组
  75 + * @constructor
  76 + */
  77 + BXPplaceClassesTime03 : function(paramObj, lpArray) {
  78 + // 参数对象
  79 + _paramObj = paramObj;
  80 +
  81 + // 1、初始化行车计划
  82 + var schedule = new InternalScheduleObj(_paramObj, lpArray, _factory);
  83 + schedule.initDataWithBxLayout();
  84 +
  85 + // 2、计算每个路牌的班型及对应工时
  86 + schedule.calcuLpBx_fg();
  87 +
  88 + // TODO：3、根据班型补充所有的不足班次
  89 +
  90 + // TODO：4、确定末班车
  91 +
  92 + // TODO：5、补进出场班次
  93 +
  94 +
  95 + //-------------------- 输出ganut图上的班次，班型描述 ----------------------//
  96 + var gBcData = schedule.toGanttBcArray();
  97 + // TODO：班型再议
  98 + return {'json':gBcData,'bxrcgs':null};
  99 +
  100 + }
  101 +
  102 + };
  103 +
  104 +}();
0 105 \ No newline at end of file
... ...
src/main/resources/static/pages/base/timesmodel/tepms/fcjx_temp.html
  View file @e16f191
... ... @@ -184,10 +184,10 @@
184 184 </div>
185 185 </div>
186 186 <div class="col-md-6">
187   - <label class="control-label col-md-5"><span class="required"> * </span>建议加班车数　:</label>
  187 + <label class="control-label col-md-5"><span class="required"> * </span>建议加班路牌数　:</label>
188 188 <div class="col-md-5">
189 189 <input type="text" class="form-control" name="jbclcount" id="jbclcount_id"
190   - placeholder="间隔">
  190 + placeholder="为0表示是周末时刻表">
191 191 </div>
192 192 </div>
193 193 </div>
... ... @@ -458,7 +458,7 @@
458 458 <div class="form-group">
459 459 <div class="col-md-6">
460 460 <label class="control-label col-md-5">
461   - <span class="required"> * </span> 建议加班车数　:
  461 + <span class="required"> * </span> 建议加班路牌数　:
462 462 </label>
463 463 <div class="col-md-4">
464 464 <p class="form-control-static" data-display="jbclcount"> </p>
... ...