photo 3.0.0

Image utility library
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
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

<p align="center" style="font-size: 2.5em">
    Photo
</p>
<p align="center">
    <img src="./assets/images/icon.png" alt="Photo Icon" width="200" style="border-radius: 5%; border: 2px solid #000;">
</p>
<p align="center" style="font-size: 1.5em">
    A lightweight, highly-generic Rust library for image manipulation with rich format support and transformation operations.
</p>

[![crates.io](https://img.shields.io/crates/v/photo.svg)](https://crates.io/crates/photo)
[![Documentation](https://docs.rs/photo/badge.svg)](https://docs.rs/photo)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

## Features

- **Multiple Image Formats**: Complete support for grayscale, grayscale with alpha, RGB, and RGBA images
- **Type Flexibility**: Generic implementation for various component types (`u8`, `f32`, `f64`, etc.)
- **Image Manipulation**: Comprehensive operations for regions, borders, and transformations
- **Tiling Operations**: Create, extract and compose image tiles with or without overlaps
- **Image Composition**: Stack images horizontally and vertically
- **Advanced Indexing**: Access and modify pixels and channels with ease
- **Comprehensive Testing**: High test coverage ensures library reliability
- **Minimal Dependencies**: Core functionality relies on few, well-maintained dependencies

## Installation

Add this to your `Cargo.toml`:

```toml
[dependencies]
photo = "3.0.0"
```

## Usage

### Basic Image Operations

```rust
use photo::{Channels, Image};

// Create a new empty RGB image with f32 components
let mut image = Image::<f32>::empty((100, 100), Channels::RGB);

// Fill an image with a specific color
let red_image = Image::<f32>::filled((50, 50), &[1.0, 0.0, 0.0]);

// Access and modify pixel values
let pixel = image.get_pixel((10, 10));
image.set_pixel((20, 20), &pixel);

// Get a specific channel
let red_channel = image.get_channel(0);
```

### Image Transformations

```rust
use photo::Image;

// Create a new image from multiple layers
let layers = vec![red_layer, green_layer, blue_layer];
let mut image = Image::from_layers(&layers);

// Move pixels around (with wrapping)
image.slide_inplace((10, -5));

// Copy a region of the image
let region = image.copy_region((0, 0), (50, 50));
```

### Working with Tiles

```rust
use photo::Image;

// Split an image into tiles (non-overlapping)
let tile_size = (32, 32);
let no_overlap = (0, 0);
let tiles = image.copy_tiles(tile_size, no_overlap);

// Create an image from a grid of tiles
let combined_image = Image::stack(&tiles);

// Extract tiles with overlap
let overlap = (4, 4);
let overlapping_tiles = image.copy_tiles(tile_size, overlap);
```

### Working with Borders

```rust
use photo::Image;
use nav::Direction;

// Get a view of the border regions
let north_border = image.view_border(&Direction::North, 5);
let south_border = image.view_border(&Direction::South, 5);

// Copy border regions
let east_border = image.copy_border(&Direction::East, 5);
let west_border = image.copy_border(&Direction::West, 5);

// View or copy the interior (excluding borders)
let interior = image.copy_interior(5);
```

### Composing Images

```rust
use photo::Image;

// Stack images vertically
let vertical_stack = Image::vstack(&[image1, image2, image3]);

// Stack images horizontally
let horizontal_stack = Image::hstack(&[image1, image2, image3]);
```

## Applications

This library is useful for:

- Image processing and manipulation
- Computer vision
- Pattern recognition
- Procedural texture generation
- Image-based machine learning
- Tile-based graphics
- Cellular automata and grid-based simulations

## License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.