Jimp

https://jimp-dev.github.io/jimp/
Admin
Jimp is a JavaScript image manipulation library that supports multiple formats (PNG, JPEG, BMP, GIF,...
Tokens:15,762
Snippets:109
Trust Score:8.3
Update:1 year ago
Show doc for...
Tokens:
Raw
### Exporting Images Asynchronously in Jimp v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

In Jimp v1, all export methods are now asynchronous and have been renamed for clarity. For example, `getBufferAsync` is now `getBuffer`, and `writeAsync` is now `write`. These methods return Promises, allowing for cleaner async/await syntax.

```javascript
import Jimp from 'jimp';

async function processImage(imagePath) {
  const image = await Jimp.read(imagePath);
  const buffer = await image.getBuffer(Jimp.MIME_PNG);
  await image.write('output.png');
}
```

--------------------------------

### Reading Images Using Jimp.read in v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

The asynchronous constructor from Jimp v0 has been replaced by the static `Jimp.read` method in v1. This method handles reading images from various sources, including file paths in Node.js, URLs in the browser, and Buffers or ArrayBuffers.

```javascript
import Jimp from 'jimp';

// Reading from a file path (Node.js)
async function readFromFile(filePath) {
  const image = await Jimp.read(filePath);
  return image;
}

// Reading from a URL (Browser)
async function readFromUrl(url) {
  const image = await Jimp.read(url);
  return image;
}

// Reading from a Buffer
async function readFromBuffer(buffer) {
  const image = await Jimp.read(buffer);
  return image;
}
```

--------------------------------

### Loading Images from Buffers with Jimp.fromBuffer in v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

Jimp v1 introduces the `Jimp.fromBuffer` static method for loading images directly from a Buffer or ArrayBuffer. This replaces the previous method of passing a buffer to the Jimp constructor in v0, providing a clearer and more explicit API for buffer-based image loading.

```javascript
import Jimp from 'jimp';

async function loadImageFromBuffer(buffer) {
  const image = await Jimp.fromBuffer(buffer);
  return image;
}
```

--------------------------------

### Creating and Modifying Images with Options Objects in Jimp v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

Jimp v1 replaces positional arguments with options objects for methods like `resize`. This makes the API more readable and extensible. The `Jimp` constructor also now accepts an options object for creating new images, including specifying dimensions and background color.

```javascript
import Jimp from 'jimp';

// Creating a new image with options
const image = new Jimp(300, 200, '#FF0000'); // 300 width, 200 height, red background

// Resizing using options object
image.resize({
  width: 150,
  height: 100,
  mode: Jimp.RESIZE_BILINEAR // Example of specifying resize mode
});
```

--------------------------------

### Loading Images from Bitmaps with Jimp.fromBitmap in v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

Similar to loading from buffers, Jimp v1 provides `Jimp.fromBitmap` to load images from bitmap data. This method is used for loading image data or canvas data represented as a bitmap object, replacing the older constructor-based approach from v0.

```javascript
import Jimp from 'jimp';

async function loadImageFromBitmap(bitmapData) {
  const image = await Jimp.fromBitmap(bitmapData);
  return image;
}
```

--------------------------------

### Named Exports for Jimp Constructor and Utilities

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

Jimp v1 no longer uses a default export for the main `Jimp` class. Instead, it utilizes named exports. This change improves code organization and makes it explicit which components are being imported. Utility functions like `intToRGBA` are also available as named imports.

```javascript
import Jimp, { JimpMime, intToRGBA } from 'jimp';

// Example using named export for JimpMime
console.log(JimpMime.PNG);

// Example using named export for intToRGBA
const rgba = intToRGBA(0xFF0000FF);
console.log(rgba);
```

--------------------------------

### Specifying Encoding Options During Export in Jimp v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

Jimp v1 handles encoding and decoding options by passing them directly to the export methods (e.g., `getBuffer`, `write`). This is a change from v0, where options were global. This approach makes it clear which options apply to a specific export operation.

```javascript
import Jimp from 'jimp';

async function exportWithQuality(image, quality) {
  // Exporting as JPEG with specific quality
  const jpegBuffer = await image.getBuffer(Jimp.MIME_JPEG, {
    quality: quality
  });

  // Writing as PNG with compression level
  await image.write('output.png', {
    compressionLevel: 9
  });
}
```

--------------------------------

### Accessing Image Dimensions and MIME Type in Jimp v1

Source: https://jimp-dev.github.io/jimp/guides/migrate-to-v1

In Jimp v1, properties like `width`, `height`, and `mime` are directly accessible on the image object, replacing the getter methods like `getWidth()`, `getHeight()`, and `getMIME()` from v0. This provides a more straightforward way to retrieve these image properties.

```javascript
import Jimp from 'jimp';

async function getImageInfo(imagePath) {
  const image = await Jimp.read(imagePath);
  const width = image.width;
  const height = image.height;
  const mimeType = image.mime;

  console.log(`Image dimensions: ${width}x${height}`);
  console.log(`MIME type: ${mimeType}`);
}
```

--------------------------------

### Jimp: Scan Iterator

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Provides an iterator to scan through a region of the image's bitmap. Optional parameters define the starting x, y coordinates and the width/height of the scan region. It yields objects containing index, image, x, and y.

```typescript
scanIterator(x?: number, y?: number, w?: number, h?: number): Generator<{ idx: number; image: any; x: number; y: number }, void, unknown>
```

--------------------------------

### Get Pixel Index in Bitmap with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `getPixelIndex()` function returns the offset of a pixel within the bitmap buffer. It takes x and y coordinates and an optional edge handling parameter. It returns the index as a number or -1 if not found.

```typescript
getPixelIndex(x: number, y: number, edgeHandling?: Edge): number
```

--------------------------------

### Crop Image to Specific Dimensions - Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Crops the image to a specified width and height starting from a given x and y coordinate. This function modifies the image dimensions to the new crop area.

```typescript
crop(options: { h: number; w: number; x: number; y: number; }): Jimp
```

--------------------------------

### Jimp Constructors

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Information about how to instantiate the Jimp class, including creating empty images and loading images from various sources.

```APIDOC
## new Jimp()

### Description
Creates a new Jimp instance. Can be used to make empty images or initialize with existing bitmap data.

### Method
`new Jimp(JimpConstructorOptions)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **JimpConstructorOptions** (Bitmap | JimpSimpleConstructorOptions) - Options for constructing the Jimp instance.

### Request Example
```json
{
  "example": "new Jimp({ width: 100, height: 100, color: \'#FF0000\' })"
}
```

### Response
#### Success Response (200)
* **Jimp** - An instance of the Jimp class representing the image.

#### Response Example
```json
{
  "example": "[Jimp instance]"
}
```

## static fromBitmap()

### Description
Creates a Jimp instance from raw image data in bitmap format.

### Method
`static fromBitmap(bitmap)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **bitmap** (RawImageData) - The raw image data in bitmap format.

### Request Example
```json
{
  "example": "Jimp.fromBitmap(bitmapData)"
}
```

### Response
#### Success Response (200)
* **any** - A Jimp instance created from the provided bitmap.

#### Response Example
```json
{
  "example": "[Jimp instance]"
}
```

## static fromBuffer()

### Description
Parses raw image data from a Buffer or ArrayBuffer to create a Jimp instance.

### Method
`static fromBuffer(buffer, options?)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **buffer** (Buffer | ArrayBuffer) - Raw image data.
* **options?** (Record<string, any>) - Optional decoding options specific to image formats.

### Request Example
```json
{
  "example": "Jimp.fromBuffer(bufferData, { 'image/jpeg': { quality: 0.8 } })"
}
```

### Response
#### Success Response (200)
* **Promise<Jimp>** - A Promise that resolves with a Jimp instance.

#### Response Example
```json
{
  "example": "[Promise resolving to Jimp instance]"
}
```

## static read()

### Description
Creates a Jimp instance by reading an image from a URL, file path, or Buffer.

### Method
`static read(url, options?)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **url** (string | Buffer | ArrayBuffer) - The source of the image.
* **options?** (Record<string, any>) - Optional decoding options specific to image formats.

### Request Example
```json
{
  "example": "Jimp.read('https://example.com/image.jpg')"
}
```

### Response
#### Success Response (200)
* **Promise<Jimp>** - A Promise that resolves with a Jimp instance.

#### Response Example
```json
{
  "example": "[Promise resolving to Jimp instance]"
}
```
```

--------------------------------

### Get Pixel Color Value with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `getPixelColor()` function retrieves the hex color value of a specific pixel at given x and y coordinates. It returns a number representing the color.

```typescript
getPixelColor(x: number, y: number): number
```

--------------------------------

### Create Jimp Instance from Bitmap with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Demonstrates creating a Jimp instance from raw image data in bitmap format using the static `fromBitmap` method. This is useful when you have image data already in Jimp's internal format.

```javascript
import Jimp from 'jimp';

const bitmapData = {
  data: new Uint8Array([255, 0, 0, 255]), // RGBA for a red pixel
  width: 1,
  height: 1
};

const image = Jimp.fromBitmap(bitmapData);
// Now 'image' is a Jimp instance that can be manipulated.

```

--------------------------------

### Create New Image with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Demonstrates how to create a new, empty image using the Jimp class, useful for composing images or creating backgrounds.

```javascript
import Jimp from 'jimp';

// Create a new 100x100 image with a white background
new Jimp(100, 100, 0xFFFFFFFF, (err, image) => {
  if (err) throw err;
  // Do something with the image
});

```

--------------------------------

### Clone Jimp Image Instance

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Explains and demonstrates the `clone` method, which creates an exact copy of a Jimp image instance. This is essential when you need to perform multiple modifications on an image without affecting the original.

```javascript
import Jimp from 'jimp';

Jimp.read('original.jpg').then(originalImage => {
  const clonedImage = originalImage.clone();
  
  // Modify clonedImage without affecting originalImage
  clonedImage.brightness(0.5).write('modified-clone.jpg');
  
  // originalImage remains unchanged
  originalImage.write('original-untouched.jpg'); 
}).catch(err => {
  console.error(err);
});

```

--------------------------------

### Read and Resize Image in Node.js with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Shows how to read an image from a file path in a Node.js environment, resize it, and write it back to a new file using Jimp.

```javascript
import Jimp from 'jimp';

Jimp.read('image.jpg')
  .then(image => {
    return image
      .resize(256, 256) // resize
      .quality(60) // set quality
      .write('image-resized.jpg'); // save
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### scan()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Scans through the image and calls a callback for each pixel.

```APIDOC
## scan(f) / scan(x, y, w, h, cb)

### Description
Scans through the image and calls the callback for each pixel.

### Method
GET

### Endpoint
/scan

### Parameters
#### Query Parameters
- **f** (function) - The callback function to execute for each pixel (for the `scan(f)` overload).
- **x** (number) - The x coordinate to begin the scan at (for the `scan(x, y, w, h, cb)` overload).
- **y** (number) - The y coordinate to begin the scan at (for the `scan(x, y, w, h, cb)` overload).
- **w** (number) - The width of the scan region (for the `scan(x, y, w, h, cb)` overload).
- **h** (number) - The height of the scan region (for the `scan(x, y, w, h, cb)` overload).
- **cb** (function) - The callback function to execute for each pixel (for the `scan(x, y, w, h, cb)` overload).

### Request Example
```json
// Example for scan(f)
{
  "f": "function(x, y, idx) { /* pixel processing */ }"
}

// Example for scan(x, y, w, h, cb)
{
  "x": 0,
  "y": 0,
  "w": 100,
  "h": 100,
  "cb": "function(pixel) { /* pixel processing */ }"
}
```

### Response
#### Success Response (200)
- **any** - The return value of the callback function or an indicator of completion.

#### Response Example
```json
{
  "message": "Scan complete."
}
```
```

--------------------------------

### resize()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Resizes the image to a specified width and height using a 2-pass bilinear algorithm.

```APIDOC
## resize(options)

### Description
Resizes the image to a set width and height using a 2-pass bilinear algorithm.

### Method
POST

### Endpoint
/resize

### Parameters
#### Request Body
- **options** (object) - The resizing options.
  - **width** (number) - The target width.
  - **height** (number) - The target height.

### Request Example
```json
{
  "options": {
    "width": 200,
    "height": 150
  }
}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Image resized successfully."
}
```
```

--------------------------------

### sepia()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies a sepia tone to the image.

```APIDOC
## sepia()

### Description
Applies a sepia tone to the image.

### Method
GET

### Endpoint
/sepia

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Sepia tone applied."
}
```
```

