vips-rs

https://houseme.github.io/vips-rs/vips
Admin
vips-rs is a lightweight Rust safety wrapper around libvips that provides initialization,...
Tokens:149,400
Snippets:937
Trust Score:8.3
Update:8 months ago
Show doc for...
Tokens:
Raw
### Example: Calling VipsInterpolateMethod::call (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod_search=

Provides an example of how to invoke the 'call' method of VipsInterpolateMethod. This snippet shows the setup required, including VipsInstance, VipsImage, VipsRegion, and VipsInterpolate, before performing the interpolation call.

```rust
use vips :: *;
fn main() -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    let method = interpolate.method();
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Example of Calling VipsInterpolateMethod (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides an example of calling the 'call' method of VipsInterpolateMethod. This snippet shows the setup required, including initializing vips, loading an image, defining a region, and preparing an output buffer before invoking the interpolation.

```rust
use vips :: *;
fn main () -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    let method = interpolate.method();
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Example: Using VipsInterpolateMethod for Image Interpolation (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod_search=

Demonstrates how to use VipsInterpolateMethod to perform image interpolation. It initializes a VipsInstance, gets a bilinear interpolation method, loads an image, creates a region, and then calls the interpolation method to get pixel data.

```rust
use vips :: *;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Example Usage of VipsInterpolateMethod (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use VipsInterpolateMethod to perform image interpolation. It initializes a VipsInstance, gets a bilinear interpolation method, loads an image, creates a region, and then calls the interpolation method to get pixel data.

```rust
use vips :: *;

fn main () -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Initialize VipsInstance and Load Image (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=u32+-%3E+bool

Demonstrates the basic setup for using the vips-rs library by initializing a VipsInstance and loading an image from a buffer. This is a prerequisite for most image manipulation operations.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/* image data */];
    let img = VipsImage::from_buffer(img_data)?;
    Ok(())
}
```

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

### VipsImage Struct Definition and Usage Example

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Defines the VipsImage struct, which represents a libvips image. Includes an example demonstrating image loading, thumbnail generation, and saving.

```rust
pub struct VipsImage<'a> {
    pub c: *mut VipsImage,
    /* private fields */
}

use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("input.jpg")?;
    let thumb = img.thumbnail(100, 100, VipsSize::VIPS_SIZE_BOTH)?;
    thumb.write_to_file("thumb.jpg")?;
    Ok(())
}
```

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

### Example Usage of VipsInterpolateMethod (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod

Demonstrates how to use the VipsInterpolateMethod to perform image interpolation. It initializes a VipsInstance, gets a bilinear interpolation method, and then calls the method to interpolate a pixel.

```rust
use vips ::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Create and Use VipsRegion with VipsImage in Rust

Source: https://houseme.github.io/vips-rs/vips/struct.VipsRegion_search=

Demonstrates how to create a VipsInstance, load an image using VipsImage, and then create a VipsRegion associated with that image. This example requires the 'vips' crate.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    Ok(())
}
```

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

### Calling VipsInterpolateMethod (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolateMethod

Provides an example of calling the `call` method on a VipsInterpolateMethod. This method performs the actual pixel interpolation based on the provided coordinates and input region.

```rust
use vips ::*;
fn main() -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    let method = interpolate.method();
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Get VipsInterpolate Method and Properties (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate_search=u32+-%3E+bool

Illustrates how to retrieve the interpolation method and its properties (window size, window offset) from a VipsInterpolate instance. These methods allow inspecting the configuration of the chosen interpolation algorithm.

```rust
use vips::*
fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

```rust
use vips::*
fn main() -> Result<()> {
   let interpolate = VipsInterpolate::bilinear_static();
   let window_size = interpolate.window_size();
    println!("Window size: {}", window_size);
    Ok(())
}
```

```rust
use vips::*
fn main() -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let window_offset = interpolate.window_offset();
    println!("Window offset: {}", window_offset);
    Ok(())
}
```

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

### Create Static VipsInterpolate Instances (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate_search=u32+-%3E+bool

Shows how to create static instances of VipsInterpolate for 'nearest' and 'bilinear' interpolation methods. These methods do not require a nickname and directly return a VipsInterpolate instance. The examples demonstrate their usage with image processing operations.

```rust
use vips::*
fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::nearest_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

