jimp

jimp

Version 1.6.0
Published 4 months ago
4.03 MB
27 dependencies
MIT license

Install

npm i jimp

yarn add jimp

pnpm add jimp

Overview

An image processing library written entirely in JavaScript.

Index

Variables

defaultFormats
defaultPlugins
Jimp
JimpMime

Type Aliases

JimpInstance

Variables

variable defaultFormats

const defaultFormats: any[];

variable defaultPlugins

const defaultPlugins: (
    | { blit<I extends any>(image: I, options: blit.BlitOptions): I }
    | {
          blur<I extends any>(image: I, r: number): I;
          gaussian<I extends any>(image: I, r: number): I;
      }
    | { circle<I extends any>(image: I, options?: circle.CircleOptions): I }
    | {
          normalize<I extends any>(image: I): I;
          invert<I extends any>(image: I): I;
          brightness<I extends any>(image: I, val: number): I;
          contrast<I extends any>(image: I, val: number): I;
          posterize<I extends any>(image: I, n: number): I;
          greyscale<I extends any>(image: I): I;
          opacity<I extends any>(image: I, f: number): I;
          sepia<I extends any>(image: I): I;
          fade<I extends any>(image: I, f: number): I;
          convolution<I extends any>(
              image: I,
              options:
                  | {
                        kernel: number[][];
                        edgeHandling?: import('@jimp/types').Edge | undefined;
                    }
                  | number[][]
          ): I;
          opaque<I extends any>(image: I): I;
          pixelate<I extends any>(
              image: I,
              options:
                  | number
                  | {
                        size: number;
                        x?: number | undefined;
                        y?: number | undefined;
                        w?: number | undefined;
                        h?: number | undefined;
                    }
          ): I;
          convolute<I extends any>(
              image: I,
              options:
                  | number[][]
                  | {
                        kernel: number[][];
                        x?: number | undefined;
                        y?: number | undefined;
                        w?: number | undefined;
                        h?: number | undefined;
                    }
          ): I;
          color<I extends any>(image: I, actions: color.ColorAction[]): I;
      }
    | { contain<I extends any>(image: I, options: contain.ContainOptions): I }
    | { cover<I extends any>(image: I, options: cover.CoverOptions): I }
    | {
          crop<I extends any>(image: I, options: crop.CropOptions): I;
          autocrop<I extends any>(image: I, options?: crop.AutocropOptions): I;
      }
    | { displace<I extends any>(image: I, options: displace.DisplaceOptions): I }
    | { dither<I extends any>(image: I): I }
    | { fisheye<I extends any>(image: I, options?: fisheye.FisheyeOptions): I }
    | { flip<I extends any>(image: I, options: flip.FlipOptions): I }
    | {
          pHash<I extends any>(image: I): string;
          hash<I extends any>(image: I, base?: number): string;
          distanceFromHash<I extends any>(image: I, compareHash: string): number;
      }
    | { mask<I extends any>(image: I, options: mask.MaskOptions): I }
    | { print<I extends any>(image: I, { font, ...options }: any): I }
    | {
          resize<I extends any>(image: I, options: resize.ResizeOptions): I;
          scale<I extends any>(image: I, options: resize.ScaleOptions): I;
          scaleToFit<I extends any>(image: I, options: resize.ScaleToFitOptions): I;
      }
    | { rotate<I extends any>(image: I, options: rotate.RotateOptions): I }
    | { threshold<I extends any>(image: I, options: threshold.ThresholdOptions): I }
    | { quantize<I extends any>(image: I, options: quantize.QuantizeOptions): I }
)[];

variable Jimp

