kercylan98
483 lines
14 KiB
Go
483 lines
14 KiB
Go
package geometry
|
|
|
|
import (
|
|
"bytes"
|
|
"fmt"
|
|
"github.com/kercylan98/minotaur/utils/collection"
|
|
"github.com/kercylan98/minotaur/utils/generic"
|
|
"math"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
var (
|
|
shapeStringHasBorder = false // 控制 Shape.String 是否拥有边界
|
|
)
|
|
|
|
// SetShapeStringHasBorder 设置 Shape.String 是拥有边界的
|
|
func SetShapeStringHasBorder() {
|
|
shapeStringHasBorder = true
|
|
}
|
|
|
|
// SetShapeStringNotHasBorder 设置 Shape.String 是没有边界的
|
|
func SetShapeStringNotHasBorder() {
|
|
shapeStringHasBorder = false
|
|
}
|
|
|
|
// NewShape 通过多个点生成一个形状进行返回
|
|
func NewShape[V generic.SignedNumber](points ...Point[V]) Shape[V] {
|
|
return points
|
|
}
|
|
|
|
// NewShapeWithString 通过字符串将指定 rune 转换为点位置生成形状进行返回
|
|
// - 每个点的顺序从上到下，从左到右
|
|
func NewShapeWithString[V generic.SignedNumber](rows []string, point rune) (shape Shape[V]) {
|
|
var width int
|
|
for _, row := range rows {
|
|
length := len(row)
|
|
if length > width {
|
|
width = length
|
|
}
|
|
}
|
|
for y := 0; y < len(rows); y++ {
|
|
runes := bytes.Runes([]byte(rows[y]))
|
|
for x := 0; x < width; x++ {
|
|
if x >= len(runes) {
|
|
break
|
|
}
|
|
if point == runes[x] {
|
|
shape = append(shape, NewPoint(V(x), V(y)))
|
|
}
|
|
}
|
|
}
|
|
|
|
return shape
|
|
}
|
|
|
|
// Shape 通过多个点表示了一个形状
|
|
type Shape[V generic.SignedNumber] []Point[V]
|
|
|
|
// Points 获取这个形状的所有点
|
|
func (slf Shape[V]) Points() []Point[V] {
|
|
return slf
|
|
}
|
|
|
|
// PointCount 获取这个形状的点数量
|
|
func (slf Shape[V]) PointCount() int {
|
|
return len(slf)
|
|
}
|
|
|
|
// Contains 返回该形状中是否包含点
|
|
func (slf Shape[V]) Contains(point Point[V]) bool {
|
|
x, y := point.GetXY()
|
|
inside := false
|
|
for i, j := 0, len(slf)-1; i < len(slf); i, j = i+1, i {
|
|
ix := slf[i].GetX()
|
|
iy := slf[i].GetY()
|
|
jx := slf[j].GetX()
|
|
jy := slf[j].GetY()
|
|
|
|
if ((iy <= y && y < jy) || (jy <= y && y < iy)) && x < ((jx-ix)*(y-iy))/(jy-iy)+ix {
|
|
inside = !inside
|
|
}
|
|
}
|
|
return inside
|
|
}
|
|
|
|
// ToCircle 将形状转换为圆形进行处理
|
|
// - 当形状非圆形时将会产生意外情况
|
|
func (slf Shape[V]) ToCircle() Circle[V] {
|
|
return Circle[V]{Shape: slf}
|
|
}
|
|
|
|
// String 将该形状转换为可视化的字符串进行返回
|
|
func (slf Shape[V]) String() string {
|
|
var result string
|
|
left, right, top, bottom := GetShapeCoverageAreaWithPoint(slf.Points()...)
|
|
width := right - left + 1
|
|
height := bottom - top + 1
|
|
if !shapeStringHasBorder {
|
|
for y := top; y < top+height; y++ {
|
|
for x := left; x < left+width; x++ {
|
|
exist := false
|
|
for _, p := range slf {
|
|
if int(x) == int(p.GetX()) && int(y) == int(p.GetY()) {
|
|
exist = true
|
|
break
|
|
}
|
|
}
|
|
if exist {
|
|
result += "X "
|
|
} else {
|
|
result += "# "
|
|
}
|
|
}
|
|
result = result[:len(result)-1]
|
|
result += "\n"
|
|
}
|
|
} else {
|
|
if left < 0 {
|
|
left += -left
|
|
right += -left
|
|
}
|
|
if top < 0 {
|
|
top += -top
|
|
bottom += -top
|
|
}
|
|
for y := V(0); y < top+height; y++ {
|
|
for x := V(0); x < left+width; x++ {
|
|
exist := false
|
|
for _, p := range slf {
|
|
if x == p.GetX() && y == p.GetY() {
|
|
exist = true
|
|
break
|
|
}
|
|
}
|
|
if exist {
|
|
result += "X "
|
|
} else {
|
|
result += "# "
|
|
}
|
|
}
|
|
result = result[:len(result)-1]
|
|
result += "\n"
|
|
}
|
|
}
|
|
return fmt.Sprintf("%v\n%s", slf.Points(), strings.TrimSuffix(result, "\n"))
|
|
}
|
|
|
|
// ShapeSearch 获取该形状中包含的所有图形组合及其位置
|
|
// - 需要注意的是，即便图形最终表示为相同的，但是只要位置组合顺序不同，那么也将被认定为一种图形组合
|
|
// - [[1 0] [1 1] [1 2]] 和 [[1 1] [1 0] [1 2]] 可以被视为两个图形组合
|
|
// - 返回的坐标为原始形状的坐标
|
|
//
|
|
// 可通过可选项对搜索结果进行过滤
|
|
func (slf Shape[V]) ShapeSearch(options ...ShapeSearchOption) (result []Shape[V]) {
|
|
opt := newShapeSearchOptions()
|
|
opt.directionCountUpper = map[Direction]int{}
|
|
for _, d := range DirectionUDLR {
|
|
opt.directionCountUpper[d] = math.MaxInt
|
|
}
|
|
|
|
for _, option := range options {
|
|
option(opt)
|
|
}
|
|
|
|
var shapes []Shape[V]
|
|
switch opt.sort {
|
|
case 1:
|
|
shapes = slf.getAllGraphicCompositionWithAsc(opt)
|
|
case -1:
|
|
shapes = slf.getAllGraphicCompositionWithDesc(opt)
|
|
default:
|
|
shapes = slf.getAllGraphicComposition(opt)
|
|
}
|
|
result = shapes
|
|
|
|
if opt.deduplication {
|
|
deduplication := make(map[V]struct{})
|
|
w := V(len(slf.Points()))
|
|
|
|
var notRepeat = make([]Shape[V], 0, len(result))
|
|
for _, points := range result {
|
|
count := len(points)
|
|
if count < opt.lowerLimit || count > opt.upperLimit {
|
|
continue
|
|
}
|
|
var match = true
|
|
for _, point := range points {
|
|
pos := point.GetPos(w)
|
|
if _, exist := deduplication[pos]; exist {
|
|
match = false
|
|
break
|
|
}
|
|
deduplication[pos] = struct{}{}
|
|
}
|
|
if match {
|
|
notRepeat = append(notRepeat, points)
|
|
}
|
|
}
|
|
|
|
result = notRepeat
|
|
} else {
|
|
limit := make([]Shape[V], 0, len(result))
|
|
for _, shape := range result {
|
|
count := len(shape.Points())
|
|
if count < opt.lowerLimit || count > opt.upperLimit {
|
|
continue
|
|
}
|
|
limit = append(limit, shape)
|
|
}
|
|
result = limit
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// getAllGraphicComposition 获取该形状中包含的所有图形组合及其位置
|
|
// - 需要注意的是，即便图形最终表示为相同的，但是只要位置组合顺序不同，那么也将被认定为一种图形组合
|
|
// - [[1 0] [1 1] [1 2]] 和 [[1 1] [1 0] [1 2]] 可以被视为两个图形组合
|
|
// - 返回的坐标为原始形状的坐标
|
|
func (slf Shape[V]) getAllGraphicComposition(opt *shapeSearchOptions) (result []Shape[V]) {
|
|
left, right, top, bottom := GetShapeCoverageAreaWithPoint(slf.Points()...)
|
|
width := right - left + 1
|
|
height := bottom - top + 1
|
|
areaWidth := width + left
|
|
areaHeight := height + top
|
|
rectangleShape := GenerateShapeOnRectangleWithCoordinate(slf.Points()...)
|
|
records := make(map[V]struct{})
|
|
|
|
var match = func(links Shape[V], directionCount map[Direction]int, count int) bool {
|
|
if opt.rectangle {
|
|
return false
|
|
}
|
|
match := true
|
|
for _, direction := range DirectionUDLR {
|
|
c := directionCount[direction]
|
|
if c < opt.directionCountLower[direction] || c > opt.directionCountUpper[direction] {
|
|
match = false
|
|
break
|
|
}
|
|
}
|
|
|
|
if opt.directionCount > 0 && len(directionCount) != opt.directionCount {
|
|
match = false
|
|
}
|
|
|
|
if directionCount[GetOppositionDirection(opt.oppositionDirection)] > 0 {
|
|
match = false
|
|
}
|
|
|
|
if opt.ra {
|
|
match = false
|
|
if directionCount[DirectionLeft] > 0 && directionCount[DirectionUp] > 0 && count == directionCount[DirectionLeft]+directionCount[DirectionUp] {
|
|
match = true
|
|
} else if directionCount[DirectionUp] > 0 && directionCount[DirectionRight] > 0 && count == directionCount[DirectionUp]+directionCount[DirectionRight] {
|
|
match = true
|
|
} else if directionCount[DirectionRight] > 0 && directionCount[DirectionDown] > 0 && count == directionCount[DirectionRight]+directionCount[DirectionDown] {
|
|
match = true
|
|
} else if directionCount[DirectionDown] > 0 && directionCount[DirectionLeft] > 0 && count == directionCount[DirectionDown]+directionCount[DirectionLeft] {
|
|
match = true
|
|
}
|
|
}
|
|
|
|
if match {
|
|
result = append(result, links)
|
|
}
|
|
return match
|
|
}
|
|
|
|
if opt.rectangle {
|
|
l, r, t, b := GetShapeCoverageAreaWithPoint(slf.Points()...)
|
|
rs := GenerateShapeOnRectangleWithCoordinate(slf.Points()...)
|
|
w := r - l + 1
|
|
h := b - t + 1
|
|
shapes := GetExpressibleRectangleBySize(w, h, V(opt.rectangleMinWidth), V(opt.rectangleMinHeight))
|
|
for _, s := range shapes {
|
|
x, y := 0, 0
|
|
for {
|
|
if V(x)+s.GetX() >= w {
|
|
x = 0
|
|
y++
|
|
}
|
|
if V(y)+s.GetY() >= h {
|
|
break
|
|
}
|
|
points := GetRectangleFullPoints(s[0]+1, s[1]+1)
|
|
find := 0
|
|
for _, point := range points {
|
|
px, py := PointToCoordinate(point)
|
|
ox, oy := px+V(x), py+V(y)
|
|
if !rs[int(ox)][int(oy)] {
|
|
find = 0
|
|
break
|
|
}
|
|
find++
|
|
}
|
|
if find == len(points) {
|
|
sw := s.GetX() + 1
|
|
sh := s.GetY() + 1
|
|
if !(sw < V(opt.rectangleMinWidth) || sw > V(opt.rectangleMaxWidth) || sh < V(opt.rectangleMinHeight) || sh > V(opt.rectangleMaxHeight)) {
|
|
result = append(result, points)
|
|
}
|
|
}
|
|
|
|
x++
|
|
}
|
|
}
|
|
} else {
|
|
for _, point := range slf.Points() {
|
|
// 搜索四个方向
|
|
var next = -1
|
|
var directionPoint = point
|
|
var links = Shape[V]{}
|
|
var linkRecord = map[V]struct{}{}
|
|
var directionCount = map[Direction]int{}
|
|
var count = 0
|
|
for i, directions := range [][]Direction{DirectionUDLR, DirectionLRUD} {
|
|
var direction Direction
|
|
for {
|
|
next, direction = collection.FindLoopedNextInSlice(directions, next)
|
|
for {
|
|
directionPoint = GetDirectionNextWithPoint(direction, directionPoint)
|
|
if px, py := directionPoint.GetXY(); px < 0 || px >= areaWidth || py < 0 || py >= areaHeight {
|
|
break
|
|
}
|
|
offset := directionPoint.GetOffset(-left, -top)
|
|
if offset.OutOf(V(0), V(0), width, height) || !rectangleShape[int(offset.GetX())][int(offset.GetY())] {
|
|
break
|
|
}
|
|
recordPos := directionPoint.GetPos(areaWidth)
|
|
if _, exist := linkRecord[recordPos]; !exist {
|
|
linkRecord[recordPos] = struct{}{}
|
|
links = append(links, directionPoint)
|
|
directionCount[direction]++
|
|
count++
|
|
match(links, directionCount, count)
|
|
}
|
|
|
|
pos := directionPoint.GetPos(areaWidth)
|
|
if _, exist := records[pos]; !exist && opt.directionCount < 1 {
|
|
result = append(result, Shape[V]{directionPoint})
|
|
records[pos] = struct{}{}
|
|
}
|
|
}
|
|
|
|
finish := false
|
|
switch i {
|
|
case 0:
|
|
if direction == DirectionRight {
|
|
finish = true
|
|
}
|
|
case 1:
|
|
if direction == DirectionDown {
|
|
finish = true
|
|
}
|
|
}
|
|
if finish {
|
|
break
|
|
}
|
|
directionPoint = point
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return result
|
|
}
|
|
|
|
// Edges 获取该形状每一条边
|
|
// - 该形状需要最少由3个点组成，否则将不会返回任意一边
|
|
func (slf Shape[V]) Edges() (edges []LineSegment[V]) {
|
|
if len(slf) < 3 {
|
|
return
|
|
}
|
|
for i := 1; i < slf.PointCount(); i++ {
|
|
before := slf[i-1]
|
|
edges = append(edges, NewLineSegment(before, slf[i]))
|
|
}
|
|
edges = append(edges, NewLineSegment(slf[0], slf[len(slf)-1]))
|
|
return edges
|
|
}
|
|
|
|
// IsPointOnEdge 检查点是否在该形状的一条边上
|
|
func (slf Shape[V]) IsPointOnEdge(point Point[V]) bool {
|
|
for _, edge := range slf.Edges() {
|
|
if PointOnLineSegmentWithPointInBounds(edge.GetStart(), edge.GetEnd(), point) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// getAllGraphicCompositionWithAsc 通过升序的方式获取该形状中包含的所有图形组合及其位置
|
|
// - 升序指标为图形包含的点数量
|
|
// - 其余内容可参考 getAllGraphicComposition
|
|
func (slf Shape[V]) getAllGraphicCompositionWithAsc(opt *shapeSearchOptions) (result []Shape[V]) {
|
|
result = slf.getAllGraphicComposition(opt)
|
|
sort.Slice(result, func(i, j int) bool {
|
|
return len(result[i].Points()) < len(result[j].Points())
|
|
})
|
|
return
|
|
}
|
|
|
|
// getAllGraphicCompositionWithDesc 通过降序的方式获取该形状中包含的所有图形组合及其位置
|
|
// - 降序指标为图形包含的点数量
|
|
// - 其余内容可参考 GetAllGraphicComposition
|
|
func (slf Shape[V]) getAllGraphicCompositionWithDesc(opt *shapeSearchOptions) (result []Shape[V]) {
|
|
result = slf.getAllGraphicComposition(opt)
|
|
sort.Slice(result, func(i, j int) bool {
|
|
return len(result[i].Points()) > len(result[j].Points())
|
|
})
|
|
return
|
|
}
|
|
|
|
// CalcBoundingRadius 计算多边形转换为圆的半径，即外接圆的半径
|
|
func CalcBoundingRadius[V generic.SignedNumber](shape Shape[V]) V {
|
|
var boundingRadius V
|
|
var centroid = CalcRectangleCentroid(shape)
|
|
for _, point := range shape.Points() {
|
|
distance := CalcDistanceWithCoordinate(DoublePointToCoordinate(centroid, point))
|
|
if distance > boundingRadius {
|
|
boundingRadius = distance
|
|
}
|
|
}
|
|
return boundingRadius
|
|
}
|
|
|
|
// CalcBoundingRadiusWithWidthAndHeight 计算多边形转换为圆的半径，即外接圆的半径
|
|
func CalcBoundingRadiusWithWidthAndHeight[V generic.SignedNumber](width, height V) V {
|
|
return V(math.Sqrt(float64(width*width+height*height)) / 2)
|
|
}
|
|
|
|
// CalcBoundingRadiusWithCentroid 计算多边形在特定质心下圆的半径
|
|
func CalcBoundingRadiusWithCentroid[V generic.SignedNumber](shape Shape[V], centroid Point[V]) V {
|
|
var boundingRadius V
|
|
for _, point := range shape.Points() {
|
|
distance := CalcDistanceWithCoordinate(DoublePointToCoordinate(centroid, point))
|
|
if distance > boundingRadius {
|
|
boundingRadius = distance
|
|
}
|
|
}
|
|
return boundingRadius
|
|
}
|
|
|
|
// CalcTriangleTwiceArea 计算由 a、b、c 三个点组成的三角形的面积的两倍
|
|
func CalcTriangleTwiceArea[V generic.SignedNumber](a, b, c Point[V]) V {
|
|
ax := b.GetX() - a.GetX()
|
|
ay := b.GetY() - a.GetY()
|
|
bx := c.GetX() - a.GetX()
|
|
by := c.GetY() - a.GetY()
|
|
return bx*ay - ax*by
|
|
}
|
|
|
|
// IsPointOnEdge 检查点是否在 edges 的任意一条边上
|
|
func IsPointOnEdge[V generic.SignedNumber](edges []LineSegment[V], point Point[V]) bool {
|
|
for _, edge := range edges {
|
|
if PointOnLineSegmentWithPointInBounds(edge.GetStart(), edge.GetEnd(), point) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ProjectionPointToShape 将一个点投影到一个多边形上，找到离该点最近的投影点，并返回投影点和距离
|
|
func ProjectionPointToShape[V generic.SignedNumber](point Point[V], shape Shape[V]) (Point[V], V) {
|
|
var closestProjection Point[V]
|
|
var hasClosestProjection bool
|
|
var closestDistance V
|
|
|
|
for _, edge := range shape.Edges() {
|
|
projectedPoint := CalcProjectionPoint(edge, point)
|
|
distance := CalcDistanceWithCoordinate(DoublePointToCoordinate(point, projectedPoint))
|
|
if !hasClosestProjection || distance < closestDistance {
|
|
closestDistance = distance
|
|
closestProjection = projectedPoint
|
|
hasClosestProjection = true
|
|
}
|
|
}
|
|
|
|
return closestProjection, closestDistance
|
|
}
|