--------------------------------

### quantize()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Reduces the number of colors in an image.

```APIDOC
## quantize(options)

### Description
Reduces the number of colors in an image.

### Method
POST

### Endpoint
/quantize

### Parameters
#### Request Body
- **options** (object) - Options for color quantization.
  - **colors** (number) - The target number of colors.
  - **imageQuantization** (string, optional) - The image quantization algorithm to use (e.g., "floyd-steinberg").
  - **paletteQuantization** (string, optional) - The palette quantization algorithm to use (e.g., "wuquant").
  - **colorDistanceFormula** (string, optional) - The color distance formula to use (e.g., "euclidean-bt709").

### Request Example
```json
{
  "options": {
    "colors": 16,
    "imageQuantization": "floyd-steinberg"
  }
}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Image colors quantized."
}
```
```

--------------------------------

### Apply Color Modifications with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Illustrates the `color` method for applying a series of color manipulation rules to an image. The `actions` parameter accepts an array of objects, each defining an operation and its parameters.

```javascript
import Jimp from 'jimp';

Jimp.read('image.jpg')
  .then(image => {
    return image.color([
      { apply: 'saturate', params: [50] },
      { apply: 'hue', params: [30] }
    ]);
  })
  .then(image => {
    image.write('image-colored.jpg');
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### posterize()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies a posterize effect to the image.

```APIDOC
## posterize(n)

