flatland.core.grid.grid_utils module

class flatland.core.grid.grid_utils.Vec2dOperations[source]

Bases: object

static add(node_a:Tuple[float, float], node_b:Tuple[float, float]) → Tuple[float, float][source]

vector operation : node_a + node_b

Parameters:
  • node_a – tuple with coordinate (x,y) or 2d vector
  • node_b – tuple with coordinate (x,y) or 2d vector
Returns:

tuple with coordinate (x,y) or 2d vector

static bound(node:Tuple[float, float], min_value:float, max_value:float) → Tuple[float, float][source]

force the values x and y to be between min_value and max_value

Parameters:
  • node – tuple with coordinate (x,y) or 2d vector
  • min_value – scalar value
  • max_value – scalar value
Returns:

tuple with coordinate (x,y) or 2d vector

static ceil(node:Tuple[float, float]) → Tuple[int, int][source]

ceiling the x and y coordinate and convert them to an integer values

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static floor(node:Tuple[float, float]) → Tuple[int, int][source]

floor the x and y coordinate and convert them to an integer values

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static get_chebyshev_distance(node_a:Tuple[float, float], node_b:Tuple[float, float]) → float[source]

calculates the chebyshev norm of the 2d vector [see: https://lyfat.wordpress.com/2012/05/22/euclidean-vs-chebyshev-vs-manhattan-distance/]

Parameters:
node_a

tuple with coordinate (x,y) or 2d vector

node_b

tuple with coordinate (x,y) or 2d vector

Returns:
float

the chebyshev distance

static get_euclidean_distance(node_a:Tuple[float, float], node_b:Tuple[float, float]) → float[source]

calculates the euclidean norm of the 2d vector

Parameters:
node_a

tuple with coordinate (x,y) or 2d vector

node_b

tuple with coordinate (x,y) or 2d vector

Returns:
float

Euclidean distance

static get_manhattan_distance(node_a:Tuple[float, float], node_b:Tuple[float, float]) → float[source]

calculates the manhattan distance of the 2d vector [see: https://lyfat.wordpress.com/2012/05/22/euclidean-vs-chebyshev-vs-manhattan-distance/]

Parameters:
node_a

tuple with coordinate (x,y) or 2d vector

node_b

tuple with coordinate (x,y) or 2d vector

Returns:
float

Mahnhattan distance

static get_norm(node:Tuple[float, float]) → float[source]

calculates the euclidean norm of the 2d vector [see: https://lyfat.wordpress.com/2012/05/22/euclidean-vs-chebyshev-vs-manhattan-distance/]

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static is_equal(node_a:Tuple[float, float], node_b:Tuple[float, float]) → bool[source]

vector operation : node_a + node_b

Parameters:
  • node_a – tuple with coordinate (x,y) or 2d vector
  • node_b – tuple with coordinate (x,y) or 2d vector
Returns:

check if node_a and nobe_b are equal

static make_orthogonal(node:Tuple[float, float]) → Tuple[float, float][source]

vector operation : rotates the 2D vector +90°

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static normalize(node:Tuple[float, float]) → Tuple[float, float][source]

normalize the 2d vector = v/|v|

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static rotate(node:Tuple[float, float], rot_in_degree:float) → Tuple[float, float][source]

rotate the 2d vector with given angle in degree

Parameters:
  • node – tuple with coordinate (x,y) or 2d vector
  • rot_in_degree – angle in degree
Returns:

tuple with coordinate (x,y) or 2d vector

static round(node:Tuple[float, float]) → Tuple[int, int][source]

rounds the x and y coordinate and convert them to an integer values

Parameters:node – tuple with coordinate (x,y) or 2d vector
Returns:tuple with coordinate (x,y) or 2d vector
static scale(node:Tuple[float, float], scale:float) → Tuple[float, float][source]

scales the 2d vector = node * scale

Parameters:
  • node – tuple with coordinate (x,y) or 2d vector
  • scale – scalar to scale
Returns:

tuple with coordinate (x,y) or 2d vector

static subtract(node_a:Tuple[float, float], node_b:Tuple[float, float]) → Tuple[float, float][source]

vector operation : node_a - node_b

Parameters:
  • node_a – tuple with coordinate (x,y) or 2d vector
  • node_b – tuple with coordinate (x,y) or 2d vector
Returns:

tuple with coordinate (x,y) or 2d vector

flatland.core.grid.grid_utils.coordinate_to_position(depth, coords)[source]

Converts positions to coordinates:

[ 0      d    ..  (w-1)*d
  1      d+1
  ...
  d-1    2d-1     w*d-1
]
-->
[ (0,0) (0,1) ..  (0,w-1)
  (1,0) (1,1)     (1,w-1)
  ...
  (d-1,0) (d-1,1)     (d-1,w-1)
 ]
Parameters:
  • depth
  • coords
Returns:

flatland.core.grid.grid_utils.distance_on_rail(pos1, pos2, metric='Euclidean')[source]
flatland.core.grid.grid_utils.position_to_coordinate(depth:int, positions:List[int])[source]

Converts coordinates to positions:

[ (0,0) (0,1) ..  (0,w-1)
  (1,0) (1,1)     (1,w-1)
    ...
  (d-1,0) (d-1,1)     (d-1,w-1)
]

 -->

[ 0      d    ..  (w-1)*d
  1      d+1
  ...
  d-1    2d-1     w*d-1
]
Parameters:
depth : int
positions : List[Tuple[int,int]]