Index

Modules: pixie, pixie/blends, pixie/common, pixie/fileformats/bmp, pixie/fileformats/jpg, pixie/fileformats/png, pixie/fileformats/svg, pixie/images, pixie/internal, pixie/masks, pixie/paints, pixie/paths.

API symbols

`$`:

• images: `$`(image: Image): string
• masks: `$`(mask: Mask): string
• paths: `$`(path: Path): string

`[]=`:

• images: `[]=`(image: Image; x, y: int; rgba: ColorRGBX)
• masks: `[]=`(mask: Mask; x, y: int; value: uint8)

`[]`:

• images: `[]`(image: Image; x, y: int): ColorRGBX
• masks: `[]`(mask: Mask; x, y: int): uint8

addPath:

• paths: addPath(path: var Path; other: Path)

applyOpacity:

• images: applyOpacity(target: Image | Mask; opacity: float32)

Arc:

• PathCommandKind.Arc

arcTo:

• paths: arcTo(path: var Path; x1, y1, x2, y2, radius: float32)
• paths: arcTo(path: var Path; ctrl1, ctrl2: Vec2; radius: float32)

bezierCurveTo:

• paths: bezierCurveTo(path: var Path; x1, y1, x2, y2, x3, y3: float32)
• paths: bezierCurveTo(path: var Path; ctrl1, ctrl2, to: Vec2)

blendAlpha:

• blends: blendAlpha(backdrop, source: uint8): uint8

Blender:

• blends: Blender

blender:

• blends: blender(blendMode: BlendMode): Blender

BlenderSimd:

• blends: BlenderSimd

blenderSimd:

• blends: blenderSimd(blendMode: BlendMode): BlenderSimd

BlendMode:

• blends: BlendMode

blur:

• images: blur(image: Image; radius: float32; outOfBounds = ColorRGBX())
• masks: blur(mask: Mask; radius: float32; outOfBounds: uint8 = 0)

bmColor:

• BlendMode.bmColor

bmColorBurn:

• BlendMode.bmColorBurn

bmColorDodge:

• BlendMode.bmColorDodge

bmDarken:

• BlendMode.bmDarken

bmDifference:

• BlendMode.bmDifference

bmExcludeMask:

• BlendMode.bmExcludeMask

bmExclusion:

• BlendMode.bmExclusion

bmHardLight:

• BlendMode.bmHardLight

bmHue:

• BlendMode.bmHue

bmIntersectMask:

• BlendMode.bmIntersectMask

bmLighten:

• BlendMode.bmLighten

bmLuminosity:

• BlendMode.bmLuminosity

bmMask:

• BlendMode.bmMask

bmMultiply:

• BlendMode.bmMultiply

bmNormal:

• BlendMode.bmNormal

bmOverlay:

• BlendMode.bmOverlay

bmOverwrite:

• BlendMode.bmOverwrite

bmpSignature:

• bmp: bmpSignature

bmSaturation:

• BlendMode.bmSaturation

bmScreen:

• BlendMode.bmScreen

bmSoftLight:

• BlendMode.bmSoftLight

bmSubtractMask:

• BlendMode.bmSubtractMask

ceil:

• masks: ceil(mask: Mask)

Close:

• PathCommandKind.Close

closePath:

• paths: closePath(path: var Path)

ColorStop:

• paints: ColorStop

commandsToShapes:

• paths: commandsToShapes(path: Path; pixelScale: float32 = 1.0): seq[seq[Vec2]]

copy:

• images: copy(image: Image): Image
• masks: copy(mask: Mask): Mask

Cubic:

• PathCommandKind.Cubic

dataIndex:

• images: dataIndex(image: Image; x, y: int): int
• masks: dataIndex(mask: Mask; x, y: int): int

decodeBmp:

• bmp: decodeBmp(data: seq[uint8]): Image
• bmp: decodeBmp(data: string): Image

decodeImage:

• pixie: decodeImage(data: string | seq[uint8]): Image

decodeJpg:

• jpg: decodeJpg(data: seq[uint8]): Image
• jpg: decodeJpg(data: string): Image

decodePng:

• png: decodePng(data: seq[uint8]): Image
• png: decodePng(data: string): Image

decodeSvg:

• svg: decodeSvg(data: string; width = 0; height = 0): Image

diff:

• images: diff(master, image: Image): (float32, Image)

draw:

• images: draw(a, b: Image; pos = vec2(0, 0); blendMode = bmNormal)
• images: draw(a, b: Image; mat: Mat3; blendMode = bmNormal)
• images: draw(image: Image; mask: Mask; pos = vec2(0, 0); blendMode = bmMask)
• images: draw(image: Image; mask: Mask; mat: Mat3; blendMode = bmMask)
• images: draw(mask: Mask; image: Image; pos = vec2(0, 0); blendMode = bmMask)
• images: draw(mask: Mask; image: Image; mat: Mat3; blendMode = bmMask)
• images: draw(a, b: Mask; pos = vec2(0, 0); blendMode = bmMask)
• images: draw(a, b: Mask; mat: Mat3; blendMode = bmMask)

drawTiled:

• images: drawTiled(dest, src: Image; mat: Mat3; blendMode = bmNormal)

ellipse:

• paths: ellipse(path: var Path; cx, cy, rx, ry: float32)
• paths: ellipse(path: var Path; center: Vec2; rx, ry: float32)

ellipticalArcTo:

• paths: ellipticalArcTo(path: var Path; rx, ry: float32; xAxisRotation: float32; largeArcFlag, sweepFlag: bool; x, y: float32)

encodeBmp:

• bmp: encodeBmp(image: Image): string

encodeImage:

• pixie: encodeImage(image: Image; fileFormat: FileFormat): string

encodeJpg:

• jpg: encodeJpg(image: Image): string

encodePng:

• png: encodePng(image: Image): string
• png: encodePng(width, height, channels: int; data: pointer; len: int): seq[uint8]
• png: encodePng(mask: Mask): string

ffBmp:

• FileFormat.ffBmp

ffJpg:

• FileFormat.ffJpg

ffPng:

• FileFormat.ffPng

FileFormat:

• pixie: FileFormat

fill:

• images: fill(image: Image; rgba: ColorRGBX)
• masks: fill(mask: Mask; value: uint8)

fillAngularGradient:

• paints: fillAngularGradient(image: Image; center, edge, skew: Vec2; stops: seq[ColorStop])

fillCircle:

• pixie: fillCircle(image: Image; center: Vec2; radius: float32; color: ColorRGBA)
• pixie: fillCircle(mask: Mask; center: Vec2; radius: float32)

fillEllipse:

• pixie: fillEllipse(image: Image; center: Vec2; rx, ry: float32; color: ColorRGBA; blendMode = bmNormal)
• pixie: fillEllipse(mask: Mask; center: Vec2; rx, ry: float32)

fillLinearGradient:

• paints: fillLinearGradient(image: Image; at, to: Vec2; stops: seq[ColorStop])

fillPath:

• paths: fillPath(image: Image; path: SomePath; color: ColorRGBX; windingRule = wrNonZero; blendMode = bmNormal)
• paths: fillPath(image: Image; path: SomePath; color: ColorRGBX; transform: Vec2 | Mat3; windingRule = wrNonZero; blendMode = bmNormal)
• paths: fillPath(image: Image; path: SomePath; paint: Paint; windingRule = wrNonZero)
• paths: fillPath(mask: Mask; path: SomePath; windingRule = wrNonZero)
• paths: fillPath(mask: Mask; path: SomePath; transform: Vec2 | Mat3; windingRule = wrNonZero)

fillPolygon:

• pixie: fillPolygon(image: Image; pos: Vec2; size: float32; sides: int; color: ColorRGBA)
• pixie: fillPolygon(mask: Mask; pos: Vec2; size: float32; sides: int)

fillRadialGradient:

• paints: fillRadialGradient(image: Image; center, edge, skew: Vec2; stops: seq[ColorStop])

fillRect:

• pixie: fillRect(image: Image; rect: Rect; color: ColorRGBA)
• pixie: fillRect(mask: Mask; rect: Rect)

fillRoundedRect:

• pixie: fillRoundedRect(image: Image; rect: Rect; radius: float32; color: ColorRGBA)
• pixie: fillRoundedRect(image: Image; rect: Rect; nw, ne, se, sw: float32; color: ColorRGBA)
• pixie: fillRoundedRect(mask: Mask; rect: Rect; radius: float32)
• pixie: fillRoundedRect(mask: Mask; rect: Rect; nw, ne, se, sw: float32)

fillUnsafe:

• images: fillUnsafe(data: var seq[ColorRGBX]; rgba: ColorRGBX; start, len: int)
• masks: fillUnsafe(data: var seq[uint8]; value: uint8; start, len: int)

flipHorizontal:

• images: flipHorizontal(image: Image)

flipVertical:

• images: flipVertical(image: Image)

fractional:

