pixel-data-js 0.9.2 → 0.10.1

package/dist/index.prod.d.ts

@@ -580,6 +580,12 @@ declare function imgBlobToImageData(blob: Blob): Promise<ImageData>;
 
 declare function invertImageData(imageData: ImageData): ImageData;
 
+/**
+ * Resamples ImageData by a specific factor.
+ * Factor > 1 upscales, Factor < 1 downscales.
+ */
+declare function resampleImageData(source: ImageData, factor: number): ImageData;
+
 /**
  * Non destructively resizes the {@link ImageData} buffer to new dimensions, optionally
  * offsetting the original content.
@@ -664,7 +670,7 @@ type IndexedImage = {
     /**
      * A palette of packed 32-bit colors (ABGR).
      */
-    palette: Int32Array;
+    palette: Uint32Array;
     /**
      * The specific index in the palette that represents a fully transparent pixel.
      */
@@ -673,10 +679,16 @@ type IndexedImage = {
 /**
  * Converts standard ImageData into an IndexedImage format.
  */
+declare function makeIndexedImage(imageData: ImageData): IndexedImage;
+declare function makeIndexedImage(data: Uint8ClampedArray, width: number, height: number): IndexedImage;
+
 /**
- * Converts standard ImageData into an IndexedImage format.
+ * Calculates the frequency of each palette index based on the image data.
+ * The index of the returned array maps directly to the index of the palette.
+ * @param indexedImage - The source image containing data and palette definitions.
+ * @returns A typed array where each entry represents the total count of that palette index.
  */
-declare function makeIndexedImage(imageData: ImageData): IndexedImage;
+declare function getIndexedImageColorCounts(indexedImage: IndexedImage): Int32Array;
 
 /**
  * Calculates the area-weighted average color of an IndexedImage.
@@ -688,12 +700,10 @@ declare function makeIndexedImage(imageData: ImageData): IndexedImage;
 declare function indexedImageToAverageColor(indexedImage: IndexedImage, includeTransparent?: boolean): Color32;
 
 /**
- * Calculates the frequency of each palette index based on the image data.
- * The index of the returned array maps directly to the index of the palette.
- * @param indexedImage - The source image containing data and palette definitions.
- * @returns A typed array where each entry represents the total count of that palette index.
+ * Resamples an IndexedImage by a specific factor using nearest neighbor
+ * Factor > 1 upscales, Factor < 1 downscales.
  */
-declare function getIndexedImageColorCounts(indexedImage: IndexedImage): Int32Array;
+declare function resampleIndexedImage(source: IndexedImage, factor: number): IndexedImage;
 
 /**
  * A convenience wrapper that extracts the first {@link File} from an
@@ -888,6 +898,12 @@ declare function pixelDataToAlphaMask(pixelData: PixelData): AlphaMask;
 declare function reflectPixelDataHorizontal(pixelData: PixelData): void;
 declare function reflectPixelDataVertical(pixelData: PixelData): void;
 
+/**
+ * Resamples an PixelData by a specific factor using nearest neighbor
+ * Factor > 1 upscales, Factor < 1 downscales.
+ */
+declare function resamplePixelData(pixelData: PixelData, factor: number): PixelData;
+
 /**
  * Rotates pixel data 90 degrees clockwise.
  * If the image is square, it performs the rotation in-place.
@@ -911,4 +927,4 @@ declare function rotatePixelData(pixelData: PixelData): void;
  */
 declare function trimRectBounds<T extends Rect | SelectionRect>(target: T, bounds: Rect): void;
 
-export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, BlendMode, type BlendModeIndex, type BlendToIndexGetter, type Color32, type ColorBlendOptions, FAST_BLENDER_REGISTRY, FAST_BLEND_MODES, FAST_BLEND_MODE_BY_NAME, FAST_BLEND_TO_INDEX, type FastBlendModes, type FloodFillImageDataOptions, type FloodFillResult, INDEX_TO_FAST_BLEND, INDEX_TO_PERFECT_BLEND, type ImageDataLike, type IndexToBlendGetter, type IndexedImage, MaskType, PERFECT_BLENDER_REGISTRY, PERFECT_BLEND_MODES, PERFECT_BLEND_MODE_BY_NAME, PERFECT_BLEND_TO_INDEX, type PerfectBlendModes, type PixelBlendOptions, type PixelCanvas, PixelData, type PixelOptions, type Point, type RGBA, type Rect, type RegisteredFastBlender, type RegisteredPerfectBlender, type ReusableCanvas, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataPixels, extractMask, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getIndexedImageColorCounts, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imgBlobToImageData, indexedImageToAverageColor, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeIndexedImage, makePixelCanvas, makeReusableCanvas, mergeMasks, multiplyFast, multiplyPerfect, overlayFast, overlayPerfect, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageDataPixels, writeImageDataToClipboard, writeImgBlobToClipboard };
+export { type AlphaMask, type AnyMask, type ApplyMaskOptions, type Base64EncodedUInt8Array, type BinaryMask, type BlendColor32, BlendMode, type BlendModeIndex, type BlendToIndexGetter, type Color32, type ColorBlendOptions, FAST_BLENDER_REGISTRY, FAST_BLEND_MODES, FAST_BLEND_MODE_BY_NAME, FAST_BLEND_TO_INDEX, type FastBlendModes, type FloodFillImageDataOptions, type FloodFillResult, INDEX_TO_FAST_BLEND, INDEX_TO_PERFECT_BLEND, type ImageDataLike, type IndexToBlendGetter, type IndexedImage, MaskType, PERFECT_BLENDER_REGISTRY, PERFECT_BLEND_MODES, PERFECT_BLEND_MODE_BY_NAME, PERFECT_BLEND_TO_INDEX, type PerfectBlendModes, type PixelBlendOptions, type PixelCanvas, PixelData, type PixelOptions, type Point, type RGBA, type Rect, type RegisteredFastBlender, type RegisteredPerfectBlender, type ReusableCanvas, type SelectionRect, type SerializedImageData, UnsupportedFormatError, applyMaskToPixelData, base64DecodeArrayBuffer, base64EncodeArrayBuffer, blendColorPixelData, blendPixelData, clearPixelData, color32ToCssRGBA, color32ToHex, colorBurnFast, colorBurnPerfect, colorDistance, colorDodgeFast, colorDodgePerfect, copyImageData, copyImageDataLike, copyMask, darkenFast, darkenPerfect, darkerFast, darkerPerfect, deserializeImageData, deserializeNullableImageData, deserializeRawImageData, differenceFast, differencePerfect, divideFast, dividePerfect, exclusionFast, exclusionPerfect, extractImageDataPixels, extractMask, fileInputChangeToImageData, fileToImageData, fillPixelData, floodFillSelection, getImageDataFromClipboard, getIndexedImageColorCounts, getSupportedPixelFormats, hardLightFast, hardLightPerfect, hardMixFast, hardMixPerfect, imageDataToAlphaMask, imageDataToDataUrl, imageDataToImgBlob, imgBlobToImageData, indexedImageToAverageColor, invertAlphaMask, invertBinaryMask, invertImageData, invertPixelData, lerpColor32, lerpColor32Fast, lightenFast, lightenPerfect, lighterFast, lighterPerfect, linearBurnFast, linearBurnPerfect, linearDodgeFast, linearDodgePerfect, linearLightFast, linearLightPerfect, makeIndexedImage, makePixelCanvas, makeReusableCanvas, mergeMasks, multiplyFast, multiplyPerfect, overlayFast, overlayPerfect, overwriteFast, overwritePerfect, packColor, packRGBA, pinLightFast, pinLightPerfect, pixelDataToAlphaMask, reflectPixelDataHorizontal, reflectPixelDataVertical, resampleImageData, resampleIndexedImage, resamplePixelData, resizeImageData, rotatePixelData, screenFast, screenPerfect, serializeImageData, serializeNullableImageData, softLightFast, softLightPerfect, sourceOverFast, sourceOverPerfect, subtractFast, subtractPerfect, trimRectBounds, unpackAlpha, unpackBlue, unpackColor, unpackColorTo, unpackGreen, unpackRed, vividLightFast, vividLightPerfect, writeImageDataPixels, writeImageDataToClipboard, writeImgBlobToClipboard };

