# 过滤多边形中冗余的点

大家好，我是前端丁修。

在图形学和前端开发中，处理多边形时，顶点通常以循环的方式连接，即第一个点与最后一个点相连。有时需要优化多边形的点，移除路径中不必要的点以简化多边形结构。本节将介绍如何使用 TypeScript 实现一个过滤多边形中冗余点的工具。

### 功能列表

1. **初始化多边形**  
   定义多边形的点集。

2. **检测和移除冗余点**  
   判断哪些点是多余的，并将其移除。

3. **优化后的多边形输出**  
   输出经过优化后的点集。

## 实现过滤冗余点的方法

我们将采用**共线检测**和**距离阈值**的方法来判断点是否冗余。通过检查连续三个点是否共线，可以有效识别并删除那些位于直线上的中间点，从而优化多边形的顶点数，提升计算效率。

### 共线检测

如果三个连续的点在同一直线上，中间的点就是冗余的，可以被移除。

### 距离阈值

在某些情况下，点之间的距离过小也可以被认为是冗余的，根据设定的阈值来移除这些点。

## 代码实现

下面是过滤多边形中冗余点的 TypeScript 实现。

```typescript
// 定义点的接口
interface Point {
  x: number;
  y: number;
}

// 多边形类
class Polygon {
  points: Point[];

  constructor(points: Point[]) {
    this.points = points;
  }

  // 检查三个点是否共线
  private isCollinear(p1: Point, p2: Point, p3: Point): boolean {
    const area =
      p1.x * (p2.y - p3.y) + p2.x * (p3.y - p1.y) + p3.x * (p1.y - p2.y);
    return Math.abs(area) < 1e-6;
  }

  // 计算两点之间的距离
  private distance(p1: Point, p2: Point): number {
    return Math.sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2);
  }

  // 移除近距离的点
  private removeClosePoints(distanceThreshold: number): void {
    if (this.points.length <= 3) return;

    // 先检查首尾点
    if (this.distance(this.points[0], this.points[this.points.length - 1])<= distanceThreshold) {
        this.points.pop();
    }

    this.points = this.points.filter((point, index, arr) => {
      if (index === 0) return true;
      return this.distance(point, arr[index - 1]) > distanceThreshold;
    });
  }

  // 移除共线的点
  private removeCollinearPoints(): void {
    if (this.points.length <= 3) return;
    const filteredPoints: Point[] = [];
    const n = this.points.length;
    for (let i = 0; i < n; i++) {
      // 保证 i 为 0 时，i - 1 不会变为负数
      const prev = this.points[(i - 1 + n) % n];
      const current = this.points[i];
      // 取模运算，用于确保索引始终在 0 到 n-1 之间，避免数组越界
      const next = this.points[(i + 1) % n];

      if (
        this.isCollinear(prev, current, next) &&
        // 检查当前点之后是否至少还有两个点。
        // 如果 i + 2 大于或等于 n，意味着已经到达数组的末尾，此时不需要进一步检查共线性，直接保留当前点。
        (i + 2 >= n ||
          !this.isCollinear(current, next, this.points[(i + 2) % n]))
      ) {
        continue;
      }
      filteredPoints.push(current);
    }
    this.points = filteredPoints;
  }

  // 过滤冗余点
  private filterRedundantPoints(distanceThreshold: number = 0.01): void {
    if (this.points.length < 3) return;
    this.removeClosePoints(distanceThreshold);
    this.removeCollinearPoints();
  }

  // 输出多边形的点
  getPoints(): Point[] {
    return this.points;
  }
}
```

## 使用方法

创建一个 `Polygon` 实例，传入点集后调用 `filterRedundantPoints` 方法即可过滤冗余点。通过调整 `distanceThreshold` 参数，可以控制距离过滤的敏感度。

