---
title: "Path"
description: ""
type: "interface"
---
Interface
Common
```kotlin
@JvmDefaultWithCompatibility
/* expect class */ interface Path
```
## Properties
Common
```kotlin
var fillType: PathFillType
```
Determines how the interior of this path is calculated.
Defaults to the non-zero winding rule, `PathFillType.NonZero`.
Common
```kotlin
val isConvex: Boolean
```
Returns the path's convexity, as defined by the content of the path.
A path is convex if it has a single contour, and only ever curves in a single direction.
This function will calculate the convexity of the path from its control points, and cache the
result.
Common
```kotlin
val isEmpty: Boolean
```
Returns true if the path is empty (contains no lines or curves)
#### Returns
| | |
| --- | --- |
| | true if the path is empty (contains no lines or curves) |
## Functions
```kotlin
fun moveTo(x: Float, y: Float)
```
Starts a new subpath at the given coordinate
```kotlin
fun relativeMoveTo(dx: Float, dy: Float)
```
Starts a new subpath at the given offset from the current point
```kotlin
fun lineTo(x: Float, y: Float)
```
Adds a straight line segment from the current point to the given point
```kotlin
fun 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.
```kotlin
fun quadraticBezierTo(x1: Float, y1: Float, x2: Float, y2: Float)
```
Adds a quadratic bezier segment that curves from the current point to the given point (`x2`,
`y2`), using the control point (`x1`, `y1`).
```kotlin
fun quadraticTo(x1: Float, y1: Float, x2: Float, y2: Float)
```
Adds a quadratic bezier segment that curves from the current point to the given point (`x2`,
`y2`), using the control point (`x1`, `y1`).
```kotlin
fun relativeQuadraticBezierTo(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
(`dx2`, `dy2`) from the current point, using the control point at the offset (`dx1`, `dy1`)
from the current point.
```kotlin
fun 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
(`dx2`, `dy2`) from the current point, using the control point at the offset (`dx1`, `dy1`)
from the current point.
```kotlin
fun cubicTo(x1: Float, y1: Float, x2: Float, y2: Float, x3: Float, y3: Float)
```
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`).
```kotlin
fun relativeCubicTo(dx1: Float, dy1: Float, dx2: Float, dy2: Float, dx3: Float, dy3: Float)
```
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.
```kotlin
fun arcToRad(
rect: Rect,
startAngleRadians: Float,
sweepAngleRadians: Float,
forceMoveTo: Boolean,
)
```
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.
```kotlin
fun arcTo(rect: Rect, startAngleDegrees: Float, sweepAngleDegrees: Float, forceMoveTo: Boolean)
```
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.
```kotlin
fun addRect(rect: Rect)
```
Adds a new subpath that consists of four lines that outline the given rectangle. The
rectangle is wound counter-clockwise.
```kotlin
fun addRect(rect: Rect, direction: Direction = Direction.CounterClockwise)
```
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`.
```kotlin
fun addOval(oval: Rect)
```
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 oval is wound counter-clockwise.
```kotlin
fun addOval(oval: Rect, direction: Direction = Direction.CounterClockwise)
```
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`.
```kotlin
fun addRoundRect(roundRect: RoundRect)
```
Add a round rectangle shape to the path from the given `RoundRect`. The round rectangle is
wound counter-clockwise.
```kotlin
fun addRoundRect(roundRect: RoundRect, direction: Direction = Direction.CounterClockwise)
```
Add a round rectangle shape to the path from the given `RoundRect`. The direction to wind the
rectangle's contour is specified by `direction`.
```kotlin
fun addArcRad(oval: Rect, startAngleRadians: Float, sweepAngleRadians: Float)
```
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.
```kotlin
fun addArc(oval: Rect, startAngleDegrees: Float, sweepAngleDegrees: Float)
```
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.
```kotlin
fun addPath(path: Path, offset: Offset = Offset.Zero)
```
Adds a new subpath that consists of the given `path` offset by the given `offset`.
```kotlin
fun close()
```
Closes the last subpath, as if a straight line had been drawn from the current point to the
first point of the subpath.
```kotlin
fun reset()
```
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.
```kotlin
fun rewind()
```
Rewinds the path: clears any lines and curves from the path but keeps the internal data
structure for faster reuse.
```kotlin
fun translate(offset: Offset)
```
Translates all the segments of every subpath by the given offset.
```kotlin
fun transform(matrix: Matrix)
```
Transform the points in this path by the provided matrix
```kotlin
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)
```kotlin
operator fun iterator() = PathIterator(this)
```
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.
```kotlin
fun iterator(conicEvaluation: PathIterator.ConicEvaluation, tolerance: Float = 0.25f) =
PathIterator(this, conicEvaluation, tolerance)
```
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 | Indicates how to evaluate conic segments |
| tolerance | When `conicEvaluation` is set to `PathIterator.ConicEvaluation.AsQuadratics` defines the maximum distance between the original conic curve and its quadratic approximations |
```kotlin
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 | The first operand (for difference, the minuend) |
| path2 | The second operand (for difference, the subtrahend) |
| operation | `PathOperation` to apply to the 2 specified paths |
#### Returns
| | |
| --- | --- |
| | True if operation succeeded, false otherwise and this path remains unmodified. |
```kotlin
operator fun plus(path: Path) = Path().apply { op(this@Path, path, PathOperation.Union) }
```
Returns the union of two paths as a new `Path`.
```kotlin
operator fun minus(path: Path) = Path().apply { op(this@Path, path, PathOperation.Difference) }
```
Returns the difference of two paths as a new `Path`.
```kotlin
infix fun or(path: Path): Path
```
Returns the union of two paths as a new `Path`.
```kotlin
infix fun and(path: Path) = Path().apply { op(this@Path, path, PathOperation.Intersect) }
```
Returns the intersection of two paths as a new `Path`. If the paths do not intersect, returns
an empty path.
```kotlin
infix fun xor(path: Path) = Path().apply { op(this@Path, path, PathOperation.Xor) }
```
Returns the union minus the intersection of two paths as a new `Path`.