精华内容
下载资源
问答
我要提问

  • 面积

     千次阅读 2013-12-10 19:34:03
    编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下所示，在10*10的二维数组中，有“*”围住了15个点，因此面积为15。 0 0 0 0 0 0 0 0 0 0 0 0 0 0... 
    
Problem Description
    

    
编程计算由“*”号围成的下列图形的面积。面积计算方法是统计*号所围成的闭合曲线中水平线和垂直线交点的数目。如下所示，在10*10的二维数组中，有“*”围住了15个点，因此面积为15。
    
0 0 0 0 0 0 0 0 0 0
    
0 0 0 0 * * * 0 0 0
    
0 0 0 0 * 0 0 * 0 0
    
0 0 0 0 0 * 0 0 * 0
    
0 0 * 0 0 0 * 0 * 0
    
0 * 0 * 0 * 0 0 * 0
    
0 * 0 0 * * 0 * * 0
    
0 0 * 0 0 0 0 * 0 0
    
0 0 0 * * * * * 0 0
    
0 0 0 0 0 0 0 0 0 0
    

    
Input
    

    
输入有多组数据，每组数据是10*10的二维数组。
    

    
Output
    

    
对于每组数据输出面积。
    

    
Sample Input
    

    

    0 0 0 0 0 0 0 0 0 0
0 0 0 0 1 1 1 0 0 0
0 0 0 0 1 0 0 1 0 0
0 0 0 0 0 1 0 0 1 0
0 0 1 0 0 0 1 0 1 0
0 1 0 1 0 1 0 0 1 0
0 1 0 0 1 1 0 1 1 0
0 0 1 0 0 0 0 1 0 0
0 0 0 1 1 1 1 1 0 0
0 0 0 0 0 0 0 0 0 0
    

    

    
Sample Output
    

    

    15
    

    /*
         解题报告：把边界的0全部赋值为-1，然后进行两次遍历，从上往下，在从下往上；
                        在遍历时，当前位置为0，如果上，下，左，右有一个是-1，则把当前的
                        0更改为-1；
                        遍历完后，在记录0的个数，就是所求的结果。
*/
//标程：
#include<stdio.h>
#include<string.h>
int p[20][20];
int main()
{
    //freopen("a.txt","r",stdin);
    int k;
    while(scanf("%d",&k)!=EOF)
    {
        memset(p,0,sizeof(p));
        p[1][1]=k;
        int i,j,cnt=0;
        for(i=1;i<=10;i++)
        {
           if(i==1)
               for(j=2;j<=10;j++) scanf("%d",&p[i][j]);
            else
              for(j=1;j<=10;j++) scanf("%d",&p[i][j]);
        }
        for(i=1;i<=10;i++)
        {
            if(p[1][i]==0) p[1][i]=-1;
            if(p[10][i]==0) p[10][i]=-1;
            if(p[i][10]==0) p[i][10]=-1;
            if(p[i][1]==0) p[i][1]=-1;
        }
          for(i=1;i<=10;i++)
            for(j=1;j<=10;j++)
              if(p[i][j]==0 && (p[i][j+1]==-1 || p[i][j-1]==-1 || p[i-1][j]==-1 || p[i+1][j]==-1))
                  p[i][j]=-1;
         for(i=10;i>0;i--)
           for(j=10;j>0;j--)
            if(p[i][j]==0 && (p[i][j+1]==-1 || p[i][j-1]==-1 || p[i-1][j]==-1 || p[i+1][j]==-1))
                 p[i][j]=-1;
        for(i=1;i<=10;i++)
           for(j=1;j<=10;j++)
            if(p[i][j]==0) cnt++;
        printf("%d\n",cnt);
    }
     return 0;
}
    收起
    展开全文

  • 百度地图实现测量面积和测量距离功能

     万次阅读 热门讨论 2018-01-06 22:01:20
    最近在公司的项目中，需要用到百度地图的测距和测面积功能，但是在网上只找到了测量距离的api，即BMapLib.DistanceTool。 但是测面积在网上没有找到很好的资料，百度提供的DrawingManager虽然也可以实现测面积，... 
    最近在公司的项目中，需要用到百度地图的测距和测面积功能，但是在网上只找到了测量距离的api，即BMapLib.DistanceTool。
    


    但是测面积在网上没有找到很好的资料，百度提供的DrawingManager虽然也可以实现测面积，但是感觉太lol了，然后继续找资料，发现有人跟我遇到同样的问题，他的解决思路是对BMapLib.DistanceTool进行改造，但遗憾的是没有提供源码。
    


    我也想过要改造BMapLib.DistanceTool，但是这个对我来说很有挑战性，毕竟js我差不多是小白，今天闲来无事，决定一试。下载了BMapLib.DistanceTool的源码看，大部分都看不懂，呵呵，不过我要做的工作就是在事件处理中加入自己的逻辑，寻着这个思路，经过几番折腾，终于搞定了，整体效果自己还比较满意。
    


    好了，废话不多说，接下来进入重点，我把百度地图实现测量面积源码公布下（Java成长交流学习群：184998348），代码下载地址：https://download.csdn.net/download/hgq0916/12403463。分享给大家，若有大神路过，别见怪，哈哈。
    


    首先来张效果图：
    


    


    下面是源码：
    


    1.measureAreaTool_baidu.html
    


     
    


    <!DOCTYPE html>    
<html>    
<head>    
    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />    
    <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />    
    <style type="text/css">    
    body, html{width: 100%;height: 100%;margin:0;font-family:"微软雅黑";}    
    #allmap {width: 100%; height:500px; overflow: hidden;}    
    #result {width:100%;font-size:12px;}    
    </style>
     <script type="text/javascript" src="http://api.map.baidu.com/api?v=2.0&ak=你的AK"></script>    
    <script src="js/GeoUtils.js" type="text/javascript"></script>
    <script type="text/javascript" src="js/AreaTool_min.js"></script>
    <title>百度地图API功能演示</title>
</head>    
<body>
    <div id="allmap" style="overflow:hidden;zoom:1;position:relative;">       
        <div id="map" style="height:100%;-webkit-transition: all 0.5s ease-in-out;transition: all 0.5s ease-in-out;">    
       </div>    
    </div>
    <div id="result">    
        <input type="button"  value="面积测量" onclick="measureArea(this)" /><br/>
    </div>

<script type="text/javascript">    
    var map = new BMap.Map('map');
    var poi = new BMap.Point(113.948913,22.530844);    
    map.centerAndZoom(poi, 16);    
    map.enableScrollWheelZoom();
    //添加测量面积工具
   	var measureAreaTool = createMeasureAreaTool(map);
    //面积测量
    var measureArea = function(e){
    	measureAreaTool.open();
    }
</script>
</body>    
</html>    
    


    2.依赖的js
    


    2.1  百度地图的核心js文件，这个用于显示百度地图的，不多说
    


    2.2    AreaTool_min.js  这个就是我改造百度地图测距js后自己创建的测面积工具，完成对面积的测量
    


     
    


     // 百度地图API功能
