SMathUtil.js 6.2 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184
  1. "use strict";
  2. Object.defineProperty(exports, "__esModule", { value: true });
  3. exports.SMathUtil = void 0;
  4. const lib_1 = require("@persagy-web/draw/lib");
  5. const polybooljs_1 = require("polybooljs");
  6. class SMathUtil {
  7. static pointDistance(x1, y1, x2, y2) {
  8. return Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2));
  9. }
  10. static getMinDisPoint(p, arr) {
  11. if (!arr.length) {
  12. return null;
  13. }
  14. let minDis = {
  15. MinDis: SMathUtil.pointDistance(p.x, p.y, arr[0].X, -arr[0].Y),
  16. Point: arr[0]
  17. };
  18. for (let i = 1; i < arr.length; i++) {
  19. let ds = SMathUtil.pointDistance(p.x, p.y, arr[i].X, -arr[i].Y);
  20. if (ds < minDis.MinDis) {
  21. minDis.MinDis = ds;
  22. minDis.Point = arr[i];
  23. }
  24. }
  25. return minDis;
  26. }
  27. static pointToLine(p, l) {
  28. let d = {
  29. MinDis: Number.MAX_SAFE_INTEGER,
  30. Line: new lib_1.SLine(),
  31. Point: new lib_1.SPoint()
  32. };
  33. let bgX = Math.max(l.x1, l.x2);
  34. let smX = Math.min(l.x1, l.x2);
  35. if (l.dx == 0) {
  36. let bgY = Math.max(l.y1, l.y2);
  37. let smY = Math.min(l.y1, l.y2);
  38. if (p.y > smY && p.y < bgY) {
  39. d.MinDis = Math.abs(p.x - l.x1);
  40. d.Line = l;
  41. d.Point = new lib_1.SPoint(l.x1, p.y);
  42. }
  43. }
  44. else if (l.dy == 0) {
  45. if (p.x > smX && p.x < bgX) {
  46. d.MinDis = Math.abs(p.y - l.y1);
  47. d.Line = l;
  48. d.Point = new lib_1.SPoint(p.x, l.y1);
  49. }
  50. }
  51. else {
  52. let k1 = (l.y1 - l.y2) / (l.x1 - l.x2);
  53. let b1 = l.y1 - k1 * l.x1;
  54. let k2 = -1 / k1;
  55. let b2 = p.y - k2 * p.x;
  56. let x = (b1 - b2) / (k2 - k1);
  57. let y = k1 * x + b1;
  58. if (x > smX && x < bgX) {
  59. d.MinDis = SMathUtil.pointDistance(p.x, p.y, x, y);
  60. d.Line = l;
  61. d.Point = new lib_1.SPoint(x, y);
  62. }
  63. }
  64. return d;
  65. }
  66. static getMinDisLine(p, arr) {
  67. if (arr.length < 2) {
  68. return null;
  69. }
  70. let PTL = SMathUtil.pointToLine(p, new lib_1.SLine(arr[arr.length - 1].X, -arr[arr.length - 1].Y, arr[0].X, -arr[0].Y));
  71. for (let i = 0; i < arr.length - 1; i++) {
  72. let temp = SMathUtil.pointToLine(p, new lib_1.SLine(arr[i].X, -arr[i].Y, arr[i + 1].X, -arr[i + 1].Y));
  73. if (temp.MinDis < PTL.MinDis) {
  74. PTL = temp;
  75. }
  76. }
  77. return PTL;
  78. }
  79. static rectIntersection(rect1, rect2) {
  80. let minX = rect1.x < rect2.x ? rect1.x : rect2.x;
  81. let minY = rect1.y < rect2.y ? rect1.y : rect2.y;
  82. let maxX = rect1.right > rect2.right ? rect1.right : rect2.right;
  83. let maxY = rect1.bottom > rect2.bottom ? rect2.bottom : rect2.bottom;
  84. return (rect1.width + rect2.width > maxX - minX &&
  85. rect1.height + rect2.height > maxY - minY);
  86. }
  87. static lineIntersection(line1, line2) {
  88. let k1 = line1.dy / line1.dx;
  89. let b1 = line1.y1 - k1 * line1.x1;
  90. let k2 = line2.dy / line2.dx;
  91. let b2 = line2.y1 - k2 * line2.x1;
  92. if (k1 == k2) {
  93. if (b1 == b2) {
  94. return "repeat";
  95. }
  96. return null;
  97. }
  98. let intersectionX = (b2 - b1) / (k1 - k2);
  99. let intersectionY = k1 * intersectionX + b1;
  100. let minX = Math.min(line1.x1, line1.x2);
  101. let maxX = Math.min(line2.x1, line2.x2);
  102. if (intersectionX >= minX && intersectionX <= maxX) {
  103. return new lib_1.SPoint(intersectionX, intersectionY);
  104. }
  105. return null;
  106. }
  107. static transferToArray(SP) {
  108. return SP.map((t) => {
  109. return [t.x, t.y];
  110. });
  111. }
  112. static transferToSPoint(arr) {
  113. return arr.map((t) => {
  114. return new lib_1.SPoint(t[0], t[1]);
  115. });
  116. }
  117. static getIntersectInArray(array) {
  118. let outlineList = [];
  119. if (!array.length) {
  120. }
  121. else if (array.length == 1) {
  122. let outline = {
  123. Outer: [],
  124. Inner: []
  125. };
  126. outline.Outer = array[0].map((t) => {
  127. return new lib_1.SPoint(t[0], t[1]);
  128. });
  129. outlineList.push(outline);
  130. }
  131. else {
  132. let poly2 = {
  133. regions: [],
  134. inverted: false
  135. };
  136. poly2.regions.push(array[array.length - 1]);
  137. let indexArr = [array.length - 1];
  138. for (let i = array.length - 2; i > 0; i--) {
  139. let poly1 = {
  140. regions: [],
  141. inverted: false
  142. };
  143. poly1.regions.push(array[i]);
  144. let intersectObj = polybooljs_1.intersect(poly1, poly2);
  145. console.log(intersectObj);
  146. if (!intersectObj.regions.length) {
  147. indexArr.unshift(i);
  148. poly2.regions = [];
  149. poly2.regions.push(array[i]);
  150. }
  151. }
  152. indexArr.unshift(0);
  153. console.log(indexArr);
  154. for (let i = 0; i < indexArr.length - 1; i++) {
  155. let axArr = array.slice(i == 0 ? 0 : indexArr[i] + 1, indexArr[i + 1]);
  156. let outline = {
  157. Outer: [],
  158. Inner: []
  159. };
  160. outline.Outer = array[indexArr[i + 1]].map((t) => {
  161. return new lib_1.SPoint(t[0], t[1]);
  162. });
  163. outline.Inner = axArr.map((t) => {
  164. return t.map((item) => {
  165. return new lib_1.SPoint(item[0], item[1]);
  166. });
  167. });
  168. outlineList.push(outline);
  169. }
  170. }
  171. console.log(outlineList);
  172. return outlineList;
  173. }
  174. static calculateArea(arr) {
  175. let sum = 0;
  176. let n = arr.length;
  177. arr[n] = arr[0];
  178. for (let i = 1; i <= n; i++) {
  179. sum += arr[i].x * arr[i - 1].y - arr[i - 1].x * arr[i].y;
  180. }
  181. return sum / 2;
  182. }
  183. }
  184. exports.SMathUtil = SMathUtil;