利用百度API（JavaScript 版）實如今地圖上繪製任一多邊形，並判斷給定經緯度是否在多邊形範圍內。以及兩點間的測距功能

時間  2019-12-14
標籤 利用 百度 api javascript 如今 地圖 繪製 任一 多邊形 判斷 給定 經緯度 是否 範圍內 以及 兩點 2點 測距 功能 欄目 JavaScript 简体版
原文   原文鏈接

權聲明：本文爲博主原創文章，未經博主容許不得轉載。javascript

 

利用百度API（JavaScript 版）實如今地圖上繪製任一多邊形，並判斷給定經緯度是否在多邊形範圍內。以及兩點間的測距功能。css

[javascript]  view plain  copy
 
  1. 繪製多邊形（藍色），折線軌跡（紅色）效果圖：  
[javascript]  view plain  copy
 
  1. <img src="http://img.blog.csdn.net/20150915193750707?watermark/2/text/aHR0cDovL2Jsb2cuY3Nkbi5uZXQv/font/5a6L5L2T/fontsize/400/fill/I0JBQkFCMA==/dissolve/70/gravity/Center" alt="" />  

判斷點範圍，測距：html

html代碼：java

 

[html]  view plain  copy
 
  1. <!DOCTYPE html>  
  2. <html>  
  3. <head>  
  4.     <meta http-equiv="Content-Type" content="text/html; charset=gbk" />  
  5.     <meta name="viewport" content="initial-scale=1.0, user-scalable=no" />  
  6.     <style type="text/css">  
  7.         body, html{width: 100%;height: 100%;margin:0;font-family:"微軟雅黑";}  
  8.         #allmap {height:500px; width: 100%;}  
  9.         #control{width:100%;}  
  10.     </style>  
  11.     <script type="text/javascript" src="http://api.map.baidu.com/api?v=2.0&ak=iqgvSM0gddG4NkGXFlawVa6C"></script>      
  12.         <script type="text/javascript" src="GeoUtils.js"></script>  
  13.     <title>設置線、面可編輯</title>  
  14. </head>  
  15. <body>  
  16.     <div id="allmap"></div>  
  17.     <div id="control">  
  18.         <button onclick = "polyline.enableEditing();polygon.enableEditing();">開啓線、面編輯功能</button>  
  19.         <button onclick = "polyline.disableEditing();polygon.disableEditing();">關閉線、面編輯功能</button>  
  20.     </div>  
  21. </body>  
  22. </html>  
  23. <script type="text/javascript">  
  24.     // 百度地圖API功能  
  25.     var map = new BMap.Map("allmap");  
  26.     map.centerAndZoom(new BMap.Point(106.613922,29.53832), 15);  
  27.     map.enableScrollWheelZoom();  
  28.   
  29.     var polyline = new BMap.Polyline([  
  30.         new BMap.Point(106.612539,29.529602),  
  31.         new BMap.Point(106.607975,29.53177),  
  32.         new BMap.Point(106.610311,29.525862),  
  33.                new BMap.Point(106.60776,29.524008)  
  34.     ], {strokeColor:"red", strokeWeight:2, strokeOpacity:0.5});   //建立折線  
  35.     map.addOverlay(polyline);   //增長折線  
  36.       
  37.     var polygon = new BMap.Polygon([  
  38.         new BMap.Point(106.607477,29.544864),  
  39.         new BMap.Point(106.613572,29.548324),  
  40.         new BMap.Point(106.619357,29.537421),  
  41.         new BMap.Point(106.612988,29.537079),  
  42.         new BMap.Point(106.615359,29.541143)  
  43.     ], {strokeColor:"blue", strokeWeight:2, strokeOpacity:0.5});  //建立多邊形  
  44.     map.addOverlay(polygon);   //增長多邊形  
  45.   
  46.         var ppoint = new BMap.Point(106.613087,29.540485);  
  47.   
  48.          var result=BMapLib.GeoUtils.isPointInPolygon(ppoint, polygon);  
  49.       
  50.          alert("數字圖書館是否在多邊形範圍內："+result);  
  51.   
  52.          var ppoint1 = new BMap.Point(106.614986,29.539876);  
  53.           
  54.         var result1=BMapLib.GeoUtils.isPointInPolygon(ppoint1, polygon);  
  55.   
  56.         alert("乒乓球館是否在多邊形範圍內："+result1+"米");  
  57.   
  58.          var distance =map.getDistance(ppoint, ppoint1);  
  59.         
  60.          alert("The Distance is"+distance);   
  61.           
  62. </script>  