```typescript
const polygon = new Polygon([
  { x: 0, y: 0 },
  { x: 2, y: 2 },
  { x: 4, y: 4 }, // 冗余点
  { x: 6, y: 2 },
  { x: 8, y: 0 },
  { x: 8.02, y: 0 }, // 冗余点
]);

console.log("原始点集:", polygon.getPoints());
polygon.filterRedundantPoints(0.05);
console.log("优化后点集:", polygon.getPoints());
```
![图 0](https://assets.npmstar.com/article-images/6c991b105a0ded199cbc6b3acd751d0ca4045d501b3d90674cba6b759e76e96b.png)  


输出：

```
原始点集: [
  { x: 0, y: 0 },
  { x: 2, y: 2 },
  { x: 4, y: 4 },
  { x: 6, y: 2 },
  { x: 8, y: 0 },
  { x: 8.02, y: 0 }
]
优化后点集: [
  { x: 0, y: 0 }, 
  { x: 4, y: 4 }, 
  { x: 8, y: 0 } 
]
```


几何算法：过滤多边形中冗余的点的

# 判断点 P 是否在三角形 ABC 之内

大家好，我是前端丁修，这篇文章给大家分享一下，如何判断点在三角形内。

## 为什么这个问题这么重要？

想象一下，你正在开发一个地图应用，用户点击屏幕时，你需要判断点击的位置是否落在某个区域内。这些场景都需要用到点和多边形的位置关系判断，而三角形作为最基本的多边形，是解决这类问题的基础。

## 几种常用的判断方法

判断点是否在三角形内，常用的有面积法、同向法、重心坐标法、射线法等四种方法。每种方法都有其特点，要根据实际情况选择最合适的方法。



### 1. 面积法

这个方法特别容易理解，就像小时候玩拼图一样。假设点 P 在三角形 ABC 内部，那么 P 会把三角形分成三个小三角形：PAB、PBC 和 PCA。如果 P 真的在三角形内部，这三个小三角形的面积之和就等于大三角形 ABC 的面积。



![面积法](https://assets.npmstar.com/article-images/72fb4a4e6a21aea4ba90d226ac9f4f225aec84e503097f49be7447b93f55f3c4/%E9%9D%A2%E7%A7%AF%E6%B3%95.png)  

![面积法-点在三角形外](https://assets.npmstar.com/article-images/9b99822310d31cf1c551c9781de69351e20818447ac0f47cb62a924aa7eccc84/%24%7Bfilename%7D.png)  


来看看具体怎么实现：
计算三角形的面积，其实有很多种方法，我们在项目中通常会存储三角形三个点的坐标，所以这里直接根据三角形坐标，使用三角形的面积行列公式计算面积。
```typescript
interface Point {
  x: number;
  y: number;
}

// 根据三角形的三个点坐标，计算三角形面积
function calculateTriangleArea(a: Point, b: Point, c: Point): number {
  return Math.abs(
    (a.x * (b.y - c.y) + b.x * (c.y - a.y) + c.x * (a.y - b.y)) / 2
  );
}
```

```typescript
function isPointInTriangleByArea(
  p: Point,
  a: Point,
  b: Point,
  c: Point
): boolean {
  const areaABC = calculateTriangleArea(a, b, c);
  const areaPAB = calculateTriangleArea(p, a, b);
  const areaPBC = calculateTriangleArea(p, b, c);
  const areaPCA = calculateTriangleArea(p, c, a);

  return Math.abs(areaABC - (areaPAB + areaPBC + areaPCA)) < 0.001;
}
```

这个方法的优点是特别直观，代码也容易理解。不过计算量相对大一些，因为要计算四个三角形的面积。

### 2. 同向法

我们用向量叉积来判断方向，向量叉积（Cross Product）是向量运算中的一种，用于判断两个向量的相对方向。

这个方法的思路是通过向量叉积来判断点 P 相对于三角形三条边的位置。如果点 P 相对于每条边的叉积符号相同（都为正或都为负），则点 P 在三角形内部；否则，点 P 在三角形外部。

![同向法 点在三角形内](https://assets.npmstar.com/article-images/15e1c4cd52ea31128e468a9ed99e51a9f1dae073168d56ca10280274987a0d40/%E5%90%8C%E5%90%91%E6%B3%95.png)  

![同向法 点在三角形外](https://assets.npmstar.com/article-images/01eb214f2e270e8baa22e4293a75c041a9c891208552bc3375c0e6c15f3c17b5/%E5%90%8C%E5%90%91%E6%B3%95%20%E7%82%B9%E5%9C%A8%E4%B8%89%E8%A7%92%E5%BD%A2%E5%A4%96.png)  

具体来说：

如果点 P 在边 AB 的左侧，则向量叉积 calcCrossProduct(a, b, p) 为正值。
如果点 P 在边 AB 的右侧，则向量叉积 calcCrossProduct(a, b, p) 为负值。
如果点 P 在边 AB 上，则向量叉积 calcCrossProduct(a, b, p) 为零。
同理，我们可以计算点 P 相对于边 BC 和边 CA 的叉积。如果点 P 相对于三条边的叉积符号相同（都为正或都为负），则点 P 在三角形内部；否则，点 P 在三角形外部。

```typescript
// 计算向量的叉积
function calcCrossProduct(a: Point, b: Point, p: Point): number {
  // |  (b.x - a.x)  (p.x - a.x) |  | ABx  APx |
  // |  (b.y - a.y)  (p.y - a.y) |  | ABy  APy |
  return (b.x - a.x) * (p.y - a.y) - (b.y - a.y) * (p.x - a.x);
}

function isPointInTriangleByCrossProduct(
  p: Point,
  a: Point,
  b: Point,
  c: Point
): boolean {
  const ab = calcCrossProduct(a, b, p); // AB AP
  const bc = calcCrossProduct(b, c, p); // BC BP
  const ca = calcCrossProduct(c, a, p); // CA CP

  return (ab >= 0 && bc >= 0 && ca >= 0) || (ab <= 0 && bc <= 0 && ca <= 0);
}
```

这个方法的计算效率比面积法高，而且实现起来也不复杂。

### 3. 重心坐标法

重心坐标法是一种判断点是否在三角形内部的有效方法。它基于将点表示为三角形顶点的线性组合。通过计算点在三角形顶点的权重，我们可以确定点是否在三角形内部。具体步骤如下：

#### 重心坐标的定义

重心坐标（Barycentric Coordinates）是一种在三角形内部表示点位置的坐标系统。对于任意一个三角形 ABC 和其中的一个点 P，重心坐标使用三个权重(λ1, λ2, λ3)来表示，这三个权重就是重心坐标。公式为：

$$ P = \lambda_1 \cdot A + \lambda_2 \cdot B + \lambda_3 \cdot C $$

#### 重心坐标的推导


![重心坐标法](https://assets.npmstar.com/article-images/34b34e6e30ec521bdd2d3674956ee4a94d52b152a762a80b6f39411cf8cae3ed/%E9%87%8D%E5%BF%83%E5%9D%90%E6%A0%87%E6%B3%95.png)  
![重心坐标法，点在三角形外](https://assets.npmstar.com/article-images/9676185723e3e294be8532c9976d14be78dad6d6c4ea2639a3716e6dfab256d8/%E9%87%8D%E5%BF%83%E5%9D%90%E6%A0%87%E6%B3%95%EF%BC%8C%E7%82%B9%E5%9C%A8%E4%B8%89%E8%A7%92%E5%BD%A2%E5%A4%96.png)  


在同一平面内，三角形的三个顶点 ABC 中若选定一点 A 作为基点，则 B 与 C 可视为相对 A 的位移。对于该平面上任意一点 P，都可通过下式表示：

P = A + u(C – A) + v(B – A)

若将系数 u、v 取负数，即表示沿相反方向移动；若要使 P 位于三角形内部，则需满足：

u ≥ 0  
v ≥ 0  
u + v ≤ 1

当 u=0 且 v=0 时，P 落在点 A；当 u=0, v=1 时，P 在点 B；当 u=1, v=0 时，P 在点 C。

令 v0 = C – A（表示从点 A 到点 C 的向量）、v1 = B – A（表示从点 A 到点 B 的向量）、v2 = P – A（表示从点 A 到点 P 的向量），则有 v2 = u·v0 + v·v1。将等式两边分别与 v0、v1 做点乘，便得到：

v2 • v0 = u(v0 • v0) + v(v1 • v0)  
v2 • v1 = u(v0 • v1) + v(v1 • v1)

可将这组方程视作线性方程组并使用行列式求解。  
令 a = (v0•v0), b = (v1•v0), c = (v0•v1), d = (v1•v1)，p = (v2•v0), q = (v2•v1)。

两式写成矩阵乘法形式：  
[ a b ] [ u ] = [ p ]  
[ c d ] [ v ] = [ q ]

行列式 det = ad - bc。矩阵逆为 (1/det)·[ d -b; -c a ]，因此有：  
u = (1/det) · ( d·p - b·q )  
v = (1/det) · ( -c·p + a·q )

将 a、b、c、d、p、q 换回原始点积，即得：  
u = [(v1•v1)(v2•v0) - (v1•v0)(v2•v1)] / [(v0•v0)(v1•v1) - (v0•v1)(v1•v0)]  
v = [(v0•v0)(v2•v1) - (v0•v1)(v2•v0)] / [(v0•v0)(v1•v1) - (v0•v1)(v1•v0)]

代码如下

```typescript
// 函数接收四个参数，分别是点 p 和三角形的三个顶点 a、b、c，
function isPointInTriangle(p: Point, a: Point, b: Point, c: Point): boolean {
  // 向量 AC
  const v0 = { x: c.x - a.x, y: c.y - a.y };
  // 向量 AB
  const v1 = { x: b.x - a.x, y: b.y - a.y };
  // 向量 AP
  const v2 = { x: p.x - a.x, y: p.y - a.y };
  // 这些点积用于计算重心坐标（barycentric coordinates），以确定点 P 是否在三角形内。
  // 计算五个点积：dot00、dot01、dot02、dot11 和 dot12。
  // dot00 是向量 v0 与自身的点积，表示 v0 的长度平方。
  const dot00 = v0.x * v0.x + v0.y * v0.y;
  // dot11 是向量 v1 与自身的点积，表示 v1 的长度平方。
  const dot11 = v1.x * v1.x + v1.y * v1.y;

  // dot01 是向量 v0 与 v1 的点积，表示 v0 和 v1 之间的夹角关系。
  const dot01 = v0.x * v1.x + v0.y * v1.y;
  // dot02 是向量 v0 与 v2 的点积，表示 v0 和 v2 之间的夹角关系。
  const dot02 = v0.x * v2.x + v0.y * v2.y;
  // dot12 是向量 v1 与 v2 的点积，表示 v1 和 v2 之间的夹角关系。
  const dot12 = v1.x * v2.x + v1.y * v2.y;

  const invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
  const u = (dot11 * dot02 - dot01 * dot12) * invDenom;
  const v = (dot00 * dot12 - dot01 * dot02) * invDenom;

  return u >= 0 && v >= 0 && u + v < 1;
}
```

### 4. 射线法

从点 P 向任意方向发射一条射线，统计它和三角形边的交点个数。如果交点个数是奇数，说明点在三角形内部；如果是偶数，说明在外部。

![射线法](https://assets.npmstar.com/article-images/bd602ae57e9144674e03556874d438944710dcaa405a9e47e34733e7b6047a82/%E5%B0%84%E7%BA%BF%E6%B3%95.png)  

![射线法 点在三角形外](https://assets.npmstar.com/article-images/b92d0719501d5550606b239487440ed7b557457a92cfc054170b2d6bad5fc53e/%E5%B0%84%E7%BA%BF%E6%B3%95%20%E7%82%B9%E5%9C%A8%E4%B8%89%E8%A7%92%E5%BD%A2%E5%A4%96.png)  


```typescript
 

// 判断点是否在三角形内的射线法实现
 // 计算叉积
export function crossProduct(a: Point, b: Point, c: Point): number {
  return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x);
}

// 判断线段是否相交
function isIntersect(
  p1: Point, p2: Point,  // 第一条线段的端点
  p3: Point, p4: Point   // 第二条线段的端点
): boolean {
  // 完全不相交
  if (Math.max(p1.x, p2.x) < Math.min(p3.x, p4.x) ||
      Math.max(p3.x, p4.x) < Math.min(p1.x, p2.x) ||
      Math.max(p1.y, p2.y) < Math.min(p3.y, p4.y) ||
      Math.max(p3.y, p4.y) < Math.min(p1.y, p2.y)) {
    return false;
  }

  // 跨立实验
  const cross1 = crossProduct(p1, p2, p3) * crossProduct(p1, p2, p4);
  const cross2 = crossProduct(p3, p4, p1) * crossProduct(p3, p4, p2);
  return cross1 <= 0 && cross2 <= 0;
}

// 使用射线法判断点是否在三角形内
export function isPointInTriangleByRay(
  p: Point,
  triangle: Triangle
): {
  isInside: boolean;
  intersections: {
    ab: boolean;
    bc: boolean;
    ca: boolean;
  };
} {
  const { a, b, c } = triangle;
  
  // 创建一条向右的射线
  const ray = {
    x: p.x + 1000, // 足够长的射线
    y: p.y
  };

  // 检查与三条边的相交情况
  const intersectAB = isIntersect(p, ray, a, b);
  const intersectBC = isIntersect(p, ray, b, c);
  const intersectCA = isIntersect(p, ray, c, a);

  // 统计交点个数
  const intersectCount = (intersectAB ? 1 : 0) + 
                        (intersectBC ? 1 : 0) + 
                        (intersectCA ? 1 : 0);

  return {
    isInside: intersectCount % 2 === 1,
    intersections: {
      ab: intersectAB,
      bc: intersectBC,
      ca: intersectCA
    }
  };
}

```

## 实际应用中的注意事项

在实际使用这些方法时，有几点需要特别注意：

1. 浮点数精度问题：由于计算机浮点数的精度限制，判断相等时要留有一定的误差范围。
2. 边界情况：点在三角形边上或顶点上时的处理要特别小心。
3. 性能考虑：在需要大量计算的场景下，建议使用同向法或重心坐标法。


希望这篇文章对大家有帮助！

几何算法：判断点在三角形之内

# 如何判断一个点是否在一个凸多边形内

大家好，我是前端丁修，今天我们来学习如何判断一个点是否在凸多边形内。这是图形处理中经常遇到的问题，也是面试中的常见问题。

首先，我们讨论的是凸多边形。什么是凸多边形呢？简单来说，就是所有内角都小于 180 度的多边形，看起来没有"凹进去"的部分。虽然本文标题是关于凸多边形的判断，但其中的引射线法实际上对任意多边形（包括凹多边形）都适用。面积法和夹角法则主要适用于凸多边形。

接下来，我会介绍几种常用的方法，包括面积和判别法、夹角和判别法以及引射线法。

## 面积和判别法

### 基本原理

第一种方法是用面积来判断：如果点在多边形内部，那么这个点和多边形的每条边组成的小三角形的面积之和，应该等于整个多边形的面积。

三角形面积可以通过向量叉积计算：

![面积法](https://assets.npmstar.com/article-images/2024-12/%E9%9D%A2%E7%A7%AF%E6%B3%95.png)

### 详细步骤

1. 计算多边形的总面积。可以通过以下方式计算:
   - 选择多边形的一个顶点作为基准点
   - 将多边形分割成多个三角形
   - 对每个三角形使用向量叉积计算其有向面积
   - 将所有三角形的面积相加得到多边形总面积
     注意：向量叉积得到的是有向面积，需要取绝对值才是真实面积

2. 计算点与多边形各顶点形成的三角形面积之和。
3. 比较总面积与三角形面积之和，如果相等，则点在多边形内，这里要考虑容差。

### 示例代码

```typescript
// 计算三角形面积的函数
function triangleArea(p1: [number, number], p2: [number, number], p3: [number, number]): number {
  const [x1, y1] = p1;
  const [x2, y2] = p2;
  const [x3, y3] = p3;
  return Math.abs((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2;
}

function isPointInsidePolygonArea(polygon: [number, number][], point: [number, number]): boolean {
  let totalArea = 0;
  let sumAreas = 0;
  const n = polygon.length;

  // 计算多边形总面积
  for (let i = 0; i < n; i++) {
    const j = (i + 1) % n;
    totalArea += triangleArea(polygon[0], polygon[i], polygon[j]);
  }

  // 计算点与各边构成的三角形面积和
  for (let i = 0; i < n; i++) {
    const j = (i + 1) % n;
    sumAreas += triangleArea(point, polygon[i], polygon[j]);
  }

  // 考虑JS浮点数精度问题
  return Math.abs(totalArea - sumAreas) < 1e-10;
}
```

## 夹角和判别法

### 基本原理

第二种方法是看夹角。如果一个点在多边形内部，那么这个点与多边形各顶点的向量之间的夹角之和应该等于 360 度。这就是夹角和判别法的核心思想。
![夹角法](https://assets.npmstar.com/article-images/2024-12/%E5%A4%B9%E8%A7%92%E6%B3%95.png)

### 详细步骤

1. 计算点与多边形各顶点的向量。
2. 计算相邻向量之间的夹角。
3. 判断夹角之和是否为 360 度。

### 示例代码

```typescript
// 计算两个向量之间的夹角
// v1, v2: 两个二维向量
// 返回值: 两个向量的夹角(弧度)
function vectorAngle(v1: [number, number], v2: [number, number]): number {
  // 计算点积
  const dotProduct = v1[0] * v2[0] + v1[1] * v2[1];
  // 计算叉积
  const crossProduct = v1[0] * v2[1] - v1[1] * v2[0];
  // 使用atan2计算夹角,范围为[-π,π]
  return Math.atan2(crossProduct, dotProduct);
}

// 使用夹角和判别法判断点是否在多边形内
// polygon: 多边形顶点数组
// point: 待判断的点
// 返回值: 点是否在多边形内
function isPointInsidePolygonAngle(polygon: [number, number][], point: [number, number]): boolean {
  let angleSum = 0; // 夹角和
  const n = polygon.length; // 多边形顶点数

  // 遍历多边形的每条边
  for (let i = 0; i < n; i++) {
    // 计算point到当前顶点的向量
    const v1: [number, number] = [polygon[i][0] - point[0], polygon[i][1] - point[1]];
    // 计算point到下一个顶点的向量
    const v2: [number, number] = [
      polygon[(i + 1) % n][0] - point[0],
      polygon[(i + 1) % n][1] - point[1],
    ];
    // 累加两个向量的夹角
    angleSum += vectorAngle(v1, v2);
  }

  // 判断夹角和是否接近2π(考虑浮点数误差)
  return Math.abs(Math.abs(angleSum) - 2 * Math.PI) < 1e-10;
}
```

## 引射线法

### 基本原理

最后一种方法原理是这样的：从点画一条射线线，看这条线和多边形边界相交多少次。如果是奇数次，说明点在内部；偶数次说明在外部。
![射线法](https://assets.npmstar.com/article-images/2024-12/%E5%B0%84%E7%BA%BF%E6%B3%95.png)

### 详细步骤

- 从点向任意方向引射线。
- 计算射线与多边形边的交点数。
- 判断交��数是否为奇数。

### 示例代码

```typescript
// 使用射线法判断点是否在多边形内
// polygon: 多边形顶点数组
// point: 待判断的点[x,y]
// 返回值: 点是否在多边形内
function isPointInsidePolygonRay(polygon: [number, number][], point: [number, number]): boolean {
  // 获取待判断点的坐标
  const [x, y] = point;
  // inside表示点是否在多边形内
  let inside = false;

  // 遍历多边形的每条边
  // j表示当前边的起点索引,i表示终点索引
  for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
    // 获取边的两个端点坐标
    const [xi, yi] = polygon[i];
    const [xj, yj] = polygon[j];

    // 判断射线是否与当前边相交
    // 条件1:点的y坐标在边的两个端点y坐标之间
    // 条件2:点的x坐标小于射线与边的交点的x坐标
    if (yi > y !== yj > y && x < ((xj - xi) * (y - yi)) / (yj - yi) + xi) {
      // 如果相交则改变inside的值
      inside = !inside;
    }
  }

  return inside;
}
```

## 5. 实际应用建议

这三种方法各有优缺点：

- 面积法：好理解，好实现，但有浮点数误差，适用于需要快速判断且对精度要求不是特别高的场景
- 夹角法：精确度高，但计算量大，涉及三角函数，适用于需要同时计算其他几何特征的场景
- 引射线法：通用性强，精度较好，实现相对复杂，适用于要求高精度的场景，特别是处理边界情况时

在实际开发中，要注意这些坑：

- JS 的浮点数精度问题，所以判断相等时要用一个很小的误差值
- 点正好在多边形边上的情况要特别处理
- 多边形顶点的顺序最好是顺时针或逆时针，不要乱序

以上介绍了三种判断点是否在凸多边形内的方法：面积和判别法、夹角和判别法以及引射线法。每种方法都有其优缺点，大家可以根据实际需求选择合适的方法。希望这篇文章对你有所帮助！


几何算法：如何判断一个点是否在一个凸多边形内

酷前端是一个专注前端2D3D图形开发的博客，涉及webgl、threejs、pixijs、konvajs等绘图技术、绘图引擎，以及math库、geometry算法库等。