coord_transforms 1.4.1

A Rust crate use for performing coordinate transformations.
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

extern crate coord_transforms;
extern crate nalgebra as na;
extern crate minifb;
use coord_transforms::prelude::*;
use minifb::{Key, WindowOptions, Window};

const WIDTH: usize = 800;
const HEIGHT: usize = 600;

fn main() {
	let mut buffer: Vec<u32> = vec![0; WIDTH * HEIGHT];

    let mut window = Window::new("Test - Visual - coord_transforms",
                                 WIDTH,
                                 HEIGHT,
                                 WindowOptions::default()).unwrap_or_else(|e| {
        panic!("{}", e);
    });

    let mut line_angle_rads = 0.0;
    while window.is_open() && !window.is_key_down(Key::Escape) {
    	//Circle code
    	let radius: i64 = 200;
    	let x0: i64 = WIDTH as i64 / 2;
    	let y0: i64 = HEIGHT as i64 / 2;
    	let mut x: i64 = radius - 1;
    	let mut y: i64 = 0;
    	let mut dx: i64 = 1;
    	let mut dy: i64 = 1;
    	let mut err: i64 = dx - (radius << 1);
    	let colorPix = 0xFFFFFF;

    	//Line code
    	let mut p1x: i64 = WIDTH as i64 / 2;
    	let mut p1y: i64 = HEIGHT as i64 / 2;
    	let pol_vec: Vector2<f64> = Vector2::new(radius as f64, line_angle_rads);
    	let cart_vec = d2::polar2cartesian(&pol_vec);
    	let mut p2x: i64 = p1x + cart_vec.x as i64;
    	let mut p2y: i64 = p1y + cart_vec.y as i64;
    	let mut psteep = false;
    	if (p2y - p1y).abs() > (p2x - p1x).abs() {
    		psteep = true;
    	}
    	if psteep {
    		let tempx = p1x;
    		p1x = p1y;
    		p1y = tempx;
    		let tempx2 = p2x;
    		p2x = p2y;
    		p2y = tempx2;
    	}
    	if p1x > p2x {
    		let tempx = p1x;
    		p1x = p2x;
    		p2x = tempx;
    		let tempy = p1y;
    		p1y = p2y;
    		p2y = tempy;
    	}
    	let pdx = p2x - p1x;
    	let pdy = (p2y - p1y).abs();
    	let mut perror = pdx / 2;
    	let mut pystep = 0;
    	if p1y < p2y {
    		pystep = 1;
    	}else{
    		pystep = -1;
    	}
    	let mut py0 = p1y;
    	let pmaxx = p2x;

    	//Draw circle
    	while x >= y {
        	buffer[xy2lin(x0 + x, y0 + y) as usize] = colorPix;
        	buffer[xy2lin(x0 + y, y0 + x) as usize] = colorPix;
        	buffer[xy2lin(x0 - y, y0 + x) as usize] = colorPix;
        	buffer[xy2lin(x0 - x, y0 + y) as usize] = colorPix;
        	buffer[xy2lin(x0 - x, y0 - y) as usize] = colorPix;
        	buffer[xy2lin(x0 - y, y0 - x) as usize] = colorPix;
        	buffer[xy2lin(x0 + y, y0 - x) as usize] = colorPix;
        	buffer[xy2lin(x0 + x, y0 - y) as usize] = colorPix;
            if err <= 0 {
            	y += 1;
            	err += dy;
            	dy += 2;
            }
            if err > 0 {
            	x -= 1;
            	dx += 2;
            	err += (-radius << 1) + dx;
            }
		}

		//Draw line
		for x in p1x..pmaxx {
			if psteep {
				buffer[xy2lin(py0, x) as usize] = colorPix;
			}else{
				buffer[xy2lin(x, py0) as usize] = colorPix;
			}
			perror -= pdy;
			if perror < 0 {
				py0 += pystep;
				perror += pdx;
			}
		}

    	window.update_with_buffer(&buffer, WIDTH, HEIGHT).unwrap();

    	//Wrap radians
    	if line_angle_rads >= 2.0 * 3.14 {
    		line_angle_rads = 0.0;
    	}else{
    		line_angle_rads += 0.001;
    	}

    	//Clear
    	for x in 0..WIDTH * HEIGHT {
    		buffer[x] = 0x0;
    	}
	}
}

fn xy2lin(x: i64, y: i64) -> i64 {
	WIDTH as i64 * y + x
}