iris-cv 0.0.0

A fast computer vision library framework in Rust.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83

---
title: "Threshold Module Reference"
description: "API reference for Iris threshold module — binary, Otsu, triangle, and adaptive thresholding operations."
keywords: ["threshold", "binary threshold", "Otsu", "triangle", "adaptive threshold", "segmentation"]
---

# Threshold Module Reference

Provides thresholding operations for image binarization and segmentation.

## Threshold Types

```rust
pub enum ThresholdType {
    Binary,
    BinaryInv,
    Trunc,
    ToZero,
    ToZeroInv,
}
```

| Type | Description |
|---|---|
| `Binary` | `pixel > thresh ? maxval : 0` |
| `BinaryInv` | `pixel > thresh ? 0 : maxval` |
| `Trunc` | `pixel > thresh ? thresh : pixel` |
| `ToZero` | `pixel > thresh ? pixel : 0` |
| `ToZeroInv` | `pixel > thresh ? 0 : pixel` |

## Adaptive Methods

```rust
pub enum AdaptiveMethod {
    MeanC,
    GaussianC,
}
```

| Method | Description |
|---|---|
| `MeanC` | Mean of the blockSize x blockSize neighborhood. |
| `GaussianC` | Gaussian-weighted sum of the neighborhood. |

## Operations

```rust
impl<B: Backend> Image<B> {
    pub fn threshold(&self, thresh: f32, maxval: f32, thresh_type: ThresholdType) -> Result<Self>;
    pub fn threshold_otsu(&self, maxval: f32) -> Result<Self>;
    pub fn threshold_triangle(&self, maxval: f32) -> Result<Self>;
    pub fn adaptive_threshold(
        &self,
        maxval: f32,
        method: AdaptiveMethod,
        block_size: usize,
        c: f32,
    ) -> Result<Self>;
}
```

## Example

```rust
use iris::prelude::*;
use burn::backend::wgpu::Wgpu;

type Backend = Wgpu;
let device = Default::default();
let img = Image::<Backend>::open("input.jpg", &device)?;

// Fixed binary threshold
let binary = img.threshold(0.5, 1.0, ThresholdType::Binary)?;

// Automatic Otsu threshold
let otsu = img.threshold_otsu(1.0)?;

// Triangle method
let triangle = img.threshold_triangle(1.0)?;

// Adaptive threshold
let adaptive = img.adaptive_threshold(1.0, AdaptiveMethod::MeanC, 11, 2.0)?;
```