Class CircularEdge

A circular arc Edge belonging to a RigidBody.

Making a CircularEdge

Full Circle

A full circle is a special case detected by the constructor. When vertex1 and vertex2 are at the same location, then we assume a full circle is desired. The two Vertexes need not be identical, just very close together. In this case, only one of the Vertexes is kept and there is a single Vertex and single Edge forming the circle.

Mid-Point Vertexes

See Vertex for information about why mid-point Vertexes are created on a CircularEdge and how they are used for collision checking.

Edge Coordinates

In addition to world and body coordinates, CircularEdge also has 'edge coordinates' which takes body coordinates but shifts the origin to be the center of the circle that defines this Edge. For CircularEdge there is no change in angle between edge and body coords (unlike with an oval edge).

About Coordinates and Angles

To avoid confusion, be clear about which of these conventions you are dealing with:

  • In myPhysicsLab, simulation coordinates uses y increases up coordinates and angle increases counter-clockwise. Also called world coordinates.

  • Javascript's screen coordinates uses y increases down coordinates and angle increases clockwise in canvas.arc().

The transformation between these coordinate systems is handled by CoordMap.

The table below summarizes the conventions used for angles. CircularEdge uses the math convention for angles shown in this table.

    wall clock         math convention         canvas.arc()

        12      |            pi/2       |           -pi/2
  9          3  |   -pi/pi          0   |  +pi/-pi          0
        6       |           -pi/2       |           +pi/2

Details About Coordinates and Drawing

The 'y increases up' convention interacts with drawing in Javascript via CircularEdge.addPath, and DisplayShape. In DisplayShape we use the AffineTransform from the CoordMap which applies a negative factor to the vertical scale as seen in this line of code from CoordMap's constructor:

at = at.scale(this.pixel_per_unit_x_, -this.pixel_per_unit_y_);

The result is that all drawing happens upside down -- if you were to draw text or an image with that AffineTransform it will appear upside down.

The two conventions, simulation coords vs. screen coords, cancel out as a "double negative" when specifying startAngle, finishAngle and antiClockwise arguments to JavaScript's canvas.arc() function.

Note that for canvas.arc(), an increase in angle moves in a clockwise direction. However, because we use 'y increases up' coordinates, the drawing is flipped vertically, both of these cancel, and we can use regular 'math' angles with canvas.arc().

In contrast to canvas.arc(), the Javascript Math.atan2() function uses standard math coordinates.

Hierarchy (view full)

Implements

Constructors

constructor

Properties

angle_high_ angle_low_ body_ center_body_ centroidRadius_ centroid_body_ clockwise_ completeCircle_ decoratedAngle_ depth_ finishAngle_ index_ outsideIsOut_ radius_ startAngle_ v1_ v2_

Methods

addPath angleToBody bodyToEdge chordError depthOfArc distanceToEdge distanceToLine distanceToPoint edgeToBody edgeToWorld findVertexContact forgetPosition getBody getBottomBody getCenterBody getCentroidBody getCentroidRadius getCentroidWorld getClassName getCurvature getDecoratedVertexes getIndex getLeftBody getNormalBody getPointOnEdge getRadius getRightBody getTopBody getVertex1 getVertex2 highlight improveAccuracyEdge intersection intersectionPossible isStraight isWithinArc isWithinArc2 isWithinReflectedArc isWithinReflectedArc2 maxDistanceTo nearestPointByAngle outsideIsOut pointOffset setCentroidRadius setVertex2 testCollisionEdge findAngleLowHigh findDepth isWithinArc make

Constructors

constructor

  • new CircularEdge(body, vertex1, vertex2, center_body, clockwise, outsideIsOut, opt_spacing?): CircularEdge

  • The Edge starts at vertex1 (given in body coordinates) proceeding along a circular arc with given center to the ending vertex2. The direction of the arc is given by the clockwise parameter. When the outsideIsOut variable is true, the outside of the circle is considered the outside of the RigidBody. Both Vertexes must be equidistant from the center, otherwise an exception is thrown.

    Parameters

    • body: RigidBody

      Edge will be added to this RigidBody

    • vertex1: Vertex

      Edge starts at this Vertex, given in body coordinates

    • vertex2: Vertex

      Edge finishes at this Vertex, given in body coordinates

    • center_body: Vector

      center of the circular arc, in body coordinates

    • clockwise: boolean

      direction of the arc

    • outsideIsOut: boolean

      true means the region outside of the circle is considered the outside of the RigidBody, so the edge is convex. False indicates a concave edge.

    • Optional opt_spacing: number

      the distance between 'decorated' mid-point Vertexes.

    Returns CircularEdge

    Throws

    if the Vertexes are not equidistant from the center within CircularEdge.TINY_POSITIVE tolerance

    Throws

    if vertex1 is already connected to a 'next' Edge

    Throws

    if vertex2 is already connected to a 'previous' Edge