```rust
use vips::*
fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Example: Create Thumbnail from Byte Buffer using VipsBuffer (Rust)

Source: https://houseme.github.io/vips-rs/vips/trait.VipsBuffer_search=

Demonstrates how to use the `VipsBuffer` trait to create a thumbnail from a byte slice. It reads an image file into a byte slice, generates a thumbnail, and saves it. Requires the `vips` crate.

```Rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let binding = std::fs::read("./examples/images/kodim01.png")?;
    let img_data: &[u8] = binding.as_slice();
    let thumbnail = img_data.thumbnail(100, 100)?;
    thumbnail.write_to_file("kodim01_thumb.png")?;
    Ok(())
}
```

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

### Create Static Nearest Neighbor VipsInterpolate

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate

Provides a static method to create a VipsInterpolate instance configured for nearest neighbor interpolation. This is a convenient way to get a pre-configured interpolator.

```rust
use vips::*
fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::nearest_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

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

### Get libvips Version (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.version_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the libvips version as a tuple of major, minor, and micro integers. This function has no external dependencies and returns a fixed tuple representing the library's version.

```rust
use vips::version;

let (major, minor, micro) = version();
println!("libvips version: {}.{}.{}", major, minor, micro);
```

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

### Create Thumbnail from Byte Slice using VipsBuffer in Rust

Source: https://houseme.github.io/vips-rs/vips/trait.VipsBuffer_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create a thumbnail from a byte slice using the `VipsBuffer` trait implementation for `&[u8]`. This example reads an image file into a byte slice and then generates a 100x100 thumbnail, saving it to a new file.

```rust
use vips :: *;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let binding = std::fs::read("./examples/images/kodim01.png")?;
    let img_data: &[u8] = binding.as_slice();
    let thumbnail = img_data.thumbnail(100, 100)?;
    thumbnail.write_to_file("kodim01_thumb.png")?;
    Ok(())
}
```

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

### Create VipsImage Instance and Load Image Data

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Demonstrates how to initialize a VipsInstance and create a VipsImage from raw image data. This is a foundational step for many image manipulation operations. It requires the 'vips' crate and returns a Result.

```rust
use vips::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/* image data */];
    let img = VipsImage::from_buffer(img_data)?;
    Ok(())
}
```

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

### Initialize and Configure vips-rs

Source: https://houseme.github.io/vips-rs/vips/index_search=

Demonstrates the initialization of the vips library with an application name and configuration of concurrency, cache size, and file limits. This is essential for setting up the vips environment before performing image operations. It uses standard Rust error handling.

```rust
use vips::{init, set_concurrency};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // initialization (idempotent), recommended to call as early as possible
    init(Some("my-app"))?;

    // Configure concurrency (default = number of CPU cores)
    vips::set_concurrency(4);

    // Tuning the cache
    vips::set_max_operations(1000);
    vips::set_max_mem_bytes(256 * 1024 * 1024);
    vips::set_max_files(100);

    Ok(())
}
```

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

### Initialization and Configuration

Source: https://houseme.github.io/vips-rs/vips/index

This section details how to initialize the vips library, configure concurrency, and tune caching parameters.