第二步，添加GeoUtils.js文件，代碼以下：算法

 

[javascript]  view plain  copy
 
  1. /**   
  2. * @fileoverview GeoUtils類提供若干幾何算法，用來幫助用戶判斷點與矩形、   
  3. * 圓形、多邊形線、多邊形面的關係,並提供計算折線長度和多邊形的面積的公式。    
  4. * 主入口類是<a href="symbols/BMapLib.GeoUtils.html">GeoUtils</a>，   
  5. * 基於Baidu Map API 1.2。   
  6. *   
  7. * @author Baidu Map Api Group    
  8. * @version 1.2   
  9. */      
  10.       
  11. //BMapLib.GeoUtils.degreeToRad(Number)      
  12. //將度轉化爲弧度      
  13.       
  14. //BMapLib.GeoUtils.getDistance(Point, Point)      
  15. //計算兩點之間的距離,兩點座標必須爲經緯度      
  16.       
  17. //BMapLib.GeoUtils.getPolygonArea(polygon)      
  18. //計算多邊形面或點數組構建圖形的面積,注意：座標類型只能是經緯度，且不適合計算自相交多邊形的面積(封閉的面積)      
  19.       
  20. //BMapLib.GeoUtils.getPolylineDistance(polyline)      
  21. //計算折線或者點數組的長度      
  22.       
  23. //BMapLib.GeoUtils.isPointInCircle(point, circle)      
  24. //判斷點是否在圓形內      
  25.       
  26. //BMapLib.GeoUtils.isPointInPolygon(point, polygon)      
  27. //判斷點是否多邊形內      
  28.       
  29. //BMapLib.GeoUtils.isPointInRect(point, bounds)      
  30. //判斷點是否在矩形內      
  31.       
  32. //BMapLib.GeoUtils.isPointOnPolyline(point, polyline)      
  33. //判斷點是否在折線上      
  34.       
  35. //BMapLib.GeoUtils.radToDegree(Number)      
  36. //將弧度轉化爲度      
  37.       
  38. /**    
  39. * @namespace BMap的全部library類均放在BMapLib命名空間下   
  40. */      
  41. var BMapLib = window.BMapLib = BMapLib || {};      
  42. (function () {      
  43.       
  44.     /**   
  45.     * 地球半徑   
  46.     */      
  47.     var EARTHRADIUS = 6370996.81;      
  48.       
  49.     /**    
  50.     * @exports GeoUtils as BMapLib.GeoUtils    
  51.     */      
  52.     var GeoUtils =      
  53.     /**   
  54.     * GeoUtils類，靜態類，勿需實例化便可使用   
  55.     * @class GeoUtils類的<b>入口</b>。   
  56.     * 該類提供的都是靜態方法，勿需實例化便可使用。        
  57.     */      
  58.      BMapLib.GeoUtils = function () {      
  59.      }      
  60.       
  61.     /**   
  62.     * 判斷點是否在矩形內   
  63.     * @param {Point} point 點對象   
  64.     * @param {Bounds} bounds 矩形邊界對象   
  65.     * @returns {Boolean} 點在矩形內返回true,不然返回false   
  66.     */      
  67.     GeoUtils.isPointInRect = function (point, bounds) {      
  68.         //檢查類型是否正確      
  69.         if (!(point instanceof BMap.Point) ||      
  70.              !(bounds instanceof BMap.Bounds)) {      
  71.             return false;      
  72.         }      
  73.         var sw = bounds.getSouthWest(); //西南腳點      
  74.         var ne = bounds.getNorthEast(); //東北腳點      
  75.         return (point.lng >= sw.lng && point.lng <= ne.lng && point.lat >= sw.lat && point.lat <= ne.lat);      
  76.     }      
  77.       
  78.     /**   
  79.     * 判斷點是否在圓形內   
  80.     * @param {Point} point 點對象   
  81.     * @param {Circle} circle 圓形對象   
  82.     * @returns {Boolean} 點在圓形內返回true,不然返回false   
  83.     */      
  84.     GeoUtils.isPointInCircle = function (point, circle) {      
  85.         //檢查類型是否正確      
  86.         if (!(point instanceof BMap.Point) ||      
  87.             !(circle instanceof BMap.Circle)) {      
  88.             return false;      
  89.         }      
  90.       
  91.         //point與圓心距離小於圓形半徑，則點在圓內，不然在圓外      
  92.         var c = circle.getCenter();      
  93.         var r = circle.getRadius();      
  94.       
  95.         var dis = GeoUtils.getDistance(point, c);      
  96.         if (dis <= r) {      
  97.             return true;      
  98.         } else {      
  99.             return false;      
  100.         }      
  101.     }      
  102.       
  103.     /**   
  104.     * 判斷點是否在折線上   
  105.     * @param {Point} point 點對象   
  106.     * @param {Polyline} polyline 折線對象   
  107.     * @returns {Boolean} 點在折線上返回true,不然返回false   
  108.     */      
  109.     GeoUtils.isPointOnPolyline = function (point, polyline) {      
  110.         //檢查類型      
  111.         if (!(point instanceof BMap.Point) ||      
  112.              !(polyline instanceof BMap.Polyline)) {      
  113.             return false;      
  114.         }      
  115.       
  116.         //首先判斷點是否在線的外包矩形內，若是在，則進一步判斷，不然返回false      
  117.         var lineBounds = polyline.getBounds();      
  118.         if (!this.isPointInRect(point, lineBounds)) {      
  119.             return false;      
  120.         }      
  121.       
  122.         //判斷點是否在線段上，設點爲Q，線段爲P1P2 ，      
  123.         //判斷點Q在該線段上的依據是：( Q - P1 ) × ( P2 - P1 ) = 0，且 Q 在以 P1，P2爲對角頂點的矩形內      
  124.         var pts = polyline.getPath();      
  125.         for (var i = 0; i < pts.length - 1; i++) {      
  126.             var curPt = pts[i];      
  127.             var nextPt = pts[i + 1];      
  128.             //首先判斷point是否在curPt和nextPt之間，即：此判斷該點是否在該線段的外包矩形內      
  129.             if (point.lng >= Math.min(curPt.lng, nextPt.lng) && point.lng <= Math.max(curPt.lng, nextPt.lng) &&      
  130.                  point.lat >= Math.min(curPt.lat, nextPt.lat) && point.lat <= Math.max(curPt.lat, nextPt.lat)) {      
  131.                 //判斷點是否在直線上公式      
  132.                 var precision = (curPt.lng - point.lng) * (nextPt.lat - point.lat) - (nextPt.lng - point.lng) * (curPt.lat - point.lat);      
  133.                 if (precision < 2e-10 && precision > -2e-10) {//實質判斷是否接近0      
  134.                     return true;      
  135.                 }      
  136.             }      
  137.         }      
  138.         return false;      
  139.     }      
  140.       
  141.     /**   
  142.     * 判斷點是否多邊形內   
  143.     * @param {Point} point 點對象   
  144.     * @param {Polyline} polygon 多邊形對象   
  145.     * @returns {Boolean} 點在多邊形內返回true,不然返回false   
  146.     */      
  147.     GeoUtils.isPointInPolygon = function (point, polygon) {      
  148.         //檢查類型      
  149.         if (!(point instanceof BMap.Point) ||      
  150.              !(polygon instanceof BMap.Polygon)) {      
  151.             return false;      
  152.         }      
  153.       
  154.         //首先判斷點是否在多邊形的外包矩形內，若是在，則進一步判斷，不然返回false      
  155.         var polygonBounds = polygon.getBounds();      
  156.         if (!this.isPointInRect(point, polygonBounds)) {      
  157.             return false;      
  158.         }      
  159.       
  160.         var pts = polygon.getPath(); //獲取多邊形點      
  161.       
  162.         //下述代碼來源：http://paulbourke.net/geometry/insidepoly/，進行了部分修改      
  163.         //基本思想是利用射線法，計算射線與多邊形各邊的交點，若是是偶數，則點在多邊形外，不然      
  164.         //在多邊形內。還會考慮一些特殊狀況，如點在多邊形頂點上，點在多邊形邊上等特殊狀況。      
  165.       
  166.         var N = pts.length;      
  167.         var boundOrVertex = true; //若是點位於多邊形的頂點或邊上，也算作點在多邊形內，直接返回true      
  168.         var intersectCount = 0; //cross points count of x       
  169.         var precision = 2e-10; //浮點類型計算時候與0比較時候的容差      
  170.         var p1, p2; //neighbour bound vertices      
  171.         var p = point; //測試點      
  172.       
  173.         p1 = pts[0]; //left vertex              
  174.         for (var i = 1; i <= N; ++i) {//check all rays                  
  175.             if (p.equals(p1)) {      
  176.                 return boundOrVertex; //p is an vertex      
  177.             }      
  178.       
  179.             p2 = pts[i % N]; //right vertex                  
  180.             if (p.lat < Math.min(p1.lat, p2.lat) || p.lat > Math.max(p1.lat, p2.lat)) {//ray is outside of our interests                   
  181.                 p1 = p2;      
  182.                 continue; //next ray left point      
  183.             }      
  184.             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)      
  185.                 if (p.lng <= Math.max(p1.lng, p2.lng)) {//x is before of ray                          
  186.                     if (p1.lat == p2.lat && p.lng >= Math.min(p1.lng, p2.lng)) {//overlies on a horizontal ray      
  187.                         return boundOrVertex;      
  188.                     }      
  189.       
  190.                     if (p1.lng == p2.lng) {//ray is vertical               
  191.       
  192.       
  193.                         if (p1.lng == p.lng) {//overlies on a vertical ray      
  194.                             return boundOrVertex;      
  195.                         } else {//before ray      
  196.                             ++intersectCount;      
  197.                         }      
  198.                     } else {//cross point on the left side                 
  199.       
  200.       
  201.                         var xinters = (p.lat - p1.lat) * (p2.lng - p1.lng) / (p2.lat - p1.lat) + p1.lng; //cross point of lng                    
  202.       
  203.       
  204.                         if (Math.abs(p.lng - xinters) < precision) {//overlies on a ray      
  205.                             return boundOrVertex;      
  206.                         }      
  207.       
  208.                         if (p.lng < xinters) {//before ray      
  209.                             ++intersectCount;      
  210.                         }      
  211.                     }      
  212.                 }      
  213.             } else {//special case when ray is crossing through the vertex                      
  214.                 if (p.lat == p2.lat && p.lng <= p2.lng) {//p crossing over p2                          
  215.                     var p3 = pts[(i + 1) % N]; //next vertex               
  216.       
  217.       
  218.                     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      
  219.                         ++intersectCount;      
  220.                     } else {      
  221.                         intersectCount += 2;      
  222.                     }      
  223.                 }      
  224.             }      
  225.             p1 = p2; //next ray left point      
  226.         }      
  227.       
  228.         if (intersectCount % 2 == 0) {//偶數在多邊形外      
  229.             return false;      
  230.         } else { //奇數在多邊形內      
  231.             return true;      
  232.         }      
  233.     }      
  234.       
  235.     /**   
  236.     * 將度轉化爲弧度   
  237.     * @param {degree} Number 度        
  238.     * @returns {Number} 弧度   
  239.     */      
  240.     GeoUtils.degreeToRad = function (degree) {      
  241.         return Math.PI * degree / 180;      
  242.     }      
  243.       
  244.     /**   
  245.     * 將弧度轉化爲度   
  246.     * @param {radian} Number 弧度        
  247.     * @returns {Number} 度   
  248.     */      
  249.     GeoUtils.radToDegree = function (rad) {      
  250.         return (180 * rad) / Math.PI;      
  251.     }      
  252.       
  253.     /**   
  254.     * 將v值限定在a,b之間，緯度使用   
  255.     */      
  256.     function _getRange(v, a, b) {      
  257.         if (a != null) {      
  258.             v = Math.max(v, a);      
  259.         }      
  260.         if (b != null) {      
  261.             v = Math.min(v, b);      
  262.         }      
  263.         return v;      
  264.     }      
  265.       
  266.     /**   
  267.     * 將v值限定在a,b之間，經度使用   
  268.     */      
  269.     function _getLoop(v, a, b) {      
  270.         while (v > b) {      
  271.             v -= b - a      
  272.         }      
  273.         while (v < a) {      
  274.             v += b - a      
  275.         }      
  276.         return v;      
  277.     }      
  278.       
  279.     /**   
  280.     * 計算兩點之間的距離,兩點座標必須爲經緯度   
  281.     * @param {point1} Point 點對象   
  282.     * @param {point2} Point 點對象   
  283.     * @returns {Number} 兩點之間距離，單位爲米   
  284.     */      
  285.     GeoUtils.getDistance = function (point1, point2) {      
  286.         //判斷類型      
  287.         if (!(point1 instanceof BMap.Point) ||      
  288.              !(point2 instanceof BMap.Point)) {      
  289.             return 0;      
  290.         }      
  291.       
  292.         point1.lng = _getLoop(point1.lng, -180, 180);      
  293.         point1.lat = _getRange(point1.lat, -74, 74);      
  294.         point2.lng = _getLoop(point2.lng, -180, 180);      
  295.         point2.lat = _getRange(point2.lat, -74, 74);      
  296.       
  297.         var x1, x2, y1, y2;      
  298.         x1 = GeoUtils.degreeToRad(point1.lng);      
  299.         y1 = GeoUtils.degreeToRad(point1.lat);      
  300.         x2 = GeoUtils.degreeToRad(point2.lng);      
  301.         y2 = GeoUtils.degreeToRad(point2.lat);      
  302.       
  303.         return EARTHRADIUS * Math.acos((Math.sin(y1) * Math.sin(y2) + Math.cos(y1) * Math.cos(y2) * Math.cos(x2 - x1)));      
  304.     }      
  305.       
  306.     /**   
  307.     * 計算折線或者點數組的長度   
  308.     * @param {Polyline|Array<Point>} polyline 折線對象或者點數組   
  309.     * @returns {Number} 折線或點數組對應的長度   
  310.     */      
  311.     GeoUtils.getPolylineDistance = function (polyline) {      
  312.         //檢查類型      
  313.         if (polyline instanceof BMap.Polyline ||      
  314.              polyline instanceof Array) {      
  315.             //將polyline統一爲數組      
  316.             var pts;      
  317.             if (polyline instanceof BMap.Polyline) {      
  318.                 pts = polyline.getPath();      
  319.             } else {      
  320.                 pts = polyline;      
  321.             }      
  322.       
  323.             if (pts.length < 2) {//小於2個點，返回0      
  324.                 return 0;      
  325.             }      
  326.       
  327.             //遍歷全部線段將其相加，計算整條線段的長度      
  328.             var totalDis = 0;      
  329.             for (var i = 0; i < pts.length - 1; i++) {      
  330.                 var curPt = pts[i];      
  331.                 var nextPt = pts[i + 1]      
  332.                 var dis = GeoUtils.getDistance(curPt, nextPt);      
  333.                 totalDis += dis;      
  334.             }      
  335.       
  336.             return totalDis;      
  337.       
  338.         } else {      
  339.             return 0;      
  340.         }      
  341.     }      
  342.       
  343.     /**   
  344.     * 計算多邊形面或點數組構建圖形的面積,注意：座標類型只能是經緯   
  345.    
  346.     度，且不適合計算自相交多邊形的面積   
  347.     * @param {Polygon|Array<Point>} polygon 多邊形面對象或者點數   
  348.    
  349.     組   
  350.     * @returns {Number} 多邊形面或點數組構成圖形的面積   
  351.     */      
  352.     GeoUtils.getPolygonArea = function (polygon) {      
  353.         //檢查類型      
  354.         if (!(polygon instanceof BMap.Polygon) &&      
  355.              !(polygon instanceof Array)) {      
  356.             return 0;      
  357.         }      
  358.         var pts;      
  359.         if (polygon instanceof BMap.Polygon) {      
  360.             pts = polygon.getPath();      
  361.         } else {      
  362.             pts = polygon;      
  363.         }      
  364.       
  365.         if (pts.length < 3) {//小於3個頂點，不能構建面      
  366.             return 0;      
  367.         }      
  368.       
  369.         var totalArea = 0; //初始化總面積      
  370.         var LowX = 0.0;      
  371.         var LowY = 0.0;      
  372.         var MiddleX = 0.0;      
  373.         var MiddleY = 0.0;      
  374.         var HighX = 0.0;      
  375.         var HighY = 0.0;      
  376.         var AM = 0.0;      
  377.         var BM = 0.0;      
  378.         var CM = 0.0;      
  379.         var AL = 0.0;      
  380.         var BL = 0.0;      
  381.         var CL = 0.0;      
  382.         var AH = 0.0;      
  383.         var BH = 0.0;      
  384.         var CH = 0.0;      
  385.         var CoefficientL = 0.0;      
  386.         var CoefficientH = 0.0;      
  387.         var ALtangent = 0.0;      
  388.         var BLtangent = 0.0;      
  389.         var CLtangent = 0.0;      
  390.         var AHtangent = 0.0;      
  391.         var BHtangent = 0.0;      
  392.         var CHtangent = 0.0;      
  393.         var ANormalLine = 0.0;      
  394.         var BNormalLine = 0.0;      
  395.         var CNormalLine = 0.0;      
  396.         var OrientationValue = 0.0;      
  397.         var AngleCos = 0.0;      
  398.         var Sum1 = 0.0;      
  399.         var Sum2 = 0.0;      
  400.         var Count2 = 0;      
  401.         var Count1 = 0;      
  402.         var Sum = 0.0;      
  403.         var Radius = EARTHRADIUS; //6378137.0,WGS84橢球半徑       
  404.         var Count = pts.length;      
  405.         for (var i = 0; i < Count; i++) {      
  406.             if (i == 0) {      
  407.                 LowX = pts[Count - 1].lng * Math.PI / 180;      
  408.                 LowY = pts[Count - 1].lat * Math.PI / 180;      
  409.                 MiddleX = pts[0].lng * Math.PI / 180;      
  410.                 MiddleY = pts[0].lat * Math.PI / 180;      
  411.                 HighX = pts[1].lng * Math.PI / 180;      
  412.                 HighY = pts[1].lat * Math.PI / 180;      
  413.             }      
  414.             else if (i == Count - 1) {      
  415.                 LowX = pts[Count - 2].lng * Math.PI / 180;      
  416.                 LowY = pts[Count - 2].lat * Math.PI / 180;      
  417.                 MiddleX = pts[Count - 1].lng * Math.PI / 180;      
  418.                 MiddleY = pts[Count - 1].lat * Math.PI / 180;      
  419.                 HighX = pts[0].lng * Math.PI / 180;      
  420.                 HighY = pts[0].lat * Math.PI / 180;      
  421.             }      
  422.             else {      
  423.                 LowX = pts[i - 1].lng * Math.PI / 180;      
  424.                 LowY = pts[i - 1].lat * Math.PI / 180;      
  425.                 MiddleX = pts[i].lng * Math.PI / 180;      
  426.                 MiddleY = pts[i].lat * Math.PI / 180;      
  427.                 HighX = pts[i + 1].lng * Math.PI / 180;      
  428.                 HighY = pts[i + 1].lat * Math.PI / 180;      
  429.             }      
  430.             AM = Math.cos(MiddleY) * Math.cos(MiddleX);      
  431.             BM = Math.cos(MiddleY) * Math.sin(MiddleX);      
  432.             CM = Math.sin(MiddleY);      
  433.             AL = Math.cos(LowY) * Math.cos(LowX);      
  434.             BL = Math.cos(LowY) * Math.sin(LowX);      
  435.             CL = Math.sin(LowY);      
  436.             AH = Math.cos(HighY) * Math.cos(HighX);      
  437.             BH = Math.cos(HighY) * Math.sin(HighX);      
  438.             CH = Math.sin(HighY);      
  439.             CoefficientL = (AM * AM + BM * BM + CM * CM) / (AM * AL + BM * BL + CM * CL);      
  440.             CoefficientH = (AM * AM + BM * BM + CM * CM) / (AM * AH + BM * BH + CM * CH);      
  441.             ALtangent = CoefficientL * AL - AM;      
  442.             BLtangent = CoefficientL * BL - BM;      
  443.             CLtangent = CoefficientL * CL - CM;      
  444.             AHtangent = CoefficientH * AH - AM;      
  445.             BHtangent = CoefficientH * BH - BM;      
  446.             CHtangent = CoefficientH * CH - CM;      
  447.             AngleCos = (AHtangent * ALtangent + BHtangent * BLtangent + CHtangent * CLtangent) / (Math.sqrt(AHtangent * AHtangent + BHtangent * BHtangent + CHtangent * CHtangent) * Math.sqrt(ALtangent * ALtangent + BLtangent * BLtangent + CLtangent * CLtangent));      
  448.             AngleCos = Math.acos(AngleCos);      
  449.             ANormalLine = BHtangent * CLtangent - CHtangent * BLtangent;      
  450.             BNormalLine = 0 - (AHtangent * CLtangent - CHtangent * ALtangent);      
  451.             CNormalLine = AHtangent * BLtangent - BHtangent * ALtangent;      
  452.             if (AM != 0)      
  453.                 OrientationValue = ANormalLine / AM;      
  454.             else if (BM != 0)      
  455.                 OrientationValue = BNormalLine / BM;      
  456.             else      
  457.                 OrientationValue = CNormalLine / CM;      
  458.             if (OrientationValue > 0) {      
  459.                 Sum1 += AngleCos;      
  460.                 Count1++;      
  461.             }      
  462.             else {      
  463.                 Sum2 += AngleCos;      
  464.                 Count2++;      
  465.             }      
  466.         }      
  467.         var tempSum1, tempSum2;      
  468.         tempSum1 = Sum1 + (2 * Math.PI * Count2 - Sum2);      
  469.         tempSum2 = (2 * Math.PI * Count1 - Sum1) + Sum2;      
  470.         if (Sum1 > Sum2) {      
  471.             if ((tempSum1 - (Count - 2) * Math.PI) < 1)      
  472.                 Sum = tempSum1;      
  473.             else      
  474.                 Sum = tempSum2;      
  475.         }      
  476.         else {      
  477.             if ((tempSum2 - (Count - 2) * Math.PI) < 1)      
  478.                 Sum = tempSum2;      
  479.             else      
  480.                 Sum = tempSum1;      
  481.         }      
  482.         totalArea = (Sum - (Count - 2) * Math.PI) * Radius * Radius;      
  483.         return totalArea; //返回總面積      
  484.     }      
相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程