geometry

package
v0.5.8 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 1, 2024 License: MIT Imports: 10 Imported by: 0

README

Geometry

Go doc

geometry 旨在提供一组用于处理几何形状和计算几何属性的函数和数据结构。该包旨在简化几何计算的过程，并提供一致的接口和易于使用的功能。 主要特性：

  • 几何形状："geometry"包支持处理各种几何形状，如点、线、多边形和圆等。您可以使用这些形状来表示和操作实际世界中的几何对象。
  • 几何计算：该包提供了一系列函数，用于执行常见的几何计算，如计算两点之间的距离、计算线段的长度、计算多边形的面积等。这些函数旨在提供高效和准确的计算结果。
  • 坐标转换："geometry"包还提供了一些函数，用于在不同坐标系之间进行转换。您可以将点从笛卡尔坐标系转换为极坐标系，或者从二维坐标系转换为三维坐标系等。
  • 简化接口：该包的设计目标之一是提供简化的接口，使几何计算变得更加直观和易于使用。您可以轻松地创建和操作几何对象，而无需处理繁琐的底层细节。

目录导航

列出了该 package 下所有的函数及类型定义，可通过目录导航进行快捷跳转 ❤️

展开 / 折叠目录导航

包级函数定义

函数名称 描述
NewCircle 通过传入圆的半径和需要的点数量，生成一个圆
CalcCircleCentroidDistance 计算两个圆质心距离
GetOppositionDirection 获取特定方向的对立方向
GetDirectionNextWithCoordinate 获取特定方向上的下一个坐标
GetDirectionNextWithPoint 获取特定方向上的下一个坐标
GetDirectionNextWithPos 获取位置在特定宽度和特定方向上的下一个位置
CalcDirection 计算点2位于点1的方向
CalcDistanceWithCoordinate 计算两点之间的距离
CalcDistanceWithPoint 计算两点之间的距离
CalcDistanceSquared 计算两点之间的平方距离
CalcAngle 计算点2位于点1之间的角度
CalcNewCoordinate 根据给定的x、y坐标、角度和距离计算新的坐标
CalcRadianWithAngle 根据角度 angle 计算弧度
CalcAngleDifference 计算两个角度之间的最小角度差
CalcRayIsIntersect 根据给定的位置和角度生成射线，检测射线是否与多边形发生碰撞
NewLineSegment 创建一根线段
NewLineSegmentCap 创建一根包含数据的线段
NewLineSegmentCapWithLine 通过已有线段创建一根包含数据的线段
ConvertLineSegmentGeneric 转换线段的泛型类型为特定类型
PointOnLineSegmentWithCoordinate 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
PointOnLineSegmentWithPos 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
PointOnLineSegmentWithPoint 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
PointOnLineSegmentWithCoordinateInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
PointOnLineSegmentWithPosInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
PointOnLineSegmentWithPointInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上
CalcLineSegmentIsCollinear 检查两条线段在一个误差内是否共线
CalcLineSegmentIsOverlap 通过对点进行排序来检查两条共线线段是否重叠，返回重叠线段
CalcLineSegmentIsIntersect 计算两条线段是否相交
CalcLineSegmentSlope 计算线段的斜率
CalcLineSegmentIntercept 计算线段的截距
NewPoint 创建一个由 x、y 坐标组成的点
NewPointCap 创建一个由 x、y 坐标组成的点，这个点具有一个数据容量
NewPointCapWithData 通过设置数据的方式创建一个由 x、y 坐标组成的点，这个点具有一个数据容量
NewPointCapWithPoint 通过设置数据的方式创建一个由已有坐标组成的点，这个点具有一个数据容量
CoordinateToPoint 将坐标转换为x、y的坐标数组
CoordinateToPos 将坐标转换为二维数组的顺序位置坐标
PointToCoordinate 将坐标数组转换为x和y坐标
PointToPos 将坐标转换为二维数组的顺序位置
PosToCoordinate 通过宽度将一个二维数组的顺序位置转换为xy坐标
PosToPoint 通过宽度将一个二维数组的顺序位置转换为x、y的坐标数组
PosToCoordinateX 通过宽度将一个二维数组的顺序位置转换为X坐标
PosToCoordinateY 通过宽度将一个二维数组的顺序位置转换为Y坐标
PointCopy 复制一个坐标数组
PointToPosWithMulti 将一组坐标转换为二维数组的顺序位置
PosToPointWithMulti 将一组二维数组的顺序位置转换为一组数组坐标
PosSameRow 返回两个顺序位置在同一宽度是否位于同一行
DoublePointToCoordinate 将两个位置转换为 x1, y1, x2, y2 的坐标进行返回
CalcProjectionPoint 计算一个点到一条线段的最近点（即投影点）的。这个函数接收一个点和一条线段作为输入，线段由两个端点组成。
GetAdjacentTranslatePos 获取一个连续位置的矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置
GetAdjacentTranslateCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置
GetAdjacentTranslateCoordinateYX 获取一个基于 y、x 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置
GetAdjacentDiagonalsPos 获取一个连续位置的矩阵中，特定位置相邻的对角线最多四个方向的位置
GetAdjacentDiagonalsCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置
GetAdjacentDiagonalsCoordinateYX 获取一个基于 tx 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置
GetAdjacentPos 获取一个连续位置的矩阵中，特定位置相邻的最多八个方向的位置
GetAdjacentCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多八个方向的位置
GetAdjacentCoordinateYX 获取一个基于 yx 的二维矩阵中，特定位置相邻的最多八个方向的位置
CoordinateMatrixToPosMatrix 将二维矩阵转换为顺序的二维矩阵
GetShapeCoverageAreaWithPoint 通过传入的一组坐标 points 计算一个图形覆盖的矩形范围
GetShapeCoverageAreaWithPos 通过传入的一组坐标 positions 计算一个图形覆盖的矩形范围
CoverageAreaBoundless 将一个图形覆盖矩形范围设置为无边的
GenerateShapeOnRectangle 生成一组二维坐标的形状
GenerateShapeOnRectangleWithCoordinate 生成一组二维坐标的形状
GetExpressibleRectangleBySize 获取一个宽高可表达的所有特定尺寸以上的矩形形状
GetExpressibleRectangle 获取一个宽高可表达的所有矩形形状
GetRectangleFullPointsByXY 通过开始结束坐标获取一个矩形包含的所有点
GetRectangleFullPoints 获取一个矩形填充满后包含的所有点
GetRectangleFullPos 获取一个矩形填充满后包含的所有位置
CalcRectangleCentroid 计算矩形质心
SetShapeStringHasBorder 设置 Shape.String 是拥有边界的
SetShapeStringNotHasBorder 设置 Shape.String 是没有边界的
NewShape 通过多个点生成一个形状进行返回
NewShapeWithString 通过字符串将指定 rune 转换为点位置生成形状进行返回
CalcBoundingRadius 计算多边形转换为圆的半径
CalcBoundingRadiusWithCentroid 计算多边形在特定质心下圆的半径
CalcTriangleTwiceArea 计算由 a、b、c 三个点组成的三角形的面积的两倍
IsPointOnEdge 检查点是否在 edges 的任意一条边上
ProjectionPointToShape 将一个点投影到一个多边形上，找到离该点最近的投影点，并返回投影点和距离
WithShapeSearchRectangleLowerLimit 通过矩形宽高下限的方式搜索
WithShapeSearchRectangleUpperLimit 通过矩形宽高上限的方式搜索
WithShapeSearchRightAngle 通过直角的方式进行搜索
WithShapeSearchOppositionDirection 通过限制对立方向的方式搜索
WithShapeSearchDirectionCount 通过限制方向数量的方式搜索
WithShapeSearchDirectionCountLowerLimit 通过限制特定方向数量下限的方式搜索
WithShapeSearchDirectionCountUpperLimit 通过限制特定方向数量上限的方式搜索
WithShapeSearchDeduplication 通过去重的方式进行搜索
WithShapeSearchPointCountLowerLimit 通过限制图形构成的最小点数进行搜索
WithShapeSearchPointCountUpperLimit 通过限制图形构成的最大点数进行搜索
WithShapeSearchAsc 通过升序的方式进行搜索
WithShapeSearchDesc 通过降序的方式进行搜索

类型定义

类型 名称 描述
STRUCT Circle 圆形
STRUCT FloorPlan 平面图
STRUCT Direction 方向
STRUCT LineSegment 通过两个点表示一根线段
STRUCT LineSegmentCap 可以包含一份额外数据的线段
STRUCT Point 表示了一个由 x、y 坐标组成的点
STRUCT PointCap 表示了一个由 x、y 坐标组成的点，这个点具有一个数据容量
STRUCT Shape 通过多个点表示了一个形状
STRUCT ShapeSearchOption 图形搜索可选项，用于 Shape.ShapeSearch 搜索支持

详情信息

func NewCircle[V generic.SignedNumber](radius V, points int) Circle[V]

通过传入圆的半径和需要的点数量，生成一个圆

示例代码：


func ExampleNewCircle() {
	fmt.Println(geometry.NewCircle[float64](7, 12))
}
func CalcCircleCentroidDistance[V generic.SignedNumber](circle1 Circle[V], circle2 Circle[V]) V

计算两个圆质心距离

func GetOppositionDirection(direction Direction) Direction

获取特定方向的对立方向

func GetDirectionNextWithCoordinate[V generic.SignedNumber](direction Direction, x V, y V) (nx V, ny V)

获取特定方向上的下一个坐标

func GetDirectionNextWithPoint[V generic.SignedNumber](direction Direction, point Point[V]) Point[V]

