Class StraightEdge

A straight Edge belonging to a RigidBody. A StraightEdge is defined by its two endpoint Vertexes, which are in body coordinates, plus it knows which side of the Edge is outside of the body.

distanceToLine() Derivation

Let the Vertexes of this edge be v and v2, with slope k.
The line of the edge is y - vy = k(x - vx).
The line of the normal through p is y - py = (-1/k)(x - px)
Solve these two equations to get the intersection point q.
qx = (-vy + py + px/k + k vx) / (1/k + k)
qy = vy + k (qx - vx)
Return distance between p and q (or minus that distance).

distanceToPoint() Derivation

Let the Vertexes of this edge be v and v2, with slope k.
The line of the edge is y - vy = k(x - vx).
The line of the normal through p is y - py = (-1/k)(x - px)
Solve these two equations to get the intersection point q.
qx = (-vy + py + px/k + k vx) / (1/k + k)
qy = vy + k (qx - vx)
Check if the intersection point q within endpoints of the edge,
return infinity if not.
Return distance between p and q (or minus that distance).

getNormalBody() Derivation

Let k be the slope of the edge.
The normal has slope -1/k = y/x
To be unit normal, we need: x^2 + y^2 =1
Solve for x and y:
x = -k y
(k^2 + 1) y^2 = 1
y = 1/sqrt(1 + k^2)
x = -k/sqrt(1 + k^2)

Hierarchy (view full)

Implements

Constructors

constructor

Properties

body_ centroidRadius_ centroid_body_ index_ v1_ v2_

Methods

addPath checkVertexVertex chordError distanceToEdge distanceToLine distanceToPoint findVertexContact forgetPosition getBody getBottomBody getCentroidBody getCentroidRadius getCentroidWorld getClassName getCurvature getDecoratedVertexes getIndex getLeftBody getNormalBody getPointOnEdge getRightBody getTopBody getVertex1 getVertex2 highlight improveAccuracyEdge intersection intersectionPossible isStraight makeVertexVertex maxDistanceTo pointOffset projectionOntoLine setCentroidRadius setVertex2 testCollisionEdge

Constructors

constructor

  • new StraightEdge(body, vertex1, vertex2, outsideIsUp): StraightEdge

  • Parameters

    • body: RigidBody

      the RigidBody this Edge is a part of

    • vertex1: Vertex

      the previous Vertex, in body coords

    • vertex2: Vertex

      the next Vertex, in body coords

    • outsideIsUp: boolean

      true means the region above the Edge is outside of the RigidBody (when viewed in body coordinates); for vertical Edge true means region right of Edge is outside.

    Returns StraightEdge

    Throws

    if vertex1 is already connected to a 'next' Edge

    Throws

    if vertex2 is already connected to a 'previous' Edge

Properties

Protected body_

body_: RigidBody

the RigidBody that this edge is a part of

Protected centroidRadius_

centroidRadius_: number = NaN

the maximum distance from centroid to any point on this edge

Protected centroid_body_

centroid_body_: Vector

the 'center' of this edge, an arbitrary point selected to minimize the centroid radius of this edge

Protected index_

index_: number = -1

index of this edge in the body's list of edges

Protected v1_

v1_: Vertex

the previous vertex, in body coords; matches the next (second) vertex of the previous edge

Protected v2_

v2_: Vertex

the next vertex, in body coords

Methods

addPath

  • addPath(context): void

  • Add this Edge to the currently open path of the JavaScript canvas context for drawing the Edge. The Edge should be drawn in local body coordinates.

    Parameters

    • context: CanvasRenderingContext2D

      the JavaScript canvas context to draw this Edge into

    Returns void

Private checkVertexVertex

chordError

  • chordError(): number

  • Returns the maximum distance between this Edge and any chord between Vertexes on this Edge (including decorated mid-point Vertexes). A chord is the straight line between two adjacent Vertexes.

    Here is a picture of a curved Edge, the chord between two Vertexes, V1, V2, and the chord error is the maximum distance between the chord and curved Edge.

    Note that having more decorated mid-point Vertexes results in a smaller chord error, because the chords are closer to the curve.

    See Vertex for more about decorated mid-point Vertexes

    Returns number

    the maximum distance between this Edge and a chord between any Vertexes on this Edge

distanceToEdge

  • distanceToEdge(edge): number

  • Returns smallest distance between this Edge and the given Edge. Returns NaN in cases where the calculation can't be done. One of the Edges must be curved.

    TO DO distanceToEdge is not used currently... delete it? or use it in places like CircleStraight.testCollision and CircleCircle.testCollision?

    Parameters

    • edge: Edge

      the Edge to measure distance to

    Returns number

    smallest distance between this Edge and the given Edge, or NaN when the calculation cannot be done

    Throws

    if both Edges are StraightEdges.

distanceToLine

  • distanceToLine(p_body): number

  • Returns distance from the given point (in body coordinates) to the extended line of this Edge, where the extensions continue beyond the endpoints of this Edge. For a CircularEdge the extended line is taken to be the full circle. Positive distance means the point is outside of this Edge, negative means inside.

    Parameters

    • p_body: Vector

      the point to find distance from, in body coords

    Returns number

    distance from the given point to the extended line of this Edge

distanceToPoint

  • distanceToPoint(p_body): number

  • Returns signed distance of the given point (in body coordinates) to this Edge along a line that is normal to this Edge, or infinity if beyond an endpoint of this Edge. Distance is positive if it is on the side of the line that the normal points towards, otherwise negative.

    Parameters

    • p_body: Vector

      the point to find distance from, in body coords

    Returns number

    signed distance from the given point to this Edge (positive if point is on side the normal points towards) or infinity if beyond the endpoint of this Edge

