front_end/libs/Calculate/CalculateLine.js

function CalculateLine(layer){
	this.layer=layer;
	this.interval=wallThickness;
	this.interval2=partitionThickness;
};

//两点成一线
CalculateLine.prototype.createLine=function(point1,point2)
{
	if(point1.x==point2.x)
	{
		return {a:0,b:0,x:point1.x};	
	}
	else if(point1.y==point2.y)
	{
		return {a:0,b:0,y:point1.y};		
	}
	
	var parametera=(point1.y-point2.y)/(point1.x-point2.x);
	var parameterb=(point1.x*point2.y-point2.x*point1.y)/(point1.x-point2.x);
	var parameter={a:parametera,b:parameterb};
	return parameter;
};

//与line平行并且point在线上
CalculateLine.prototype.createLine2=function(line,point)
{
	var parameter={};
	if(line.a==0)
	{
		if(line.x)	
		{
			parameter.a=0
			parameter.b=0
			parameter.x=point.x;
		}
		else if(line.y)
		{
			parameter.a=0
			parameter.b=0
			parameter.y=point.y;
		}
	}
	else
	{
		parameter.a=line.a;
		parameter.b=point.y-point.x*line.a;
	}
	return parameter;
};

//垂直线
CalculateLine.prototype.getVerticalLine=function(line,point)
{
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			return {a:0,b:0,y:point.y};	
		}
		else if(line.hasOwnProperty('y'))
		{
			return {a:0,b:0,x:point.x};	
		}
		else
		{
			console.log("CalculateLine:64");
			return null;
		}
	}
	else
	{
		var tl={};
		tl.a=-1/line.a;
		var result=this.createLine2(tl,point);
		return result;
	}
};

//经过point且与line垂直的直线，该直线与line的交点
CalculateLine.prototype.getJoinLinePoint=function(point,line)
{
	var verticalLine=this.getVerticalLine(line,point);
	var join=this.getIntersectionPoint(line,verticalLine);
	return join;
};

//经过point且与line垂直的线
CalculateLine.prototype.getLineForPoint=function(line,point)
{
	var parameter={};
	if(line.a==0)
	{
			if(line.x)	
			{
					parameter.a=0
					parameter.b=0
					parameter.x=point.x;
			}
			else if(line.y)
			{
					parameter.a=0
					parameter.b=0
					parameter.y=point.y;
			}
	}
	else
	{
			parameter.a=line.a;
			parameter.b=point.y-point.x*line.a;
	}
	return parameter;
};

//两条线的交点
CalculateLine.prototype.getIntersectionPoint=function(parameter1,parameter2)
{
	if(this.isParallel(parameter1,parameter2))
	{
		return null;
	}
	if(parameter1.a==0&&parameter2.a!=0)
	{
		if(parameter1.x)
		{
			return {x:parameter1.x,y:parameter2.a*parameter1.x+parameter2.b};
		}
		else if(parameter1.y)
		{
			return {x:(parameter1.y-parameter2.b)/parameter2.a,y:parameter1.y};
		}
	}
	else if(parameter2.a==0&&parameter1.a!=0)
	{
		if(parameter2.x)
		{
			return {x:parameter2.x,y:parameter1.a*parameter2.x+parameter1.b};	
		}	
		else if(parameter2.y)
		{
			return {x:(parameter2.y-parameter1.b)/parameter1.a,y:parameter2.y};
		}
	}
	else if(parameter2.a==0&&parameter1.a==0)
	{
		if(parameter1.hasOwnProperty('x')&&parameter2.hasOwnProperty('y'))
		{
			return {x:parameter1.x,y:parameter2.y};	
		}
		else if(parameter1.hasOwnProperty('y')&&parameter2.hasOwnProperty('x'))
		{
			return {x:parameter2.x,y:parameter1.y};	
		}
		else
		{
			return null;
		}
	}

    if(parameter1.a==parameter2.a)
    {
    	return null;
    }

    var joinpointx=(parameter2.b-parameter1.b)/(parameter1.a-parameter2.a);
    var joinpointy=(parameter1.a*parameter2.b-parameter2.a*parameter1.b)/(parameter1.a-parameter2.a);
 
    var point={x:joinpointx,y:joinpointy};
    return point;	
};

CalculateLine.prototype.getMid=function(point1,point2)
{
	return {x:(point1.x+point2.x)/2,y:(point1.y+point2.y)/2};
};

//重合也返回false
CalculateLine.prototype.isMid=function(value,value1,value2)
{
	var min,max;
	if(value1>value2)
	{
		max=value1;
		min=value2;
	}
	else
	{
		max=value2;
		min=value1;
	}
	if(value>min&&value<max)
	{
		return true;
	}
	else
	{
		return false;
	}
};

