@leafer/path 1.0.0-alpha.7 → 1.0.0-bate

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leafer/path",
-  "version": "1.0.0-alpha.7",
+  "version": "1.0.0-bate",
   "description": "@leafer/path",
   "author": "Chao (Leafer) Wan",
   "license": "MIT",
@@ -19,9 +19,10 @@
     "leaferjs"
   ],
   "dependencies": {
-    "@leafer/math": "1.0.0-alpha.7"
+    "@leafer/math": "1.0.0-bate",
+    "@leafer/debug": "1.0.0-bate"
   },
   "devDependencies": {
-    "@leafer/interface": "1.0.0-alpha.7"
+    "@leafer/interface": "1.0.0-bate"
   }
 }

package/src/BezierHelper.ts

@@ -1,104 +1,142 @@
 import { IPointData, ITwoPointBoundsData, IPathCommandData } from '@leafer/interface'
-import { TwoPointBoundsHelper } from '@leafer/math'
+import { OneRadian, PI2, PI_2, PointHelper, TwoPointBoundsHelper } from '@leafer/math'
 
 import { PathCommandMap } from './PathCommandMap'
+import { RectHelper } from './RectHelper'
+import { PathHelper } from './PathHelper'
 
-
-const tempPoint = {} as IPointData
-const { sin, cos, sqrt, atan2, ceil, abs, PI } = Math
+const { sin, cos, atan2, ceil, abs, PI } = Math
 const { setPoint, addPoint } = TwoPointBoundsHelper