获取特定方向上的下一个坐标

func GetDirectionNextWithPos[V generic.SignedNumber](direction Direction, width V, pos V) V

获取位置在特定宽度和特定方向上的下一个位置

  • 需要注意的是，在左右方向时，当下一个位置不在矩形区域内时，将会返回上一行的末位置或下一行的首位置
func CalcDirection[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V) Direction

计算点2位于点1的方向

func CalcDistanceWithCoordinate[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V) V

计算两点之间的距离

func CalcDistanceWithPoint[V generic.SignedNumber](point1 Point[V], point2 Point[V]) V

计算两点之间的距离

func CalcDistanceSquared[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V) V

计算两点之间的平方距离

  • 这个函数的主要用途是在需要计算两点之间距离的情况下，但不需要得到实际的距离值，而只需要比较距离大小。因为平方根运算相对较为耗时，所以在只需要比较大小的情况下，通常会使用平方距离。
func CalcAngle[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V) V

计算点2位于点1之间的角度

func CalcNewCoordinate[V generic.SignedNumber](x V, y V, angle V, distance V) (newX V, newY V)

根据给定的x、y坐标、角度和距离计算新的坐标

func CalcRadianWithAngle[V generic.SignedNumber](angle V) V

根据角度 angle 计算弧度

func CalcAngleDifference[V generic.SignedNumber](angleA V, angleB V) V

计算两个角度之间的最小角度差

func CalcRayIsIntersect[V generic.SignedNumber](x V, y V, angle V, shape Shape[V]) bool

根据给定的位置和角度生成射线，检测射线是否与多边形发生碰撞

func NewLineSegment[V generic.SignedNumber](start Point[V], end Point[V]) LineSegment[V]

创建一根线段

func NewLineSegmentCap[V generic.SignedNumber, Data any](start Point[V], end Point[V], data Data) LineSegmentCap[V, Data]

创建一根包含数据的线段

func NewLineSegmentCapWithLine[V generic.SignedNumber, Data any](line LineSegment[V], data Data) LineSegmentCap[V, Data]

通过已有线段创建一根包含数据的线段

func ConvertLineSegmentGeneric[V generic.SignedNumber, TO generic.SignedNumber](line LineSegment[V]) LineSegment[TO]

转换线段的泛型类型为特定类型

func PointOnLineSegmentWithCoordinate[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V, x V, y V) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithPos[V generic.SignedNumber](width V, pos1 V, pos2 V, pos V) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithPoint[V generic.SignedNumber](point1 Point[V], point2 Point[V], point Point[V]) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithCoordinateInBounds[V generic.SignedNumber](x1 V, y1 V, x2 V, y2 V, x V, y V) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithCoordinate 不同的是， PointOnLineSegmentWithCoordinateInBounds 中会判断线段及点的位置是否正确
func PointOnLineSegmentWithPosInBounds[V generic.SignedNumber](width V, pos1 V, pos2 V, pos V) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithPos 不同的是， PointOnLineSegmentWithPosInBounds 中会判断线段及点的位置是否正确
func PointOnLineSegmentWithPointInBounds[V generic.SignedNumber](point1 Point[V], point2 Point[V], point Point[V]) bool

通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithPoint 不同的是， PointOnLineSegmentWithPointInBounds 中会判断线段及点的位置是否正确
func CalcLineSegmentIsCollinear[V generic.SignedNumber](line1 LineSegment[V], line2 LineSegment[V], tolerance V) bool

检查两条线段在一个误差内是否共线

  • 共线是指两条线段在同一直线上，即它们的延长线可以重合
func CalcLineSegmentIsOverlap[V generic.SignedNumber](line1 LineSegment[V], line2 LineSegment[V]) (line LineSegment[V], overlap bool)

通过对点进行排序来检查两条共线线段是否重叠，返回重叠线段

func CalcLineSegmentIsIntersect[V generic.SignedNumber](line1 LineSegment[V], line2 LineSegment[V]) bool

计算两条线段是否相交

查看 / 收起单元测试 

func TestCalcLineSegmentIsIntersect(t *testing.T) {
	line1 := geometry.NewLineSegment(geometry.NewPoint(1, 1), geometry.NewPoint(3, 5))
	line2 := geometry.NewLineSegment(geometry.NewPoint(0, 5), geometry.NewPoint(3, 6))
	fmt.Println(geometry.CalcLineSegmentIsIntersect(line1, line2))
}
func CalcLineSegmentSlope[V generic.SignedNumber](line LineSegment[V]) V

计算线段的斜率

func CalcLineSegmentIntercept[V generic.SignedNumber](line LineSegment[V]) V

计算线段的截距

func NewPoint[V generic.SignedNumber](x V, y V) Point[V]

创建一个由 x、y 坐标组成的点

查看 / 收起单元测试 

func TestNewPoint(t *testing.T) {
	p := [2]int{1, 1}
	fmt.Println(PointToPos(9, p))
}
func NewPointCap[V generic.SignedNumber, D any](x V, y V) PointCap[V, D]

创建一个由 x、y 坐标组成的点，这个点具有一个数据容量

func NewPointCapWithData[V generic.SignedNumber, D any](x V, y V, data D) PointCap[V, D]

通过设置数据的方式创建一个由 x、y 坐标组成的点，这个点具有一个数据容量

func NewPointCapWithPoint[V generic.SignedNumber, D any](point Point[V], data D) PointCap[V, D]

通过设置数据的方式创建一个由已有坐标组成的点，这个点具有一个数据容量

func CoordinateToPoint[V generic.SignedNumber](x V, y V) Point[V]

将坐标转换为x、y的坐标数组

func CoordinateToPos[V generic.SignedNumber](width V, x V, y V) V

将坐标转换为二维数组的顺序位置坐标

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值
func PointToCoordinate[V generic.SignedNumber](position Point[V]) (x V, y V)

将坐标数组转换为x和y坐标

func PointToPos[V generic.SignedNumber](width V, xy Point[V]) V

将坐标转换为二维数组的顺序位置

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值
func PosToCoordinate[V generic.SignedNumber](width V, pos V) (x V, y V)

通过宽度将一个二维数组的顺序位置转换为xy坐标

func PosToPoint[V generic.SignedNumber](width V, pos V) Point[V]

通过宽度将一个二维数组的顺序位置转换为x、y的坐标数组

func PosToCoordinateX[V generic.SignedNumber](width V, pos V) V

通过宽度将一个二维数组的顺序位置转换为X坐标

func PosToCoordinateY[V generic.SignedNumber](width V, pos V) V

通过宽度将一个二维数组的顺序位置转换为Y坐标

func PointCopy[V generic.SignedNumber](point Point[V]) Point[V]

复制一个坐标数组

func PointToPosWithMulti[V generic.SignedNumber](width V, points ...Point[V]) []V

将一组坐标转换为二维数组的顺序位置

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值
func PosToPointWithMulti[V generic.SignedNumber](width V, positions ...V) []Point[V]

将一组二维数组的顺序位置转换为一组数组坐标

func PosSameRow[V generic.SignedNumber](width V, pos1 V, pos2 V) bool

返回两个顺序位置在同一宽度是否位于同一行

func DoublePointToCoordinate[V generic.SignedNumber](point1 Point[V], point2 Point[V]) (x1 V, y1 V, x2 V, y2 V)

将两个位置转换为 x1, y1, x2, y2 的坐标进行返回

func CalcProjectionPoint[V generic.SignedNumber](line LineSegment[V], point Point[V]) Point[V]

计算一个点到一条线段的最近点（即投影点）的。这个函数接收一个点和一条线段作为输入，线段由两个端点组成。

  • 该函数的主要用于需要计算一个点到一条线段的最近点的情况下
func GetAdjacentTranslatePos[T any, P generic.SignedNumber](matrix []T, width P, pos P) (result []P)

获取一个连续位置的矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetAdjacentTranslateCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetAdjacentTranslateCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 y、x 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetAdjacentDiagonalsPos[T any, P generic.SignedNumber](matrix []T, width P, pos P) (result []P)

获取一个连续位置的矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentDiagonalsCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 x、y 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentDiagonalsCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 tx 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentPos[T any, P generic.SignedNumber](matrix []T, width P, pos P) (result []P)

获取一个连续位置的矩阵中，特定位置相邻的最多八个方向的位置

func GetAdjacentCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多八个方向的位置

func GetAdjacentCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x P, y P) (result []Point[P])

获取一个基于 yx 的二维矩阵中，特定位置相邻的最多八个方向的位置

func CoordinateMatrixToPosMatrix[V any](matrix [][]V) (width int, posMatrix []V)

将二维矩阵转换为顺序的二维矩阵

func GetShapeCoverageAreaWithPoint[V generic.SignedNumber](points ...Point[V]) (left V, right V, top V, bottom V)

通过传入的一组坐标 points 计算一个图形覆盖的矩形范围

示例代码：


func ExampleGetShapeCoverageAreaWithPoint() {
	var points []geometry.Point[int]
	points = append(points, geometry.NewPoint(1, 1))
	points = append(points, geometry.NewPoint(2, 1))
	points = append(points, geometry.NewPoint(2, 2))
	left, right, top, bottom := geometry.GetShapeCoverageAreaWithPoint(points...)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))
}
查看 / 收起单元测试 

