Photon RS

https://docs.rs/photon-rs/latest/photon_rs/
Admin
A high-performance image processing library for Rust that provides native and WebAssembly support...
Tokens:66,272
Snippets:483
Trust Score:9.7
Update:6 months ago
Show doc for...
Tokens:
Raw
### Selective Lightening Example

Source: https://docs.rs/photon-rs/latest/photon_rs/channels/fn.selective_lighten.html

Demonstrates how to lighten pixels similar to a specific RGB color in an image.

```rust
// For example, to only lighten the pixels that are of or similar to RGB value RGB{20, 40, 60}:
use photon_rs::Rgb;
use photon_rs::channels::selective_lighten;
use photon_rs::native::open_image;

let ref_color = Rgb::new(20_u8, 40_u8, 60_u8);
let mut img = open_image("img.jpg").expect("File should open");
selective_lighten(&mut img, ref_color, 0.2_f32);
```

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

### Apply HSL Effect to Image

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.hsl.html

Example demonstrating how to open an image and apply a saturation increase using the hsl function.

```rust
// For example to increase the saturation by 10%:
use photon_rs::colour_spaces::hsl;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
hsl(&mut img, "saturate", 0.1_f32);
```

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

### Selective Hue Rotation Example

Source: https://docs.rs/photon-rs/latest/photon_rs/channels/fn.selective_hue_rotate.html

Demonstrates how to rotate the hue of pixels matching a specific RGB reference color.

```rust
// For example, to only rotate the pixels that are of RGB value RGB{20, 40, 60}:
use photon_rs::Rgb;
use photon_rs::channels::selective_hue_rotate;
use photon_rs::native::open_image;

let ref_color = Rgb::new(20_u8, 40_u8, 60_u8);
let mut img = open_image("img.jpg").expect("File should open");
selective_hue_rotate(&mut img, ref_color, 180_f32);
```

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

### Selective Saturation Example

Source: https://docs.rs/photon-rs/latest/photon_rs/channels/fn.selective_saturate.html

Use this function to increase the saturation of pixels similar to a specific RGB color. Ensure the 'photon_rs::native::open_image' function is used to load the image and 'photon_rs::Rgb' is used to define the reference color.

```rust
use photon_rs::Rgb;
use photon_rs::channels::selective_saturate;
use photon_rs::native::open_image;

let ref_color = Rgb::new(20_u8, 40_u8, 60_u8);
let mut img = open_image("img.jpg").expect("File should open");
selective_saturate(&mut img, ref_color, 0.1_f32);
```

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

### Example Usage of selective_color_convert

Source: https://docs.rs/photon-rs/latest/photon_rs/channels/fn.selective_color_convert.html

Demonstrates how to selectively change pixels similar to a specific RGB value by mixing in a new color at a 25% intensity.

```rust
// For example, to only change the color of pixels that are similar to the RGB value RGB{200, 120, 30} by mixing RGB{30, 120, 200} with 25%:
use photon_rs::Rgb;
use photon_rs::channels::selective_color_convert;
use photon_rs::native::open_image;

let ref_color = Rgb::new(200, 120, 30);
let new_color = Rgb::new(30, 120, 200);
let mut img = open_image("img.jpg").expect("File should open");
selective_color_convert(&mut img, ref_color, new_color, 0.25);
```

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

### Selective Desaturation Example

Source: https://docs.rs/photon-rs/latest/photon_rs/channels/fn.selective_desaturate.html

Use this function to desaturate pixels similar to a reference color. Ensure the PhotonImage and Rgb types are imported, and the image is opened before calling.

```rust
use photon_rs::Rgb;
use photon_rs::channels::selective_desaturate;
use photon_rs::native::open_image;

let ref_color = Rgb::new(20_u8, 40_u8, 60_u8);
let mut img = open_image("img.jpg").expect("File should open");
selective_desaturate(&mut img, ref_color, 0.1_f32);
```

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

### Open an image from a byte slice

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.open_image_from_bytes.html

Demonstrates how to read a file into a buffer and convert it into a PhotonImage. Use open_image instead if reading directly from a file path.

```rust
use photon_rs::native::open_image_from_bytes;

// Code to read a file to buffer. If you are reading from a file its better to use `open_image`
let buffer = std::fs::read("img.jpg").expect("File Should Open");

// Open the image. A PhotonImage is returned.
let img = open_image_from_bytes(buffer.as_slice()).expect("Buffer should be valid");

// ... image editing functionality here ...
```

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

### Get Blue Value

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgba.html

Returns the blue component of an Rgba color.

```rust
pub fn get_blue(&self) -> u8
```

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

### Mix image with color

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.mix_with_colour.html

Demonstrates how to blend a PhotonImage with a specific RGB color at 40% opacity.