+const { set } = PointHelper
+const tempPoint = {} as IPointData
 
 export const BezierHelper = {
 
-    getFromACommand(fromX: number, fromY: number, rx: number, ry: number, rotateAngle: number, largeFlag: number, sweepFlag: number, toX: number, toY: number): IPathCommandData { //  [...CCommandData, ...CCommandData]
-
-        const localToX = toX - fromX
-        const localToY = toY - fromY
-
-        const rotation = rotateAngle * PI / 180
-        const sinRotation = sin(rotation)
-        const cosRotation = cos(rotation)
-
-        const ax = -cosRotation * localToX * 0.5 - sinRotation * localToY * 0.5
-        const ay = -cosRotation * localToY * 0.5 + sinRotation * localToX * 0.5
-        const rxSquare = rx * rx
-        const rySquare = ry * ry
-        const pySquare = ay * ay
-        const pxSquare = ax * ax
-        const a = rxSquare * rySquare - rxSquare * pySquare - rySquare * pxSquare
-        let sr = 0
-
-        if (a < 0) {
-            const scale = sqrt(1 - a / (rxSquare * rySquare))
-            rx *= scale
-            ry *= scale
-        } else {
-            const sign = largeFlag === sweepFlag ? -1 : 1
-            sr = sign * sqrt(a / (rxSquare * pySquare + rySquare * pxSquare))
+    rect(data: IPathCommandData, x: number, y: number, width: number, height: number) {
+        PathHelper.creator.path = data
+        PathHelper.creator.moveTo(x, y).lineTo(x + width, y).lineTo(x + width, y + height).lineTo(x, y + height).lineTo(x, y)
+    },
+
+    roundRect(data: IPathCommandData, x: number, y: number, width: number, height: number, radius: number | number[]): void {
+        PathHelper.creator.path = []
+        RectHelper.drawRoundRect(PathHelper.creator, x, y, width, height, radius)
+        data.push(...PathHelper.convertToCanvasData(PathHelper.creator.path, true))
+    },
+
+    arcTo(data: IPathCommandData | null | void, fromX: number, fromY: number, x1: number, y1: number, toX: number, toY: number, radius: number, setPointBounds?: ITwoPointBoundsData, setEndPoint?: IPointData, setStartPoint?: IPointData): void {
+        const BAx = x1 - fromX
+        const BAy = y1 - fromY
+        const CBx = toX - x1
+        const CBy = toY - y1
+
+        let startRadian = atan2(BAy, BAx)
+        let endRadian = atan2(CBy, CBx)
+        let totalRadian = endRadian - startRadian
+        if (totalRadian < 0) totalRadian += PI2
+
+        if (totalRadian === PI || (abs(BAx + BAy) < 1.e-12) || (abs(CBx + CBy) < 1.e-12)) { // invalid
+            if (data) data.push(PathCommandMap.L, x1, y1)
+            if (setPointBounds) {
+                setPoint(setPointBounds, fromX, fromY)
+                addPoint(setPointBounds, x1, y1)
+            }
+            if (setStartPoint) set(setStartPoint, fromX, fromY)
+            if (setEndPoint) set(setEndPoint, x1, y1)
+            return
         }
 
-        const cx = sr * rx * ay / ry
-        const cy = -sr * ry * ax / rx
-        const cx1 = cosRotation * cx - sinRotation * cy + localToX * 0.5
-        const cy1 = sinRotation * cx + cosRotation * cy + localToY * 0.5
+        const anticlockwise = BAx * CBy - CBx * BAy < 0
+        const sign = anticlockwise ? -1 : 1
+        const c = radius / cos(totalRadian / 2)
 
-        let r1 = atan2((ay - cy) / ry, (ax - cx) / rx)
-        let r2 = atan2((-ay - cy) / ry, (-ax - cx) / rx)
-        let totalRadian = r2 - r1
+        const centerX = x1 + c * cos(startRadian + totalRadian / 2 + PI_2 * sign)
+        const centerY = y1 + c * sin(startRadian + totalRadian / 2 + PI_2 * sign)
+        startRadian -= PI_2 * sign
+        endRadian -= PI_2 * sign
 
-        if (sweepFlag === 0 && totalRadian > 0) {
-            totalRadian -= 2 * PI
-        } else if (sweepFlag === 1 && totalRadian < 0) {
-            totalRadian += 2 * PI
-        }
+        return ellipse(data, centerX, centerY, radius, radius, 0, startRadian / OneRadian, endRadian / OneRadian, anticlockwise, setPointBounds, setEndPoint, setStartPoint)
+    },
+
+    arc(data: IPathCommandData | null | void, x: number, y: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean, setPointBounds?: ITwoPointBoundsData, setEndPoint?: IPointData, setStartPoint?: IPointData): void {
+        return ellipse(data, x, y, radius, radius, 0, startAngle, endAngle, anticlockwise, setPointBounds, setEndPoint, setStartPoint)
+    },
+
+    ellipse(data: IPathCommandData | null | void, cx: number, cy: number, radiusX: number, radiusY: number, rotation: number, startAngle: number, endAngle: number, anticlockwise?: boolean, setPointBounds?: ITwoPointBoundsData, setEndPoint?: IPointData, setStartPoint?: IPointData): void {
+        const rotationRadian = rotation * OneRadian
+        const rotationSin = sin(rotationRadian)
+        const rotationCos = cos(rotationRadian)
+
+        let startRadian = startAngle * OneRadian
+        let endRadian = endAngle * OneRadian
+
+        if (startRadian > PI) startRadian -= PI2
+        if (endRadian < 0) endRadian += PI2
+
+        let totalRadian = endRadian - startRadian
+        if (totalRadian < 0) totalRadian += PI2
+        else if (totalRadian > PI2) totalRadian -= PI2
 
-        // segments arc
-        const data: IPathCommandData = []
-        const segments = ceil(abs(totalRadian / PI * 2))
-        const segmentRadian = totalRadian / segments
-        const sinSegmentRadian2 = sin(segmentRadian / 2)
-        const sinSegmentRadian4 = sin(segmentRadian / 4)
-        const controlRadian = 8 / 3 * sinSegmentRadian4 * sinSegmentRadian4 / sinSegmentRadian2
-
-        r1 = 0
-        r2 = atan2((ay - cy) / ry, (ax - cx) / rx)
-        let startRadian = r2 - r1
-        let endRadian = startRadian + segmentRadian
-        let cosStart = cos(startRadian)
-        let sinStart = sin(startRadian)
-        let cosEnd: number, sinEnd: number
-        let startX = 0, startY = 0
+        if (anticlockwise) totalRadian -= PI2
+
+
+        const parts = ceil(abs(totalRadian / PI_2))
+        const partRadian = totalRadian / parts
+        const partRadian4Sin = sin(partRadian / 4)
+        const control = 8 / 3 * partRadian4Sin * partRadian4Sin / sin(partRadian / 2)
+
+        endRadian = startRadian + partRadian
+
+        let startCos = cos(startRadian)
+        let startSin = sin(startRadian)
+        let endCos: number, endSin: number
 
         let x: number, y: number, x1: number, y1: number, x2: number, y2: number
-        for (let i = 0; i < segments; i++) {
 
-            cosEnd = cos(endRadian)
-            sinEnd = sin(endRadian)
+        let startX = x = rotationCos * radiusX * startCos - rotationSin * radiusY * startSin
+        let startY = y = rotationSin * radiusX * startCos + rotationCos * radiusY * startSin
+
+        let fromX = cx + x, fromY = cy + y
+
+        if (data) data.push(PathCommandMap.L, fromX, fromY)
+        if (setPointBounds) setPoint(setPointBounds, fromX, fromY)
+        if (setStartPoint) set(setStartPoint, fromX, fromY)
+
+        for (let i = 0; i < parts; i++) {
+
+            endCos = cos(endRadian)
+            endSin = sin(endRadian)
 
-            // segment bezier
-            x = cosRotation * rx * cosEnd - sinRotation * ry * sinEnd + cx1
-            y = sinRotation * rx * cosEnd + cosRotation * ry * sinEnd + cy1
-            x1 = startX + controlRadian * (-cosRotation * rx * sinStart - sinRotation * ry * cosStart)
-            y1 = startY + controlRadian * (-sinRotation * rx * sinStart + cosRotation * ry * cosStart)
-            x2 = x + controlRadian * (cosRotation * rx * sinEnd + sinRotation * ry * cosEnd)
-            y2 = y + controlRadian * (sinRotation * rx * sinEnd - cosRotation * ry * cosEnd)
+            x = rotationCos * radiusX * endCos - rotationSin * radiusY * endSin
+            y = rotationSin * radiusX * endCos + rotationCos * radiusY * endSin
+            x1 = cx + startX - control * (rotationCos * radiusX * startSin + rotationSin * radiusY * startCos)
+            y1 = cy + startY - control * (rotationSin * radiusX * startSin - rotationCos * radiusY * startCos)
+            x2 = cx + x + control * (rotationCos * radiusX * endSin + rotationSin * radiusY * endCos)
+            y2 = cy + y + control * (rotationSin * radiusX * endSin - rotationCos * radiusY * endCos)
 
-            data.push(PathCommandMap.C, x1 + fromX, y1 + fromY, x2 + fromX, y2 + fromY, x + fromX, y + fromY)
+            if (data) data.push(PathCommandMap.C, x1, y1, x2, y2, cx + x, cy + y)
+            if (setPointBounds) toTwoPointBounds(cx + startX, cy + startY, x1, y1, x2, y2, cx + x, cy + y, setPointBounds, true)
 
             startX = x
             startY = y
+            startCos = endCos
+            startSin = endSin
             startRadian = endRadian
-            cosStart = cosEnd
-            sinStart = sinEnd
-            endRadian += segmentRadian
-
+            endRadian += partRadian
         }
 
-        return data
+        if (setEndPoint) set(setEndPoint, cx + x, cy + y)
+
+    },
 
+    quadraticCurveTo(data: IPathCommandData, fromX: number, fromY: number, x1: number, y1: number, toX: number, toY: number): void {
+        data.push(PathCommandMap.C, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY)
     },
 
-    toTwoPointBounds(fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number, pointBounds: ITwoPointBoundsData): void {
+    toTwoPointBoundsByQuadraticCurve(fromX: number, fromY: number, x1: number, y1: number, toX: number, toY: number, pointBounds: ITwoPointBoundsData, addMode?: boolean): void {
+        toTwoPointBounds(fromX, fromY, (fromX + 2 * x1) / 3, (fromY + 2 * y1) / 3, (toX + 2 * x1) / 3, (toY + 2 * y1) / 3, toX, toY, pointBounds, addMode)
+    },
+
+    toTwoPointBounds(fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number, pointBounds: ITwoPointBoundsData, addMode?: boolean): void {
 
         const tList = []
         let a, b, c, t, t1, t2, v, sqrtV
@@ -131,13 +169,14 @@ export const BezierHelper = {
             if (0 < t2 && t2 < 1) tList.push(t2)
         }
 
-        setPoint(pointBounds, fromX, fromY)
+        addMode ? addPoint(pointBounds, fromX, fromY) : setPoint(pointBounds, fromX, fromY)
         addPoint(pointBounds, toX, toY)
 
         for (let i = 0, len = tList.length; i < len; i++) {
-            B.getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint)
+            getPointAndSet(tList[i], fromX, fromY, x1, y1, x2, y2, toX, toY, tempPoint)
             addPoint(pointBounds, tempPoint.x, tempPoint.y)
         }
+
     },
 
     getPointAndSet(t: number, fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number, setPoint: IPointData): void {
@@ -148,10 +187,9 @@ export const BezierHelper = {
 
     getPoint(t: number, fromX: number, fromY: number, x1: number, y1: number, x2: number, y2: number, toX: number, toY: number): IPointData {
         const point = {} as IPointData
-        B.getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, point)
+        getPointAndSet(t, fromX, fromY, x1, y1, x2, y2, toX, toY, point)
         return point
     }
-
 }
 
-const B = BezierHelper
+const { getPointAndSet, toTwoPointBounds, ellipse } = BezierHelper

package/src/EllipseHelper.ts

@@ -0,0 +1,70 @@
+import { IPathCommandData } from '@leafer/interface'
+import { OneRadian, PI2 } from '@leafer/math'
+
+import { PathCommandMap } from './PathCommandMap'
+import { BezierHelper } from './BezierHelper'
+
+const { sin, cos, sqrt, atan2 } = Math
+const { ellipse } = BezierHelper
+
+export const EllipseHelper = {
+
+    // svg 
+    ellipticalArc(data: IPathCommandData, fromX: number, fromY: number, radiusX: number, radiusY: number, rotation: number, largeFlag: number, sweepFlag: number, toX: number, toY: number, curveMode?: boolean): void {
+
+        const halfX = (toX - fromX) / 2
+        const halfY = (toY - fromY) / 2
+
+        const rotationRadian = rotation * OneRadian
+        const rotationSin = sin(rotationRadian)
+        const rotationCos = cos(rotationRadian)
+
+        const px = -rotationCos * halfX - rotationSin * halfY
+        const py = -rotationCos * halfY + rotationSin * halfX
+        const rxSquare = radiusX * radiusX
+        const rySquare = radiusY * radiusY
+        const pySquare = py * py
+        const pxSquare = px * px
+
+        const a = rxSquare * rySquare - rxSquare * pySquare - rySquare * pxSquare
+        let s = 0
+
+        if (a < 0) {
+            const t = sqrt(1 - a / (rxSquare * rySquare))
+            radiusX *= t
+            radiusY *= t
+        } else {
+            s = (largeFlag === sweepFlag ? -1 : 1) * sqrt(a / (rxSquare * pySquare + rySquare * pxSquare))
+        }
+
+        const cx = s * radiusX * py / radiusY
+        const cy = -s * radiusY * px / radiusX
+
+        const startRadian = atan2((py - cy) / radiusY, (px - cx) / radiusX)
+        const endRadian = atan2((-py - cy) / radiusY, (-px - cx) / radiusX)
+
+        let totalRadian = endRadian - startRadian
+
+        if (sweepFlag === 0 && totalRadian > 0) {
+            totalRadian -= PI2
+        } else if (sweepFlag === 1 && totalRadian < 0) {
+            totalRadian += PI2
+        }
+
+        const centerX = fromX + halfX + rotationCos * cx - rotationSin * cy
+        const centerY = fromY + halfY + rotationSin * cx + rotationCos * cy
+
+        const anticlockwise = totalRadian < 0 ? 1 : 0
+
+        if (curveMode) {
+            ellipse(data, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise as unknown as boolean)
+        } else {
+            if (radiusX === radiusY && !rotation) {
+                data.push(PathCommandMap.O, centerX, centerY, radiusX, startRadian / OneRadian, endRadian / OneRadian, anticlockwise)
+            } else {
+                data.push(PathCommandMap.G, centerX, centerY, radiusX, radiusY, rotation, startRadian / OneRadian, endRadian / OneRadian, anticlockwise)
+            }
+        }
+    }
+
+}

package/src/PathBounds.ts

@@ -0,0 +1,138 @@
+import { ITwoPointBoundsData, IPathCommandData, IBoundsData, IPointData } from '@leafer/interface'
+import { TwoPointBoundsHelper } from '@leafer/math'
+import { Debug } from '@leafer/debug'
+
+import { BezierHelper } from './BezierHelper'
+import { PathCommandMap as Command } from './PathCommandMap'
+
+
+const { M, L, C, Q, Z, N, D, X, G, F, O, P, U } = Command
+const { toTwoPointBounds, toTwoPointBoundsByQuadraticCurve, arcTo, arc, ellipse } = BezierHelper
+const { add, copy, addPoint, setPoint, addBounds, toBounds } = TwoPointBoundsHelper
+const debug = Debug.get('PathBounds')
+
+let radius: number, radiusX: number, radiusY: number
+const tempPointBounds = {} as ITwoPointBoundsData
+const setPointBounds = {} as ITwoPointBoundsData
+const setEndPoint = {} as IPointData
+
+export const PathBounds = {
+
+    toBounds(data: IPathCommandData, setBounds: IBoundsData): void {
+        PathBounds.toTwoPointBounds(data, setPointBounds)
+        toBounds(setPointBounds, setBounds)
+    },
+
+    toTwoPointBounds(data: IPathCommandData, setPointBounds: ITwoPointBoundsData): void {
+        if (!data || !data.length) return setPoint(setPointBounds, 0, 0)
+
+        let command: number
+        let i: number = 0, x: number = 0, y: number = 0, x1: number, y1: number, toX: number, toY: number
+
+        const len = data.length
+
+        while (i < len) {
+            command = data[i]
+
+            if (i === 0) {
+                if (command === Z || command === C || command === Q) {
+                    setPoint(setPointBounds, x, y)
+                } else {
+                    setPoint(setPointBounds, data[i + 1], data[i + 2])
+                }
+            }
+
+            switch (command) {
+                case M: //moveto(x, y)
+                case L: //lineto(x, y)
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    addPoint(setPointBounds, x, y)
+                    i += 3
+                    break
+                case C: //bezierCurveTo(x1, y1, x2, y2, x,y)
+                    toX = data[i + 5]
+                    toY = data[i + 6]
+                    toTwoPointBounds(x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], toX, toY, tempPointBounds)
+                    add(setPointBounds, tempPointBounds)
+                    x = toX
+                    y = toY
+                    i += 7
+                    break
+                case Q: //quadraticCurveTo(x1, y1, x, y)
+                    x1 = data[i + 1]
+                    y1 = data[i + 2]
+                    toX = data[i + 3]
+                    toY = data[i + 4]
+                    toTwoPointBoundsByQuadraticCurve(x, y, x1, y1, toX, toY, tempPointBounds)
+                    add(setPointBounds, tempPointBounds)
+                    x = toX
+                    y = toY
+                    i += 5
+                    break
+                case Z: //closepath()
+                    i += 1
+                    break
+
+                // canvas command
+
+                case N: // rect(x, y, width, height)
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    addBounds(setPointBounds, x, y, data[i + 3], data[i + 4])
+                    i += 5
+                    break
+                case D: // roundRect(x, y, width, height, radius1, radius2, radius3, radius4)
+                case X: // simple roundRect(x, y, width, height, radius)
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    addBounds(setPointBounds, x, y, data[i + 3], data[i + 4])
+                    i += (command === D ? 9 : 6)
+                    break
+                case G: // ellipse(x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise)
+                    ellipse(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6], data[i + 7], data[i + 8] as unknown as boolean, tempPointBounds, setEndPoint)
+                    i === 0 ? copy(setPointBounds, tempPointBounds) : add(setPointBounds, tempPointBounds)
+                    x = setEndPoint.x
+                    y = setEndPoint.y
+                    i += 9
+                    break
+                case F: // simple ellipse(x, y, radiusX, radiusY)
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    radiusX = data[i + 3]
+                    radiusY = data[i + 4]
+                    addBounds(setPointBounds, x - radiusX, y - radiusY, radiusX * 2, radiusY * 2)
+                    x += radiusX
+                    i += 5
+                    break
+                case O: // arc(x, y, radius, startAngle, endAngle, anticlockwise)
+                    arc(null, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], data[i + 6] as unknown as boolean, tempPointBounds, setEndPoint)
+                    i === 0 ? copy(setPointBounds, tempPointBounds) : add(setPointBounds, tempPointBounds)
+                    x = setEndPoint.x
+                    y = setEndPoint.y
+                    i += 7
+                    break
+                case P: // simple arc(x, y, radius)
+                    x = data[i + 1]
+                    y = data[i + 2]
+                    radius = data[i + 3]
+                    addBounds(setPointBounds, x - radius, y - radius, radius * 2, radius * 2)
+                    x += radius
+                    i += 4
+                    break
+                case U: // arcTo(x1, y1, x2, y2, radius)
+                    arcTo(null, x, y, data[i + 1], data[i + 2], data[i + 3], data[i + 4], data[i + 5], tempPointBounds, setEndPoint)
+                    i === 0 ? copy(setPointBounds, tempPointBounds) : add(setPointBounds, tempPointBounds)
+                    x = setEndPoint.x
+                    y = setEndPoint.y
+                    i += 6
+                    break
+                default:
+                    debug.error(`command: ${command} [index:${i}]`, data)
+                    return
+            }
+        }
+
+    }
+
+}

package/src/PathCommandDataHelper.ts

@@ -0,0 +1,98 @@
+import { IPathCommandData, IPointData } from '@leafer/interface'
+import { PathCommandMap } from './PathCommandMap'
+import { BezierHelper } from './BezierHelper'
+import { MathHelper } from '@leafer/math'
+
+
+const { M, L, C, Q, Z, N, D, X, G, F, O, P, U } = PathCommandMap
+const startPoint = {} as IPointData
+
+export const PathCommandDataHelper = {
+
+    beginPath(data: IPathCommandData): void {
+        data.length = 0
+    },
+
+    // svg and canvas
+
+    moveTo(data: IPathCommandData, x: number, y: number): void {
+        data.push(M, x, y)
+    },
+
+    lineTo(data: IPathCommandData, x: number, y: number): void {
+        data.push(L, x, y)
+    },
+
+    bezierCurveTo(data: IPathCommandData, x1: number, y1: number, x2: number, y2: number, x: number, y: number): void {
+        data.push(C, x1, y1, x2, y2, x, y)
+    },
+
+    quadraticCurveTo(data: IPathCommandData, x1: number, y1: number, x: number, y: number): void {
+        data.push(Q, x1, y1, x, y)
+    },
+
+    closePath(data: IPathCommandData): void {
+        data.push(Z)
+    },
+
+    // canvas
+
+    rect(data: IPathCommandData, x: number, y: number, width: number, height: number): void {
+        data.push(N, x, y, width, height)
+    },
+
+    roundRect(data: IPathCommandData, x: number, y: number, width: number, height: number, cornerRadius: number | number[]): void {
+        if (typeof cornerRadius === 'number') {
+            data.push(X, x, y, width, height, cornerRadius)
+        } else {
+            const fourCorners = MathHelper.fourNumber(cornerRadius)
+            if (fourCorners) {
+                data.push(D, x, y, width, height, ...fourCorners)
+            } else {
+                data.push(N, x, y, width, height)
+            }
+        }
+    },
+
+    ellipse(data: IPathCommandData, x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): void {
+        if (rotation === undefined) {
+            data.push(F, x, y, radiusX, radiusY)
+        } else {
+            if (startAngle === undefined) startAngle = 0
+            if (endAngle === undefined) endAngle = 360
+            data.push(G, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise ? 1 : 0)
+        }
+    },
+
+    arc(data: IPathCommandData, x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): void {
+        if (startAngle === undefined) {
+            data.push(P, x, y, radius)
+        } else {
+            if (endAngle === undefined) endAngle = 360
+            data.push(O, x, y, radius, startAngle, endAngle, anticlockwise ? 1 : 0)
+        }
+    },
+
+    moveToEllipse(data: IPathCommandData, x: number, y: number, radiusX: number, radiusY: number, rotation?: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): void {
+        if (rotation === undefined) rotation = 0
+        if (startAngle === undefined) startAngle = 0
+        if (endAngle === undefined) endAngle = 360
+        BezierHelper.ellipse(null, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise, null, null, startPoint)
+        data.push(M, startPoint.x, startPoint.y)
+        ellipse(data, x, y, radiusX, radiusY, rotation, startAngle, endAngle, anticlockwise)
+    },
+
+    moveToArc(data: IPathCommandData, x: number, y: number, radius: number, startAngle?: number, endAngle?: number, anticlockwise?: boolean): void {
+        if (startAngle === undefined) startAngle = 0
+        if (endAngle === undefined) endAngle = 360
+        BezierHelper.arc(null, x, y, radius, startAngle, endAngle, anticlockwise, null, null, startPoint)
+        data.push(M, startPoint.x, startPoint.y)
+        arc(data, x, y, radius, startAngle, endAngle, anticlockwise)
+    },
+
+    arcTo(data: IPathCommandData, x1: number, y1: number, x2: number, y2: number, radius: number): void {
+        data.push(U, x1, y1, x2, y2, radius)
+    }
+}
+
+const { ellipse, arc } = PathCommandDataHelper