func TestGetShapeCoverageAreaWithPoint(t *testing.T) {
	Convey("TestGetShapeCoverageAreaWithPoint", t, func() {
		var points []geometry.Point[int]
		points = append(points, geometry.NewPoint(1, 1))
		points = append(points, geometry.NewPoint(2, 1))
		points = append(points, geometry.NewPoint(2, 2))
		left, right, top, bottom := geometry.GetShapeCoverageAreaWithPoint(points...)
		So(left, ShouldEqual, 1)
		So(right, ShouldEqual, 2)
		So(top, ShouldEqual, 1)
		So(bottom, ShouldEqual, 2)
	})
}
func GetShapeCoverageAreaWithPos[V generic.SignedNumber](width V, positions ...V) (left V, right V, top V, bottom V)

通过传入的一组坐标 positions 计算一个图形覆盖的矩形范围

示例代码：


func ExampleGetShapeCoverageAreaWithPos() {
	left, right, top, bottom := geometry.GetShapeCoverageAreaWithPos(3, 4, 7, 8)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))
}
查看 / 收起单元测试 

func TestGetShapeCoverageAreaWithPos(t *testing.T) {
	Convey("TestGetShapeCoverageAreaWithPos", t, func() {
		left, right, top, bottom := geometry.GetShapeCoverageAreaWithPos(3, 4, 7, 8)
		So(left, ShouldEqual, 1)
		So(right, ShouldEqual, 2)
		So(top, ShouldEqual, 1)
		So(bottom, ShouldEqual, 2)
	})
}
func CoverageAreaBoundless[V generic.SignedNumber](l V, r V, t V, b V) (left V, right V, top V, bottom V)

将一个图形覆盖矩形范围设置为无边的

  • 无边化表示会将多余的部分进行裁剪，例如图形左边从 2 开始的时候，那么左边将会被裁剪到从 0 开始

示例代码：


func ExampleCoverageAreaBoundless() {
	left, right, top, bottom := geometry.CoverageAreaBoundless(1, 2, 1, 2)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))
}
查看 / 收起单元测试 

func TestCoverageAreaBoundless(t *testing.T) {
	Convey("TestCoverageAreaBoundless", t, func() {
		left, right, top, bottom := geometry.CoverageAreaBoundless(1, 2, 1, 2)
		So(left, ShouldEqual, 0)
		So(right, ShouldEqual, 1)
		So(top, ShouldEqual, 0)
		So(bottom, ShouldEqual, 1)
	})
}
func GenerateShapeOnRectangle[V generic.SignedNumber](points ...Point[V]) (result []PointCap[V, bool])

生成一组二维坐标的形状

  • 这个形状将被在一个刚好能容纳形状的矩形中表示
  • 为 true 的位置表示了形状的每一个点
查看 / 收起单元测试 

func TestGenerateShapeOnRectangle(t *testing.T) {
	Convey("TestGenerateShapeOnRectangle", t, func() {
		var points geometry.Shape[int]
		points = append(points, geometry.NewPoint(1, 1))
		points = append(points, geometry.NewPoint(2, 1))
		points = append(points, geometry.NewPoint(2, 2))
		fmt.Println(points)
		ps := geometry.GenerateShapeOnRectangle(points.Points()...)
		So(ps[0].GetX(), ShouldEqual, 0)
		So(ps[0].GetY(), ShouldEqual, 0)
		So(ps[0].GetData(), ShouldEqual, true)
		So(ps[1].GetX(), ShouldEqual, 1)
		So(ps[1].GetY(), ShouldEqual, 0)
		So(ps[1].GetData(), ShouldEqual, true)
		So(ps[2].GetX(), ShouldEqual, 0)
		So(ps[2].GetY(), ShouldEqual, 1)
		So(ps[2].GetData(), ShouldEqual, false)
		So(ps[3].GetX(), ShouldEqual, 1)
		So(ps[3].GetY(), ShouldEqual, 1)
		So(ps[3].GetData(), ShouldEqual, true)
	})
}
func GenerateShapeOnRectangleWithCoordinate[V generic.SignedNumber](points ...Point[V]) (result [][]bool)

生成一组二维坐标的形状

  • 这个形状将被在一个刚好能容纳形状的矩形中表示
  • 为 true 的位置表示了形状的每一个点
func GetExpressibleRectangleBySize[V generic.SignedNumber](width V, height V, minWidth V, minHeight V) (result []Point[V])

获取一个宽高可表达的所有特定尺寸以上的矩形形状

  • 返回值表示了每一个矩形右下角的x,y位置（左上角始终为0, 0）
  • 矩形尺寸由大到小
func GetExpressibleRectangle[V generic.SignedNumber](width V, height V) (result []Point[V])

获取一个宽高可表达的所有矩形形状

  • 返回值表示了每一个矩形右下角的x,y位置（左上角始终为0, 0）
  • 矩形尺寸由大到小
func GetRectangleFullPointsByXY[V generic.SignedNumber](startX V, startY V, endX V, endY V) (result []Point[V])

通过开始结束坐标获取一个矩形包含的所有点

  • 例如 1,1 到 2,2 的矩形结果为 1,1 2,1 1,2 2,2
func GetRectangleFullPoints[V generic.SignedNumber](width V, height V) (result []Point[V])

获取一个矩形填充满后包含的所有点

func GetRectangleFullPos[V generic.SignedNumber](width V, height V) (result []V)

获取一个矩形填充满后包含的所有位置

func CalcRectangleCentroid[V generic.SignedNumber](shape Shape[V]) Point[V]

计算矩形质心

  • 非多边形质心计算，仅为顶点的平均值 - 该区域中多边形因子的适当质心
func SetShapeStringHasBorder()

设置 Shape.String 是拥有边界的

func SetShapeStringNotHasBorder()

设置 Shape.String 是没有边界的

func NewShape[V generic.SignedNumber](points ...Point[V]) Shape[V]

通过多个点生成一个形状进行返回

示例代码：


func ExampleNewShape() {
	shape := geometry.NewShape[int](geometry.NewPoint(3, 0), geometry.NewPoint(3, 1), geometry.NewPoint(3, 2), geometry.NewPoint(3, 3), geometry.NewPoint(4, 3))
	fmt.Println(shape)
}
查看 / 收起单元测试 

func TestNewShape(t *testing.T) {
	Convey("TestNewShape", t, func() {
		shape := geometry.NewShape[int](geometry.NewPoint(3, 0), geometry.NewPoint(3, 1), geometry.NewPoint(3, 2), geometry.NewPoint(3, 3), geometry.NewPoint(4, 3))
		fmt.Println(shape)
		points := shape.Points()
		count := shape.PointCount()
		So(count, ShouldEqual, 5)
		So(points[0], ShouldEqual, geometry.NewPoint(3, 0))
		So(points[1], ShouldEqual, geometry.NewPoint(3, 1))
		So(points[2], ShouldEqual, geometry.NewPoint(3, 2))
		So(points[3], ShouldEqual, geometry.NewPoint(3, 3))
		So(points[4], ShouldEqual, geometry.NewPoint(4, 3))
	})
}
func NewShapeWithString[V generic.SignedNumber](rows []string, point rune) (shape Shape[V])

通过字符串将指定 rune 转换为点位置生成形状进行返回

  • 每个点的顺序从上到下，从左到右

示例代码：


func ExampleNewShapeWithString() {
	shape := geometry.NewShapeWithString[int]([]string{"###X###", "###X###", "###X###", "###XX##"}, 'X')
	fmt.Println(shape)
}
查看 / 收起单元测试 

func TestNewShapeWithString(t *testing.T) {
	Convey("TestNewShapeWithString", t, func() {
		shape := geometry.NewShapeWithString[int]([]string{"###X###", "###X###", "###X###", "###XX##"}, 'X')
		points := shape.Points()
		count := shape.PointCount()
		So(count, ShouldEqual, 5)
		So(points[0], ShouldEqual, geometry.NewPoint(3, 0))
		So(points[1], ShouldEqual, geometry.NewPoint(3, 1))
		So(points[2], ShouldEqual, geometry.NewPoint(3, 2))
		So(points[3], ShouldEqual, geometry.NewPoint(3, 3))
		So(points[4], ShouldEqual, geometry.NewPoint(4, 3))
	})
}
func CalcBoundingRadius[V generic.SignedNumber](shape Shape[V]) V

计算多边形转换为圆的半径

func CalcBoundingRadiusWithCentroid[V generic.SignedNumber](shape Shape[V], centroid Point[V]) V

计算多边形在特定质心下圆的半径

func CalcTriangleTwiceArea[V generic.SignedNumber](a Point[V], b Point[V], c Point[V]) V

计算由 a、b、c 三个点组成的三角形的面积的两倍

func IsPointOnEdge[V generic.SignedNumber](edges []LineSegment[V], point Point[V]) bool

检查点是否在 edges 的任意一条边上

func ProjectionPointToShape[V generic.SignedNumber](point Point[V], shape Shape[V]) (Point[V], V)

将一个点投影到一个多边形上，找到离该点最近的投影点，并返回投影点和距离

func WithShapeSearchRectangleLowerLimit(minWidth int, minHeight int) ShapeSearchOption

通过矩形宽高下限的方式搜索

func WithShapeSearchRectangleUpperLimit(maxWidth int, maxHeight int) ShapeSearchOption

通过矩形宽高上限的方式搜索

func WithShapeSearchRightAngle() ShapeSearchOption

通过直角的方式进行搜索

func WithShapeSearchOppositionDirection(direction Direction) ShapeSearchOption

通过限制对立方向的方式搜索

  • 对立方向例如上不能与下共存
func WithShapeSearchDirectionCount(count int) ShapeSearchOption

通过限制方向数量的方式搜索

func WithShapeSearchDirectionCountLowerLimit(direction Direction, count int) ShapeSearchOption