```rust
// For example, to mix an image with rgb (50, 255, 254) and opacity 0.4:
use photon_rs::Rgb;
use photon_rs::colour_spaces::mix_with_colour;
use photon_rs::native::open_image;

let mix_colour = Rgb::new(50_u8, 255_u8, 254_u8);
let mut img = open_image("img.jpg").expect("File should open");
mix_with_colour(&mut img, mix_colour, 0.4_f32);
```

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

### Get Green Value

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgba.html

Returns the green component of an Rgba color.

```rust
pub fn get_green(&self) -> u8
```

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

### Apply lix filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.lix.html

Demonstrates how to import and apply the lix filter to a loaded PhotonImage.

```rust
use photon_rs::filters::lix;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
lix(&mut img);
```

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

### Get Red Value

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgba.html

Returns the red component of an Rgba color.

```rust
pub fn get_red(&self) -> u8
```

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

### Get Image Data

Source: https://docs.rs/photon-rs/latest/photon_rs/fn.get_image_data.html

Retrieves the ImageData from a 2D canvas context.

```APIDOC
## get_image_data

### Description
Get the ImageData from a 2D canvas context.

### Method
Not applicable (Rust function)

### Endpoint
Not applicable (Rust function)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
```rust
// Example usage within a Rust context
pub fn get_image_data(
    canvas: &HtmlCanvasElement,
    ctx: &CanvasRenderingContext2d,
) -> ImageData
```

### Response
#### Success Response (ImageData)
- **ImageData** (ImageData) - The image data object.

#### Response Example
```rust
// The return type is ImageData, specific structure depends on the ImageData definition in the library.
// Example conceptual representation:
// ImageData { data: Vec<u8>, width: u32, height: u32 }
```
```

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

### WebAssembly Integration

Source: https://docs.rs/photon-rs/latest/photon_rs/index.html

Information on how to use the photon-rs library within a WebAssembly environment.

```APIDOC
## WebAssembly Use

### Description
The photon-rs library is designed for universal communication between its core Rust code and WebAssembly. This allows for image processing to be performed directly in the browser.

### Getting Started
Refer to the official guide on how to integrate and use Photon on the web for detailed instructions and examples.

### Live Demo
A live demo showcasing WebAssembly integration is available on the official website.
```

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

### Open Image from File Path

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.open_image.html

Use this function to open an image from the filesystem. Ensure the path is correct and the file exists. A PhotonImage object is returned upon success.

```rust
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let img = open_image("img.jpg").expect("File should open");

// ... image editing functionality here ...
```

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

### Get Alpha Value

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgba.html

Returns the alpha (transparency) component of an Rgba color.

```rust
pub fn get_alpha(&self) -> u8
```

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

### Decompose an image using min decomposition

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.decompose_min.html

Demonstrates how to import and apply the min decomposition algorithm to a PhotonImage.

```rust
// For example, to decompose an image with min decomposition:
use photon_rs::monochrome::decompose_min;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
decompose_min(&mut img);
```

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

### desaturate

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.desaturate.html

Desaturate an image by getting the min/max of each pixel’s RGB values.

```APIDOC
## desaturate

### Description
Desaturate an image by getting the min/max of each pixel’s RGB values.

### Parameters
#### Arguments
- **photon_image** (PhotonImage) - Required - A PhotonImage object to be desaturated.

### Request Example
```rust
use photon_rs::monochrome::desaturate;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
desaturate(&mut img);
```
```

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

### PhotonImage Initialization

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Methods to create a new PhotonImage instance from various data sources.

```APIDOC
## PhotonImage Initialization

### Description
Create a new PhotonImage instance from different input formats.

### Methods
- `new(raw_pixels: Vec<u8>, width: u32, height: u32) -> PhotonImage`
- `new_from_base64(base64: &str) -> PhotonImage`
- `new_from_byteslice(vec: Vec<u8>) -> PhotonImage`
- `new_from_blob(blob: Blob) -> PhotonImage`
- `new_from_image(image: HtmlImageElement) -> PhotonImage`
```

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

### Apply sepia filter to a PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.sepia.html

Demonstrates how to load an image and apply the sepia effect using the photon_rs library.

```rust
// For example, to sepia an image of type `PhotonImage`:
use photon_rs::monochrome::sepia;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
sepia(&mut img);
```

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

### Get Type ID

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/enum.SamplingFilter.html

Implements the Any trait to allow retrieving the TypeId of a type, useful for runtime type identification.

```rust
impl<T> Any for T
```

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

### Apply solarize effect to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.solarize.html

Demonstrates how to import the solarize function and apply it to a loaded PhotonImage.

```rust
// For example, to colorize an image of type `PhotonImage`:
use photon_rs::effects::solarize;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
solarize(&mut img);
```

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

### Apply threshold to a PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.threshold.html

Demonstrates how to open an image and apply a threshold value using the photon_rs library.