### Description
Apply a posterize effect to the image.

### Method
POST

### Endpoint
/posterize

### Parameters
#### Request Body
- **n** (number) - The amount to adjust the contrast. Minimum threshold is two.

### Request Example
```json
{
  "n": 4
}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Posterize effect applied."
}
```
```

--------------------------------

### Jimp Core API - Properties

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Provides access to various properties of the Jimp image object, including dimensions, background color, and supported formats.

```APIDOC
## GET /properties

### Description
Access various properties of the Jimp image object.

### Method
GET

### Endpoint
/properties

### Parameters
None

### Response
#### Success Response (200)
- **background** (number) - Default color to use for new pixels.
- **bitmap** (Bitmap) - The bitmap data of the image.
- **formats** (Format[]) - Formats that can be used with Jimp.
- **height** (number) - The height of the image.
- **mime?** (string) - The original MIME type of the image.
- **width** (number) - The width of the image.

#### Response Example
```json
{
  "background": 0,
  "bitmap": { ... },
  "formats": ["image/png", "image/jpeg"],
  "height": 500,
  "mime": "image/png",
  "width": 1000
}
```
```

--------------------------------

### Jimp Core API - threshold()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies a minimum color threshold to a grayscale image. It converts the image to grayscale by default unless specified otherwise.

```APIDOC
## POST /threshold

