pixel-data-js 0.30.0 → 0.32.0

package/src/PixelData/extractPixelDataBuffer.ts

@@ -1,15 +1,21 @@
 import type { Rect } from '../Rect/_rect-types'
-import { makeClippedBlit, resolveBlitClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_BLIT = makeClippedBlit()
-
 /**
  * Extracts a rectangular region of pixels from PixelData.
  * Returns a new Uint32Array containing the extracted pixels.
  */
-export function extractPixelDataBuffer(source: PixelData32, rect: Rect): Uint32Array
-export function extractPixelDataBuffer(source: PixelData32, x: number, y: number, w: number, h: number): Uint32Array
+export function extractPixelDataBuffer(
+  source: PixelData32,
+  rect: Rect,
+): Uint32Array
+export function extractPixelDataBuffer(
+  source: PixelData32,
+  x: number,
+  y: number,
+  w: number,
+  h: number,
+): Uint32Array
 export function extractPixelDataBuffer(
   source: PixelData32,
   _x: Rect | number,
@@ -17,56 +23,63 @@ export function extractPixelDataBuffer(
   _w?: number,
   _h?: number,
 ): Uint32Array {
-  const { x, y, w, h } = typeof _x === 'object'
-    ? _x
-    : { x: _x, y: _y!, w: _w!, h: _h! }
+  let x: number
+  let y: number
+  let w: number
+  let h: number
+
+  if (typeof _x === 'object') {
+    x = _x.x
+    y = _x.y
+    w = _x.w
+    h = _x.h
+  } else {
+    x = _x
+    y = _y!
+    w = _w!
+    h = _h!
+  }
 
   const srcW = source.w
   const srcH = source.h
   const srcData = source.data
 
-  // Safety check for empty or invalid dimensions
-  if (w <= 0 || h <= 0) {
-    return new Uint32Array(0)
-  }
+  if (w <= 0) return new Uint32Array(0)
+  if (h <= 0) return new Uint32Array(0)
 
   const dstData = new Uint32Array(w * h)
 
-  // 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,
-  )
+  // Inline clipping logic to avoid object allocations
+  let srcX = x
+  let srcY = y
+  let dstX = 0
+  let dstY = 0
+  let copyW = w
+  let copyH = h
+
+  if (srcX < 0) {
+    dstX = -srcX
+    copyW += srcX
+    srcX = 0
+  }
 
-  if (!clip.inBounds) return dstData
+  if (srcY < 0) {
+    dstY = -srcY
+    copyH += srcY
+    srcY = 0
+  }
 
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH,
-  } = clip
+  copyW = Math.min(copyW, srcW - srcX)
+  copyH = Math.min(copyH, srcH - srcY)
+
+  if (copyW <= 0) return dstData
+  if (copyH <= 0) return dstData
 
   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 + copyW)
+
     dstData.set(chunk, dstStart)
   }
 

package/src/PixelData/fillPixelData.ts

@@ -1,10 +1,7 @@
 import type { Color32 } from '../_types'
 import type { Rect } from '../Rect/_rect-types'
