https://github.com/fschutt/marching-squares

Parallelized marching squares algorithm for constructing closed isolines / contour lines
https://github.com/fschutt/marching-squares

Last synced: 9 months ago
JSON representation

Parallelized marching squares algorithm for constructing closed isolines / contour lines

• Host: GitHub
• URL: https://github.com/fschutt/marching-squares
• Owner: fschutt
• License: mit
• Created: 2020-04-24T12:26:44.000Z (about 6 years ago)
• Default Branch: master
• Last Pushed: 2020-04-24T21:18:15.000Z (about 6 years ago)
• Last Synced: 2024-11-15T04:39:27.751Z (over 1 year ago)
• Language: Rust
• Size: 8.79 KB
• Stars: 3
• Watchers: 2
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md
  • License: LICENSE

Awesome Lists containing this project

README

          
# marching-squares

This crate provides an (optionally parallelizable)

marching squares algorithm to generate isolines from

a heightmap of `Vec>` values.

Adapted from [https://github.com/d-dorazio/marching-squares](https://github.com/d-dorazio/marching-squares)

## Warning

- The returned lines may only have two points.

## Example

```rust

use marching_squares::{Field, Point};

fn main() {

    let width = 1600_usize;

    let height = 1600_usize;

    let n_steps = 10_usize;

    let mut min_val = 0;

    let mut max_val = 0;

    // Build the heightmap data (here: randomly generated from a function)

    let z_values = (0..height).map(|y| {

        (0..width).map(|x| {

            let x = (x as f64 - width as f64 / 2.0) / 150.0;

            let y = (y as f64 - height as f64 / 2.0) / 150.0;

            let val = ((1.3 * x).sin() * (0.9 * y).cos() + (0.8 * x).cos() * (1.9 * y).sin() + (y * 0.2 * x).cos()) as i16;

            min_val = min_val.min(val);

            max_val = max_val.max(val);

            val

        }).collect()

    }).collect::>>();

    let field = Field {

        dimensions: (width, height),

        top_left: Point { x: 0.0, y: 0.0 },

        pixel_size: (1.0, 1.0),

        values: &z_values,

    };

    let step_size = (max_val - min_val) as f32 / n_steps as f32;

    // Generate 10 isolines

    // note: you could do this in parallel using rayon

    for step in 0..n_steps {

        let isoline_height = min_val as f32 + (step_size * step as f32);

        println!("{:#?}", field.get_contours(isoline_height as i16));

    }

}

```

License: MIT