```rust
// For example, to threshold an image of type `PhotonImage`:
use photon_rs::monochrome::threshold;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
threshold(&mut img, 30_u32);
```

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

### Crop an image using photon_rs

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.crop.html

Demonstrates how to open an image and apply a crop transformation using specific coordinate bounds.

```rust
// For example, to crop an image at (0, 0) to (500, 800)
use photon_rs::native::{open_image};
use photon_rs::transform::crop;
use photon_rs::PhotonImage;

let mut img = open_image("img.jpg").expect("File should open");
let cropped_img: PhotonImage = crop(&img, 0_u32, 0_u32, 500_u32, 800_u32);
// Write the contents of this image in JPG format.
```

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

### Calculate Square Distance Between Colors

Source: https://docs.rs/photon-rs/latest/photon_rs/helpers/fn.square_distance.html

Use this function to get the square distance between two RGB colors. It's a helper function for color comparisons.

```rust
pub fn square_distance(color1: Rgb, color2: Rgb) -> i32
```

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

### Apply edge detection to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/conv/fn.edge_detection.html

Demonstrates how to load an image and apply the edge detection filter using the photon_rs library.

```rust
// For example, to increase the Red channel for all pixels by 10:
use photon_rs::conv::edge_detection;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
edge_detection(&mut img);
```

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

### Get Raw Pixels from DynamicImage

Source: https://docs.rs/photon-rs/latest/photon_rs/helpers/fn.get_pixels.html

Use this function to obtain the raw pixel data as a Vec<u8> from a DynamicImage. Ensure you have a DynamicImage instance to pass as an argument.

```rust
pub fn get_pixels(img: DynamicImage) -> Vec<u8> ⓘ
```

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

### Apply Sobel Global Filter

Source: https://docs.rs/photon-rs/latest/photon_rs/conv/fn.sobel_global.html

Demonstrates how to import and apply the global Sobel filter to an image loaded from a file.

```rust
// For example, to apply a global Sobel filter:
use photon_rs::conv::sobel_global;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
sobel_global(&mut img);
```

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

### Convert HTML5 Canvas to PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/fn.open_image.html

Use this function to initialize a PhotonImage from an existing HTML5 canvas context.

```rust
pub fn open_image(
    canvas: HtmlCanvasElement,
    ctx: CanvasRenderingContext2d,
) -> PhotonImage
```

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

### Fade Images Horizontally, Vertically, or Axially

Source: https://docs.rs/photon-rs/latest/photon_rs/multiple/fn.fade.html

Use this function to blend two images. Ensure both images are the same size. For horizontal or vertical fades, align the start and end Y or X coordinates respectively. Otherwise, axial fading is applied.

```rust
use photon_rs::multiple::fade;
use photon_rs::native::open_image;

let img1 = open_image("img1.jpg").expect("File should open");
let img2 = open_image("img2.jpg").expect("File should open");
let _faded_img = fade(&img1, &img2, 0, 100, 0, 100);
```

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

### Apply obsidian filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.obsidian.html

Demonstrates how to import the obsidian filter and apply it to an image opened from the local filesystem.

```rust
use photon_rs::filters::obsidian;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
obsidian(&mut img);
```

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

### Increase Image Saturation in LCh Color Space

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.saturate_lch.html

Use this function to increase the saturation of an image within the LCh color space. The `level` parameter, a float between 0 and 1, determines the intensity of the saturation increase. For example, a `level` of 0.4 increases saturation by 40%. Ensure the image is opened using `open_image` before applying this function.

```rust
use photon_rs::colour_spaces::saturate_lch;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
saturate_lch(&mut img, 0.4_f32);
```

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

### Desaturate an image using HSLuv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.desaturate_hsluv.html

Demonstrates how to open an image and apply a 10% desaturation using the HSLuv colour space.

```rust
// For example to desaturate an image by 10% in the HSLuv colour space:
use photon_rs::colour_spaces::desaturate_hsluv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
desaturate_hsluv(&mut img, 0.1_f32);
```

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

### Increase saturation using saturate_hsluv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.saturate_hsluv.html

Demonstrates how to open an image and apply a 40% saturation increase using the HSLuv colour space.

```rust
// For example to increase saturation by 40% in the HSLuv colour space:
use photon_rs::colour_spaces::saturate_hsluv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
saturate_hsluv(&mut img, 0.4_f32);
```

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

### Apply ryo filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.ryo.html

Demonstrates how to import and apply the ryo filter to a loaded PhotonImage.

```rust
use photon_rs::filters::ryo;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
ryo(&mut img);
```

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

### Open Image

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.open_image.html

Opens an image from the filesystem and returns a PhotonImage object for further manipulation.

```APIDOC
## open_image

### Description
Opens an image at a given path from the filesystem. A PhotonImage is returned.

### Method
Rust Function

### Endpoint
photon_rs::native::open_image

### Parameters
#### Path Parameters
- **img_path** (P: AsRef<Path>) - Required - Path to the image you wish to edit.

### Request Example
```rust
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let img = open_image("img.jpg").expect("File should open");