通过限制特定方向数量下限的方式搜索

func WithShapeSearchDirectionCountUpperLimit(direction Direction, count int) ShapeSearchOption

通过限制特定方向数量上限的方式搜索

func WithShapeSearchDeduplication() ShapeSearchOption

通过去重的方式进行搜索

  • 去重方式中每个点仅会被使用一次
func WithShapeSearchPointCountLowerLimit(lowerLimit int) ShapeSearchOption

通过限制图形构成的最小点数进行搜索

  • 当搜索到的图形的点数量低于 lowerLimit 时，将被忽略
func WithShapeSearchPointCountUpperLimit(upperLimit int) ShapeSearchOption

通过限制图形构成的最大点数进行搜索

  • 当搜索到的图形的点数量大于 upperLimit 时，将被忽略
func WithShapeSearchAsc() ShapeSearchOption

通过升序的方式进行搜索

func WithShapeSearchDesc() ShapeSearchOption

通过降序的方式进行搜索

Circle STRUCT

圆形

type Circle[V generic.SignedNumber] struct {
	Shape[V]
}

func (Circle) Radius() V

获取圆形半径

func (Circle) Centroid() Point[V]

获取圆形质心位置

func (Circle) Overlap(circle Circle[V]) bool

与另一个圆是否发生重叠

func (Circle) Area() V

获取圆形面积

func (Circle) Length() V

获取圆的周长

func (Circle) CentroidDistance(circle Circle[V]) V

计算与另一个圆的质心距离

FloorPlan STRUCT

平面图

type FloorPlan []string

func (FloorPlan) IsFree(point Point[int]) bool

检查位置是否为空格

func (FloorPlan) IsInBounds(point Point[int]) bool

检查位置是否在边界内

func (FloorPlan) Put(point Point[int], c rune)

设置平面图特定位置的字符

func (FloorPlan) String() string

获取平面图结果

Direction STRUCT

方向

type Direction uint8

LineSegment STRUCT

通过两个点表示一根线段

type LineSegment[V generic.SignedNumber] [2]Point[V]

func (LineSegment) GetPoints() [2]Point[V]

获取该线段的两个点

func (LineSegment) GetStart() Point[V]

获取该线段的开始位置

func (LineSegment) GetEnd() Point[V]

获取该线段的结束位置

func (LineSegment) GetLength() V

获取该线段的长度

LineSegmentCap STRUCT

可以包含一份额外数据的线段

type LineSegmentCap[V generic.SignedNumber, Data any] struct {
	LineSegment[V]
	Data Data
}

func (*LineSegmentCap) GetData() Data

Point STRUCT

表示了一个由 x、y 坐标组成的点

type Point[V generic.SignedNumber] [2]V

func (Point) GetX() V

返回该点的 x 坐标

func (Point) GetY() V

返回该点的 y 坐标

func (Point) GetXY() (x V, y V)

返回该点的 x、y 坐标

func (Point) GetPos(width V) V

返回该点位于特定宽度的二维数组的顺序位置

func (Point) GetOffset(x V, y V) Point[V]

获取偏移后的新坐标

func (Point) Negative() bool

返回该点是否是一个负数坐标

func (Point) OutOf(minWidth V, minHeight V, maxWidth V, maxHeight V) bool

返回该点在特定宽高下是否越界f

func (Point) Equal(point Point[V]) bool

返回两个点是否相等

func (Point) Copy() Point[V]

复制一个点位置

func (Point) Add(point Point[V]) Point[V]

得到加上 point 后的点

func (Point) Sub(point Point[V]) Point[V]

得到减去 point 后的点

func (Point) Mul(point Point[V]) Point[V]

得到乘以 point 后的点

func (Point) Div(point Point[V]) Point[V]

得到除以 point 后的点

func (Point) Abs() Point[V]

返回位置的绝对值

func (Point) Max(point Point[V]) Point[V]

返回两个位置中每个维度的最大值组成的新的位置

func (Point) Min(point Point[V]) Point[V]

返回两个位置中每个维度的最小值组成的新的位置

PointCap STRUCT

表示了一个由 x、y 坐标组成的点，这个点具有一个数据容量

type PointCap[V generic.SignedNumber, D any] struct {
	Point[V]
	Data D
}

func (PointCap) GetData() D

获取数据

Shape STRUCT

通过多个点表示了一个形状

type Shape[V generic.SignedNumber] []Point[V]

func (Shape) Points() []Point[V]

获取这个形状的所有点

示例代码：


func ExampleShape_Points() {
	shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
	points := shape.Points()
	fmt.Println(points)
}
查看 / 收起单元测试 

func TestShape_Points(t *testing.T) {
	Convey("TestShape_Points", t, func() {
		shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
		points := shape.Points()
		So(points[0], ShouldEqual, geometry.NewPoint(3, 0))
		So(points[1], ShouldEqual, geometry.NewPoint(2, 1))
		So(points[2], ShouldEqual, geometry.NewPoint(3, 1))
		So(points[3], ShouldEqual, geometry.NewPoint(4, 1))
	})
}

func (Shape) PointCount() int

获取这个形状的点数量

示例代码：


func ExampleShape_PointCount() {
	shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
	fmt.Println(shape.PointCount())
}
查看 / 收起单元测试 

func TestShape_PointCount(t *testing.T) {
	Convey("TestShape_PointCount", t, func() {
		shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
		So(shape.PointCount(), ShouldEqual, 4)
	})
}

func (Shape) Contains(point Point[V]) bool

返回该形状中是否包含点

func (Shape) ToCircle() Circle[V]

将形状转换为圆形进行处理

  • 当形状非圆形时将会产生意外情况

func (Shape) String() string

将该形状转换为可视化的字符串进行返回

示例代码：


func ExampleShape_String() {
	shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
	fmt.Println(shape)
}
查看 / 收起单元测试 

func TestShape_String(t *testing.T) {
	Convey("TestShape_String", t, func() {
		shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##"}, 'X')
		str := shape.String()
		So(str, ShouldEqual, "[[3 0] [2 1] [3 1] [4 1]]\n# X #\nX X X")
	})
}

func (Shape) ShapeSearch(options ...ShapeSearchOption) (result []Shape[V])

获取该形状中包含的所有图形组合及其位置

  • 需要注意的是，即便图形最终表示为相同的，但是只要位置组合顺序不同，那么也将被认定为一种图形组合
  • [[1 0] [1 1] [1 2]] 和 [[1 1] [1 0] [1 2]] 可以被视为两个图形组合
  • 返回的坐标为原始形状的坐标

可通过可选项对搜索结果进行过滤

示例代码：


func ExampleShape_ShapeSearch() {
	shape := geometry.NewShapeWithString[int]([]string{"###X###", "##XXX##", "###X###"}, 'X')
	shapes := shape.ShapeSearch(geometry.WithShapeSearchDeduplication(), geometry.WithShapeSearchDesc())
	for _, shape := range shapes {
		fmt.Println(shape)
	}
}

func (Shape) Edges() (edges []LineSegment[V])

获取该形状每一条边

  • 该形状需要最少由3个点组成，否则将不会返回任意一边

func (Shape) IsPointOnEdge(point Point[V]) bool

检查点是否在该形状的一条边上

ShapeSearchOption STRUCT

图形搜索可选项，用于 Shape.ShapeSearch 搜索支持

type ShapeSearchOption func(options *shapeSearchOptions)

Documentation

Overview

Package geometry 旨在提供一组用于处理几何形状和计算几何属性的函数和数据结构。该包旨在简化几何计算的过程，并提供一致的接口和易于使用的功能。 主要特性：

  • 几何形状："geometry"包支持处理各种几何形状，如点、线、多边形和圆等。您可以使用这些形状来表示和操作实际世界中的几何对象。
  • 几何计算：该包提供了一系列函数，用于执行常见的几何计算，如计算两点之间的距离、计算线段的长度、计算多边形的面积等。这些函数旨在提供高效和准确的计算结果。
  • 坐标转换："geometry"包还提供了一些函数，用于在不同坐标系之间进行转换。您可以将点从笛卡尔坐标系转换为极坐标系，或者从二维坐标系转换为三维坐标系等。
  • 简化接口：该包的设计目标之一是提供简化的接口，使几何计算变得更加直观和易于使用。您可以轻松地创建和操作几何对象，而无需处理繁琐的底层细节。

Index

Examples

Constants

View Source 
const (
	DirectionUnknown = Direction(iota) // 未知
	DirectionUp                        // 上方
	DirectionDown                      // 下方
	DirectionLeft                      // 左方
	DirectionRight                     // 右方
)

Variables

View Source 
var (
	DirectionUDLR = []Direction{DirectionUp, DirectionDown, DirectionLeft, DirectionRight} // 上下左右四个方向的数组
	DirectionLRUD = []Direction{DirectionLeft, DirectionRight, DirectionUp, DirectionDown} // 左右上下四个方向的数组
)
View Source 
var (
	// ErrUnexplainedDirection 错误的方向
	ErrUnexplainedDirection = errors.New("unexplained direction")
)

Functions

func CalcAngle 

func CalcAngle[V generic.SignedNumber](x1, y1, x2, y2 V) V

CalcAngle 计算点2位于点1之间的角度

func CalcAngleDifference 

func CalcAngleDifference[V generic.SignedNumber](angleA, angleB V) V

CalcAngleDifference 计算两个角度之间的最小角度差

func CalcBoundingRadius 

func CalcBoundingRadius[V generic.SignedNumber](shape Shape[V]) V

