pixel-data-js 0.17.1 → 0.19.0

package/src/PixelData/blendPixelDataBinaryMask.ts

@@ -0,0 +1,133 @@
+import type { BinaryMask, Color32, IPixelData, PixelBlendMaskOptions } from '../_types'
+import { sourceOverPerfect } from '../BlendModes/blend-modes-perfect'
+
+export function blendPixelDataBinaryMask(
+  dst: IPixelData,
+  src: IPixelData,
+  binaryMask: BinaryMask,
+  opts: PixelBlendMaskOptions,
+) {
+  const {
+    x: targetX = 0,
+    y: targetY = 0,
+    sx: sourceX = 0,
+    sy: sourceY = 0,
+    w: width = src.width,
+    h: height = src.height,
+    alpha: globalAlpha = 255,
+    blendFn = sourceOverPerfect,
+    mw = src.width,
+    mx = 0,
+    my = 0,
+    invertMask = false,
+  } = opts
+
+  if (globalAlpha === 0) return
+
+  let x = targetX
+  let y = targetY
+  let sx = sourceX
+  let sy = sourceY
+  let w = width
+  let h = height
+
+  // 1. Source Clipping
+  if (sx < 0) {
+    x -= sx
+    w += sx
+    sx = 0
+  }
+  if (sy < 0) {
+    y -= sy
+    h += sy
+    sy = 0
+  }
+  w = Math.min(w, src.width - sx)
+  h = Math.min(h, src.height - sy)
+
+  // 2. Destination Clipping
+  if (x < 0) {
+    sx -= x
+    w += x
+    x = 0
+  }
+  if (y < 0) {
+    sy -= y
+    h += y
+    y = 0
+  }
+
+  const actualW = Math.min(w, dst.width - x)
+  const actualH = Math.min(h, dst.height - y)
+
+  if (actualW <= 0 || actualH <= 0) return
+
+  // 3. Coordinate Displacement for Mask Sync
+  // dx/dy represents how far the clipped start is from the requested start.
+  // This is the stable way to align the mask across all clipping permutations.
+  const dx = (x - targetX) | 0
+  const dy = (y - targetY) | 0
+
+  const dst32 = dst.data32
+  const src32 = src.data32
+  const dw = dst.width
+  const sw = src.width
+  const mPitch = mw
+
+  let dIdx = (y * dw + x) | 0
+  let sIdx = (sy * sw + sx) | 0
+  let mIdx = ((my + dy) * mPitch + (mx + dx)) | 0
+
+  const dStride = (dw - actualW) | 0
+  const sStride = (sw - actualW) | 0
+  const mStride = (mPitch - actualW) | 0
+
+  const skipVal = invertMask ? 1 : 0
+  const isOpaque = globalAlpha === 255
+  const isOverwrite = blendFn.isOverwrite || false
+
+  for (let iy = 0; iy < actualH; iy++) {
+    for (let ix = 0; ix < actualW; ix++) {
+      // Binary Mask Check (Earliest exit)
+      if (binaryMask[mIdx] === skipVal) {
+        dIdx++
+        sIdx++
+        mIdx++
+        continue
+      }
+
+      const srcCol = src32[sIdx] as Color32
+      const srcAlpha = srcCol >>> 24
+
+      // Source Alpha Check
+      if (srcAlpha === 0 && !isOverwrite) {
+        dIdx++
+        sIdx++
+        mIdx++
+        continue
+      }
+
+      let finalCol = srcCol
+      if (!isOpaque) {
+        // Rounding-corrected global alpha application
+        const a = (srcAlpha * globalAlpha + 128) >> 8
+        if (a === 0 && !isOverwrite) {
+          dIdx++
+          sIdx++
+          mIdx++
+          continue
+        }
+        finalCol = ((srcCol & 0x00ffffff) | (a << 24)) >>> 0 as Color32
+      }
+
+      dst32[dIdx] = blendFn(finalCol, dst32[dIdx] as Color32)
+
+      dIdx++
+      sIdx++
+      mIdx++
+    }
+    dIdx += dStride
+    sIdx += sStride
+    mIdx += mStride
+  }
+}

package/src/PixelData/clearPixelData.ts