// ... image editing functionality here ...
```

### Response
#### Success Response (Result<PhotonImage, Error>)
- **PhotonImage** - An object representing the opened image.
- **Error** - An error type if the image cannot be opened.

#### Response Example
```rust
// Successful opening returns a PhotonImage
let img: PhotonImage = open_image("path/to/your/image.png").unwrap();

// Failed opening returns an Error
// let error: Error = open_image("nonexistent/image.jpg").unwrap_err();
```
```

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

### Desaturate an image using desaturate_hsv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.desaturate_hsv.html

Demonstrates how to open an image and apply a 10% desaturation in the HSV color space.

```rust
// For example to desaturate an image by 10% in the HSV colour space:
use photon_rs::colour_spaces::desaturate_hsv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
desaturate_hsv(&mut img, 0.1_f32);
```

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

### Flip an image vertically using photon_rs

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.flipv.html

Demonstrates how to open an image and apply a vertical flip transformation.

```rust
// For example, to flip an image vertically:
use photon_rs::native::open_image;
use photon_rs::transform::flipv;

let mut img = open_image("img.jpg").expect("File should open");
flipv(&mut img);
```

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

### Apply padding to the right side of an image

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.padding_right.html

Demonstrates how to import the necessary modules and apply 10 pixels of padding with a specific RGBA color to an image.

```rust
// For example, to apply a padding of 10 pixels on the right side of a PhotonImage:
use photon_rs::transform::padding_right;
use photon_rs::native::open_image;
use photon_rs::Rgba;

let mut img = open_image("img.jpg").expect("File should open");
let rgba = Rgba::new(200_u8, 100_u8, 150_u8, 255_u8);
padding_right(&img, 10_u32, rgba);
```

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

### Increase image saturation using saturate_hsv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.saturate_hsv.html

Demonstrates how to open an image and apply a 30% saturation increase in the HSV colour space.

```rust
// For example to increase saturation by 30% in the HSV colour space:
use photon_rs::colour_spaces::saturate_hsv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
saturate_hsv(&mut img, 0.3_f32);
```

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

### Apply monochrome effect to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.monochrome.html

Demonstrates how to import the monochrome function and apply it to a loaded PhotonImage with specific channel offsets.

```rust
// For example, to apply a monochrome effect to an image:
use photon_rs::monochrome::monochrome;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
monochrome(&mut img, 40_u32, 50_u32, 100_u32);
```

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

### Apply Gamma Correction to a PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.gamma_correction.html

Demonstrates how to load an image and apply gamma correction using the gamma_correction function.

```rust
// For example, to turn an image of type `PhotonImage` into a gamma corrected image:
use photon_rs::colour_spaces::gamma_correction;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
gamma_correction(&mut img, 2.2, 2.2, 2.2);
```

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

### Apply firenze filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.firenze.html

Demonstrates applying the firenze filter to a loaded image using the photon_rs library.

```Rust
use photon_rs::filters::firenze;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
firenze(&mut img);
```

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

### Increase saturation using saturate_hsl

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.saturate_hsl.html

Demonstrates how to open an image and apply a 10% saturation increase using the HSL color space.

```rust
// For example to increase saturation by 10% in the HSL colour space:
use photon_rs::colour_spaces::saturate_hsl;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
saturate_hsl(&mut img, 0.1_f32);
```

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

### Convert PhotonImage to bytes

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.image_to_bytes.html

Demonstrates the conversion of an opened image file into a byte vector using the native module.

```rust
use photon_rs::native::{open_image,image_to_bytes};

let img = open_image("img.jpg").expect("File should open");
// Save the image at a vec<u8>
let byt = image_to_bytes(img);
```

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

### Apply horizontal strips effect in Rust

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.horizontal_strips.html

Demonstrates how to open an image and apply the horizontal_strips effect using a specified number of strips.

```rust
// For example, to draw horizontal strips on a `PhotonImage`:
use photon_rs::effects::horizontal_strips;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
horizontal_strips(&mut img, 8u8);
```

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

### Apply red channel offset to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.offset_red.html

Demonstrates how to load an image and apply a 30-pixel offset to its red channel.

```rust
// For example, to add an offset to the red channel by 30 pixels.
use photon_rs::effects::offset_red;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
offset_red(&mut img, 30_u32);
```

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

### Compress an image using photon-rs

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.compress.html

Use this function to compress an image to a specified quality level. Requires opening the image first.

```rust
use photon_rs::native::open_image;
use photon_rs::transform::compress;

let image = open_image("img.jpg").expect("File should open");

let compressed_image = compress(&image, 50);
```

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

### Apply a filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.filter.html

Demonstrates how to load an image and apply the 'vintage' filter using the filter function.