var BMapLib = window.BMapLib = BMapLib || {}; (function() {
    var c = c || {
        guid: "$BAIDU$"
    }; (function() {
        window[c.guid] = {};
        c.extend = function(g, e) {
            for (var f in e) {
                if (e.hasOwnProperty(f)) {
                    g[f] = e[f]
                }
            }
            return g
        };
        c.lang = c.lang || {};
        c.lang.guid = function() {
            return "TANGRAM__" + (window[c.guid]._counter++).toString(36)
        };
        window[c.guid]._counter = window[c.guid]._counter || 1;
        window[c.guid]._instances = window[c.guid]._instances || {};
        c.lang.Class = function(e) {
            this.guid = e || c.lang.guid();
            window[c.guid]._instances[this.guid] = this
        };
        window[c.guid]._instances = window[c.guid]._instances || {};
        c.lang.isString = function(e) {
            return "[object String]" == Object.prototype.toString.call(e)
        };
        c.lang.isFunction = function(e) {
            return "[object Function]" == Object.prototype.toString.call(e)
        };
        c.lang.Class.prototype.toString = function() {
            return "[object " + (this._className || "Object") + "]"
        };
        c.lang.Class.prototype.dispose = function() {
            delete window[c.guid]._instances[this.guid];
            for (var e in this) {
                if (!c.lang.isFunction(this[e])) {
                    delete this[e]
                }
            }
            this.disposed = true
        };
        c.lang.Event = function(e, f) {
            this.type = e;
            this.returnValue = true;
            this.target = f || null;
            this.currentTarget = null
        };
        c.lang.Class.prototype.addEventListener = function(h, g, f) {
            if (!c.lang.isFunction(g)) {
                return
            } ! this.__listeners && (this.__listeners = {});
            var e = this.__listeners,
            i;
            if (typeof f == "string" && f) {
                if (/[^\w\-]/.test(f)) {
                    throw ("nonstandard key:" + f)
                } else {
                    g.hashCode = f;
                    i = f
                }
            }
            h.indexOf("on") != 0 && (h = "on" + h);
            typeof e[h] != "object" && (e[h] = {});
            i = i || c.lang.guid();
            g.hashCode = i;
            e[h][i] = g
        };
        c.lang.Class.prototype.removeEventListener = function(g, f) {
            if (c.lang.isFunction(f)) {
                f = f.hashCode
            } else {
                if (!c.lang.isString(f)) {
                    return
                }
            } ! this.__listeners && (this.__listeners = {});
            g.indexOf("on") != 0 && (g = "on" + g);
            var e = this.__listeners;
            if (!e[g]) {
                return
            }
            e[g][f] && delete e[g][f]
        };
        c.lang.Class.prototype.dispatchEvent = function(h, e) {
            if (c.lang.isString(h)) {
                h = new c.lang.Event(h)
            } ! this.__listeners && (this.__listeners = {});
            e = e || {};
            for (var g in e) {
                h[g] = e[g]
            }
            var g, f = this.__listeners,
            j = h.type;
            h.target = h.target || this;
            h.currentTarget = this;
            j.indexOf("on") != 0 && (j = "on" + j);
            c.lang.isFunction(this[j]) && this[j].apply(this, arguments);
            if (typeof f[j] == "object") {
                for (g in f[j]) {
                    f[j][g].apply(this, arguments)
                }
            }
            return h.returnValue
        };
        c.lang.inherits = function(k, i, h) {
            var g, j, e = k.prototype,
            f = new Function();
            f.prototype = i.prototype;
            j = k.prototype = new f();
            for (g in e) {
                j[g] = e[g]
            }
            k.prototype.constructor = k;
            k.superClass = i.prototype;
            if ("string" == typeof h) {
                j._className = h
            }
        };
        c.dom = c.dom || {};
        c._g = c.dom._g = function(e) {
            if (c.lang.isString(e)) {
                return document.getElementById(e)
            }
            return e
        };
        c.g = c.dom.g = function(e) {
            if ("string" == typeof e || e instanceof String) {
                return document.getElementById(e)
            } else {
                if (e && e.nodeName && (e.nodeType == 1 || e.nodeType == 9)) {
                    return e
                }
            }
            return null
        };
        c.insertHTML = c.dom.insertHTML = function(h, e, g) {
            h = c.dom.g(h);
            var f, i;
            if (h.insertAdjacentHTML) {
                h.insertAdjacentHTML(e, g)
            } else {
                f = h.ownerDocument.createRange();
                e = e.toUpperCase();
                if (e == "AFTERBEGIN" || e == "BEFOREEND") {
                    f.selectNodeContents(h);
                    f.collapse(e == "AFTERBEGIN")
                } else {
                    i = e == "BEFOREBEGIN";
                    f[i ? "setStartBefore": "setEndAfter"](h);
                    f.collapse(i)
                }
                f.insertNode(f.createContextualFragment(g))
            }
            return h
        };
        c.ac = c.dom.addClass = function(k, m) {
            k = c.dom.g(k);
            var f = m.split(/\s+/),
            e = k.className,
            j = " " + e + " ",
            h = 0,
            g = f.length;
            for (; h < g; h++) {
                if (j.indexOf(" " + f[h] + " ") < 0) {
                    e += (e ? " ": "") + f[h]
                }
            }
            k.className = e;
            return k
        };
        c.event = c.event || {};
        c.event._listeners = c.event._listeners || [];
        c.on = c.event.on = function(f, i, k) {
            i = i.replace(/^on/i, "");
            f = c._g(f);
            var j = function(m) {
                k.call(f, m)
            },
            e = c.event._listeners,
            h = c.event._eventFilter,
            l,
            g = i;
            i = i.toLowerCase();
            if (h && h[i]) {
                l = h[i](f, i, j);
                g = l.type;
                j = l.listener
            }
            if (f.addEventListener) {
                f.addEventListener(g, j, false)
            } else {
                if (f.attachEvent) {
                    f.attachEvent("on" + g, j)
                }
            }
            e[e.length] = [f, i, k, j, g];
            return f
        };
        c.un = c.event.un = function(g, j, f) {
            g = c._g(g);
            j = j.replace(/^on/i, "").toLowerCase();
            var m = c.event._listeners,
            h = m.length,
            i = !f,
            l, k, e;
            while (h--) {
                l = m[h];
                if (l[1] === j && l[0] === g && (i || l[2] === f)) {
                    k = l[4];
                    e = l[3];
                    if (g.removeEventListener) {
                        g.removeEventListener(k, e, false)
                    } else {
                        if (g.detachEvent) {
                            g.detachEvent("on" + k, e)
                        }
                    }
                    m.splice(h, 1)
                }
            }
            return g
        };
        c.preventDefault = c.event.preventDefault = function(e) {
            if (e.preventDefault) {
                e.preventDefault()
            } else {
                e.returnValue = false
            }
        }
    })();
    //TODO
    var d = BMapLib.MeasureAreaTool = function(f, e) {
        if (!f) {
            return
        }
        this._map = f;
        e = e || {};
        this._opts = c.extend(c.extend(this._opts || {},
        {
            tips: "\u6d4b\u8ddd",
            followText: "\u5355\u51fb\u786e\u5b9a\u5730\u70b9\uff0c\u53cc\u51fb\u7ed3\u675f",
            unit: "metric",
            lineColor: "#ff6319",
            lineStroke: 2,
            opacity: 0.8,
            lineStyle: "solid",
            cursor: "http://api.map.baidu.com/images/ruler.cur",
            secIcon: null,
            closeIcon: null
        }), e);
        this._followTitle = null;
        this._points = [];
        this._paths = [];
        this._dots = [];
        this._segDistance = [];
        this._overlays = [];
        this._enableMassClear = true,
        this._units = {
            metric: {
                name: "metric",
                conv: 1,
                incon: 1000,
                u1: "\u7c73",
                u2: "\u516c\u91cc"
            },
            us: {
                name: "us",
                conv: 3.2808,
                incon: 5279.856,
                u1: "\u82f1\u5c3a",
                u2: "\u82f1\u91cc"
            }
        };
        this._isOpen = false;
        this._startFollowText = "\u5355\u51fb\u786e\u5b9a\u8d77\u70b9";
        this._movingTimerId = null;
        this._styles = {
            BMapLib_diso: "height:17px;width:5px;position:absolute;background:url(http://api.map.baidu.com/images/dis_box_01.gif) no-repeat left top",
            BMapLib_disi: "color:#7a7a7a;position:absolute;left:5px;padding:0 4px 1px 0;line-height:17px;background:url(http://api.map.baidu.com/images/dis_box_01.gif) no-repeat right top",
            BMapLib_disBoxDis: "color:#ff6319;font-weight:bold"
        };
        if (this._opts.lineStroke <= 0) {
            this._opts.lineStroke = 2
        }
        if (this._opts.opacity > 1) {
            this._opts.opacity = 1
        } else {
            if (this._opts.opacity < 0) {
                this._opts.opacity = 0
            }
        }
        if (this._opts.lineStyle != "solid" && this._opts.lineStyle != "dashed") {
            this._opts.lineStyle = "solid"
        }
        if (!this._units[this._opts.unit]) {
            this._opts.unit = "metric"
        }
        this.text = "\u6d4b\u8ddd"
    };
    c.lang.inherits(d, c.lang.Class, "DistanceTool");
    d.prototype._bind = function() {
        this._setCursor(this._opts.cursor);
        var f = this;
        c.on(this._map.getContainer(), "mousemove",
        function(i) {
            if (!f._isOpen) {
                return
            }
            if (!f._followTitle) {
                return
            }
            i = window.event || i;
            var g = i.target || i.srcElement;
            if (g != a.getDom(f._map)) {
                f._followTitle.hide();
                return
            }
            if (!f._mapMoving) {
                f._followTitle.show()
            }
            var h = a.getDrawPoint(i, true);
            f._followTitle.setPosition(h)
        });
        if (this._startFollowText) {
            var e = this._followTitle = new BMap.Label(this._startFollowText, {
                offset: new BMap.Size(14, 16)
            });
            this._followTitle.setStyles({
                color: "#333",
                borderColor: "#ff0103"
            })
        }
    };
    d.prototype.open = function() {
        if (this._isOpen == true) {
            return true
        }
        if ( !! BMapLib._toolInUse) {
            return
        }
        this._isOpen = true;
        BMapLib._toolInUse = true;
        if (this._mapMoving) {
            delete this._mapMoving
        }
        var h = this;
        if (!this._binded) {
            this._binded = true;
            this._bind();
            this._map.addEventListener("moving",
            function() {
                h._hideCurrent()
            })
        }
        if (this._followTitle) {
            this._map.addOverlay(this._followTitle);
            this._followTitle.hide()
        }
        var g = function(q) {
        	//TODO
            var l = h._map;//获取map对象
            if (!h._isOpen) {//判断测距工具是否打开，关闭则返回
                return
            }
            q = window.event || q;
            var n = a.getDrawPoint(q, true);//获取鼠标点击的点
            if (!h._isPointValid(n)) {//判断点是否有效
                return
            }
            h._bind.initX = q.pageX || q.clientX || 0;//绑定当前的坐标
            h._bind.initY = q.pageY || q.clientY || 0;
            if (h._points.length > 0) {
                var t = l.pointToPixel(h._points[h._points.length - 1]);//获取点数组最后一个元素，转换为Pixel点
                var m = l.pointToPixel(n);//将当前的点转换为Pixel点
                var p = Math.sqrt(Math.pow(t.x - m.x, 2) + Math.pow(t.y - m.y, 2));//求两个点的距离
                if (p < 5) {//距离小于5则返回
                    return
                }
            }
            h._bind.x = q.layerX || q.offsetX || 0;//保存当前坐标
            h._bind.y = q.layerY || q.offsetY || 0;
            h._points.push(n);//将当前坐标存入数组
            h._addSecPoint(n);//TODO
            if (h._paths.length == 0) {
                h._formatTitle(1, h._opts.followText, h._getTotalDistance())
            }
            if (h._paths.length > 0) {
                h._paths[h._paths.length - 1].show();
                h._paths[h._paths.length - 1].setStrokeOpacity(h._opts.opacity)
            }
            var w = new BMap.Polyline([n, n], {
                enableMassClear: h._enableMassClear
            });
            h._map.addOverlay(w);
            h._paths.push(w);
            h._overlays.push(w);
            w.setStrokeWeight(h._opts.lineStroke);
            w.setStrokeColor(h._opts.lineColor);
            w.setStrokeOpacity(h._opts.opacity / 2);
            w.setStrokeStyle(h._opts.lineStyle);
            if (h._mapMoving) {
                w.hide()
            }
            if (h._points.length > 1) {
                var o = h._paths[h._points.length - 2];
                o.setPositionAt(1, n)
            }
            var r = "";
            var v;
            if (h._points.length > 1) {
                var u = h._setSegDistance(h._points[h._points.length - 2], h._points[h._points.length - 1]);
                var s = h._getTotalDistance();
                r = h._formatDisStr(s);
                v = new BMap.Label(r, {
                    offset: new BMap.Size(10, -5),
                    enableMassClear: h._enableMassClear
                });
            } else {
                r = "\u8d77\u70b9";
                v = new BMap.Label(r, {
                    offset: new BMap.Size(-10, -25),
                    enableMassClear: h._enableMassClear
                });
            }
            // var v = new BMap.Label(r, {
            //     offset: new BMap.Size(10, -5),
            //     enableMassClear: h._enableMassClear
            // });
            v.setStyles({
                color: "#333",
                borderColor: "#ff0103"
            });
            h._map.addOverlay(v);
            h._formatSegLabel(v, r);
            h._overlays.push(v);
            n.disLabel = v;
            v.setPosition(n);
            var k = new c.lang.Event("onaddpoint");
            k.point = n;
            k.pixel = h._map.pointToPixel(n);
            k.index = h._points.length - 1;
            k.distance = h._getTotalDistance().toFixed(0);
            h.dispatchEvent(k)
        };
        var f = function(p) {
            if (!h._isOpen) {
                return
            }
            if (h._paths.length > 0) {
                p = window.event || p;
                var l = p.pageX || p.clientX || 0;
                var k = p.pageY || p.clientY || 0;
                if (typeof h._bind.initX == "undefined") {
                    h._bind.x = p.layerX || p.offsetX || 0;
                    h._bind.y = p.layerY || p.offsetY || 0;
                    h._bind.initX = l;
                    h._bind.initY = k
                }
                var r = h._bind.x + l - h._bind.initX;
                var q = h._bind.y + k - h._bind.initY;
                var z = h._paths[h._paths.length - 1];
                var m = h._map.pixelToPoint(new BMap.Pixel(r, q));
                z.setPositionAt(1, m);
                if (!h._mapMoving) {
                    z.show()
                }
                var A = 0;
                var u = 0;
                if (r < 10) {
                    A = 8
                } else {
                    if (r > h._map.getSize().width - 10) {
                        A = -8
                    }
                }
                if (q < 10) {
                    u = 8
                } else {
                    if (q > h._map.getSize().height - 10) {
                        u = -8
                    }
                }
                if (A != 0 || u != 0) {
                    if (!f._movingTimerId) {
                        h._mapMoving = true;
                        h._map.panBy(A, u, {
                            noAnimation: true
                        });
                        h._movingTimerId = f._movingTimerId = setInterval(function() {
                            h._map.panBy(A, u, {
                                noAnimation: true
                            })
                        },
                        30);
                        z.hide();
                        h._followTitle && h._followTitle.hide()
                    }
                } else {
                    if (f._movingTimerId) {
                        clearInterval(f._movingTimerId);
                        delete f._movingTimerId;
                        delete h._movingTimerId;
                        var w = h._paths[h._paths.length - 1];
                        var v = h._map.pixelToPoint(new BMap.Pixel(r, q));
                        if (!w) {
                            return
                        }
                        w.setPositionAt(1, v);
                        w.show();
                        if (h._followTitle) {
                            h._followTitle.setPosition(v);
                            h._followTitle.show()
                        }
                        h._bind.i = 0;
                        h._bind.j = 0;
                        delete h._mapMoving
                    }
                }
                if (h._followTitle) {
                    var o = h._getTotalDistance();
                    var n = h._map.getDistance(h._points[h._points.length - 1], m);
                    h._updateInstDis(h._followTitle, o + n)
                }
            } else {
                if (h._followTitle) {
                    h._followTitle.show();
                    p = window.event || p;
                    var s = p.target || p.srcElement;
                    if (s != a.getDom()) {
                        h._followTitle.hide()
                    }
                }
            }
        };
        var e = function(k) {
            if (!h._isOpen) {
                return
            }
            c.un(a.getDom(h._map), "click", g);
            c.un(document, "mousemove", f);
            c.un(a.getDom(h._map), "dblclick", e);
            c.un(document, "keydown", j);
            c.un(a.getDom(h._map), "mouseup", i);
            setTimeout(function() {
            	//1
                h.close()
            },
            50)
        };
        var j = function(k) {
            k = window.event || k;
            if (k.keyCode == 27) {
                h._clearCurData();
                setTimeout(function() {
                	//2
                    h.close()
                },
                50)
            }
        };
        var i = function(k) {
            k = window.event || k;
            var l = 0;
            if (/msie (\d+\.\d)/i.test(navigator.userAgent)) {
                l = document.documentMode || +RegExp["\x241"]
            }
            if (l && k.button != 1 || k.button == 2) {
            	//3
                h.close()
            }
        };
        h._initData();
        this._formatTitle();
        a.show(this._map);
        this._setCursor(this._opts.cursor);
        c.on(a.getDom(this._map), "click", g);
        c.on(document, "mousemove", f);
        c.on(a.getDom(this._map), "dblclick", e);
        c.on(document, "keydown", j);
        c.on(a.getDom(this._map), "mouseup", i);
        this.bindFunc = [{
            elem: a.getDom(this._map),
            type: "click",
            func: g
        },
        {
            elem: a.getDom(this._map),
            type: "dblclick",
            func: e
        },
        {
            elem: document,
            type: "mousemove",
            func: f
        },
        {
            elem: document,
            type: "keydown",
            func: j
        },
        {
            elem: a.getDom(this._map),
            type: "mouseup",
            func: i
        }];
        return true
    };
    d.prototype._dispatchLastEvent = function() {
        var e = new c.lang.Event("ondrawend");
        e.points = this._points ? this._points.slice(0) : [];
        e.overlays = this._paths ? this._paths.slice(0, this._paths.length - 1) : [];
        e.distance = this._getTotalDistance().toFixed(0);
        this.dispatchEvent(e)
    };
    d.prototype.close = function() {
        if (this._isOpen == false) {
            return
        }
        this._isOpen = false;
        BMapLib._toolInUse = false;
        if (this._mapMoving) {
            delete this._mapMoving
        }
        var g = this;
        g._dispatchLastEvent();
        if (g._points.length < 2) {
            g._clearCurData()
        } else {
            g._paths[g._paths.length - 1].remove();
            g._paths[g._paths.length - 1] = null;
            g._paths.length = g._paths.length - 1;
            var h = g._points[g._points.length - 1];
            if (h.disLabel) {
                h.disLabel.remove()
            }
            g._processLastOp()
        }
        a.hide();
        for (var f = 0,
        e = this.bindFunc.length; f < e; f++) {
            c.un(this.bindFunc[f].elem, this.bindFunc[f].type, this.bindFunc[f].func)
        }
        if (g._movingTimerId) {
            clearInterval(g._movingTimerId);
            g._movingTimerId = null
        }
        if (this._followTitle) {
            this._followTitle.hide()
        }
    };
    d.prototype._clearCurData = function() {
        for (var f = 0,
        e = this._points.length; f < e; f++) {
            if (this._points[f].disLabel) {
                this._points[f].disLabel.remove()
            }
        }
        for (var f = 0,
        e = this._paths.length; f < e; f++) {
            this._paths[f].remove()
        }
        for (var f = 0,
        e = this._dots.length; f < e; f++) {
            this._dots[f].remove()
        }
        this._initData()
    };
    d.prototype._initData = function() {
        this._points.length = 0;
        this._paths.length = 0;
        this._segDistance.length = 0;
        this._dots.length = 0
    };
    d.prototype._setSegDistance = function(g, f) {
        if (!g || !f) {
            return
        }
        var e = this._map.getDistance(g, f);
        this._segDistance.push(e);
        return e
    };
    d.prototype._getTotalDistance = function() {
        var g = 0;
        for (var f = 0,
        e = this._segDistance.length; f < e; f++) {
            g += this._segDistance[f]
        }
        return g
    };
    d.prototype._convertUnit = function(e, f) {
        f = f || "metric";
        if (this._units[f]) {
            return e * this._units[f].conv
        }
        return e
    };
    d.prototype._addSecPoint = function(g) {
        var f = this._opts.secIcon ? this._opts.secIcon: new BMap.Icon("http://api.map.baidu.com/images/mapctrls.png", new BMap.Size(11, 11), {
            imageOffset: new BMap.Size( - 26, -313)
        });
        var e = new BMap.Marker(g, {
            icon: f,
            clickable: false,
            baseZIndex: 3500000,
            zIndexFixed: true,
            enableMassClear: this._enableMassClear
        });
        this._map.addOverlay(e);
        this._dots.push(e)
    };
    d.prototype._formatDisStr = function(h) {
        var f = this._opts.unit;
        var g = this._units[f].u1;
        var e = this._convertUnit(h, f);
        if (e > this._units[f].incon) {
            e = e / this._units[f].incon;
            g = this._units[f].u2;
            e = e.toFixed(1)
        } else {
            e = e.toFixed(0)
        }
        return e + g
    };
    d.prototype._setCursor = function(f) {
        var e = /webkit/.test(navigator.userAgent.toLowerCase()) ? "url(" + this._opts.cursor + ") 3 6, crosshair": "url(" + this._opts.cursor + "), crosshair";
        a._setCursor(e)
    };
    d.prototype._getCursor = function() {
        return this._opts.cursor
    };
    d.prototype._formatSegLabel = function(e, f) {
        e.setStyle({
            border: "none",
            padding: "0"
        });
        e.setContent("<span style='" + this._styles.BMapLib_diso + "'><span style='" + this._styles.BMapLib_disi + "'>" + f + "</span></span>")
    };
    d.prototype._processLastOp = function() {
        var i = this;
        delete i._bind.x;
        delete i._bind.y;
        delete i._bind.initX;
        delete i._bind.initY;
        if (i._paths.length > i._points.length - 1) {
            var g = i._paths.length - 1;
            i._paths[g].remove();
            i._paths[g] = null;
            i._paths.length = g
        }
        var e = {};
        e.points = i._points.slice(0);
        e.paths = i._paths.slice(0);
        e.dots = i._dots.slice(0);
        e.segDis = i._segDistance.slice(0);
        var j = i._map.pointToPixel(e.points[e.points.length - 1]);
        var h = i._map.pointToPixel(e.points[e.points.length - 2]);
        var k = [0, 0];
        var f = [0, 0];
        if (j.y - h.y >= 0) {
            f = [ - 5, 11]
        } else {
            f = [ - 5, -35]
        }
        if (j.x - h.x >= 0) {
            k = [14, 0]
        } else {
            k = [ - 14, 0]
        }
        var n = e.points[e.points.length - 1];
        n.disLabel = new BMap.Label("", {
            offset: new BMap.Size( - 15, -40),
            enableMassClear: i._enableMassClear
        });
        n.disLabel.setStyles({
            color: "#333",
            borderColor: "#ff0103"
        });
        i._map.addOverlay(n.disLabel);
        n.disLabel.setOffset(new BMap.Size(f[0], f[1]));
        n.disLabel.setPosition(n);
        i._formatTitle(2, "", "", n.disLabel);
        var m = this._opts.closeIcon ? this._opts.closeIcon: new BMap.Icon("http://api.map.baidu.com/images/mapctrls.gif", new BMap.Size(12, 12), {
            imageOffset: new BMap.Size(0, -14)
        });
        e.closeBtn = new BMap.Marker(e.points[e.points.length - 1], {
            icon: m,
            offset: new BMap.Size(k[0], k[1]),
            baseZIndex: 3600000,
            enableMassClear: i._enableMassClear
        });
        //将多边形绑定到关闭按钮上
        var hh = this;
        e.closeBtn._polygon = hh.polygon;
        hh.polygon = undefined;
        hh._areaPoints = undefined;
        i._map.addOverlay(e.closeBtn);
        //绑定添加焦点事件
        e.closeBtn.setTitle("\u6e05\u9664\u672c\u6b21\u6d4b\u8ddd");
        e.closeBtn.addEventListener("click",
        function(r) {
        	//TODO
        	var polygon = r.target._polygon;
        	if(polygon.label!=undefined){
        		hh._map.removeOverlay(polygon.label);
        	}
        	hh._map.removeOverlay(polygon);
            r.target._polygon =undefined;

            for (var p = 0,
            o = e.points.length; p < o; p++) {
                e.points[p].disLabel.remove();
                e.points[p].disLabel = null
            }
            for (var p = 0,
            o = e.paths.length; p < o; p++) {
                e.paths[p].remove();
                e.paths[p] = null
            }
            for (var p = 0,
            o = e.dots.length; p < o; p++) {
                e.dots[p].remove();
                e.dots[p] = null
            }
            e.closeBtn.remove();
            e.closeBtn = null;
            b(r);
            var q = new c.lang.Event("onremovepolyline");
            i.dispatchEvent(q)
            //todo
        });
        i._initData()
    };
    d.prototype._formatTitle = function(g, l, e, i) {
        var h = i || this._followTitle;
        if (!h) {
            return
        }
        h.setStyle({
            lineHeight: "16px",
            zIndex: "85",
            padding: "3px 5px"
        });
        var n = this._startFollowText || "";
        var k = [];
        if (g == 1) {
            h.setOffset(0, 25);
            var m = this._opts.unit;
            var j = this._units[m].u1;
            var f = this._convertUnit(e, m);
            if (f > this._units[m].incon) {
                f = f / this._units[m].incon;
                j = this._units[m].u2;
                f = f.toFixed(1)
            } else {
                f = f.toFixed(0)
            }
            k.push("<span>\u603b\u957f\uff1a<span style='" + this._styles.BMapLib_disBoxDis + "'>" + f + "</span>" + j + "</span><br />");
            k.push("<span style='color:#7a7a7a'>" + l + "</span>")
        } else {
            if (g == 2) {
                var m = this._opts.unit;
                var j = this._units[m].u1;
                var f = this._convertUnit(this._getTotalDistance(), m);
                if (f > this._units[m].incon) {
                    f = f / this._units[m].incon;
                    j = this._units[m].u2;
                    f = f.toFixed(1)
                } else {
                    f = f.toFixed(0)
                }
                k.push("\u603b\u957f\uff1a<span style='" + this._styles.BMapLib_disBoxDis + "'>" + f + "</span>" + j)
            } else {
                h.setOffset(0, 25);
                k.push(n)
            }
        }
        h.setContent(k.join(""))
    };
    d.prototype._updateInstDis = function(g, e) {
        var f = this._opts.unit;
        var i = this._units[f].u1;
        if (e > this._units[f].incon) {
            e = e / this._units[f].incon;
            i = this._units[f].u2;
            e = e.toFixed(1)
        } else {
            e = e.toFixed(0)
        }
        if (g) {
            var h = [];
            h.push("<span>\u603b\u957f\uff1a<span style='" + this._styles.BMapLib_disBoxDis + "'>" + e + "</span>" + i + "</span><br />");
            h.push("<span style='color:#7a7a7a'>" + this._opts.followText + "</span>");
            g.setContent(h.join(""))
        }
    };
    d.prototype._hideCurrent = function() {
        if (!this._isOpen) {
            return
        }
        if (this._paths.length > 0) {
            var e = this._paths[this._paths.length - 1];
            e.hide()
        }
        this._followTitle && this._followTitle.hide()
    };
    d.prototype._isPointValid = function(h) {
        if (!h) {
            return false
        }
        var f = this._map.getBounds();
        var e = f.getSouthWest(),
        g = f.getNorthEast();
        if (h.lng < e.lng || h.lng > g.lng || h.lat < e.lat || h.lat > g.lat) {
            return false
        }
        return true
    };
    var a = {
        _map: null,
        _html: "<div style='background:transparent url(http://api.map.baidu.com/images/blank.gif);position:absolute;left:0;top:0;width:100%;height:100%;z-index:1000' unselectable='on'></div>",
        _maskElement: null,
        _cursor: "default",
        _inUse: false,
        show: function(e) {
            if (!this._map) {
                this._map = e
            }
            this._inUse = true;
            if (!this._maskElement) {
                this._createMask(e)
            }
            this._maskElement.style.display = "block"
        },
        _createMask: function(g) {
            this._map = g;
            if (!this._map) {
                return
            }
            c.insertHTML(this._map.getContainer(), "beforeEnd", this._html);
            var f = this._maskElement = this._map.getContainer().lastChild;
            var e = function(h) {
                b(h);
                return c.preventDefault(h)
            };
            c.on(f, "mouseup",
            function(h) {
                if (h.button == 2) {
                    e(h)
                }
            });
            c.on(f, "contextmenu", e);
            f.style.display = "none"
        },
        getDrawPoint: function(h, j) {
            h = window.event || h;
            var f = h.layerX || h.offsetX || 0;
            var i = h.layerY || h.offsetY || 0;
            var g = h.target || h.srcElement;
            if (g != a.getDom(this._map) && j == true) {
                while (g && g != this._map.getContainer()) {
                    if (! (g.clientWidth == 0 && g.clientHeight == 0 && g.offsetParent && g.offsetParent.nodeName.toLowerCase() == "td")) {
                        f += g.offsetLeft;
                        i += g.offsetTop
                    }
                    g = g.offsetParent
                }
            }
            if (g != a.getDom(this._map) && g != this._map.getContainer()) {
                return
            }
            if (typeof f === "undefined" || typeof i === "undefined") {
                return
            }
            if (isNaN(f) || isNaN(i)) {
                return
            }
            return this._map.pixelToPoint(new BMap.Pixel(f, i))
        },
        hide: function() {
            if (!this._map) {
                return
            }
            this._inUse = false;
            if (this._maskElement) {
                this._maskElement.style.display = "none"
            }
        },
        getDom: function(e) {
            if (!this._maskElement) {
                this._createMask(e)
            }
            return this._maskElement
        },
        _setCursor: function(e) {
            this._cursor = e || "default";
            if (this._maskElement) {
                this._maskElement.style.cursor = this._cursor
            }
        }
    };
    function b(f) {
        var f = window.event || f;
        f.stopPropagation ? f.stopPropagation() : f.cancelBubble = true
    }
})();