-import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_RECT = makeClippedRect()
-
 /**
  * Fills a region or the {@link PixelData32} buffer with a solid color.
  *
@@ -42,6 +39,9 @@ export function fillPixelData(
   _w?: number,
   _h?: number,
 ): boolean {
+  const dstW = dst.w
+  const dstH = dst.h
+
   let x: number
   let y: number
   let w: number
@@ -50,8 +50,8 @@ export function fillPixelData(
   if (typeof _x === 'object') {
     x = _x.x ?? 0
     y = _x.y ?? 0
-    w = _x.w ?? dst.w
-    h = _x.h ?? dst.h
+    w = _x.w ?? dstW
+    h = _x.h ?? dstH
   } else if (typeof _x === 'number') {
     x = _x
     y = _y!
@@ -60,37 +60,55 @@ export function fillPixelData(
   } else {
     x = 0
     y = 0
-    w = dst.w
-    h = dst.h
+    w = dstW
+    h = dstH
+  }
+
+  // Inline bounds clipping
+  let dstX = x
+  let dstY = y
+  let fillW = w
+  let fillH = h
+
+  if (dstX < 0) {
+    fillW += dstX
+    dstX = 0
   }
 
-  const clip = resolveRectClipping(
-    x,
-    y,
-    w,
-    h,
-    dst.w,
-    dst.h,
-    SCRATCH_RECT,
-  )
+  if (dstY < 0) {
+    fillH += dstY
+    dstY = 0
+  }
 
-  if (!clip.inBounds) return false
+  fillW = Math.min(fillW, dstW - dstX)
+  fillH = Math.min(fillH, dstH - dstY)
 
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH,
-  } = clip
+  if (fillW <= 0) return false
+  if (fillH <= 0) return false
 
   const dst32 = dst.data
-  const dw = dst.w
   let hasChanged = false
 
-  for (let iy = 0; iy < actualH; iy++) {
-    const rowOffset = (finalY + iy) * dw
-    const start = rowOffset + finalX
-    const end = start + actualW
+  // Fast-path: If the area spans the full width, we can treat it as a contiguous 1D array
+  if (dstX === 0 && fillW === dstW) {
+    const start = dstY * dstW
+    const end = start + fillW * fillH
+
+    for (let i = start; i < end; i++) {
+      if (dst32[i] !== color) {
+        dst32[i] = color
+        hasChanged = true
+      }
+    }
+
+    return hasChanged
+  }
+
+  // Standard path: row-by-row
+  for (let iy = 0; iy < fillH; iy++) {
+    const rowOffset = (dstY + iy) * dstW
+    const start = rowOffset + dstX
+    const end = start + fillW
 
     for (let i = start; i < end; i++) {
       if (dst32[i] !== color) {

package/src/PixelData/fillPixelDataBinaryMask.ts

@@ -1,17 +1,16 @@
 import type { Color32 } from '../_types'
 import type { BinaryMask } from '../Mask/_mask-types'
-import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_RECT = makeClippedRect()
-
 /**
- * Fills a region of the {@link PixelData32} buffer with a solid color using a mask.
+ * Fills the target PixelData with a color based on a binary mask.
+ *
  * @param target - The target to modify.
  * @param color - The color to apply.
- * @param mask - The mask defining the area to fill.
- * @param x - Starting horizontal coordinate for the mask placement.
- * @param y - Starting vertical coordinate for the mask placement.
+ * @param mask - The binary mask determining where to fill.
+ * @param x - Horizontal offset to place the mask.
+ * @param y - Vertical offset to place the mask.
+ * @returns true if any pixels were actually modified.
  */
 export function fillPixelDataBinaryMask(
   target: PixelData32,
@@ -20,55 +19,61 @@ export function fillPixelDataBinaryMask(
   x = 0,
   y = 0,
 ): boolean {
-
+  const targetW = target.w
+  const targetH = target.h
   const maskW = mask.w
   const maskH = mask.h
 
-  const clip = resolveRectClipping(
-    x,
-    y,
-    maskW,
-    maskH,
-    target.w,
-    target.h,
-    SCRATCH_RECT,
-  )
+  // Inline clipping logic
+  let dstX = x
+  let dstY = y
+  let actualW = maskW
+  let actualH = maskH
+
+  if (dstX < 0) {
+    actualW += dstX
+    dstX = 0
+  }
+
+  if (dstY < 0) {
+    actualH += dstY
+    dstY = 0
+  }
 
-  if (!clip.inBounds) return false
+  actualW = Math.min(actualW, targetW - dstX)
+  actualH = Math.min(actualH, targetH - dstY)
 
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH,
-  } = clip
+  if (actualW <= 0 || actualH <= 0) return false
 
   const maskData = mask.data
   const dst32 = target.data
-  const dw = target.w
+
+  // Calculate offsets for the mask based on clipping
+  const mx = dstX - x
+  const my = dstY - y
 
   let hasChanged = false
 
-  for (let iy = 0; iy < actualH; iy++) {
-    const currentY = finalY + iy
-    const maskY = currentY - y
-    const maskOffset = maskY * maskW
+  // Stride-based loop for performance
+  let dIdx = dstY * targetW + dstX
+  let mIdx = my * maskW + mx
 
-    const dstRowOffset = currentY * dw
+  const dStride = targetW - actualW
+  const mStride = maskW - actualW
 
+  for (let iy = 0; iy < actualH; iy++) {
     for (let ix = 0; ix < actualW; ix++) {
-      const currentX = finalX + ix
-      const maskX = currentX - x
-      const maskIndex = maskOffset + maskX
-
-      if (maskData[maskIndex]) {
-        const current = dst32[dstRowOffset + currentX]
-        if (current !== color) {
-          dst32[dstRowOffset + currentX] = color
+      if (maskData[mIdx]) {
+        if (dst32[dIdx] !== color) {
+          dst32[dIdx] = color
           hasChanged = true
         }
       }
+      dIdx++
+      mIdx++
     }
+    dIdx += dStride
+    mIdx += mStride
   }
 
   return hasChanged

package/src/PixelData/fillPixelDataFast.ts

@@ -1,10 +1,7 @@
 import type { Color32 } from '../_types'
 import type { Rect } from '../Rect/_rect-types'
-import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_RECT = makeClippedRect()
-
 /**
  * Fills a region or the {@link PixelData32} buffer with a solid color.
  * This function is faster than {@link fillPixelData} but does not
@@ -44,6 +41,9 @@ export function fillPixelDataFast(
   _w?: number,
   _h?: number,
 ): void {
+  const dstW = dst.w
+  const dstH = dst.h
+
   let x: number
   let y: number
   let w: number
@@ -66,31 +66,41 @@ export function fillPixelDataFast(
     h = dst.h
   }
 
-  const clip = resolveRectClipping(x, y, w, h, dst.w, dst.h, SCRATCH_RECT)
+  // Inline bounds clipping
+  let dstX = x
+  let dstY = y
+  let fillW = w
+  let fillH = h
+
+  if (dstX < 0) {
+    fillW += dstX
+    dstX = 0
+  }
+
+  if (dstY < 0) {
+    fillH += dstY
+    dstY = 0
+  }
 
-  if (!clip.inBounds) return
+  fillW = Math.min(fillW, dstW - dstX)
+  fillH = Math.min(fillH, dstH - dstY)
 
-  // Use the clipped values
-  const {
-    x: finalX,
-    y: finalY,
-    w: actualW,
-    h: actualH,
-  } = clip
+  if (fillW <= 0) return
+  if (fillH <= 0) return
 
   const dst32 = dst.data
   const dw = dst.w
 
   // Optimization: If filling the entire buffer, use the native .fill()
-  if (actualW === dw && actualH === dst.h && finalX === 0 && finalY === 0) {
+  if (fillW === dw && fillH === dst.h && dstX === 0 && dstY === 0) {
     dst32.fill(color)
     return
   }
 
   // Row-by-row fill for partial rectangles
-  for (let iy = 0; iy < actualH; iy++) {
-    const start = (finalY + iy) * dw + finalX
-    const end = start + actualW
+  for (let iy = 0; iy < fillH; iy++) {
+    const start = (dstY + iy) * dw + dstX
+    const end = start + fillW
     dst32.fill(color, start, end)
   }
 }

package/src/PixelData/invertPixelData.ts

@@ -1,49 +1,66 @@
 import { type PixelMutateOptions } from '../_types'
-import { makeClippedRect, resolveRectClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_RECT = makeClippedRect()
-
+/**
+ * Inverts the RGB color data of the target PixelData, optionally controlled by a mask.
+ * @param target - The target to modify.
+ * @param opts - Options defining the area, mask, and offsets.
+ * @returns true if the operation was performed within bounds.
+ */
 export function invertPixelData(
   target: PixelData32,
   opts?: PixelMutateOptions,
 ): boolean {
+  const targetW = target.w
+  const targetH = target.h
+
   const mask = opts?.mask
+  const invertMask = opts?.invertMask ?? false
+
   const targetX = opts?.x ?? 0
   const targetY = opts?.y ?? 0
   const mx = opts?.mx ?? 0
   const my = opts?.my ?? 0
-  const width = opts?.w ?? target.w
-  const height = opts?.h ?? target.h
-  const invertMask = opts?.invertMask ?? false
+  const w = opts?.w ?? targetW
+  const h = opts?.h ?? targetH
 
-  const clip = resolveRectClipping(targetX, targetY, width, height, target.w, target.h, SCRATCH_RECT)
+  // Inline clipping logic
+  let x = targetX
+  let y = targetY
+  let actualW = w
+  let actualH = h
 
-  if (!clip.inBounds) return false
+  if (x < 0) {
+    actualW += x
+    x = 0
+  }
 
-  const {
-    x,
-    y,
-    w: actualW,
-    h: actualH,
-  } = clip
+  if (y < 0) {
+    actualH += y
+    y = 0
+  }
+
+  actualW = Math.min(actualW, targetW - x)
+  actualH = Math.min(actualH, targetH - y)
+
+  if (actualW <= 0 || actualH <= 0) return false
 
   const dst32 = target.data
-  const dw = target.w
-  const mPitch = mask?.w ?? width
+  const dw = targetW
 
+  // Calculate relative movement for the mask coordinate
   const dx = x - targetX
   const dy = y - targetY
 
   let dIdx = y * dw + x
-  let mIdx = (my + dy) * mPitch + (mx + dx)
-
   const dStride = dw - actualW
-  const mStride = mPitch - actualW
 
-  // Optimization: Split loops to avoid checking `if (mask)` for every pixel.
   if (mask) {
     const maskData = mask.data
+    const mPitch = mask.w
+    let mIdx = (my + dy) * mPitch + (mx + dx)
+    const mStride = mPitch - actualW
+
     for (let iy = 0; iy < actualH; iy++) {
       for (let ix = 0; ix < actualW; ix++) {
         const mVal = maskData[mIdx]
@@ -52,7 +69,7 @@ export function invertPixelData(
           : mVal === 1
 
         if (isHit) {
-          // XOR with 0x00FFFFFF flips RGB bits and ignores Alpha (the top 8 bits)
+          // XOR with 0x00FFFFFF flips RGB bits and ignores Alpha
           dst32[dIdx] = dst32[dIdx] ^ 0x00FFFFFF
         }
         dIdx++

package/src/PixelData/resizePixelData.ts

@@ -0,0 +1,75 @@
+import type { MutablePixelData32, PixelData32 } from './_pixelData-types'
+
+/**
+ * Non-destructively resizes the {@link PixelData32} buffer to new dimensions, optionally
+ * offsetting the original content.
+ * This operation creates a new buffer. It does not scale or stretch pixels;
+ * instead, it crops or pads the image based on the new dimensions.
+ *
+ * @param target - The source pixel data to resize.
+ * @param newWidth - The target width in pixels.
+ * @param newHeight - The target height in pixels.
+ * @param offsetX - The horizontal offset for placing the original image.
+ * @param offsetY - The vertical offset for placing the original image.
+ * @param out - output object
+ * @returns A new {@link PixelData32} object with the specified dimensions.
+ */
+export function resizePixelData(
+  target: PixelData32,
+  newWidth: number,
+  newHeight: number,
+  offsetX = 0,
+  offsetY = 0,
+  out?: MutablePixelData32,
+): PixelData32 {
+  const newData = new Uint32Array(newWidth * newHeight)
+  const {
+    w: oldW,
+    h: oldH,
+    data: oldData,
+  } = target
+
+  const result = out ?? {} as MutablePixelData32
+  result.w = newWidth
+  result.h = newHeight
+  result.data = newData
+
+  // Determine intersection of the old image (at offset) and new canvas bounds
+  const x0 = Math.max(0, offsetX)
+  const y0 = Math.max(0, offsetY)
+  const x1 = Math.min(newWidth, offsetX + oldW)
+  const y1 = Math.min(newHeight, offsetY + oldH)
+
+  if (x1 <= x0 || y1 <= y0) {
+    return result
+  }
+
+  const copyW = x1 - x0
+  const copyH = y1 - y0
+
+  // Optimization: If we are copying the full width of both buffers,
+  // we can perform a single bulk 1D copy.
+  if (copyW === oldW && copyW === newWidth && offsetX === 0) {
+    const srcStart = (y0 - offsetY) * oldW
+    const dstStart = y0 * newWidth
+    const len = copyW * copyH
+
+    newData.set(oldData.subarray(srcStart, srcStart + len), dstStart)
+    return result
+  }
+
+  // Standard row-by-row copy
+  for (let row = 0; row < copyH; row++) {
+    const dstY = y0 + row
+    const srcY = dstY - offsetY
+    const srcX = x0 - offsetX
+
+    const dstStart = dstY * newWidth + x0
+    const srcStart = srcY * oldW + srcX
+    const chunk = oldData.subarray(srcStart, srcStart + copyW)
+
+    newData.set(chunk, dstStart)
+  }
+
+  return result
+}