```rust
// For example, to add a filter called "vintage" to an image:
use photon_rs::filters::filter;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
filter(&mut img, "vintage");
```

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

### Apply dramatic filter to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.dramatic.html

Demonstrates how to import the dramatic filter and apply it to an image opened from the local filesystem.

```rust
use photon_rs::filters::dramatic;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
dramatic(&mut img);
```

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

### Apply horizontal strips to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.color_horizontal_strips.html

Demonstrates how to apply horizontal strips to a PhotonImage using a specified RGB color.

```rust
// For example, to draw blue horizontal strips on a `PhotonImage`:
use photon_rs::effects::color_horizontal_strips;
use photon_rs::native::open_image;
use photon_rs::Rgb;

let color = Rgb::new(255u8, 0u8, 0u8);
let mut img = open_image("img.jpg").expect("File should open");
color_horizontal_strips(&mut img, 8u8, color);
```

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

### Darken an image using darken_hsluv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.darken_hsluv.html

Demonstrates how to darken a PhotonImage by 10% using the HSLuv colour space. Requires importing the function and the image opening utility.

```rust
// For example to darken an image by 10% in the HSLuv colour space:
use photon_rs::colour_spaces::darken_hsluv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
darken_hsluv(&mut img, 0.1_f32);
```

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

### General Conversion Utilities

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgb.html

A collection of utility methods for various types of conversions, including approximate, into, try_into, and value conversions.

```APIDOC
## impl<T, Dst> ConvAsUtil<Dst> for T

### Description
Provides utility methods for converting a type `T` into a destination type `Dst`.

### Methods

#### `approx(self) -> Result<Dst, Self::Err>`
Approximates the subject with the default scheme.
- **Returns**: A `Result` containing the approximated value or an error.

#### `approx_by<Scheme>(self) -> Result<Dst, Self::Err>`
Approximates the subject with a specific scheme.
- **Scheme**: The approximation scheme to use.
- **Returns**: A `Result` containing the approximated value or an error.

## impl<T> ConvUtil for T

### Description
Provides utility methods for converting a type `T` into other types.

### Methods

#### `approx_as<Dst>(self) -> Result<Dst, Self::Err>`
Approximates the subject to a given type with the default scheme.
- **Dst**: The destination type.
- **Returns**: A `Result` containing the approximated value or an error.

#### `approx_as_by<Dst, Scheme>(self) -> Result<Dst, Self::Err>`
Approximates the subject to a given type with a specific scheme.
- **Dst**: The destination type.
- **Scheme**: The approximation scheme to use.
- **Returns**: A `Result` containing the approximated value or an error.

#### `into_as<Dst>(self) -> Dst`
Converts the subject to a given type.
- **Dst**: The destination type.

#### `try_as<Dst>(self) -> Result<Dst, Self::Err>`
Attempts to convert the subject to a given type.
- **Dst**: The destination type.
- **Returns**: A `Result` containing the converted value or an error.

#### `value_as<Dst>(self) -> Result<Dst, Self::Err>`
Attempts a value conversion of the subject to a given type.
- **Dst**: The destination type.
- **Returns**: A `Result` containing the converted value or an error.

```

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

### Function open_dyn_image

Source: https://docs.rs/photon-rs/latest/photon_rs/helpers/fn.open_dyn_image.html

Opens a dynamic image from a given file path.

