map.js

《SVG开发实践》源代码

		}
		catch(e)
		{
			alert(e);
		}
	}
	SVGDoc.getElementById("infotipRect").getStyle().setProperty ('visibility', 'hidden');
}

function drawContour()
{
	if(ContourLayer.hasChildNodes)
	{
		if(ContourLayer.getAttributeNS(null,"visibility")=="visible")
			ContourLayer.setAttributeNS(null,"visibility","hidden");
		else ContourLayer.setAttributeNS(null,"visibility","visible");
	}
	else
	{
		delete PtArr;
		delete NdArr;
		PointId = 0;
		makePtArr()
		makeNdArr()

		var nodes=CitysLayer.getElementsByTagName("a");
		for(var i=0;i<nodes.length;i++)
		{
			var m=nodes.item(i).firstChild.getCTM();
			//此处需要根据站点结构的改变而改变
			var data=nodes.item(i).childNodes.item(4).firstChild.nextSibling.firstChild.data;
			if(data!="") AddPoint(parseInt(m.e),parseInt(m.f),parseInt(data*10));
		}
		prepGrid();
		konturken();
		ContourLayer.setAttributeNS(null,"visibility","visible");
	}
}
parent.drawContour=drawContour;

/*--------------------------------------------------------------------------
	Object definition Functions
-------------------------------------------------------------------------------*/
	function GPoint(NumId,Xpos,Ypos,Zval) { //point object
     		this.length = 5;               
     		this.Id = NumId;
		this.X = Xpos;               
     		this.Y = Ypos;             
     		this.Z = Zval;             
	}

	function GNode( NumId,Xpos, Ypos) { //define node object
     		this.length = 5;               
     		this.Id =NumId ;
		this.X =Xpos ;               
     		this.Y =Ypos ; 
		invdpow=2;    //determine the kind of inverse distance
		var tval=0;
		var invdtot=0;
		var iscoincide=false;
		var iczval=-1;
		for (i=1; i<=PtArr.size;i++){ //calculate total inverse distance
			dx = PtArr[i].X-Xpos
			dy = PtArr[i].Y-Ypos
			dist = Math.sqrt(Math.pow(dx,2)+ Math.pow(dy,2))
			if (dist!=0){	//if point does NOT coincide with gridnode
				invdtot+=1/Math.pow(dist,invdpow)
			}
		}   		
		for (i=1; i<=PtArr.size;i++){ //calculate weight
			dx = PtArr[i].X-Xpos
			dy = PtArr[i].Y-Ypos
			dist = Math.sqrt(Math.pow(dx,2)+ Math.pow(dy,2))		
			if (dist!=0) {	//if NOT coincide 
				var invd=1/Math.pow(dist,invdpow)
				tval+=PtArr[i].Z*(invd/invdtot)
			}else{
				iscoincide=true
				iczval =PtArr[i].Z
			}
		}   		
		//round value to nearest 3 decimal
		var rval = (Math.round(tval*1000))/1000
		if (iscoincide) {
			this.Z =iczval ; // set gridnode value to coincident point value
		}else{ 
			this.Z =rval ; // inverse distance function to calculate z value             
		}
		if  (invdtot<=0) {this.Z =0};
	}

/*--------------------------------------------------------------------------
	Functions for creating all kinds of array
-------------------------------------------------------------------------------*/
	function createArray(n, init)	{
     		this.size = n  //This initialization is absolutely necessary = this[0]
     		for (i = 1 ; i <= n ; i++) { 
			this[i] = init      //Initialize all of the left hand elements
          		}
		this.minval=99999999  //en passan sorting 
		this.maxval=-99999999
     		return this
	}

	function makePtArr(){
		var Ptinst;
		Ptinst=new GPoint(1,0,0,0); 
		PtArr =new createArray(0, Ptinst); //initializing array for points
	}
	function makeNdArr(){
		var Ptdanc;
		Ptdanc=new GNode(1,0,0); 
		NdArr =new createArray(0, Ptdanc); //initializing array of gridnodes
	}

/*--------------------------------------------------------------------------
	add Objects into array Functions
-------------------------------------------------------------------------------*/
	function AddPoint(Xpos,Ypos,Zval){ // add point object to points array PtArr
		PointId += 1
		var Ptx;
		Ptx=new GPoint(PointId,Xpos,Ypos,Zval);
		PtArr[PointId]=Ptx;		// add object point to array points
		PtArr.size = PointId;
		PtArr.minval=Math.min(PtArr.minval,Zval)
		PtArr.maxval=Math.max(PtArr.maxval,Zval)
	}

	function makeGNodes(i,j,k){ //add gridnode object to gridnodes array NdArr
		var nid=j*i+k+1
		var nodx=gsize*j
		var nody=gsize*k
		var PtNod;
		PtNod=new GNode(nid,nodx,nody); 
		NdArr[nid]=PtNod
		NdArr.size=nid
		NdArr.minval=0
		NdArr.maxval=0
	}


