等高线生成算法

输入:离散的采样点坐标和高度值(x_0,y_0,value_0),(x_1,y_1,value_1)......(x_n, y_n, value_n) 

输出:等高线图,如下所示

等高线生成算法

  

  

  wiki上的Marching squares算法对此有很好的说明,我也是按照wiki上面的步骤来实现这个算法的,下面对该算法的步骤进行简要说明。

输入参数:

1、点的集合(x_0,y_0,value_0),(x_1,y_1,value_1)......(x_n, y_n, value_n) ;

2、高度值数组,即每条等高线表示的值,以上图为例是[0.0, 0.1, 0.2, .... 1.0]共10个区间,9个等高线值;

3、颜色数组,必须与高度值数组等长。

步骤:

1、构造矩阵

计算出输入点的x,y范围,即找到xmin, ymin, xmax, ymax,形成一个rectangle,然后拟定一个step,形成一个空的矩阵,step越小,等高线越平滑,计算速度也越慢。

2、矩阵插值

由输入点的值确定矩阵上每一个元素的值,这样一来,稀疏的输入点就变成了一个稠密的矩阵。一种简单的插值方式是:

matrix(x,y) = Sum(1/dist[i]^2 * value[i]) / Sum(1/dist[i]^2),其中dist[i]表示第i个点到(x,y)的欧式距离。

3、画等高线

到这里就可以完全按照wiki上的Marching squares来进行了。Marching squares算法把等高线绘制分成了两种情况,其一是只画线不上色,即isoLine算法,这种比较简单,不做讨论了;其二是画等高带,即isoBand算法,也就是本文采用的方法,如下说明:

对于每一个等高带,从高度数组中取出相临的两个阈值(如0.0, 0.1),从颜色数组中取一个颜色,用两个阈值把矩阵三值化成为一个只包含0,1,2的矩阵。0表示小于矩阵元素小于这两个阈值,1表示介于其中间,2表示大于这两个阈值。

这时,你的矩阵中就只有(0,1,2)三个值了,然后考虑矩阵中的每四个元素组成的单位正方形的状态,该状态由其四个角的元素值唯一确定,共3^4 = 81种,然后根据这81种情况分类讨论,分别上色了,此处请参考wiki的marching square页面。

如此,第一种颜色的等高带就画完了,把第3步的内容重复10次,画完所有的等高线。

 

补充一段第3步的actionscript代码,是我按照wiki的步骤实现的

 

public function isoband(data:qyMatrix, thArray:Array, 

    dstLayer:GraphicsLayer, extent:Extent):Vector.<Polygon> 