```APIDOC
## Function open_dyn_image

### Description
Opens a dynamic image from the specified file path.

### Signature
```rust
pub fn open_dyn_image(img_path: &'static str) -> DynamicImage
```

### Parameters
#### Path Parameters
- **img_path** (string) - Required - The static string path to the image file.

### Returns
- **DynamicImage** - The opened dynamic image.
```

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

### Color Adaptation Utilities

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgb.html

Provides methods for adapting colors between different color spaces, with options for specific transformation matrices or default methods.

```APIDOC
## impl<S, D, Swp, Dwp, T> AdaptInto<D, Swp, Dwp, T> for S

### Description
Provides methods for adapting colors between different color spaces.

### Methods

#### `adapt_into_using<M>(self, method: M) -> D`
Converts the source color to the destination color using the specified method.

- **method** (M): The transformation matrix to use for adaptation.

#### `adapt_into(self) -> D`
Converts the source color to the destination color using the Bradford method by default.

```

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

### Rgb Struct Methods

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.Rgb.html

Methods for creating and interacting with the Rgb struct.

```APIDOC
## Rgb Struct Methods

### Description
Methods to initialize and modify RGB color components.

### Methods
- **new(r: u8, g: u8, b: u8) -> Rgb**: Create a new RGB struct.
- **set_red(r: u8)**: Set the Red value.
- **set_green(g: u8)**: Set the Green value.
- **set_blue(b: u8)**: Set the Blue value.
- **get_red() -> u8**: Get the Red value.
- **get_green() -> u8**: Get the Green value.
- **get_blue() -> u8**: Get the Blue value.
```

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

### Desaturate Image using Photon-RS

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.desaturate.html

Use this function to desaturate an image. Ensure you have the `photon_rs` crate imported and an image opened using `open_image`.

```rust
use photon_rs::monochrome::desaturate;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
desaturate(&mut img);
```

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

### Serialize for PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Serialization support for the PhotonImage struct using Serde.

```APIDOC
## serialize

### Description
Serializes the PhotonImage instance into a given Serde serializer.

### Parameters
#### Request Body
- **__serializer** (Serializer) - Required - The serializer to use for the conversion.

### Response
#### Success Response (200)
- **Result<__S::Ok, __S::Error>** - Returns the result of the serialization process.
```

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

### Apply uniform padding to an image

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.padding_uniform.html

Use this function to add uniform padding around a PhotonImage. Ensure the image file exists and is accessible.

```rust
use photon_rs::transform::padding_uniform;
use photon_rs::native::open_image;
use photon_rs::Rgba;

let mut img = open_image("img.jpg").expect("File should open");
let rgba = Rgba::new(200_u8, 100_u8, 150_u8, 255_u8);
padding_uniform(&img, 10_u32, rgba);
```

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

### Lighten an image using lighten_hsv

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.lighten_hsv.html

Demonstrates how to open an image and apply a 10% lightening effect using the HSV color space.

```rust
// For example to lighten an image by 10% in the HSV colour space:
use photon_rs::colour_spaces::lighten_hsv;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
lighten_hsv(&mut img, 0.1_f32);
```

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

### Create Gradient Image

Source: https://docs.rs/photon-rs/latest/photon_rs/multiple/fn.create_gradient.html

Use this function to create a new PhotonImage with a gradient. Specify the desired width and height.

```rust
pub fn create_gradient(width: u32, height: u32) -> PhotonImage
```

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

### Apply padding to PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.padding_top.html

Use this function to add padding to the top of an image. Ensure the image is opened and RGBA values are correctly defined.

```rust
use photon_rs::transform::padding_top;
use photon_rs::native::open_image;
use photon_rs::Rgba;

let mut img = open_image("img.jpg").expect("File should open");
let rgba = Rgba::new(200_u8, 100_u8, 150_u8, 255_u8);
padding_top(&img, 10_u32, rgba);
```

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

### Save Image to Filesystem

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.save_image.html

Use this function to save a PhotonImage to a specified file path. Ensure the image object is valid and the path is accessible.

```rust
use photon_rs::native::{open_image, save_image};

let img = open_image("img.jpg").expect("File should open");
// Save the image at the given path.
save_image(img,"manipulated_image.jpg").expect("Save failed");
```

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

### Apply Solarizing Effect with solarize_retimg

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.solarize_retimg.html

Applies a solarizing effect to a PhotonImage. Requires opening the image first.

```rust
use photon_rs::effects::solarize_retimg;
use photon_rs::native::open_image;
use photon_rs::PhotonImage;

let img = open_image("img.jpg").expect("File should open");
let result: PhotonImage = solarize_retimg(&img);
```

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

### Shear an image along the X axis

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.shearx.html

Demonstrates how to load an image and apply an X-axis shear transformation using the shearx function.

```rust
// For example, to shear an image by 0.5:
use photon_rs::native::open_image;
use photon_rs::transform::shearx;

let img = open_image("img.jpg").expect("File should open");
let sheared_img = shearx(&img, 0.5);
```

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

### Draw text on an image

Source: https://docs.rs/photon-rs/latest/photon_rs/text/fn.draw_text.html

Demonstrates how to open an image and apply text using the draw_text function.

```rust
// For example to draw the string "Welcome to Photon!" at 10, 10:
use photon_rs::native::open_image;
use photon_rs::text::draw_text;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
draw_text(&mut img, "Welcome to Photon!", 10_i32, 10_i32, 90_f32);
```

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

### Convert Image to Grayscale with photon-rs

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.b_grayscale.html

Use this function to convert an image to grayscale. Ensure you have opened the image using `open_image` before calling this function.

```rust
use photon_rs::monochrome::b_grayscale;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
b_grayscale(&mut img);
```

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

### Lighten an image using lighten_lch

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.lighten_lch.html

Demonstrates how to open an image and apply the lighten_lch transformation with a 10% intensity.

```rust
// For example to lighten an image by 10% in the LCh colour space:
use photon_rs::colour_spaces::lighten_lch;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
lighten_lch(&mut img, 0.1_f32);
```

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

### TryFrom and TryInto

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Facilitates fallible conversions between types, returning a Result.

```APIDOC
## TryFrom<Src> for Src

### Description
Defines fallible conversion from a source type `Src` to itself.

### Type Alias
`Err` - The error type produced by a failed conversion (`NoError`).

### Method
`try_from(src: Src) -> Result<Src, <Src as TryFrom<Src>>::Err>`

### Endpoint
N/A (Trait method)

### Parameters
- **src** (Src) - The source value to convert.

### Request Body
None

### Response
- **Result<Src, Err>** - The result of the conversion.

## TryFrom<U> for T

### Description
Defines fallible conversion from a source type `U` to a target type `T`.

### Type Alias
`Error` - The error type produced by a failed conversion (`Infallible`).

### Method
`try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### Endpoint
N/A (Trait method)

### Parameters
- **value** (U) - The value to convert.

### Request Body
None

### Response
- **Result<T, Error>** - The result of the conversion.

## TryInto<Dst> for Src

### Description
Defines fallible conversion from a source type `Src` to a destination type `Dst`.

### Type Alias
`Err` - The error type produced by a failed conversion.

### Method
`try_into(self) -> Result<Dst, <Src as TryInto<Dst>>::Err>`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
- **Result<Dst, Err>** - The result of the conversion.

## TryInto<U> for T

### Description
Defines fallible conversion from a source type `T` to a target type `U`.

### Type Alias
`Error` - The error type produced by a failed conversion.

### Method
`try_into(self) -> Result<U, <U as TryFrom<T>>::Error>`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
- **Result<U, Error>** - The result of the conversion.
```

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

### Apply Frosted Glass Effect

Source: https://docs.rs/photon-rs/latest/photon_rs/effects/fn.frosted_glass.html

Applies a frosted glass effect to a PhotonImage. Requires an existing PhotonImage instance.

```rust
// For example, to turn an image of type `PhotonImage` into frosted glass see through:
use photon_rs::effects::frosted_glass;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
frosted_glass(&mut img);
```

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

### From Trait Implementation

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/enum.SamplingFilter.html

Provides a way to create an instance of a type from another type.

```APIDOC
## impl<T> From<T> for T

### Description
Provides a way to create an instance of a type from another type.

#### fn from(t: T) -> T

### Description
Returns the argument unchanged.

### Method
N/A (Associated function)

### Endpoint
N/A

### Parameters
- **t** (T) - The value to convert from.

### Request Example
N/A

### Response
#### Success Response (T)
- **T**: The created value.

#### Response Example
N/A
```

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

### open_image_from_bytes

Source: https://docs.rs/photon-rs/latest/photon_rs/native/fn.open_image_from_bytes.html

Loads an image from a byte slice and returns a PhotonImage object.

```APIDOC
## FUNCTION open_image_from_bytes

### Description
Saves an image from a byte slice. A PhotonImage is returned.

### Parameters
#### Arguments
- **buffer** (&[u8]) - Required - A byte slice containing the image you want to edit.

### Request Example
```rust
use photon_rs::native::open_image_from_bytes;
let buffer = std::fs::read("img.jpg").expect("File Should Open");
let img = open_image_from_bytes(buffer.as_slice()).expect("Buffer should be valid");
```

### Response
- **PhotonImage** (Object) - The resulting image object ready for editing.
```

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

### Apply LCh colour space effects

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.lch.html

Demonstrates how to import the lch function and apply a saturation effect to a loaded image.

```rust
// For example to increase the saturation by 10%:
use photon_rs::colour_spaces::lch;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
lch(&mut img, "saturate", 0.1_f32);
```

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

### ValueFrom and ValueInto Conversions

Source: https://docs.rs/photon-rs/latest/photon_rs/native/enum.Error.html

Methods for converting between types where the conversion is guaranteed to be exact and lossless.

```APIDOC
## `ValueFrom<Src>` for `Dst`

### Description
Provides a method to convert a source type `Src` into a destination type `Dst` with an exact and equivalent representation.

### Associated Types
- `Err`: The error type produced by a failed conversion (e.g., `NoError`).

### Method

#### `value_from(src: Src) -> Result<Dst, Self::Err>`
Converts the given value `src` into an exactly equivalent representation of type `Dst`.
```

```APIDOC
## `ValueInto<Dst>` for `Src`

### Description
Provides a method to convert a source type `Src` into a destination type `Dst` with an exact and equivalent representation, leveraging the `ValueFrom` trait.

### Associated Types
- `Err`: The error type produced by a failed conversion, aliased from `Dst::Err`.

### Method

#### `value_into(self) -> Result<Dst, Self::Err>`
Converts the subject `self` into an exactly equivalent representation of type `Dst`.
```

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

### Convert Image to Grayscale with photon-rs

Source: https://docs.rs/photon-rs/latest/photon_rs/monochrome/fn.g_grayscale.html

Use this function to convert an image to grayscale. Ensure the image is opened using `open_image` before calling `g_grayscale`.

```rust
use photon_rs::monochrome::g_grayscale;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
g_grayscale(&mut img);
```

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

### Darken an image using darken_lch

Source: https://docs.rs/photon-rs/latest/photon_rs/colour_spaces/fn.darken_lch.html

Demonstrates how to darken an image by 10% using the LCh colour space. Requires an existing PhotonImage instance.

```rust
// For example to darken an image by 10% in the LCh colour space:
use photon_rs::colour_spaces::darken_lch;
use photon_rs::native::open_image;

// Open the image. A PhotonImage is returned.
let mut img = open_image("img.jpg").expect("File should open");
darken_lch(&mut img, 0.1_f32);
```

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

### TryFromJsValue for PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Methods for converting a JavaScript value into a PhotonImage instance.

```APIDOC
## try_from_js_value

### Description
Performs the conversion from a JsValue to a PhotonImage.

### Parameters
#### Request Body
- **value** (JsValue) - Required - The JavaScript value to convert.

### Response
#### Success Response (200)
- **Result<Self, JsValue>** - Returns the converted PhotonImage or an error.

## try_from_js_value_ref

### Description
Performs the conversion from a reference to a JsValue to an Option containing a PhotonImage.

### Parameters
#### Request Body
- **value** (&JsValue) - Required - The reference to the JavaScript value to convert.

### Response
#### Success Response (200)
- **Option<Self>** - Returns the PhotonImage if conversion is successful.
```

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

### Sharpen an image using photon-rs

Source: https://docs.rs/photon-rs/latest/photon_rs/conv/fn.sharpen.html

Use this function to sharpen an image. Ensure you have opened the image using `open_image` before calling `sharpen`.

```rust
use photon_rs::conv::sharpen;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
sharpen(&mut img);
```

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

### run function

Source: https://docs.rs/photon-rs/latest/photon_rs/fn.run.html

The run function checks if WebAssembly (WASM) is supported in the current environment.

```APIDOC
## run

### Description
Checks if WASM is supported in the current environment.

### Signature
`pub fn run() -> Result<(), JsValue>`
```

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

### Apply Neue Filter to Image

Source: https://docs.rs/photon-rs/latest/photon_rs/filters/fn.neue.html

Use the `neue` function to apply solarization to the blue channel of a PhotonImage. Ensure the image is opened successfully before applying the filter.

```rust
use photon_rs::filters::neue;
use photon_rs::native::open_image;

let mut img = open_image("img.jpg").expect("File should open");
neue(&mut img);
```

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

### ValueFrom and ValueInto

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Provides methods for converting values into an exactly equivalent representation.

```APIDOC
## ValueFrom<Src> for Src

### Description
Defines conversion from a source type `Src` to itself, ensuring an exactly equivalent representation.

### Type Alias
`Err` - The error type produced by a failed conversion (`NoError`).

### Method
`value_from(src: Src) -> Result<Src, <Src as ValueFrom<Src>>::Err>`

### Endpoint
N/A (Trait method)

### Parameters
- **src** (Src) - The source value to convert.

### Request Body
None

### Response
- **Result<Src, Err>** - The result of the conversion.

## ValueInto<Dst> for Src

### Description
Defines conversion from a source type `Src` to a destination type `Dst`, ensuring an exactly equivalent representation.

### Type Alias
`Err` - The error type produced by a failed conversion.

### Method
`value_into(self) -> Result<Dst, <Src as ValueInto<Dst>>::Err>`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
- **Result<Dst, Err>** - The result of the conversion.
```

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

### Apply padding to PhotonImage

Source: https://docs.rs/photon-rs/latest/photon_rs/transform/fn.padding_bottom.html

Use this function to add padding to the bottom of a PhotonImage. Ensure you have opened the image and defined the RGBA color for the padding.

```rust
use photon_rs::transform::padding_bottom;
use photon_rs::native::open_image;
use photon_rs::Rgba;

let mut img = open_image("img.jpg").expect("File should open");
let rgba = Rgba::new(200_u8, 100_u8, 150_u8, 255_u8);
padding_bottom(&img, 10_u32, rgba);
```

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

### ReturnWasmAbi

Source: https://docs.rs/photon-rs/latest/photon_rs/struct.PhotonImage.html

Handles returning values with Wasm ABI, potentially panicking instead of returning an error.

```APIDOC
## ReturnWasmAbi for T

### Description
Implements Wasm ABI return behavior for types that implement `IntoWasmAbi`.

### Type Alias
`Abi` - Alias for `<T as IntoWasmAbi>::Abi`.

### Method
`return_abi(self)`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
- **Abi** (type) - The Wasm ABI representation of the value.
```

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

### Open a dynamic image in Rust

Source: https://docs.rs/photon-rs/latest/photon_rs/helpers/fn.open_dyn_image.html

Use this function to load an image from a static file path into a DynamicImage structure.

```rust
pub fn open_dyn_image(img_path: &'static str) -> DynamicImage
```
Tokens:
Raw