Kornia-rs

https://docs.rs/kornia/latest/
Admin
Kornia-rs is a low-level computer vision library written in Rust, designed for efficient and...
Tokens:1,214,151
Snippets:10,796
Trust Score:9.7
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Output for Kornia-rs Image Loading

Source: https://docs.rs/kornia/latest/kornia?search=

This is the expected console output when running the 'Getting Started' example.

```text
Hello, world! 🦀
Loaded Image size: ImageSize { width: 258, height: 195 }

Goodbyte!
```

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

### threshold_to_zero Example Usage

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_to_zero.html?search=

An example demonstrating how to use the threshold_to_zero function to threshold an image and assert its properties.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_to_zero;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 3, _>::new(ImageSize { width: 2, height: 1 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 3, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_to_zero(&image, &mut thresholded, 150).unwrap();
assert_eq!(thresholded.num_channels(), 3);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 1);

```

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

### Example Usage of read_image_metadata

Source: https://docs.rs/kornia/latest/kornia/io/metadata/fn.read_image_metadata.html?search=

Demonstrates how to use `read_image_metadata` to get image metadata and check for EXIF orientation. Ensure the `kornia_io::metadata` module is imported.

```rust
use kornia_io::metadata::read_image_metadata;

let metadata = read_image_metadata("photo.jpg")?;
if let Some(orientation) = metadata.exif_orientation {
    println!("Orientation: {}", orientation.get());
}

```

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

### Example Usage of find_min_max

Source: https://docs.rs/kornia/latest/kornia/imgproc/normalize/fn.find_min_max.html?search=std%3A%3Avec

Demonstrates how to use the `find_min_max` function to get the minimum and maximum values from an image. Ensure you have the necessary imports and image data initialized.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::normalize::find_min_max;

let image_data = vec![0u8, 1, 0, 1, 2, 3, 0, 1, 0, 1, 2, 3];
let image = Image::<u8, 3, _>::new(
  ImageSize {
    width: 2,
    height: 2,
  },
  image_data,
  CpuAllocator
)
.unwrap();

let (min, max) = find_min_max(&image).unwrap();
assert_eq!(min, 0);
assert_eq!(max, 3);

```

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

### Install Rust using rustup

Source: https://docs.rs/kornia/latest/kornia/index.html?search=

Installs Rust and the rustup toolchain manager. This is a prerequisite for many development tasks.

```shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

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

### Getting Started with Kornia-rs Image Reading

Source: https://docs.rs/kornia/latest/kornia/index.html?search=

Demonstrates how to read an image file using kornia's IO functionality and print its dimensions. Ensure you have an image file at the specified path.

```rust
use kornia::image::Image;
use kornia::io::functional as F;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // read the image
    let image: Image<u8, 3> = F::read_image_any_rgb8("tests/data/dog.jpeg")?;

    println!("Hello, world! 🦀");
    println!("Loaded Image size: {:?}", image.size());
    println!("\nGoodbyte!");

    Ok(())
}
```

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

### Install Rust using rustup

Source: https://docs.rs/kornia/latest/index.html

Installs Rust and the rustup toolchain manager. This is a prerequisite for building the kornia-rs project.

```shell
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

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

### Traditional API Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/index.html?search=

Illustrates the traditional API for color space conversions using direct function calls, maintaining backward compatibility. This example shows converting an RGB image to grayscale.

```APIDOC
## Traditional API (Backward Compatible)

Direct function calls are still available:

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::color::gray_from_rgb;

let rgb = Image::<f32, 3, _>::new(
    ImageSize { width: 4, height: 5 },
    vec![0.5f32; 4 * 5 * 3],
    CpuAllocator
)?;

let mut gray = Image::<f32, 1, _>::from_size_val(rgb.size(), 0.0, CpuAllocator)?;
gray_from_rgb(&rgb, &mut gray)?;
```
```

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

### Example Usage of threshold_truncate

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_truncate.html?search=

This example demonstrates how to use the threshold_truncate function. It creates an input image, an output image, applies the threshold, and asserts the properties of the output image.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_truncate;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 1, _>::new(ImageSize { width: 2, height: 3 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 1, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_truncate(&image, &mut thresholded, 150).unwrap();
assert_eq!(thresholded.num_channels(), 1);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 3);

```

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