@@ -1,5 +1,4 @@
-import type { Color32, Rect } from '../_types'
-import type { PixelData } from './PixelData'
+import type { Color32, IPixelData, Rect } from '../_types'
 import { fillPixelData } from './fillPixelData'
 
 /**
@@ -7,7 +6,7 @@ import { fillPixelData } from './fillPixelData'
  * Internally uses the optimized fillPixelData.
  */
 export function clearPixelData(
-  dst: PixelData,
+  dst: IPixelData,
   rect?: Partial<Rect>,
 ): void {
   fillPixelData(dst, 0 as Color32, rect)

package/src/PixelData/extractPixelData.ts

@@ -1,4 +1,4 @@
-import type { Rect } from '../_types'
+import type { IPixelData, Rect } from '../_types'
 import { extractPixelDataBuffer } from './extractPixelDataBuffer'
 import { PixelData } from './PixelData'
 
@@ -6,10 +6,10 @@ import { PixelData } from './PixelData'
  * High-level extraction that returns a new PixelData instance.
  * Leverages extractPixelDataBuffer for optimized 32-bit memory moves.
  */
-export function extractPixelData(source: PixelData, rect: Rect): PixelData
-export function extractPixelData(source: PixelData, x: number, y: number, w: number, h: number): PixelData
+export function extractPixelData(source: IPixelData, rect: Rect): PixelData
+export function extractPixelData(source: IPixelData, x: number, y: number, w: number, h: number): PixelData
 export function extractPixelData(
-  source: PixelData,
+  source: IPixelData,
   _x: Rect | number,
   _y?: number,
   _w?: number,

package/src/PixelData/extractPixelDataBuffer.ts

@@ -1,14 +1,16 @@
-import type { Rect } from '../_types'
-import type { PixelData } from './PixelData'
+import type { IPixelData, Rect } from '../_types'
+import { makeClippedBlit, resolveBlitClipping } from '../Internal/resolveClipping'
+
+const SCRATCH_BLIT = makeClippedBlit()
 
 /**
  * Extracts a rectangular region of pixels from PixelData.
  * Returns a new Uint32Array containing the extracted pixels.
  */
-export function extractPixelDataBuffer(source: PixelData, rect: Rect): Uint32Array
-export function extractPixelDataBuffer(source: PixelData, x: number, y: number, w: number, h: number): Uint32Array
+export function extractPixelDataBuffer(source: IPixelData, rect: Rect): Uint32Array
+export function extractPixelDataBuffer(source: IPixelData, x: number, y: number, w: number, h: number): Uint32Array
 export function extractPixelDataBuffer(
-  source: PixelData,
+  source: IPixelData,
   _x: Rect | number,
   _y?: number,
   _w?: number,
@@ -27,33 +29,43 @@ export function extractPixelDataBuffer(
     return new Uint32Array(0)
   }
 
-  // Create a new ImageData to get a clean, aligned buffer
-  const dstImageData = new ImageData(w, h)
-  const dstData = new Uint32Array(dstImageData.data.buffer)
-
-  const x0 = Math.max(0, x)
-  const y0 = Math.max(0, y)
-  const x1 = Math.min(srcW, x + w)
-  const y1 = Math.min(srcH, y + h)
+  const dstData = new Uint32Array(w * h)
 
-  // Return empty buffer if no intersection
-  if (x1 <= x0 || y1 <= y0) {
-    return dstData
-  }
+  // We map from Source (srcW, srcH) at (x,y)
+  // To Dest (w, h) at (0,0)
+  // Note: resolveBlitClipping usually takes (dstX, dstY, srcX, srcY...)
+  // Here we are "blitting" FROM x,y TO 0,0.
+  const clip = resolveBlitClipping(
+    0,
+    0,
+    x,
+    y,
+    w,
+    h,
+    w,
+    h,
+    srcW,
+    srcH,
+    SCRATCH_BLIT,
+  )
 
-  const copyWidth = x1 - x0
-  const copyHeight = y1 - y0
+  if (!clip.inBounds) return dstData
 
-  for (let row = 0; row < copyHeight; row++) {
-    const srcRow = y0 + row
-    const srcStart = srcRow * srcW + x0
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH,
+  } = clip
 
-    const dstRow = (y0 - y) + row
-    const dstCol = (x0 - x)
-    const dstStart = dstRow * w + dstCol
+  for (let row = 0; row < copyH; row++) {
+    const srcStart = (srcY + row) * srcW + srcX
+    const dstStart = (dstY + row) * w + dstX
 
     // Perform the high-speed 32-bit bulk copy
-    const chunk = srcData.subarray(srcStart, srcStart + copyWidth)
+    const chunk = srcData.subarray(srcStart, srcStart + copyW)
     dstData.set(chunk, dstStart)
   }
 

package/src/PixelData/fillPixelData.ts

@@ -1,6 +1,9 @@
-import type { Color32, Rect } from '../_types'
+import type { Color32, IPixelData, Rect } from '../_types'
+import { makeClippedRect, resolveRectClipping } from '../Internal/resolveClipping'
 import type { PixelData } from './PixelData'
 
+const SCRATCH_RECT = makeClippedRect()
+
 /**
  * Fills a region or the {@link PixelData} buffer with a solid color.
  *
@@ -10,7 +13,7 @@ import type { PixelData } from './PixelData'
  * buffer is filled.
  */
 export function fillPixelData(
-  dst: PixelData,
+  dst: IPixelData,
   color: Color32,
   rect?: Partial<Rect>,
 ): void
@@ -23,7 +26,7 @@ export function fillPixelData(
  * @param h - Height of the fill area.
  */
 export function fillPixelData(
-  dst: PixelData,
+  dst: IPixelData,
   color: Color32,
   x: number,
   y: number,
@@ -31,7 +34,7 @@ export function fillPixelData(
   h: number,
 ): void
 export function fillPixelData(
-  dst: PixelData,
+  dst: IPixelData,
   color: Color32,
   _x?: Partial<Rect> | number,
   _y?: number,
@@ -60,35 +63,30 @@ export function fillPixelData(
     h = dst.height
   }
 
-  // Destination Clipping
-  if (x < 0) {
-    w += x
-    x = 0
-  }
-  if (y < 0) {
-    h += y
-    y = 0
-  }
+  const clip = resolveRectClipping(x, y, w, h, dst.width, dst.height, SCRATCH_RECT)
 
-  const actualW = Math.min(w, dst.width - x)
-  const actualH = Math.min(h, dst.height - y)
+  if (!clip.inBounds) return
 
-  if (actualW <= 0 || actualH <= 0) {
-    return
-  }
+  // Use the clipped values
+  const {
+    x: finalX,
+    y: finalY,
+    w: actualW,
+    h: actualH,
+  } = clip
 
   const dst32 = dst.data32
   const dw = dst.width
 
   // Optimization: If filling the entire buffer, use the native .fill()
-  if (actualW === dw && actualH === dst.height && x === 0 && y === 0) {
+  if (actualW === dw && actualH === dst.height && finalX === 0 && finalY === 0) {
     dst32.fill(color)
     return
   }
 
   // Row-by-row fill for partial rectangles
   for (let iy = 0; iy < actualH; iy++) {
-    const start = (y + iy) * dw + x
+    const start = (finalY + iy) * dw + finalX
     const end = start + actualW
     dst32.fill(color, start, end)
   }

package/src/PixelData/invertPixelData.ts

@@ -1,15 +1,16 @@
-import { type PixelMutateOptions } from '../_types'
-import type { PixelData } from './PixelData'
+import { type IPixelData, type PixelMutateOptions } from '../_types'
+import { makeClippedRect, resolveRectClipping } from '../Internal/resolveClipping'
+
+const SCRATCH_RECT = makeClippedRect()
 
 export function invertPixelData(
-  pixelData: PixelData,
+  pixelData: IPixelData,
   opts: PixelMutateOptions = {},
 ): void {
   const dst = pixelData
   const {
     x: targetX = 0,
     y: targetY = 0,
-
     w: width = pixelData.width,
     h: height = pixelData.height,
     mask,
@@ -19,25 +20,16 @@ export function invertPixelData(
     invertMask = false,
   } = opts
 
-  let x = targetX
-  let y = targetY
-  let w = width
-  let h = height
-
-  // Destination Clipping
-  if (x < 0) {
-    w += x
-    x = 0
-  }
-  if (y < 0) {
-    h += y
-    y = 0
-  }
+  const clip = resolveRectClipping(targetX, targetY, width, height, dst.width, dst.height, SCRATCH_RECT)
 
-  const actualW = Math.min(w, dst.width - x)
-  const actualH = Math.min(h, dst.height - y)
+  if (!clip.inBounds) return
 
-  if (actualW <= 0 || actualH <= 0) return
+  const {
+    x,
+    y,
+    w: actualW,
+    h: actualH,
+  } = clip
 
   const dst32 = dst.data32
   const dw = dst.width

package/src/PixelData/pixelDataToAlphaMask.ts

@@ -1,12 +1,11 @@
-import type { AlphaMask } from '../_types'
-import type { PixelData } from './PixelData'
+import type { AlphaMask, IPixelData } from '../_types'
 
 /**
  * Extracts the alpha channel from PixelData into a single-channel mask.
  * Returns a Uint8Array branded as AlphaMask.
  */
 export function pixelDataToAlphaMask(
-  pixelData: PixelData,
+  pixelData: IPixelData,
 ): AlphaMask {
   const {
     data32,

package/src/PixelData/reflectPixelData.ts

@@ -1,6 +1,6 @@
-import type { PixelData } from './PixelData'
+import type { IPixelData } from '../_types'
 
-export function reflectPixelDataHorizontal(pixelData: PixelData): void {
+export function reflectPixelDataHorizontal(pixelData: IPixelData): void {
   const width = pixelData.width
   const height = pixelData.height
   const data = pixelData.data32
@@ -20,7 +20,7 @@ export function reflectPixelDataHorizontal(pixelData: PixelData): void {
   }
 }
 
-export function reflectPixelDataVertical(pixelData: PixelData): void {
+export function reflectPixelDataVertical(pixelData: IPixelData): void {
   const width = pixelData.width
   const height = pixelData.height
   const data = pixelData.data32

package/src/PixelData/resamplePixelData.ts

@@ -1,8 +1,4 @@
-/**
- * Resamples an PixelData by a specific factor using nearest neighbor
- * Factor > 1 upscales, Factor < 1 downscales.
- */
-import { PixelData } from '../index'
+import { type IPixelData, PixelData } from '../index'
 import { resample32 } from '../Internal/resample32'
 
 /**
@@ -10,7 +6,7 @@ import { resample32 } from '../Internal/resample32'
  * Factor > 1 upscales, Factor < 1 downscales.
  */
 export function resamplePixelData(
-  pixelData: PixelData,
+  pixelData: IPixelData,
   factor: number,
 ): PixelData {
   const { data, width, height } = resample32(pixelData.data32, pixelData.width, pixelData.height, factor)

package/src/PixelData/writePixelDataBuffer.ts

@@ -1,5 +1,8 @@
+import { type IPixelData, type Rect } from '../_types'
+import { makeClippedBlit, resolveBlitClipping } from '../Internal/resolveClipping'
 import type { PixelData } from './PixelData'
-import { type Rect } from '../_types'
+
+const SCRATCH_BLIT = makeClippedBlit()
 
 /**
  * Copies a pixel buffer into a specific region of a {@link PixelData} object.
@@ -8,12 +11,12 @@ import { type Rect } from '../_types'
  * into the target {@link PixelData} buffer.
  */
 export function writePixelDataBuffer(
-  target: PixelData,
+  target: IPixelData,
   data: Uint32Array,
   rect: Rect,
 ): void
 export function writePixelDataBuffer(
-  target: PixelData,
+  target: IPixelData,
   data: Uint32Array,
   x: number,
   y: number,
@@ -21,7 +24,7 @@ export function writePixelDataBuffer(
   h: number,
 ): void
 export function writePixelDataBuffer(
-  target: PixelData,
+  target: IPixelData,
   data: Uint32Array,
   _x: Rect | number,
   _y?: number,
@@ -41,25 +44,36 @@ export function writePixelDataBuffer(
   const dstH = target.height
   const dstData = target.data32
 
-  const x0 = Math.max(0, x)
-  const y0 = Math.max(0, y)
-  const x1 = Math.min(dstW, x + w)
-  const y1 = Math.min(dstH, y + h)
+  // treat the source buffer as a Source Image starting at 0,0 with size w,h
+  const clip = resolveBlitClipping(
+    x,
+    y,
+    0,
+    0,
+    w,
+    h,
+    dstW,
+    dstH,
+    w,
+    h,
+    SCRATCH_BLIT,
+  )
 
-  if (x1 <= x0 || y1 <= y0) {
-    return
-  }
+  if (!clip.inBounds) return
 
-  const rowLen = x1 - x0
-  const srcCol = x0 - x
-  const srcYOffset = y0 - y
-  const actualH = y1 - y0
+  const {
+    x: dstX,
+    y: dstY,
+    sx: srcX,
+    sy: srcY,
+    w: copyW,
+    h: copyH,
+  } = clip
 
-  for (let row = 0; row < actualH; row++) {
-    const dstStart = (y0 + row) * dstW + x0
-    const srcRow = srcYOffset + row
-    const srcStart = srcRow * w + srcCol
+  for (let row = 0; row < copyH; row++) {
+    const dstStart = (dstY + row) * dstW + dstX
+    const srcStart = (srcY + row) * w + srcX
 
-    dstData.set(data.subarray(srcStart, srcStart + rowLen), dstStart)
+    dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart)
   }
 }

package/src/Rect/getCircleBrushOrPencilBounds.ts

@@ -0,0 +1,43 @@
+import type { Rect } from '../_types'
+
+export function getCircleBrushOrPencilBounds(
+  centerX: number,
+  centerY: number,
+  brushSize: number,
+  targetWidth: number,
+  targetHeight: number,
+  out?: Rect,
+): Rect {
+  const r = brushSize / 2
+
+  const minOffset = -Math.ceil(r - 0.5)
+  const maxOffset = Math.floor(r - 0.5)
+
+  // start is inclusive, end is exclusive
+  const startX = Math.floor(centerX + minOffset)
+  const startY = Math.floor(centerY + minOffset)
+  const endX = Math.floor(centerX + maxOffset) + 1
+  const endY = Math.floor(centerY + maxOffset) + 1
+
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const cStartX = Math.max(0, startX)
+  const cStartY = Math.max(0, startY)
+  const cEndX = Math.min(targetWidth, endX)
+  const cEndY = Math.min(targetHeight, endY)
+
+  const w = cEndX - cStartX
+  const h = cEndY - cStartY
+
+  res.x = cStartX
+  res.y = cStartY
+  res.w = w < 0 ? 0 : w
+  res.h = h < 0 ? 0 : h
+
+  return res
+}

package/src/Rect/getCircleBrushOrPencilStrokeBounds.ts

@@ -0,0 +1,24 @@
+import type { Rect } from '../_types'
+
+export function getCircleBrushOrPencilStrokeBounds(
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  brushSize: number,
+  result: Rect,
+): Rect {
+  const r = Math.ceil(brushSize / 2)
+
+  const minX = Math.min(x0, x1) - r
+  const minY = Math.min(y0, y1) - r
+  const maxX = Math.max(x0, x1) + r
+  const maxY = Math.max(x0, y1) + r
+
+  result.x = Math.floor(minX)
+  result.y = Math.floor(minY)
+  result.w = Math.ceil(maxX - minX)
+  result.h = Math.ceil(maxY - minY)
+
+  return result
+}

package/src/Rect/getRectBrushOrPencilBounds.ts

@@ -0,0 +1,38 @@
+import type { Rect } from '../_types'
+
+export function getRectBrushOrPencilBounds(
+  centerX: number,
+  centerY: number,
+  brushWidth: number,
+  brushHeight: number,
+  targetWidth: number,
+  targetHeight: number,
+  out?: Rect,
+): Rect {
+  const startX = Math.floor(centerX - brushWidth / 2)
+  const startY = Math.floor(centerY - brushHeight / 2)
+  const endX = startX + brushWidth
+  const endY = startY + brushHeight
+
+  const res = out ?? {
+    x: 0,
+    y: 0,
+    w: 0,
+    h: 0,
+  }
+
+  const cStartX = Math.max(0, startX)
+  const cStartY = Math.max(0, startY)
+  const cEndX = Math.min(targetWidth, endX)
+  const cEndY = Math.min(targetHeight, endY)
+
+  const w = cEndX - cStartX
+  const h = cEndY - cStartY
+
+  res.x = cStartX
+  res.y = cStartY
+  res.w = w < 0 ? 0 : w
+  res.h = h < 0 ? 0 : h
+
+  return res
+}

package/src/Rect/getRectBrushOrPencilStrokeBounds.ts

@@ -0,0 +1,26 @@
+import type { Rect } from '../_types'
+
+export function getRectBrushOrPencilStrokeBounds(
+  x0: number,
+  y0: number,
+  x1: number,
+  y1: number,
+  brushWidth: number,
+  brushHeight: number,
+  result: Rect,
+): Rect {
+  const halfW = brushWidth / 2
+  const halfH = brushHeight / 2
+
+  const minX = Math.min(x0, x1) - halfW
+  const minY = Math.min(y0, y1) - halfH
+  const maxX = Math.max(x0, x1) + halfW
+  const maxY = Math.max(y0, y1) + halfH
+
+  result.x = Math.floor(minX)
+  result.y = Math.floor(minY)
+  result.w = Math.ceil(maxX - minX)
+  result.h = Math.ceil(maxY - minY)
+
+  return result
+}