Properties

Private angle_high_

angle_high_: number

Any point on the arc falls between angle_low and angle_high, where angle_low < angle_high. Note that angle_low might be startAngle or finishAngle (modulo 2 pi), same with angle_high. In math convention, angle_high is between angle_low and 3 pi.

Private angle_low_

angle_low_: number

Any point on the arc falls between angle_low and angle_high, where angle_low < angle_high. Note that angle_low might be startAngle or finishAngle (modulo 2 pi), same with angle_high. In math convention, angle_low is between -pi and pi.

Protected body_

body_: RigidBody

the RigidBody that this edge is a part of

Private center_body_

center_body_: Vector

position of the center, in body coords

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

Private clockwise_

clockwise_: boolean

when true, arc goes clockwise from startAngle to finishAngle.

Private completeCircle_

completeCircle_: boolean

true when this is a complete circle

Private decoratedAngle_

decoratedAngle_: number

the angle between decorated Vertexes

Private depth_

depth_: number

depth is used to limit how far a penetration is regarded as a collision. 'depth of arc' is thickest distance between arc and line connecting arc ends.

Private finishAngle_

finishAngle_: number

finish angle, in mathematical body coords (in radians, 0 = 3 o'clock, increase counter-clockwise) startAngle and finishAngle are same in body or edge coords

Protected index_

index_: number = -1

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

Private outsideIsOut_

outsideIsOut_: boolean

when true, the outside of the circle is outside of the object.

Private radius_

radius_: number

radius of the edge; NOTE: radius is positive, but getCurvature() returns negative for concave edge

Private startAngle_

startAngle_: number

starting angle, in mathematical body coords (in radians, 0 = 3 o'clock, increase counter-clockwise) startAngle and finishAngle are same in body or edge coords

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

angleToBody

  • angleToBody(angle): Vector

  • Returns the location on this CircularEdge corresponding to the given angle, in body coordinates.

    Parameters

    • angle: number

      in edge coords

    Returns Vector

    location on this CircularEdge in body coords

bodyToEdge

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

depthOfArc

  • depthOfArc(): number

  • Returns the thickest distance between arc and the line between the end points of this curved Edge. Depth of arc is used to limit how far a penetration can be and still be regarded as a collision.

    Returns number

    the thickest distance between arc and line connecting arc ends

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

edgeToBody

edgeToWorld

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

getCenterBody

  • getCenterBody(_p_body?): Vector

  • Returns center of curvature of this Edge. For an oval shape, this calculates the curvature at the given point on the Edge. For a circle or straight line, the curvature is the same at any point on the Edge.

    Parameters

    • Optional _p_body: Vector

      the point on this Edge, in body coordinates (optional)

    Returns Vector

    center of curvature at the given point on this Edge in body coordinates

    Throws

    for an oval shape, when p_body is undefined

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.

getRadius

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

isWithinArc

  • isWithinArc(p_edge): boolean

  • Returns true if the angle of the given point is within this arc. Looks at the angle from the origin to the point, compares this angle to the angle range of this arc.

    Parameters

    • p_edge: Vector

      the point of interest, in edge coordinates.

    Returns boolean

    true if the given point is within this arc.

isWithinArc2

  • isWithinArc2(p_world): boolean

  • Returns true if the angle of the given point is within this arc. Looks at the angle from the origin to the point, compares this angle to the angle range of this arc.

    Parameters

    • p_world: Vector

      the point of interest, in world coordinates.

    Returns boolean

    true if the given point is within this arc.

isWithinReflectedArc

  • isWithinReflectedArc(p_edge): boolean

  • Returns true if the angle of the given point is within the reflection of this arc through the center. Looks at the angle from the origin to the point, compares this angle to the angle range of the reflected arc.

    Examples of reflected arcs:

    • If the arc goes from 0 to pi/4, then the reflected arc goes from pi to 5 pi/4.
    • If the arc goes from 0 to 3 pi/2, then the reflected arc goes from pi to 5 pi/2.

    Parameters

    • p_edge: Vector

      the point of interest, in edge coordinates.

    Returns boolean

    true if the given point is within the reflected arc.

isWithinReflectedArc2

  • isWithinReflectedArc2(p_world): boolean

  • Returns true if the angle of the given point is within the reflection of this arc through the center. Same as isWithinReflectedArc but accepts a point in world coordinates.

    Parameters

    • p_world: Vector

      the point of interest, in world coordinates.

    Returns boolean

    true if the given point is within the reflected arc.

maxDistanceTo

nearestPointByAngle

  • nearestPointByAngle(p_body): Vector

  • Finds the 'nearest' point (by angle) on this arc to the given point p_body.

    • If the angle to p_body is within the arc, return p_body unchanged.
    • If the angle to p_body is outside of the arc, return the nearest endpoint of the arc.

    Parameters

    • p_body: Vector

      the point of interest, in body coordinates

    Returns Vector

    the nearest point (by angle) on this arc to the given point, in body coordinates

outsideIsOut

  • outsideIsOut(): boolean

  • Returns true when the region outside of the circle is outside of the object, meaning the edge is convex. Returns false for a concave edge.

    Returns boolean

    true means the region outside of the circle is outside of the object.

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

setCentroidRadius

setVertex2

testCollisionEdge

Static Private findAngleLowHigh

  • findAngleLowHigh(startAngle, finishAngle, clockwise): number[]

  • Converts the start and finish angles of an arc to a pair of angles such that all of the arc is within that pair of angles.

    Parameters

    • startAngle: number

      starting angle, math convention

    • finishAngle: number

      finish angle, math convention

    • clockwise: boolean

      true means arc goes clockwise in math convention

    Returns number[]

    pair of angles, low and high, such that all of the arc is within that pair of angles.

Static Private findDepth

  • findDepth(angle, radius): number

  • Returns 'depth of arc' which is maximum distance between arc and line connecting arc ends.

    Derivation:
On unit circle, let arc start at
  A = [1, 0]
and extend counter clockwise along circle to
  B = [cos theta, sin theta].
Draw a line between those two points, A and B.
Let C be the midpoint of that line. C is at:
  C = [(1 + cos theta)/2, sin theta / 2 ].
Distance between C and (cos theta/2, sin theta/2) is the depth.

    Parameters

    • angle: number

      angle of arc, in radians

    • radius: number

      radius of circle that arc is part of

    Returns number

    maximum distance between arc and line connecting arc ends

Static Private isWithinArc

  • isWithinArc(p_edge, angleLow, angleHigh): boolean

  • Parameters

    • p_edge: Vector

      the point of interest, in edge coordinates.

    • angleLow: number
    • angleHigh: number

    Returns boolean

    true if the given point is within this arc.

Static make

  • make(body, vertex1, vertex2, radius, aboveRight, clockwise, outsideIsOut): CircularEdge

  • Creates a CircularEdge between the given Vertexes with the given radius, calculating the position of the center, and adds the edge to the given RigidBody.

    Calculates the center to be at the vertex of an isoceles triangle with the given Vertexes, where the center is radius distance from each Vertex.

    There are two choices for where to put the center in relation to the line connecting the two given Vertexes: either above or below the line. The aboveRight parameter specifies which choice to make. For a vertical connecting line, the choice is right or left of the line.

    Parameters

    • body: RigidBody

      edge will be added to this RigidBody

    • vertex1: Vertex

      edge starts at this Vertex, given in body coordinates

    • vertex2: Vertex

      edge finishes at this Vertex, given in body coordinates

    • radius: number

      the radius of the circular arc

    • aboveRight: boolean

      if true, then the center of CircularEdge is located above or right of the line connecting vertex1 and vertex2; if false, then center is located below or left of the connecting line.

    • clockwise: boolean

      direction of the arc

    • outsideIsOut: boolean

      true means the outside of the circle is considered the outside of the RigidBody.

    Returns CircularEdge

    the CircularEdge that is created

    Throws

    if absolute value of radius is too small; must be greater than half the distance between the two Vertexes

    Throws

    if vertex1 is already connected to a 'next' Edge

    Throws

    if vertex2 is already connected to a 'previous' Edge

Settings

Member Visibility

Theme

On This Page

Generated using TypeDoc