### Vertical Flip Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/flip/fn.vertical_flip.html?search=std%3A%3Avec

An example demonstrating how to use the vertical_flip function to flip an image. Ensure the input and output images have the same dimensions.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::flip::vertical_flip;

let image = Image::<f32, 3, _>::new(
    ImageSize {
        width: 2,
        height: 3,
    },
    vec![0f32; 2 * 3 * 3],
    CpuAllocator,
)
.unwrap();

let mut flipped = Image::<f32, 3, _>::from_size_val(image.size(), 0.0, CpuAllocator).unwrap();

vertical_flip(&image, &mut flipped).unwrap();

```

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

### Install Kornia-rs Python Package

Source: https://docs.rs/kornia/latest/kornia/index.html?search=

Use pip to install the kornia-rs Python package. Note that only a subset of the Rust API is exposed.

```python
pip install kornia-rs
```

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

### Example Usage of hsv_from_rgb

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/fn.hsv_from_rgb.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the `hsv_from_rgb` function to convert an RGB image to an HSV image. It includes image creation, function call, and assertions to verify the output.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::color::hsv_from_rgb;

let image = Image::<f32, 3, _>::new(
    ImageSize {
       width: 4,
       height: 5,
    },
    vec![0f32; 4 * 5 * 3],
    CpuAllocator
)
.unwrap();

let mut hsv = Image::<f32, 3, _>::from_size_val(image.size(), 0.0, CpuAllocator).unwrap();

hsv_from_rgb(&image, &mut hsv).unwrap();

assert_eq!(hsv.num_channels(), 3);
assert_eq!(hsv.size().width, 4);
assert_eq!(hsv.size().height, 5);

```

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

### Binary Thresholding Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_binary.html