var _polygonStyleOptions = {    
        strokeColor:"blue",    //边线颜色。    
        fillColor:"#FFCCFF",      //填充颜色。当参数为空时，圆形将没有填充效果。    
        strokeWeight: 0.00001,       //边线的宽度，以像素为单位。    
        strokeOpacity: 0,    //边线透明度，取值范围0 - 1。    
        fillOpacity: 0.3,      //填充的透明度，取值范围0 - 1。    
        strokeStyle: 'solid' //边线的样式，solid或dashed。    
}   
var _LabelOptions = {    
    color : "black",    
    fontSize : "16px",    
    fillColor:"red"      //填充颜色。当参数为空时，圆形将没有填充效果。    
}   

//自定义测量面积工具
var createMeasureAreaTool =function(map){
	var myDis = new BMapLib.MeasureAreaTool(map);   //测距插件

	myDis.addEventListener("addpoint", function(e) {
		var _map = e.target._map;
		if(e.target._areaPoints == undefined){
            e.target._areaPoints = new Array();
		}
        e.target._areaPoints.push(e.point);
		if(e.target.polygon == undefined){
			var polygon = new BMap.Polygon(e.target._areaPoints,_polygonStyleOptions);
			myDis.polygon = polygon;
			_map.addOverlay(polygon);
		}else{
			var polygon = e.target.polygon;
			polygon.setPath(e.target._areaPoints);
			//计算多边形的面积
			var _area = 0;
			_area = BMapLib.GeoUtils.getPolygonArea(polygon);
			//保留两位小数
			_area = _area.toFixed(2);
			//获取多边形的中心
			var _paths = polygon.getPath();
			var point = getCenterPoint(_paths);
			//移除polygon之前的label
			if(polygon.label!=undefined){
				var l = polygon.label;
				_map.removeOverlay(l);
				polygon.label = undefined;
			}
			//往多边形添加标注
			var label = new BMap.Label("区域面积："+_area+"m2",_LabelOptions);
			polygon.label =label;
			label.setPosition(point);
			//往地图上添加标注
			_map.addOverlay(label);
		}
	}); 
	return myDis;
}
    



    
2.3  GeoUtils.js  这个是计算面积的api,这个也是必须的，代码如下：
    


    /**  
* @fileoverview GeoUtils类提供若干几何算法，用来帮助用户判断点与矩形、  
* 圆形、多边形线、多边形面的关系,并提供计算折线长度和多边形的面积的公式。   
* 主入口类是<a href="symbols/BMapLib.GeoUtils.html">GeoUtils</a>，  
* 基于Baidu Map API 1.2。  
*  
* @author Baidu Map Api Group   
* @version 1.2  
*/    
    