```APIDOC
## Initialization and Configuration

### Description
Initialize the libvips library, set concurrency levels, and configure cache settings for optimal performance.

### Functions

#### `init(app_name: Option<&str>) -> Result<(), Box<dyn std::error::Error>>`

Initialize libvips (idempotent). `app_name` can be used for logging and diagnostic display. If `app_name` is `None`, a default name “vips-rs” will be used.

**Method:** `POST` (conceptual, as this is a library function)

**Endpoint:** N/A

**Parameters:**

*   **Path Parameters:** None
*   **Query Parameters:** None
*   **Request Body:** None

**Usage Example:**
```rust
use vips::init;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    init(Some("my-app"))?;
    Ok(())
}
```

#### `is_initialized() -> bool`

Check if the libvips library has been initialized.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** `true` if initialized, `false` otherwise.

#### `set_concurrency(concurrency: i32)`

Set concurrency (<=0 will fall back to default, which is the number of CPU cores).

**Method:** `POST` (conceptual)

**Endpoint:** N/A

**Parameters:**

*   **Query Parameters:**
    *   **concurrency** (i32) - Required - The number of concurrent threads to use.

**Usage Example:**
```rust
vips::set_concurrency(4);
```

#### `set_max_operations(max_ops: usize)`

Sets the maximum number of compute nodes that can be retained in the cache.

**Method:** `POST` (conceptual)

**Endpoint:** N/A

**Parameters:**

*   **Query Parameters:**
    *   **max_ops** (usize) - Required - The maximum number of operations to cache.

**Usage Example:**
```rust
vips::set_max_operations(1000);
```

#### `set_max_mem_bytes(max_mem: usize)`

Set the maximum memory allowed in bytes for the cache.

**Method:** `POST` (conceptual)

**Endpoint:** N/A

**Parameters:**

*   **Query Parameters:**
    *   **max_mem** (usize) - Required - The maximum memory in bytes for the cache.

**Usage Example:**
```rust
vips::set_max_mem_bytes(256 * 1024 * 1024);
```

#### `set_max_files(max_files: usize)`

Set the maximum number of files allowed to open at the same time.

**Method:** `POST` (conceptual)

**Endpoint:** N/A

**Parameters:**

*   **Query Parameters:**
    *   **max_files** (usize) - Required - The maximum number of open files.

**Usage Example:**
```rust
vips::set_max_files(100);
```

### Getters

#### `concurrency() -> i32`

Get the current concurrency setting.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The current concurrency level.

#### `max_operations() -> usize`

Gets the maximum number of compute nodes configured for the cache.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The maximum number of operations in the cache.

#### `max_mem_bytes() -> usize`

Get the maximum cache memory (bytes) configured.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The maximum cache memory in bytes.

#### `max_files() -> usize`

Get the maximum number of files configured.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The maximum number of files allowed.

#### `size_operations() -> usize`

Gets the number of compute nodes currently in the cache.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The number of operations currently in the cache.

#### `tracked_mem_bytes() -> usize`

Returns the currently tracked memory usage in bytes.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** Currently tracked memory in bytes.

#### `tracked_mem_highwater_bytes() -> usize`

Returns the historical peak memory usage in bytes.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** Historical peak memory usage in bytes.

#### `version() -> (i32, i32, i32)`

Returns the libvips version as a tuple: (major, minor, micro).

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** A tuple representing the version (major, minor, micro).

#### `version_string() -> String`

Returns the full libvips version string, such as “8.14.2”.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** The full version string.

### Error Handling

#### `take_vips_error() -> Option<String>`

Read and empty the error buffer of libvips. Returns `Some(error_message)` if an error occurred, `None` otherwise.

**Method:** `GET` (conceptual)

**Endpoint:** N/A

**Returns:** An `Option<String>` containing the error message if available.

#### `code_to_result(code: i32) -> Result<(), Box<dyn std::error::Error>>`

Convert the return code (0=OK, non-0=ERR) convention in libvips to a Rust `Result`.

**Method:** `POST` (conceptual)

**Endpoint:** N/A

**Parameters:**

*   **Query Parameters:**
    *   **code** (i32) - Required - The integer return code from a libvips operation.

**Returns:** `Ok(())` if the code is 0, otherwise an `Err` with a descriptive error message.

```

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

### Initialize and Configure vips-rs