### Description
Applies a minimum color threshold to a grayscale image. Converts image to grayscale by default.

### Method
POST

### Endpoint
/threshold

### Parameters
#### Request Body
- **options** (object) - Required - Options for the threshold operation.
  - **autoGreyscale?** (boolean) - Optional - Whether to apply greyscale beforehand (default true).
  - **max** (number) - Required - A number auto limited between 0 - 255.
  - **replace?** (number) - Optional - A number auto limited between 0 - 255 (default 255).

### Response
#### Success Response (200)
- **Jimp** - Returns the Jimp object after applying the threshold.

#### Response Example
```json
{
  "message": "Threshold applied successfully"
}
```
```

--------------------------------

### Jimp: Quantize Image Colors

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Reduces the number of colors in the image. The 'options' parameter allows customization of color distance formulas, the number of colors, and the image quantization algorithm. Returns a Jimp object.

```typescript
quantize(options: object): Jimp
```

--------------------------------

### Jimp Core API - toString()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Converts the Jimp object into a nicely formatted string representation.

```APIDOC
## GET /toString

### Description
Nicely format Jimp object when converted to a string.

### Method
GET

### Endpoint
/toString

### Parameters
None

### Response
#### Success Response (200)
- **string** - A pretty-printed string representation of the Jimp object.

#### Response Example
```json
{
  "representation": "<Jimp width=100 height=50>"
}
```
```

--------------------------------

### Create Circle Image with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Demonstrates the `circle` method for creating a circular image mask or shape. Options can specify the radius and position of the circle.

```javascript
import Jimp from 'jimp';