const Jimp: {
    new (options?: any): {
        bitmap: any;
        background: number;
        formats: import('@jimp/types').Format<any>[];
        mime?: string;
        inspect(): string;
        toString(): string;
        readonly width: number;
        readonly height: number;
        getBuffer<
            ProvidedMimeType extends
                | 'image/bmp'
                | 'image/gif'
                | 'image/jpeg'
                | 'image/png'
                | 'image/tiff'
                | 'image/x-ms-bmp',
            Options extends
                | (Record<
                      'image/bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
                | (Record<'image/tiff', Record<string, any>> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<
                      'image/x-ms-bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
                | (Record<'image/gif', Record<string, any>> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<'image/jpeg', any> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<
                      'image/png',
                      Omit<any, 'filterType' | 'colorType' | 'inputColorType'> & {
                          filterType?: any;
                          colorType?: any;
                          inputColorType?: any;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
        >(
            mime: ProvidedMimeType,
            options?: Options
        ): Promise<Buffer>;
        getBase64<
            ProvidedMimeType extends
                | 'image/bmp'
                | 'image/gif'
                | 'image/jpeg'
                | 'image/png'
                | 'image/tiff'
                | 'image/x-ms-bmp',
            Options extends
                | (Record<
                      'image/bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
                | (Record<'image/tiff', Record<string, any>> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<
                      'image/x-ms-bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
                | (Record<'image/gif', Record<string, any>> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<'image/jpeg', any> extends Record<
                      ProvidedMimeType,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<
                      'image/png',
                      Omit<any, 'filterType' | 'colorType' | 'inputColorType'> & {
                          filterType?: any;
                          colorType?: any;
                          inputColorType?: any;
                      }
                  > extends Record<ProvidedMimeType, infer O>
                      ? O
                      : never)
        >(
            mime: ProvidedMimeType,
            options?: Options
        ): Promise<string>;
        write<
            Extension extends string,
            Mime extends
                | (Record<'bmp', 'image/bmp'> extends Record<Extension, infer M>
                      ? M
                      : never)
                | (Record<'tiff', 'image/tiff'> extends Record<Extension, infer M>
                      ? M
                      : never)
                | (Record<'x-ms-bmp', 'image/x-ms-bmp'> extends Record<
                      Extension,
                      infer M
                  >
                      ? M
                      : never)
                | (Record<'gif', 'image/gif'> extends Record<Extension, infer M>
                      ? M
                      : never)
                | (Record<'jpeg', 'image/jpeg'> extends Record<Extension, infer M>
                      ? M
                      : never)
                | (Record<'png', 'image/png'> extends Record<Extension, infer M>
                      ? M
                      : never),
            Options extends
                | (Record<
                      'image/bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<Mime, infer O>
                      ? O
                      : never)
                | (Record<'image/tiff', Record<string, any>> extends Record<
                      Mime,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<
                      'image/x-ms-bmp',
                      {
                          palette?: import('@jimp/js-bmp').BmpColor[] | undefined;
                          colors?: number | undefined;
                          importantColors?: number | undefined;
                          hr?: number | undefined;
                          vr?: number | undefined;
                          reserved1?: number | undefined;
                          reserved2?: number | undefined;
                      }
                  > extends Record<Mime, infer O>
                      ? O
                      : never)
                | (Record<'image/gif', Record<string, any>> extends Record<
                      Mime,
                      infer O
                  >
                      ? O
                      : never)
                | (Record<'image/jpeg', any> extends Record<Mime, infer O>
                      ? O
                      : never)
                | (Record<
                      'image/png',
                      Omit<any, 'filterType' | 'colorType' | 'inputColorType'> & {
                          filterType?: any;
                          colorType?: any;
                          inputColorType?: any;
                      }
                  > extends Record<Mime, infer O>
                      ? O
                      : never)
        >(
            path: `${string}.${Extension}`,
            options?: Options
        ): Promise<void>;
        clone<S extends unknown>(this: S): S;
        getPixelIndex(x: number, y: number, edgeHandling?: any): number;
        getPixelColor(x: number, y: number): number;
        setPixelColor(hex: number, x: number, y: number): any;
        hasAlpha(): boolean;
        composite<I extends unknown>(
            src: I,
            x?: number,
            y?: number,
            options?: {
                mode?: import('@jimp/core').BlendMode;
                opacitySource?: number;
                opacityDest?: number;
            }
        ): any;
        scan(f: (x: number, y: number, idx: number) => any): any;
        scan(
            x: number,
            y: number,
            w: number,
            h: number,
            cb: (x: number, y: number, idx: number) => any
        ): any;
        scanIterator(
            x?: number,
            y?: number,
            w?: number,
            h?: number
        ): Generator<
            { x: number; y: number; idx: number; image: any },
            void,
            unknown
        >;
    };
    read(
        url: string | Buffer | ArrayBuffer,
        options?:
            | Record<'image/tiff', Record<string, any> | undefined>
            | Record<'image/gif', Record<string, any> | undefined>
            | Record<'image/bmp', import('@jimp/js-bmp').DecodeBmpOptions>
            | Record<'image/x-ms-bmp', import('@jimp/js-bmp').DecodeBmpOptions>
            | Record<'image/jpeg', import('@jimp/js-jpeg').DecodeJpegOptions>
            | Record<'image/png', import('@jimp/js-png').DecodePngOptions>
            | undefined
    ): Promise<any>;
    fromBitmap(bitmap: any): any;
    fromBuffer(
        buffer: Buffer | ArrayBuffer,
        options?:
            | Record<'image/tiff', Record<string, any> | undefined>
            | Record<'image/gif', Record<string, any> | undefined>
            | Record<'image/bmp', import('@jimp/js-bmp').DecodeBmpOptions>
            | Record<'image/x-ms-bmp', import('@jimp/js-bmp').DecodeBmpOptions>
            | Record<'image/jpeg', import('@jimp/js-jpeg').DecodeJpegOptions>
            | Record<'image/png', import('@jimp/js-png').DecodePngOptions>
            | undefined
    ): Promise<any>;
} & (new (...args: any[]) => any);

A Jimp class enables you to:class

- Read an image into a "bit map" (a collection of pixels) - Modify the bit map through methods that change the pixels - Write the bit map back to an image buffer

Example 1

#### Basic

You can use the Jimp class to make empty images. This is useful for when you want to create an image that composed of other images on top of a background.

import { Jimp } from "jimp";

const image = new Jimp({ width: 256, height: 256, color: 0xffffffff });
const image2 = new Jimp({ width: 100, height: 100, color: 0xff0000ff });

image.composite(image2, 50, 50);

#### Node

You can use jimp in Node.js. For example you can read an image from a file and resize it and then write it back to a file.

import { Jimp } from "jimp";
import { promises as fs } from "fs";

const image = await Jimp.read("test/image.png");

image.resize(256, 100);
image.greyscale();

await image.write('test/output.png');

#### Browser

You can use jimp in the browser by reading files from URLs

import { Jimp } from "jimp";

const image = await Jimp.read("https://upload.wikimedia.org/wikipedia/commons/0/01/Bot-Test.jpg");

image.resize(256, 100);
image.greyscale();

const output = await image.getBuffer("test/image.png");

const canvas = document.createElement("canvas");

canvas.width = image.bitmap.width;
canvas.height = image.bitmap.height;

const ctx = canvas.getContext("2d");
ctx.putImageData(image.bitmap, 0, 0);

document.body.appendChild(canvas);

variable JimpMime

const JimpMime: {
    bmp: 'image/bmp';
    gif: 'image/gif';
    jpeg: 'image/jpeg';
    png: 'image/png';
    tiff: 'image/tiff';
};

Convenience object for getting the MIME types of the default formats

Type Aliases

type JimpInstance

type JimpInstance = InstanceType<typeof Jimp>;

Package Files (1)

dist/commonjs/index.d.ts

Peer Dependencies (0)

No peer dependencies.

Badge

To add a badge like this oneto your package's README, use the codes available below.

You may also use Shields.io to create a custom badge linking to https://www.jsdocs.io/package/jimp.

Markdown

[![jsDocs.io](https://img.shields.io/badge/jsDocs.io-reference-blue)](https://www.jsdocs.io/package/jimp)

HTML

<a href="https://www.jsdocs.io/package/jimp"><img src="https://img.shields.io/badge/jsDocs.io-reference-blue" alt="jsDocs.io"></a>

Updated 4 months ago.
Package analyzed in 7875 ms.
Missing or incorrect documentation? Open an issue for this package.

jimp

Install

Overview

Index

Variables

Type Aliases

Variables

variable defaultFormats

variable defaultPlugins

variable Jimp

Example 1

variable JimpMime

Type Aliases

type JimpInstance

Package Files (1)

Dependencies (27)

Dev Dependencies (21)

Peer Dependencies (0)

Badge