精华内容
下载资源
问答
  • 面积

    千次阅读 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

     

     

     

     

     

    展开全文
  • 我们又来破解验证码啦,今天上场的是–顶象面积验证码 根据场景来看,我们需要根据图片中分隔好的区域找到面积最大的一块来点击它。 那么我们把它拆分成以下几个步骤: 检测出图中标记的点 将检测出来的点连成线 ...

    前言
    在这里插入图片描述

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

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

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

    1. 检测出图中标记的点
    2. 将检测出来的点连成线
    3. 根据线分割出的区域计算各区域面积,并得到最大面积
    4. 在该区域面积中选取一个坐标点作为结果

    一、检测出图中标记的点

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

    这里使用哈里斯角点检测,这里采用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 验证码》

    展开全文
  • 任意多边形面积—有向面积

    万次阅读 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...
  • 21世纪世界国土面积排名

    万次阅读 2019-01-20 20:42:04
    国土面积 1.巨型国家 --100万平方千米以上 -------------------以下国土面积单位为(/万平方千米) 排名 国家 面积(单位:万平方千米) 除争议后面积 1 俄罗斯 1712.4442 1709 2 ...
  • 多边形面积的计算

    万次阅读 2017-12-21 18:02:01
    多边形面积的计算一般是将其剖分为三角形,利用海伦公式计算每个三角形的面积,然后将所有三角形的面积加起来。但是,这种方法程序实现起来比较复杂,因为无法预知多边形的形状,需要判断多边形的“凸凹”,才能避免...
  • 芯片杂谈001:综合面积与PR后芯片面积 1、Place&Routing后芯片面积与综合面积差异很大? 在完成Place&Routing后的芯片实际面积与综合面积差异很大,这是什么原因呢? 在综合时我们会得到模块的组合逻辑...
  • 例题:图1是某广告公司为某种商品设计的商标图案,若图中每个小正方形的面积都是l,则阴影部分的面积是( ) A 6 B 6.5 C 7 D 7.5 此题为某地中考试题,我们先不谈题目的解答,而来聊一聊这个有点古怪的图形。...
  • 例47:C语言编程求圆周长、圆面积、圆球表面积、圆球体积、圆柱体积。 解题思路:就是简单的数学公式套用,圆周长公式=2πr,圆面积=πr²,圆球表面积=4πr²,圆球体积=4πR³ /3,圆柱体积=πr²h。 源代码演示:...
  • 求凸包面积

    千次阅读 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...
  • 面积测量精灵语音版是一款可以在手机上测量各种土地面积的软件,软件的使用方法十分简单,在手机界面上框选出范围,软件就可以根据定位来算出准确的土地面积,超多功能可以体验,快来试试吧!面积测量精灵软件介绍...
  • 本程序通过一个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},对面积微元积分每个微元是, 横截的圆周 ...
  • 本文演示创建面积边界及面积。 using Autodesk.Revit.Attributes; using Autodesk.Revit.DB; using Autodesk.Revit.UI; namespace RevitAddin4 { [TransactionAttribute(TransactionMode.Manual)] public ...
  • 计算多边形面积

    千次阅读 2019-08-11 02:52:06
    对于规则多边形,矩形、梯形、平行四边形、三角形(根据三边长度,利用公式计算),可以通过公式计算其面积,而对于一般意义的多边形(单一多边形、不包含“洞”),怎么计算面积呢,先想到是分割为三角形,但是程序...
  • 圆的周长和面积: static void Main(string[] args) { Console.WriteLine("请输入圆的半径:"); double r = Convert.ToDouble(Console.ReadLine()); double per = 2 * r * 3.14; ...
  • 01矩阵最大正方形面积 题意:给定一个矩阵,其中的元素为0或者1,要求找出其中元素全为1的面积最大的正方形。 题解:动态规划:对每个元素,把以其为右下角,元素全为1的正方形的最长边长记录下来。如果以元素a(i, j...
  • 如何在arcgis中计算面数据的投影面积和椭球面积 参考资料: 这一个公开课介绍的非常好,链接:https://www.bilibili.com/video/BV1gJ411M7cX?zw 计算面数据的投影面积 投影面积也可以叫做平面面积 如果面...
  • 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
      面积等效原理:   冲量相等而形状不同的窄脉冲加在具有惯性的环节上时,其效果基本相同。冲量即指窄脉冲的面积。这里所说的效果基本相同,是指环节的输出响应波形基本相同。   目前能找到的出处:《电力电子...
  • 首先我们要知道圆的面积计算公式: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位小数,每一...
  • c语言 求圆周长 圆面积 圆球表面积 圆球体积 圆柱体积
  • 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面积积分

    千次阅读 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
关键字:

面积