Source: https://houseme.github.io/vips-rs/vips/index_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize the vips library with an application name, set the concurrency level, and tune cache parameters. Initialization is idempotent and should be called early. Concurrency defaults to the number of CPU cores if not explicitly set.

```rust
use vips::{init, set_concurrency};

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // initialization (idempotent), recommended to call as early as possible
    init(Some("my-app"))?;

    // Configure concurrency (default = number of CPU cores)
    vips::set_concurrency(4);

    // Tuning the cache
    vips::set_max_operations(1000);
    vips::set_max_mem_bytes(256 * 1024 * 1024);
    vips::set_max_files(100);

    Ok(())
}

```

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

### vips Result Enum Definition and Example (Rust)

Source: https://houseme.github.io/vips-rs/vips/type.Result_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides the definition of the `Result` enum used in vips-rs, which represents either a successful outcome (`Ok(T)`) or an error (`Err(Error)`). An example function demonstrates how to return this specialized `Result` type.

```rust
pub enum Result<T> {
    Ok(T),
    Err(Error),
}

use vips::{Error, Result};

fn example() -> Result<()> {
    // some libvips operation
    Ok(())
}
```

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

### VipsInterpolate::window_offset

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate

Gets the window offset used by the interpolation method.

```APIDOC
## `VipsInterpolate::window_offset(&self) -> i32`

### Description
Get the window offset.

### Method
`window_offset`

### Returns
The integer window offset used by the interpolation method.

### Example
```rust
use vips::*

fn main() -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let window_offset = interpolate.window_offset();
    println!("Window offset: {}", window_offset);
    Ok(())
}
```
```

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

### Create VipsRegion Instance - Rust

Source: https://houseme.github.io/vips-rs/vips/struct.VipsRegion

Demonstrates how to create a new VipsRegion instance for a given VipsImage. This involves initializing a VipsInstance and loading an image.

```rust
use vips :: *;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    Ok(())
}
```

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

### VipsInterpolate::window_size

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate

Gets the window size used by the interpolation method.

```APIDOC
## `VipsInterpolate::window_size(&self) -> i32`

### Description
Get the window size.

### Method
`window_size`

### Returns
The integer window size used by the interpolation method.

### Example
```rust
use vips::*

fn main() -> Result<()> {
   let interpolate = VipsInterpolate::bilinear_static();
   let window_size = interpolate.window_size();
    println!("Window size: {}", window_size);
    Ok(())
}
```
```

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

### Initialize Vips Instance and Load Image (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize a VipsInstance and load an image from buffer or file. This is a prerequisite for most image manipulation operations.

```Rust
use vips::*; 

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/ * image data * /];
    let img = VipsImage::from_buffer(img_data)?;
    Ok(())
}
```

```Rust
use vips::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let mut img = VipsImage::from_file("input.jpg")?;
    img.draw_rect(&[255.0, 0.0, 0.0], 10, 10, 100, 50)?;
    img.write_to_file("output.jpg")?;
    Ok(())
}
```

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

### size_operations

Source: https://houseme.github.io/vips-rs/vips/fn.size_operations_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the number of compute nodes in the current cache.

```APIDOC
## size_operations

### Description
Gets the number of compute nodes in the current cache.

### Method
GET

### Endpoint
/size_operations

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **size** (i32) - The current size of the operations cache.
```

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

### Initialize VipsInstance

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInstance

Demonstrates how to create a new VipsInstance, which initializes the libvips library. This function should only be called once per program execution. It takes an application name and a boolean for leak testing.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    // Your libvips code here
    Ok(())
}
```

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

### Get Concurrency

Source: https://houseme.github.io/vips-rs/vips/fn.concurrency_search=u32+-%3E+bool

Retrieves the number of threads currently used by libvips.

```APIDOC
## GET /concurrency

### Description
Retrieves the current concurrency level used by the libvips library.

### Method
GET

### Endpoint
/concurrency