//BMapLib.GeoUtils.degreeToRad(Number)    
//将度转化为弧度    
    
//BMapLib.GeoUtils.getDistance(Point, Point)    
//计算两点之间的距离,两点坐标必须为经纬度    
    
//BMapLib.GeoUtils.getPolygonArea(polygon)    
//计算多边形面或点数组构建图形的面积,注意：坐标类型只能是经纬度，且不适合计算自相交多边形的面积(封闭的面积)    
    
//BMapLib.GeoUtils.getPolylineDistance(polyline)    
//计算折线或者点数组的长度    
    
//BMapLib.GeoUtils.isPointInCircle(point, circle)    
//判断点是否在圆形内    
    
//BMapLib.GeoUtils.isPointInPolygon(point, polygon)    
//判断点是否多边形内    
    
//BMapLib.GeoUtils.isPointInRect(point, bounds)    
//判断点是否在矩形内    
    
//BMapLib.GeoUtils.isPointOnPolyline(point, polyline)    
//判断点是否在折线上    
    
//BMapLib.GeoUtils.radToDegree(Number)    
//将弧度转化为度    

 function getCenterPoint(path)
    {
        //var path = e.;//Array<Point> 返回多边型的点数组
        //var ret=parseFloat(num1)+parseFloat(num2);  
        var x = 0.0;
        var y = 0.0;
        for(var i=0;i<path.length;i++){
             x=x+ parseFloat(path[i].lng);
             y=y+ parseFloat(path[i].lat);
        }
        x=x/path.length;
        y=y/path.length;
        return new BMap.Point(x,y);
    }

    
