Path
-
Cmn
interface Path
Summary
Nested types |
|---|
enum Path.Direction : EnumSpecifies how closed shapes (e.g. rectangles, ovals) are wound (oriented) when they are added to a path. |
Public companion functions |
||
|---|---|---|
Path |
combine(operation: PathOperation, path1: Path, path2: Path)Combines the two paths according to the manner specified by the given |
Cmn
|
Public functions |
||
|---|---|---|
Unit |
Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle degrees around the oval up to startAngle + sweepAngle degrees around the oval, with zero degrees being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval. |
Cmn
|
Unit |
Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle radians around the oval up to startAngle + sweepAngle radians around the oval, with zero radians being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval. |
Cmn
|
Unit |
addOval(oval: Rect, direction: Path.Direction)Adds a new subpath that consists of a curve that forms the ellipse that fills the given rectangle. |
Cmn
|
Unit |
Adds a new subpath that consists of the given |
Cmn
|
Unit |
addRect(rect: Rect, direction: Path.Direction)Adds a new subpath that consists of four lines that outline the given rectangle. |
Cmn
|
Unit |
addRoundRect(roundRect: RoundRect, direction: Path.Direction)Add a round rectangle shape to the path from the given |
Cmn
|
open infix Path |
Returns the intersection of two paths as a new |
Cmn
|
Unit |
If the |
Cmn
|
open Unit |
If the |
Cmn
|
Unit |
close()Closes the last subpath, as if a straight line had been drawn from the current point to the first point of the subpath. |
Cmn
|
Unit |
Adds a cubic bezier segment that curves from the current point to the given point ( |
Cmn
|
Rect |
Compute the bounds of the control points of the path, and write the answer into bounds. |
Cmn
|
open operator PathIterator |
iterator()Creates a new |
Cmn
|
open PathIterator |
iterator(conicEvaluation: PathIterator.ConicEvaluation, tolerance: Float)Creates a new |
Cmn
|
Unit |
Adds a straight line segment from the current point to the given point |
Cmn
|
open operator Path |
Returns the difference of two paths as a new |
Cmn
|
Unit |
Starts a new subpath at the given coordinate |
Cmn
|
Boolean |
op(path1: Path, path2: Path, operation: PathOperation)Set this path to the result of applying the Op to the two specified paths. |
Cmn
|
open infix Path |
Returns the union of two paths as a new |
Cmn
|
open operator Path |
Returns the union of two paths as a new |
Cmn
|
Unit |
This function is deprecated. Use quadraticTo() for consistency with cubicTo() |
Cmn
|
open Unit |
quadraticTo(x1: Float, y1: Float, x2: Float, y2: Float)Adds a quadratic bezier segment that curves from the current point to the given point ( |
Cmn
|
Unit |
Adds a cubic bezier segment that curves from the current point to the point at the offset ( |
Cmn
|
Unit |
relativeLineTo(dx: Float, dy: Float)Adds a straight line segment from the current point to the point at the given offset from the current point. |
Cmn
|
Unit |
relativeMoveTo(dx: Float, dy: Float)Starts a new subpath at the given offset from the current point |
Cmn
|
Unit |
This function is deprecated. Use relativeQuadraticTo() for consistency with relativeCubicTo() |
Cmn
|
open Unit |
relativeQuadraticTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float)Adds a quadratic bezier segment that curves from the current point to the point at the offset ( |
Cmn
|
Unit |
reset()Clears the |
Cmn
|
open Unit |
rewind()Rewinds the path: clears any lines and curves from the path but keeps the internal data structure for faster reuse. |
Cmn
|
open Unit |
Transform the points in this path by the provided matrix |
Cmn
|
Unit |
Translates all the segments of every subpath by the given offset. |
Cmn
|
open infix Path |
Returns the union minus the intersection of two paths as a new |
Cmn
|
Public properties |
||
|---|---|---|
PathFillType |
Determines how the interior of this path is calculated. |
Cmn
|
Boolean |
Returns the path's convexity, as defined by the content of the path. |
Cmn
|
Boolean |
Returns true if the path is empty (contains no lines or curves) |
Cmn
|
Extension functions |
||
|---|---|---|
inline Path |
android
|
|
Unit |
Path.addOutline(outline: Outline) |
Cmn
|
Path.Direction |
Computes this |
Cmn
|
MutableList<Path> |
Path.divide(contours: MutableList<Path>)Divides this path into a list of paths. |
Cmn
|
Path |
Reverses the segments of this path into the specified |
Cmn
|
Path |
Create a new path, copying the contents from the src path. |
Cmn
|
Unit |
Cmn
|
|
String |
Returns an SVG representation of this path. |
Cmn
|
Public companion functions
combine
fun combine(operation: PathOperation, path1: Path, path2: Path): Path
Combines the two paths according to the manner specified by the given operation.
The resulting path will be constructed from non-overlapping contours. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.
Throws IllegalArgumentException if the combining operation fails.
Public functions
addArc
fun addArc(oval: Rect, startAngleDegrees: Float, sweepAngleDegrees: Float): Unit
Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle degrees around the oval up to startAngle + sweepAngle degrees around the oval, with zero degrees being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.
addArcRad
fun addArcRad(oval: Rect, startAngleRadians: Float, sweepAngleRadians: Float): Unit
Adds a new subpath with one arc segment that consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle radians around the oval up to startAngle + sweepAngle radians around the oval, with zero radians being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.
addOval
fun addOval(oval: Rect, direction: Path.Direction = Direction.CounterClockwise): Unit
Adds a new subpath that consists of a curve that forms the ellipse that fills the given rectangle.
To add a circle, pass an appropriate rectangle as oval. Rect can be used to easily describe the circle's center Offset and radius.
The direction to wind the rectangle's contour is specified by direction.
addPath
fun addPath(path: Path, offset: Offset = Offset.Zero): Unit
Adds a new subpath that consists of the given path offset by the given offset.
addRect
fun addRect(rect: Rect, direction: Path.Direction = Direction.CounterClockwise): Unit
Adds a new subpath that consists of four lines that outline the given rectangle. The direction to wind the rectangle's contour is specified by direction.
addRoundRect
fun addRoundRect(
roundRect: RoundRect,
direction: Path.Direction = Direction.CounterClockwise
): Unit
Add a round rectangle shape to the path from the given RoundRect. The direction to wind the rectangle's contour is specified by direction.
and
open infix fun and(path: Path): Path
Returns the intersection of two paths as a new Path. If the paths do not intersect, returns an empty path.
arcTo
fun arcTo(
rect: Rect,
startAngleDegrees: Float,
sweepAngleDegrees: Float,
forceMoveTo: Boolean
): Unit
If the forceMoveTo argument is false, adds a straight line segment and an arc segment.
If the forceMoveTo argument is true, starts a new subpath consisting of an arc segment.
In either case, the arc segment consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle degrees around the oval up to startAngle + sweepAngle degrees around the oval, with zero degrees being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.
The line segment added if forceMoveTo is false starts at the current point and ends at the start of the arc.
arcToRad
open fun arcToRad(
rect: Rect,
startAngleRadians: Float,
sweepAngleRadians: Float,
forceMoveTo: Boolean
): Unit
If the forceMoveTo argument is false, adds a straight line segment and an arc segment.
If the forceMoveTo argument is true, starts a new subpath consisting of an arc segment.
In either case, the arc segment consists of the arc that follows the edge of the oval bounded by the given rectangle, from startAngle radians around the oval up to startAngle + sweepAngle radians around the oval, with zero radians being the point on the right hand side of the oval that crosses the horizontal line that intersects the center of the rectangle and with positive angles going clockwise around the oval.
The line segment added if forceMoveTo is false starts at the current point and ends at the start of the arc.
close
fun close(): Unit
Closes the last subpath, as if a straight line had been drawn from the current point to the first point of the subpath.
cubicTo
fun cubicTo(x1: Float, y1: Float, x2: Float, y2: Float, x3: Float, y3: Float): Unit
Adds a cubic bezier segment that curves from the current point to the given point (x3, y3), using the control points (x1, y1) and (x2, y2).
getBounds
fun getBounds(): Rect
Compute the bounds of the control points of the path, and write the answer into bounds. If the path contains 0 or 1 points, the bounds is set to (0,0,0,0)
iterator
open operator fun iterator(): PathIterator
Creates a new PathIterator for this Path that evaluates conics as quadratics. To preserve conics, use the Path.iterator function that takes a PathIterator.ConicEvaluation parameter.
iterator
open fun iterator(
conicEvaluation: PathIterator.ConicEvaluation,
tolerance: Float = 0.25f
): PathIterator
Creates a new PathIterator for this Path. To preserve conics as conics (not convert them to quadratics), set conicEvaluation to PathIterator.ConicEvaluation.AsConic.
| Parameters | |
|---|---|
conicEvaluation: PathIterator.ConicEvaluation |
Indicates how to evaluate conic segments |
tolerance: Float = 0.25f |
When |
lineTo
fun lineTo(x: Float, y: Float): Unit
Adds a straight line segment from the current point to the given point
op
fun op(path1: Path, path2: Path, operation: PathOperation): Boolean
Set this path to the result of applying the Op to the two specified paths. The resulting path will be constructed from non-overlapping contours. The curve order is reduced where possible so that cubics may be turned into quadratics, and quadratics maybe turned into lines.
| Parameters | |
|---|---|
path1: Path |
The first operand (for difference, the minuend) |
path2: Path |
The second operand (for difference, the subtrahend) |
operation: PathOperation |
|
| Returns | |
|---|---|
Boolean |
True if operation succeeded, false otherwise and this path remains unmodified. |
quadraticBezierTo
funquadraticBezierTo(x1: Float, y1: Float, x2: Float, y2: Float): Unit
Adds a quadratic bezier segment that curves from the current point to the given point (x2, y2), using the control point (x1, y1).
quadraticTo
open fun quadraticTo(x1: Float, y1: Float, x2: Float, y2: Float): Unit
Adds a quadratic bezier segment that curves from the current point to the given point (x2, y2), using the control point (x1, y1).
relativeCubicTo
fun relativeCubicTo(
dx1: Float,
dy1: Float,
dx2: Float,
dy2: Float,
dx3: Float,
dy3: Float
): Unit
Adds a cubic bezier segment that curves from the current point to the point at the offset (dx3, dy3) from the current point, using the control points at the offsets (dx1, dy1) and (dx2, dy2) from the current point.
relativeLineTo
fun relativeLineTo(dx: Float, dy: Float): Unit
Adds a straight line segment from the current point to the point at the given offset from the current point.
relativeMoveTo
fun relativeMoveTo(dx: Float, dy: Float): Unit
Starts a new subpath at the given offset from the current point
relativeQuadraticBezierTo
funrelativeQuadraticBezierTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float): Unit
Adds a quadratic bezier segment that curves from the current point to the point at the offset (dx2, dy2) from the current point, using the control point at the offset (dx1, dy1) from the current point.
relativeQuadraticTo
open fun relativeQuadraticTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float): Unit
Adds a quadratic bezier segment that curves from the current point to the point at the offset (dx2, dy2) from the current point, using the control point at the offset (dx1, dy1) from the current point.
reset
fun reset(): Unit
Clears the Path object of all subpaths, returning it to the same state it had when it was created. The current point is reset to the origin. This does NOT change the fill-type setting.
rewind
open fun rewind(): Unit
Rewinds the path: clears any lines and curves from the path but keeps the internal data structure for faster reuse.
transform
open fun transform(matrix: Matrix): Unit
Transform the points in this path by the provided matrix
Public properties
fillType
var fillType: PathFillType
Determines how the interior of this path is calculated.
Defaults to the non-zero winding rule, PathFillType.NonZero.
Extension functions
asAndroidPath
inline fun Path.asAndroidPath(): Path
| Throws | |
|---|---|
kotlin.UnsupportedOperationException |
if this Path is not backed by an |
computeDirection
fun Path.computeDirection(): Path.Direction
Computes this Path's direction (or winding, or orientation), which can be either Path.Direction.Clockwise or Path.Direction.CounterClockwise.
If the path is made of multiple contours (the path contains multiple "move" commands), the direction returned by this property is the direction of the first contour.
If the path is empty (contains no lines/curves), the direction is Path.Direction.Clockwise.
If the path has no area (single straight line), the direction is Path.Direction.Clockwise.
Calling this property does not cache the result, the direction is computed Calling this method does not cache the result, the direction is computed every time the method is called.
If you need to query the direction of individual contours, you should divide the path first.
divide
fun Path.divide(contours: MutableList<Path> = mutableListOf()): MutableList<Path>
Divides this path into a list of paths. Each contour inside this path is returned as a separate Path. For instance the following code snippet creates two rectangular contours:
val p = Path()
p.addRect(...)
p.addRect(...)
val contours = p.divide()
The list returned by calling p.divide() will contain two Path instances, each representing one of the two rectangles.
Empty contours (contours with no lines/curves) are omitted from the resulting list.
| Parameters | |
|---|---|
contours: MutableList<Path> = mutableListOf() |
An optional mutable list of |
| Returns | |
|---|---|
MutableList<Path> |
A list of |
reverse
fun Path.reverse(destination: Path = Path()): Path
Reverses the segments of this path into the specified destination, turning a clockwise path into a counter-clockwise path and vice-versa. Each contour in the path is reversed independently, and the contours appear in the destination in reverse order.
This method preserves the general structure of this path as much as possible:
-
Lines become lines
-
Quadratic Bézier curves become quadratic Bézier curves
-
Cubic Bézier curves become cubic Bézier curves
-
Close and move commands remain close and move commands
-
Conic segments become quadratic Bézier curves
| Returns | |
|---|---|
Path |
A |
addSvg
fun Path.addSvg(pathData: String): Unit
Adds the specified SVG path data to this Path. The SVG path data encodes a series of instructions that will be applied to this path. For instance, the following path data:
M200,300 Q400,50 600,300 L1000,300
Will generate the following series of instructions for this path:
moveTo(200f, 300f)
quadraticTo(400f, 50f, 600f, 300f)
lineTo(1000f, 300f)
To convert a Path to its SVG path data representation, please refer to Path.toSvg.
| Throws | |
|---|---|
kotlin.IllegalArgumentException |
if the path data contains an invalid instruction |
| See also | |
|---|---|
toSvg |
toSvg
fun Path.toSvg(asDocument: Boolean = false): String
Returns an SVG representation of this path. The caller can choose whether the returned SVG represents a fully-formed SVG document or only the path data. By default, only the path data is returned which can be used either with Path.addSvg or androidx.compose.ui.graphics.vector.PathParser.
| Parameters | |
|---|---|
asDocument: Boolean = false |
When set to true, this function returns a fully-formed SVG document, otherwise returns only the path data. |
| See also | |
|---|---|
PathParser |
|
addSvg |