CalcBoundingRadius 计算多边形转换为圆的半径，即外接圆的半径

func CalcBoundingRadiusWithCentroid 

func CalcBoundingRadiusWithCentroid[V generic.SignedNumber](shape Shape[V], centroid Point[V]) V

CalcBoundingRadiusWithCentroid 计算多边形在特定质心下圆的半径

func CalcBoundingRadiusWithWidthAndHeight added in v0.5.4 

func CalcBoundingRadiusWithWidthAndHeight[V generic.SignedNumber](width, height V) V

CalcBoundingRadiusWithWidthAndHeight 计算多边形转换为圆的半径，即外接圆的半径

func CalcCircleCentroidDistance 

func CalcCircleCentroidDistance[V generic.SignedNumber](circle1, circle2 Circle[V]) V

CalcCircleCentroidDistance 计算两个圆质心距离

func CalcDistanceSquared 

func CalcDistanceSquared[V generic.SignedNumber](x1, y1, x2, y2 V) V

CalcDistanceSquared 计算两点之间的平方距离

  • 这个函数的主要用途是在需要计算两点之间距离的情况下，但不需要得到实际的距离值，而只需要比较距离大小。因为平方根运算相对较为耗时，所以在只需要比较大小的情况下，通常会使用平方距离。

func CalcDistanceWithCoordinate 

func CalcDistanceWithCoordinate[V generic.SignedNumber](x1, y1, x2, y2 V) V

CalcDistanceWithCoordinate 计算两点之间的距离

func CalcDistanceWithPoint 

func CalcDistanceWithPoint[V generic.SignedNumber](point1, point2 Point[V]) V

CalcDistanceWithPoint 计算两点之间的距离

func CalcLineSegmentIntercept 

func CalcLineSegmentIntercept[V generic.SignedNumber](line LineSegment[V]) V

CalcLineSegmentIntercept 计算线段的截距

func CalcLineSegmentIsCollinear 

func CalcLineSegmentIsCollinear[V generic.SignedNumber](line1, line2 LineSegment[V], tolerance V) bool

CalcLineSegmentIsCollinear 检查两条线段在一个误差内是否共线

  • 共线是指两条线段在同一直线上，即它们的延长线可以重合

func CalcLineSegmentIsIntersect 

func CalcLineSegmentIsIntersect[V generic.SignedNumber](line1, line2 LineSegment[V]) bool

CalcLineSegmentIsIntersect 计算两条线段是否相交

func CalcLineSegmentSlope 

func CalcLineSegmentSlope[V generic.SignedNumber](line LineSegment[V]) V

CalcLineSegmentSlope 计算线段的斜率

func CalcNewCoordinate 

func CalcNewCoordinate[V generic.SignedNumber](x, y, angle, distance V) (newX, newY V)

CalcNewCoordinate 根据给定的x、y坐标、角度和距离计算新的坐标

func CalcRadianWithAngle 

func CalcRadianWithAngle[V generic.SignedNumber](angle V) V

CalcRadianWithAngle 根据角度 angle 计算弧度

func CalcRayIsIntersect 

func CalcRayIsIntersect[V generic.SignedNumber](x, y, angle V, shape Shape[V]) bool

CalcRayIsIntersect 根据给定的位置和角度生成射线，检测射线是否与多边形发生碰撞

func CalcTriangleTwiceArea 

func CalcTriangleTwiceArea[V generic.SignedNumber](a, b, c Point[V]) V

CalcTriangleTwiceArea 计算由 a、b、c 三个点组成的三角形的面积的两倍

func CoordinateMatrixToPosMatrix 

func CoordinateMatrixToPosMatrix[V any](matrix [][]V) (width int, posMatrix []V)

CoordinateMatrixToPosMatrix 将二维矩阵转换为顺序的二维矩阵

func CoordinateToPos 

func CoordinateToPos[V generic.SignedNumber](width, x, y V) V

CoordinateToPos 将坐标转换为二维数组的顺序位置坐标

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值

func CoverageAreaBoundless 

func CoverageAreaBoundless[V generic.SignedNumber](l, r, t, b V) (left, right, top, bottom V)

CoverageAreaBoundless 将一个图形覆盖矩形范围设置为无边的

  • 无边化表示会将多余的部分进行裁剪，例如图形左边从 2 开始的时候，那么左边将会被裁剪到从 0 开始
Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	// # # #
	// # X #
	// # X X

	//   ↓

	// X #
	// X X

	left, right, top, bottom := geometry.CoverageAreaBoundless(1, 2, 1, 2)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))

	// left: 0, right: 1, top: 0, bottom: 1
}

Output:

func DoublePointToCoordinate 

func DoublePointToCoordinate[V generic.SignedNumber](point1, point2 Point[V]) (x1, y1, x2, y2 V)

DoublePointToCoordinate 将两个位置转换为 x1, y1, x2, y2 的坐标进行返回

func GenerateShapeOnRectangleWithCoordinate 

func GenerateShapeOnRectangleWithCoordinate[V generic.SignedNumber](points ...Point[V]) (result [][]bool)

GenerateShapeOnRectangleWithCoordinate 生成一组二维坐标的形状

  • 这个形状将被在一个刚好能容纳形状的矩形中表示
  • 为 true 的位置表示了形状的每一个点

func GetAdjacentDiagonalsPos 

func GetAdjacentDiagonalsPos[T any, P generic.SignedNumber](matrix []T, width, pos P) (result []P)

GetAdjacentDiagonalsPos 获取一个连续位置的矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentPos 

func GetAdjacentPos[T any, P generic.SignedNumber](matrix []T, width, pos P) (result []P)

GetAdjacentPos 获取一个连续位置的矩阵中，特定位置相邻的最多八个方向的位置

func GetAdjacentTranslatePos 

func GetAdjacentTranslatePos[T any, P generic.SignedNumber](matrix []T, width, pos P) (result []P)

GetAdjacentTranslatePos 获取一个连续位置的矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetDirectionNextWithCoordinate 

func GetDirectionNextWithCoordinate[V generic.SignedNumber](direction Direction, x, y V) (nx, ny V)

GetDirectionNextWithCoordinate 获取特定方向上的下一个坐标

func GetDirectionNextWithPos 

func GetDirectionNextWithPos[V generic.SignedNumber](direction Direction, width, pos V) V

GetDirectionNextWithPos 获取位置在特定宽度和特定方向上的下一个位置

  • 需要注意的是，在左右方向时，当下一个位置不在矩形区域内时，将会返回上一行的末位置或下一行的首位置

func GetRectangleFullPos 

func GetRectangleFullPos[V generic.SignedNumber](width, height V) (result []V)

GetRectangleFullPos 获取一个矩形填充满后包含的所有位置

func GetShapeCoverageAreaWithPoint 

func GetShapeCoverageAreaWithPoint[V generic.SignedNumber](points ...Point[V]) (left, right, top, bottom V)

GetShapeCoverageAreaWithPoint 通过传入的一组坐标 points 计算一个图形覆盖的矩形范围

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	// # # #
	// # X #
	// # X X

	var points []geometry.Point[int]
	points = append(points, geometry.NewPoint(1, 1))
	points = append(points, geometry.NewPoint(2, 1))
	points = append(points, geometry.NewPoint(2, 2))

	left, right, top, bottom := geometry.GetShapeCoverageAreaWithPoint(points...)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))

	// left: 1, right: 2, top: 1, bottom: 2
}

Output:

func GetShapeCoverageAreaWithPos 

func GetShapeCoverageAreaWithPos[V generic.SignedNumber](width V, positions ...V) (left, right, top, bottom V)

GetShapeCoverageAreaWithPos 通过传入的一组坐标 positions 计算一个图形覆盖的矩形范围

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	// # # #    0 1 2
	// # X #    3 4 5
	// # X X    6 7 8

	left, right, top, bottom := geometry.GetShapeCoverageAreaWithPos(3, 4, 7, 8)
	fmt.Println(fmt.Sprintf("left: %v, right: %v, top: %v, bottom: %v", left, right, top, bottom))

	// left: 1, right: 2, top: 1, bottom: 2
}

Output:

func IsPointOnEdge 

func IsPointOnEdge[V generic.SignedNumber](edges []LineSegment[V], point Point[V]) bool

IsPointOnEdge 检查点是否在 edges 的任意一条边上

func PointOnLineSegmentWithCoordinate 

func PointOnLineSegmentWithCoordinate[V generic.SignedNumber](x1, y1, x2, y2, x, y V) bool

PointOnLineSegmentWithCoordinate 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithCoordinateInBounds 

func PointOnLineSegmentWithCoordinateInBounds[V generic.SignedNumber](x1, y1, x2, y2, x, y V) bool

PointOnLineSegmentWithCoordinateInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithCoordinate 不同的是， PointOnLineSegmentWithCoordinateInBounds 中会判断线段及点的位置是否正确

func PointOnLineSegmentWithPoint 

func PointOnLineSegmentWithPoint[V generic.SignedNumber](point1, point2, point Point[V]) bool

PointOnLineSegmentWithPoint 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithPointInBounds 

func PointOnLineSegmentWithPointInBounds[V generic.SignedNumber](point1, point2, point Point[V]) bool

PointOnLineSegmentWithPointInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithPoint 不同的是， PointOnLineSegmentWithPointInBounds 中会判断线段及点的位置是否正确

func PointOnLineSegmentWithPos 

func PointOnLineSegmentWithPos[V generic.SignedNumber](width, pos1, pos2, pos V) bool

PointOnLineSegmentWithPos 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