//movPoint移动的点
//fixPoint墙的另一头
CalculateLine.prototype.getNewSymbolPoint=function(symbol2d,movPoint,fixPoint)
{
	var newline=this.createLine(movPoint,fixPoint);
	var temp_line=this.getVerticalLine(newline,fixPoint);
	var point1={};
	var point2={};

	var angle=null;
	if(newline.a!=0)
	{
		angle=Math.atan(newline.a);
	}
	
	var symbol2dlength=symbol2d.getSymbolLen();
	var symbolMidPoint=this.getMid(symbol2d.geometry.point1,symbol2d.geometry.point2);

	//symbol不在墙面上就删除
	if(!this.segmentContainPoint(movPoint,fixPoint,symbol2d.geometry.point1)||!this.segmentContainPoint(movPoint,fixPoint,symbol2d.geometry.point2))
	{
		this.layer.deleteSymbol(symbol2d.id,symbol2d.attributes.wallId);
	}
	
	var distance =BABYLON.Vector2.Distance(fixPoint,symbolMidPoint);
	

	var temp={};
	
	if(newline.hasOwnProperty('x'))
	{
		point1.x=newline.x;
		point2.x=newline.x;
		if(movPoint.y>fixPoint.y)
		{
			temp.y=parseFloat(fixPoint.y)+parseFloat(distance);
		}
		else
		{
			temp.y=parseFloat(fixPoint.y)-parseFloat(distance);
		}
		
		point1.y=temp.y-symbol2dlength/2;
		point2.y=temp.y+symbol2dlength/2;
		
	}
	else if(newline.hasOwnProperty('y'))
	{
		point1.y=newline.y;
		point2.y=newline.y;
		
		if(movPoint.x>fixPoint.x)
		{
			temp.x=parseFloat(fixPoint.x)+parseFloat(distance);
		}
		else
		{
			temp.x=parseFloat(fixPoint.x)-parseFloat(distance);
		}
		
		point1.x=temp.x-symbol2dlength/2;
		point2.x=temp.x+symbol2dlength/2;
	}
	else
	{
		var db;
		
		if(angle>0)
		{
			db=distance/Math.sin(angle);
		}
		else
		{
			db=-distance/Math.sin(angle);
		}
		if(fixPoint.y>movPoint.y)
		{
			db=temp_line.b-db;
		}
		else 
		{
			db=temp_line.b+db;
		}
		temp_line.b=db;
		
		var point=this.getIntersectionPoint(temp_line, newline);
		
		var endpoint=this.getDisPointsLine(newline,point,symbol2dlength/2,symbol2dlength/2);
		
		point1=endpoint.newpoint1;
		point2=endpoint.newpoint2;
	}

	return {point1:point1,point2:point2};
};

//点到线的距离
CalculateLine.prototype.getDistancePointToLine=function(point,line) 
{
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			return Math.abs(point.x-line.x);
		}	
		else if(line.hasOwnProperty('y'))
		{
			return Math.abs(point.y-line.y);	
		}
		else
		{
			return null;	
		}
	}
	var a=-1/line.a;
	var b=point.y-a*point.x;
	
	var newline={a:a,b:b};

	var join=this.getIntersectionPoint(newline,line);
	
	return BABYLON.Vector2.Distance(point,join);
		
};

CalculateLine.prototype.containPoint=function(point1,point2,point)
{
	var minX,maxX,minY,maxY;
	
	if(point1.x>point2.x)
	{
		maxX=point1.x;
		minX=point2.x;
	}
	else
	{
		maxX=point2.x;
		minX=point1.x;
	}
	
	if(point1.y>point2.y)
	{
		maxY=point1.y;
		minY=point2.y;
	}
	else
	{
		maxY=point2.y;
		minY=point1.y;
	}
	
	if(point.x>=minX&&point.x<=maxX&&point.y>=minY&&point.y<=maxY)
	{
		return true;
	}
	else
	{
		return false;
	}
}

CalculateLine.prototype.overbound=function(point1,point2,endPoint1,endPoint2)
{
	var minX,maxX,minY,maxY,upX,upY,downX,downY;
	if(point1.x>point2.x)
	{
		maxX=point1.x;
		minX=point2.x;
	}
	else
	{
		maxX=point2.x;
		minX=point1.x;
	}
	if(point1.y>point2.y)
	{
		maxY=point1.y;
		minY=point2.y;
	}
	else
	{
		maxY=point2.y;
		minY=point1.y;
	}
	
	if(endPoint2.x>endPoint1.x)
	{
		upX=endPoint2.x;
		downX=endPoint1.x;
	}
	else
	{
		downX=endPoint2.x;
		upX=endPoint1.x;
	}
	
	if(endPoint2.y>endPoint1.y)
	{
		upY=endPoint2.y;
		downY=endPoint1.y;
	}
	else
	{
		downY=endPoint2.y;
		upY=endPoint1.y;
	}
	//没有超越边界
	if(downY<=minY&&upY>=maxY&&downX<=minX&&upX>=maxX)    
	{
		return false;
	}
	else                                                  //超越了边界
	{
		return true;
	}
};