/**   
* @namespace BMap的所有library类均放在BMapLib命名空间下  
*/    
var BMapLib = window.BMapLib = BMapLib || {};    
(function () {    
    
    /**  
    * 地球半径  
    */    
    var EARTHRADIUS = 6370996.81;    
    
    /**   
    * @exports GeoUtils as BMapLib.GeoUtils   
    */    
    var GeoUtils =    
    /**  
    * GeoUtils类，静态类，勿需实例化即可使用  
    * @class GeoUtils类的<b>入口</b>。  
    * 该类提供的都是静态方法，勿需实例化即可使用。       
    */    
     BMapLib.GeoUtils = function () {    
     }    
    
    /**  
    * 判断点是否在矩形内  
    * @param {Point} point 点对象  
    * @param {Bounds} bounds 矩形边界对象  
    * @returns {Boolean} 点在矩形内返回true,否则返回false  
    */    
    GeoUtils.isPointInRect = function (point, bounds) {    
        //检查类型是否正确    
        if (!(point instanceof BMap.Point) ||    
             !(bounds instanceof BMap.Bounds)) {    
            return false;    
        }    
        var sw = bounds.getSouthWest(); //西南脚点    
        var ne = bounds.getNorthEast(); //东北脚点    
        return (point.lng >= sw.lng && point.lng <= ne.lng && point.lat >= sw.lat && point.lat <= ne.lat);    
    }    
    
    /**  
    * 判断点是否在圆形内  
    * @param {Point} point 点对象  
    * @param {Circle} circle 圆形对象  
    * @returns {Boolean} 点在圆形内返回true,否则返回false  
    */    
    GeoUtils.isPointInCircle = function (point, circle) {    
        //检查类型是否正确    
        if (!(point instanceof BMap.Point) ||    
            !(circle instanceof BMap.Circle)) {    
            return false;    
        }    
    
        //point与圆心距离小于圆形半径，则点在圆内，否则在圆外    
        var c = circle.getCenter();    
        var r = circle.getRadius();    
    
        var dis = GeoUtils.getDistance(point, c);    
        if (dis <= r) {    
            return true;    
        } else {    
            return false;    
        }    
    }    
    
    /**  
    * 判断点是否在折线上  
    * @param {Point} point 点对象  
    * @param {Polyline} polyline 折线对象  
    * @returns {Boolean} 点在折线上返回true,否则返回false  
    */    
    GeoUtils.isPointOnPolyline = function (point, polyline) {    
        //检查类型    
        if (!(point instanceof BMap.Point) ||    
             !(polyline instanceof BMap.Polyline)) {    
            return false;    
        }    
    
        //首先判断点是否在线的外包矩形内，如果在，则进一步判断，否则返回false    
        var lineBounds = polyline.getBounds();    
        if (!this.isPointInRect(point, lineBounds)) {    
            return false;    
        }    
    
        //判断点是否在线段上，设点为Q，线段为P1P2 ，    
        //判断点Q在该线段上的依据是：( Q - P1 ) × ( P2 - P1 ) = 0，且 Q 在以 P1，P2为对角顶点的矩形内    
        var pts = polyline.getPath();    
        for (var i = 0; i < pts.length - 1; i++) {    
            var curPt = pts[i];    
            var nextPt = pts[i + 1];    
            //首先判断point是否在curPt和nextPt之间，即：此判断该点是否在该线段的外包矩形内    
            if (point.lng >= Math.min(curPt.lng, nextPt.lng) && point.lng <= Math.max(curPt.lng, nextPt.lng) &&    
                 point.lat >= Math.min(curPt.lat, nextPt.lat) && point.lat <= Math.max(curPt.lat, nextPt.lat)) {    
                //判断点是否在直线上公式    
                var precision = (curPt.lng - point.lng) * (nextPt.lat - point.lat) - (nextPt.lng - point.lng) * (curPt.lat - point.lat);    
                if (precision < 2e-10 && precision > -2e-10) {//实质判断是否接近0    
                    return true;    
                }    
            }    
        }    
        return false;    
    }    
    
    /**  
    * 判断点是否多边形内  
    * @param {Point} point 点对象  
    * @param {Polyline} polygon 多边形对象  
    * @returns {Boolean} 点在多边形内返回true,否则返回false  
    */    
    GeoUtils.isPointInPolygon = function (point, polygon) {    
        //检查类型    
        if (!(point instanceof BMap.Point) ||    
             !(polygon instanceof BMap.Polygon)) {    
            return false;    
        }    
    
        //首先判断点是否在多边形的外包矩形内，如果在，则进一步判断，否则返回false    
        var polygonBounds = polygon.getBounds();    
        if (!this.isPointInRect(point, polygonBounds)) {    
            return false;    
        }    
    
        var pts = polygon.getPath(); //获取多边形点    
    
        //下述代码来源：http://paulbourke.net/geometry/insidepoly/，进行了部分修改    
        //基本思想是利用射线法，计算射线与多边形各边的交点，如果是偶数，则点在多边形外，否则    
        //在多边形内。还会考虑一些特殊情况，如点在多边形顶点上，点在多边形边上等特殊情况。    
    
        var N = pts.length;    
        var boundOrVertex = true; //如果点位于多边形的顶点或边上，也算做点在多边形内，直接返回true    
        var intersectCount = 0; //cross points count of x     
        var precision = 2e-10; //浮点类型计算时候与0比较时候的容差    
        var p1, p2; //neighbour bound vertices    
        var p = point; //测试点    
    
        p1 = pts[0]; //left vertex            
        for (var i = 1; i <= N; ++i) {//check all rays                
            if (p.equals(p1)) {    
                return boundOrVertex; //p is an vertex    
            }    
    
            p2 = pts[i % N]; //right vertex                
            if (p.lat < Math.min(p1.lat, p2.lat) || p.lat > Math.max(p1.lat, p2.lat)) {//ray is outside of our interests                 
                p1 = p2;    
                continue; //next ray left point    
            }    
            if (p.lat > Math.min(p1.lat, p2.lat) && p.lat < Math.max(p1.lat, p2.lat)) {//ray is crossing over by the algorithm (common part of)    
                if (p.lng <= Math.max(p1.lng, p2.lng)) {//x is before of ray                        
                    if (p1.lat == p2.lat && p.lng >= Math.min(p1.lng, p2.lng)) {//overlies on a horizontal ray    
                        return boundOrVertex;    
                    }    
    
                    if (p1.lng == p2.lng) {//ray is vertical             
    
    
                        if (p1.lng == p.lng) {//overlies on a vertical ray    
                            return boundOrVertex;    
                        } else {//before ray    
                            ++intersectCount;    
                        }    
                    } else {//cross point on the left side               
    
    
                        var xinters = (p.lat - p1.lat) * (p2.lng - p1.lng) / (p2.lat - p1.lat) + p1.lng; //cross point of lng                  
    
    
                        if (Math.abs(p.lng - xinters) < precision) {//overlies on a ray    
                            return boundOrVertex;    
                        }    
    
                        if (p.lng < xinters) {//before ray    
                            ++intersectCount;    
                        }    
                    }    
                }    
            } else {//special case when ray is crossing through the vertex                    
                if (p.lat == p2.lat && p.lng <= p2.lng) {//p crossing over p2                        
                    var p3 = pts[(i + 1) % N]; //next vertex             
    
    
                    if (p.lat >= Math.min(p1.lat, p3.lat) && p.lat <= Math.max(p1.lat, p3.lat)) {//p.lat lies between p1.lat & p3.lat    
                        ++intersectCount;    
                    } else {    
                        intersectCount += 2;    
                    }    
                }    
            }    
            p1 = p2; //next ray left point    
        }    
    
        if (intersectCount % 2 == 0) {//偶数在多边形外    
            return false;    
        } else { //奇数在多边形内    
            return true;    
        }    
    }    
    
    /**  
    * 将度转化为弧度  
    * @param {degree} Number 度       
    * @returns {Number} 弧度  
    */    
    GeoUtils.degreeToRad = function (degree) {    
        return Math.PI * degree / 180;    
    }    
    
    /**  
    * 将弧度转化为度  
    * @param {radian} Number 弧度       
    * @returns {Number} 度  
    */    
    GeoUtils.radToDegree = function (rad) {    
        return (180 * rad) / Math.PI;    
    }    
    
    /**  
    * 将v值限定在a,b之间，纬度使用  
    */    
    function _getRange(v, a, b) {    
        if (a != null) {    
            v = Math.max(v, a);    
        }    
        if (b != null) {    
            v = Math.min(v, b);    
        }    
        return v;    
    }    
    
    /**  
    * 将v值限定在a,b之间，经度使用  
    */    
    function _getLoop(v, a, b) {    
        while (v > b) {    
            v -= b - a    
        }    
        while (v < a) {    
            v += b - a    
        }    
        return v;    
    }    
    
    /**  
    * 计算两点之间的距离,两点坐标必须为经纬度  
    * @param {point1} Point 点对象  
    * @param {point2} Point 点对象  
    * @returns {Number} 两点之间距离，单位为米  
    */    
    GeoUtils.getDistance = function (point1, point2) {    
        //判断类型    
        if (!(point1 instanceof BMap.Point) ||    
             !(point2 instanceof BMap.Point)) {    
            return 0;    
        }    
    
        point1.lng = _getLoop(point1.lng, -180, 180);    
        point1.lat = _getRange(point1.lat, -74, 74);    
        point2.lng = _getLoop(point2.lng, -180, 180);    
        point2.lat = _getRange(point2.lat, -74, 74);    
    
        var x1, x2, y1, y2;    
        x1 = GeoUtils.degreeToRad(point1.lng);    
        y1 = GeoUtils.degreeToRad(point1.lat);    
        x2 = GeoUtils.degreeToRad(point2.lng);    
        y2 = GeoUtils.degreeToRad(point2.lat);    
    
        return EARTHRADIUS * Math.acos((Math.sin(y1) * Math.sin(y2) + Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1)));    
    }    
    
    /**  
    * 计算折线或者点数组的长度  
    * @param {Polyline|Array<Point>} polyline 折线对象或者点数组  
    * @returns {Number} 折线或点数组对应的长度  
    */    
    GeoUtils.getPolylineDistance = function (polyline) {    
        //检查类型    
        if (polyline instanceof BMap.Polyline ||    
             polyline instanceof Array) {    
            //将polyline统一为数组    
            var pts;    
            if (polyline instanceof BMap.Polyline) {    
                pts = polyline.getPath();    
            } else {    
                pts = polyline;    
            }    
    
            if (pts.length < 2) {//小于2个点，返回0    
                return 0;    
            }    
    
            //遍历所有线段将其相加，计算整条线段的长度    
            var totalDis = 0;    
            for (var i = 0; i < pts.length - 1; i++) {    
                var curPt = pts[i];    
                var nextPt = pts[i + 1]    
                var dis = GeoUtils.getDistance(curPt, nextPt);    
                totalDis += dis;    
            }    
    
            return totalDis;    
    
        } else {    
            return 0;    
        }    
    }    
    
    /**  
    * 计算多边形面或点数组构建图形的面积,注意：坐标类型只能是经纬  
  
    度，且不适合计算自相交多边形的面积  
    * @param {Polygon|Array<Point>} polygon 多边形面对象或者点数  
  
    组  
    * @returns {Number} 多边形面或点数组构成图形的面积  
    */    
    GeoUtils.getPolygonArea = function (polygon) {    
        //检查类型    
        if (!(polygon instanceof BMap.Polygon) &&    
             !(polygon instanceof Array)) {    
            return 0;    
        }    
        var pts;    
        if (polygon instanceof BMap.Polygon) {    
            pts = polygon.getPath();    
        } else {    
            pts = polygon;    
        }    
    
        if (pts.length < 3) {//小于3个顶点，不能构建面    
            return 0;    
        }    
    
        var totalArea = 0; //初始化总面积    
        var LowX = 0.0;    
        var LowY = 0.0;    
        var MiddleX = 0.0;    
        var MiddleY = 0.0;    
        var HighX = 0.0;    
        var HighY = 0.0;    
        var AM = 0.0;    
        var BM = 0.0;    
        var CM = 0.0;    
        var AL = 0.0;    
        var BL = 0.0;    
        var CL = 0.0;    
        var AH = 0.0;    
        var BH = 0.0;    
        var CH = 0.0;    
        var CoefficientL = 0.0;    
        var CoefficientH = 0.0;    
        var ALtangent = 0.0;    
        var BLtangent = 0.0;    
        var CLtangent = 0.0;    
        var AHtangent = 0.0;    
        var BHtangent = 0.0;    
        var CHtangent = 0.0;    
        var ANormalLine = 0.0;    
        var BNormalLine = 0.0;    
        var CNormalLine = 0.0;    
        var OrientationValue = 0.0;    
        var AngleCos = 0.0;    
        var Sum1 = 0.0;    
        var Sum2 = 0.0;    
        var Count2 = 0;    
        var Count1 = 0;    
        var Sum = 0.0;    
        var Radius = EARTHRADIUS; //6378137.0,WGS84椭球半径     
        var Count = pts.length;    
        for (var i = 0; i < Count; i++) {    
            if (i == 0) {    
                LowX = pts[Count - 1].lng * Math.PI / 180;    
                LowY = pts[Count - 1].lat * Math.PI / 180;    
                MiddleX = pts[0].lng * Math.PI / 180;    
                MiddleY = pts[0].lat * Math.PI / 180;    
                HighX = pts[1].lng * Math.PI / 180;    
                HighY = pts[1].lat * Math.PI / 180;    
            }    
            else if (i == Count - 1) {    
                LowX = pts[Count - 2].lng * Math.PI / 180;    
                LowY = pts[Count - 2].lat * Math.PI / 180;    
                MiddleX = pts[Count - 1].lng * Math.PI / 180;    
                MiddleY = pts[Count - 1].lat * Math.PI / 180;    
                HighX = pts[0].lng * Math.PI / 180;    
                HighY = pts[0].lat * Math.PI / 180;    
            }    
            else {    
                LowX = pts[i - 1].lng * Math.PI / 180;    
                LowY = pts[i - 1].lat * Math.PI / 180;    
                MiddleX = pts[i].lng * Math.PI / 180;    
                MiddleY = pts[i].lat * Math.PI / 180;    
                HighX = pts[i + 1].lng * Math.PI / 180;    
                HighY = pts[i + 1].lat * Math.PI / 180;    
            }    
            AM = Math.cos(MiddleY) * Math.cos(MiddleX);    
            BM = Math.cos(MiddleY) * Math.sin(MiddleX);    
            CM = Math.sin(MiddleY);    
            AL = Math.cos(LowY) * Math.cos(LowX);    
            BL = Math.cos(LowY) * Math.sin(LowX);    
            CL = Math.sin(LowY);    
            AH = Math.cos(HighY) * Math.cos(HighX);    
            BH = Math.cos(HighY) * Math.sin(HighX);    
            CH = Math.sin(HighY);    
            CoefficientL = (AM * AM + BM * BM + CM * CM) / (AM * AL + BM * BL + CM * CL);    
            CoefficientH = (AM * AM + BM * BM + CM * CM) / (AM * AH + BM * BH + CM * CH);    
            ALtangent = CoefficientL * AL - AM;    
            BLtangent = CoefficientL * BL - BM;    
            CLtangent = CoefficientL * CL - CM;    
            AHtangent = CoefficientH * AH - AM;    
            BHtangent = CoefficientH * BH - BM;    
            CHtangent = CoefficientH * CH - CM;    
            AngleCos = (AHtangent * ALtangent + BHtangent * BLtangent + CHtangent * CLtangent) / (Math.sqrt(AHtangent * AHtangent + BHtangent * BHtangent + CHtangent * CHtangent) * Math.sqrt(ALtangent * ALtangent + BLtangent * BLtangent + CLtangent * CLtangent));    
            AngleCos = Math.acos(AngleCos);    
            ANormalLine = BHtangent * CLtangent - CHtangent * BLtangent;    
            BNormalLine = 0 - (AHtangent * CLtangent - CHtangent * ALtangent);    
            CNormalLine = AHtangent * BLtangent - BHtangent * ALtangent;    
            if (AM != 0)    
                OrientationValue = ANormalLine / AM;    
            else if (BM != 0)    
                OrientationValue = BNormalLine / BM;    
            else    
                OrientationValue = CNormalLine / CM;    
            if (OrientationValue > 0) {    
                Sum1 += AngleCos;    
                Count1++;    
            }    
            else {    
                Sum2 += AngleCos;    
                Count2++;    
            }    
        }    
        var tempSum1, tempSum2;    
        tempSum1 = Sum1 + (2 * Math.PI * Count2 - Sum2);    
        tempSum2 = (2 * Math.PI * Count1 - Sum1) + Sum2;    
        if (Sum1 > Sum2) {    
            if ((tempSum1 - (Count - 2) * Math.PI) < 1)    
                Sum = tempSum1;    
            else    
                Sum = tempSum2;    
        }    
        else {    
            if ((tempSum2 - (Count - 2) * Math.PI) < 1)    
                Sum = tempSum2;    
            else    
                Sum = tempSum1;    
        }    
        totalArea = (Sum - (Count - 2) * Math.PI) * Radius * Radius;    
        return totalArea; //返回总面积    
    }    
    
})(); //闭包结束    
    


    GeoUtilsAPI文档地址：http://api.map.baidu.com/library/GeoUtils/1.2/docs/symbols/BMapLib.GeoUtils.html
    


     
    


    好了，现在可以测试效果了，浏览器打开measureAreaTool_baidu.html这个页面，点击面积测量就可以看到效果。
    


    代码下载地址：https://download.csdn.net/download/hgq0916/12403463
    


    本人水平有限，代码有不足之处还请大家见谅，欢迎大家提建议。本人目前主要方向是Java，如果有兴趣，可以一起交流，
    


    Java成长交流学习群：184998348
    


     
    


     
    


     
    


     
    


     
    收起
    展开全文
    js 百度地图

  • 使用java + OpenCV破解破解顶象面积验证码

     万次阅读 2020-12-04 17:22:36
    我们又来破解验证码啦，今天上场的是–顶象面积验证码 根据场景来看，我们需要根据图片中分隔好的区域找到面积最大的一块来点击它。 那么我们把它拆分成以下几个步骤： 检测出图中标记的点 将检测出来的点连成线 ... 
    前言
    