Demonstrates how to apply a binary threshold to an image using kornia. Ensure the necessary imports are included and the image data is prepared correctly.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_binary;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 1, _>::new(ImageSize { width: 2, height: 3 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 1, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_binary(&image, &mut thresholded, 100, 255).unwrap();
assert_eq!(thresholded.num_channels(), 1);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 3);
```

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

### Rust Result and_then Example (File System)

Source: https://docs.rs/kornia/latest/kornia/linalg/rigid/type.UmeyamaResult.html

Demonstrates `and_then` for chaining fallible file system operations. It attempts to get metadata and then the modified time, handling potential errors like NotFound.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### Resizing an Image with resize_native

Source: https://docs.rs/kornia/latest/kornia/imgproc/resize/fn.resize_native.html?search=u32+-%3E+bool

Example demonstrating how to use the resize_native function to resize an image. It shows the creation of an input image, defining a new size, creating an output image container, and performing the resize operation with nearest neighbor interpolation.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::resize::resize_native;
use kornia_imgproc::interpolation::InterpolationMode;

let image = Image::<_, 3, _>::new(
    ImageSize {
        width: 4,
        height: 5,
    },
    vec![0f32; 4 * 5 * 3],
    CpuAllocator
)
.unwrap();

let new_size = ImageSize {
    width: 2,
    height: 3,
};

let mut image_resized = Image::<_, 3, _>::from_size_val(new_size, 0.0, CpuAllocator).unwrap();

resize_native(
    &image,
    &mut image_resized,
    InterpolationMode::Nearest,
)
.unwrap();

assert_eq!(image_resized.num_channels(), 3);
assert_eq!(image_resized.size().width, 2);
assert_eq!(image_resized.size().height, 3);

```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Rgba8.html?search=u32+-%3E+bool

Get an element at the specified index with bounds checking.

```APIDOC
## get

### Description
Get an element at the specified index with bounds checking.

### Method
`&self`

### Parameters
#### Path Parameters
- `index` (array of usize) - Required - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Rgbaf32.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get an element at a given index with bounds checking.

```APIDOC
## pub fn get(&self, index: [usize; N]) -> Option<&T>

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
  * `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Inverse Binary Thresholding Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_binary_inverse.html

Demonstrates how to use `threshold_binary_inverse` to apply an inverse binary threshold to a 1-channel image. Ensure the necessary imports are included.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_binary_inverse;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 1, _>::new(ImageSize { width: 2, height: 3 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 1, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_binary_inverse(&image, &mut thresholded, 100, 255).unwrap();
assert_eq!(thresholded.num_channels(), 1);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 3);
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Bgraf64.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get a reference to an element at the specified index with bounds checking.

```APIDOC
## get

### Description
Get a reference to an element at the specified index with bounds checking.

### Method
`&self` (implicitly a getter method)

### Arguments
#### Path Parameters
- **index** (`[usize; N]`) - Required - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Bgrf32.html?search=std%3A%3Avec

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Method
`&self`

### Arguments
* `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### CpuAllocator Usage Example

Source: https://docs.rs/kornia/latest/kornia/image/allocator/struct.CpuAllocator.html

Demonstrates how to create a tensor using CpuAllocator.

```APIDOC
## CpuAllocator Usage Example

### Description
This example shows how to instantiate a `Tensor` with `f32` data type and 2 dimensions using `CpuAllocator`.

### Code
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let tensor = Tensor::<f32, 2, _>::zeros([10, 10], CpuAllocator);
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Bgr8.html?search=std%3A%3Avec

Get the element at the given multi-dimensional index with bounds checking.

```APIDOC
## get

### Description
Get the element at the given multi-dimensional index with bounds checking.

### Arguments
  * `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Example Usage of resize_fast_rgb

Source: https://docs.rs/kornia/latest/kornia/imgproc/resize/fn.resize_fast_rgb.html?search=u32+-%3E+bool

Demonstrates how to use the `resize_fast_rgb` function to resize a 3-channel u8 image. It includes setting up the source and destination images, specifying the new size, and performing the resize operation with nearest-neighbor interpolation. Asserts are included to verify the dimensions of the resized image.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::resize::resize_fast_rgb;
use kornia_imgproc::interpolation::InterpolationMode;

let image = Image::<_, 3, _>::new(
    ImageSize { 
        width: 4,
        height: 5,
    },
    vec![0u8; 4 * 5 * 3],
    CpuAllocator
)
.unwrap();

let new_size = ImageSize {
  width: 2,
  height: 3,
};

let mut image_resized = Image::<_, 3, _>::from_size_val(new_size, 0, CpuAllocator).unwrap();

resize_fast_rgb(
  &image,
  &mut image_resized,
  InterpolationMode::Nearest,
)
.unwrap();

assert_eq!(image_resized.num_channels(), 3);
assert_eq!(image_resized.size().width, 2);
assert_eq!(image_resized.size().height, 3);
```

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

### Resize Fast RGB Image Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/resize/fn.resize_fast_rgb.html

Demonstrates how to resize a 3-channel u8 image using the resize_fast_rgb function with Nearest interpolation. Ensure the necessary imports are included.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::resize::resize_fast_rgb;
use kornia_imgproc::interpolation::InterpolationMode;

let image = Image::<_, 3, _>::new(
    ImageSize {
        width: 4,
        height: 5,
    },
    vec![0u8; 4 * 5 * 3],
    CpuAllocator
)
.unwrap();

let new_size = ImageSize {
  width: 2,
  height: 3,
};

let mut image_resized = Image::<_, 3, _>::from_size_val(new_size, 0, CpuAllocator).unwrap();

resize_fast_rgb(
  &image,
  &mut image_resized,
  InterpolationMode::Nearest,
)
.unwrap();

assert_eq!(image_resized.num_channels(), 3);
assert_eq!(image_resized.size().width, 2);
assert_eq!(image_resized.size().height, 3);
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/image/struct.Image.html?search=

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Method
`&self`

### Parameters
#### Arguments
- `index` ([usize; N]) - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### RGB from RGBA Conversion Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/fn.rgb_from_rgba.html?search=

Demonstrates how to convert an RGBA image to an RGB image using the `rgb_from_rgba` function. Ensure input and output images have the correct channel counts and dimensions.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::color::rgb_from_rgba;

let src = Image::<u8, 4, CpuAllocator>::new(ImageSize { width: 3, height: 2 }, vec![
    0, 1, 2, 255, // (0, 0)
    3, 4, 5, 255, // (0, 1)
    6, 7, 8, 255, // (0, 2)
    9, 10, 11, 255, // (1, 0)
    12, 13, 14, 255, // (1, 1)
    15, 16, 17, 255, // (1, 2)
], CpuAllocator).unwrap();

let mut dst = Image::<u8, 3, CpuAllocator>::new(ImageSize { width: 3, height: 2 }, vec![0; 18], CpuAllocator).unwrap();

rgb_from_rgba(&src, &mut dst, None).unwrap();

```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Rgba8.html?search=u32+-%3E+bool

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Method
`&self`

### Parameters
#### Path Parameters
- **index** (array of usize) - Required - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Grayf32.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Get an element at a given multi-dimensional index with bounds checking.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Method
`&self`

### Parameters
#### Path Parameters
- `index` (array of usize) - Required - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Crop Image Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/crop/fn.crop_image.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to crop an image using the crop_image function. Ensure the source and destination images are properly initialized and the coordinates are within bounds.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::crop::crop_image;

let image = Image::<_, 1, _>::new(ImageSize { width: 4, height: 4 }, vec![
    0u8, 1, 2, 3,
    4u8, 5, 6, 7,
    8u8, 9, 10, 11,
    12u8, 13, 14, 15
], CpuAllocator).unwrap();

let mut cropped = Image::<_, 1, _>::from_size_val(ImageSize { width: 2, height: 2 }, 0u8, CpuAllocator).unwrap();

crop_image(&image, &mut cropped, 1, 1).unwrap();

assert_eq!(cropped.as_slice(), &[5u8, 6, 9, 10]);

```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Bgrf32.html?search=

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
- `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```

### Method Signature
`pub fn get(&self, index: [usize; N]) -> Option<&T>`
```

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

### Applying Inverse Binary Threshold

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_binary_inverse.html?search=

Example demonstrating how to use the threshold_binary_inverse function. It initializes an image, creates a destination image, applies the threshold, and asserts properties of the result.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_binary_inverse;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 1, _>::new(ImageSize { width: 2, height: 3 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 1, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_binary_inverse(&image, &mut thresholded, 100, 255).unwrap();
assert_eq!(thresholded.num_channels(), 1);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 3);

```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Bgraf32.html?search=u32+-%3E+bool

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
  * `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Example Usage of threshold_binary

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_binary.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use the threshold_binary function to apply a binary threshold to an image. Ensure you have the necessary kornia crates imported.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_binary;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 1, _>::new(ImageSize { width: 2, height: 3 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 1, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_binary(&image, &mut thresholded, 100, 255).unwrap();
assert_eq!(thresholded.num_channels(), 1);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 3);

```

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

### Rust Dot Product Kernel Example

Source: https://docs.rs/kornia/latest/kornia/tensor_ops/kernels/fn.dot_product1_kernel.html

Demonstrates how to use the `dot_product1_kernel` function to compute the dot product of two slices. Ensure slices have the same length to avoid errors.

```rust
use kornia_tensor_ops::kernels::dot_product1_kernel;

let a = [1.0, 2.0, 3.0];
let b = [4.0, 5.0, 6.0];
let result = dot_product1_kernel(&a, &b).unwrap();
assert_eq!(result, 32.0); // (1*4) + (2*5) + (3*6) = 32
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Bgra16.html?search=std%3A%3Avec

Get the element at the given index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
* `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Bgr16.html?search=

Get a reference to an element at the given index with bounds checking.

```APIDOC
## get

### Description
Get a reference to an element at the given index, checking if the index is out of bounds.

### Method
`&self`

### Parameters
#### Arguments
- `index` ([usize; N]) - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```rust
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Example Usage of dot_product1_kernel

Source: https://docs.rs/kornia/latest/kornia/tensor_ops/kernels/fn.dot_product1_kernel.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to use `dot_product1_kernel` to compute the dot product of two float slices and asserts the expected result.

```rust
use kornia_tensor_ops::kernels::dot_product1_kernel;

let a = [1.0, 2.0, 3.0];
let b = [4.0, 5.0, 6.0];
let result = dot_product1_kernel(&a, &b).unwrap();
assert_eq!(result, 32.0); // (1*4) + (2*5) + (3*6) = 32

```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Bgra16.html?search=

Get a reference to an element at a given index with bounds checking.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
  * `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```

```

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

### Creating and Asserting ImageSize

Source: https://docs.rs/kornia/latest/kornia/image/image/struct.ImageSize.html?search=std%3A%3Avec

Demonstrates how to create an ImageSize instance and assert its width and height values.

```rust
use kornia_image::ImageSize;

let image_size = ImageSize {
  width: 10,
  height: 20,
};

assert_eq!(image_size.width, 10);
assert_eq!(image_size.height, 20);

```

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

### AlignedAllocator Example

Source: https://docs.rs/kornia/latest/kornia/tensor/allocator/trait.TensorAllocator.html?search=std%3A%3Avec

Example of implementing a custom TensorAllocator with guaranteed alignment.

```APIDOC
## Example: Implementing a custom allocator

```rust
use std::alloc::Layout;
use kornia_tensor::{TensorAllocator, allocator::TensorAllocatorError};

#[derive(Clone)]
struct AlignedAllocator {
    alignment: usize,
}

impl TensorAllocator for AlignedAllocator {
    fn alloc(&self, layout: Layout) -> Result<*mut u8, TensorAllocatorError> {
        // Custom allocation with guaranteed alignment
        let aligned_layout = Layout::from_size_align(layout.size(), self.alignment)
            .map_err(TensorAllocatorError::LayoutError)?;

        let ptr = unsafe { std::alloc::alloc(aligned_layout) };
        if ptr.is_null() {
            return Err(TensorAllocatorError::NullPointer);
        }
        Ok(ptr)
    }

    fn dealloc(&self, ptr: *mut u8, layout: Layout) {
        if !ptr.is_null() {
            let aligned_layout = Layout::from_size_align(layout.size(), self.alignment)
                .unwrap();
            unsafe { std::alloc::dealloc(ptr, aligned_layout) }
        }
    }
}
```
```

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

### Install uv for Python dependency management

Source: https://docs.rs/kornia/latest/index.html

Installs uv, a fast Python package installer and dependency resolver. This tool is used for managing Python dependencies within the project.

```shell
curl -LsSf https://astral.sh/uv/install.sh | sh
```

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

### Creating and Asserting ImageSize

Source: https://docs.rs/kornia/latest/kornia/image/image/struct.ImageSize.html?search=u32+-%3E+bool

Demonstrates how to create an ImageSize instance and assert its width and height values.

```rust
use kornia_image::ImageSize;

let image_size = ImageSize {
  width: 10,
  height: 20,
};

assert_eq!(image_size.width, 10);
assert_eq!(image_size.height, 20);
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Rgba16.html

Get a reference to an element at a given multi-dimensional index with bounds checking.

```APIDOC
## get

### Description
Get a reference to an element at a given multi-dimensional index with bounds checking.

### Arguments
* `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index, or None if the index is out of bounds.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```

### Signature
`pub fn get(&self, index: [usize; N]) -> Option<&T>`
```

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

### Inverse Thresholding Example

Source: https://docs.rs/kornia/latest/kornia/imgproc/threshold/fn.threshold_to_zero_inverse.html

Demonstrates the usage of `threshold_to_zero_inverse` to process an image. It initializes an image, applies the inverse threshold, and asserts the properties of the resulting image.

```rust
use kornia_image::{Image, ImageSize};
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::threshold::threshold_to_zero_inverse;

let data = vec![100u8, 200, 50, 150, 200, 250];
let image = Image::<_, 3, _>::new(ImageSize { width: 2, height: 1 }, data, CpuAllocator).unwrap();

let mut thresholded = Image::<_, 3, _>::from_size_val(image.size(), 0, CpuAllocator).unwrap();

threshold_to_zero_inverse(&image, &mut thresholded, 150).unwrap();
assert_eq!(thresholded.num_channels(), 3);
assert_eq!(thresholded.size().width, 2);
assert_eq!(thresholded.size().height, 1);
```

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

### Create TensorStorage from Vec

Source: https://docs.rs/kornia/latest/kornia/tensor/storage/struct.TensorStorage.html

Demonstrates how to create a TensorStorage instance by moving data from a Vec. Requires importing TensorStorage and a CpuAllocator.

```rust
use kornia_tensor::{storage::TensorStorage, CpuAllocator};

let data = vec![1, 2, 3, 4, 5];
let storage = TensorStorage::from_vec(data, CpuAllocator);

assert_eq!(storage.as_slice(), &[1, 2, 3, 4, 5]);
assert!(!storage.is_empty());
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/struct.Grayf64.html?search=std%3A%3Avec

Get the element at the given multi-dimensional index, checking if the index is out of bounds.

```APIDOC
## get

### Description
Get the element at the given multi-dimensional index, checking if the index is out of bounds.

### Arguments
* `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Rgbaf32.html?search=

Get a reference to an element at a given multi-dimensional index with bounds checking.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
- `index` (array of usize): The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```
```

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

### Rust: Example of RGBf32 to Grayf32 Conversion

Source: https://docs.rs/kornia/latest/kornia/imgproc/color/trait.ConvertColor.html

Demonstrates converting an RGBf32 image to a Grayf32 image using the ConvertColor trait. Ensure necessary types and the trait are in scope.

```rust
use kornia_image::ImageSize;
use kornia_image::allocator::CpuAllocator;
use kornia_imgproc::color::{Rgbf32, Grayf32, ConvertColor};

let rgb = Rgbf32::from_size_vec(
    ImageSize { width: 4, height: 5 },
    vec![0.5f32; 4 * 5 * 3],
    CpuAllocator
).unwrap();

let mut gray = Grayf32::from_size_val(rgb.size(), 0.0, CpuAllocator).unwrap();

rgb.convert(&mut gray).unwrap();

```

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

### Rust: Applying spatial padding to an image

Source: https://docs.rs/kornia/latest/kornia/imgproc/padding/fn.spatial_padding.html

Demonstrates how to use the spatial_padding function to add a 1-pixel black border to a 2x2 RGB image, expanding it to a 4x4 size. This example requires setting up source and destination images with specified dimensions and allocators.

```rust
use kornia_image::{allocator::CpuAllocator, ImageSize, Image};
use kornia_imgproc::padding::{PaddingMode, Padding2D, spatial_padding};

// Create a 2x2 RGB image filled with 1s
let src = Image::<u8, 3, _>::new(
    ImageSize { width: 2, height: 2 },
    vec![1u8; 2 * 2 * 3],
    CpuAllocator,
).unwrap();

// Create destination image
let mut dst = Image::<u8, 3, _>::new(
    ImageSize { width: 4, height: 4 },
    vec![0u8; 4 * 4 * 3],
    CpuAllocator,
).unwrap();

// Apply 1-pixel constant padding with black (0) border
spatial_padding(
    &src,
    &mut dst,
    Padding2D { top: 1, bottom: 1, left: 1, right: 1 },
    PaddingMode::Constant,
    [0u8; 3],
).unwrap();

// The resulting image should now be 4x4 in size
assert_eq!(dst.size().width, 4);
assert_eq!(dst.size().height, 4);
```

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

### get

Source: https://docs.rs/kornia/latest/kornia/image/color_spaces/struct.Hsvf32.html?search=

Get a reference to an element at a given multi-dimensional index with bounds checking.

```APIDOC
## get

### Description
Get the element at the given index, checking if the index is out of bounds.

### Arguments
* `index` - The list of indices to get the element from.

### Returns
A reference to the element at the given index.

### Errors
If the index is out of bounds, an error is returned.

### Example
```
use kornia_tensor::{Tensor, CpuAllocator};

let data: Vec<u8> = vec![1, 2, 3, 4];

let t = Tensor::<u8, 2, CpuAllocator>::from_shape_vec([2, 2], data, CpuAllocator).unwrap();

assert_eq!(t.get([0, 0]), Some(&1));
assert_eq!(t.get([0, 1]), Some(&2));
assert_eq!(t.get([1, 0]), Some(&3));
assert_eq!(t.get([1, 1]), Some(&4));

assert!(t.get([2, 0]).is_none());
```

```
Tokens:
Raw