{ 

    var x:int, y:int, k:int; 

    var count:int=0; 

    var squareWidth:Number = extent.width / (data.width - 1); 

    var squareHeight:Number = extent.height / (data.height - 1); 

    var dstPolygonVec:Vector.<Polygon> = new Vector.<Polygon>(thArray.length - 1); 



                // 等值线的每一个阈值 

    for (k=0; k<thArray.length - 1; k++){ 



        // 3值化 

        var stateMat:qyMatrix = new qyMatrix(data.width, data.height); 

        for (y=0; y<data.height; y++){ 

            for (x=0; x<data.width; x++){ 

                if (data.getData(x, y) < thArray[k]){ 

                    stateMat.setData(x, y, 0); 

                } 

                else{ 

                    if (data.getData(x, y) < thArray[k+1]){ 

                        stateMat.setData(x, y, 1); 

                    } 

                    else{ 

                        stateMat.setData(x, y, 2); 

                    } 

                } 

            } 

        } 

        

        var x1:Number, y1:Number, x2:Number, y2:Number, x3:Number, y3:Number, x4:Number, y4:Number; 

        var polygon:Polygon = new Polygon; 

        

        for (y=0; y<data.height - 1; y++){ 



            var ymin:Number = extent.ymin + y / (data.height - 1) * extent.height; 

            var ymax:Number = extent.ymin + (y+1) / (data.height - 1) * extent.height; 



            for (x=0; x<data.width - 1; x++){ 



                var xmin:Number = extent.xmin + x / (data.width - 1) * extent.width; 

                var xmax:Number = extent.xmin + (x+1) / (data.width - 1) * extent.width; 



                // square 四角坐标 

                var p7:MapPoint = new MapPoint (xmin, ymin); 

                var p9:MapPoint = new MapPoint (xmax, ymin); 

                var p3:MapPoint = new MapPoint (xmax, ymax); 

                var p1:MapPoint = new MapPoint (xmin, ymax); 

                

                // square 四角数值 

                var d7:Number = data.getData(x, y); 

                var d9:Number = data.getData(x+1, y); 

                var d3:Number = data.getData(x+1, y+1); 

                var d1:Number = data.getData(x, y+1); 

                var mid:Number; 

                

                // isoband的顶点坐标 

                var pt1:MapPoint = null; 

                var pt2:MapPoint = null; 

                var pt3:MapPoint = null; 

                var pt4:MapPoint = null; 

                var pt5:MapPoint = null; 

                var pt6:MapPoint = null; 

                var pt7:MapPoint = null; 

                var pt8:MapPoint = null; 

                

                var squareState:String = getSquareState(stateMat, x, y); 

                switch (squareState)        // total 81 cases 

                { 

                   // no color 

                    case "2222": 

                    case "0000": 

                    break; 

                    // square 

                    case "1111": 

                    polygon.addRing([p7, p9, p3, p1]); 

                    break; 

                    // triangle                8 cases 

                    case "2221": 

                    x1 = p1.x + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    y2 = p1.y - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, p1.y); 

                    pt2 = new MapPoint(p7.x, y2); 

                    polygon.addRing([pt1, p1, pt2]); 

                    break; 

                    case "2212": 

                    y1 = p3.y - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    x2 = p3.x - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(p9.x, y1); 

                    pt2 = new MapPoint(x2, p1.y); 

                    polygon.addRing([pt1, p3, pt2]); 

                    break; 

                    case "2122": 

                    x1 = p9.x - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y2 = p9.y + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    pt1 = new MapPoint(x1, p7.y); 

                    pt2 = new MapPoint(p9.x, y2) 

                    polygon.addRing([pt1, p9, pt2]); 

                    break; 

                    case "1222": 

                    x1 = p7.x + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y2 = p7.y + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, p7.y); 

                    pt2 = new MapPoint(p7.x, y2); 

                    polygon.addRing([p7, pt1, pt2]); 

                    break; 

                    case "0001": 

                    x1 = p3.x - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    y2 = p7.y + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, p1.y); 

                    pt2 = new MapPoint(p7.x, y2); 

                    polygon.addRing([pt1, p1, pt2]); 

                    break; 

                    case "0010": 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x2, ymax); 

                    polygon.addRing([pt1, p3, pt2]); 

                    break; 

                    case "0100": 

                    x1 = p7.x + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y2 = p3.y - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    pt1 = new MapPoint(x1, p9.y); 

                    pt2 = new MapPoint(p9.x, y2); 

                    polygon.addRing([pt1, p9, pt2]); 

                    break; 

                    case "1000": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, pt1, pt2]); 

                    break; 

                    // trapezoid        8 cases 

                    case "2220": 

                    x1 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y1 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, p1.y); 

                    pt2 = new MapPoint(x2, p1.y); 

                    pt3 = new MapPoint(p7.x, y1); 

                    pt4 = new MapPoint(p7.x, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "2202": 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x1 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmax, y2); 

                    pt3 = new MapPoint(x1, ymax); 

                    pt4 = new MapPoint(x2, ymax); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "2022": 

                    x1 = p9.x - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = p9.x - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = p9.y + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = p9.y + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    pt1 = new MapPoint(x1, p9.y); 

                    pt2 = new MapPoint(x2, p9.y); 

                    pt3 = new MapPoint(p9.x ,y1); 

                    pt4 = new MapPoint(p9.x, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0222": 

                    x1 = p7.x + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = p7.x + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = p7.y + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y2 = p7.y + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, p7.y); 

                    pt2 = new MapPoint(x2, p7.y); 

                    pt3 = new MapPoint(p7.x, y1); 

                    pt4 = new MapPoint(p7.x, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0002": 

                    x1 = p3.x - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x2 = p3.x - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y1 = p7.y + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y2 = p7.y + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, p1.y); 

                    pt2 = new MapPoint(x2, p1.y); 

                    pt3 = new MapPoint(p1.x, y1); 

                    pt4 = new MapPoint(p1.x, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0020": 

                    y1 = p9.y + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = p9.y + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x1 = p1.x + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x2 = p1.x + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(p3.x, y1); 

                    pt2 = new MapPoint(p3.x, y2); 

                    pt3 = new MapPoint(x1, p3.y); 

                    pt4 = new MapPoint(x2, p3.y); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0200": 

                    x1 = p7.x + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = p7.x + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = p3.y - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = p3.y - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    pt1 = new MapPoint(x1, p9.y); 

                    pt2 = new MapPoint(x2, p9.y); 

                    pt3 = new MapPoint(p9.x, y1); 

                    pt4 = new MapPoint(p9.x, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    

                    break; 

                    case "2000": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmin, y1); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    // rectangle 12 cases 

                    case "0011": 

                    y1 = p9.y + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = p7.y + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(p9.x, y1); 

                    pt2 = new MapPoint(p7.x, y2); 

                    polygon.addRing([pt1, p3, p1, pt2]); 

                    break; 

                    case "0110": 

                    x1 = p7.x + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = p1.x + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, p7.y); 

                    pt2 = new MapPoint(x2, p1.y); 

                    polygon.addRing([pt1, p9, p3, pt2]); 

                    break; 

                    case "1100": 

                    y1 = p3.y - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    y2 = p1.y - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(p9.x, y1); 

                    pt2 = new MapPoint(p7.x, y2); 

                    polygon.addRing([p7, p9, pt1, pt2]); 

                    break; 

                    case "1001": 

                    x1 = p9.x - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    x2 = p3.x - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, p7.y); 

                    pt2 = new MapPoint(x2, p1.y); 

                    polygon.addRing([p7, pt1, pt2, p1]); 

                    break; 

                    case "2211": 

                    y1 = p3.y - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = p1.y - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p3, p1, pt2]); 

                    break; 

                    case "2112": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    polygon.addRing([pt1, p9, p3, pt2]); 

                    break; 

                    case "1122": 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareWidth; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, p9, pt1, pt2]); 

                    break; 

                    case "1221": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    polygon.addRing([p7, pt1, pt2, p1]); 

                    break; 

                    case "2200": 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    y3 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y4 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmax, y2); 

                    pt3 = new MapPoint(xmin, y3); 

                    pt4 = new MapPoint(xmin, y4); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "2002": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    x3 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x4 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(x4, ymax); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0022": 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    y3 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y4 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmax, y2); 

                    pt3 = new MapPoint(xmin, y3); 

                    pt4 = new MapPoint(xmin, y4); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0220": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    x3 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x4 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(x4, ymax); 

                    polygon.addRing([pt1, pt2, pt3, pt4]); 

                    break; 

                    // hexagon 12 cases 

                    case "0211": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, pt2, pt3, p3, p1, pt4]); 

                    break; 

                    case "2110": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y1 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    pt3 = new MapPoint(xmin, y1); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, p3, pt2, pt3, pt4]); 

                    break; 

                    case "1102": 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x1 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x1, ymax); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, p9, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "1021": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(x2, ymax); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4, p1]); 

                    break; 

                    case "2011": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, pt2, pt3, p3, p1, pt4]); 

                    break; 

                    case "0112": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y2 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    pt3 = new MapPoint(xmin, y1); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, p3, pt2, pt3, pt4]); 

                    break; 

                    case "1120": 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x1 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x1, ymax); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, p9, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "1201": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax -  (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(x2, ymax); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4, p1]); 

                    break; 

                    case "2101": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymax -  (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, pt2, pt3, p1, pt4]); 

                    break; 

                    case "0121": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymin + (thArray[k] - d7)        / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, pt2, pt3, p1, pt4]); 

                    break; 

                    case "1012": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, pt1, pt2, p3, pt3, pt4]); 

                    break; 

                    case "1210": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, pt1, pt2, p3, pt3, pt4]); 

                    break; 

                    // pentagon        24 cases 

                    case "1211": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y2 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y2); 

                    polygon.addRing([p7, pt1, pt2, p3, p1]); 

                    break; 

                    case "2111": 

                    x1 = xmax -  (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, p3, p1, pt2]); 

                    break; 

                    case "1112": 

                    x1 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymax); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, p9, p3, pt1, pt2]); 

                    break; 

                    case "1121": 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x2, ymax); 

                    polygon.addRing([p7, p9, pt1, pt2, p1]); 

                    break; 

                    case "1011": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y2 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y2); 

                    polygon.addRing([p7, pt1, pt2, p3, p1]); 

                    break; 

                    case "0111": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y2 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([pt1, p9, p3, p1, pt2]); 

                    break; 

                    case "1110": 

                    x1 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymax); 

                    pt2 = new MapPoint(xmin, y2); 

                    polygon.addRing([p7, p9, p3, pt1, pt2]); 

                    break; 

                    case "1101": 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x2, ymax); 

                    polygon.addRing([p7, p9, pt1, pt2, p1]); 

                    break; 

                    case "1200": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    y3 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0120": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(x3, ymax); 

                    polygon.addRing([pt1, p9, pt2, pt3, pt4]); 

                    break; 

                    case "0012": 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    x1 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x1, ymax); 

                    pt3 = new MapPoint(xmin, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, p3, pt2, pt3, pt4]); 

                    break; 

                    case "2001": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    x3 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    y1 = ymax -  (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(xmin, y1); 

                    polygon.addRing([pt1, pt2, pt3, p1, pt4]); 

                    break; 

                    case "1022": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    y3 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "2102": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(x3, ymax); 

                    polygon.addRing([pt1, p9, pt2, pt3, pt4]); 

                    break; 

                    case "2210": 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    x1 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(x1, ymax); 

                    pt3 = new MapPoint(xmin, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, p3, pt2, pt3, pt4]); 

                    break; 

                    case "0221": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    x3 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    y1 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(xmin, y1); 

                    polygon.addRing([pt1, pt2, pt3, p1, pt4]); 

                    break; 

                    case "1002": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(xmin, y1); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "2100": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmin, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, p9, pt2, pt3, pt4]); 

                    break; 

                    case "0210": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(x3, ymax); 

                    polygon.addRing([pt1, pt2, pt3, p3, pt4]); 

                    break; 

                    case "0021": 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x1 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmax, y2); 

                    pt3 = new MapPoint(x1, ymax); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, pt2, pt3, p1, pt4]); 

                    break; 

                    case "1220": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y1 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymax); 

                    pt3 = new MapPoint(x3, ymax); 

                    pt4 = new MapPoint(xmin, y1); 

                    polygon.addRing([p7, pt1, pt2, pt3, pt4]); 

                    break; 

                    case "0122": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmin, y2); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, p9, pt2, pt3, pt4]); 

                    break; 

                    case "2012": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(x3, ymax); 

                    polygon.addRing([pt1, pt2, pt3, p3, pt4]); 

                    break; 

                    case "2201": 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x1 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(xmax, y1); 

                    pt2 = new MapPoint(xmax, y2); 

                    pt3 = new MapPoint(x1, ymax); 

                    pt4 = new MapPoint(xmin, y3); 

                    polygon.addRing([pt1, pt2, pt3, p1, pt4]); 

                    break; 

                    // saddles - 8 sided        2 cases 

                    case "2020": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x3 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x4 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y3 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y4 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmax, y2); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(x4, ymax); 

                    pt7 = new MapPoint(xmin, y3); 

                    pt8 = new MapPoint(xmin, y4); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([pt1, pt2, pt7, pt8]); 

                        polygon.addRing([pt3, pt4, pt5, pt6]); 

                    } 

                    else if (mid < thArray[k+1]){ 

                        polygon.addRing([pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt3, pt4]); 

                        polygon.addRing([pt5, pt6, pt7, pt8]); 

                    } 

                    break; 

                    case "0202": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x3 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x4 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y3 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y4 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmax, y2); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(x4, ymax); 

                    pt7 = new MapPoint(xmin, y3); 

                    pt8 = new MapPoint(xmin, y4); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([pt1, pt2, pt3, pt4]); 

                        polygon.addRing([pt5, pt6, pt7, pt8]); 

                    } 

                    else if (mid < thArray[k+1]){ 

                        polygon.addRing([pt1, pt2, pt3, pt4, pt5, pt6, pt7, pt8]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt7, pt8]); 

                        polygon.addRing([pt3, pt4, pt5, pt6]); 

                    } 

                    break; 

                    // saddles:        6 sided                4 cases 

                    case "0101": 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        x1 = p7.x + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                        y2 = p3.y - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                        pt1 = new MapPoint(x1, p9.y); 

                        pt2 = new MapPoint(p9.x, y2); 

                        polygon.addRing([pt1, p9, pt2]); 



                        x1 = p3.x - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                        y2 = p7.y + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                        pt1 = new MapPoint(x1, p1.y); 

                        pt2 = new MapPoint(p7.x, y2); 

                        polygon.addRing([pt1, p1, pt2]); 

                    } 

                    else{ 

                        x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                        y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                        x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                        y2 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                        pt1 = new MapPoint(x1, ymin); 

                        pt2 = new MapPoint(xmax, y1); 

                        pt3 = new MapPoint(x2, ymax); 

                        pt4 = new MapPoint(xmin, y2); 

                        polygon.addRing([pt1, p9, pt2, pt3, p1, pt4]); 

                    } 

                    break; 

                    case "1010": 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                        y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                        pt1 = new MapPoint(x1, ymin); 

                        pt2 = new MapPoint(xmin, y2); 

                        polygon.addRing([p7, pt1, pt2]); 



                        y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                        x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                        pt1 = new MapPoint(p9.x, y1); 

                        pt2 = new MapPoint(x2, p1.y); 

                        polygon.addRing([pt1, p3, pt2]); 

                    } 

                    else{ 

                        x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                        y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                        x2 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                        y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                        pt1 = new MapPoint(x1, ymin); 

                        pt2 = new MapPoint(xmax, y1); 

                        pt3 = new MapPoint(x2, ymax); 

                        pt4 = new MapPoint(xmin, y2); 

                        polygon.addRing([p7, pt1, pt2, p3, pt3, pt4]); 

                    } 

                    break; 

                    case "2121": 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                        y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                        x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                        y2 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                        pt1 = new MapPoint(x1, ymin); 

                        pt2 = new MapPoint(xmax, y1); 

                        pt3 = new MapPoint(x2, ymax); 

                        pt4 = new MapPoint(xmin, y2); 

                        polygon.addRing([pt1, p9, pt2, pt3, p1, pt4]); 

                    } 

                    else{ 

                        x1 = p9.x - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                        y2 = p9.y + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                        pt1 = new MapPoint(x1, p7.y); 

                        pt2 = new MapPoint(p9.x, y2) 

                        polygon.addRing([pt1, p9, pt2]); 



                        x1 = p1.x + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                        y2 = p1.y - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                        pt1 = new MapPoint(x1, p1.y); 

                        pt2 = new MapPoint(p7.x, y2); 

                        polygon.addRing([pt1, p1, pt2]); 

                    } 

                    break; 

                    case "1212": 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                        y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                        x2 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                        y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                        pt1 = new MapPoint(x1, ymin); 

                        pt2 = new MapPoint(xmax, y1); 

                        pt3 = new MapPoint(x2, ymax); 

                        pt4 = new MapPoint(xmin, y2); 

                        polygon.addRing([p7, pt1, pt2, p3, pt3, pt4]); 

                    } 

                    else{ 

                        x1 = p7.x + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                        y2 = p7.y + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                        pt1 = new MapPoint(x1, p7.y); 

                        pt2 = new MapPoint(p7.x, y2); 

                        polygon.addRing([p7, pt1, pt2]); 

                        y1 = p3.y - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                        x2 = p3.x - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                        pt1 = new MapPoint(p9.x, y1); 

                        pt2 = new MapPoint(x2, p1.y); 

                        polygon.addRing([pt1, p3, pt2]); 

                    } 

                    break; 

                    // saddles 7 sided                8 cases 

                    case "2120": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(x3, ymax); 

                    pt5 = new MapPoint(xmin, y2); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        polygon.addRing([pt1, p9, pt2, pt3, pt4, pt5, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, p9, pt2]); 

                        polygon.addRing([pt3, pt4, pt5, pt6]); 

                    } 

                    break; 

                    case "2021": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x3 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmax, y2); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        polygon.addRing([pt1, pt2, pt3, pt4, pt5, p1, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt3, pt4]); 

                        polygon.addRing([pt5, p1, pt6]); 

                    } 

                    break; 

                    case "1202": 

                    x1 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y3 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(x2, ymax); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(xmin, y3); 



                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        polygon.addRing([p7, pt1, pt2, pt3, pt4, pt5, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([p7, pt1, pt6]); 

                        polygon.addRing([pt2, pt3, pt4, pt5]); 

                    } 

                    break; 

                    case "0212": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(x3, ymax); 

                    pt5 = new MapPoint(xmin, y2); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k+1]){ 

                        polygon.addRing([pt1, pt2, pt3, p3, pt4, pt5, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt5, pt6]); 

                        polygon.addRing([pt3, p3, pt4]); 

                    } 

                    break; 

                    case "0102": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x2 = xmax - (thArray[k] - d3) / (d1 - d3) * squareWidth; 

                    x3 = xmax - (thArray[k+1] - d3) / (d1 - d3) * squareWidth; 

                    y2 = ymin + (thArray[k+1] - d7) / (d1 - d7) * squareHeight; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(x2, ymax); 

                    pt4 = new MapPoint(x3, ymax); 

                    pt5 = new MapPoint(xmin, y2); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([pt1, p9, pt2]); 

                        polygon.addRing([pt3, pt4, pt5, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, p9, pt2, pt3, pt4, pt5, pt6]); 

                    } 

                    break; 

                    case "0201": 

                    x1 = xmin + (thArray[k] - d7) / (d9 - d7) * squareWidth; 

                    x2 = xmin + (thArray[k+1] - d7) / (d9 - d7) * squareWidth; 

                    y1 = ymax - (thArray[k+1] - d3) / (d9 - d3) * squareHeight; 

                    y2 = ymax - (thArray[k] - d3) / (d9 - d3) * squareHeight; 

                    x3 = xmax - (thArray[k] - d3) / (d1- d3) * squareWidth; 

                    y3 = ymin + (thArray[k] - d7) / (d1 - d7) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(xmax, y2); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([pt1, pt2, pt3, pt4]); 

                        polygon.addRing([pt5, p1, pt6]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt3, pt4, pt5, p1, pt6]); 

                    } 

                    break; 

                    case "1020": 

                    x1 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    y2 = ymin + (thArray[k+1] - d9) / (d3 - d9) * squareHeight; 

                    x2 = xmin + (thArray[k+1] - d1) / (d3 - d1) * squareWidth; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y3 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(xmax, y1); 

                    pt3 = new MapPoint(xmax, y2); 

                    pt4 = new MapPoint(x2, ymax); 

                    pt5 = new MapPoint(x3, ymax); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([p7, pt1, pt6]); 

                        polygon.addRing([pt2, pt3, pt4, pt5,]); 

                    } 

                    else{ 

                        polygon.addRing([p7, pt1, pt2, pt3, pt4, pt5, pt6]); 

                    } 

                    break; 

                    case "2010": 

                    x1 = xmax - (thArray[k+1] - d9) / (d7 - d9) * squareWidth; 

                    x2 = xmax - (thArray[k] - d9) / (d7 - d9) * squareWidth; 

                    y1 = ymin + (thArray[k] - d9) / (d3 - d9) * squareHeight; 

                    x3 = xmin + (thArray[k] - d1) / (d3 - d1) * squareWidth; 

                    y2 = ymax - (thArray[k] - d1) / (d7 - d1) * squareHeight; 

                    y3 = ymax - (thArray[k+1] - d1) / (d7 - d1) * squareHeight; 

                    pt1 = new MapPoint(x1, ymin); 

                    pt2 = new MapPoint(x2, ymin); 

                    pt3 = new MapPoint(xmax, y1); 

                    pt4 = new MapPoint(x3, ymax); 

                    pt5 = new MapPoint(xmin, y2); 

                    pt6 = new MapPoint(xmin, y3); 

                    mid = (d7 + d9 + d3 + d1) / 4; 

                    if (mid < thArray[k]){ 

                        polygon.addRing([pt1, pt2, pt5, pt6]); 

                        polygon.addRing([pt3, p3, pt4]); 

                    } 

                    else{ 

                        polygon.addRing([pt1, pt2, pt3, p3, pt4, pt5, pt6]); 

                    } 

                    break; 

                    default: 

                    break; 

                } 

            } 

        } 

        dstPolygonVec[k] = polygon; 

        //DrawToolBox.qyPolygon(dstLayer, polygon, 0, 0, 0.8, colorArray[k]); 

    } 

    return dstPolygonVec; 



    function getSquareState(mat:qyMatrix, x:int, y:int):String 

    { 

        var str:String = ''; 

        str += String(mat.getData(x, y)); 

        str += String(mat.getData(x + 1, y)); 

        str += String(mat.getData(x + 1, y + 1)); 

        str += String(mat.getData(x, y + 1)); 

        return str; 

    } 

}
View Code

 

你可能感兴趣的:(算法)