在这里插入图片描述
    

    我们又来破解验证码啦，今天上场的是–顶象面积验证码
    
在这里插入图片描述
    

    根据场景来看，我们需要根据图片中分隔好的区域找到面积最大的一块来点击它。
    

    

    那么我们把它拆分成以下几个步骤：
    

      

    1. 检测出图中标记的点
      2. 

    2. 将检测出来的点连成线
      3. 

    3. 根据线分割出的区域计算各区域面积，并得到最大面积
      4. 

    4. 在该区域面积中选取一个坐标点作为结果
      5. 

    

    

    一、检测出图中标记的点
    

    第一个问题，怎么检测出图片中被标记出来的点?
    

    这里使用哈里斯角点检测，这里采用OpenCV中的cornerHarris()来实现。
    
参考下面两篇文章，感兴趣的话可以阅读一下：
    


    效果如下图
    
在这里插入图片描述
    

    	/**
	 * 哈里斯角点检测
	 * @param img	原图地址
	 * @param img2	新图地址
	 */
	public void getHarris(String img,String img2) {
		System.load(dllPath);
		File bFile = new File(img);
		try {
			Mat mat = Imgcodecs.imread(bFile.getPath());
			// 转灰度图像
			Mat gray = new Mat();
			Imgproc.cvtColor(mat, gray, Imgproc.COLOR_BGR2GRAY);
			// 角点发现
			Mat harris = new Mat();
			Imgproc.cornerHarris(gray, harris, 2, 3, 0.04);
			// 绘制角点
			float[] floats = new float[harris.cols()];
			for (int i = 0; i < harris.rows(); i++) {
				harris.get(i, 0, floats);
				for (int j = 0; j < floats.length; j++) {
					if (floats[j] > 0.0001) {// 越接近于角点数值越大
						System.out.println(floats[j]);
						Imgproc.circle(mat, new Point(j, i), 1, new Scalar(0, 255, 0));
					}
				}
			}
			Imgcodecs.imwrite(img2, mat);
		} catch (Throwable e) {
			e.printStackTrace();
		}
	}

    

    那标记点的检测完成了。
    

    二、将检测出来的点连成线
    

    如何连线就比较简单了，这里我们只需要在绘制角点的时候将浸染范围设置大一点就好了，这里设置为5即可。
    

    Imgproc.circle(mat, new Point(j, i), 5, new Scalar(0, 255, 0));

    

    下面是效果图
    
在这里插入图片描述
    
连线做到这样的效果就可以了。
    

    三、根据线分割出的区域计算各区域面积，并得到最大面积
    

    这里根据深度优先搜索的原理，划分不同区域最终选出最大的一块面积；
    

    深度优先搜索大家不会的话就可以参考这篇文章：
    
基本算法——深度优先搜索（DFS）和广度优先搜索（BFS）
    

    这里直接搜索了所有区域。将占像素量最多的区域显示了出来，效果如图：
    