//两条相交的线段的夹角，永远小于180度
CalculateLine.prototype.Angle=function(o,s,e)  
{  
    var cosfi = 0,fi = 0, norm = 0;  
    var dsx = s.x - o.x;  
    var dsy = s.y - o.y;  
    var dex = e.x - o.x;  
    var dey = e.y - o.y;  
  
    cosfi = dsx * dex + dsy * dey;  
    norm = (dsx * dsx + dsy * dsy) * (dex * dex + dey * dey);  
    cosfi /= Math.sqrt(norm);  
  
    if (cosfi >= 1.0) return 0;  
    //if (cosfi <= -1.0) return Math.PI;  
    if (cosfi <= -1.0) return 180;  
    fi = Math.acos(cosfi);  
  
    if (180 * fi / Math.PI < 180)  
    {  
        return 180 * fi / Math.PI;  
    }  
    else  
    {  
        return 360 - 180 * fi / Math.PI;  
    }  
};

CalculateLine.prototype.Angle2=function(point2,point1,tempPoint2)
{
	var angle=this.Angle(point2,point1,tempPoint2);
	var dx=point1.x-point2.x;
	var dy=point1.y-point2.y;
	
	if((dx>0&&dy>0)||(dx<0&&dy>0))
	{
		return 360-angle;
	}
	else
	{
		return angle;
	}
};

//point1,point2与point3,point4是否重合
CalculateLine.prototype.equal4=function(point1,point2,point3,point4)
{
	if(point1.x==point3.x&&point1.y==point3.y&&point2.x==point4.x&&point2.y==point4.y)	
	{
		return true;
	}
	else if(point1.x==point4.x&&point1.y==point4.y&&point2.x==point3.x&&point2.y==point3.y)	
	{
		return true;
	}
	else
	{
		return false;	
	}
};

CalculateLine.prototype.getToward=function(point1,point2,point)
{
	var line=this.createLine(point1,point2);
	
	
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			if(point.x>point1.x)
			{
				return 1;
			}
			else
			{
				return -1;
			}
		}
		else if(line.hasOwnProperty('y'))
		{
			if(point.y>point1.y)
			{
				return 1;
			}
			else
			{
				return -1;
			}
		}
	}
	else
	{
		var b=point.y-line.a*point.x;
		if(b>line.b)
		{
			return 1
		}
		else
		{
			return -1;
		}
	}
};

CalculateLine.prototype.getToward2=function(point1,point2,point3,point4)
{
	var line1=this.createLine(point1, point2);
	var line2=this.createLine(point3, point4);
	
	if(line1.a==0||line2.a==0)
	{
		var line;
		if(line1.a==0)
		{
			line=line1;
		}
		else
		{
			line=line2;
		}
		
		if(line.hasOwnProperty('x'))
		{
			if(point1.x>point3.x)
			{
				return 1;
			}
			else
			{
				return -1
			}
		}
		else 
		{
			if(point1.y>point3.y)
			{
				return 1;
			}
			else
			{
				return -1
			}
		}
	}
	else if(line1.b>line2.b)
	{
		return 1;
	}
	else
	{
		return -1;
	}
};

/*      
 *             @
 *            *
 *           *
 *         @
 *       *
 *      *
 *     @ 
 * @表示交点
 * 沿着线与point距离distance的交点
 * 
 * */
CalculateLine.prototype.getDisPointsLine=function(line,point,distance1,distance2)
{
	var newpoint1={};
	var newpoint2={};
	var result={};
	if(line.hasOwnProperty('x'))
	{
 		newpoint1.x=line.x;
		newpoint1.y=point.y-distance1;
		newpoint2.x=line.x;
		newpoint2.y=point.y+distance2;
	}
	else if(line.hasOwnProperty('y'))
	{
		newpoint1.y=line.y;
		newpoint1.x=point.x-distance1;
		newpoint2.y=line.y;
		newpoint2.x=point.x+distance2;
	}
	else 
	{
		var a=Math.atan(line.a);
		var t_line={a:-1/line.a};
		var line_ab2=this.createLine2(t_line,point);
		var join=this.getIntersectionPoint(line,line_ab2);

		newpoint1.x=join.x-distance1*Math.cos(a);
		newpoint1.y=join.y-distance1*Math.sin(a);

		newpoint2.x=join.x+distance2*Math.cos(a);
		newpoint2.y=join.y+distance2*Math.sin(a);
	}
	result.newpoint1=newpoint1;
	result.newpoint2=newpoint2;
	return result;
};

CalculateLine.prototype.driftY3=function(a,distance)
{
	var c=1/Math.sqrt(1+a*a);
	var drift=distance/c;
	return drift;	
};

CalculateLine.prototype.driftY=function(a,rate,type)
{
	var c=1/Math.sqrt(1+a*a);
	if(type==2)
	{
		var drift=this.interval2/(rate*c);
		return drift;
	}
	else
	{
		var drift=this.interval/(rate*c);
		return drift;
	}
			
};

