base-fun.js 63.7 KB

Edit Raw Blame History

var BaseFun = function() {
	var baseF = {
			/**
			 * @discription : (TODO) 确定元素顺序。在javascript中，使用sort排序，如果这个参数被省略，那么元素将按照 ASCII 字符顺序进行升序排列。
			 *
			 * @params :  [v1--数值1；v2--数值2]
			 *
			 * @return :　⊙ 负值，如果所传递的第一个参数比第二个参数小。
			 *
			 * 			　⊙ 零，如果两个参数相等。
			 *
			 * 			　⊙ 正值，如果第一个参数比第二个参数大。
			 **/
			compare : function (v1,v2) {
				if(v1>v2)
					return 1;
				else if(v1<v2)
					return -1;
				else
					return 0;
			},
			/**
			 * @discription : (TODO) 对不同时段的车辆数进行顺序排序
			 *
			 * @params : 需要排序的数组对象
			 *
			 * @return : 返回一个具有一定顺序的数组对象。这里是返回的是在不同时段车辆数顺序的数组对象
			 *
			 **/
			sortGattDate :function(gattDate) {
				var array = new Array();//一定顺序的零时数组
				var len = gattDate.length;
				for(var i =0;i<len;i++) {
					if(array.indexOf(gattDate[i].num)<0)
						array.push(gattDate[i].num);
				}
				array.sort(baseF.compare);//排序(顺序)。如果compare这个参数被省略，那么元素将按照 ASCII 字符顺序进行升序排列。
				var sortGattArray = new Array();
				/** 给参数数组进行顺序排序 */
				for(var k =0;k<array.length;k++) {
					var index = array[k];
					for(var x=0;x<gattDate.length;x++) {
						if(index==gattDate[x].num)
							sortGattArray.push({"type":gattDate[x].type,"num":gattDate[x].num,"time":gattDate[x].time});
					}
				}
				return sortGattArray;
			},
			/**
			 * @discription : (TODO)获取车辆总数
			 *
			 * @params：len {Number}
			 *
			 * @return : 返回一个数组对象。这里返回的是一个封装好的路牌对象属性值
			 *
			 **/
			getYAxisCarArray : function (len) {
				var array = new Array();
				if(len>0) {
					for(var y = 0; y<len; y++) {
						array.push({lp:null,lpNo:y+1,lpName:y+1,lpType:'普通路牌'});//添加一个路牌对象
					};
				}
				return array;
			},
			/**
			 * @discription : (TODO)获取日期
			 *
			 * @params : 具有一定日期格式的字符串
			 *
			 * @return : 返回一个中国标准时间对象
			 **/
			getEndDate :function(date) {
			    var lastEndDate = Date.now();
			    if (date) {
			    	var str = date.replace(/-/g,"/");
			    	lastEndDate = new Date(str);
			    }
			    // Wed Oct 26 2016 00:00:00 GMT+0800 (中国标准时间)
			    return lastEndDate;
			},
			/**
			 * @discription : (TODO)获取吃饭时间
			 *
			 * @params : [h--小时数值；m--分钟数值]
			 *
			 * @return : 返回一个中国标准时间对象
			 **/
			getCFDate : function(h,m) {
				var $_date = new Date();
				$_date.setHours(h);
				$_date.setMinutes(m);
				return $_date;
			},
			/**
			 * @discription : (TODO)判断上下行出场
			 *
			 * @params : [t--当前车辆首班发车时间；qdzsbsj--起点站首班时间；zdzsbsj--终点站首班时间]
			 *
			 * @return : 返回出场结果。 [0--上行出场；1--下行出场]
			 **/
			issxclOrxxcl : function(t,qdzsbsj,zdzsbsj) {
				var qsj = baseF.getDateTime(qdzsbsj),
					zsj = baseF.getDateTime(zdzsbsj),
					cjxx = 0;// 默认是上行出场。 [0--上行出场；1--下行出场]
				if(qsj>zsj) {
					if(t<qsj)
						cjxx = 1;
				}else if(qsj<zsj) {
					 if(t<zsj)
						 cjxx = 1;
				}
				return cjxx;
			},
			/**
			 * @discription : (TODO)获取默认出场方向
			 *
			 * @params : 起终点站的首末班车时间
			 *
			 * @return : 返回方向结果. [0--上；1--下；2--未知].
			 *
			 **/
			getdefaultDir : function(list) {
				var qszsbsj = baseF.getDateTime(list[0].kssj);
					zdzsbsj = baseF.getDateTime(list[1].kssj);
				if(qszsbsj>zdzsbsj)
					return 1;
				else if(qszsbsj<zdzsbsj) {
					return 0;
				} else {
					return 2;
				}
			},

			/**
			 * @discription : (TODO) 封装成对存在(上、下[进出场里程、进出场时间、行驶时间、行驶里程、早晚餐]、午、晚餐时间)数组对象
			 *
			 * @params : [v1--成对的第一个值；v2--成对的第二个值]
			 *
			 * @return : 返回数组值。这里返回的是成对存在(上、下[进出场里程、进出场时间、行驶时间、行驶里程、早晚餐]、午、晚餐时间)数组对象.
			 *
			 * 			 [下标0代表成对的第一个值意--下标1代表成对的第二个值意]
			 **/
			formatPairing : function(v1,v2) {
				v1 = v1 == '' ? 0 : parseInt(v1);
				v2 = v2 == ''? 0 : parseInt(v2) ;
				return [v1,v2];
			},
			/**
			 * @discription : (TODO)封装起终点站成数组对象
			 *
			 * @params : [zd1--站点1；zd2--站点2]
			 *
			 * @return : 返回一个数组。这里返回的是一个起终点站数组对象。[下标0代表上--下标1代表下]
			 **/
			qzdz : function(zd1,zd2) {
				return [zd1,zd2];
			},
			/**
			 * @discription : (TODO) 获取班次方向
			 *
			 * @params : [fxtag--临时数值；cc--当前方向下标]
			 *
			 * @return : 返回一个数值。该数值代表方向下标
			 **/
			getfx : function(fxtag,cc) {
				var index = cc;
				if(fxtag>0) {
					if(cc==0)
						index = 1;
					else if(cc==1)
						index = 0;
				}
				return index;
			},
			/**
			 * @discription : (TODO) 判断是否为最后一个班次
			 *
			 * @params : [t1--当前计算时间；t2--结束时间；tzsj--停站时间；bcsj--班次历时]
			 *
			 * @return : 返回一个布尔值。
			 **/
			isLastbc : function(t1,t2,tzsj,bcsj) {
				var data = new Date(t1);
				data.setMinutes(data.getMinutes() + bcsj + tzsj);
				var tag = false;
				if(data>=t2)
					tag = true;
				return tag;
			},
			/**
			 * @discription : (TODO) 封装起终点站首末班车时间对成数组
			 *
			 * @params : [被封装的参数值]
			 *
			 * @return : 返回一个数组对象。这里返回的是起终点站首末班车时间对成数组。[下标0代表起始站的首末班车时间；下标1代表终点站的首末班车时间]
			 **/
			formatksjssj : function(gp) {
				return [{'kssj':gp.startStationFirstTime,'jssj':gp.startStationEndTime},{'kssj':gp.endStationFirstTime,'jssj':gp.endStationEndTime}];
			},
			/**
			 * @discription : (TODO) 获取结束时间格式字符串
			 *
			 * @params : [type--时间段类型；smbcsj--起终点站的首末班车时间对数组；tstr--时间段默认的结束时间格式字符串；index--下标]
			 *
			 * @return : 返回一个字符串。这里返回的是一个结束时间格式字符串。
			 **/
			getEndStrt : function(type,smbcsj,tstr,index) {
				if(type=='sm' || type=='et')
					tstr = smbcsj[index].jssj;
				return tstr;
			},
			/**
			 * @discription : (TODO) 封装一个时间段
			 *
			 * @pararms : []
			 *
			 * @return : 返回一个时间段。这里返回的是一个高峰时间段
			 *
			 **/
			getsd : function(st,ed) {
				return [{'st':st,'ed':ed}];
			},
			/**
			 * @discription : (TODO) 获取行驶时间
			 *
			 * @parmas : [zg--早高峰时间段；wg--晚高峰时间段；sj--当前时间；pc--平常行驶时间；gf--高峰行驶时间；dir--方向]
			 *
			 * @return : 返回一个数值。这里返回的是行驶时间数值
			 *
			 * */
			getxssj : function(zg,wg,sj,pc,gf,dir) {
				var xxsj = 0;
				if(baseF.isgfsjd(zg[0].st,zg[0].ed,sj) || baseF.isgfsjd(wg[0].st,wg[0].ed,sj))
					xxsj = gf[dir];
				else
					xxsj = pc[dir];
				return xxsj;
			},
			/**
			 * @discription : (TODO) 比较一个时间是否在某个时间段内
			 *
			 * @params : [st--开始时间；ed--结束时间；sj--当前时间]
			 *
			 * @return : 返回一个布尔值。这里判断一个时间是否在高峰时间段
			 *
			 **/
			isgfsjd : function(st,ed,sj) {
				var tag = false;
				if((sj<=ed || (sj-st)/60000<5 ) && (sj>=st || (st-sj)/60000<5))
					tag = true;
				return tag;
			},
			/**
			 * @discription : (TODO) 根据客流数据排列班次时刻数据.
			 *
			 * @params : [slotArray--不同时段的车辆数数组对象；ma--排列明细的参数属性值；ca--车辆数组对象；gatps--表单参数对象].
			 *
			 * @return : 返回一个具有一定数据格式的json数组。这里返回的是一个时刻表明细json数组.
			 **/
			KLplaceClassesTime : function(slotArray,ma,ca,gatps,sd,dataMap) {
				var jsonArray = new Array(),// 返回的json数组对象.
					cutCarArra = baseF.getCutCarArray_(ca,baseF.getArithmetic(slotArray)),// 获取不同时段的车辆数并分配予车辆.
					lbsj = gatps.lb=='' ? 0:parseInt(gatps.lb);
				var xhNo = 1;
				for(var c = 0;c<cutCarArra.length;c++) {
					var carArray = cutCarArra[c].car,time = cutCarArra[c].time.split('-'),
								   type =cutCarArra[c].type;
					for(var a =0;a<carArray.length;a++) {
						var _mmstartTime = baseF.getDateTime(gatps.earlyStartTime);// 获取早高峰开始时间点，并转为时间对象.
						var tempTime = new Date(_mmstartTime.setMinutes(_mmstartTime.getMinutes()-(ca.length-parseInt(carArray[a].lpNo))*ma[0].fcjx));
						var cctag = baseF.getdefaultDir(dataMap.smbcsjArr);// 获取出场类型 [0--上行出场；1--下行出场]
						var kssj = baseF.getDateTime(time[0]); // 获取该时段的开始时间点，并转为时间对象.
						var sjAndDir = baseF.getBeganTime(tempTime,kssj,type, ma,dataMap.zgfsjd,dataMap.wgfsjd,dataMap.pcxssjArr,dataMap.gfxxsjArr,cctag);// 计算当前路牌第一个首班时间点.
						kssj = sjAndDir.d1;
						cctag = sjAndDir.dir;
						var	endTime = baseF.getDateTime(
								baseF.getEndStrt(type,dataMap.smbcsjArr,time[1],cctag));// 获取该时段的结束时间点，并转为时间对象.
						var $_cfn = 0,$_cfw = 0;
						if(type !='ee') {
							jsonArray.push(baseF.getbcObj(
									kssj,dataMap.ccsjArr[cctag],carArray[a],dataMap.bcTypeArr.bd,
									dataMap.dira[cctag],xhNo++,0,gatps,0,null,null,null,0,lbsj));// 早行例保班次
						}
						jsonArray.push(baseF.getbcObj(
								kssj,dataMap.ccsjArr[cctag],carArray[a],dataMap.bcTypeArr.out,
								dataMap.dira[cctag],xhNo++,dataMap.cclcArr[cctag],gatps,0,dataMap.qdzArr[cctag],null,null,0,0));// 出场班次
						var fxTagDm = 0;
						while(kssj<=endTime) {
							cctag = baseF.getfx(fxTagDm,cctag);
							fxTagDm = 1;
							if(kssj> new Date (baseF.getCFDate(10,30)) &&
									kssj<new Date (baseF.getCFDate(12,0)) && $_cfn<1 ) {
								$_cfn++;
								jsonArray.push(baseF.getbcObj(
										kssj,dataMap.zwcArr[0],carArray[a],dataMap.bcTypeArr.cf,
										dataMap.dira[cctag],xhNo++,0,gatps,0,null,null,null,0,0));// 午餐班次
							}else if(kssj> new Date (baseF.getCFDate(18,30)) &&
										kssj<new Date (baseF.getCFDate(20,0)) && $_cfw<1 ) {
								$_cfw++;
								jsonArray.push(baseF.getbcObj(
										kssj,dataMap.zwcArr[1],carArray[a],dataMap.bcTypeArr.cf,
										dataMap.dira[cctag],xhNo++,0,gatps,0,null,null,null,0,0));// 晚餐班次
							}
							var _xxsj = baseF.getxssj(dataMap.zgfsjd,dataMap.wgfsjd,kssj,dataMap.pcxssjArr,dataMap.gfxxsjArr,cctag);// 获取行驶时间
							var tzsj = baseF.isLastbc(kssj,endTime,ma[0].tzjx,_xxsj)  ?  0 :　ma[0].tzjx;
							jsonArray.push(baseF.getbcObj(
									kssj,_xxsj,carArray[a],dataMap.bcTypeArr.normal,
									dataMap.dira[cctag],xhNo++,dataMap.pcxslcArr[cctag],gatps,0,
									dataMap.qdzArr[cctag],dataMap.zdzArr[cctag],null,tzsj,0));// 正常班次
							kssj = new Date(kssj.setMinutes(kssj.getMinutes() + ma[0].tzjx));
						}
						kssj = new Date(kssj.setMinutes(kssj.getMinutes() - ma[0].tzjx));
						jsonArray.push(baseF.getbcObj(kssj,dataMap.jcsjArr[cctag],carArray[a],
								dataMap.bcTypeArr.in_,dataMap.dira[cctag],xhNo++,dataMap.jclcArr[cctag],gatps,0,dataMap.qdzArr[cctag],null,null,0,0));// 进场班次
						if(type !='mm') {
							jsonArray.push(baseF.getbcObj(kssj,dataMap.jcsjArr[cctag],carArray[a],
									dataMap.bcTypeArr.lc,dataMap.dira[cctag],xhNo++,0,gatps,0,null,null,null,0,lbsj));// 晚班例保班次
						}
					}
				}
				return {'json':baseF.tzsmbcsj(baseF.setbcsAndfcno(jsonArray),dataMap.smbcsjArr,dataMap.ccsjArr,dataMap.cclcArr,dataMap.qdzArr,lbsj),
						'bxrcgs':null};
			},

			/**
			 * @description : (TODO) 根据班型人次与车辆总数排列班次时刻数据.
			 *
			 * @param [saa--数据配置参数;cara--路牌数组;map--表单配置参数;dataMap--方向成对的数据集合].
			 *
			 * @return  返回一个具有一定数据格式的json数组。这里返回的是一个时刻表明细json数组.
			 * */
			BXPplaceClassesTime : function(saa,cara,map,seMap,dataMap) {
				// console.log(saa , cara , map, seMap ,dataMap);
				/**
				 *  获取每个路牌下的从第一个班次的发车时间点到最后的结束时间点下所有的班次.
				 *
				 *  规则 :
				 *
				 * 		✿ 以早高峰开始时间点起,从最后一个路牌开始,每个相邻路牌的第一个班次发车时间相隔为发车间隙.
				 *
				 * 		✿ 每个路牌从第一个班次起往后加上该班次的行驶时间和停站时间 得到下一个班次的发车时间.以此类推.
				 *
				 * */
				var jsonArray = baseF.plgfbc(saa,cara,map,seMap,dataMap);
				// 切割班型人次.
				var list = baseF.splitBxRc(map.bxrc);
				/*var list ={'data': [{'hoursV':11.42,'minueV':"11:25",'rs':8,'type':"一工一休"},
				                {'hoursV':8.57,'minueV':"6:40",'rs':5,'type':"二工一休"},
				                {'hoursV':6.85,'minueV':"6:51",'rs':5,'type':"五工一休"}],'rsa':[8,5,5]};*/
				// 把班型人次按照规则合理的分配到不同的路牌上.
				baseF.getRankRule(list,cara,seMap);
				var bxrclist = list.data;
				var rs = new Array(),bxrcgs= new Array();
				// 遍历已分配好路牌的班型人次数组.
				for(var x = 0 ; x < bxrclist.length; x++) {
					// 定义当前班型人次下的路牌数组.
					var cla = bxrclist[x].sslp;
					// 定义当前班型人次下的工时.
					var hoursV = bxrclist[x].hoursV;
					// 遍历路牌
					for(var s = 0 ; s < cla.length; s++) {
						// 获取路牌编号.
						var lpNo = cla[s].lpNo;
						// 定义路牌下的所有班次.
						var lpbc = new Array();
						bxrcgs.push({'lpNo':lpNo,'hoursV':hoursV,'type':bxrclist[x].type});
						// 遍历班次数.
						for(var i =0 ; i <jsonArray.length; i++) {
							// 判断当期遍历的班次是否属于当前的路牌.
							if(jsonArray[i].lpNo == lpNo)
								lpbc.push(jsonArray[i]);
						}
						// 按照发车序号顺序排序.
						lpbc.sort(function(a,b){return a.fcno-b.fcno});
						// 调整班次数.也就是说调整工时.
						baseF.tzlpgs(lpbc,hoursV,map,dataMap,lpNo,saa);
						// baseF.addjclbbc(lpbc,dataMap,saa[0].lbsj,map)
						rs = rs.concat(lpbc);
					}
				}
				var jar = baseF.tzsmbcsj(baseF.setbcsAndfcno(rs),dataMap.smbcsjArr,dataMap.ccsjArr,dataMap.cclcArr,dataMap.qdzArr,saa[0].lbsj);
				var resultJA = new Array();
				for(var m = 0 ; m < cara.length; m++) {
					// 获取路牌编号.
					var lpNo_ = cara[m].lpNo;
					// 定义路牌下的所有班次.
					var lpbc_ = new Array();
					// 遍历班次数.
					for(var j =0 ; j <jar.length; j++) {
						// 判断当期遍历的班次是否属于当前的路牌.
						if(jar[j].lpNo == lpNo_)
							lpbc_.push(jar[j]);
					}
					// 按照发车序号顺序排序.
					lpbc_.sort(function(a,b){return a.fcno-b.fcno});
					resultJA = resultJA.concat(baseF.addjclbbc(lpbc_,dataMap,saa[0].lbsj,map));
				}
				return {'json':baseF.setbcsAndfcno(resultJA),'bxrcgs':bxrcgs};
			},

			/**
			 * @description : (TODO) 添加进出场班次、早晚例保班次.
			 *
			 * @param [bc--路牌下的所有班次;dataMap--参数信息;lbsj--例保时间]
			 *
			 */
			addjclbbc :　function(bc,dataMap,lbsj,gatps) {
				bc[bc.length-1].STOPTIME = 0;
				var result = new Array();
				var fcno = 0,dxfno = 0,stas = false;
				for(var b = 0 ; b < bc.length;b++) {
					var fxdm = baseF.dirDmToIndex(bc[b].xlDir);
					var car = {'lp':bc[b].lp, 'lpNo':bc[b].lpNo, 'lpName':bc[b].lpName, 'lpType':bc[b].lpType};
					if(b==0) {
						var dqbcfcsj = baseF.getDateTime(bc[b].fcsj);
						result.push(baseF.getbcObj(
								dqbcfcsj,dataMap.ccsjArr[fxdm],car,dataMap.bcTypeArr.bd,
								dataMap.dira[fxdm],1,0,gatps,0,null,null,null,0,lbsj));// 早行例保班次
						result.push(baseF.getbcObj(
								dqbcfcsj,dataMap.ccsjArr[fxdm],car,dataMap.bcTypeArr.out,
								dataMap.dira[fxdm],2,dataMap.cclcArr[fxdm],gatps,0,dataMap.qdzArr[fxdm],null,null,0,0));// 出场班次
						fcno ++;
					}else if(b > 0 && b < bc.length-1){
						var jcbckssj =  baseF.getDateTime(bc[b].ARRIVALTIME)
						var ccbckssj = baseF.getDateTime(bc[b+1].fcsj)
						var dx = parseInt((ccbckssj - jcbckssj)/60000);
						if(dx>30) {
							//console.log(bc[b].fcno);
							var fcno_ =  bc[b].fcno + 2;
							stas = true;
							// console.log(bc[b],bc[b+1],b);
							result.push(baseF.getbcObj(
									jcbckssj,dataMap.jcsjArr[fxdm],car,dataMap.bcTypeArr.in_,
									dataMap.dira[fxdm],fcno_++,dataMap.jclcArr[fxdm],gatps,0,dataMap.qdzArr[fxdm],null,null,0,0));// 进场班次
							var ccfx = baseF.dirDmToIndex(bc[b+1].xlDir);
							result.push(baseF.getbcObj(
									ccbckssj,dataMap.ccsjArr[ccfx],car,dataMap.bcTypeArr.out,
									dataMap.dira[ccfx],fcno_++,dataMap.cclcArr[ccfx],gatps,0,dataMap.qdzArr[ccfx],null,null,0,0));// 出场班次
						}
					}else if(b==bc.length-1){
						var fcno_ =  dxfno + 2;
						var qdbcddsj = baseF.getDateTime(bc[b].ARRIVALTIME);
						result.push(baseF.getbcObj(
								qdbcddsj,dataMap.jcsjArr[fxdm],car,dataMap.bcTypeArr.in_,
								dataMap.dira[fxdm],fcno_++,dataMap.jclcArr[fxdm],gatps,0,dataMap.qdzArr[fxdm],null,null,0,0));// 进场班次
						result.push(baseF.getbcObj(
								qdbcddsj,dataMap.jcsjArr[fxdm],car,dataMap.bcTypeArr.lc,
								dataMap.dira[fxdm],fcno_++,0,gatps,0,null,null,null,0,lbsj));// 晚班例保班次
					}
					dxfno = bc[b].fcno + fcno;
					bc[b].fcno = dxfno;
					if(stas) {
						fcno ++;
						stas = false;
					}
					result.push(bc[b]);
				}

				return result;
			},


			/**
			 * @description : (TODO) 调整某路牌下的工时.
			 *
			 * @param [arr--当前路牌下的班次数组;gs--当前路牌的总工时;dataMap--参数信息;lpNo--路牌编码;saa--参数信息]
			 *
			 * */
			tzlpgs : function(arr,gs,map,dataMap,lpNo,saa) {
				// 定义当前路牌的进场时间、早晚例保时间.
				var jczwsj = saa[0].lbsj*2 + dataMap.ccsjArr[baseF.dirDmToIndex(arr[0].xlDir)] +
							 dataMap.jcsjArr[baseF.dirDmToIndex(arr[arr.length-1].xlDir)];
				// 定义开始、结束时间.
				var st = null , ed = null;
				// 根据路牌编码依次轮流取高峰之间和晚高峰之后的时间段.
				if(lpNo%2!=0) {
					st = dataMap.gfzjsjd[0].st;
					ed = dataMap.gfzjsjd[0].ed;
				}else {
					st = dataMap.wgfzhsjd[0].st;
					ed = dataMap.wgfzhsjd[0].ed;
				}
				// 定义路牌总工时.第一次切高峰之间和晚高峰之后的班次.
				var lpdqzgs = parseFloat(((baseF.getlpzgs(arr) + jczwsj)/60).toFixed(2));
				// 判断总工时是否大于班型对应的工时.
				if(lpdqzgs>gs) {
					// 定义相差值.
					var dx = parseFloat((lpdqzgs - gs).toFixed(2));
					// 定义圈数.
					var qs = Math.round(dx*60/70);
					for(var t = 0 ; t<arr.length;t++) {
						// 得到当前路牌下的发车时间.
						var dqbcfcsj = baseF.getDateTime(arr[t].fcsj);
						// 判断时间范围.
						if(dqbcfcsj>st && dqbcfcsj<ed) {
							arr[t-1].STOPTIME = 0;
							// 切割.
							arr.splice(t,qs*2);
							break;
						}
					}
					// 再次计算总工时.第二次切早高峰之前的班次.
					lpdqzgs = parseFloat(((baseF.getlpzgs(arr) + jczwsj)/60).toFixed(2));
					// 判断差值是否在一个小时范围内.
					if( lpdqzgs - gs > 1) {
						// 遍历
						for(var z = 0 ; z<arr.length;z++) {
							// 得到当前路牌下的发车时间.
							var dqbcfcsj = baseF.getDateTime(arr[z].fcsj);
							// 判断时间范围.
							if(dqbcfcsj>dataMap.zgfzqsjd[0].st && dqbcfcsj<dataMap.zgfzqsjd[0].ed) {
								arr.splice(z,1);
								z--;
							}
						}
					}
					// 再次计算总工时.第三次切高峰之间的班次.
					lpdqzgs = parseFloat(((baseF.getlpzgs(arr) + jczwsj)/60).toFixed(2));
					if( lpdqzgs - gs > 1) {
						var dx_ = parseFloat((lpdqzgs - gs).toFixed(2));
						var qs_ = Math.round(dx_*60/70);
						for(var i = 0 ; i<arr.length;i++) {
							var dqbcfcsj = baseF.getDateTime(arr[i].fcsj);
							if(dqbcfcsj>dataMap.gfzjsjd[0].st && dqbcfcsj<dataMap.gfzjsjd[0].ed) {
								arr[i-1].STOPTIME = 0;
								arr.splice(i,qs_*2);
								break;
							}
						}
					}
				}
			},

			/**
			 *
			 *
			 * */
			getlpzgs : function(list) {
				var num = 0;
				for(var i = 0 ; i<list.length; i++) {
					num = num + list[i].bcsj + list[i].STOPTIME;
				}
				return num;
			},

			/**
			 * @description : (TODO) 根据班型人次获取每个路牌下的工时.把班型人次按照规则合理的分配到不同的路牌上.
			 *
			 * @param [list--班型人次数据;clzs--路牌数组;seMap--参数信息]
			 *
			 * @return 返回一个每个路牌下对应的总工时.
			 * */
			getRankRule : function(list,clzs,seMap) {
				// 定义班型人次数据的长度.路牌数组长度.
				var bxgs = list.data.length,clzslen = clzs.length;

				/**
				 * 分配规则：获取总人数与车辆数的关系.返回值[-1-- 总人数小与车辆总数; 0--总人数等于车辆数; 1--总人数大与车辆数]
				 *
				 * 			✿ ① 当返回值为-1时：则总人数小于车辆数. 相当于人少车辆多.
				 *
				 * 			✿ ② 当返回值为0时： 则总人数等于车辆数. 相当于人和车均匀.
				 *
				 * 			✿ ③ 当返回值为1时： 则总人数大于车辆数. 相当于人多车辆少.
				 *
				 *
				 * */
				switch(baseF.isrcNumEqualCarNum(list.rsa,clzslen)){
					case -1:
						break;
					case 0:
						// 判断.班型人次是否为一种还是多种情况.
						if(bxgs==1) {
							// 当只为一种情况时.这所有路牌都为一个班型.
							list.data[0].sslp = clzs;
						}else if(bxgs>=2) {
							// 当有2种或者2种以上的班型人次组合时.需要合理的分配.
							baseF.fprclp(bxgs,list,clzs);
						}
						break;
					case 1:
						// 定义最大工时值.
						var maxhoursV = parseFloat((((baseF.getDateTime(seMap.e) - baseF.getDateTime(seMap.s))/60000)/60).toFixed(2));
						// 定义总人数.
						var rsdx = 0 ;
						for(var n = 0 ; n < list.rsa.length;n++) {
							rsdx =rsdx + list.rsa[n];
						}
						// 定义总人数与车辆的差值.
						var _rcDx = rsdx - clzslen;
						// 定义班型人次组合对象.
						var zhHoursA = new Array();
						for(var b = 0 ; b<bxgs;b++) {
							var dqhours = list.data[b].hoursV;
							for(var a = b ; a<bxgs; a++) {
								var pphours = list.data[a].hoursV;
								var zhnum = pphours+dqhours;
								if(zhnum>maxhoursV)
									continue;
								else if(zhnum<maxhoursV) {
									zhHoursA.push({'bx1':list.data[b].type,'bx2':list.data[a].type,'countGs':zhnum});
								}

							}
						}
						// 按照工时倒序排序.
						zhHoursA.sort(function(a,b){return b.countGs-a.countGs});
						var bxppA = zhHoursA[0],clp = null,dlp = null,pqobj = new Array(),bxpprc= new Array();
						for(var m = 0 ; m<list.data.length;m++) {
							if(list.data[m].type==bxppA.bx1 || list.data[m].type==bxppA.bx2) {
								bxpprc.push(list.data[m].rs);
								var czDx = list.data[m].rs - _rcDx;
								if(czDx<0) {
									var djbctype = null,absInt = Math.abs(czDx);
									if(list.data[m].type==bxppA.bx1)
										djbctype = bxppA.bx2;
									else if(list.data[m].type==bxppA.bx2)
										djbctype = bxppA.bx1;
									var bqbc = zhHoursA[1];
									for(var k  = 0 ; k<bxgs ; k++) {
										if(list.data[k].type == djbctype)
											list.data[k].rs = list.data[k].rs + Math.abs(czDx);
										if(list.data[k].type==bqbc.bx1 || list.data[k].type==bqbc.bx2) {
											if(bqbc.bx1==bqbc.bx2)
												list.data[k].rs = list.data[k].rs -  absInt*2;
											else if(bqbc.bx1!=bqbc.bx2)
												list.data[k].rs = list.data[k].rs -  absInt;
										}
									}
									pqobj.push({'type':bqbc.bx1 + '</br></br>' + bqbc.bx2 ,'minueV':bqbc.countGs,'rs':absInt});
								}
								czDx = czDx < 0 ? 0:czDx;
								list.data[m].rs =  czDx;
								if(list.data[m].rs<=0) {
									list.data.splice(m,1);
									m--;
								}
							}
						}
						list.data.push({'type':bxppA.bx1 + '</br></br>' + bxppA.bx2 ,
										'minueV' : bxppA.countGs,
										'rs':Math.min.apply(null, bxpprc) <_rcDx ? Math.min.apply(null, bxpprc) : _rcDx});
						if(pqobj.length>0)
							list.data.push(pqobj[0]);
						list.data.sort(function(a,b){return b.rs-a.rs});
						baseF.fprclp(list.data.length,list,clzs);
						break;
					default:
						console.log('数据格式错误...');
				}
			},

			/**
			 * @description (TODO) 把班型人次合理的分配到不同的路牌上.
			 *
			 * @param [bxgs--班型人次数组长度;list--班型人次数组集合;clzs--路牌数组]
			 *
			 * @return 返回一个把路牌合理的分配到班型人次下组成的数据集合.
			 * */
			fprclp : function(bxgs,list,clzs) {
				// 定义总人数.
				var dxcount = 0;
				for(var t = 1 ; t<bxgs ; t++) {
					dxcount = dxcount + list.data[t].rs;
				}
				// 最多人次与总人次的比例.
				var blnum = Math.round(list.data[0].rs/dxcount);
				var rs = new Array();
				// 遍历
				for(var r = 0 ; r<bxgs ;r++) {
					// 得到没有分配出去的路牌.
					var dxa = baseF.chaji_array(clzs,rs);
					// 定义当前人次数.
					var rsnum = list.data[r].rs;
					// 定义记录当前分割路牌的次数下标.分配到班型人次下的路牌数组.
					var index = 0,sslp = new Array();
					// 当前人次所有占比例.
					var tempint = parseInt(rsnum/blnum);
					// 判断如果比例小1 则为当前人次数.
					blnum = tempint <=1 ? rsnum : blnum;
					// 判断当前班型人次数组下标值.如果为倒数第二个或者之前
					if(r<bxgs-1) {
						// 遍历
						for(var c = 0 ; c<tempint;c++) {
							// 创建新的没有分配出去的路牌数组.
							var temp = dxa.concat();
							// 创建切割路牌数组.
							var tagA = new Array();
							// 判断切割的下标值是否小于等于路牌数组的倒数第二个或者之前.
							if(index<=dxa.length-blnum) {
								tagA = temp.splice(index,blnum);
							}else {
								tagA = temp.splice(dxa.length-blnum,blnum);
							}
							// 组合切割路牌数组.赋值给已分配出去的路牌.
							rs = rs.concat(tagA);
							// 赋值给分配到班型人次下的路牌数组.
							sslp = sslp.concat(tagA);
							// 记录切割下标.
							index = index + 1 + blnum;
						}
						// 分配到班型人次下的路牌数组.
						list.data[r].sslp = sslp;
					}else {
						list.data[r].sslp = dxa;
					}
				}
			},

			getMaxgys : function(v1,v2) {
				var temp=v1;
				while (v1!=0){
				    temp=v2%v1;
				    v2=v1;
				    v1=temp;
				}
				return v2;
			},

			/**
			 * @description : (TODO) 判断人次总数与车辆总数的关系.
			 *
			 * @param
			 *
			 * @return 返回一个布尔
			 * */
			isrcNumEqualCarNum : function(sra,clcount) {
				var count = 0,tag = null;
				for(var r = 0 ; r < sra.length; r++) {
					count = count + sra[r];
				}
				if(count==clcount)
					tag = 0;
				else if(count<clcount)
					tag = -1;
				else if(count>clcount)
					tag = 1;
				return tag;
			},

			plgfbc : function(saa , cara , map, seMap ,dataMap) {
				var len = cara.length,rs = new Array();
				var lbsj = map.lb=='' ? 0:parseInt(map.lb);
				for(var c = 0 ; c<len ; c++) {
					// 铺出所有的班次
					var _mmstartTime = baseF.getDateTime(map.earlyStartTime);// 获取早高峰开始时间点，并转为时间对象.
					var tempTime = new Date(_mmstartTime.setMinutes(_mmstartTime.getMinutes()-(len - cara[c].lpNo)*saa[0].fcjx));
					var kssj = dataMap.zgfsjd[0].st;
					var cctag = baseF.getdefaultDir(dataMap.smbcsjArr);// 获取出场类型 [0--上行出场；1--下行出场]
					var sjAndDir = baseF.getBeganTime(tempTime,kssj,null, saa,dataMap.zgfsjd,dataMap.wgfsjd,dataMap.pcxssjArr,dataMap.gfxxsjArr,cctag);// 计算当前路牌第一个首班时间点.
					kssj = sjAndDir.d1;
					cctag = sjAndDir.dir;
					var endTime = baseF.getDateTime(seMap.e),fxTagDm = 0 , xhNo = 3,$_cfn = 0,$_cfw = 0;
					while(kssj<=endTime) {
						cctag = baseF.getfx(fxTagDm,cctag);
						fxTagDm = 1;
						if(kssj> new Date (baseF.getCFDate(10,30)) &&
								kssj<new Date (baseF.getCFDate(12,0)) && $_cfn<1 ) {
							$_cfn++;
							rs.push(baseF.getbcObj(
									kssj,dataMap.zwcArr[0],cara[c],dataMap.bcTypeArr.cf,
									dataMap.dira[cctag],xhNo++,0,map,0,null,null,null,0,0));// 午餐班次
						}else if(kssj> new Date (baseF.getCFDate(18,30)) &&
									kssj<new Date (baseF.getCFDate(20,0)) && $_cfw<1 ) {
							$_cfw++;
							rs.push(baseF.getbcObj(
									kssj,dataMap.zwcArr[1],cara[c],dataMap.bcTypeArr.cf,
									dataMap.dira[cctag],xhNo++,0,map,0,null,null,null,0,0));// 晚餐班次
						}
						var _xxsj = baseF.getxssj(dataMap.zgfsjd,dataMap.wgfsjd,kssj,dataMap.pcxssjArr,dataMap.gfxxsjArr,cctag);// 获取行驶时间
						var tzsj = baseF.isLastbc(kssj,endTime,saa[0].tzjx,_xxsj)  ?  0 :　saa[0].tzjx;
						rs.push(baseF.getbcObj(
								kssj,_xxsj,cara[c],dataMap.bcTypeArr.normal,
								dataMap.dira[cctag],xhNo++,dataMap.pcxslcArr[cctag],map,0,
								dataMap.qdzArr[cctag],dataMap.zdzArr[cctag],null,tzsj,0));// 正常班次
						kssj = new Date(kssj.setMinutes(kssj.getMinutes() + saa[0].tzjx));
					}
 				}
				return rs;
			},

			getGfData : function (type, saa , cara , map, seMap ,dataMap,len,car) {
				var _mmstartTime = null,kssj = null,end = null ,result = new Array(),fxTagDm = 0 , xhNo = 0;
				if(type == 'mm') {
					_mmstartTime = baseF.getDateTime(map.earlyStartTime);// 获取早高峰开始时间点，并转为时间对象.
					kssj = dataMap.zgfsjd[0].st; // 获取该时段的开始时间点，并转为时间对象.
					end =  dataMap.zgfsjd[0].ed;
				}else if(type == 'ee'){
					_mmstartTime = baseF.getDateTime(map.lateStartTime);// 获取晚高峰开始时间点，并转为时间对象.
					kssj = dataMap.wgfsjd[0].st; // 获取该时段的开始时间点，并转为时间对象.
					end =  dataMap.wgfsjd[0].ed;
				}
				var tempTime = new Date(_mmstartTime.setMinutes(_mmstartTime.getMinutes()-(len - car.lpNo)*saa[0].fcjx));
				var cctag = baseF.getdefaultDir(dataMap.smbcsjArr);// 获取出场类型 [0--上行出场；1--下行出场]
				var sjAndDir = baseF.getBeganTime(tempTime,kssj,type, saa,dataMap.zgfsjd,dataMap.wgfsjd,dataMap.pcxssjArr,dataMap.gfxxsjArr,cctag);// 计算当前路牌第一个首班时间点.
				kssj = sjAndDir.d1;
				cctag = sjAndDir.dir;
				while(kssj<=end) {
					cctag = baseF.getfx(fxTagDm,cctag);
					fxTagDm = 1;
					var _xxsj = dataMap.gfxxsjArr[cctag];// 获取行驶时间
					var tzsj = baseF.isLastbc(kssj,end,saa[0].tzjx,_xxsj)  ?  0 :　saa[0].tzjx;
					result.push(baseF.getbcObj(
							kssj,_xxsj,car,dataMap.bcTypeArr.normal,
							dataMap.dira[cctag],xhNo++,dataMap.pcxslcArr[cctag],map,0,
							dataMap.qdzArr[cctag],dataMap.zdzArr[cctag],null,tzsj,0));// 正常班次
					kssj = new Date(kssj.setMinutes(kssj.getMinutes() + saa[0].tzjx));
				}
				return result;
			},

			splitBxRc : function(str) {
				var list = new Array(),rsa = new Array();;
				var gsgd = baseF.getBxLs();
				var bxrcAr = str.split(',');
				for(var s = 0 ; s< bxrcAr.length;s++) {
					var s1a = bxrcAr[s].split('/');
					var rs = parseInt(s1a[1]);
					var gsgdIndex = 0,hoursV = 0.0,minueV='' ;
					for(var g = 0 ; g < gsgd.length; g++) {
						if(gsgd[g].type == s1a[0]) {
							gsgdIndex = g;
							hoursV = gsgd[g].hoursV;
							minueV = gsgd[g].minueV;
						}
					}
					list.push({'type':s1a[0],
							   'rs':rs,
							   'hoursV':hoursV,
							   'minueV':minueV});
					rsa.push(rs);
				}
				return {'data':list.sort(function(a,b){return b.rs-a.rs}),'rsa':rsa.sort().reverse()};
			},

			/**
			 * @description : (TODO) 定义工时规定.
			 *
			 * @return 返回一个工时规定数组集合.
			 * */
			getBxLs : function() {
				return [{'type':'六工一休','hoursV':6.66,  'minueV':'6:40'},
			            {'type':'五工一休','hoursV':6.85,  'minueV':'6:51'},
			            {'type':'四工一休','hoursV':7.14,  'minueV':'7:08'},
			            {'type':'三工一休','hoursV':7.61,  'minueV':'7:37'},
			            {'type':'二工一休','hoursV':8.57,  'minueV':'8:34'},
			            {'type':'一工一休','hoursV':11.42, 'minueV':'11:25'},
			            {'type':'五工二休','hoursV':7.99,  'minueV':'8:00'},
			            {'type':'无工休',  'hoursV':5.43,  'minueV':'5:43'}];
			},
			setbcsAndfcno : function(listA) {
				/*var array = new Array();
				var len = listA.length;
				for(var i =0;i<len;i++) {
					if(array.indexOf(listA[i].lpNo)<0)
						array.push(listA[i].lpNo);
				}
				array.sort(baseF.compare);
				console.log(array);
				var sortGattArray = new Array();
				for(var k =0;k<array.length;k++) {
					var index = array[k];
					var temp = new Array();
					for(var x=0;x<listA.length;x++) {
						if(index==listA[x].lpNo)
							temp.push(listA[x]);
					}
					var lpbc = baseF.sortDirArray(temp);
					for(var p = 0 ;p<lpbc.length;p++) {
						lpbc[p].fcno = (p+1);
					}
					sortGattArray = sortGattArray.concat(lpbc);
				}
				for(var b = 0 ; b <sortGattArray.length;b++) {
					sortGattArray[b].bcs = (b+1);
				}
				return sortGattArray;*/
				var array = new Array();
				var len = listA.length;
				for(var i =0;i<len;i++) {
					if(array.indexOf(listA[i].lpNo)<0)
						array.push(listA[i].lpNo);
				}
				array.sort(baseF.compare);
				var sortGattArray = new Array();
				for(var k =0;k<array.length;k++) {
					var index = array[k];
					var temp = new Array();
					for(var x=0;x<listA.length;x++) {
						if(index==listA[x].lpNo)
							temp.push(listA[x]);
					}
					sortGattArray = sortGattArray.concat(baseF.pxarr(temp));
				}
				var bcs = 1,fcno_=1,temp = sortGattArray[0].lpNo;
				for(var p =0;p<len;p++) {
					sortGattArray[p].bcs = bcs;
					bcs++;
					if(temp==sortGattArray[p].lpNo){
						sortGattArray[p].fcno = fcno_;
						fcno_++;
					}else {
						fcno_ = 1;
						temp = sortGattArray[p].lpNo;
						sortGattArray[p].fcno = fcno_;
						fcno_++;
					}
				}
				return sortGattArray;
			},
			/**
			 * @discription : (TODO) 调整首末班车时间点
			 *
			 * @params : [list--时刻表明细数组；smbcsj--首末班车时间]
			 *
			 * @return : 返回一个数组对象。这里返回的是时刻表明细数据
			 **/
			tzsmbcsj : function(list,smbcsj,sj,cl,zd,lbsj) {
				var _obj = baseF.getsxAndxxbc(list);
				baseF.tcbc(_obj.sxbc,smbcsj[0].kssj,smbcsj[0].jssj);// 剔除上行不在时间范围内的班次
				baseF.tcbc(_obj.xxbc,smbcsj[1].kssj,smbcsj[1].jssj);// 剔除下行不在时间范围内的班次
				baseF.dzsmsj(_obj.sxbc,smbcsj[0].kssj,smbcsj[0].jssj,_obj.xxbc);// 调整上行首末班车时间
				baseF.dzsmsj(_obj.xxbc,smbcsj[1].kssj,smbcsj[1].jssj,_obj.sxbc);// 调整下行首末班车时间
				baseF.tzqtbc(_obj.sxbc,_obj.qt,sj,cl,zd,lbsj);
				baseF.tzqtbc(_obj.xxbc,_obj.qt,sj,cl,zd,lbsj);
				return _obj.sxbc.concat(_obj.xxbc).concat(_obj.qt);
			},
			tcbc : function(ar,kssj,jssj) {
				for(var s = 0 ; s<ar.length;s++) {
					if(baseF.isDelete(baseF.getDateTime(kssj),
										baseF.getDateTime(jssj),
										baseF.getDateTime(ar[s].fcsj))) {
						ar.splice(s, 1);
					}
				}
			},
			dzsmsj : function(ar,kssj,jssj,list) {
				var array = baseF.getsjArr(ar);
				if(baseF.getTimeStr(new Date(Math.min.apply(null, array))) != kssj) {
					baseF.upfcsj(ar,baseF.getTimeStr(new Date(Math.min.apply(null, array))),kssj,'before',list);
				}
				if(baseF.getTimeStr(new Date(Math.max.apply(null, array))) != jssj) {
					baseF.upfcsj(ar,baseF.getTimeStr(new Date(Math.max.apply(null, array))),jssj,'later',list);
				}
			},
			upfcsj : function(ar,str,sj,temp,list) {
				for(var r = 0 ;r<ar.length;r++) {
					if(ar[r].fcsj == str) {
						ar[r].fcsj = sj;
						var startTime = baseF.getDateTime(sj);
						ar[r].ARRIVALTIME = baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()+ar[r].bcsj)));
						if(temp=='before') {
							var _dx =  baseF.gettzsj(list,ar[r].bcs+1,ar[r].lpNo,ar[r].ARRIVALTIME,temp);
							ar[r].STOPTIME = _dx;
						}else if(temp=='later')
							baseF.gettzsj(list,ar[r].bcs-1,ar[r].lpNo,ar[r].fcsj,temp);
					}
				}
			},
			gettzsj : function(list,bcs,lpNo,sj,temp) {
				var _dx = 0;
				for(var t = 0;t<list.length;t++) {
					if(list[t].lpNo==lpNo  && list[t].bcs == bcs) {
						if(temp=='before') {
							_dx =  (baseF.getDateTime(list[t].fcsj) - baseF.getDateTime(sj))/60000;
						}else if(temp=='later'){
							_dx =  (baseF.getDateTime(sj) - baseF.getDateTime(list[t].ARRIVALTIME))/60000;
							list[t].STOPTIME = _dx;
						}
					}
				}
				return _dx;
			},

			getsjArr : function(ar) {
				var tempArray = new Array();
				for(var j = 0 ; j<ar.length;j++) {
					var newDate = new Date();
					var strArray = ar[j].fcsj.split(':');
					newDate.setHours(strArray[0]);
					newDate.setMinutes(strArray[1]);
					tempArray.push(newDate.getTime());
				}
				return tempArray;
			},

			tzqtbc : function(list,qt,sj,cl,zd,lbsj) {
				var array = baseF.getsjArr(list);
				for(var i =0 ; i<list.length;i++ ) {
					if(list[i].fcsj == baseF.getTimeStr(new Date(Math.min.apply(null, array)))) {
						baseF.updjcbc(qt,list[i],sj,cl,zd,lbsj,'ccbc');
					}else if(list[i].fcsj	== baseF.getTimeStr(new Date(Math.max.apply(null, array)))) {
						baseF.updjcbc(qt,list[i],sj,cl,zd,lbsj,'jcbc');
					}
				}
			},

			updjcbc : function(ar,obj,sj,cl,zd,lbsj,lx) {
				var cctag = baseF.dirDmToIndex(obj.xlDir);
				for(var r = 0; r<ar.length;r++) {
					if(lx=='ccbc') {
						if(ar[r].lpNo == obj.lpNo && ar[r].fcno <obj.fcno) {
							var startTime = baseF.getDateTime(obj.fcsj);
							if(ar[r].bcType=='out') {
								ar[r].bcsj = sj[cctag];
								ar[r].fcsj = baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()-sj[cctag])));
								ar[r].ARRIVALTIME = obj.fcsj;
								ar[r].qdz = zd[zd];
								ar[r].jhlc = cl[cctag];
							}else if(ar[r].bcType =='bd') {
								ar[r].ARRIVALTIME = baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()-sj[cctag])));
								ar[r].fcsj = baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()-lbsj)));
							}
							ar[r].xlDir = obj.xlDir;
						}
					}else if(lx=='jcbc') {
						if(ar[r].lpNo == obj.lpNo && ar[r].fcno > obj.fcno) {
							var startTime = baseF.getDateTime(obj.ARRIVALTIME);
							if(ar[r].bcType=='in') {
								ar[r].bcsj = sj[cctag];
								ar[r].fcsj = obj.ARRIVALTIME ;
								ar[r].ARRIVALTIME = baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()+sj[cctag])));
								ar[r].qdz = zd[zd];
								ar[r].jhlc = cl[cctag];
							}else if(ar[r].bcType =='lc') {
								ar[r].fcsj =  baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()+sj[cctag])));
								ar[r].ARRIVALTIME =  baseF.getTimeStr(new Date(startTime.setMinutes(startTime.getMinutes()+lbsj)));
							}
							ar[r].xlDir = obj.xlDir;
						}
					}
				}
			},

			dirDmToIndex : function (str) {
				if(str == 'relationshipGraph-up')
					return 0;
				else if(str == 'relationshipGraph-down')
					return 1;
			},

			isDelete : function(t1,t2,t) {
				var tag = false;
				if(t<t1 || t>t2)
					tag = true;
				return tag;
			},

			getsxAndxxbc : function(json) {
				var upArray = new Array(),downArray = new Array(),qt = new Array();
            	for(var j = 0 ; j< json.length ; j++) {
            		if(json[j].bcType=='normal' || json[j].bcType=='region') {
            			if(json[j].xlDir == 'relationshipGraph-up')
                			upArray.push(json[j]);
                		else if(json[j].xlDir == 'relationshipGraph-down')
                			downArray.push(json[j]);
            		}else {
            			qt.push(json[j]);
            		}
            	}
            	return {'sxbc' : upArray,'xxbc' : downArray,'qt': qt};
			},
			/**
			 * @description : (TODO) 在同一块路牌下,根据发车序号进行顺序排序
			 *
			 * @params : [a1--需要排序的数组]
			 *
			 * @return : 返回一个数组.这里返回的是一个在同一块路牌下,根据发车序号排好顺序的班次数组
			 **/
			pxarr : function (a1) {
				var array = new Array();
				var len = a1.length;
				for(var i =0;i<len;i++) {
					if(array.indexOf(a1[i].fcno)<0)
						array.push(a1[i].fcno);
				}
				array.sort(baseF.compare);
				var sortGattArray = new Array();
				for(var k =0;k<array.length;k++) {
					var index = array[k];
					for(var x=0;x<a1.length;x++) {
						if(index==a1[x].fcno)
							sortGattArray.push(a1[x]);
					}
				}
				return sortGattArray;
			},
			addbc : function(obj,lastObj,kssj,tzsj,xhNo,jsonArray,num) {
				var cctag = baseF.dirDmToIndex(lastObj.xlDir);
				var carArray = {'lp':lastObj.lp,'lpNo':lastObj.lpNo,'lpName':lastObj.lpName,'lpType':lastObj.lpType};
				var ags =  {'tcc_id':lastObj.tcc,'skbName':lastObj.ttinfo,'lineName':lastObj.xl+'_'};
				for(var t = 0 ; t<num;t++){
					cctag = baseF.getfx(1,cctag);
					var _xxsj = baseF.getxssj(obj.configuration.dataMap.zgfsjd,
											obj.configuration.dataMap.wgfsjd,
											kssj,
											obj.configuration.dataMap.pcxssjArr,
											obj.configuration.dataMap.gfxxsjArr,cctag);// 获取行驶时间
					var temptzsj = t == num-1 ? 0 : tzsj;
					jsonArray.push(baseF.getbcObj( kssj,
												_xxsj,
												carArray,
												'normal',
												obj.configuration.dataMap.dira[cctag],
												xhNo++,
												obj.configuration.dataMap.pcxslcArr[cctag],
												ags,0,
												obj.configuration.dataMap.qdzArr[cctag],
												obj.configuration.dataMap.zdzArr[cctag],
												null,temptzsj,0));
					// kssj = new Date(kssj.setMinutes(kssj.getMinutes() + temptzsj));
					kssj.setMinutes(kssj.getMinutes() + temptzsj)
				}
				lastObj.STOPTIME = 10;
			},

			/**
			 * @description : (TODO) 获取某个路牌下的最后一个班次对象
			 *
			 * @params : [$_jsonD--班次数组;carName--路牌名称]
			 *
			 * @return : 返回一个map结构的Object对象.这里返回的是某个路牌下的最后一个班次对象
			 */
			getLastTime  : function ($_jsonD,carName) {
				var $_len =$_jsonD.length,tempArray = new Array(),$_data = new Array(),result = new Array();
				for(var j = 0 ; j<$_len;j++) {
					if($_jsonD[j].lpNo == carName &&　$_jsonD[j].bcType　=='normal') {
						var newDate = new Date();
						var strArray = $_jsonD[j].ARRIVALTIME.split(':');
						newDate.setHours(strArray[0]);
						newDate.setMinutes(strArray[1]);
						tempArray.push(newDate.getTime());
						$_data.push($_jsonD[j]);
					}
				}
				var strTime  = baseF.getTimeStr(new Date(Math.max.apply(null, tempArray)));
				for(var i = 0 ; i<$_data.length;i++) {
					if(strTime == $_data[i].ARRIVALTIME && carName ==  $_data[i].parent) {
						result.push($_data[i]);
						continue;
					}

				}
				return result;
			},

			getlpFirstSj : function(arr,lpNo) {
				var dqlpbc = new Array();
				for(var a = 0 ; a < arr.length; a++) {
					if(arr[a].lpNo == lpNo && arr[a].bcType == $_GlobalGraph.configuration.dataMap.bcTypeArr.normal)
						dqlpbc.push(arr[a]);
				}
				dqlpbc.sort(function(a,b){return a.fcno-b.fcno});
				return dqlpbc.length>0 ? baseF.getDateTime(dqlpbc[0].fcsj) : $_GlobalGraph.configuration.dataMap.zgfsjd[0];
			},

			addlpbc : function(obj,bf,theCar,numqs) {
				var car = new Object(),xhNo = 1,dqlpbc = new Array();
				for(var t =0 ; t< obj.configuration.taskTypes.length;t++) {
					if(obj.configuration.taskTypes[t].lpNo == theCar)
						car = obj.configuration.taskTypes[t];
				}
				// console.log(obj.configuration);
				var _mmstartTime = new Date(obj.configuration.dataMap.zgfsjd[0].st);
				var tempTime = new Date(_mmstartTime.setMinutes(_mmstartTime.getMinutes()-
						((parseInt(obj.configuration.dataMap.map.clzs)-parseInt(theCar)))*obj.configuration.stopAraay[0].fcjx));
				var cctag = bf.getdefaultDir(obj.configuration.dataMap.smbcsjArr);// 获取出场类型 [0--上行出场；1--下行出场]
				var kssj = new Date(obj.configuration.dataMap.zgfsjd[0].st); // 获取该时段的开始时间点，并转为时间对象.
				var sjAndDir = bf.getBeganTime(tempTime,kssj,null,
							obj.configuration.stopAraay,
							obj.configuration.dataMap.zgfsjd,
							obj.configuration.dataMap.wgfsjd,
							obj.configuration.dataMap.pcxssjArr,
							obj.configuration.dataMap.gfxxsjArr,cctag);// 计算当前路牌第一个首班时间点.
				kssj = sjAndDir.d1;
				cctag = sjAndDir.dir;
				dqlpbc.push(bf.getbcObj(
						kssj,obj.configuration.dataMap.ccsjArr[cctag],
						car,obj.configuration.dataMap.bcTypeArr.bd,
						obj.configuration.dataMap.dira[cctag],xhNo++,0,
						obj.configuration.dataMap.map,0,null,null,null,0,obj.configuration.stopAraay[0].lbsj));// 早行例保班次
				dqlpbc.push(bf.getbcObj(
								kssj,obj.configuration.dataMap.ccsjArr[cctag],
								car,obj.configuration.dataMap.bcTypeArr.out,
								obj.configuration.dataMap.dira[cctag],xhNo++,
								obj.configuration.dataMap.cclcArr[cctag],
								obj.configuration.dataMap.map,0,
								obj.configuration.dataMap.qdzArr[cctag],null,null,0,0));// 出场班次
				var fxTagDm = 0;
				for(var i = 0 ; i<numqs;i++) {
					cctag = bf.getfx(fxTagDm,cctag);
					fxTagDm = 1;
					var _xxsj = bf.getxssj(obj.configuration.dataMap.zgfsjd,
							obj.configuration.dataMap.wgfsjd,kssj,
							obj.configuration.dataMap.pcxssjArr,
							obj.configuration.dataMap.gfxxsjArr,cctag);// 获取行驶时间
					var tzsj =  i==(numqs-1)  ?  0 :　obj.configuration.stopAraay[0].tzjx;
					dqlpbc.push(bf.getbcObj(
							kssj,_xxsj,car,obj.configuration.dataMap.bcTypeArr.normal,
							obj.configuration.dataMap.dira[cctag],xhNo++,
							obj.configuration.dataMap.pcxslcArr[cctag],obj.configuration.dataMap.map,0,
							obj.configuration.dataMap.qdzArr[cctag],obj.configuration.dataMap.zdzArr[cctag],null,tzsj,0));// 正常班次
					kssj = new Date(kssj.setMinutes(kssj.getMinutes() + obj.configuration.stopAraay[0].tzjx));
				}
				return dqlpbc;
			},

			getDirBc : function(arr,dir) {
				var upArr = new Array(),downArr = new Array(),qt = new Array();
				for(var a =0;a<arr.length;a++) {
					if(arr[a].xlDir == dir[0]  && arr[a].bcType=='normal') {
						upArr.push(arr[a]);
					}else if(arr[a].xlDir == dir[1]  && arr[a].bcType=='normal') {
						downArr.push(arr[a]);
					}else {
						qt.push(arr[a]);
					}
				}
				var tempup = baseF.sortDirArray(upArr);
				var tempdown = baseF.sortDirArray(downArr);
				return {'upArr':tempup,'downArr':tempdown,'qt':qt};
			},

			/**
			 * @description : (TODO) 把班次数组按发车时间进行排序.
			 *
			 * @param [arr--需要进行按时间排序的班次数组]
			 *
			 * @return 返回一个按时间顺序排序的班次数组.
			 *
			 * @status OK.
			 * */
			sortDirArray : function(arr) {
				//console.log(arr.length);
				var list = new Array(),tempArray = new Array();
				for(var a =0;a<arr.length;a++) {
					var long_ = baseF.getDateTime(arr[a].fcsj).getTime();
					if(tempArray.indexOf(long_)<0)
							tempArray.push(long_);
				}
				tempArray.sort(baseF.compare);
				for(var t = 0;t<tempArray.length;t++) {
					var strTime  = baseF.getTimeStr(new Date(tempArray[t]));
					for(var d = 0 ;d<arr.length;d++) {
						if(strTime == arr[d].fcsj)
							list.push(arr[d]);
					}
				}
				//console.log(list.length);
				return list;
			},
			/**
			 * @description : (TODO) 均匀发车间隙
			 *
			 * @params : [arr--某个方向下的班次数组;dir--方向;zzsj--周转时间]
			 *
			 * @return : 返回一个数组.这里返回的是调整过后 发车间距均匀的班次数组
			 **/
			jhfcjx : function(bcArr,dir,zzsj,dataMap) {
				console.log(bcArr.length);
				//console.log('调整' + dir + '发车间隙...');
				// 1、定义某个方向下的首末班次时间结点.
				var kssj = baseF.getDateTime(bcArr[0].fcsj),// 开始时间.
					jssj = baseF.getDateTime(bcArr[bcArr.length-1].fcsj);// 结束时间.
					// list = new Array()
				//console.log('{jssj:' + kssj + '------jssj:' + jssj + '}');
				// 2、从首班车时间开始,每次以一个周转时间段为结点.调整这个时间段内的班次发车间隙.
				while(kssj<=jssj) {
					// 2.1、定义一个在一个时间上加上周转时间后的一个时间点.
					var temp = new Date();
					temp.setHours(kssj.getHours());
					temp.setMinutes(kssj.getMinutes()+zzsj);
					// console.log('{' + kssj + '------' + temp + '}');
					// 2.2、获取这个时间内的班次数组.
					var sjdbcArr = baseF.getObjRegion(kssj,temp,bcArr);
					var len_ = sjdbcArr.length, bcCount = baseF.getlpNum(sjdbcArr);// 定长度
					// 2.3、根据在这个时间段内的班次数,得到路牌数.并计算发车间隙.[发车间隙 = 周转时间 / 一个周转时间内的车辆数].
					var _fcjx = parseInt(Math.ceil(zzsj/bcCount));
					//console.log('{' + kssj + '------' + temp + '}，----' + _fcjx + '---' + bcCount);
					if(bcCount==0)
						return;
					var fcnosj = new Date(kssj);
					// 2.4、调整班次
					for(var l = 0 ;l<bcArr.length-1;l++) {
						var _t = baseF.getDateTime(bcArr[l].fcsj);
						if(_t>temp )
							continue;
						if(_t>=kssj && _t<=temp) {
							/*if(parseInt((baseF.getDateTime(bcArr[l+1].fcsj) - baseF.getDateTime(bcArr[l].fcsj))/60000) ==_fcjx)
								continue;*/
							bcArr[l].fcsj = baseF.getTimeStr(fcnosj);
							var _xxsj = baseF.getxssj(dataMap.zgfsjd,
									  dataMap.wgfsjd,fcnosj,dataMap.pcxssjArr,
									  dataMap.gfxxsjArr,baseF.dirDmToIndex(bcArr[l].xlDir));// 获取行驶时间
							bcArr[l].bcsj = _xxsj;
							var ddsj = new Date();
							ddsj.setHours(fcnosj.getHours());
							ddsj.setMinutes(fcnosj.getMinutes()+_xxsj);
							bcArr[l].ARRIVALTIME = baseF.getTimeStr(ddsj);
							fcnosj.setMinutes(fcnosj.getMinutes() + _fcjx);
						}
						/*if(l<1) {
							fcsjStr = sjdbcArr[l].fcsj;
							continue;
						}else {
							var fcsj = baseF.getDateTime(fcsjStr);
							var ddsj = new Date();
							ddsj.setHours(fcsj.getHours());
							ddsj.setMinutes(fcsj.getMinutes()+_fcjx);
							sjdbcArr[l].fcsj = baseF.getTimeStr(ddsj);
							var _xxsj = baseF.getxssj(dataMap.zgfsjd,
													  dataMap.wgfsjd,ddsj,dataMap.pcxssjArr,
													  dataMap.gfxxsjArr,baseF.dirDmToIndex(sjdbcArr[l].xlDir));// 获取行驶时间
							sjdbcArr[l].bcsj = _xxsj;
							ddsj.setMinutes(ddsj.getMinutes()+sjdbcArr[l].bcsj);
							sjdbcArr[l].ARRIVALTIME = baseF.getTimeStr(ddsj);
							fcsjStr = sjdbcArr[l].fcsj;
						}*/
					}
					// list = list.concat(sjdbcArr);
					// 2.5、调整完毕后,进入下个周转时间.
					kssj = new Date(kssj.setMinutes(kssj.getMinutes() + zzsj));
				}
				console.log(bcArr.length);
				return bcArr;
			},
			/**
			 * @description : (TODO) 调整停站间隙
			 *
			 * @params : [arr--班次数组;lparr--路牌数组;dataMap--参数配置信息]
			 *
			 * @return : 返回一个数组.这里返回的是一个调整停站间隙完毕的班次数组.
			 **/
			tztzsj : function(arr,lparr,dataMap) {},
			tztzsj01 : function(arr,lparr,dataMap) {
				var list = new Array();
				// 遍历路牌数组.
				for(var p = 0 ; p < lparr.length ; p++) {
					/*if(p!=0)
						continue;*/
					var lpNo = lparr[p],tempA = new Array();
					// 获取当前路牌下的所有班次.
					for(var r = 0 ; r < arr.length ; r++) {
						if(arr[r].lpNo == lpNo)
							tempA.push(arr[r]);
					}
					// 给当前路牌下的所有班次 按照发车序号进行顺序排序.
					tempA.sort(function(a,b){return a.fcno-b.fcno});
					for(var t = 0 ; t < tempA.length-1 ; t++) {
						// 2.1.1、 定义下个班次的发车时间
						var xgbcfcsj = baseF.getDateTime(tempA[t+1].fcsj);
						// 2.1.2、 定义当前班次的到达时间
					 	var dqbcddsj = baseF.getDateTime(tempA[t].ARRIVALTIME);
					 	// 2.1.3、 计算从下个班次的发车时间 到 当前班次的到达时间 中间隔多长时间.等同于  当前班次的停站时间 = 下个班次的发车时间 - 当前班次的到达时间
						var dx = parseInt((xgbcfcsj.getTime()-dqbcddsj.getTime())/60000);
						var mintzsj = 0;
						if(dx<=22 && dx >= dataMap.minztjx)
							mintzsj = dx;
						else if(dx < dataMap.minztjx)
							mintzsj = dataMap.minztjx;
						else if(dx>22) {
							tempA[t].STOPTIME = mintzsj;
							continue;
						}
						baseF.updbc(tempA[t],tempA[t+1],dqbcddsj,dataMap,true,null,null == 'cf' ? 0 : mintzsj);
					}
					// 2.2、把调整完毕的班次进行合并,并放入到新的数组.
					list = list.concat(tempA);
				}
				return list;
			},
			updbc : function(dqbc,xgbc,dqbcddsj,dataMap,tagb,type,tzsj) {
				dqbc.STOPTIME = tzsj;// 修改当前班次停站时间
				dqbcddsj.setMinutes(dqbcddsj.getMinutes() + tzsj);
				xgbc.fcsj = baseF.getTimeStr(dqbcddsj);// 修改下个班次的发车时间
				var _xxsj = xgbc.bcsj;
				/*if(!tagb && type=='cf') {
					_xxsj = baseF.getxssj(dataMap.zgfsjd,
						    dataMap.wgfsjd,dqbcddsj,dataMap.pcxssjArr,
						    dataMap.gfxxsjArr,baseF.dirDmToIndex(xgbc.xlDir));// 获取行驶时间
				}*/
				xgbc.bcsj = _xxsj;
				dqbcddsj.setMinutes(dqbcddsj.getMinutes() + _xxsj);
				xgbc.ARRIVALTIME =  baseF.getTimeStr(dqbcddsj);// 修改下个班次的到达时间
			},
			getObjRegion : function(t1,t2,arr) {
				var _r = new Array();
				for(var p= 0; p<arr.length ; p++) {
					var _t = baseF.getDateTime(arr[p].fcsj);
					if(_t >= t1 && _t <= t2)
						_r.push(arr[p]);
				}
				/*return baseF.sortDirArray(_r);*/
				return _r.sort(function(a,b){return a.fcno-b.fcno});
			},

			getlpNum : function(arr) {
				var array = new Array();
				for(var r = 0 ; r < arr.length ; r++) {
					if(array.indexOf(arr[r].lpNo)<0)
						array.push(arr[r].lpNo);
				}
				return (array.length-1);
			},
			/**
			 * @description : (TODO)更新进场与离场班次
			 *
			 * @params : [a--班次数组;t--开始时间;s--配置参数信息,c--当前路牌;o--该路牌下最后一个班次对象;no--序号]
			 *
			 * @return : 返回一个数组.这里返回的是一个已更新进场与离场班次的 班次数组
			 */
			upd_Array : function (a,t,s,c,o,no) {
				for(var  i= 0 ; i<a.length;i++) {
					// 1、判断是否为进场班次
					if(a[i].bcType == 'in' && a[i].parent == c && a[i].fcsj == o.ARRIVALTIME) {
						var startTime_in = new Date(t);
						a[i].fcsj =  baseF.getTimeStr(startTime_in);
						startTime_in = new Date(startTime_in.setMinutes(startTime_in.getMinutes()+ s.jcsjArr[baseF.dirDmToIndex(o.xlDir)] ));
						a[i].ARRIVALTIME = baseF.getTimeStr(startTime_in);
						a[i].fcno = no+1;
					// 2、判断是否为离场班次
					}else if(a[i].bcType == 'lc' && a[i].parent == c ) {
						var startTime_lc = new Date(t);
						startTime_lc = new Date(startTime_lc.setMinutes(startTime_lc.getMinutes()+ s.jcsjArr[baseF.dirDmToIndex(o.xlDir)] ));
						a[i].fcsj = baseF.getTimeStr(startTime_in);
						startTime_lc = new Date(startTime_lc.setMinutes(startTime_lc.getMinutes()+s.lbsj));
						a[i].ARRIVALTIME = baseF.getTimeStr(startTime_in);
						a[i].fcno = no+2;
					}
				}
				return a;
			},
			/**
			 * @discription : (TODO) 封装班次属性值
			 *
			 * @params : [t--起始时间；bcsj--班次历时；c--lp对象属性值；type--类型]
			 *
			 * @params : [dir--方向；bcs--序号；jhlc--计划里程；gatps--表单参数对象]
			 *
			 * @params : [isfb--是否分班；qdz--起点站；zdz--终点站；isSwitchXl--是否切割线路；st--停站时间]
			 *
			 * @return : 返回班次对象属性值
			 *
			 */
			getbcObj : function(t,bcsj,c,type,dir,xh,jhlc,gatps,isfb,qdz,zdz,isSwitchXl,st,lbsj) {
				var obj = {};
				obj.parent = c.lpNo;
				obj.lpNo = c.lpNo;
				obj.lp = c.lp;
				obj.lpName = c.lpName;
				obj.lpType = c.lpType;
				obj.bcType = type;
				obj.xlDir = dir;
				obj.fcno = xh;
				obj.jhlc = jhlc;// 计划里程
				obj.tcc = gatps.tcc_id;// 停车场id
				obj.ttinfo = gatps.skbName;// 时刻表id
				obj.xl = gatps.lineName.split('_')[0];// 线路id
				obj.isfb = isfb;
				obj.qdz = qdz;
				obj.zdz = zdz;
				obj.isSwitchXl  = isSwitchXl;
				obj.STOPTIME = st;
				obj.bz = null;
				var startTime = null;
				if(type == 'bd' || type == 'out' || type == 'in' || type == 'lc')
					startTime  = new Date(t);
				else
					startTime = t;
				if(type=='bd' || type=='lc' )
					obj.bcsj = lbsj;
				else
					obj.bcsj = bcsj;
				if(type=='bd') {
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()-bcsj));
					obj.ARRIVALTIME =  baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()-lbsj));
					obj.fcsj =  baseF.getTimeStr(startTime);
				}else if(type=='out') {
					obj.ARRIVALTIME =  baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()-bcsj));
					obj.fcsj =  baseF.getTimeStr(startTime);
				}else if(type =='cf') {
					obj.fcsj =    baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()+bcsj));
					obj.ARRIVALTIME =    baseF.getTimeStr(startTime);
				}else if(type=='lc') {
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()+bcsj));
					obj.fcsj =  baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()+lbsj));
					obj.ARRIVALTIME =  baseF.getTimeStr(startTime);
				}else if(type=='in') {
					obj.fcsj = baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()+bcsj));
					obj.ARRIVALTIME =  baseF.getTimeStr(startTime);
				}else if(type=='normal') {
					obj.fcsj =    baseF.getTimeStr(startTime);
					startTime = new Date(startTime.setMinutes(startTime.getMinutes()+bcsj));
					obj.ARRIVALTIME =    baseF.getTimeStr(startTime);
				}
				return obj;
			},
			/**
			 * @discription : (TODO) 获取时间格式[00:00]
			 *
			 * @params : [time--时间对象]
			 *
			 * @return : 返回字符串。这里返回的是一个时间格式的字符串
			 **/
			getTimeStr : function(startTime) {
				return ((startTime.getHours()<10? '0' + startTime.getHours() : startTime.getHours()) == '00' ? '24' :(startTime.getHours()<10? '0' + startTime.getHours() : startTime.getHours()))
		 				+':'
		 				+(startTime.getMinutes()<10? '0' + startTime.getMinutes() : startTime.getMinutes());
			},
			/**
			 * @discription : (TODO)获取开始时间
			 *
			 * @params : [d1--零界时间点;d2--该时段开始时间点；type--时间段类型；countTime--周转时间数值；stopTime--停站时间数值]
			 *
			 * @return : 返回一个中国标准时间对象。这里返回的是每一个路牌的第一个开始时间点
			 **/
			getBeganTime : function(d1,d2,type,list,zg,wa,pc,gf,dir) {
				if(type=='ee') {
					 var cf = 0;
					 while(d1<d2) {
						 dir = baseF.getfx(1,dir);
						 var dx = baseF.getxssj(zg,wa,d1,pc,gf,dir) + list[0].tzjx;
						 if(d1> new Date (baseF.getCFDate(10,30)) &&
								 d1<new Date (baseF.getCFDate(12,0)) && cf <=0) {
							 dx = dx + 20;
							 cf++;
						 }
						 d1 =  new Date(d1.setMinutes(d1.getMinutes() + dx));
					 }
				}
				return {'d1':d1,'dir':dir};
			},
			/**
			 * @discription : (TODO) 字符串转时间对象
			 *
			 * @params : 具有一定格式的时间字符串
			 *
			 * @return : 返回一个中国标准时间点
			 *
			 **/
			getDateTime : function(time) {
				var dateTime = new Date();
				if(time !=null && time !='' && typeof(time) !='undefined') {
					timeArr = time.split(':');
					dateTime.setHours(parseInt(timeArr[0]));
					dateTime.setMinutes(parseInt(timeArr[1]));
				}
				return dateTime;
			},
			/**
			 * @discription : (TODO) 计算不同时段的车辆数
			 *
			 * @params : 数组对象
			 *
			 * @return : 返回一个数组对象。
			 **/
			getArithmetic : function(array) {
				var $_sIndex = 0;
				for(var s = 0 ; s<array.length;s++) {
					var carNum = array[s].num - $_sIndex;
					array[s].carnum = carNum;
					if(s<3)
						$_sIndex = array[s].num;
				}
				return array;
			},
			/**
			 * @discription : (TODO)根据不同时段的车辆数，用最适当的方式分配车
			 *
			 * @params : [carArra--路牌数组对象；lineTypeArray--不同时段的车辆数数组对象]
			 *
			 * @return : 返回一个数组。这里返回一个已分配好车辆的不同时段的车辆数数组对象
			 **/
			getCutCarArray_ : function(carArra,lineTypeArray) {
				var tempArra = carArra.slice(),_sortArray = new Array(),_lenArray = new Array();
				var _sortLineNum = lineTypeArray[3].carnum <= lineTypeArray[4].carnum ? lineTypeArray[4].carnum  : lineTypeArray[3].carnum,
					_lenLineNum = 	lineTypeArray[0].carnum+lineTypeArray[1].carnum+lineTypeArray[2].carnum,
					_avg = parseInt(carArra.length/2);
				if(_sortLineNum<_lenLineNum) {
					for(var e = 0 ;e<tempArra.length;e++) {
						if(e%2!=0)
							_sortArray.push(tempArra[e]);
					}
					_sortArray = _sortArray.splice(0,_sortLineNum);
					_lenArray = baseF.chaji_array(tempArra,_sortArray);
				}else if(_sortLineNum==_lenLineNum) {
					for(var t = 0 ;t<tempArra.length;t++) {
						if(t%2==0)
							_lenArray.push(tempArra[t]);
						else
							_sortArray.push(tempArra[t]);
					}
				}else if(_sortLineNum>_lenLineNum) {
					for(var e = 0 ;e<tempArra.length;e++) {
						if(e%2==0)
							_lenArray.push(tempArra[e]);
					}
					_lenArray = _lenArray.splice(0,_lenLineNum);
					_sortArray = baseF.chaji_array(tempArra,_lenArray);
				}
				for(var l =0 ;l<lineTypeArray.length;l++) {
					var carNum = lineTypeArray[l].carnum,concatArray = new Array();
					for(var c = 0; c<carNum;c++) {
						if(l<=2) {
							concatArray = concatArray.concat(_lenArray.splice(0,1));
						}else {
							concatArray = concatArray.concat(_sortArray[c]);
						}
					}
					lineTypeArray[l].car = concatArray;
				}
				return lineTypeArray;
			},
			/**
			 * @discription : (TODO)求两个集合的差集
			 *
			 * @params : [arr1--数组1；arr2--数组2]
			 *
			 * @return : 返回两个集合的差集。这里返回的是封装的ar1不在ar2中的元素数组对象
			 *
			 **/
			chaji_array : function(arr1,arr2){
			    var arr3 = [];
			    for (var i = 0; i < arr1.length; i++) {
			    	var flag = true;
			    	for (var j = 0; j < arr2.length; j++) {
			    		if (arr2[j] == arr1[i])
			    			flag = false;
			    	}
		    		if (flag)
		    			  arr3.push(arr1[i]);
			    }
			   return arr3;
			},
	};
	return baseF;
}();