在这里插入图片描述
    

    	/**根据线分割出的区域计算各区域面积，并得到最大面积
	 * @param oldimg 原图
	 * @param newimg 绘制角点后的图
	 */
	 */
	public void getMatrix(String oldimg,String newimg) {
		File ofile = new File(oldimg);
		File nfile = new File(newimg);
		try {
			BufferedImage oimage = ImageIO.read(ofile);
			BufferedImage nimage = ImageIO.read(nfile);
			int matrix[][] = new int[nimage.getWidth()][nimage.getHeight()];
			int rank = 0;
			int maxRank = 0;
			int count = 0;
			int maxCount = 0;
			//将检测并高亮部分置1，其余部分置0，得到一个代替图的二维数组
			for (int w = 0; w < nimage.getWidth(); w++) {
				for (int h = 0; h < nimage.getHeight(); h++) {
					int[] bgRgb = new int[3];
					bgRgb[0] = (nimage.getRGB(w, h) & 0xff0000) >> 16;
					bgRgb[1] = (nimage.getRGB(w, h) & 0xff00) >> 8;
					bgRgb[2] = (nimage.getRGB(w, h) & 0xff);
					if (!(bgRgb[0] <= 70 && bgRgb[1] >= 180 && bgRgb[2] <= 70)) {
						matrix[w][h] = 0;
					} else {
						matrix[w][h] = -1;
					}
				}
			}
			//深度优先搜索找出最大区域
			while (true) {
				int n = 0;
				for (int i = 0; i < matrix.length; i++) {
					for (int j = 0; j < matrix[0].length; j++) {
						if (matrix[i][j] == 0) {
							n++;
							rank++;
							count = dfs(matrix, rank);
							if (count > maxCount) {
								maxCount = count;
								maxRank = rank;
							}
						}
					}
				}
				if (n == 0)
					break;
			}
			//改变最大区域颜色
			for (int j = 0; j < matrix[0].length; j++) {
				for (int i = 0; i < matrix.length; i++) {
					if (matrix[i][j] == maxRank){
						nimage.setRGB(i, j, new Color(0, 0, 255).getRGB());
					}
				}
			}
			ImageIO.write(image, "png", new File(img));
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
	/**
	 * 深度优先搜索
	 * @param matrix 图信息数组
	 * @param n 标记数
	 * @return
	 */
	public int dfs(int matrix[][], int rank) {
		int count = 0;
		int w = -1;
		int h = -1;
		for (int i = 0; i < matrix.length; i++) {
			for (int j = 0; j < matrix[0].length; j++) {
				if (matrix[i][j] == 0) {
					w = i;
					h = j;
					break;
				}
			}
			if (w != -1) {
				break;
			}
		}
		Stack<JSONObject> stack = new Stack<JSONObject>();
		while (matrix[w][h] == 0 || h == stack.peek().getIntValue("h") && w == stack.peek().getIntValue("w")) {
			JSONObject json = new JSONObject();
			json.put("w", w);
			json.put("h", h);
			stack.push(json);
			matrix[w][h] = rank;
			count++;
			if (h + 1 < matrix[0].length) {
				if (matrix[w][h + 1] == 0) {
					h = h + 1;
					continue;
				}
			}
			if (w + 1 < matrix.length) {
				if (matrix[w + 1][h] == 0) {
					w = w + 1;
					continue;
				}
			}
			if (h - 1 >= 0) {
				if (matrix[w][h - 1] == 0) {
					h = h - 1;
					continue;
				}
			}
			if (w - 1 >= 0) {
				if (matrix[w - 1][h] == 0) {
					w = w - 1;
					continue;
				}
			}
			stack.pop();
			if (!stack.empty()) {
				if (h == stack.peek().getIntValue("h") && w == stack.peek().getIntValue("w")) {
					stack.pop();
				}
			}
			if (!stack.empty()) {
				w = stack.peek().getIntValue("w");
				h = stack.peek().getIntValue("h");
			} else {
				break;
			}
		}
		return count;
	}

    

    四、 在该区域面积中选取一个坐标点作为结果
    

    这里我们都已经找到面积最大区域了，就随意取一个点就好了
    

    将上面代码中的
    

    //改变最大区域颜色
for (int j = 0; j < matrix[0].length; j++) {
	for (int i = 0; i < matrix.length; i++) {
		if (matrix[i][j] == maxRank){
			nimage.setRGB(i, j, new Color(0, 0, 255).getRGB());
		}
	}
}

    

    改为下面的代码即可
    

    //标记选取到的点
boolean flag = false;
for (int j = 0; j < matrix[0].length; j++) {
	for (int i = 0; i < matrix.length; i++) {
		if (matrix[i][j] == maxRank) {
			oimage.setRGB(i, j, new Color(255, 0, 0).getRGB());
			System.out.println("w=" + i + "|h=" + j);
			flag = true;
			break;
		}
	}
	if (flag) {
		break;
	}
}

    

    结果展示：
    

    在这里插入图片描述
    
本文思路参考：https://blog.csdn.net/aaronjny/article/details/110245896
    
在这里插入图片描述
    

    作者:香芋味的猫丶
    
戳这里→康康你手机号在过多少网站注册过！！！
    
友情推荐：新一代安全短信
    

    猜你喜欢：
    
《腾讯防水墙滑动拼图验证码》
    
《百度旋转图片验证码》
    
《网易易盾滑动拼图验证码》
    
《顶象区域面积点选验证码》
    
《顶象滑动拼图验证码》
    
《极验滑动拼图验证码》
    
《使用深度学习来破解 captcha 验证码》
    收起
    展开全文
    算法 计算机视觉 opencv

  • 任意多边形面积—有向面积

     万次阅读 2018-07-31 09:47:33
    给定多边形的顶点坐标（有序），让你来求这个多边形的面积，你会怎么做？ 我们知道，任意多边形都可以分割为N个三角形，所以，如果以这为突破点，那么我们第一步就是把给定的多边形，分割为数个三角形，分别求面积，... 
    给定多边形的顶点坐标（有序），让你来求这个多边形的面积，你会怎么做？
    
我们知道，任意多边形都可以分割为N个三角形，所以，如果以这为突破点，那么我们第一步就是把给定的多边形，分割为数个三角形，分别求面积，最后累加就可以了，把多边形分割为三角形的方式多种多样，在这里，我们按照如下图的方法分割：
    


    


    图1
    


     
    


    （点如果是顺时针给出，有向面积为负，逆时针给出，有向面积为正）
    


    对于图1而言，多边形的面积就是：
    
S(1->6)=S(1,2,3)+S(1,3,4)+S(1,4,5)+S(1,5,6)（对凸多边形同样适用）
    


    如果我们不以多边形的某一点为顶点来划分三角形而是以任意一点，如下图，这个方法也是成立的：S = S_OAB + S_OBC + S_OCD + S_ODE + S_OEA。计算的时候，当我们取O点为原点时，可以简化计算。      
    


    image
    


    当O点为原点时，根据向量的叉积计算公式，各个三角形的面积计算如下：
    


    设a(x1,y1),b(x2,y2)
以下均为向量：
oa(x1,y1),ob(x2,y2)
oa X ob由线性代数叉积知识得：
=x1y2-x2y1
    


     
    


    S_OAB = 0.5*(A_x*B_y - A_y*B_x)   【(A_x，A_y)为A点的坐标】
    


    S_OBC = 0.5*(B_x*C_y - B_y*C_x)
    


    S_OCD = 0.5*(C_x*D_y - C_y*D_x)
    


    S_ODE = 0.5*(D_x*E_y - D_y*E_x)
    


    S_OEA = 0.5*(E_x*A_y - E_y*A_x)
    


    点如果是顺时针给出，有向面积为负，逆时针给出，有向面积为正,OAB即为O>A>B,即OA向量XOB向量
    


    无需担心点点坐标为正还是负，正负只与点给出的顺序有关，最终结果取绝对值即可。
    


    题目：hdu2036     http://acm.hdu.edu.cn/showproblem.php?pid=2036
    


    //输入必须是将点按顺序输入，顺时还是逆时程序会处理的 
#include<cstdio>
using namespace std;
double ans;
int n;
struct Point{
    int x,y;
}a[1000000];
int read(){
    int ret=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-f;ch=getchar();}
    while(ch>='0'&&ch<='9') ret=ret*10+ch-'0',ch=getchar();
    return ret*f;
}
int main(){
    n=read();//共n个点 
    for(int i=1;i<=n;i++)
         cin>>a[i].x>>a[i].y; //a[i]=(Point){read(),read()};
    for(int i=2;i<=n;i++)            //取原点为辅助点
        ans+=(double)(a[i].x*a[i-1].y-a[i].y*a[i-1].x)/*记得求平行四边形面积公式吗*//2.0;
        //求三角形面积。全加起来就好了，因为...面积有方向（正负性），自己会消掉的 
    ans+=(double)(a[1].x*a[n].y-a[1].y*a[n].x)/2.0;//第1和第n个点单独处理 
    if(ans<0.0) ans=-ans;//顺时针与逆时针输入结果互为相反数 
    printf("%lf",ans);
    return 0;
} 

//起点为（0.0）时
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <cmath>
#define fre freopen("C:\\Users\\Dell\\Desktop\\in.txt", "r", stdin);
using namespace std;
struct area{
    double x;double y;
};
int main(){
    //fre;
    int t,n;
    double sum;
    struct area a[109];
    cin>>t;
    while(t--){
        sum=0.0;
        cin>>n;
        for(int i=0;i<n;i++)
            cin>>a[i].x>>a[i].y;
        for(int i=1;i<n-1;i++)
            sum+=(a[i].x*a[i+1].y-a[i+1].x*a[i].y);
        sum=fabs(sum/2.0);     //求double绝对值用fabs,float:fabsf,int:abs
        printf("%.6f\n",sum);

    }
    return 0;
}

    


     
    收起
    展开全文

  • python计算圆的面积

     万次阅读 2018-08-24 00:43:57
    - 能计算半径为2的圆的面积 - 保留10位小数 - 可以直接执行 #!/usr/bin/env python3 import math print("Area is:{:.10f}".format(math.pi*4)) 计算圆的面积要用到pi，所以我们引用模块math... 
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        python   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    21世纪世界国土面积排名
    
                                    
                                    
                                            万次阅读
                                    
                                2019-01-20 20:42:04
                            
    
                            
    
                                
    
                                    国土面积  1.巨型国家 --100万平方千米以上 -------------------以下国土面积单位为（/万平方千米）          排名  国家  面积（单位：万平方千米）  除争议后面积          1  俄罗斯  1712.4442  1709      2  ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    多边形面积的计算
    
                                    
                                    
                                            万次阅读
                                    
                                2017-12-21 18:02:01
                            
    
                            
    
                                
    
                                    多边形面积的计算一般是将其剖分为三角形，利用海伦公式计算每个三角形的面积，然后将所有三角形的面积加起来。但是，这种方法程序实现起来比较复杂，因为无法预知多边形的形状，需要判断多边形的“凸凹”，才能避免...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    芯片杂谈001：综合面积与PR后芯片面积
    
                                    
                                    
                                            千次阅读
                                    
                                2020-10-25 20:20:08
                            
    
                            
    
                                
    
                                    芯片杂谈001：综合面积与PR后芯片面积  1、Place&Routing后芯片面积与综合面积差异很大?  在完成Place&Routing后的芯片实际面积与综合面积差异很大，这是什么原因呢？  在综合时我们会得到模块的组合逻辑...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    数格子算面积的方法_方格法计算面积 [格子与面积]
    
                                    
                                    
                                            千次阅读
                                    
                                2020-12-23 13:02:14
                            
    
                            
    
                                
    
                                    例题：图1是某广告公司为某种商品设计的商标图案，若图中每个小正方形的面积都是l，则阴影部分的面积是( ) A　6　B　6.5　C　7　D　7.5 此题为某地中考试题，我们先不谈题目的解答，而来聊一聊这个有点古怪的图形。...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    C语言 | 求圆周长 面积 圆球表面积 体积
    
                                    
                                    
                                            千次阅读
                                    
                                2020-12-29 11:12:03
                            
    
                            
    
                                
    
                                    例47：C语言编程求圆周长、圆面积、圆球表面积、圆球体积、圆柱体积。 解题思路：就是简单的数学公式套用，圆周长公式=2πr，圆面积=πr²，圆球表面积=4πr²，圆球体积=4πR³ /3，圆柱体积=πr²h。 源代码演示：...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        c语言   
                                        程序设计   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    求凸包面积
    
                                    
                                    
                                            千次阅读
                                    
                                2020-11-12 17:08:14
                            
    
                            
    
                                
    
                                    求凸包面积（分治法）  求凸包面积的方式有很多，本次我所讲的是利用分支法来求解该题，其它就不在讲述~~(狗头)~~,大部分都了解分治法是讲大问题化成小问题求解，恰恰好这种求凸包面积很适合用分支法，个人觉得这样...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        算法   
                                        分治算法   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    OpenCV python 轮廓面积与凸包面积比
    
                                    
                                    
                                            千次阅读
                                    
                                2020-01-12 12:24:14
                            
    
                            
    
                                
    
                                    OpenCV python 轮廓面积与凸包面积比 处理图片:[hand.jpg]  import cv2   def get_contours(img):  """获取连通域   :param img: 输入图片  :return: 最大连通域  """  # 灰度化, 二值化, 连通域分析  img_gray = cv...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    地图测量面积工具app_面积测量精灵手机版下载
    
                                    
                                    
                                            千次阅读
                                    
                                2021-02-05 09:20:53
                            
    
                            
    
                                
    
                                    面积测量精灵语音版是一款可以在手机上测量各种土地面积的软件，软件的使用方法十分简单，在手机界面上框选出范围，软件就可以根据定位来算出准确的土地面积，超多功能可以体验，快来试试吧！面积测量精灵软件介绍...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    python代码计算矩形面积_Python面积计算器源代码
    
                                    
                                    
                                            千次阅读
                                    
                                2021-01-02 17:46:56
                            
    
                            
    
                                
    
                                    本程序通过一个while循环分两步计算图形面积，首先确认图形形状，然后根据不同的图形采用不同的面积公式进行计算，目前可支持矩形、正方形、三角形、梯形、圆形。感兴趣的朋友还可以添加其它图形面积计算，也可对...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    矩阵面积
    
                                    
                                    
                                            千次阅读
                                    
                                2017-05-18 14:29:45
                            
    
                            
    
                                
    
                                    矩阵面积      面试题（入门）    需求：  实现一个矩阵类Rectangle，包含如下的一些成员变量与函数：    两个共有的成员变量 width 和 height 分别代表宽度和高度。一个构造函数，接受2个参数 width 和 height ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        矩阵   
                                        面试题   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    球冠面积
    
                                    
                                    
                                            千次阅读
                                    
                                2017-08-08 12:44:11
                            
    
                            
    
                                
    
                                    忘记球冠面积公式 Scap=2πR⋅hS_{\rm cap}=2\pi R\cdot h 中学教材里面是怎么推导的了。于是自己推了一下：  用到了定积分。图上 θ\theta 从 0 到 θmax\theta_{\rm max}，对面积微元积分每个微元是， 横截的圆周 ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Revit开发 - 面积边界及面积（Area & AreaBoundaryLine）
    
                                    
                                    
                                            千次阅读
                                    
                                2019-03-26 09:20:09
                            
    
                            
    
                                
    
                                    本文演示创建面积边界及面积。    using Autodesk.Revit.Attributes; using Autodesk.Revit.DB; using Autodesk.Revit.UI;  namespace RevitAddin4 {  [TransactionAttribute(TransactionMode.Manual)]  public ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    计算多边形面积
    
                                    
                                    
                                            千次阅读
                                    
                                2019-08-11 02:52:06
                            
    
                            
    
                                
    
                                    对于规则多边形，矩形、梯形、平行四边形、三角形（根据三边长度，利用公式计算），可以通过公式计算其面积，而对于一般意义的多边形（单一多边形、不包含“洞”），怎么计算面积呢，先想到是分割为三角形，但是程序...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        C#   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    C#计算圆的周长和面积、梯形的面积、三角形的面积
    
                                    
                                    
                                            千次阅读
                                    
                                2019-08-22 22:57:46
                            
    
                            
    
                                
    
                                    圆的周长和面积： static void Main(string[] args)  {  Console.WriteLine("请输入圆的半径：");  double r = Convert.ToDouble(Console.ReadLine());  double per = 2 * r * 3.14;  ...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        c#   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    01矩阵最大正方形面积、01矩阵最大矩形面积、直方图最大矩形面积
    
                                    
                                    
                                            千次阅读
                                    
                                2019-05-07 15:27:29
                            
    
                            
    
                                
    
                                    01矩阵最大正方形面积 题意：给定一个矩阵，其中的元素为0或者1，要求找出其中元素全为1的面积最大的正方形。 题解：动态规划：对每个元素，把以其为右下角，元素全为1的正方形的最长边长记录下来。如果以元素a(i, j...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    如何在arcgis中计算面数据的投影面积和椭球面积
    
                                    
                                2021-01-24 21:32:57
                            
    
                            
    
                                
    
                                    如何在arcgis中计算面数据的投影面积和椭球面积  参考资料：  这一个公开课介绍的非常好，链接：https://www.bilibili.com/video/BV1gJ411M7cX?zw    计算面数据的投影面积   投影面积也可以叫做平面面积   如果面...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    arcgis之图斑椭球面积及净面积计算工具
    
                                    
                                    
                                            千次阅读
                                    
                                2020-03-25 20:03:21
                            
    
                            
    
                                
    
                                    arcgis图斑椭球面积及净面积计算通用工具，软件计算速度快，计算结果准确，导出汇总分类面积表，省去人工繁琐计算。 运行环境:arcgis10.2；arcgis10.2.1；arcgis10.2.2；arcgis10.3；arcgis10.3.1；arcgis10.4；...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    高德地图面积测量小工具
    
                                    
                                    
                                            万次阅读
                                    
                                2018-09-26 12:11:49
                            
    
                            
    
                                
    
                                    由于项目的需要，需要用到高德地图的测量面积功能，其实高德地图官方已经提供了测量面积的工具，但是感觉有点不太方便，于是在原来的测量面积工具的基础上进行一点补充，由于时间的原因，写的比较粗糙，其实有很多...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        高德地图   
                                        工具   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    面积等效原理
    
                                    
                                    
                                            千次阅读
                                    
                                2020-08-05 22:18:27
                            
    
                            
    
                                
    
                                      面积等效原理：   冲量相等而形状不同的窄脉冲加在具有惯性的环节上时，其效果基本相同。冲量即指窄脉冲的面积。这里所说的效果基本相同，是指环节的输出响应波形基本相同。   目前能找到的出处：《电力电子...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        电力电子技术   
                                        一阶惯性环节   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    python输入圆的半径输出圆的面积_python如何求圆的面积
    
                                    
                                    
                                            千次阅读
                                    
                                2021-02-04 15:42:18
                            
    
                            
    
                                
    
                                    首先我们要知道圆的面积计算公式：S = πr²，公式中S为所求圆的面积，π为圆周率，r为圆的半径。示例： # 定义一个方法来计算圆的面积def findArea(r):PI = 3.142return PI * (r*r);# 调用方法print("圆的面积为 %....
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Java实现 蓝桥杯VIP 算法提高 3-3求圆面积表面积体积
    
                                    
                                    
                                            万次阅读
                                            多人点赞
                                    
                                2019-06-21 22:42:21
                            
    
                            
    
                                
    
                                    算法提高 3-3求圆面积表面积体积  时间限制：1.0s 内存限制：256.0MB  问题描述  　接受用户输⼊的数值，输出以该值为半径的(1)圆面积，(2)球体表面积，(3)球体体积。pi 取值3.1415926536 ，结果保留10位小数，每一...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Java   
                                        蓝桥杯VIP   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    c语言 求圆周长 圆面积 圆球表面积 圆球体积 圆柱体积
    
                                    
                                    
                                            千次阅读
                                    
                                2019-04-29 15:29:11
                            
    
                            
    
                                
    
                                    c语言 求圆周长 圆面积 圆球表面积 圆球体积 圆柱体积
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Python计算圆的周长面积和球的表面积和体积
    
                                    
                                    
                                            万次阅读
                                    
                                2018-12-21 12:46:16
                            
    
                            
    
                                
    
                                    Python计算圆的周长面积和球的表面积和体积 import math r=float(input("请输入半径：")) circumference=2*math.pi*r area=math.pi*r*r sarea=4*math.pi*r*r volume=4/3*math.pi*r**3 print ( "圆的...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    
                                
    
                                    
                                        Python   
                                        数学计算   
                                
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    Python面积积分
    
                                    
                                    
                                            千次阅读
                                    
                                2017-09-10 18:49:26
                            
    
                            
    
                                
    
                                    Python面积积分
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                        
  • 
                            
    
                                
                                    
    所有面积公式
    
                                    
                                    
                                            千次阅读
                                    
                                2017-12-01 15:31:57
                            
    
                            
    
                                
    
                                    长方形：S=ab{长方形面积=长×宽}  正方形：S=a^2{正方形面积=边长×边长}  平行四边形：S=ab{平行四边形面积=底×高}  三角形：S=ab÷2{三角形面积=底×高÷2}  梯形：S=（a+b）×h÷2{梯形面积=（上底+下底）×高...
                                
    
                                
    
                                    
    
                                        
    
                                    
    
                                    
    收起 
    
                                
    
                            
    

                        
    • 
                

            


            

                

                

                    
                    
空空如也

                

            


            

                

                

                    
                    
空空如也

                

            


            

                


 

 
 
         

            
                     


                    
                        1 
                    
                    
                        2 
                    
                    
                        3 
                    
                    
                        4 
                    
                    
                        5 
                    
                        ... 
                    
                        20 
                    

                    
            
        

   

                

                

            


        

    

    

        

            

                收藏数
                    84,002
            

            

                精华内容
                    33,600
            

        

        

            
热门标签

            
        


        


        

            关键字：
面积