CalculateLine.prototype.driftY2=function(c,rate,type)
{
	if(type==2)
	{
		var drift=this.interval2/(rate*c);
		return drift;
	}
	else
	{
		var drift=this.interval/(rate*c);
		return drift;
	}
			
};

//与line平行且两条线直接的距离是distance的两条线
CalculateLine.prototype.getParallelLineForDistance=function(line,distance)
{
	var meterdistance=5;
	
	var line1={};
	line1.a=line.a;
	line1.b=line.b;
	
	var meter1={};
	meter1.a=line.a;
	meter1.b=line.b;
	
	var line2={};
	line2.a=line.a;
	line2.b=line.b;
	
	var meter2={};
	meter2.a=line.a;
	meter2.b=line.b;
	
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			var x=line.x;
			line1.x=x+distance;
			meter1.x=x+distance+meterdistance;
			line2.x=x-distance;
			meter2.x=x-distance-meterdistance;
		}
		else if(line.hasOwnProperty('y'))
		{
			var y=line.y;
			line1.y=y+distance;
			meter1.y=y+distance+meterdistance;
			line2.y=y-distance;
			meter2.y=y-distance-meterdistance;
		}
	}
	else
	{
		var angle=Math.atan(line.a);
		var db=Math.abs(distance/Math.cos(angle));
		var db2=Math.abs(meterdistance/Math.cos(angle));
		var b=line.b;
		line1.b=b+db;
		meter1.b=b+db+db2;
		line2.b=b-db;
		meter2.b=b-db-db2;
	}
	
	return {line1:line1,line2:line2,meter1:meter1,meter2:meter2};
};

//返回true表示平行
CalculateLine.prototype.isParallel=function(line1,line2)
{
	var fixed=this.layer.parameter.fixed;
	if(line1.a.toFixed(fixed)==0&&line2.a.toFixed(fixed)==0)
	{
		if(line1.hasOwnProperty('x')&&line2.hasOwnProperty('x'))
		{
			return true;
		}
		else if(line1.hasOwnProperty('y')&&line2.hasOwnProperty('y'))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
	else if(line1.a.toFixed(fixed)==0||line2.a.toFixed(fixed)==0)
	{
		return false;
	}
	else if(line1.a.toFixed(fixed)==line2.a.toFixed(fixed))
	{
		return true;
	}
	else
	{
		return false;
	}
};

//与line1,line2平行且在他们中间
CalculateLine.prototype.isParallelMid=function(line,line1,line2)
{
	var min=null;
	var max=null;
	
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			return this.isMid(line.x,line1.x,line2.x);
		}
		else if(line.hasOwnProperty('y'))
		{
			return this.isMid(line.y,line1.y,line2.y);
		}
		else
		{
			console.log("CalculateLine: 594");
		}
	}
	else
	{
		return this.isMid(line.b,line1.b,line2.b);
	}
};

//线段是否相交,并返回交点
CalculateLine.prototype.isjoin=function(seg1,seg2)
{
	var line1=this.createLine(seg1.point1,seg1.point2);
	var line2=this.createLine(seg2.point1,seg2.point2);
	var join=this.getIntersectionPoint(line1,line2);
	if(join==null)
	{
		return null;
	}
	if(this.middle(seg1.point1,seg1.point2,join)&&this.middle(seg2.point1,seg2.point2,join))
	{
		//相交
		return join;
	}
	else
	{
		return null;
	}
};

//线段和直线是否相交
CalculateLine.prototype.isjoin2=function(seg,line)
{
	var line1=this.createLine(seg.point1,seg.point2);
	var join=this.getIntersectionPoint(line1,line);
	if(join==null)
	{
		return false;
	}
	if(this.middle(seg.point1,seg.point2,join))
	{
		return true;     //相交
	}
	else
	{
		return false;
	}
};

//线段和射线是否相交
//radial表示射线，point1表示射线的点
CalculateLine.prototype.isjoin3=function(seg,radial)
{
	var line2=this.createLine(radial.point1,radial.point2);
	if(!this.isjoin2(seg,line2))
	{
		return false;
	}
	var line1=this.createLine(seg.point1,seg.point2);
	
	var join=this.getIntersectionPoint(line1,line2);
	if(join==null)
	{
		return false;
	}
	
	if(this.middle(seg.point1,seg.point2,join)&&(this.middle(radial.point1,join,radial.point2)||this.middle(radial.point1,radial.point2,join)))
	{
		return true;
	}
	else
	{
		return false;
	}
};

//point的坐标在point1，point2之间
CalculateLine.prototype.middle=function(point1,point2,point)
{
		var startX,startY,endX,endY;
		if(point1.x<point2.x)
		{
				startX=point1.x;	
				endX=point2.x;
		}
		else
		{
				startX=point2.x;		
				endX=point1.x;
		}
		
		if(point1.y<point2.y)
		{
				startY=point1.y;	
				endY=point2.y;
		}
		else
		{
				startY=point2.y;	
				endY=point1.y;	
		}
		
		if(point.x>=startX&&point.x<=endX&&point.y>=startY&&point.y<=endY)
		{
				return true;	
		}
		else
		{
				return false;	
		}
		
};

