Module Mlpost.Point

Points in the plane

The abstract type for points

val pt : (Num.t * Num.t) -> t

Construct a point from two numeric values

The following functions create points of length 1. They are especially useful to specify directions with Path.Vec

val dir : float -> t

dir f is the point at angle f on the unit circle. f shall be given in degrees

The unitary vectors pointing up, down, left and right

val up : t
val down : t
val left : t
val right : t
val origin : t
val length : t -> Num.t

length p is the length of vector from the origin to p

val xpart : t -> Num.t

xpart p is the x coordinate of point p

val ypart : t -> Num.t

ypart p is the y coordinate of point p

Operations on points

val transform : Transform.t -> t -> t

Apply a transformation to a point

val segment : float -> t -> t -> t

segment f p1 p2 is the point (1-f)p1 + fp2. Stated otherwise, if p1 is at 0. and p2 is at 1., return the point that lies at f

val add : t -> t -> t
val shift : t -> t -> t

Sum two points

val sub : t -> t -> t

Substract two points

val mult : Num.t -> t -> t
val scale : Num.t -> t -> t

Multiply a point by a scalar

val rotate : float -> t -> t

Rotate a point by an angle in degrees

val rotate_around : t -> float -> t -> t

rotate_around p1 f p2 rotates p2 around p1 by an angle f in degrees

val xscale : Num.t -> t -> t

Scales the X coordinate of a point by a scalar

val yscale : Num.t -> t -> t

Scales the Y coordinate of a point by a scalar

val normalize : t -> t

Normalize the vector represented by the point. The origin becomes the origin

Convenient constructors

The following functions build a point at a given scale (see Num.t for scales)

val bpp : (float * float) -> t
val inp : (float * float) -> t
val cmp : (float * float) -> t
val mmp : (float * float) -> t
val ptp : (float * float) -> t

Same as the previous functions but build list of points

val map_bp : (float * float) list -> t list
val map_in : (float * float) list -> t list
val map_cm : (float * float) list -> t list
val map_mm : (float * float) list -> t list
val map_pt : (float * float) list -> t list
val p : ?scale:(float -> Num.t) -> (float * float) -> t

Builds a point from a pair of floats

  • parameter scale

    a scaling function to be applied to each float; see Num.t for scaling functions for usual units

val ptlist : ?scale:(float -> Num.t) -> (float * float) list -> t list

Same as p, but builds a list of points

val draw : ?brush:Brush.t -> ?color:Color.t -> ?pen:Pen.t -> t -> Command.t

Draw a point

  • parameter color

    the color of the point; default is black

  • parameter pen

    the pen used to draw the pen; default is Brush.Pen.default