### Parameters
#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
- **concurrency** (integer) - The number of threads currently used by libvips.

#### Response Example
```json
{
  "concurrency": 4
}
```
```

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

### Get Tracked Memory Usage

Source: https://houseme.github.io/vips-rs/vips/fn.tracked_mem_bytes_search=u32+-%3E+bool

Retrieves the currently tracked memory usage in bytes by libvips.

```APIDOC
## GET /tracked_mem_bytes

### Description
Retrieves the currently tracked memory usage in bytes by libvips.

### Method
GET

### Endpoint
/tracked_mem_bytes

### Parameters
#### Query Parameters
None

#### Request Body
None

### Response
#### Success Response (200)
- **memory_usage** (usize) - The current memory usage in bytes tracked by libvips.

#### Response Example
```json
{
  "memory_usage": 10240
}
```
```

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

### Create New VipsImage Instance

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Demonstrates how to create a new, empty VipsImage instance. This is useful for creating images programmatically before populating them with data or operations. It requires proper initialization of the VipsInstance.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::new()?;
    Ok(())
}
```

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

### Get libvips Version

Source: https://houseme.github.io/vips-rs/vips/fn.version

Retrieves the libvips version as a tuple of major, minor, and micro version numbers.

```APIDOC
## GET /version

### Description
Retrieves the libvips version as a tuple: (major, minor, micro).

### Method
GET

### Endpoint
/version

### Parameters
None

### Request Body
None

### Response
#### Success Response (200)
- **major** (integer) - The major version number.
- **minor** (integer) - The minor version number.
- **micro** (integer) - The micro version number.

#### Response Example
```json
{
  "major": 8,
  "minor": 12,
  "micro": 4
}
```
```

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

### Initialize VipsInstance (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInstance_search=

Demonstrates how to create a new VipsInstance, which initializes the libvips library. This function should only be called once per program execution. It takes an application name and a boolean for leak testing.

```rust
use vips::*; 

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    // Your libvips code here
    Ok(())
}
```

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

### Get VipsInterpolate Window Offset

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate

Retrieves the window offset for the VipsInterpolate method. This offset can influence how the interpolation kernel is applied relative to the pixel grid.

```rust
use vips::*

fn main() -> Result<()> {
    let interpolate = VipsInterpolate::bilinear_static();
    let window_offset = interpolate.window_offset();
    println!("Window offset: {}", window_offset);
    Ok(())
}
```

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

### Implementing From Trait in Rust

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `From<T>` trait allows for infallible conversions from type `T` into the implementing type. The `from(t: T) -> T` function simply returns the argument unchanged, serving as a basic example.

```rust
impl<T> From<T> for T {
    fn from(t: T) -> T {
        t
    }
}
```

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

### VipsInterpolate Creation and Usage

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate_search=std%3A%3Avec

Demonstrates how to create VipsInterpolate instances using static methods or by nickname, and how to use them with VipsImage and VipsRegion for image processing.

```APIDOC
## VipsInterpolate Methods

### `new(nickname: &str) -> Result<VipsInterpolate>`

#### Description
Create a new VipsInterpolate by nickname.

#### Arguments
- `nickname` (string) - The nickname of the interpolation method (e.g., "bilinear", "nearest").

#### Errors
Returns an error if the nickname is invalid.

#### Example
```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::new("bilinear")?;
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

### `nearest_static() -> VipsInterpolate`

#### Description
Create a new nearest static VipsInterpolate.

#### Returns
A VipsInterpolate instance for nearest neighbor interpolation.

#### Example
```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::nearest_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```

### `bilinear_static() -> VipsInterpolate`

#### Description
Create a new bilinear static VipsInterpolate.

#### Returns
A VipsInterpolate instance for bilinear interpolation.