//点在线上方还是下方
//1表示在上方，0表示下方，-1表示其他情况如：重合等
CalculateLine.prototype.isupdown=function(pt,line)
{
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			return -1;
		}
		else if(line.hasOwnProperty('y'))
		{
			if(pt.y==line.y)
			{
				return -1;
			}
			else if(pt.y<line.y)
			{
				return 0;
			}
			else
			{
				return 1;
			}
		}
	}
	else
	{
		var b=pt.y-line.a*pt.x;
		if(b>line.b)
		{
			return 1;
		}
		else if(b<line.b)
		{
			return 0;			
		}
		else
		{
			return -1;
		}
	}
}

CalculateLine.prototype.getCenterPoint=function(p)  
{  
  
    var ptCenter = {x:0,y:0};  
    var i, j;  
    var ai, atmp = 0, xtmp = 0, ytmp = 0;  
    if (p == null||p.length<3)  
    {
    		return;
    } 
  
    var n = p.length;  
    for (i = n - 1, j = 0; j < n; i = j, j++)  
    {  
        ai = p[i].x * p[j].y - p[j].x * p[i].y;  
        atmp += ai;  
        xtmp += (p[j].x + p[i].x) * ai;  
        ytmp += (p[j].y + p[i].y) * ai;  
    }  
  
    if (atmp != 0)  
    {  
        ptCenter.x = xtmp / (3 * atmp);  
        ptCenter.y = ytmp / (3 * atmp);  
    }  
    return ptCenter;  
  
};

CalculateLine.prototype.divisionBuildUseWall=function(wallinfo)  
{
	var points1=[];
	var points2=[];
	var height=[];
	for(var i=0;i<wallinfo.length;++i)
	{
		points1[i] = wallinfo[i].border1;
		points2[i] = wallinfo[i].border2;
		height[i] = wallinfo[i].height;
	}
	
	var area1=this.polygonArea(points1);
	var area2=this.polygonArea(points2);
	if(parseFloat(area1)>parseFloat(area2))
	{
		return {build:points1,use:points2,height:height};
	}
	else
	{
		return {build:points2,use:points1,height:height};
	}
};

CalculateLine.prototype.polygonArea=function(points)  
{  
    var i, j;  
    var area = 0;  
    for (i = 0; i < points.length; i++)  
    {  
        j = (i + 1) % points.length;  
        area += points[i].x * points[j].y;  
        area -= points[i].y * points[j].x;  
    }  
    area /= 2;  
    //return Math.abs(area)/(meter*meter);  
		return parseFloat(Math.abs(area)/(meter*meter)).toFixed(2);
};

//经过点并与线段垂直的线与线段的交点在线段内
//返回是true表示在
CalculateLine.prototype.segmentContainPoint=function(point1,point2,point)
{
	var line=this.createLine(point1,point2);
	var join=this.getJoinLinePoint(point,line);
	return this.containPoint(point1,point2,join);
};

