# Rustvision
Simple (and very early) project for interacting with images, vertices, and polygons (and some other stuff related to computer vision).
**Note:** This project is in a very early state and the documentation is far from perfect. Feel free to open PRs with improvements!
## Installation
Simply add this crate to your `Cargo.toml` (either via `cargo add` or manually).
## Usage
The usage of this library is very straight forward. First you need to create a new image.
```rust
use rustvision::image::Image;
fn main() {
let mut img = Image::new(400, 400);
}
```
### Rectangle
To work with a simple rectangle, you can import and then create one:
```rust
use rustvision::{image::Image, shapes::Rectangle, rgb, vec2};
// ...
let rect = Rectangle::new(vec2![50.0, 40.0], 100, 70, rgb!(255, 0, 0));
// ...
```
This will create a new instance of a rectangle at the coordinates x-y-coordinates `(50.0, 40.0)` with a width of 100, a height of 70 and the color red.
You will notice the usage of two macros here: `vec2![]` and `rgb!()`. `vec2![]` is a utility macro to create a 2D vector with the specified coordinates, whereas `rgb!()` creates a new RGB color for you. For more information on these have a look at the code (or later documentation).
If you want to draw this created rectangle to the image, you can do so by calling `img.draw`:
```rust
// ...
img.draw(&rect);
// ...
```
This will draw the rectangle to the provided image. To finally save the image to your disk, you can use another utility macro:
```rust
use rustvision::{image::Image, shapes::Rectangle, rgb, vec2, save_pnm_p6};
// ...
save_pnm_p6!("path_to_image.ppm", img);
// ...
```
The image will be saved in the P6 (binary PPM) representation. If you prefer the ASCII representation (P3), this library provides another utility macro as well.
### Polygons
Similar to rectangles, you can create more complex polygons:
```rust
use rustvision::{image::Image, shapes::Polygon, vec2};
// ...
let mut polygon = Polygon::from_points(vec![
vec2![20.0, 250.0],
vec2![50.0, 350.0],
vec2![80.0, 280.0],
vec2![110.0, 350.0],
vec2![140.0, 250.0],
vec2![110.0, 300.0],
vec2![80.0, 250.0],
vec2![50.0, 300.0],
]);
// ...
```
Notice that this "constructor" does not take a color. By default, this polygon will be black. If you want to specify a color, you can do so with the respective method:
```rust
use rustvision::{image::Image, shapes::Polygon, rgb, vec2};
// ...
polygon.set_color(rgb!(0, 255, 0));
// ...
```
This will color the polygon green. Painting this polygon now would result in only the outline being drawn. To fill it, you need to manually set the flag:
```rust
// ...
polygon.set_filled(true);
// ...
```
Similar to a rectangle, you can draw this polygon to an image:
```rust
// ...
img.draw(&polygon);
// ...
```
## Reading Files
You can read files and convert them to the internal image representation by using the `load_image` macro:
```rust
use rustvision::{load_image, save_pnm_p3};
fn main() {
let image = load_image!("assets/mona_lisa_small.ppm");
}
```
**Note:** Currently, this library only support images in PPM6 (i.e., binary PPM) representation. Trying to read any other file will lead to a panic!