#### Example
```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let interpolate = VipsInterpolate::bilinear_static();
    let method = interpolate.method();
    let img = VipsImage::from_file("examples/images/kodim01.png")?;
    let region = VipsRegion::new(&img);
    let mut out = vec![0u8; 3]; // assuming 3 channels
    method.call(&interpolate, &region, &mut out, 1.5, 1.5);
    Ok(())
}
```
```

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

### Create New VipsImage (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=

Shows how to create a new, empty VipsImage instance using the `new` function. This operation can fail, so it returns a `Result`. It requires an initialized `VipsInstance`.

```rust
use vips::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::new()?;
    Ok(())
}
```

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

### Get VipsInterpolate Window Size

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInterpolate

Returns the window size used by the current VipsInterpolate method. This value is relevant for understanding the neighborhood of pixels considered during interpolation.

```rust
use vips::*

fn main() -> Result<()> {
   let interpolate = VipsInterpolate::bilinear_static();
   let window_size = interpolate.window_size();
    println!("Window size: {}", window_size);
    Ok(())
}
```

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

### Draw Flood Fill

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=std%3A%3Avec

Performs a flood fill operation on the image starting from a given point. Supports filling with a color slice or a single color value.

```APIDOC
## POST /draw_flood

### Description
Performs a flood fill operation on the image starting from the specified coordinates with the given color.

### Method
POST

### Endpoint
`/{image_id}/draw_flood`

### Parameters
#### Path Parameters
- **image_id** (string) - Required - Identifier for the image to modify.

#### Query Parameters
None

#### Request Body
- **ink** (array of f64) - Required - The color to fill with, as a slice of f64 values.
- **x** (i32) - Required - The x-coordinate to start the flood fill from.
- **y** (i32) - Required - The y-coordinate to start the flood fill from.

### Request Example
```json
{
  "ink": [255.0, 0.0, 255.0],
  "x": 50,
  "y": 50
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

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

## POST /draw_flood1

### Description
Performs a flood fill operation on the image starting from the specified coordinates with a single color value.

### Method
POST

### Endpoint
`/{image_id}/draw_flood1`

### Parameters
#### Path Parameters
- **image_id** (string) - Required - Identifier for the image to modify.

#### Query Parameters
None

#### Request Body
- **ink** (f64) - Required - The color to fill with.
- **x** (i32) - Required - The x-coordinate to start the flood fill from.
- **y** (i32) - Required - The y-coordinate to start the flood fill from.

### Request Example
```json
{
  "ink": 128.0,
  "x": 50,
  "y": 50
}
```

### Response
#### Success Response (200)
- **status** (string) - Indicates success.

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

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

### Initialize libvips with vips-rs

Source: https://houseme.github.io/vips-rs/vips/fn.init

Initializes the libvips library. This function is idempotent and can be called multiple times. An optional application name can be provided for logging and diagnostics; otherwise, a default name 'vips-rs' is used. Initialization failure results in an `Error::InitFailed` error.

```rust
use vips::init;
use vips::errors::Result;

fn main() -> Result<()> {
    // Initialize libvips with a custom application name
    init(Some("my_app"))?;
    
    // Your libvips code can go here after successful initialization
    
    Ok(())
}

```

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

### Get Max Operations (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.max_operations_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the maximum number of compute nodes configured for the vips library. This value represents the maximum size of the operations cache.

```rust
pub fn max_operations() -> i32
```

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

### Create VipsImage from Memory Buffer Reference

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Shows how to create a VipsImage from a slice of bytes representing image data. This method is efficient as it avoids copying the data. Requires image dimensions and format. The VipsInstance must be initialized.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/* image data */];
    let img = VipsImage::from_memory_reference(img_data, 800, 600, 3, VipsBandFormat::VIPS_FORMAT_UCHAR)?;
    Ok(())
}
```

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

### Get Current Concurrency (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.concurrency_search=u32+-%3E+bool

Retrieves the current number of threads being used by the libvips library. This function is useful for monitoring and understanding the resource utilization of vips operations.

```Rust
use vips::concurrency;

let n = concurrency();
println!("Current libvips concurrency: {}", n);
```

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