CalculateLine.prototype.outinwallside=function(geometry)
{
	  var points = geometry.points;
	  var type = geometry.wallType;
	  var len=points.length;
	  var useline=[];
	  var builtline=[];

	  var interval;
	  
	  if(type==2)
	  {
		  interval=this.interval2;
	  }
	  else 
	  {
		  interval=this.interval;
	  }
		  
	  if(len<2)
	  {
	  		return;
	  }
	  else if(len==2)
	  {
	  		var newline1={a:0,b:0};
		  	var newline2={a:0,b:0};
		  	var newrealine1={a:0,b:0};
		  	var newrealine2={a:0,b:0};
	  		var lineparameter=this.createLine(points[0],points[1]);
	  		if(lineparameter.hasOwnProperty('x'))
			{
				  newrealine1.x=lineparameter.x+interval/2;
				  newrealine2.x=lineparameter.x-interval/2;
				  var pointin1={x:newrealine1.x,y:points[0].y};
				  var pointin2={x:newrealine2.x,y:points[0].y};
				  var pointout1={x:newrealine1.x,y:points[1].y};
				  var pointout2={x:newrealine2.x,y:points[1].y};
				  return {side1:[pointin1,pointin2],side2:[pointout1,pointout2]};
			}	
			else if(lineparameter.hasOwnProperty('y'))
			{
				  newrealine1.y=lineparameter.y+interval/2;
				  newrealine2.y=lineparameter.y-interval/2;
				  var pointin1={x:points[0].x,y:newrealine1.y};
				  var pointin2={x:points[0].x,y:newrealine2.y};
				  var pointout1={x:points[1].x,y:newrealine1.y};
				  var pointout2={x:points[1].x,y:newrealine2.y};
				  return {side1:[pointin1,pointin2],side2:[pointout1,pointout2]};
			}
			else
			{
				 var points1=this.singpoints(points[0],lineparameter,type);
				 var points2=this.singpoints(points[1],lineparameter,type);
				 return {side1:[points1[0],points1[1]],side2:[points2[0],points2[1]]};
			}
	  }
	  else
	  {
		  var points1=[];
		  var points2=[];
		  for(var i=0;i<len;++i)
	  	  {  	
			    var point1,point2,point3;
			    if(i==0)  
			    {
			    	point1=points[0];
			    	point2=points[1];
			    }
			    else if(i==len-1)
			    {
			    	point1=points[i-1];
			    	point2=points[i];
			    }
			    else
			    {
			    	point1=points[i-1];
			    	point2=points[i];
			    	point3=points[i+1];
			    }
			    var lineparameter=this.createLine(point1,point2);
			    	 
	  			var newlineup1={a:0,b:0};
	  	  		var newlinedown1={a:0,b:0};
		  	  	var newlineup2={a:0,b:0};
	  	  		var newlinedown2={a:0,b:0};
	  	  		var joinpointdown1,joinpointup1,joinpointdown2,joinpointup2;
		  	  	if(lineparameter.a==0)
	  	  		{
	  	  			if(lineparameter.hasOwnProperty('x'))
	  				{
		  	  			newlineup1.x=lineparameter.x+interval/2;
		  	  			newlinedown1.x=lineparameter.x-interval/2;
		  	  			if(i==0||i==len-1)
		  	  			{
		  	  				if(i==0)
		  	  				{
			  	  				joinpointdown1={x:newlineup1.x,y:point1.y};
			  	  				joinpointup1={x:newlinedown1.x,y:point1.y};
				  	  			points1.push(joinpointdown1);
			  	  				points2.push(joinpointup1);
		  	  				}
		  	  				else
		  	  				{
			  	  				joinpointdown1={x:newlineup1.x,y:point2.y};
			  	  				joinpointup1={x:newlinedown1.x,y:point2.y};
			  	  				if(this.hasPointIntersect(points[i-1], points[i], points1[points1.length-1], joinpointdown1))
			  	  				{
			  	  					points1.push(joinpointup1);
			  	  					points2.push(joinpointdown1);
			  	  				}
			  	  				else
			  	  				{
				  	  				points1.push(joinpointdown1);
			  	  					points2.push(joinpointup1);
			  	  				}
		  	  				}
		  	  				continue;
		  	  			}
	  				}	
	  				else if(lineparameter.hasOwnProperty('y'))
	  				{
	  					newlineup1.y=lineparameter.y+interval/2;
	  					newlinedown1.y=lineparameter.y-interval/2;
	  					if(i==0||i==len-1)
		  	  			{
	  						if(i==0)
	  						{
	  							joinpointdown1={x:point1.x,y:newlineup1.y};
			  	  				joinpointup1={x:point1.x,y:newlinedown1.y};
				  	  			points1.push(joinpointdown1);
			  	  				points2.push(joinpointup1);
	  						}
	  						else
	  						{
	  							joinpointdown1={x:point2.x,y:newlineup1.y};
			  	  				joinpointup1={x:point2.x,y:newlinedown1.y};
				  	  			if(this.hasPointIntersect(points[i-1], points[i], points1[points1.length-1], joinpointdown1))
			  	  				{
			  	  					points1.push(joinpointup1);
			  	  					points2.push(joinpointdown1);
			  	  				}
			  	  				else
			  	  				{
				  	  				points1.push(joinpointdown1);
			  	  					points2.push(joinpointup1);
			  	  				}
	  						}
			  	  			
		  	  				continue;
		  	  			}
	  				}
	  	  		
	  	  		}
	  	  		else
	  	  		{
		  	  		newlineup1.a=	lineparameter.a;
		  	  		newlineup1.b= lineparameter.b+this.driftY2(this.sin(newlineup1.a),2,type);
			  	    newlinedown1.a=	lineparameter.a;
			  	    newlinedown1.b= lineparameter.b-this.driftY2(this.sin(newlinedown1.a),2,type);
			  	    if(i==0||i==len-1)
		  	  		{
		  	  			var line={a:-1/lineparameter.a};
		  	  			var templine;
		  	  			if(i==0)
		  	  			{
		  	  				templine=this.createLine2(line,point1);
		  	    	  		joinpointdown1=this.getIntersectionPoint(templine, newlineup1);
				  	  		joinpointup1=this.getIntersectionPoint(templine, newlinedown1);
				  	  		points1.push(joinpointdown1);
			  				points2.push(joinpointup1);
		  	  			}
		  	  			else
		  	  			{
		  	  				templine=this.createLine2(line,point2);
		  	    	  		joinpointdown1=this.getIntersectionPoint(templine, newlineup1);
				  	  		joinpointup1=this.getIntersectionPoint(templine, newlinedown1);
							if(this.hasPointIntersect(points[i-1], points[i], points1[points1.length-1], joinpointdown1))
		  	  				{
		  	  					points1.push(joinpointup1);
		  	  					points2.push(joinpointdown1);
		  	  				}
		  	  				else
		  	  				{
			  	  				points1.push(joinpointdown1);
		  	  					points2.push(joinpointup1);
		  	  				}

		  	  			}
		  				continue;
		  	  		}
	  	  		}
		  	  	
		  	    var lineparameter2=this.createLine(point3,point2);
		  		if(lineparameter2.a==0)
	  	  		{
	  	  			if(lineparameter2.hasOwnProperty('x'))
	  				{
		  	  			newlineup2.x=lineparameter2.x+interval/2;
		  	  			newlinedown2.x=lineparameter2.x-interval/2;
	  				}	
	  				else if(lineparameter2.hasOwnProperty('y'))
	  				{
	  					newlineup2.y=lineparameter2.y+interval/2;
	  					newlinedown2.y=lineparameter2.y-interval/2;
	  				}
	  	  		
	  	  		}
	  	  		else
	  	  		{
	  	  			newlineup2.a=	lineparameter2.a;
	  	  			newlineup2.b= lineparameter2.b+this.driftY2(this.sin(newlineup2.a),2,type);
			  	    newlinedown2.a=	lineparameter2.a;
			  	    newlinedown2.b= lineparameter2.b-this.driftY2(this.sin(newlinedown2.a),2,type);
	  	  		}
	  	  		
	  	  		if(i==0)
	  	  		{
	  	  			var line={a:-1/lineparameter.a};
	  	  			var templine=this.createLine2(line,point1);
		  	  		joinpointdown1=this.getIntersectionPoint(templine, newlineup1);
		  	  		joinpointup1=this.getIntersectionPoint(templine, newlinedown1);
		  	  		points1.push(joinpointdown1);
	  				points2.push(joinpointup1);
	  				continue;
	  	  		}
	  	  		else if(i<len-1)
	  	  		{
		  	  		var joinpoint1=this.getIntersectionPoint(newlineup1, newlineup2);
		  	  		var joinpoint2=this.getIntersectionPoint(newlinedown1, newlineup2);
		  	  		var joinpoint3=this.getIntersectionPoint(newlineup1, newlinedown2);
		  	  		var joinpoint4=this.getIntersectionPoint(newlinedown1, newlinedown2);
		  	  		
		  	  		var prepoint1=points1[points1.length-1];
		  	  		var prepoint2=points2[points2.length-1];
		  	  		
		  	  		var tempoint=[];
		  	  		
		  	  		if(!this.hasPointIntersect(prepoint1,joinpoint1,point1,point2)&&!this.hasPointIntersect(prepoint1,joinpoint1,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint1);
		  	  		}
		  	  		
			  	  	if(!this.hasPointIntersect(prepoint1,joinpoint2,point1,point2)&&!this.hasPointIntersect(prepoint1,joinpoint2,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint2);
		  	  		}
			  	  	
				  	if(!this.hasPointIntersect(prepoint1,joinpoint3,point1,point2)&&!this.hasPointIntersect(prepoint1,joinpoint3,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint3);
		  	  		}
				  	
				  	if(!this.hasPointIntersect(prepoint1,joinpoint4,point1,point2)&&!this.hasPointIntersect(prepoint1,joinpoint4,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint4);
		  	  		}
				  	if(tempoint.length==2)
				  	{
				  		if(parseFloat(BABYLON.Vector2.Distance(prepoint1,tempoint[0]))<parseFloat(BABYLON.Vector2.Distance(prepoint1,tempoint[1])))
				  		{
				  			points1.push(tempoint[1]);
				  		}
				  		else
				  		{
				  			points1.push(tempoint[0]);
				  		}
				  	}
				  	else if(tempoint.length==1)
				  	{
				  		points1.push(tempoint[0]);
				  	}
				  	
				  	tempoint=[];
				  	if(!this.hasPointIntersect(prepoint2,joinpoint1,point1,point2)&&!this.hasPointIntersect(prepoint2,joinpoint1,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint1);
		  	  		}
		  	  		
			  	  	if(!this.hasPointIntersect(prepoint2,joinpoint2,point1,point2)&&!this.hasPointIntersect(prepoint2,joinpoint2,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint2);
		  	  		}
			  	  	
				  	if(!this.hasPointIntersect(prepoint2,joinpoint3,point1,point2)&&!this.hasPointIntersect(prepoint2,joinpoint3,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint3);
		  	  		}
				  	
				  	if(!this.hasPointIntersect(prepoint2,joinpoint4,point1,point2)&&!this.hasPointIntersect(prepoint2,joinpoint4,point3,point2))
		  	  		{
		  	  		      tempoint.push(joinpoint4);
		  	  		}
				  	if(tempoint.length==2)
				  	{
				  		if(parseFloat(BABYLON.Vector2.Distance(prepoint2,tempoint[0]))<parseFloat(BABYLON.Vector2.Distance(prepoint2,tempoint[1])))
				  		{
				  			points2.push(tempoint[1]);
				  		}
				  		else
				  		{
				  			points2.push(tempoint[0]);
				  		}
				  	}
				  	else if(tempoint.length==1)
				  	{
				  		points2.push(tempoint[0]);
				  	}
	  	  		}
	  	  		
	  	  }
		  return {side1:points1,side2:points2}; 
	  }
	  
};