/*--------------------------------------------------------------------------
	Grid Preparation Function
-------------------------------------------------------------------------------*/
	function prepGrid(){ //draw grids and creating gridnode array
		if (PtArr.size==0) {
			alert('地图上没有数据点！')
		}else{
			gsize = findgsize();
			//horizontal grids
			var ypos=0
			var i=0
			while(ypos<=ContourH){
				ypos+=gsize
				i+=1
			}
			//vertical grids
			var xpos=0
			var j=0
			while(xpos<=ContourW){
				xpos+=gsize
				for (k=0;k<=i;k++){ 
					makeGNodes(i,j,k)
				}
				j+=1
			}
		}
	}

/*--------------------------------------------------------------------------
	SVG Utilities Functions
-------------------------------------------------------------------------------*/
function drawPoint(ingrup,pid,cx,cy,psize,pfill){	//draw circle for points reps
	var newnode="<circle id='"+pid+"' cx='"+cx+"' cy='"+cy+"' r='"+psize+"' fill='"+pfill+"'/>";
	parseSVG(SVGDoc.getElementById(ingrup),newnode);
}
	
function drawPath(ingrup,pid,pdata,pstroke,pswidth,pfill){ // draw path for grid and contour
	var newnode="<path id='"+pid+"' d='"+pdata+"' stroke-width='"+pswidth+"' stroke='"+pstroke+"' fill='"+pfill+"'/>";
	parseSVG(ingrup,newnode);
}

function clearchilds(ingrup){		//removing child nodes from a group
	childs=ingrup.getChildNodes()
	while(childs.length>0){
		ingrup.removeChild(childs.item(0))
	} 
}


/*--------------------------------------------------------------------------
	Contouring Caller function
-------------------------------------------------------------------------------*/
function konturken(){ //drawing contour for each grid square
	if (NdArr.size==0){
		alert ('数据不够！')	
	}else{
		clearchilds(ContourLayer)
		Contourlah(ContN,'green',5);
   	}
}		

/*--------------------------------------------------------------------------
	Utility Functions
-------------------------------------------------------------------------------*/
	function findgsize(){ // find the size of a grid square
	var anjing
	ContourW/GridN < ContourH/GridN ? anjing = ContourW/GridN : anjing = ContourH/GridN;
	return anjing;
	}
	function ccolor(i,n,rlow,glow,blow,rhi,ghi,bhi){ //stroke color grader
		rhi >= rlow ? rdiv=rhi-rlow : rdiv=rhi-rlow + 255;
		ghi >= glow ? gdiv=ghi-glow : gdiv=ghi-glow + 255;
		bhi >= blow ? bdiv=bhi-blow : bdiv=bhi-blow + 255;
		rc = Math.round((i*3*rdiv/n)+rlow)
		gc = Math.round((i*3*gdiv/n)+glow)
		bc = Math.round((i*3*bdiv/n)+blow)
		var colorstr='rgb(' + rc + ',' + gc+ ',' + bc + ')' 
		return colorstr
	}