• common: fractional(v: float32): float32

gaussianKernel:

• internal: gaussianKernel(radius: int): seq[uint32]

getRgbaSmooth:

• images: getRgbaSmooth(image: Image; x, y: float32; wrapped = false): ColorRGBX

getRgbaUnsafe:

• images: getRgbaUnsafe(image: Image; x, y: int): ColorRGBX

getValueSmooth:

• masks: getValueSmooth(mask: Mask; x, y: float32): uint8

getValueUnsafe:

• masks: getValueUnsafe(mask: Mask; x, y: int): uint8

hasSimdBlender:

• blends: hasSimdBlender(blendMode: BlendMode): bool

hasSimdMasker:

• blends: hasSimdMasker(blendMode: BlendMode): bool

HLine:

• PathCommandKind.HLine

Image:

• images: Image

inside:

• images: inside(image: Image; x, y: int): bool
• masks: inside(mask: Mask; x, y: int): bool

invert:

• images: invert(target: Image | Mask)

jpgStartOfImage:

• jpg: jpgStartOfImage

lcButt:

• LineCap.lcButt

lcRound:

• LineCap.lcRound

lcSquare:

• LineCap.lcSquare

lerp:

• common: lerp(a, b: Color; v: float32): Color
• common: lerp(a, b: ColorRGBX; t: float32): ColorRGBX
• common: lerp(a, b: uint8; t: float32): uint8

Line:

• PathCommandKind.Line

LineCap:

• paths: LineCap

LineJoin:

• paths: LineJoin

lineTo:

• paths: lineTo(path: var Path; x, y: float32)
• paths: lineTo(path: var Path; v: Vec2)

ljBevel:

• LineJoin.ljBevel

ljMiter:

• LineJoin.ljMiter

ljRound:

• LineJoin.ljRound

magnifyBy2:

• images: magnifyBy2(image: Image; power = 1): Image

Mask:

• masks: Mask

Masker:

• blends: Masker

masker:

• blends: masker(blendMode: BlendMode): Masker

MaskerSimd:

• blends: MaskerSimd

maskerSimd:

• blends: maskerSimd(blendMode: BlendMode): MaskerSimd

minifyBy2:

• images: minifyBy2(image: Image; power = 1): Image
• masks: minifyBy2(mask: Mask; power = 1): Mask

Move:

• PathCommandKind.Move

moveTo:

• paths: moveTo(path: var Path; x, y: float32)
• paths: moveTo(path: var Path; v: Vec2)

newImage:

• images: newImage(width, height: int): Image

newMask:

• images: newMask(image: Image): Mask
• masks: newMask(width, height: int): Mask

packAlphaValues:

• internal: packAlphaValues(v: M128i): M128i

Paint:

• paints: Paint

PaintKind:

• paints: PaintKind

parsePath:

• paths: parsePath(path: string): Path

Path:

• paths: Path

PathCommand:

• paths: PathCommand

PathCommandKind:

• paths: PathCommandKind

PixieError:

• common: PixieError

pkGradientAngular:

• PaintKind.pkGradientAngular

pkGradientLinear:

• PaintKind.pkGradientLinear

pkGradientRadial:

• PaintKind.pkGradientRadial

pkImage:

• PaintKind.pkImage

pkImageTiled:

• PaintKind.pkImageTiled

pkSolid:

• PaintKind.pkSolid

pngSignature:

• png: pngSignature

polygon:

• paths: polygon(path: var Path; x, y, size: float32; sides: int)
• paths: polygon(path: var Path; pos: Vec2; size: float32; sides: int)

Quad:

• PathCommandKind.Quad

quadraticCurveTo:

• paths: quadraticCurveTo(path: var Path; x1, y1, x2, y2: float32)
• paths: quadraticCurveTo(path: var Path; ctrl, to: Vec2)

RArc:

• PathCommandKind.RArc

RCubic:

• PathCommandKind.RCubic

readImage:

• pixie: readImage(filePath: string): Image

rect:

• paths: rect(path: var Path; x, y, w, h: float32; clockwise = true)
• paths: rect(path: var Path; rect: Rect; clockwise = true)
• paths: rect(path: var Path; pos: Vec2; wh: Vec2; clockwise = true)

resize:

• images: resize(srcImage: Image; width, height: int): Image

RHLine:

• PathCommandKind.RHLine

RLine:

• PathCommandKind.RLine

RMove:

• PathCommandKind.RMove

roundedRect:

• paths: roundedRect(path: var Path; x, y, w, h, nw, ne, se, sw: float32; clockwise = true)
• paths: roundedRect(path: var Path; rect: Rect; nw, ne, se, sw: float32; clockwise = true)
• paths: roundedRect(path: var Path; pos, wh: Vec2; nw, ne, se, sw: float32; clockwise = true)

RQuad:

• PathCommandKind.RQuad

RSCubic:

• PathCommandKind.RSCubic

RTQuad:

• PathCommandKind.RTQuad

RVLine:

• PathCommandKind.RVLine

SCubic:

• PathCommandKind.SCubic

segments:

• paths: segments(s: seq[Vec2]): Segment

setRgbaUnsafe:

• images: setRgbaUnsafe(image: Image; x, y: int; rgba: ColorRGBX)

setValueUnsafe:

• masks: setValueUnsafe(mask: Mask; x, y: int; value: uint8)

shadow:

• images: shadow(image: Image; offset: Vec2; spread, blur: float32; color: ColorRGBX): Image

shift:

• images: shift(target: Image | Mask; offset: Vec2)

SomePath:

• paths: SomePath

spread:

• masks: spread(mask: Mask; spread: float32)

strokeCircle:

• pixie: strokeCircle(image: Image; center: Vec2; radius: float32; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeCircle(mask: Mask; center: Vec2; radius: float32; strokeWidth = 1.0)

strokeEllipse:

• pixie: strokeEllipse(image: Image; center: Vec2; rx, ry: float32; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeEllipse(mask: Mask; center: Vec2; rx, ry: float32; strokeWidth = 1.0)

strokePath:

• paths: strokePath(image: Image; path: SomePath; color: ColorRGBX; transform: Vec2 | Mat3; strokeWidth = 1.0; lineCap = lcButt; lineJoin = ljMiter; blendMode = bmNormal)
• paths: strokePath(image: Image; path: SomePath; color: ColorRGBX; strokeWidth = 1.0; lineCap = lcButt; lineJoin = ljMiter; blendMode = bmNormal)
• paths: strokePath(mask: Mask; path: SomePath; transform: Vec2 | Mat3; strokeWidth = 1.0; lineCap = lcButt; lineJoin = ljMiter)
• paths: strokePath(mask: Mask; path: SomePath; strokeWidth = 1.0; lineCap = lcButt; lineJoin = ljMiter)

strokePolygon:

• pixie: strokePolygon(image: Image; pos: Vec2; size: float32; sides: int; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokePolygon(mask: Mask; pos: Vec2; size: float32; sides: int; strokeWidth = 1.0)

strokeRect:

• pixie: strokeRect(image: Image; rect: Rect; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeRect(mask: Mask; rect: Rect; strokeWidth = 1.0)

strokeRoundedRect:

• pixie: strokeRoundedRect(image: Image; rect: Rect; radius: float32; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeRoundedRect(image: Image; rect: Rect; nw, ne, se, sw: float32; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeRoundedRect(mask: Mask; rect: Rect; radius: float32; strokeWidth = 1.0)
• pixie: strokeRoundedRect(mask: Mask; rect: Rect; nw, ne, se, sw: float32; strokeWidth = 1.0)

strokeSegment:

• pixie: strokeSegment(image: Image; segment: Segment; color: ColorRGBA; strokeWidth = 1.0)
• pixie: strokeSegment(mask: Mask; segment: Segment; strokeWidth: float32)

subImage:

• images: subImage(image: Image; x, y, w, h: int): Image

superImage:

• images: superImage(image: Image; x, y, w, h: int): Image

svgSignature:

• svg: svgSignature

toPremultipliedAlpha:

• internal: toPremultipliedAlpha(data: var seq[ColorRGBA | ColorRGBX])

toStraightAlpha:

• internal: toStraightAlpha(data: var seq[ColorRGBA | ColorRGBX])

TQuad:

• PathCommandKind.TQuad

transform:

• paths: transform(path: var Path; mat: Mat3)

unpackAlphaValues:

• internal: unpackAlphaValues(v: M128i): M128i

VLine:

• PathCommandKind.VLine

wh:

• images: wh(image: Image): Vec2
• masks: wh(mask: Mask): Vec2

WindingRule:

• paths: WindingRule

wrEvenOdd:

• WindingRule.wrEvenOdd

writeFile:

• pixie: writeFile(image: Image; filePath: string)
• pixie: writeFile(image: Image; filePath: string; fileFormat: FileFormat)

wrNonZero:

• WindingRule.wrNonZero

xmlSignature:

• svg: xmlSignature