//墙的两边的点，不受其他墙的影响
//该墙既不平行于x轴也不平行于y轴
CalculateLine.prototype.singpoints=function(point,line,type)
{
	var a=-1/line.a;
	var b=point.y-point.x*a;
	var line1={a:a,b:b};
		
	var newrealine1={};
	var newrealine2={};
	
	newrealine1.a=line.a;
	newrealine1.b=line.b+this.driftY2(this.sin(newrealine1.a),type)/2;

	newrealine2.a=line.a;
	newrealine2.b=line.b-this.driftY2(this.sin(newrealine2.a),type)/2;
	
	var point1=this.getIntersectionPoint(line1, newrealine1);
	var point2=this.getIntersectionPoint(line1, newrealine2);
	
	var points=[];
	points.push(point1);
	points.push(point2);
	return points;
};

//两个线段是否有交点
CalculateLine.prototype.hasPointIntersect=function(point1,point2,point3,point4)
{
	var line1=this.createLine(point1, point2);
	var line2=this.createLine(point3, point4);
	var intersectp=this.getIntersectionPoint(line1,line2);
	if(intersectp==null)
	{
		return false;
	}
	else
	{
		if(this.middle(point1,point2,intersectp)&&this.middle(point3,point4,intersectp))
		{
			return true;
		}
		else
		{
			return false;
		}
	}
};

