You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
250 lines
12 KiB
250 lines
12 KiB
import {
|
|
addBoundingSquareTo,
|
|
getDirectionSorter,
|
|
Graph,
|
|
GraphBoundary,
|
|
GraphDirection,
|
|
Point,
|
|
Segment,
|
|
SegmentWithIntersection, Triangle
|
|
} from "./pslg";
|
|
|
|
export function getFirstIntersectingSegmentInDirection(raySegment: Segment, boundary: GraphBoundary, graph: Graph, direction: GraphDirection): [Segment, Point] {
|
|
const intersectingSegment = boundary.getBoundary(direction)
|
|
const intersectingPoint = raySegment.getIntersectionWith(intersectingSegment)
|
|
if ( !intersectingPoint ) {
|
|
console.log(
|
|
'getFirstIntersectingSegmentInDirection',
|
|
[raySegment.from.coordinate, raySegment.to.coordinate],
|
|
[intersectingSegment.from.coordinate, intersectingSegment.to.coordinate],
|
|
intersectingPoint
|
|
)
|
|
throw new RangeError('Ray segment does not extend to boundary in the given direction!')
|
|
}
|
|
|
|
// Now, collect all non-boundary segments that intersect with the ray segment
|
|
const intersections = (graph.segments
|
|
.map(segment => {
|
|
if ( boundary.isBoundarySegment(segment) ) return undefined
|
|
|
|
return {
|
|
segment,
|
|
intersect: segment.getIntersectionWithin(raySegment)
|
|
}
|
|
})
|
|
.filter(x => x && x.intersect) as SegmentWithIntersection[])
|
|
.sort(getDirectionSorter(direction))
|
|
|
|
const intersection = intersections[0]
|
|
if ( intersection ) {
|
|
return [intersection.segment, intersection.intersect]
|
|
}
|
|
|
|
return [intersectingSegment, intersectingPoint]
|
|
}
|
|
|
|
export function triangulate(originalGraph: Graph): Graph {
|
|
const graph = originalGraph.clone()
|
|
const boundary = addBoundingSquareTo(graph)
|
|
|
|
const leftBound = boundary.getLeftBoundary()
|
|
const rightBound = boundary.getRightBoundary()
|
|
|
|
const trapezoidSegments: Segment[] = []
|
|
|
|
// For each vertex in the original graph, create a horizontal line that
|
|
// extends in both directions until it intersects with either (1) the boundary
|
|
// or (2) a segment in the graph.
|
|
for ( const point of graph.points ) {
|
|
if ( boundary.isBoundaryPoint(point) ) continue // skip boundary points
|
|
|
|
// Create the segment extending out to the left boundary
|
|
const leftPoint = Point.from(leftBound.from.x, point.y)
|
|
let leftSegment = new Segment(point, leftPoint)
|
|
|
|
// Get segments that intersect with this
|
|
const leftIntersectingSegments = (graph.segments
|
|
.map(segment => {
|
|
if ( boundary.isBoundarySegment(segment) ) {
|
|
// Exclude boundary segments
|
|
return undefined
|
|
}
|
|
|
|
return {
|
|
segment,
|
|
intersect: segment.getIntersectionWithin(leftSegment),
|
|
}
|
|
})
|
|
.filter(group => group && group.intersect) as Array<{segment: Segment, intersect: Point}>)
|
|
.sort((a, b) => {
|
|
return b.intersect.x - a.intersect.x // Sort by right-most x-value
|
|
})
|
|
|
|
// Check if there was a nearer intersecting segment
|
|
const firstLeftIntersectingSegment = leftIntersectingSegments?.[0]?.segment
|
|
if ( firstLeftIntersectingSegment ) {
|
|
// Modify the leftSegment to end at the intersection point
|
|
const leftIntersect = graph.findExistingPointOrAdd(leftIntersectingSegments[0].intersect)
|
|
leftSegment = new Segment(point, leftIntersect)
|
|
}
|
|
|
|
// Create the segment extending out to the right boundary
|
|
const rightPoint = Point.from(rightBound.from.x, point.y)
|
|
let rightSegment = new Segment(point, rightPoint)
|
|
|
|
// Get segments that intersect with this
|
|
const rightIntersectingSegments = (graph.segments
|
|
.map(segment => {
|
|
if ( boundary.isBoundarySegment(segment) ) {
|
|
// Exclude boundary segments
|
|
return undefined
|
|
}
|
|
|
|
return {
|
|
segment,
|
|
intersect: segment.getIntersectionWithin(rightSegment),
|
|
}
|
|
})
|
|
.filter(group => group && group.intersect) as Array<{segment: Segment, intersect: Point}>)
|
|
.sort((a, b) => {
|
|
return a.intersect.x - b.intersect.x // Sort by left-most x-value
|
|
})
|
|
|
|
// Check if there was a nearer intersecting segment
|
|
const firstRightIntersectingSegment = rightIntersectingSegments?.[0]?.segment
|
|
if ( firstRightIntersectingSegment ) {
|
|
// Modify the leftSegment to end at the intersection point
|
|
const rightIntersect = graph.findExistingPointOrAdd(rightIntersectingSegments[0].intersect)
|
|
rightSegment = new Segment(point, rightIntersect)
|
|
}
|
|
|
|
const graphLeftSegment = graph.findExistingSegmentOrAdd(leftSegment)
|
|
const graphRightSegment = graph.findExistingSegmentOrAdd(rightSegment)
|
|
trapezoidSegments.push(graphLeftSegment, graphRightSegment)
|
|
}
|
|
|
|
// Now, go through and identify trapezoids for all the horizontal segments we just added
|
|
for ( const segment of trapezoidSegments ) {
|
|
// First, find the trapezoid formed with the segment as the bottom
|
|
// Create a vertical segment from the midpoint of the segment to the top boundary
|
|
const horizontalMidpoint = segment.getMidpoint()
|
|
let upperBoundaryPoint = Point.from(horizontalMidpoint.x, boundary.ymax)
|
|
let upperBoundaryVerticalSegment = new Segment(horizontalMidpoint, upperBoundaryPoint)
|
|
|
|
const [upperIntersectSegment, upperIntersectPoint] = getFirstIntersectingSegmentInDirection(
|
|
upperBoundaryVerticalSegment,
|
|
boundary,
|
|
graph,
|
|
GraphDirection.UP
|
|
)
|
|
|
|
upperBoundaryVerticalSegment = new Segment(horizontalMidpoint, upperIntersectPoint)
|
|
|
|
// Now we have the upper and lower boundaries of the trapezoid.
|
|
// So, we need to figure out the left and right boundaries next.
|
|
// Get the midpoint of the vertical segment
|
|
const verticalMidpoint = upperBoundaryVerticalSegment.getMidpoint()
|
|
let leftBoundaryPoint = Point.from(boundary.xmin, verticalMidpoint.y)
|
|
let leftBoundaryHorizontalSegment = new Segment(verticalMidpoint, leftBoundaryPoint)
|
|
|
|
const [leftIntersectSegment, leftIntersectPoint] = getFirstIntersectingSegmentInDirection(
|
|
leftBoundaryHorizontalSegment,
|
|
boundary,
|
|
graph,
|
|
GraphDirection.LEFT
|
|
)
|
|
|
|
leftBoundaryHorizontalSegment = new Segment(verticalMidpoint, leftIntersectPoint)
|
|
|
|
// Repeat to get the right boundary
|
|
let rightBoundaryPoint = Point.from(boundary.xmax, verticalMidpoint.y)
|
|
let rightBoundaryHorizontalSegment = new Segment(verticalMidpoint, rightBoundaryPoint)
|
|
|
|
const [rightIntersectSegment, rightIntersectPoint] = getFirstIntersectingSegmentInDirection(
|
|
rightBoundaryHorizontalSegment,
|
|
boundary,
|
|
graph,
|
|
GraphDirection.RIGHT,
|
|
)
|
|
|
|
rightBoundaryHorizontalSegment = new Segment(verticalMidpoint, rightIntersectPoint)
|
|
|
|
// Now, check if we actually have a 4-bound trapezoid, or if we have a triangle
|
|
const points = Point.distinct([
|
|
segment.from,
|
|
segment.to,
|
|
upperIntersectSegment.from,
|
|
upperIntersectSegment.to,
|
|
])
|
|
|
|
if ( points.length === 3 ) {
|
|
// We found a triangle! Less work.
|
|
// Create the triangle and push it onto the graph
|
|
const [p1, p2, p3] = points.map(x => graph.findExistingPointOrAdd(x))
|
|
const s12 = graph.findExistingSegmentOrAdd(new Segment(p1, p2))
|
|
const s23 = graph.findExistingSegmentOrAdd(new Segment(p2, p3))
|
|
const s31 = graph.findExistingSegmentOrAdd(new Segment(p3, p1))
|
|
graph.findExistingTriangleOrAdd(new Triangle([s12, s23, s31]))
|
|
continue // FIXME - remove to handle below-segment case
|
|
}
|
|
|
|
if ( points.length !== 4 ) {
|
|
throw new RangeError('Found shape with invalid number of distinct points!')
|
|
}
|
|
|
|
// Now, we have the 4 bounding segments of the trapezoid.
|
|
// Let's find the segments that make up the trapezoid
|
|
// We will do this by re-creating segments for the four sides of the trapezoid
|
|
// Split the left-side on the intersection point
|
|
let [leftSegment1, leftSegment2] = leftIntersectSegment.splitAt(leftIntersectPoint) // This is not right. Needs to be `segment`'s intersect point, not the midpoint intersect point
|
|
graph.removeSegment(leftIntersectSegment)
|
|
leftSegment1 = graph.findExistingSegmentOrAdd(leftSegment1)
|
|
leftSegment2 = graph.findExistingSegmentOrAdd(leftSegment2)
|
|
|
|
// We care about the upper-segment from the split, as that is the bound of our trapezoid
|
|
const trapezoidLeftBoundSegment = leftSegment1.ymin === leftIntersectPoint.y ? leftSegment1 : leftSegment2
|
|
|
|
// Repeat this process for the right-side segment
|
|
let [rightSegment1, rightSegment2] = rightIntersectSegment.splitAt(rightIntersectPoint)
|
|
graph.removeSegment(rightIntersectSegment)
|
|
rightSegment1 = graph.findExistingSegmentOrAdd(rightSegment1)
|
|
rightSegment2 = graph.findExistingSegmentOrAdd(rightSegment2)
|
|
|
|
const trapezoidRightBoundSegment = rightSegment1.ymin === rightBoundaryPoint.y ? leftSegment1 : leftSegment2
|
|
|
|
// Now we have all 4 bounding segments. We find the bisector that creates
|
|
// triangles with the largest minimum angle.
|
|
|
|
// First, try making triangles from bottom-left to top-right
|
|
const lowerLeftPoint = graph.findExistingPointOrAdd(Point.from(segment.xmin, segment.ymin))
|
|
const upperRightPoint = graph.findExistingPointOrAdd(Point.from(upperIntersectSegment.xmax, upperIntersectSegment.ymax))
|
|
|
|
const bottomLeftBisectorSegment = new Segment(lowerLeftPoint, upperRightPoint)
|
|
// const bottomLeftBisectorUpperTriangle = new Triangle([bottomLeftBisectorSegment, upperIntersectSegment, trapezoidLeftBoundSegment])
|
|
// const bottomLeftBisectorLowerTriangle = new Triangle([bottomLeftBisectorSegment, segment, trapezoidRightBoundSegment])
|
|
// const bottomLeftBisectorMinAngle = Math.min(bottomLeftBisectorUpperTriangle.getMinimumAngle(), bottomLeftBisectorLowerTriangle.getMinimumAngle())
|
|
|
|
const upperLeftPoint = graph.findExistingPointOrAdd(Point.from(upperIntersectSegment.xmin, upperIntersectSegment.ymax))
|
|
const lowerRightPoint = graph.findExistingPointOrAdd(Point.from(segment.xmax, segment.ymin))
|
|
|
|
// const topRightBisectorSegment = new Segment(upperLeftPoint, lowerRightPoint)
|
|
// const upperRightBisectorUpperTriangle = new Triangle([topRightBisectorSegment, upperIntersectSegment, trapezoidRightBoundSegment])
|
|
// const upperRightBisectorLowerTriangle = new Triangle([topRightBisectorSegment, trapezoidLeftBoundSegment, segment])
|
|
// const upperRightBisectorMinAngle = Math.min(upperRightBisectorUpperTriangle.getMinimumAngle(), upperRightBisectorLowerTriangle.getMinimumAngle())
|
|
|
|
// const optimalBisectorUpperTriangle = upperRightBisectorMinAngle > bottomLeftBisectorMinAngle ? upperRightBisectorUpperTriangle : bottomLeftBisectorUpperTriangle
|
|
// const optimalBisectorLowerTriangle = upperRightBisectorMinAngle > bottomLeftBisectorMinAngle ? upperRightBisectorLowerTriangle : bottomLeftBisectorLowerTriangle
|
|
|
|
// Add the triangles to the graph
|
|
// const upperTriangleSegments = optimalBisectorUpperTriangle.sides.map(side => graph.findExistingSegmentOrAdd(side))
|
|
// graph.findExistingTriangleOrAdd(new Triangle(upperTriangleSegments as [Segment, Segment, Segment]))
|
|
|
|
// const lowerTriangleSegments = optimalBisectorLowerTriangle.sides.map(side => graph.findExistingSegmentOrAdd(side))
|
|
// graph.findExistingTriangleOrAdd(new Triangle(lowerTriangleSegments as [Segment, Segment, Segment]))
|
|
}
|
|
|
|
// FIXME handle the lower-trapezoid case
|
|
|
|
return graph
|
|
}
|