korge-foundation/korlibs.math.geom.vector/VectorPath

VectorPath

class VectorPath(val commands: IntArrayList = IntArrayList(), val data: DoubleArrayList = DoubleArrayList(), var winding: Winding = Winding.DEFAULT, var optimize: Boolean = true) : AbstractShape2D, IVectorPath, Extra

Constructors

VectorPath

constructor(commands: IntArrayList = IntArrayList(), data: DoubleArrayList = DoubleArrayList(), winding: Winding = Winding.DEFAULT, optimize: Boolean = true)

Types

object Command

object Companion

class Stats

interface Visitor

Properties

area

open override val area: Double

assumeConvex

var assumeConvex: Boolean

cachedPoints

val VectorPath.cachedPoints: PointList

center

open val center: Point

closed

open val closed: Boolean

commands

val commands: IntArrayList

data

val data: DoubleArrayList

extra

open override var extra: ExtraType

isLastCommandClose

val isLastCommandClose: Boolean

lastMovePos

open override var lastMovePos: Vector2D

lastPos

open override var lastPos: Vector2D

optimize

var optimize: Boolean

perimeter

open val perimeter: Double

scanline

val scanline: PolygonScanline

totalPoints

open override val totalPoints: Int

trapezoids

val trapezoids: VectorPathTrapezoids

version

var version: Int

winding

var winding: Winding

Functions

append

open override fun VectorBuilder.append(p0: Point, p1: Point, width: Double)

appendFrom

fun appendFrom(other: VectorPath)

applyTransform

fun VectorPath.applyTransform(m: Matrix): VectorPath

arc

open fun arc(center: Point, r: Double, start: Angle, end: Angle, counterclockwise: Boolean = false)

arcTo

open fun arcTo(a: Point, c: Point, r: Double)

open fun arcTo(a: Point, c: Point, r: Float)

arrow