### Initialize VipsInstance in Rust

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=

Demonstrates how to initialize a VipsInstance, which is necessary before performing any image operations. This function requires a name for the application and a boolean indicating whether to enable logging.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/ * image data * /];
    let img = VipsImage::from_buffer(img_data)?;
    Ok(())
}
```

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

### Get libvips Concurrency (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.concurrency

Retrieves the number of threads currently utilized by the libvips library. This function returns an i32 representing the thread count. It has no input parameters.

```Rust
pub fn concurrency() -> i32
```

```Rust
use vips::concurrency;

let n = concurrency();
println!("Current libvips concurrency: {}", n);
```

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

### Get Operations Cache Size (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.size_operations_search=

Retrieves the number of compute nodes currently in the operations cache. This function is part of the vips library and returns an i32 representing the cache size.

```rust
pub fn size_operations() -> i32
```

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

### Initialize libvips in Rust

Source: https://houseme.github.io/vips-rs/vips/fn.init_search=

Initializes the libvips library. This operation is idempotent. An optional application name can be provided for logging and diagnostics; otherwise, a default name 'vips-rs' is used. Initialization failure results in an `Error::InitFailed` error.

```rust
pub fn init(app_name: Option<&str>) -> Result<()>
```

```rust
use vips::*

fn main() -> Result<()> {
    init(Some("my_app"))?;
    // Your libvips code here
    Ok(())
}
```

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

### Get references from Result (Rust)

Source: https://houseme.github.io/vips-rs/vips/type.Result_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Illustrates the `as_ref()` method, which converts a `&Result<T, E>` into a `Result<&T, &E>`. This allows borrowing the contained values without consuming the original Result.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### Initialize libvips

Source: https://houseme.github.io/vips-rs/vips/fn.init_search=

Initializes the libvips library. This function is idempotent and can be called multiple times. An optional application name can be provided for logging purposes.

```APIDOC
## POST /init

### Description
Initializes the libvips library. This function is idempotent and can be called multiple times. An optional application name can be provided for logging purposes.

### Method
POST

### Endpoint
/init

### Parameters
#### Query Parameters
- **app_name** (Option<string>) - Optional - The name of the application using libvips, used for logging and diagnostic display. Defaults to "vips-rs" if None.

### Request Body
None

### Response
#### Success Response (200)
- **status** (string) - Indicates successful initialization.

#### Response Example
```json
{
  "status": "initialized"
}
```

#### Error Response (500)
- **error** (string) - Indicates that initialization failed.

#### Error Example
```json
{
  "error": "InitFailed"
}
```
```

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

### Get Tracked Memory Usage (Rust)

Source: https://houseme.github.io/vips-rs/vips/fn.tracked_mem_bytes_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This function returns the currently tracked memory usage in bytes by the libvips library. It does not take any arguments and returns a `usize` representing the memory in bytes.

```Rust
pub fn tracked_mem_bytes() -> usize
```

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

### VipsInstance Initialization Function

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInstance_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Details the `new` function for VipsInstance, which initializes libvips. It returns a Result, indicating success or failure if an instance already exists. Arguments include the application name and a leak test flag.

```rust
pub fn new(name: &str, leak_test: bool) -> Result<VipsInstance>

```

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

### Create VipsImage from Memory Buffer

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Demonstrates creating a VipsImage directly from a byte vector containing image data. Requires specifying image dimensions, number of bands, and pixel format. The VipsInstance must be initialized.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: Vec<u8> = vec![/* image data */];
    let img = VipsImage::from_memory(img_data, 800, 600, 3, VipsBandFormat::VIPS_FORMAT_UCHAR)?;
    Ok(())
}
```

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

### Provide Default Value with `unwrap_or` in Rust

Source: https://houseme.github.io/vips-rs/vips/type.Result_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Shows how to use `unwrap_or` to get the `Ok` value from a Result or a provided default value if the Result is `Err`. The default value is eagerly evaluated.