Jimp.read('image.jpg')
  .then(image => {
    return image.circle({ // Create a circle with radius 50 at center
      radius: 50,
      x: image.bitmap.width / 2,
      y: image.bitmap.height / 2
    });
  })
  .then(image => {
    image.write('image-circle.png');
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### opaque()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Sets the alpha channel on every pixel to fully opaque.

```APIDOC
## opaque()

### Description
Sets the alpha channel on every pixel to fully opaque.

### Method
GET

### Endpoint
/opaque

### Parameters
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Image pixels set to opaque."
}
```
```

--------------------------------

### Image Manipulation Methods

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Methods for modifying Jimp image instances, including cropping, blurring, adjusting brightness, and more.

```APIDOC
## autocrop()

### Description
Autocrops an image by removing uniform color borders, typically transparent pixels.

### Method
`autocrop(options?)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **options?** (AutocropOptions) - Optional configuration for the autocrop operation.

### Request Example
```json
{
  "example": "image.autocrop({ leaveBorder: 10 })"
}
```

### Response
#### Success Response (200)
* **Jimp** - The modified Jimp instance.

#### Response Example
```json
{
  "example": "[Modified Jimp instance]"
}
```

## blit()

### Description
Performs a blit operation, transferring pixel data from one area to another. Useful for compositing images.

### Method
`blit(options)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **options** (object) - An object specifying the source and destination areas for the blit operation.

### Request Example
```json
{
  "example": "image.blit({ src: { x: 0, y: 0, width: 50, height: 50 }, dst: { x: 10, y: 10 } })"
}
```

### Response
#### Success Response (200)
* **Jimp** - The modified Jimp instance.

#### Response Example
```json
{
  "example": "[Modified Jimp instance]"
}
```

## blur()

### Description
Applies a fast blur effect to the image, similar to Gaussian blur but more performant.

### Method
`blur(r)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **r** (number) - The pixel radius of the blur effect.

### Request Example
```json
{
  "example": "image.blur(5)"
}
```

### Response
#### Success Response (200)
* **Jimp** - The blurred Jimp instance.

#### Response Example
```json
{
  "example": "[Blurred Jimp instance]"
}
```

## brightness()

### Description
Adjusts the overall brightness of the image.

### Method
`brightness(val)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **val** (number) - The amount to adjust the brightness. Positive values increase brightness, negative values decrease it.

### Request Example
```json
{
  "example": "image.brightness(0.2)"
}
```

### Response
#### Success Response (200)
* **Jimp** - The brightness-adjusted Jimp instance.

#### Response Example
```json
{
  "example": "[Brightness-adjusted Jimp instance]"
}
```

## circle()

### Description
Converts the image into a circular shape.

### Method
`circle(options?)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **options?** (object)
    * **radius?** (number) - The radius of the circle.
    * **x?** (number) - The x-coordinate for the circle's center.
    * **y?** (number) - The y-coordinate for the circle's center.

### Request Example
```json
{
  "example": "image.circle({ radius: 50, x: 100, y: 100 })"
}
```

### Response
#### Success Response (200)
* **Jimp** - The circular Jimp instance.

#### Response Example
```json
{
  "example": "[Circular Jimp instance]"
}
```

## clone()

### Description
Creates a deep copy of the current Jimp image instance.

### Method
`clone<S>(this)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **this** (S) - The Jimp instance to clone.

### Request Example
```json
{
  "example": "const clonedImage = image.clone();"
}
```

### Response
#### Success Response (200)
* **S** - A new Jimp instance that is a copy of the original.

#### Response Example
```json
{
  "example": "[New Jimp instance]"
}
```

## color()

### Description
Applies a list of color modification rules to the image.

### Method
`color(actions)`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
* **actions** (Array<object>) - An array of color modification rules, each with an `apply` property and `params` array.

### Request Example
```json
{
  "example": "image.color([ { apply: 'saturate', params: [ 30 ] }, { apply: 'hue', params: [ 20 ] } ])"
}
```

### Response
#### Success Response (200)
* **Jimp** - The color-modified Jimp instance.

#### Response Example
```json
{
  "example": "[Modified Jimp instance]"
}
```
```

--------------------------------

### Jimp: Resize Image

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Resizes the image to a specified width and height using a 2-pass bilinear algorithm. The 'options' parameter is an object that defines the new dimensions. Returns a Jimp object.

```typescript
resize(options: object): Jimp
```

--------------------------------

### Generate Perceptual Hash with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `hash()` function generates a perceptual hash of the image. It can pad the string and allows configuration of the base for the hash (e.g., binary, decimal, hex, base64). It returns a string.

```typescript
hash(base?: number): string
```

--------------------------------

### Apply Grayscale Threshold to Image (Jimp)

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `threshold` function applies a minimum color threshold to an image, optionally converting it to grayscale first. It takes an options object with parameters for greyscale conversion, maximum threshold, and replacement color. The function returns a Jimp object.

```typescript
threshold(options: {
    autoGreyscale?: boolean;
    max: number;
    replace?: number;
}): Jimp;
```

--------------------------------

### Jimp Contrast API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Adjusts the contrast of the image.

```APIDOC
## POST /contrast

### Description
Adjusts the contrast of the image.

### Method
POST

### Endpoint
/contrast

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **val** (number) - Required - the amount to adjust the contrast, a number between -1 and +1

### Request Example
```json
{
  "val": 0.5
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The Jimp instance with adjusted contrast.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Jimp: Apply Sepia Tone

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies a sepia tone effect to the image, giving it a vintage look. This function does not require any parameters and returns a Jimp object for method chaining.

```typescript
sepia(): Jimp
```

--------------------------------

### Parse Image Buffer with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Shows how to parse raw image data from a Buffer or ArrayBuffer into a Jimp instance. This is useful for handling image data received from various sources.

```javascript
import Jimp from 'jimp';

// Assuming 'buffer' is a Buffer or ArrayBuffer containing image data
Jimp.fromBuffer(buffer)
  .then(image => {
    // Process the image
    console.log('Image parsed from buffer');
  })
  .catch(err => {
    console.error('Error parsing buffer:', err);
  });

```

--------------------------------

### Apply Blur Effect with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Demonstrates the `blur` method for applying a fast blur effect to an image, similar to Gaussian blur but with higher performance. The `r` parameter controls the pixel radius of the blur.

```javascript
import Jimp from 'jimp';

Jimp.read('image.jpg')
  .then(image => {
    return image.blur(5); // Apply a blur with a radius of 5 pixels
  })
  .then(image => {
    image.write('image-blurred.jpg');
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### Jimp Contain API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Resizes the image to the given width and height while maintaining the aspect ratio. Letterboxing may occur.

```APIDOC
## POST /contain

### Description
Scale the image to the given width and height keeping the aspect ratio. Some parts of the image may be letter boxed.

### Method
POST

### Endpoint
/contain

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (object) - Required
  - **w** (number) - Required - the width to resize the image to
  - **h** (number) - Required - the height to resize the image to
  - **align** (number) - Optional - A bitmask for horizontal and vertical alignment
  - **mode** (ResizeStrategy) - Optional - a scaling method (e.g. Jimp.RESIZE_BEZIER)

### Request Example
```json
{
  "options": {
    "w": 800,
    "h": 600,
    "align": 9,
    "mode": "RESIZE_BILINEAR"
  }
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The resized Jimp instance.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Jimp Core API - write()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Writes the current image data to a specified file path, supporting various image formats and options.

```APIDOC
## POST /write

### Description
Write the image to a file.

### Method
POST

### Endpoint
/write

### Parameters
#### Request Body
- **path** (string) - Required - The path to write the image to (e.g., "output.png").
- **options?** (object) - Optional - The options to use when writing the image. Specific options depend on the image format.

### Response
#### Success Response (200)
- **void** - Indicates the image was written successfully.

#### Response Example
```json
{
  "message": "Image written successfully to path: output.png"
}
```
```

--------------------------------

### Blit (Bit-Block Transfer) with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Explains and demonstrates the `blit` method, which is used for transferring pixel data between areas of an image. It's a fundamental operation for image composition and manipulation.

```javascript
import Jimp from 'jimp';

Promise.all([
  Jimp.read('foreground.png'),
  Jimp.read('background.jpg')
]).then(function ([fg, bg]) {
  bg.blit(fg, 10, 10).write('output.jpg'); // Blit fg onto bg at position (10, 10)
});

```

--------------------------------

### print()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Draws text on an image within a given boundary.

```APIDOC
## print(__namedParameters)

### Description
Draws text on an image on a given boundary.

### Method
POST

### Endpoint
/print

### Parameters
#### Request Body
- **__namedParameters** (object) - An object containing parameters for printing text.
  - **text** (string) - The text to draw.
  - **x** (number) - The x-coordinate for the text.
  - **y** (number) - The y-coordinate for the text.
  - **font** (object) - The font to use (e.g., Jimp.FONT_SANS_8_BLACK).

### Request Example
```json
{
  "__namedParameters": {
    "text": "Hello, Jimp!",
    "x": 10,
    "y": 10,
    "font": "Jimp.FONT_SANS_8_BLACK"
  }
}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Text printed on image."
}
```
```

--------------------------------

### scale()

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Uniformly scales the image by a given factor.

```APIDOC
## scale(options)

### Description
Uniformly scales the image by a factor.

### Method
POST

### Endpoint
/scale

### Parameters
#### Request Body
- **options** (object) - The scaling options.
  - **factor** (number) - The scaling factor.

### Request Example
```json
{
  "options": {
    "factor": 1.5
  }
}
```

### Response
#### Success Response (200)
- **Jimp** (object) - The Jimp object instance.

#### Response Example
```json
{
  "message": "Image scaled successfully."
}
```
```

--------------------------------

### Jimp Dither API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies an ordered dithering effect to the image.

```APIDOC
## POST /dither

### Description
Apply a ordered dithering effect.

### Method
POST

### Endpoint
/dither

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```json
{}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The Jimp instance with dithering applied.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Convert Jimp Image to Buffer

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `getBuffer()` function converts a Jimp image instance to an image buffer. It supports various MIME types and optional export options. This function returns a Promise that resolves to a Buffer.

```typescript
getBuffer<ProvidedMimeType, Options>(mime: ProvidedMimeType, options?: Options): Promise<Buffer>
```

--------------------------------

### Jimp Convolute API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies a convolution kernel to the image.

```APIDOC
## POST /convolute

### Description
Applies a convolution kernel to the image or a region.

### Method
POST

### Endpoint
/convolute

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (number[][] | object) - Required - The convolution kernel or options.

### Request Example
```json
{
  "options": [
    [0, -1, 0],
    [-1, 5, -1],
    [0, -1, 0]
  ]
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The Jimp instance after applying the convolution.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Jimp Cover API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Resizes the image to cover the given width and height while maintaining the aspect ratio. Parts of the image may be clipped.

```APIDOC
## POST /cover

### Description
Scale the image so the given width and height keeping the aspect ratio. Some parts of the image may be clipped.

### Method
POST

### Endpoint
/cover

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (object) - Required
  - **w** (number) - Required - the width to resize the image to
  - **h** (number) - Required - the height to resize the image to
  - **align** (number) - Optional - A bitmask for horizontal and vertical alignment
  - **mode** (ResizeStrategy) - Optional - a scaling method (e.g. ResizeStrategy.BEZIER)

### Request Example
```json
{
  "options": {
    "w": 800,
    "h": 600,
    "align": 13
  }
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The Jimp instance after covering.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Jimp: Scale Image Uniformly

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Uniformly scales the image by a given factor. The 'options' parameter should be of type ScaleOptions, specifying the scaling factor. Returns a Jimp object.

```typescript
scale(options: ScaleOptions): Jimp
```

--------------------------------

### Write Image to File (Jimp)

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

The `write` method saves the current Jimp image to a specified file path. It supports various image formats and allows for format-specific options. This is an asynchronous operation returning a Promise that resolves when the write operation is complete.

```typescript
write<Extension, Mime, Options>(path: `${string}.${Extension}`, options?: Options): Promise<void>;
```

--------------------------------

### Read Image from URL in Browser with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Illustrates how to read an image from a URL in a browser environment using Jimp. This allows for client-side image manipulation.

```javascript
import Jimp from 'jimp';

Jimp.read('http://example.com/image.png')
  .then(image => {
    // Do something with the image
    console.log('Image loaded successfully');
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### Jimp Crop API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Crops the image to a specified size at a given point.

```APIDOC
## POST /crop

### Description
Crops the image at a given point to a give size.

### Method
POST

### Endpoint
/crop

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (object) - Required
  - **x** (number) - Required - the x position to crop form
  - **y** (number) - Required - the y position to crop form
  - **w** (number) - Required - the width to crop form
  - **h** (number) - Required - the height to crop form

### Request Example
```json
{
  "options": {
    "x": 50,
    "y": 50,
    "w": 100,
    "h": 100
  }
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The cropped Jimp instance.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Jimp: Scan Pixels (Callback)

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Scans through the image, calling a provided callback function 'f' for each pixel. This is a general-purpose scanning function. It returns any.

```typescript
scan(f: (x: number, y: number, idx: number) => void): any
```

--------------------------------

### Resize Image to Cover Dimensions - Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Scales the image so that it covers the specified width and height while maintaining the aspect ratio. Portions of the image may be clipped if the aspect ratios do not match. Supports alignment and different resizing strategies.

```typescript
cover(options: { align?: number; h: number; mode?: ResizeStrategy; w: number; }): Jimp
```

--------------------------------

### Adjust Brightness with Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Shows how to modify the brightness of an image using the `brightness` method. The `val` parameter determines the amount of adjustment, with positive values increasing brightness and negative values decreasing it.

```javascript
import Jimp from 'jimp';

Jimp.read('image.jpg')
  .then(image => {
    return image.brightness(0.3); // Increase brightness by 30%
  })
  .then(image => {
    image.write('image-brighter.jpg');
  })
  .catch(err => {
    console.error(err);
  });

```

--------------------------------

### Jimp Composite API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Composites a source image over the current image, respecting alpha channels.

```APIDOC
## POST /composite

### Description
Composites a source image over to this image respecting alpha channels.

### Method
POST

### Endpoint
/composite

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **src** (I) - Required - the source Jimp instance
- **x** (number) - Optional - the x position to blit the image
- **y** (number) - Optional - the y position to blit the image
- **options** (object) - Optional - determine what mode to use
  - **mode** (BlendMode) - Optional
  - **opacityDest** (number) - Optional
  - **opacitySource** (number) - Optional

### Request Example
```json
{
  "src": "source_image_data",
  "x": 10,
  "y": 20,
  "options": {
    "mode": "REPLACE",
    "opacitySource": 0.5
  }
}
```

### Response
#### Success Response (200)
- **result** (any) - The result of the composite operation.

#### Response Example
```json
{
  "result": "success"
}
```
```

--------------------------------

### Jimp ResizeStrategy: HERMITE Interpolation

Source: https://jimp-dev.github.io/jimp/api/jimp/enumerations/resizestrategy

Defines the HERMITE resizing algorithm for Jimp. This method uses Hermite interpolation, calculating output pixel values based on a weighted average of surrounding pixels. While slower than simpler methods, it produces higher quality visuals with less blurring.

```typescript
HERMITE = "hermiteInterpolation"
```

--------------------------------

### Jimp Displace API

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Displaces the image based on a provided displacement map.

```APIDOC
## POST /displace

### Description
Displaces the image based on the provided displacement map.

### Method
POST

### Endpoint
/displace

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **options** (object) - Required
  - **map** (Jimp) - Required - the source Jimp instance used as a displacement map
    - **bitmap** (object)
      - **width** (number) - Required
      - **height** (number) - Required
      - **data** (Buffer | Uint8Array) - Required
  - **offset** (number) - Required - the maximum displacement value

### Request Example
```json
{
  "options": {
    "map": {
      "bitmap": {
        "width": 100,
        "height": 100,
        "data": "base64_encoded_bitmap_data"
      }
    },
    "offset": 10
  }
}
```

### Response
#### Success Response (200)
- **result** (Jimp) - The displaced Jimp instance.

#### Response Example
```json
{
  "result": "jimp_instance_data"
}
```
```

--------------------------------

### Apply Ordered Dithering - Jimp

Source: https://jimp-dev.github.io/jimp/api/jimp/classes/jimp

Applies an ordered dithering effect to the image. Dithering is a technique used to create the illusion of more colors than are actually available.

```typescript
dither(): Jimp
```
Tokens:
Raw