fun VectorBuilder.arrow(p0: Point, p1: Point, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

arrowTo

fun VectorBuilder.arrowTo(p: Point, capEnd: ArrowCap = ArrowCap.Line(null), capStart: ArrowCap = ArrowCap.NoCap)

ceil

fun ceil(): VectorPath

circle

open fun circle(circle: Circle)

open fun circle(center: Point, radius: Double)

circle

inline fun VectorBuilder.circle(center: Point, radius: Number)

circleHole

open fun circleHole(circle: Circle)

open fun circleHole(center: Point, radius: Double)

circleHole

inline fun VectorBuilder.circleHole(center: Point, radius: Number)

clear

fun clear()

clone

fun clone(): VectorPath

open override fun close()

containsPoint

open fun ~~containsPoint~~(ml: Matrix, p: Point, mr: Matrix): Boolean

ml transformation matrix of this Shape2D, mr transformation matrix of the point p

fun containsPoint(p: MPoint): Boolean

open override fun containsPoint(p: Point): Boolean

fun containsPoint(x: Double, y: Double): Boolean

fun containsPoint(x: Float, y: Float): Boolean

fun containsPoint(x: Int, y: Int): Boolean

fun containsPoint(x: Double, y: Double, winding: Winding): Boolean

fun containsPoint(x: Float, y: Float, winding: Winding): Boolean

fun containsPoint(x: Int, y: Int, winding: Winding): Boolean

cubic

open fun cubic(o: Point, c1: Point, c2: Point, a: Point)

cubicTo

open fun cubicTo(c1x: Double, c1y: Double, c2x: Double, c2y: Double, ax: Double, ay: Double)

open fun cubicTo(c1x: Float, c1y: Float, c2x: Float, c2y: Float, ax: Float, ay: Float)

open fun cubicTo(c1x: Int, c1y: Int, c2x: Int, c2y: Int, ax: Int, ay: Int)

open override fun cubicTo(c1: Point, c2: Point, a: Point)

cubicTo

fun VectorBuilder.cubicTo(c1: Point, c2: Point, a: Point, m: Matrix = Matrix.NIL)

curve

open fun curve(curve: Bezier)

curves

open fun curves(curves: Curves)

open fun curves(curves: List<Curves>)

distance

open override fun distance(p: Point): Double

Compute the distance to the shortest point to the edge (SDF). Negative inside. Positive outside.

open fun ~~distance~~(ml: Matrix, p: Point, mr: Matrix): Double

ml transformation matrix of this Shape2D, mr transformation matrix of the point p

ellipse

open fun ellipse(ellipse: Ellipse)

open fun ellipse(bounds: Rectangle)

open fun ellipse(center: Point, radius: Size)

emitEdges

inline fun VectorPath.emitEdges(crossinline edge: (Point, Point) -> Unit)

emitPoints2

inline fun VectorPath.emitPoints2(crossinline flush: (close: Boolean) -> Unit = {}, crossinline joint: (close: Boolean) -> Unit = {}, crossinline emit: (Point, move: Boolean) -> Unit)

equals

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

extraCache

fun <T> Extra.extraCache(name: String, block: () -> T): T

floor

fun floor(): VectorPath

getBounds

open override fun getBounds(): Rectangle

getBVHBeziers

fun VectorPath.getBVHBeziers(): BVH2D<Bezier>

getCurves

fun VectorPath.getCurves(): Curves

getCurvesList

fun VectorPath.getCurvesList(): List<Curves>

getExtra

fun Extra.getExtra(name: String): Any?

getExtraTyped

fun <T> Extra.getExtraTyped(name: String): T?

getLineIntersection

fun getLineIntersection(line: Line, out: LineIntersection = LineIntersection()): LineIntersection?

getPoints2List

fun VectorPath.getPoints2List(): List<PointArrayList>

hasExtra

fun Extra.hasExtra(name: String): Boolean

hashCode

open override fun hashCode(): Int

intersectionsWith

open fun intersectionsWith(that: Shape2D): PointList

open fun intersectionsWith(ml: Matrix, that: Shape2D, mr: Matrix): PointList

ml transformation matrix of this Shape2D, mr transformation matrix of the shape that

intersectsWith

open fun intersectsWith(that: Shape2D): Boolean

open fun intersectsWith(ml: Matrix, that: Shape2D, mr: Matrix): Boolean

fun intersectsWith(right: VectorPath): Boolean

fun intersectsWith(leftMatrix: Matrix, right: VectorPath, rightMatrix: Matrix): Boolean

isEmpty

open fun isEmpty(): Boolean

isNotEmpty

open fun isNotEmpty(): Boolean

line

open fun line(p0: Point, p1: Point)

lineTo

open fun lineTo(x: Double, y: Double)

open fun lineTo(x: Float, y: Float)

open fun lineTo(x: Int, y: Int)

open override fun lineTo(p: Point)

lineTo

fun VectorBuilder.lineTo(p: Point, m: Matrix = Matrix.NIL)

lineToH

open fun lineToH(x: Double)

lineToV

open fun lineToV(y: Double)

moveTo

open fun moveTo(x: Double, y: Double)

open fun moveTo(x: Float, y: Float)

open fun moveTo(x: Int, y: Int)

open override fun moveTo(p: Point)

moveTo

fun VectorBuilder.moveTo(p: Point, m: Matrix = Matrix.NIL)

moveToH

open fun moveToH(x: Double)

moveToV

open fun moveToV(y: Double)

normalVectorAt

open override fun normalVectorAt(p: Point): Vector2D

Returns the normal vector to the shortest point to the edge

open fun ~~normalVectorAt~~(ml: Matrix, p: Point, mr: Matrix): Point

ml transformation matrix of this Shape2D, mr transformation matrix of the point p

optimizeLastCommand

fun optimizeLastCommand()

parallelogram

open fun parallelogram(bounds: Rectangle, angle: Angle = 30.degrees, direction: Boolean = true)

Creates a parallelogram where the inner part is within bounds.

path

fun VectorBuilder.path(path: VectorPath?)

fun VectorBuilder.path(path: VectorPath, m: Matrix = Matrix.NIL)

polyArrows

fun VectorBuilder.polyArrows(points: PointList, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

fun VectorBuilder.polyArrows(vararg points: Point, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

fun VectorBuilder.polyArrows(points: List<Point>, capEnd: ArrowCap = ArrowCap.Line(), capStart: ArrowCap = ArrowCap.NoCap)

Creates a polyline from points adding arrow caps (capEnd and capStart) in each segment. Useful for displaying directed graphs

polygon

open fun polygon(path: PointList, close: Boolean = true)

open fun polygon(vararg path: Point, close: Boolean = true)

open fun polygon(path: List<Point>, close: Boolean = true)

polyline

open fun polyline(points: PointList, close: Boolean = false)

open fun polyline(vararg points: Point, close: Boolean = false)

open fun polyline(points: List<Point>, close: Boolean = false)

projectedPoint

open override fun projectedPoint(p: Point): Point

Point projected to the closest edge

open fun ~~projectedPoint~~(ml: Matrix, p: Point, mr: Matrix): Point

ml transformation matrix of this Shape2D, mr transformation matrix of the point p

quad

open fun quad(o: Point, c: Point, a: Point)

quadTo

open fun quadTo(cx: Double, cy: Double, ax: Double, ay: Double)

open fun quadTo(cx: Float, cy: Float, ax: Float, ay: Float)

open fun quadTo(cx: Int, cy: Int, ax: Int, ay: Int)

open override fun quadTo(c: Point, a: Point)

quadTo

fun VectorBuilder.quadTo(c: Point, a: Point, m: Matrix = Matrix.NIL)

rCubicTo

open fun rCubicTo(c1: Point, c2: Point, a: Point)

open fun rCubicTo(c1: Point, c2: Point, a: Point, relative: Boolean)

readStats

fun readStats(out: VectorPath.Stats = Stats()): VectorPath.Stats

rect

open fun rect(rect: Rectangle)

open fun rect(rect: RectangleInt)

open fun rect(pos: Point, size: Size)

open fun rect(x: Double, y: Double, width: Double, height: Double)

open fun rect(x: Float, y: Float, width: Float, height: Float)

open fun rect(x: Int, y: Int, width: Int, height: Int)

rectHole

open fun rectHole(rect: Rectangle)

open fun rectHole(x: Double, y: Double, width: Double, height: Double)

open fun rectHole(x: Float, y: Float, width: Float, height: Float)

open fun rectHole(x: Int, y: Int, width: Int, height: Int)

regularPolygon

open fun regularPolygon(points: Int, radius: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

regularPolygonHole

open fun regularPolygonHole(points: Int, radius: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

removeLastCommand

fun removeLastCommand()

rLineTo

open fun rLineTo(delta: Point)

open fun rLineTo(a: Point, relative: Boolean)

rLineToH

open fun rLineToH(x: Double)

open fun rLineToH(x: Double, relative: Boolean)

rLineToHV

open fun rLineToHV(value: Double, horizontal: Boolean)

rLineToV

open fun rLineToV(y: Double)

open fun rLineToV(y: Double, relative: Boolean)

rMoveTo

open fun rMoveTo(delta: Point)

open fun rMoveTo(a: Point, relative: Boolean)

rMoveToH

open fun rMoveToH(x: Double)

open fun rMoveToH(x: Double, relative: Boolean)

rMoveToHV

open fun rMoveToHV(value: Double, horizontal: Boolean)

rMoveToV

open fun rMoveToV(y: Double)

open fun rMoveToV(y: Double, relative: Boolean)

round

fun round(): VectorPath

roundDecimalPlaces

fun roundDecimalPlaces(places: Int): VectorPath

roundRect

open fun roundRect(rect: RoundRectangle)

open fun roundRect(x: Double, y: Double, w: Double, h: Double, rx: Double, ry: Double = rx)

open fun roundRect(x: Float, y: Float, w: Float, h: Float, rx: Float, ry: Float = rx)

open fun roundRect(x: Int, y: Int, w: Int, h: Int, rx: Int, ry: Int = rx)

open fun roundRect(x: Double, y: Double, w: Double, h: Double, rtl: Double, rtr: Double, rbr: Double, rbl: Double)

rQuadTo

open fun rQuadTo(c: Point, a: Point)

open fun rQuadTo(c: Point, a: Point, relative: Boolean)

scale

fun scale(sx: Double, sy: Double = sx): VectorPath

setExtra

fun Extra.setExtra(name: String, value: Any?)

setFrom

fun setFrom(other: VectorPath)

star

open fun star(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

starHole

open fun starHole(points: Int, radiusSmall: Double, radiusBig: Double, rotated: Angle = 0.degrees, x: Double = 0.0, y: Double = 0.0)

strokeToFill

fun VectorPath.strokeToFill(info: StrokeInfo, temp: StrokeToFill = StrokeToFill(), outFill: VectorPath = VectorPath(winding = Winding.NON_ZERO)): VectorPath

fun VectorPath.strokeToFill(lineWidth: Double, joins: LineJoin = LineJoin.MITER, startCap: LineCap = LineCap.BUTT, endCap: LineCap = startCap, miterLimit: Double = 4.0, lineDash: DoubleList? = null, lineDashOffset: Double = 0.0, temp: StrokeToFill = StrokeToFill(), outFill: VectorPath = VectorPath(winding = Winding.NON_ZERO)): VectorPath

toCurves

fun VectorPath.toCurves(): Curves

toCurvesList

fun VectorPath.toCurvesList(): List<Curves>

toHitTestable

fun VectorPath.toHitTestable(testDirections: HitTestDirectionFlags): HitTestable

toPathPointList

fun VectorPath.toPathPointList(m: Matrix = Matrix.NIL, emitClosePoint: Boolean = false): List<PointList>

toSegments

fun VectorPath.toSegments(scale: Int = 1): FSegmentsInt

toShape2D

fun Shape2D.toShape2D(): Shape2D

fun VectorPath.toShape2D(closed: Boolean = true): Shape2D

toShape2d

fun Shape2D.~~toShape2d~~(): Shape2D

fun VectorPath.~~toShape2d~~(closed: Boolean = true): Shape2D

toShape2DNew

fun VectorPath.toShape2DNew(closed: Boolean = true): Shape2D

toShape2dNew

fun VectorPath.~~toShape2dNew~~(closed: Boolean = true): Shape2D

toShape2DOld

fun VectorPath.toShape2DOld(closed: Boolean = true): Shape2D

toShape2dOld

fun VectorPath.~~toShape2dOld~~(closed: Boolean = true): Shape2D

toString

open override fun toString(): String

toStrokePointsList

fun VectorPath.toStrokePointsList(info: StrokeInfo, mode: StrokePointsMode = StrokePointsMode.NON_SCALABLE_POS, generateDebug: Boolean = false, forceClosed: Boolean? = null): List<StrokePoints>

toSvgString

open override fun toSvgString(): String

toTrapezoids

fun VectorPath.toTrapezoids(scale: Int = 1, winding: Winding = this.winding, out: FTrapezoidsInt = FTrapezoidsInt()): FTrapezoidsInt

toVectorPath

open override fun toVectorPath(): VectorPath

transformed

open fun transformed(m: Matrix): VectorBuilder

open fun <T> transformed(m: Matrix, block: VectorBuilder.() -> T): T

transformPoints

inline fun transformPoints(transform: (Point) -> Point): VectorPath

visit

fun visit(visitor: VectorPath.Visitor)

visitCmds

inline fun visitCmds(moveTo: (Point) -> Unit, lineTo: (Point) -> Unit, quadTo: (Point, Point) -> Unit, cubicTo: (Point, Point, Point) -> Unit, close: () -> Unit)

visitEdges

inline fun visitEdges(line: (Point, Point) -> Unit, quad: (Point, Point, Point) -> Unit, cubic: (Point, Point, Point, Point) -> Unit, close: () -> Unit = {}, move: (Point) -> Unit = { }, dummy: Unit = Unit, optimizeClose: Boolean = true)

visitEdgesSimple

inline fun visitEdgesSimple(line: (Point, Point) -> Unit, cubic: (Point, Point, Point, Point) -> Unit, close: () -> Unit)

write

open fun write(curves: Curves)

open fun write(curves: List<Curves>)

fun write(path: VectorPath, transform: Matrix = Matrix.IDENTITY)

write

fun VectorBuilder.write(path: VectorPath)

fun VectorBuilder.write(path: VectorPath, m: Matrix = Matrix.NIL)