```rust
let default = 2;
let x: Result<u32, &str> = Ok(9);
assert_eq!(x.unwrap_or(default), 9);

let x: Result<u32, &str> = Err("error");
assert_eq!(x.unwrap_or(default), default);
```

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

### Get mutable references from Result (Rust)

Source: https://houseme.github.io/vips-rs/vips/type.Result_search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Explains the `as_mut()` method, which converts a `&mut Result<T, E>` into a `Result<&mut T, &mut E>`. This enables modifying the contained values in place.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### Load VipsImage from File

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage

Illustrates creating a VipsImage by loading it from a specified file path. This is a common operation for image processing workflows. Ensure the file exists and is accessible.

```rust
use vips::*

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img = VipsImage::from_file("input.jpg")?;
    Ok(())
}
```

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

### Create VipsImage from Memory Reference (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=

Demonstrates creating a VipsImage from a slice of memory containing image data. This method is similar to `from_memory` but accepts a reference, ensuring the data remains valid for the lifetime of the VipsImage. It returns a Result.

```rust
use vips::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: &[u8] = &[/* image data */];
    let img = VipsImage::from_memory_reference(img_data, 800, 600, 3, VipsBandFormat::VIPS_FORMAT_UCHAR)?;
    Ok(())
}
```

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

### Example Usage of vips Result Type (Rust)

Source: https://houseme.github.io/vips-rs/vips/type.Result_search=u32+-%3E+bool

Demonstrates how to use the specialized `Result` type for libvips operations in a function. It shows a typical pattern of performing an operation and returning `Ok(())` on success or an `Err` on failure.

```rust
use vips::{Error, Result};

fn example() -> Result<()> {
    // some libvips operation
    Ok(())
}
```

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

### VipsInstance Initialization API

Source: https://houseme.github.io/vips-rs/vips/struct.VipsInstance_search=

This API allows for the creation of a VipsInstance, which is responsible for initializing and managing the libvips library. It ensures that libvips is initialized only once per program execution.

```APIDOC
## POST /vips/instance

### Description
Initializes the libvips library and creates a singleton instance to manage its lifecycle. This function should ideally be called only once per program execution. Subsequent calls will result in an error.

### Method
POST

### Endpoint
/vips/instance

### Parameters
#### Query Parameters
- **name** (string) - Required - The application name to be used for libvips initialization.
- **leak_test** (boolean) - Optional - If set to `true`, enables leak testing within libvips. Defaults to `false`.

### Request Body
This endpoint does not require a request body.

### Response
#### Success Response (200)
- **instance_id** (string) - A unique identifier for the created VipsInstance.

#### Response Example
```json
{
  "instance_id": "vips_instance_12345"
}
```

#### Error Response (400)
- **error** (string) - Description of the error, e.g., "libvips already initialized".

#### Error Response Example
```json
{
  "error": "libvips already initialized"
}
```

### Safety Note
**Shutdown Timing:** The libvips library is automatically shut down when the `VipsInstance` is dropped (typically at the end of `main()`). Any operations referencing libvips after this point (such as in other static destructors or background threads) may result in undefined behavior. To avoid this, ensure all libvips operations are completed before the `Vips Instance` is dropped.
```

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

### Create VipsImage from Memory (Rust)

Source: https://houseme.github.io/vips-rs/vips/struct.VipsImage_search=

Illustrates creating a VipsImage from raw image data in memory. This function takes image dimensions, band count, and format as arguments. It returns a Result to handle potential creation failures.

```rust
use vips::*;

fn main() -> Result<()> {
    let _instance = VipsInstance::new("app_test", true)?;
    let img_data: Vec<u8> = vec![/* image data */];
    let img = VipsImage::from_memory(img_data, 800, 600, 3, VipsBandFormat::VIPS_FORMAT_UCHAR)?;
    Ok(())
}
```
Tokens:
Raw