CalculateLine.prototype.sin=function(a)
{
		var c=1/Math.sqrt(1+a*a);
		return c;
} ;

//判断逆时针还是顺时针
CalculateLine.prototype.isClockWise=function(points)
{
	var pre,next;
	var sub=0;
	for(var i=0;i<points.length;++i)
	{
		if(i==0)
		{
			pre=points.length-1;
		}
		else
		{
			pre=i-1;
		}
		if(i==points.length-1)
		{
			next=0;
		}
		else
		{
			next=i+1;
		}
		var result=(points[i].x-points[pre].x)*(points[next].y-points[i].y)-(points[i].y-points[pre].y)*(points[next].x-points[i].x);
		if(result>0)
		{
			++sub;
		}
		else if(result<0)
		{
			--sub;
		}
	}
	
	if(sub>0)
	{
		//逆时针
		return 1;
	}
	else
	{
		//顺时针
		return -1;
	}
};

CalculateLine.prototype.getPositionIntersect3D=function(point1,point2,toward,thice,point)
{
	var line=this.createLine(point1,point2);
	var pt1={};
	var pt2={};
	if(line.a==0)
	{
		if(line.hasOwnProperty('x'))
		{
			if(toward==1)
			{
				pt1.x=point.x+thice;
				pt1.y=point.y;
				pt1.z=point.z;
				pt2.x=point.x;
				pt2.y=point.y;
				pt2.z=point.z;
			}
			else
			{
				pt1.x=point.x-thice;
				pt1.y=point.y;
				pt1.z=point.z;
				pt2.x=point.x;
				pt2.y=point.y;
				pt2.z=point.z;
			}
		}
		else if(line.hasOwnProperty('y'))
		{
			if(toward==1)
			{
				pt1.z=point.z+thice;
				pt1.x=point.x;
				pt1.y=point.y;
				pt2.z=point.z;
				pt2.x=point.x;
				pt2.y=point.y;
			}
			else
			{
				pt1.z=point.z-thice;
				pt1.x=point.x;
				pt1.y=point.y;
				pt2.z=point.z;
				pt2.x=point.x;
				pt2.y=point.y;
			}
		}
		return {point1:pt1,point2:pt2};
	}
	else
	{
		var line2=this.createLine(point1,point2);
		if(toward==1)
		{
			line.b+=thice;
		}
		else
		{
			line.b-=thice;
		}
		var m_point={x:point.x,y:point.z};
		pt1=this.getJoinLinePoint(m_point,line);
		pt2=this.getJoinLinePoint(m_point,line2);
		return {point1:{x:pt1.x,y:point.y,z:pt1.y},point2:{x:pt2.x,y:point.y,z:pt2.y}};
	}
};

//判断正数
CalculateLine.prototype.checkRate=function(nubmer)
{
    //判断字符串是否为数字     /^[0-9]+.?[0-9]*$/
    //判断正整数  /^[1-9]+[0-9]*]*$/; 
    var re=/^\d+(?=\.{0,1}\d+$|$)/;      
    
    if (!re.test(nubmer))
    {
        //alert("请输入数字");
        return false;
    }
    else 
    {
    	return true;
    }
};

CalculateLine.prototype.checkRate2=function(nubmer)
{
    var re=/^[-+]?[0-9]+(\.[0-9]+)?$/;      
    
    if (!re.test(nubmer))
    {
        //alert("请输入数字");
        return false;
    }
    else 
    {
    	return true;
    }
};