Segment

class Segment : ShapeContourProvider

Creates a new Segment, which specifies a linear or a Bézier curve path between two anchor points (and up to two control points for curvature).

Constructors

fun Segment(    start: Vector2,     end: Vector2,     corner: Boolean = true)

Linear segment constructor.

fun Segment(    start: Vector2,     c0: Vector2,     end: Vector2,     corner: Boolean = true)

fun Segment(    start: Vector2,     c0: Vector2,     c1: Vector2,     end: Vector2,     corner: Boolean = true)

Cubic Bézier segment constructor.

fun Segment(    start: Vector2,     control: Array<Vector2>,     end: Vector2,     corner: Boolean = true)

Functions

fun adaptivePositions(distanceTolerance: Double = 0.5): List<Vector2>

Recursively subdivides Segment to approximate Bézier curve.

fun adaptivePositionsWithT(distanceTolerance: Double = 0.5): List<Pair<Vector2, Double>>
fun copy(    start: Vector2 = this.start,     control: Array<Vector2> = this.control,     end: Vector2 = this.end): Segment

Returns a shallow copy of the Segment.

fun derivative(t: Double): Vector2
fun direction(): Vector2

Returns the direction Vector2 of between the Segment anchor points.

fun direction(t: Double): Vector2
operator fun div(scale: Double): Segment
open operator override fun equals(other: Any?): Boolean
fun equidistantPositions(pointCount: Int, distanceTolerance: Double = 0.5): List<Vector2>

Samples specified amount of points on the Segment.

fun equidistantPositionsWithT(pointCount: Int, distanceTolerance: Double = 0.5): List<Pair<Vector2, Double>>
fun extrema(): List<Double>

Returns the t values of the extrema for the current Segment.

fun extremaPoints(): List<Vector2>

Returns the extrema points as Vector2s for current Segment

open override fun hashCode(): Int
fun isStraight(epsilon: Double = 0.01): Boolean

Determines if the Segment forms a straight line.

fun lut(size: Int = 100): List<Vector2>
operator fun minus(right: Segment): Segment
fun nearest(point: Vector2): SegmentPoint

Find point on segment nearest to given point.

fun normal(ut: Double, polarity: YPolarity = YPolarity.CW_NEGATIVE_Y): Vector2

Returns a normal Vector2 at given value of t in the range of `0.0` to `1.0`.

fun offset(    distance: Double,     stepSize: Double = 0.01,     yPolarity: YPolarity = YPolarity.CW_NEGATIVE_Y): List<Segment>
fun on(point: Vector2, error: Double = 5.0): Double?
operator fun plus(right: Segment): Segment
fun pointAtLength(length: Double, distanceTolerance: Double = 0.5): Vector2

Calculates the point at a given distance along this Segment.

fun pose(t: Double, polarity: YPolarity = YPolarity.CW_NEGATIVE_Y): Matrix44

Calculates the pose Matrix44 (i.e. translation and rotation) that describes an orthonormal basis formed by normal and tangent of the contour at t.

fun position(ut: Double): Vector2

Returns a point on the segment.

fun reduced(stepSize: Double = 0.01): List<Segment>
fun scale(scale: Double, polarity: YPolarity): Segment
fun scale(polarity: YPolarity, scale: (Double) -> Double): Segment
fun split(t: Double): Array<Segment>

Splits the path into one or two parts, depending on if the cut was successful.

fun sub(t0: Double, t1: Double): Segment

Samples a new Segment from the current Segment starting at t0 and ending at t1.

fun tForLength(length: Double): Double

Estimate t value for a given length

operator fun times(scale: Double): Segment
open override fun toString(): String
fun transform(transform: Matrix44): Segment

Applies given linear transformation.

Properties

val bounds: Rectangle

Returns the bounding box.

val clockwise: Boolean
open override val contour: ShapeContour

the provided contour

val control: Array<Vector2>

Array of control points which control the curvature of the Segment.

val corner: Boolean
val cubic: Segment

Converts the Segment to a cubic Bézier curve.

val end: Vector2

The end point of the Segment.

val length: Double

Calculates approximate Euclidean length of the Segment.

val linear: Boolean

Indicates whether or not the Segment is linear.

Converts the Segment to a quadratic Bézier curve.

val reverse: Segment

Reverses the order of control points of the given path Segment.

val simple: Boolean
val start: Vector2

The start point of the Segment.

val type: SegmentType

Returns the type of the segment.

Extensions

fun Segment.intersections(other: Segment): List<SegmentIntersection>

Calculates a List of all points where two Segments intersect.

fun Segment.intersections(other: ShapeContour): List<ContourIntersection>

Calculates a List of all points of where a Segment and a ShapeContour intersect.

fun Segment.intersections(other: Shape): List<ContourIntersection>

Calculates a List of all points of where a Segment and a Shape intersect.