122 lines
3 KiB
Go
122 lines
3 KiB
Go
package geom
|
|
|
|
import (
|
|
"image"
|
|
"math"
|
|
)
|
|
|
|
const (
|
|
East = iota
|
|
North
|
|
West
|
|
South
|
|
)
|
|
|
|
// PolygonExtrema returns the most easterly, northerly, westerly, and southerly
|
|
// points (north is in the -Y direction, east is in the +X direction, etc). If
|
|
// there are multiple points furthest in any direction, the first one is used.
|
|
func PolygonExtrema(polygon []image.Point) [4]image.Point {
|
|
var e, n, w, s image.Point
|
|
e.X = math.MinInt
|
|
n.Y = math.MaxInt
|
|
w.X = math.MaxInt
|
|
s.Y = math.MinInt
|
|
for _, p := range polygon {
|
|
if p.X > e.X {
|
|
e = p
|
|
}
|
|
if p.X < w.X {
|
|
w = p
|
|
}
|
|
if p.Y > s.Y {
|
|
s = p
|
|
}
|
|
if p.Y < n.Y {
|
|
n = p
|
|
}
|
|
}
|
|
return [4]image.Point{East: e, North: n, West: w, South: s}
|
|
}
|
|
|
|
// PolygonContains reports if a convex polygon contains a point. The polygon
|
|
// must be in clockwise order if +Y is pointing upwards, or anticlockwise if +Y
|
|
// is pointing downwards.
|
|
func PolygonContains(convex []image.Point, p image.Point) bool {
|
|
for i, q := range convex {
|
|
r := convex[(i+1)%len(convex)]
|
|
// ∆(p q r) should have positive signed area
|
|
q, r = q.Sub(p), r.Sub(p)
|
|
if q.X*r.Y > r.X*q.Y {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// PolygonRectOverlap reports if a convex polygon overlaps a rectangle.
|
|
func PolygonRectOverlap(convex []image.Point, rect image.Rectangle) bool {
|
|
if convex[0].In(rect) {
|
|
return true
|
|
}
|
|
|
|
// Check if any vertex of the rect is inside the polygon.
|
|
if PolygonContains(convex, rect.Min) {
|
|
return true
|
|
}
|
|
// Reduced Max (to the inclusive bound).
|
|
rmax := rect.Max.Sub(image.Pt(1, 1))
|
|
// Since we went to the trouble of computing another point...
|
|
// TODO: this shouldn't be necessary
|
|
if PolygonContains(convex, rmax) {
|
|
return true
|
|
}
|
|
|
|
// Only remaining cases involve line intersection between the rect and poly
|
|
// having eliminated the possibility that one is entirely within another.
|
|
|
|
// Since rect is an axis-aligned rectangle, we only need vertical and
|
|
// horizontal line intersection tests.
|
|
// Walk each edge of polygon.
|
|
for i, p := range convex {
|
|
q := convex[(i+1)%len(convex)]
|
|
// Pretend the edge is a rectangle. Exclude those that don't overlap.
|
|
if !rect.Overlaps(image.Rectangle{p, q}.Canon()) {
|
|
continue
|
|
}
|
|
|
|
d := q.Sub(p)
|
|
// If the polygon edge is not vertical, test left and right sides
|
|
if d.X != 0 {
|
|
if d.X < 0 {
|
|
d = d.Mul(-1)
|
|
}
|
|
min := (rect.Min.Y - p.Y) * d.X
|
|
max := (rect.Max.Y - p.Y) * d.X
|
|
// Test left side of rect
|
|
if t := (rect.Min.X - p.X) * d.Y; min <= t && t < max {
|
|
return true
|
|
}
|
|
// Test right side of rect
|
|
if t := (rmax.X - p.X) * d.Y; min <= t && t < max {
|
|
return true
|
|
}
|
|
}
|
|
// If the polygon edge is not horizontal, test the top and bottom sides
|
|
if d.Y != 0 {
|
|
if d.Y < 0 {
|
|
d = d.Mul(-1)
|
|
}
|
|
min := (rect.Min.X - p.X) * d.Y
|
|
max := (rect.Max.X - p.X) * d.Y
|
|
// Test top side of rect
|
|
if t := (rect.Min.Y - p.Y) * d.X; min <= t && t < max {
|
|
return true
|
|
}
|
|
// Test bottom side of rect
|
|
if t := (rmax.Y - p.Y) * d.X; min <= t && t < max {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|