func PointOnLineSegmentWithPosInBounds 

func PointOnLineSegmentWithPosInBounds[V generic.SignedNumber](width, pos1, pos2, pos V) bool

PointOnLineSegmentWithPosInBounds 通过一个线段两个点的位置和一个点的坐标，判断这个点是否在一条线段上

  • 与 PointOnLineSegmentWithPos 不同的是， PointOnLineSegmentWithPosInBounds 中会判断线段及点的位置是否正确

func PointToCoordinate 

func PointToCoordinate[V generic.SignedNumber](position Point[V]) (x, y V)

PointToCoordinate 将坐标数组转换为x和y坐标

func PointToPos 

func PointToPos[V generic.SignedNumber](width V, xy Point[V]) V

PointToPos 将坐标转换为二维数组的顺序位置

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值

func PointToPosWithMulti 

func PointToPosWithMulti[V generic.SignedNumber](width V, points ...Point[V]) []V

PointToPosWithMulti 将一组坐标转换为二维数组的顺序位置

  • 需要确保x的取值范围必须小于width，或者将会得到不正确的值

func PosSameRow 

func PosSameRow[V generic.SignedNumber](width, pos1, pos2 V) bool

PosSameRow 返回两个顺序位置在同一宽度是否位于同一行

func PosToCoordinate 

func PosToCoordinate[V generic.SignedNumber](width, pos V) (x, y V)

PosToCoordinate 通过宽度将一个二维数组的顺序位置转换为xy坐标

func PosToCoordinateX 

func PosToCoordinateX[V generic.SignedNumber](width, pos V) V

PosToCoordinateX 通过宽度将一个二维数组的顺序位置转换为X坐标

func PosToCoordinateY 

func PosToCoordinateY[V generic.SignedNumber](width, pos V) V

PosToCoordinateY 通过宽度将一个二维数组的顺序位置转换为Y坐标

func SetShapeStringHasBorder 

func SetShapeStringHasBorder()

SetShapeStringHasBorder 设置 Shape.String 是拥有边界的

func SetShapeStringNotHasBorder 

func SetShapeStringNotHasBorder()

SetShapeStringNotHasBorder 设置 Shape.String 是没有边界的

Types

type Circle 

type Circle[V generic.SignedNumber] struct {
	Shape[V]
}

Circle 由多个点组成的圆形数据结构

func NewCircle 

func NewCircle[V generic.SignedNumber](radius V, points int) Circle[V]

NewCircle 通过传入圆的半径和需要的点数量，生成一个圆

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	fmt.Println(geometry.NewCircle[float64](7, 12))

}

Output:

[[0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [0 0] [7 0] [6.062177826491071 3.4999999999999996] [3.500000000000001 6.06217782649107] [4.28626379701573e-16 7] [-3.4999999999999982 6.062177826491071] [-6.0621778264910695 3.500000000000002] [-7 8.57252759403146e-16] [-6.062177826491071 -3.4999999999999982] [-3.500000000000003 -6.062177826491069] [-1.285879139104719e-15 -7] [3.499999999999995 -6.062177826491074] [6.062177826491069 -3.500000000000003]]
# # # # # # # X # # # # # # #
# # # # X # # # # # X # # # #
# # # # # # # # # # # # # # #
# # # # # # # # # # # # # # #
# X # # # # # # # # # # # X #
# # # # # # # # # # # # # # #
# # # # # # # # # # # # # # #
X # # # # # # X # # # # # # X
# # # # # # # # # # # # # # #
# # # # # # # # # # # # # # #
# X # # # # # # # # # # # X #
# # # # # # # # # # # # # # #
# # # # # # # # # # # # # # #
# # # # X # # # # # X # # # #
# # # # # # # X # # # # # # #

func (Circle[V]) Area 

func (slf Circle[V]) Area() V

Area 获取圆形面积

func (Circle[V]) Centroid 

func (slf Circle[V]) Centroid() Point[V]

Centroid 获取圆形质心位置

func (Circle[V]) CentroidDistance 

func (slf Circle[V]) CentroidDistance(circle Circle[V]) V

CentroidDistance 计算与另一个圆的质心距离

func (Circle[V]) Length 

func (slf Circle[V]) Length() V

Length 获取圆的周长

func (Circle[V]) Overlap 

func (slf Circle[V]) Overlap(circle Circle[V]) bool

Overlap 与另一个圆是否发生重叠

func (Circle[V]) Radius 

func (slf Circle[V]) Radius() V

Radius 获取圆形半径

type Direction 

type Direction uint8

Direction 方向

func CalcDirection 

func CalcDirection[V generic.SignedNumber](x1, y1, x2, y2 V) Direction

CalcDirection 计算点2位于点1的方向

func GetOppositionDirection 

func GetOppositionDirection(direction Direction) Direction

GetOppositionDirection 获取特定方向的对立方向

type FloorPlan 

type FloorPlan []string

FloorPlan 平面图

func (FloorPlan) IsFree 

func (slf FloorPlan) IsFree(point Point[int]) bool

IsFree 检查位置是否为空格

func (FloorPlan) IsInBounds 

func (slf FloorPlan) IsInBounds(point Point[int]) bool

IsInBounds 检查位置是否在边界内

func (FloorPlan) Put 

func (slf FloorPlan) Put(point Point[int], c rune)

Put 设置平面图特定位置的字符

func (FloorPlan) String 

func (slf FloorPlan) String() string

String 获取平面图结果

type LineSegment 

type LineSegment[V generic.SignedNumber] [2]Point[V]

LineSegment 通过两个点表示一根线段

func CalcLineSegmentIsOverlap 

func CalcLineSegmentIsOverlap[V generic.SignedNumber](line1, line2 LineSegment[V]) (line LineSegment[V], overlap bool)

CalcLineSegmentIsOverlap 通过对点进行排序来检查两条共线线段是否重叠，返回重叠线段

func ConvertLineSegmentGeneric 

func ConvertLineSegmentGeneric[V generic.SignedNumber, TO generic.SignedNumber](line LineSegment[V]) LineSegment[TO]

ConvertLineSegmentGeneric 转换线段的泛型类型为特定类型

func NewLineSegment 

func NewLineSegment[V generic.SignedNumber](start, end Point[V]) LineSegment[V]

NewLineSegment 创建一根线段

func (LineSegment[V]) GetEnd 

func (slf LineSegment[V]) GetEnd() Point[V]

GetEnd 获取该线段的结束位置

func (LineSegment[V]) GetLength 

func (slf LineSegment[V]) GetLength() V

GetLength 获取该线段的长度

func (LineSegment[V]) GetPoints 

func (slf LineSegment[V]) GetPoints() [2]Point[V]

GetPoints 获取该线段的两个点

func (LineSegment[V]) GetStart 

func (slf LineSegment[V]) GetStart() Point[V]

GetStart 获取该线段的开始位置

type LineSegmentCap 

type LineSegmentCap[V generic.SignedNumber, Data any] struct {
	LineSegment[V]
	Data Data
}

LineSegmentCap 可以包含一份额外数据的线段

func NewLineSegmentCap 

func NewLineSegmentCap[V generic.SignedNumber, Data any](start, end Point[V], data Data) LineSegmentCap[V, Data]

NewLineSegmentCap 创建一根包含数据的线段

func NewLineSegmentCapWithLine 

func NewLineSegmentCapWithLine[V generic.SignedNumber, Data any](line LineSegment[V], data Data) LineSegmentCap[V, Data]

NewLineSegmentCapWithLine 通过已有线段创建一根包含数据的线段

func (*LineSegmentCap[V, Data]) GetData 

func (slf *LineSegmentCap[V, Data]) GetData() Data

type Point 

type Point[V generic.SignedNumber] [2]V

Point 表示了一个由 x、y 坐标组成的点

func CalcProjectionPoint 

func CalcProjectionPoint[V generic.SignedNumber](line LineSegment[V], point Point[V]) Point[V]

CalcProjectionPoint 计算一个点到一条线段的最近点（即投影点）的。这个函数接收一个点和一条线段作为输入，线段由两个端点组成。

  • 该函数的主要用于需要计算一个点到一条线段的最近点的情况下

func CalcRectangleCentroid 

func CalcRectangleCentroid[V generic.SignedNumber](shape Shape[V]) Point[V]

CalcRectangleCentroid 计算矩形质心

  • 非多边形质心计算，仅为顶点的平均值 - 该区域中多边形因子的适当质心

func CoordinateToPoint 

func CoordinateToPoint[V generic.SignedNumber](x, y V) Point[V]

CoordinateToPoint 将坐标转换为x、y的坐标数组

func GetAdjacentCoordinateXY 

func GetAdjacentCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多八个方向的位置

func GetAdjacentCoordinateYX 

func GetAdjacentCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentCoordinateYX 获取一个基于 yx 的二维矩阵中，特定位置相邻的最多八个方向的位置

func GetAdjacentDiagonalsCoordinateXY 

func GetAdjacentDiagonalsCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentDiagonalsCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentDiagonalsCoordinateYX 

func GetAdjacentDiagonalsCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentDiagonalsCoordinateYX 获取一个基于 tx 的二维矩阵中，特定位置相邻的对角线最多四个方向的位置

func GetAdjacentTranslateCoordinateXY 

func GetAdjacentTranslateCoordinateXY[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentTranslateCoordinateXY 获取一个基于 x、y 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetAdjacentTranslateCoordinateYX 

func GetAdjacentTranslateCoordinateYX[T any, P generic.SignedNumber](matrix [][]T, x, y P) (result []Point[P])

GetAdjacentTranslateCoordinateYX 获取一个基于 y、x 的二维矩阵中，特定位置相邻的最多四个平移方向（上下左右）的位置

func GetDirectionNextWithPoint 

func GetDirectionNextWithPoint[V generic.SignedNumber](direction Direction, point Point[V]) Point[V]

GetDirectionNextWithPoint 获取特定方向上的下一个坐标

func GetExpressibleRectangle 

func GetExpressibleRectangle[V generic.SignedNumber](width, height V) (result []Point[V])

GetExpressibleRectangle 获取一个宽高可表达的所有矩形形状

  • 返回值表示了每一个矩形右下角的x,y位置（左上角始终为0, 0）
  • 矩形尺寸由大到小

func GetExpressibleRectangleBySize 

func GetExpressibleRectangleBySize[V generic.SignedNumber](width, height, minWidth, minHeight V) (result []Point[V])

GetExpressibleRectangleBySize 获取一个宽高可表达的所有特定尺寸以上的矩形形状

  • 返回值表示了每一个矩形右下角的x,y位置（左上角始终为0, 0）
  • 矩形尺寸由大到小

func GetRectangleFullPoints 

func GetRectangleFullPoints[V generic.SignedNumber](width, height V) (result []Point[V])

GetRectangleFullPoints 获取一个矩形填充满后包含的所有点

func GetRectangleFullPointsByXY 

func GetRectangleFullPointsByXY[V generic.SignedNumber](startX, startY, endX, endY V) (result []Point[V])

GetRectangleFullPointsByXY 通过开始结束坐标获取一个矩形包含的所有点

  • 例如 1,1 到 2,2 的矩形结果为 1,1 2,1 1,2 2,2

func NewPoint 

func NewPoint[V generic.SignedNumber](x, y V) Point[V]

NewPoint 创建一个由 x、y 坐标组成的点

func PointCopy 

func PointCopy[V generic.SignedNumber](point Point[V]) Point[V]

PointCopy 复制一个坐标数组

func PosToPoint 

func PosToPoint[V generic.SignedNumber](width, pos V) Point[V]

PosToPoint 通过宽度将一个二维数组的顺序位置转换为x、y的坐标数组

func PosToPointWithMulti 

func PosToPointWithMulti[V generic.SignedNumber](width V, positions ...V) []Point[V]

PosToPointWithMulti 将一组二维数组的顺序位置转换为一组数组坐标

func ProjectionPointToShape 

func ProjectionPointToShape[V generic.SignedNumber](point Point[V], shape Shape[V]) (Point[V], V)

ProjectionPointToShape 将一个点投影到一个多边形上，找到离该点最近的投影点，并返回投影点和距离

func (Point[V]) Abs 

func (slf Point[V]) Abs() Point[V]

Abs 返回位置的绝对值

func (Point[V]) Add 

func (slf Point[V]) Add(point Point[V]) Point[V]

Add 得到加上 point 后的点

func (Point[V]) Copy 

func (slf Point[V]) Copy() Point[V]

Copy 复制一个点位置

func (Point[V]) Distance added in v0.5.4 

func (slf Point[V]) Distance(point Point[V]) float64

Distance 返回两个点之间的距离

func (Point[V]) DistanceSquared added in v0.5.4 

func (slf Point[V]) DistanceSquared(point Point[V]) V

DistanceSquared 返回两个点之间的距离的平方

func (Point[V]) Div 

func (slf Point[V]) Div(point Point[V]) Point[V]

Div 得到除以 point 后的点

func (Point[V]) Equal 

func (slf Point[V]) Equal(point Point[V]) bool

Equal 返回两个点是否相等

func (Point[V]) GetOffset 

func (slf Point[V]) GetOffset(x, y V) Point[V]

GetOffset 获取偏移后的新坐标

func (Point[V]) GetPos 

func (slf Point[V]) GetPos(width V) V

GetPos 返回该点位于特定宽度的二维数组的顺序位置

func (Point[V]) GetX 

func (slf Point[V]) GetX() V

GetX 返回该点的 x 坐标

func (Point[V]) GetXY 

func (slf Point[V]) GetXY() (x, y V)

GetXY 返回该点的 x、y 坐标

func (Point[V]) GetY 

func (slf Point[V]) GetY() V

GetY 返回该点的 y 坐标

func (Point[V]) Max 

func (slf Point[V]) Max(point Point[V]) Point[V]

Max 返回两个位置中每个维度的最大值组成的新的位置

func (Point[V]) Min 

func (slf Point[V]) Min(point Point[V]) Point[V]

Min 返回两个位置中每个维度的最小值组成的新的位置

func (Point[V]) Move added in v0.5.4 

func (slf Point[V]) Move(angle, direction V) Point[V]

Move 返回向特定角度移动特定距离后的新的位置，其中 angle 期待的角度范围是 -180~180

func (Point[V]) Mul 

func (slf Point[V]) Mul(point Point[V]) Point[V]

Mul 得到乘以 point 后的点

func (Point[V]) Negative 

func (slf Point[V]) Negative() bool

Negative 返回该点是否是一个负数坐标

func (Point[V]) OutOf 

func (slf Point[V]) OutOf(minWidth, minHeight, maxWidth, maxHeight V) bool

OutOf 返回该点在特定宽高下是否越界f

func (Point[V]) Sub 

func (slf Point[V]) Sub(point Point[V]) Point[V]

Sub 得到减去 point 后的点

type PointCap 

type PointCap[V generic.SignedNumber, D any] struct {
	Point[V]
	Data D
}

PointCap 表示了一个由 x、y 坐标组成的点，这个点具有一个数据容量

func GenerateShapeOnRectangle 

func GenerateShapeOnRectangle[V generic.SignedNumber](points ...Point[V]) (result []PointCap[V, bool])

GenerateShapeOnRectangle 生成一组二维坐标的形状

  • 这个形状将被在一个刚好能容纳形状的矩形中表示
  • 为 true 的位置表示了形状的每一个点

func NewPointCap 

func NewPointCap[V generic.SignedNumber, D any](x, y V) PointCap[V, D]

NewPointCap 创建一个由 x、y 坐标组成的点，这个点具有一个数据容量

func NewPointCapWithData 

func NewPointCapWithData[V generic.SignedNumber, D any](x, y V, data D) PointCap[V, D]

NewPointCapWithData 通过设置数据的方式创建一个由 x、y 坐标组成的点，这个点具有一个数据容量

func NewPointCapWithPoint 

func NewPointCapWithPoint[V generic.SignedNumber, D any](point Point[V], data D) PointCap[V, D]

NewPointCapWithPoint 通过设置数据的方式创建一个由已有坐标组成的点，这个点具有一个数据容量

func (PointCap[V, D]) GetData 

func (slf PointCap[V, D]) GetData() D

GetData 获取数据

type Shape 

type Shape[V generic.SignedNumber] []Point[V]

Shape 通过多个点表示了一个形状

func NewShape 

func NewShape[V generic.SignedNumber](points ...Point[V]) Shape[V]

NewShape 通过多个点生成一个形状进行返回

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShape[int](
		geometry.NewPoint(3, 0),
		geometry.NewPoint(3, 1),
		geometry.NewPoint(3, 2),
		geometry.NewPoint(3, 3),
		geometry.NewPoint(4, 3),
	)

	fmt.Println(shape)

}

Output:

[[3 0] [3 1] [3 2] [3 3] [4 3]]
X #
X #
X #
X X

func NewShapeWithString 

func NewShapeWithString[V generic.SignedNumber](rows []string, point rune) (shape Shape[V])

NewShapeWithString 通过字符串将指定 rune 转换为点位置生成形状进行返回

  • 每个点的顺序从上到下，从左到右
Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShapeWithString[int]([]string{
		"###X###",
		"###X###",
		"###X###",
		"###XX##",
	}, 'X')

	fmt.Println(shape)

}

Output:

[[3 0] [3 1] [3 2] [3 3] [4 3]]
X #
X #
X #
X X

func (Shape[V]) Contains 

func (slf Shape[V]) Contains(point Point[V]) bool

Contains 返回该形状中是否包含点

func (Shape[V]) Edges 

func (slf Shape[V]) Edges() (edges []LineSegment[V])

Edges 获取该形状每一条边

  • 该形状需要最少由3个点组成，否则将不会返回任意一边

func (Shape[V]) IsPointOnEdge 

func (slf Shape[V]) IsPointOnEdge(point Point[V]) bool

IsPointOnEdge 检查点是否在该形状的一条边上

func (Shape[V]) PointCount 

func (slf Shape[V]) PointCount() int

PointCount 获取这个形状的点数量

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShapeWithString[int]([]string{
		"###X###",
		"##XXX##",
	}, 'X')

	fmt.Println(shape.PointCount())

}

Output:

4

func (Shape[V]) Points 

func (slf Shape[V]) Points() []Point[V]

Points 获取这个形状的所有点

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShapeWithString[int]([]string{
		"###X###",
		"##XXX##",
	}, 'X')

	points := shape.Points()

	fmt.Println(points)

}

Output:

[[3 0] [2 1] [3 1] [4 1]]

func (Shape[V]) ShapeSearch 

func (slf Shape[V]) ShapeSearch(options ...ShapeSearchOption) (result []Shape[V])

ShapeSearch 获取该形状中包含的所有图形组合及其位置

  • 需要注意的是，即便图形最终表示为相同的，但是只要位置组合顺序不同，那么也将被认定为一种图形组合
  • [[1 0] [1 1] [1 2]] 和 [[1 1] [1 0] [1 2]] 可以被视为两个图形组合
  • 返回的坐标为原始形状的坐标

