pixel-data-js 0.31.0 → 0.33.0

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,40 @@ 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 || 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
+}

package/src/PixelData/writePixelData.ts

@@ -0,0 +1,55 @@
+import type { PixelData32 } from './_pixelData-types'
+
+/**
+ * Writes PixelData from a source to a target.
+ * @param target - The destination to write to.
+ * @param source - The source to read from.
+ * @param x - The x-coordinate in the target where drawing starts.
+ * @param y - The y-coordinate in the target where drawing starts.
+ */
+export function writePixelData(
+  target: PixelData32,
+  source: PixelData32,
+  x = 0,
+  y = 0,
+): void {
+  const dstW = target.w
+  const dstH = target.h
+  const dst = target.data
+
+  const srcW = source.w
+  const srcH = source.h
+  const src = source.data
+
+  let dstX = x
+  let dstY = y
+  let srcX = 0
+  let srcY = 0
+  let copyW = srcW
+  let copyH = srcH
+
+  if (dstX < 0) {
+    srcX = -dstX
+    copyW += dstX
+    dstX = 0
+  }
+
+  if (dstY < 0) {
+    srcY = -dstY
+    copyH += dstY
+    dstY = 0
+  }
+
+  copyW = Math.min(copyW, dstW - dstX)
+  copyH = Math.min(copyH, dstH - dstY)
+
+  if (copyW <= 0 || copyH <= 0) return
+
+  for (let row = 0; row < copyH; row++) {
+    const dstStart = (dstY + row) * dstW + dstX
+    const srcStart = (srcY + row) * srcW + srcX
+    const chunk = src.subarray(srcStart, srcStart + copyW)
+
+    dst.set(chunk, dstStart)
+  }
+}

package/src/PixelData/writePixelDataBuffer.ts

@@ -1,20 +1,25 @@
 import type { Rect } from '../Rect/_rect-types'
-import { makeClippedBlit, resolveBlitClipping } from '../Rect/resolveClipping'
 import type { PixelData32 } from './_pixelData-types'
 
-const SCRATCH_BLIT = makeClippedBlit()
-
 /**
  * Copies a pixel buffer into a specific region of a {@link PixelData32} object.
- *
- * This function performs a direct memory copy from a {@link Uint32Array}
- * into the target buffer.
+ * @param target - The target to write into.
+ * @param data - The source pixel data (Uint32Array).
+ * @param rect - A rect defining the destination region.
  */
 export function writePixelDataBuffer(
   target: PixelData32,
   data: Uint32Array,
   rect: Rect,
 ): void
+/**
+ * @param target - The target to write into.
+ * @param data - The source pixel data (Uint32Array).
+ * @param x - The starting horizontal coordinate in the target.
+ * @param y - The starting vertical coordinate in the target.
+ * @param w - The width of the region to write.
+ * @param h - The height of the region to write.
+ */
 export function writePixelDataBuffer(
   target: PixelData32,
   data: Uint32Array,
@@ -31,49 +36,59 @@ export function writePixelDataBuffer(
   _w?: number,
   _h?: number,
 ): void {
-  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!
+  }
+
+  if (w <= 0 || h <= 0) return
 
   const dstW = target.w
   const dstH = target.h
   const dstData = target.data
 
-  // 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,
-  )
+  // Inline clipping logic
+  let dstX = x
+  let dstY = y
+  let srcX = 0
+  let srcY = 0
+  let copyW = w
+  let copyH = h
+
+  if (dstX < 0) {
+    srcX = -dstX
+    copyW += dstX
+    dstX = 0
+  }
+
+  if (dstY < 0) {
+    srcY = -dstY
+    copyH += dstY
+    dstY = 0
+  }
 
-  if (!clip.inBounds) return
+  copyW = Math.min(copyW, dstW - dstX)
+  copyH = Math.min(copyH, dstH - dstY)
 
-  const {
-    x: dstX,
-    y: dstY,
-    sx: srcX,
-    sy: srcY,
-    w: copyW,
-    h: copyH,
-  } = clip
+  if (copyW <= 0 || copyH <= 0) return
 
   for (let row = 0; row < copyH; row++) {
     const dstStart = (dstY + row) * dstW + dstX
     const srcStart = (srcY + row) * w + srcX
+    const chunk = data.subarray(srcStart, srcStart + copyW)
 
-    dstData.set(data.subarray(srcStart, srcStart + copyW), dstStart)
+    dstData.set(chunk, dstStart)
   }
 }

package/src/index.ts

@@ -58,6 +58,7 @@ export * from './History/PixelWriter'
 
 export * from './ImageData/_ImageData-types'
 export * from './ImageData/copyImageData'
+export * from './ImageData/extractImageData'
 export * from './ImageData/extractImageDataBuffer'
 export * from './ImageData/ImageDataLike'
 export * from './ImageData/imageDataToAlphaMaskBuffer'
@@ -160,15 +161,16 @@ export * from './PixelData/PixelData'
 export * from './PixelData/pixelDataToAlphaMask'
 export * from './PixelData/reflectPixelData'
 export * from './PixelData/resamplePixelData'
+export * from './PixelData/resizePixelData'
 export * from './PixelData/ReusablePixelData'
 export * from './PixelData/rotatePixelData'
 export * from './PixelData/uInt32ArrayToPixelData'
 export * from './PixelData/writePaintBufferToPixelData'
+export * from './PixelData/writePixelData'
 export * from './PixelData/writePixelDataBuffer'
 
 export * from './Rect/_rect-types'
 export * from './Rect/getRectsBounds'
-export * from './Rect/resolveClipping'
 export * from './Rect/trimMaskRectBounds'
 export * from './Rect/trimRectBounds'