package/dist/index.prod.js

@@ -1495,6 +1495,31 @@ function invertImageData(imageData) {
   return imageData;
 }
 
+// src/ImageData/resampleImageData.ts
+function resampleImageData(source, factor) {
+  const srcW = source.width;
+  const srcH = source.height;
+  const dstW = Math.max(1, srcW * factor | 0);
+  const dstH = Math.max(1, srcH * factor | 0);
+  const srcData = source.data;
+  const dstData = new Uint8ClampedArray(dstW * dstH * 4);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const srcRowOffset = srcY * srcW * 4;
+    const dstRowOffset = y * dstW * 4;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      const srcIdx = srcRowOffset + srcX * 4;
+      const dstIdx = dstRowOffset + x * 4;
+      dstData[dstIdx] = srcData[srcIdx];
+      dstData[dstIdx + 1] = srcData[srcIdx + 1];
+      dstData[dstIdx + 2] = srcData[srcIdx + 2];
+      dstData[dstIdx + 3] = srcData[srcIdx + 3];
+    }
+  }
+  return new ImageData(dstData, dstW, dstH);
+}
+
 // src/ImageData/resizeImageData.ts
 function resizeImageData(current, newWidth, newHeight, offsetX = 0, offsetY = 0) {
   const result = new ImageData(newWidth, newHeight);
@@ -1589,10 +1614,12 @@ function writeImageDataPixels(imageData, data, _x, _y, _w, _h) {
 }
 
 // src/IndexedImage/IndexedImage.ts
-function makeIndexedImage(imageData) {
-  const width = imageData.width;
-  const height = imageData.height;
-  const rawData = new Uint32Array(imageData.data.buffer);
+function makeIndexedImage(imageOrData, width, height) {
+  const isImageData = "width" in imageOrData;
+  const actualWidth = isImageData ? imageOrData.width : width;
+  const actualHeight = isImageData ? imageOrData.height : height;
+  const buffer = isImageData ? imageOrData.data.buffer : imageOrData.buffer;
+  const rawData = new Uint32Array(buffer);
   const indexedData = new Int32Array(rawData.length);
   const colorMap = /* @__PURE__ */ new Map();
   const transparentColor = 0;
@@ -1602,7 +1629,7 @@ function makeIndexedImage(imageData) {
     const pixel = rawData[i];
     const alpha = pixel >>> 24 & 255;
     const isTransparent = alpha === 0;
-    const colorKey = isTransparent ? transparentColor : pixel;
+    const colorKey = isTransparent ? transparentColor : pixel >>> 0;
     let id = colorMap.get(colorKey);
     if (id === void 0) {
       id = colorMap.size;
@@ -1610,16 +1637,28 @@ function makeIndexedImage(imageData) {
     }
     indexedData[i] = id;
   }
-  const palette = new Int32Array(colorMap.keys());
+  const palette = Uint32Array.from(colorMap.keys());
   return {
-    width,
-    height,
+    width: actualWidth,
+    height: actualHeight,
     data: indexedData,
     transparentPalletIndex,
     palette
   };
 }
 
+// src/IndexedImage/getIndexedImageColorCounts.ts
+function getIndexedImageColorCounts(indexedImage) {
+  const data = indexedImage.data;
+  const palette = indexedImage.palette;
+  const frequencies = new Int32Array(palette.length);
+  for (let i = 0; i < data.length; i++) {
+    const colorIndex = data[i];
+    frequencies[colorIndex]++;
+  }
+  return frequencies;
+}
+
 // src/IndexedImage/indexedImageToAverageColor.ts
 function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   const { data, palette, transparentPalletIndex } = indexedImage;
@@ -1662,16 +1701,30 @@ function indexedImageToAverageColor(indexedImage, includeTransparent = false) {
   return packColor(r, g, b, a);
 }
 
-// src/IndexedImage/getIndexedImageColorCounts.ts
-function getIndexedImageColorCounts(indexedImage) {
-  const data = indexedImage.data;
-  const palette = indexedImage.palette;
-  const frequencies = new Int32Array(palette.length);
-  for (let i = 0; i < data.length; i++) {
-    const colorIndex = data[i];
-    frequencies[colorIndex]++;
+// src/IndexedImage/resampleIndexedImage.ts
+function resampleIndexedImage(source, factor) {
+  const srcW = source.width;
+  const srcH = source.height;
+  const dstW = srcW * factor;
+  const dstH = srcH * factor;
+  const srcData = source.data;
+  const dstData = new Int32Array(dstW * dstH);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const rowOffset = srcY * srcW;
+    const dstOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      dstData[dstOffset + x] = srcData[rowOffset + srcX];
+    }
   }
-  return frequencies;
+  return {
+    width: dstW,
+    height: dstH,
+    data: dstData,
+    palette: source.palette,
+    transparentPalletIndex: source.transparentPalletIndex
+  };
 }
 
 // src/Input/fileInputChangeToImageData.ts
@@ -2298,6 +2351,28 @@ function reflectPixelDataVertical(pixelData) {
   }
 }
 
+// src/PixelData/resamplePixelData.ts
+function resamplePixelData(pixelData, factor) {
+  const dstW = Math.max(1, pixelData.width * factor | 0);
+  const dstH = Math.max(1, pixelData.height * factor | 0);
+  const dstBuffer = new Uint8ClampedArray(dstW * dstH * 4);
+  const dstData32 = new Uint32Array(dstBuffer.buffer);
+  for (let y = 0; y < dstH; y++) {
+    const srcY = y / factor | 0;
+    const srcRowOffset = srcY * pixelData.width;
+    const dstRowOffset = y * dstW;
+    for (let x = 0; x < dstW; x++) {
+      const srcX = x / factor | 0;
+      dstData32[dstRowOffset + x] = pixelData.data32[srcRowOffset + srcX];
+    }
+  }
+  return new PixelData({
+    data: dstBuffer,
+    width: dstW,
+    height: dstH
+  });
+}
+
 // src/PixelData/rotatePixelData.ts
 function rotatePixelData(pixelData) {
   const width = pixelData.width;
@@ -2435,6 +2510,9 @@ export {
   pixelDataToAlphaMask,
   reflectPixelDataHorizontal,
   reflectPixelDataVertical,
+  resampleImageData,
+  resampleIndexedImage,
+  resamplePixelData,
   resizeImageData,
   rotatePixelData,
   screenFast,