/*--------------------------------------------------------------------------
	Contouring Function
-------------------------------------------------------------------------------*/
function Contourlah(NCont,Cstrk,Cstwd){
var x1;
var x2;
var y1;
var y2;
var pid;
var pdata;
var Frac; 
var gsize = findgsize();
var htdiv=Math.round(ContourH/gsize) + 1;  // the height division of SVGEmbed
//var ContInterval=Math.round(1000*(PtArr.maxval-PtArr.minval)/NCont)/1000	//round value to nearest 3 decimal
var ContInterval=(PtArr.maxval-PtArr.minval)/NCont
var loureed = 0
var lowgreen = 0
var lowblow = 255
var hired=255
var higreen=0
var hiblue=0

for (j=1;j<=NCont;j++){
	IContour = j
	var CVal = ContInterval*IContour

	Cstrk = ccolor(j,NCont,loureed,lowgreen,lowblow,hired,higreen,hiblue);
	//alert ('contour ' + j + ' color : ' + Cstrk)

	for (i=1;i<=NdArr.size-htdiv-1;i++){
		// i index of gridnode at the upperleft corner of current gridsquare 
		var LPoint = NdArr[i].X;
		var RPoint = NdArr[i].X + gsize;
		var UPoint = NdArr[i].Y;
		var DPoint = NdArr[i].Y + gsize;

		var ULVal = NdArr[i].Z;
		var URVal = NdArr[i+htdiv].Z;
		var LRVal = NdArr[i+htdiv+1].Z;
		var LLVal = NdArr[i+1].Z;

		var MinValue = Math.min(ULVal, Math.min(URVal, Math.min(LRVal,LLVal)));
		var MaxValue = Math.max(ULVal, Math.max(URVal, Math.max(LRVal,LLVal)));
		
		if((ContInterval * NCont) > MinValue) { 
			//IContour=Math.ceil(MinValue/ContInterval) 
			//var CVal = ContInterval*IContour

			if ((CVal < MaxValue) ) { // end bracket is down below
      		
        			if ((CVal < Math.max(ULVal,LLVal)) && (CVal>Math.min(ULVal,LLVal))) { // Left Side
        				x1 = LPoint;
        				y1 = UPoint + Math.round(gsize*(CVal-ULVal)/(LLVal-ULVal));
        				if ((CVal<Math.max(LLVal,LRVal)) && (CVal>Math.min(LLVal,LRVal))) { // Join to Bottom
          					x2 = LPoint + Math.round(gsize*(CVal-LLVal)/(LRVal-LLVal));
          					y2 = DPoint;
        				}else{  // Join to Diagonal
          					Frac = (CVal-ULVal)/(LRVal-ULVal);
          					x2 = LPoint + Math.round(gsize*Frac);
          					y2 = UPoint + Math.round(gsize*Frac);
					} 	// end of line if (CVal < Math.max(LLVal,LRVal))...
 		
					pdata='M'+ x1 + ',' + y1 + 'L' + x2 + ',' + y2
					pid = 'Level_' + CVal
					drawPath(ContourLayer,pid,pdata,Cstrk,Cstwd,'none') 
					//addseg(IContour,x1,y1,x2,y2)

        			}else{ //	Bottom
        				if ((CVal < Math.max(LLVal,LRVal)) && (CVal > Math.min(LLVal,LRVal))) {
          					x1 = LPoint + Math.round(gsize*(CVal-LLVal)/(LRVal-LLVal));
          					y1 = DPoint;
          					//Join to Diagonal
          					Frac = (CVal-ULVal)/(LRVal-ULVal);
          					x2 = LPoint + Math.round(gsize*Frac);
          					y2 = UPoint + Math.round(gsize*Frac);
						pdata='M'+ x1 + ',' + y1 + 'L' + x2 + ',' + y2
						pid = 'Level_' + CVal
						drawPath(ContourLayer,pid,pdata,Cstrk,Cstwd,'none')
						//addseg(IContour,x1,y1,x2,y2)
					}
	  			} // end of line : if (CVal<Math.max(ULVal,LLVal)...

        			if ((CVal < Math.max(URVal,LRVal)) && (CVal > Math.min(URVal,LRVal))) { // Right Side
      				x1 = RPoint;
      				y1 = UPoint + Math.round(gsize*(CVal-URVal)/(LRVal-URVal));
      				if ((CVal < Math.max(ULVal,URVal)) && (CVal > Math.min(ULVal,URVal))) { //Join to Top
      					x2 = LPoint + Math.round(gsize*(CVal-ULVal)/(URVal-ULVal));
          					y2 = UPoint;
					}
        				//join to Diagonal, note that (x2,y2) are the same as before
 					pdata='M'+ x1 + ',' + y1 + 'L' + x2 + ',' + y2
					pid = 'Level_' + CVal
					drawPath(ContourLayer,pid,pdata,Cstrk,Cstwd,'none')
					//addseg(IContour,x1,y1,x2,y2)

        			}else{	// Top
      				if (CVal < Math.max(ULVal,URVal) && CVal > Math.min(ULVal,URVal)) {
          					x1 = LPoint + Math.round(gsize*(CVal-ULVal)/(URVal-ULVal));
          					y1 = UPoint;
          					//Join to Diagonal, note that (x2,y2) are the same as before
						pdata='M'+ x1 + ',' + y1 + 'L' + x2 + ',' + y2
						pid = 'Level_' + CVal
						drawPath(ContourLayer,pid,pdata,Cstrk,Cstwd,'none')
						//addseg(IContour,x1,y1,x2,y2)
					}
	  			} // end of line if (CVal < Math.max(URVal,LRVal)...
			}
  		} 	
	}
}
}