openrndr-shape/org.openrndr.shape/Segment

Segment

class Segment : ShapeContourProvider(source)

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

Segment

@JvmOverloads

constructor(start: Vector2, end: Vector2, corner: Boolean = true)

Linear segment constructor.

@JvmOverloads

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

Quadratic Bézier segment constructor.

@JvmOverloads

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

Cubic Bézier segment constructor.

@JvmOverloads

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

Functions

adaptivePositions

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

Recursively subdivides Segment to approximate Bézier curve.

adaptivePositionsWithT

fun adaptivePositionsWithT(distanceTolerance: Double = 0.5): List<Pair<Vector2, Double>>

copy

fun copy(start: Vector2 = this.start, control: Array<Vector2> = this.control, end: Vector2 = this.end): Segment

Returns a shallow copy of the Segment.

derivative

fun derivative(t: Double): Vector2

direction

fun direction(): Vector2

Returns the direction Vector2 of between the Segment anchor points.

fun direction(t: Double): Vector2

div

operator fun div(scale: Double): Segment

equals

open operator override fun equals(other: Any?): Boolean

equidistantPositions

fun equidistantPositions(pointCount: Int, distanceTolerance: Double = 0.5): List<Vector2>

Samples specified amount of points on the Segment.

equidistantPositionsWithT

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

extrema

fun extrema(): List<Double>

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

extremaPoints

fun extremaPoints(): List<Vector2>

Returns the extrema points as Vector2s for current Segment

hashCode

open override fun hashCode(): Int

intersections

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

Calculates a List of all points where two Segments intersect.

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

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

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

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

isStraight

fun isStraight(epsilon: Double = 0.01): Boolean

Determines if the Segment forms a straight line.

lut

fun lut(size: Int = 100): List<Vector2>

minus

operator fun minus(right: Segment): Segment

nearest

fun nearest(point: Vector2): SegmentPoint

Find point on segment nearest to given point.

normal

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.

offset

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?

plus

operator fun plus(right: Segment): Segment

pointAtLength

fun pointAtLength(length: Double, distanceTolerance: Double = 0.5): Vector2

Calculates the point at a given distance along this Segment.

pose

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.

position

fun position(ut: Double): Vector2

Returns a point on the segment.

reduced

fun reduced(stepSize: Double = 0.01): List<Segment>

scale

fun scale(scale: Double, polarity: YPolarity): Segment

fun scale(polarity: YPolarity, scale: (Double) -> Double): Segment

split

fun split(t: Double): Array<Segment>

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

sub

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

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

tForLength

fun tForLength(length: Double): Double

Estimate t value for a given length

times

operator fun times(scale: Double): Segment

toString

open override fun toString(): String

transform

fun transform(transform: Matrix44): Segment

Applies given linear transformation.

Properties

bounds

val bounds: Rectangle

Returns the bounding box.

clockwise

val clockwise: Boolean

contour

open override val contour: ShapeContour

the provided contour

control

val control: Array<Vector2>

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

corner

val corner: Boolean

cubic

val cubic: Segment

Converts the Segment to a cubic Bézier curve.

end

val end: Vector2

The end point of the Segment.

length

val length: Double

Calculates approximate Euclidean length of the Segment.

linear

val linear: Boolean

Indicates whether or not the Segment is linear.

quadratic

val quadratic: Segment

Converts the Segment to a quadratic Bézier curve.

reverse

val reverse: Segment

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

simple

val simple: Boolean

start

val start: Vector2

The start point of the Segment.

type

val type: SegmentType

Returns the type of the segment.