findVertexContact

  • findVertexContact(v, p_body, distTol): null | RigidBodyCollision

  • Returns a RigidBodyCollision representing the contact point if the given Vertex is close to this Edge. Closeness is specified by the given distance tolerance. Note that this does not consider velocity tests for a contact. If the point does not lie along any normal to this Edge, then it is not close; this occurs when the point is past the endpoints of this Edge.

    If the point is near, then the returned RigidBodyCollision will have the following information set:

    • body is set to the RigidBody of the Vertex
    • normalBody is set to the RigidBody of this Edge
    • impact point is set to the nearest point on this Edge, in world coords
    • distance is set to the distance of Vertex from this Edge; negative distance means penetration into this Edge.
    • normal is set to the unit normal vector at the nearest point on this Edge, in world coords
    • r2 is based on current position of this Edge's RigidBody

    Additionally, if this Edge is curved, the following are also set: ballNormal, radius2, u2.

    Parameters

    • v: Vertex

      the Vertex of interest on other-body

    • p_body: Vector

      the body coordinate position of the Vertex in body coords of this Edge's body (normalBody)

    • distTol: number

      the distance tolerance; distance to Vertex must be smaller than this to be considered close enough.

    Returns null | RigidBodyCollision

    a RigidBodyCollision representing the contact point, or null if not close enough.

forgetPosition

getBody

getBottomBody

getCentroidBody

getCentroidRadius

getCentroidWorld

getClassName

getCurvature

  • getCurvature(_p_body): number

  • Returns radius of curvature at the given point on this Edge. Radius of curvature is the radius of a circle that would give equivalent curvature at a given point on an Edge. Negative curvature means the Edge is concave at that point.

    For a circle, every point on the circle has the same center and radius of curvature. But for any other curve (an oval for instance), each point on the edge can have a different center and radius of curvature.

    Parameters

    • _p_body: Vector

      the point on this Edge, in body coordinates

    Returns number

    the radius of curvature; negative means concave; returns positive infinity if this is a straight edge

    Throws

    if the point is not close to this Edge

getDecoratedVertexes

getIndex

getLeftBody

getNormalBody

  • getNormalBody(_p_body): Vector

  • Returns unit normal vector in body coordinates, at the given body coordinates point. Normal points outwards from the RigidBody. TO DO what if the point is not on this Edge?

    Parameters

    • _p_body: Vector

      the point on this Edge in body coordinates

    Returns Vector

    the outwards pointing unit normal vector at the given point, in body coordinates

getPointOnEdge

  • getPointOnEdge(p_body): Vector[]

  • Finds the nearest point on this Edge to the given point, returns that nearest point and the unit normal vector there. Returns null if the given point lies beyond the end point of this Edge, meaning that there is no perpendicular line to this Edge passing thru the given point.

    Parameters

    • p_body: Vector

      a point near this Edge, in body coordinates

    Returns Vector[]

    a pair of Vectors: the nearest point on this Edge, and the unit normal vector at that point both in body coords; or null if there is no nearest point on this Edge.

getRightBody

getTopBody

getVertex1

getVertex2

highlight

improveAccuracyEdge

intersection

  • intersection(p1_body, p2_body): null | Vector[]

  • Returns points on this Edge intersecting the straight line segment between the two given points (in body coordinates), or null if there is no intersection. There can be more than one point of intersection.

    Parameters

    • p1_body: Vector

      point 1 in body coords

    • p2_body: Vector

      point 2 in body coords

    Returns null | Vector[]

    array of intersection points, in body coords, or null if no intersection.

intersectionPossible

  • intersectionPossible(edge, swellage): boolean

  • Rough proximity test that returns true if an intersection is possible between this Edge and the specified Edge. This is intended to do a quick rough test to eliminate obvious cases where no intersection is possible. Swellage is a fudge factor which is added to the max radius of the Edges, to make the test easier to succeed.

    Parameters

    • edge: Edge

      the other Edge

    • swellage: number

      a fudge factor which is added to the max radius of the Edges

    Returns boolean

    whether an intersection between the Edges is possible

isStraight

Private makeVertexVertex

maxDistanceTo

pointOffset

  • pointOffset(p_body, length): Vector

  • Returns the point offset in the direction of this Edge's normal. The normal is taken at the point on this Edge that is closest to the given point. The point is given and returned in body coordinates. Note that the returned point might be closer to this Edge when the starting point is on the inside of the RigidBody, because the normal points outwards.

    Parameters

    • p_body: Vector

      the point near this Edge, in body coordinates

    • length: number

      the distance to move the point

    Returns Vector

    the point offset in the direction of this Edge's normal, in body coordinates

projectionOntoLine

  • projectionOntoLine(p_body): Vector

  • Returns the projection of the given point onto the extended line of this Edge, where the extensions continue beyond the endpoints of this Edge. This is the point on this line where a perpendicular would cross the given point.

    Derivation:  Let the Vertexes of this edge be v and v2, with slope k.
The line of the edge is y - vy = k(x - vx).
The line of the normal through p is y - py = (-1/k)(x - px)
Solve these two equations to get the intersection point q.
qx = (-vy + py + px/k + k vx) / (1/k + k)
qy = vy + k (qx - vx)

    Parameters

    • p_body: Vector

      the point on this Edge, in body coordinates

    Returns Vector

    the projection of the given point onto the extended line of this Edge

setCentroidRadius

setVertex2

testCollisionEdge

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc