# ArcGIS Runtime in Rust 🗺️

    🗺️  _~^~^~_   🔧
    \) /  o o  \ (/
      '_   -   _'
      / '-----' \

**NOTE**: This Runtime is still under development, please report any bugs or issues to help us make this runtime more reliable!


Welcome to **ArcGIS Rust**! This project is a Rust-based geospatial intelligence library inspired by ArcGIS Runtime. It provides core geospatial types, rendering capabilities, and task execution for geoprocessing and locator tasks.

## Table of Contents

- [Introduction](#introduction)
- [Installation](#installation)
- [Usage](#usage)
  - [Examples](#examples)
- [API Specifications](#api-specifications)
  - [Core Module](#core-module)
  - [Data Module](#data-module)
  - [Rendering Module](#rendering-module)
  - [Tasks Module](#tasks-module)
- [Contributing](#contributing)
- [License](#license)

## Introduction

This project aims to provide a comprehensive geospatial intelligence library in Rust. It includes:
- Core geospatial types (Point, Polygon, Envelope, etc.)
- Feature layers for managing geographic features
- Map view rendering capabilities using `wgpu`
- Task execution for geoprocessing and locator tasks using `reqwest`

## Installation

To use this library in your project, add the following to your `Cargo.toml`:

```toml
[dependencies]
arcgis_rust = { git = "https://github.com/dfridkin/arcgis-rust-runtime.git" }
geo = "0.23.0"
wgpu = "0.12.0"
winit = "0.26.0"
reqwest = { version = "0.11", features = ["json"] }
tokio = { version = "1", features = ["full"] }
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"
```

## Usage

**Examples**

Creating and Using Geospatial Types
```rust
use arcgis_rust::core::geometry::*;
use geo::point;

fn main() {
    let point = point!(x: 1.0, y: 2.0);
    println!("Point: {:?}", point);

    let envelope = Envelope {
        min: point!(x: 0.0, y: 0.0),
        max: point!(x: 10.0, y: 10.0),
    };

    let point_inside = point!(x: 5.0, y: 5.0);
    let point_outside = point!(x: 15.0, y: 15.0);

    println!("Point inside: {}", envelope.contains(&point_inside));
    println!("Point outside: {}", envelope.contains(&point_outside));
}
```
Executing a Geoprocessing Task
```rust
use arcgis_rust::tasks::geoprocessing::GeoprocessingTask;
use tokio;

#[tokio::main]
async fn main() {
    let geoprocessing_task = GeoprocessingTask {
        url: "https://example.com/arcgis/rest/services/GP/Service".to_string(),
    };

    match geoprocessing_task.execute("parameters").await {
        Ok(result) => println!("Geoprocessing result: {}", result),
        Err(e) => println!("Error: {}", e),
    }
}
```

## API Specifications

**Core Module**

`Point`

Represents a 2D point with x and y coordinates.
```rust
#[derive(Debug, Clone)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}
```


`Envelope`

Represents a rectangular envelope defined by its minimum and maximum coordinates.

```rust
#[derive(Debug, Clone)]
pub struct Envelope {
    pub min: Point<f64>,
    pub max: Point<f64>,

    pub fn contains(&self, point: &Point<f64>) -> bool;
}
```
`Intersection`

Calculate the intersection of two geometries.


```rust

use arcgis_rust::core::geometry::{Polygon, run_intersection};

let poly1 = polygon![
    (x: 0.0, y: 0.0),
    (x: 10.0, y: 0.0),
    (x: 10.0, y: 10.0),
    (x: 0.0, y: 10.0),
    (x: 0.0, y: 0.0)
];
let poly2 = polygon![
    (x: 5.0, y: 5.0),
    (x: 15.0, y: 5.0),
    (x: 15.0, y: 15.0),
    (x: 5.0, y: 15.0),
    (x: 5.0, y: 5.0)
];
let intersection = run_intersection(&poly1, &poly2);

println!("Intersection: {:?}", intersection);
```

`Union`

Merge multiple geometries into a single geometry.

```rust

use arcgis_rust::core::geometry::{Polygon, run_union};

let poly1 = polygon![
    (x: 0.0, y: 0.0),
    (x: 10.0, y: 0.0),
    (x: 10.0, y: 10.0),
    (x: 0.0, y: 10.0),
    (x: 0.0, y: 0.0)
];
let poly2 = polygon![
    (x: 5.0, y: 5.0),
    (x: 15.0, y: 5.0),
    (x: 15.0, y: 15.0),
    (x: 5.0, y: 15.0),
    (x: 5.0, y: 5.0)
];
let union = run_union(&poly1, &poly2);

println!("Union: {:?}", union);
```

`Boundaries`

Retrieve the boundary of a geometry.

```rust

use arcgis_rust::core::geometry::{Polygon, calculate_boundaries};

let poly = polygon![
    (x: 0.0, y: 0.0),
    (x: 10.0, y: 0.0),
    (x: 10.0, y: 10.0),
    (x: 0.0, y: 10.0),
    (x: 0.0, y: 0.0)
];
let boundaries = calculate_boundaries(&poly);

println!("Boundaries: {:?}", boundaries);
```

## Data Module

`Feature`

Represents a geographic feature with geometry and attributes.

```rust

#[derive(Debug, Clone)]
pub struct Feature {
    pub geometry: Geometry<f64>,
    pub attributes: HashMap<String, String>,
}
```
`FeatureLayer`

Manages a collection of features.

```rust

pub struct FeatureLayer {
    pub features: Vec<Feature>,

    pub fn query(&self, envelope: &Envelope) -> Vec<&Feature>;
}
```
## Rendering Module

`MapView`

Manages the rendering of a map view.

```rust

pub struct MapView {
    pub fn new(event_loop: &EventLoop<()>) -> Self;
    pub fn add_layer(&mut self, layer: Box<dyn Layer>);
    pub fn render(&self);
}
```
`Layer`

Trait for defining a renderable layer.

```rust

pub trait Layer {
    fn render(&self);
}
```
## Tasks Module

`GeoprocessingTask`

Executes geoprocessing tasks.

```rust

pub struct GeoprocessingTask {
    pub url: String,

    pub async fn execute(&self, parameters: &str) -> Result<String, reqwest::Error>;
}
```
`LocatorTask`

Executes geocoding tasks.

```rust

pub struct LocatorTask {
    pub url: String,

    pub async fn geocode(&self, address: &str) -> Result<Point<f64>, reqwest::Error>;
}
```
## Contributing

We welcome contributions to make this project even more awesome! To contribute, please follow these steps:

    Fork the repository.
    Create a new branch (git checkout -b feature-branch).
    Make your changes.
    Commit your changes (git commit -m 'Add new feature').
    Push to the branch (git push origin feature-branch).
    Open a pull request.

## License

This project is licensed under the MIT License. See the LICENSE file for details.

Happy coding, and may your Rust adventures be filled with joy and discovery! 🦀❤️