The global XY frame.

Frame2d.xy
--> Frame2d
-->     { originPoint = Point2d.origin
-->     , xDirection = Direction2d.x
-->     , yDirection = Direction2d.y
-->     }

Construct a frame aligned with the global XY frame but with the given origin point.

Frame2d.at (Point2d ( 2, 3 ))
--> Frame2d
-->     { originPoint = Point2d ( 2, 3 )
-->     , xDirection = Direction2d.x
-->     , yDirection = Direction2d.y
-->     }

Get the origin point of a given frame.

Frame2d.originPoint Frame2d.xy
--> Point2d.origin

Get the X direction of a given frame.

Frame2d.xDirection Frame2d.xy
--> Direction2d.x

Get the Y direction of a given frame.

Frame2d.yDirection Frame2d.xy
--> Direction2d.y

Check if a frame is right-handed.

Frame2d.isRightHanded Frame2d.xy
--> True


Frame2d.isRightHanded (Frame2d.flipX Frame2d.xy)
--> False

All predefined frames are right-handed, and most operations on frames preserve handedness, so about the only ways to end up with a left-handed frame are by constructing one explicitly or by mirroring a right-handed frame.

Get the X axis of a given frame (the axis formed from the frame's origin point and X direction).

Frame2d.xAxis Frame2d.xy
--> Axis2d.x

Get the Y axis of a given frame (the axis formed from the frame's origin point and Y direction).

Frame2d.yAxis Frame2d.xy
--> Axis2d.y

Reverse the X direction of a frame, leaving its Y direction and origin point the same.

Frame2d.flipX Frame2d.xy
--> Frame2d
-->     { originPoint = Point2d.origin
-->     , xDirection = Direction2d.negativeX
-->     , yDirection = Direction2d.positiveY
-->     }

Note that this will switch the handedness of the frame.

Reverse the Y direction of a frame, leaving its X direction and origin point the same.

Frame2d.flipY Frame2d.xy
--> Frame2d
-->     { originPoint = Point2d.origin
-->     , xDirection = Direction2d.positiveX
-->     , yDirection = Direction2d.negativeY
-->     }

Note that this will switch the handedness of the frame.

Move a frame so that it has the given origin point.

frame =
    Frame2d
        { point = Point2d ( 2, 3 )
        , xDirection = Direction2d ( 0.8, 0.6 )
        , yDirection = Direction2d ( -0.6, 0.8 )
        }


Frame2d.moveTo (Point2d ( 1, 1 )) frame
--> Frame2d
-->     { point = Point2d ( 1, 1 )
-->     , xDirection = Direction2d ( 0.8, 0.6 )
-->     , yDirection = Direction2d ( -0.6, 0.8 )
-->     }

Rotate a frame counterclockwise by a given angle around the frame's own origin point. The resulting frame will have the same origin point, and its X and Y directions will be rotated by the given angle.

frame =
    Frame2d.at (Point2d ( 1, 1 ))


Frame2d.rotateBy (degrees 45) frame
--> Frame2d
-->     { originPoint = Point2d ( 1, 1 )
-->     , xDirection = Direction2d ( 0.7071, 0.7071 )
-->     , yDirection = Direction2d ( -0.7071, 0.7071 )
-->     }

Rotate a frame counterclockwise around a given point by a given angle. The frame's origin point will be rotated around the given point by the given angle, and its X and Y basis directions will be rotated by the given angle.

frame =
    Frame2d.at (Point2d ( 1, 1 ))


Frame2d.rotateAround Point2d.origin (degrees 45) frame
--> Frame2d
-->     { originPoint = Point2d ( 0, 1.4142 )
-->     , xDirection = Direction2d ( 0.7071, 0.7071 )
-->     , yDirection = Direction2d ( -0.7071, 0.7071 )
-->     }

Translate a frame by a given displacement.

frame =
    Frame2d.at (Point2d ( 2, 3 ))


displacement =
    Vector2d ( 1, 1 )


Frame2d.translateBy displacement frame
--> Frame2d.at (Point2d ( 3, 4 ))

Translate a frame along one of its own axes by a given distance.

The first argument is a function that returns the axis to translate along, given the current frame. The majority of the time this argument will be either Frame2d.xAxis or Frame2d.yAxis. The second argument is the distance to translate along the given axis.

This function is convenient when constructing frames via a series of transformations. For example,

Frame2d.at (Point2d ( 2, 0 ))
    |> Frame2d.rotateBy (degrees 45)
    |> Frame2d.translateAlongOwn Frame2d.xAxis 2

means "construct a frame at the point (2, 0), rotate it around its own origin point by 45 degrees, then translate it along its own X axis by 2 units", resulting in

Frame2d
    { originPoint = Point2d ( 3.4142, 1.4142 )
    , xDirection = Direction2d ( 0.7071, 0.7071 )
    , yDirection = Direction2d ( -0.7071, 0.7071 )
    }

Mirror a frame across an axis.

frame =
    Frame2d.at (Point2d ( 2, 3 ))


Frame2d.mirrorAcross Axis2d.x frame
--> Frame2d
-->     { originPoint = Point2d ( 2, -3 )
-->     , xDirection = Direction2d.positiveX
-->     , yDirection = Direction2d.negativeY
-->     }

Note that this will switch the handedness of the frame.

Take two frames defined in global coordinates, and return the second one expressed in local coordinates relative to the first.

Take one frame defined in global coordinates and a second frame defined in local coordinates relative to the first frame, and return the second frame expressed in global coordinates.