可通过可选项对搜索结果进行过滤

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShapeWithString[int]([]string{
		"###X###",
		"##XXX##",
		"###X###",
	}, 'X')

	shapes := shape.ShapeSearch(
		geometry.WithShapeSearchDeduplication(),
		geometry.WithShapeSearchDesc(),
	)
	for _, shape := range shapes {
		fmt.Println(shape)
	}

}

Output:

[[3 0] [3 2] [2 1] [4 1] [3 1]]
# X #
X X X
# X #

func (Shape[V]) String 

func (slf Shape[V]) String() string

String 将该形状转换为可视化的字符串进行返回

Example 
package main

import (
	"fmt"
	"github.com/kercylan98/minotaur/utils/geometry"
)

func main() {
	shape := geometry.NewShapeWithString[int]([]string{
		"###X###",
		"##XXX##",
	}, 'X')

	fmt.Println(shape)

}

Output:

[[3 0] [2 1] [3 1] [4 1]]
# X #
X X X

func (Shape[V]) ToCircle 

func (slf Shape[V]) ToCircle() Circle[V]

ToCircle 将形状转换为圆形进行处理

  • 当形状非圆形时将会产生意外情况

type ShapeSearchOption 

type ShapeSearchOption func(options *shapeSearchOptions)

ShapeSearchOption 图形搜索可选项，用于 Shape.ShapeSearch 搜索支持

func WithShapeSearchAsc 

func WithShapeSearchAsc() ShapeSearchOption

WithShapeSearchAsc 通过升序的方式进行搜索

func WithShapeSearchDeduplication 

func WithShapeSearchDeduplication() ShapeSearchOption

WithShapeSearchDeduplication 通过去重的方式进行搜索

  • 去重方式中每个点仅会被使用一次

func WithShapeSearchDesc 

func WithShapeSearchDesc() ShapeSearchOption

WithShapeSearchDesc 通过降序的方式进行搜索

func WithShapeSearchDirectionCount 

func WithShapeSearchDirectionCount(count int) ShapeSearchOption

WithShapeSearchDirectionCount 通过限制方向数量的方式搜索

func WithShapeSearchDirectionCountLowerLimit 

func WithShapeSearchDirectionCountLowerLimit(direction Direction, count int) ShapeSearchOption

WithShapeSearchDirectionCountLowerLimit 通过限制特定方向数量下限的方式搜索

func WithShapeSearchDirectionCountUpperLimit 

func WithShapeSearchDirectionCountUpperLimit(direction Direction, count int) ShapeSearchOption

WithShapeSearchDirectionCountUpperLimit 通过限制特定方向数量上限的方式搜索

func WithShapeSearchOppositionDirection 

func WithShapeSearchOppositionDirection(direction Direction) ShapeSearchOption

WithShapeSearchOppositionDirection 通过限制对立方向的方式搜索

  • 对立方向例如上不能与下共存

func WithShapeSearchPointCountLowerLimit 

func WithShapeSearchPointCountLowerLimit(lowerLimit int) ShapeSearchOption

WithShapeSearchPointCountLowerLimit 通过限制图形构成的最小点数进行搜索

  • 当搜索到的图形的点数量低于 lowerLimit 时，将被忽略

func WithShapeSearchPointCountUpperLimit 

func WithShapeSearchPointCountUpperLimit(upperLimit int) ShapeSearchOption

WithShapeSearchPointCountUpperLimit 通过限制图形构成的最大点数进行搜索

  • 当搜索到的图形的点数量大于 upperLimit 时，将被忽略

func WithShapeSearchRectangleLowerLimit 

func WithShapeSearchRectangleLowerLimit(minWidth, minHeight int) ShapeSearchOption

WithShapeSearchRectangleLowerLimit 通过矩形宽高下限的方式搜索

func WithShapeSearchRectangleUpperLimit 

func WithShapeSearchRectangleUpperLimit(maxWidth, maxHeight int) ShapeSearchOption

WithShapeSearchRectangleUpperLimit 通过矩形宽高上限的方式搜索

func WithShapeSearchRightAngle 

func WithShapeSearchRightAngle() ShapeSearchOption

WithShapeSearchRightAngle 通过直角的方式进行搜索

type SimpleCircle added in v0.5.4 

type SimpleCircle[V generic.SignedNumber] struct {
	// contains filtered or unexported fields
}

SimpleCircle 仅由位置和半径组成的圆形数据结构

func NewSimpleCircle added in v0.5.4 

func NewSimpleCircle[V generic.SignedNumber](radius V, centroid Point[V]) SimpleCircle[V]

NewSimpleCircle 通过传入圆的半径和圆心位置，生成一个圆

func (SimpleCircle[V]) Area added in v0.5.4 

func (sc SimpleCircle[V]) Area() V

Area 获取圆形面积

func (SimpleCircle[V]) Centroid added in v0.5.4 

func (sc SimpleCircle[V]) Centroid() Point[V]

Centroid 获取圆形质心位置

func (SimpleCircle[V]) CentroidDistance added in v0.5.4 

func (sc SimpleCircle[V]) CentroidDistance(circle SimpleCircle[V]) float64

CentroidDistance 计算与另一个圆的质心距离

func (SimpleCircle[V]) CentroidX added in v0.5.4 

func (sc SimpleCircle[V]) CentroidX() V

CentroidX 获取圆形质心位置的 X 坐标

func (SimpleCircle[V]) CentroidXY added in v0.5.4 

func (sc SimpleCircle[V]) CentroidXY() (V, V)

CentroidXY 获取圆形质心位置的 X、Y 坐标

func (SimpleCircle[V]) CentroidY added in v0.5.4 

func (sc SimpleCircle[V]) CentroidY() V

CentroidY 获取圆形质心位置的 Y 坐标

func (SimpleCircle[V]) IsZero added in v0.5.4 

func (sc SimpleCircle[V]) IsZero() bool

IsZero 反映该圆形是否为零值的无效圆形

func (SimpleCircle[V]) Length added in v0.5.4 

func (sc SimpleCircle[V]) Length() V

Length 获取圆的周长

func (SimpleCircle[V]) Overlap added in v0.5.4 

func (sc SimpleCircle[V]) Overlap(circle SimpleCircle[V]) bool

Overlap 与另一个圆是否发生重叠

func (SimpleCircle[V]) PointIsIn added in v0.5.4 

func (sc SimpleCircle[V]) PointIsIn(pos Point[V]) bool

PointIsIn 检查特定点是否位于圆内

func (SimpleCircle[V]) Projection added in v0.5.4 

func (sc SimpleCircle[V]) Projection(circle SimpleCircle[V], ratio float64) SimpleCircle[V]

Projection 获取圆形投影到另一个圆形的特定比例下的位置和半径（同心合并）

func (SimpleCircle[V]) Radius added in v0.5.4 

func (sc SimpleCircle[V]) Radius() V

Radius 获取圆形半径

func (SimpleCircle[V]) RandomCircleWithinParent added in v0.5.4 

func (sc SimpleCircle[V]) RandomCircleWithinParent(radius V) SimpleCircle[V]

RandomCircleWithinParent 根据指定半径，生成一个圆内随机子圆，该圆不会超出父圆

func (SimpleCircle[V]) RandomPoint added in v0.5.4 

func (sc SimpleCircle[V]) RandomPoint() Point[V]

RandomPoint 获取圆内随机点

func (SimpleCircle[V]) RandomPointWithinCircle added in v0.5.4 

func (sc SimpleCircle[V]) RandomPointWithinCircle(radius V) Point[V]

RandomPointWithinCircle 获取圆内随机点，且该圆在 radius 小于父圆时不会超出父圆

func (SimpleCircle[V]) RandomPointWithinRadius added in v0.5.4 

func (sc SimpleCircle[V]) RandomPointWithinRadius(radius V) Point[V]

RandomPointWithinRadius 获取圆内随机点，且该点与圆心的距离小于等于指定半径

func (SimpleCircle[V]) RandomPointWithinRadiusAndSector added in v0.5.4 

func (sc SimpleCircle[V]) RandomPointWithinRadiusAndSector(radius, startAngle, endAngle V) Point[V]

RandomPointWithinRadiusAndSector 获取圆内随机点，且距离圆心小于等于指定半径，且角度在指定范围内

  • startAngle: 起始角度，取值范围为 0 到 360 度
  • endAngle: 结束角度，取值范围为 0 到 360 度，且大于起始角度

func (SimpleCircle[V]) String added in v0.5.4 

func (sc SimpleCircle[V]) String() string

String 获取圆形的字符串表示

func (SimpleCircle[V]) ZoomRadius added in v0.5.4 

func (sc SimpleCircle[V]) ZoomRadius(zoom float64) V

ZoomRadius 获取缩放后的半径

Source Files

View all Source files

Directories

Path Synopsis
Package astar 提供用于实现 A* 算法的函数和数据结构。
 Package astar 提供用于实现 A* 算法的函数和数据结构。
Package dp (DistributionPattern) 提供用于在二维数组中根据不同的特征标记为数组成员建立分布链接的函数和数据结构。
 Package dp (DistributionPattern) 提供用于在二维数组中根据不同的特征标记为数组成员建立分布链接的函数和数据结构。
Package matrix 提供了一个简单的二维数组的实现
 Package matrix 提供了一个简单的二维数组的实现
Package navmesh 提供了用于导航网格处理的函数和数据结构。
 Package navmesh 提供了用于导航网格处理的函数和数据结构。

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.