279 lines
11 KiB
Python
279 lines
11 KiB
Python
from __future__ import annotations
|
|
from dataclasses import dataclass
|
|
from enum import Enum
|
|
from math import gcd, sqrt, inf, atan2, degrees
|
|
from typing import Union, List, Optional
|
|
|
|
|
|
class DistanceAlgorithm(Enum):
|
|
MANHATTAN = 0
|
|
EUCLIDEAN = 1
|
|
PYTHAGOREAN = 1
|
|
CHEBYSHEV = 2
|
|
CHESSBOARD = 2
|
|
|
|
|
|
@dataclass(frozen=True)
|
|
class Coordinate:
|
|
x: int
|
|
y: int
|
|
z: Optional[int] = None
|
|
|
|
def getDistanceTo(self, target: Coordinate, algorithm: DistanceAlgorithm = DistanceAlgorithm.EUCLIDEAN,
|
|
includeDiagonals: bool = False) -> Union[int, float]:
|
|
"""
|
|
Get distance to target Coordinate
|
|
|
|
:param target:
|
|
:param algorithm: Calculation Algorithm (s. DistanceAlgorithm)
|
|
:param includeDiagonals: in Manhattan Mode specify if diagonal
|
|
movements are allowed (counts as 1.4 in 2D, 1.7 in 3D)
|
|
:return: Distance to Target
|
|
"""
|
|
if algorithm == DistanceAlgorithm.EUCLIDEAN:
|
|
if self.z is None:
|
|
return sqrt(abs(self.x - target.x) ** 2 + abs(self.y - target.y) ** 2)
|
|
else:
|
|
return sqrt(abs(self.x - target.x) ** 2 + abs(self.y - target.y) ** 2 + abs(self.z - target.z) ** 2)
|
|
elif algorithm == DistanceAlgorithm.CHEBYSHEV:
|
|
if self.z is None:
|
|
return max(abs(target.x - self.x), abs(target.y - self.y))
|
|
else:
|
|
return max(abs(target.x - self.x), abs(target.y - self.y), abs(target.z - self.z))
|
|
elif algorithm == DistanceAlgorithm.MANHATTAN:
|
|
if not includeDiagonals:
|
|
if self.z is None:
|
|
return abs(self.x - target.x) + abs(self.y - target.y)
|
|
else:
|
|
return abs(self.x - target.x) + abs(self.y - target.y) + abs(self.z - target.z)
|
|
else:
|
|
dist = [abs(self.x - target.x), abs(self.y - target.y)]
|
|
if self.z is None:
|
|
o_dist = max(dist) - min(dist)
|
|
return o_dist + 1.4 * min(dist)
|
|
else:
|
|
dist.append(abs(self.z - target.z))
|
|
d_steps = min(dist)
|
|
dist.remove(min(dist))
|
|
dist = [x - d_steps for x in dist]
|
|
o_dist = max(dist) - min(dist)
|
|
return 1.7 * d_steps + o_dist + 1.4 * min(dist)
|
|
|
|
def getNeighbours(self, includeDiagonal: bool = True, minX: int = -inf, minY: int = -inf,
|
|
maxX: int = inf, maxY: int = inf, minZ: int = -inf, maxZ: int = inf) -> list[Coordinate]:
|
|
"""
|
|
Get a list of neighbouring coordinates
|
|
|
|
:param includeDiagonal: include diagonal neighbours
|
|
:param minX: ignore all neighbours that would have an X value below this
|
|
:param minY: ignore all neighbours that would have an Y value below this
|
|
:param minZ: ignore all neighbours that would have an Z value below this
|
|
:param maxX: ignore all neighbours that would have an X value above this
|
|
:param maxY: ignore all neighbours that would have an Y value above this
|
|
:param maxZ: ignore all neighbours that would have an Z value above this
|
|
:return: list of Coordinate
|
|
"""
|
|
neighbourList = []
|
|
if self.z is None:
|
|
if includeDiagonal:
|
|
nb_list = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
|
|
else:
|
|
nb_list = [(-1, 0), (1, 0), (0, -1), (0, 1)]
|
|
|
|
return [
|
|
Coordinate(self.x + dx, self.y + dy)
|
|
for dx, dy in nb_list
|
|
if minX <= self.x + dx <= maxX and minY <= self.y + dy <= maxY
|
|
]
|
|
else:
|
|
if includeDiagonal:
|
|
nb_list = [(x, y, z) for x in [-1, 0, 1] for y in [-1, 0, 1] for z in [-1, 0, 1]]
|
|
nb_list.remove((0, 0, 0))
|
|
else:
|
|
nb_list = [(-1, 0, 0), (0, -1, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1), (0, 0, -1)]
|
|
|
|
return [
|
|
Coordinate(self.x + dx, self.y + dy, self.z + dz)
|
|
for dx, dy, dz in nb_list
|
|
if minX <= self.x + dx <= maxX and minY <= self.y + dy <= maxY and minZ <= self.z + dz <= maxZ
|
|
]
|
|
|
|
def getAngleTo(self, target: Coordinate, normalized: bool = False) -> float:
|
|
"""normalized returns an angle going clockwise with 0 starting in the 'north'"""
|
|
if self.z is not None:
|
|
raise NotImplementedError() # which angle?!?!
|
|
|
|
dx = target.x - self.x
|
|
dy = target.y - self.y
|
|
if not normalized:
|
|
return degrees(atan2(dy, dx))
|
|
else:
|
|
angle = degrees(atan2(dx, dy))
|
|
if dx >= 0:
|
|
return 180.0 - angle
|
|
else:
|
|
return 180.0 + abs(angle)
|
|
|
|
def getLineTo(self, target: Coordinate) -> List[Coordinate]:
|
|
diff = target - self
|
|
|
|
if self.z is None:
|
|
steps = gcd(diff.x, diff.y)
|
|
step_x = diff.x // steps
|
|
step_y = diff.y // steps
|
|
return [Coordinate(self.x + step_x * i, self.y + step_y * i) for i in range(steps + 1)]
|
|
else:
|
|
steps = gcd(diff.x, diff.y, diff.z)
|
|
step_x = diff.x // steps
|
|
step_y = diff.y // steps
|
|
step_z = diff.z // steps
|
|
return [Coordinate(self.x + step_x * i, self.y + step_y * i, self.z + step_z * i) for i in range(steps + 1)]
|
|
|
|
def __add__(self, other: Coordinate) -> Coordinate:
|
|
if self.z is None:
|
|
return Coordinate(self.x + other.x, self.y + other.y)
|
|
else:
|
|
return Coordinate(self.x + other.x, self.y + other.y, self.z + other.z)
|
|
|
|
def __sub__(self, other: Coordinate) -> Coordinate:
|
|
if self.z is None:
|
|
return Coordinate(self.x - other.x, self.y - other.y)
|
|
else:
|
|
return Coordinate(self.x - other.x, self.y - other.y, self.z - other.z)
|
|
|
|
def __eq__(self, other):
|
|
return self.x == other.x and self.y == other.y and self.z == other.z
|
|
|
|
def __gt__(self, other):
|
|
if self.z is None:
|
|
return self.x > other.x and self.y > other.y
|
|
else:
|
|
return self.x > other.x and self.y > other.y and self.z > other.z
|
|
|
|
def __ge__(self, other):
|
|
if self.z is None:
|
|
return self.x >= other.x and self.y >= other.y
|
|
else:
|
|
return self.x >= other.x and self.y >= other.y and self.z >= other.z
|
|
|
|
def __lt__(self, other):
|
|
if self.z is None:
|
|
return self.x < other.x and self.y < other.y
|
|
else:
|
|
return self.x < other.x and self.y < other.y and self.z < other.z
|
|
|
|
def __le__(self, other):
|
|
if self.z is None:
|
|
return self.x <= other.x and self.y <= other.y
|
|
else:
|
|
return self.x <= other.x and self.y <= other.y and self.z <= other.z
|
|
|
|
def __str__(self):
|
|
if self.z is None:
|
|
return "(%d,%d)" % (self.x, self.y)
|
|
else:
|
|
return "(%d,%d,%d)" % (self.x, self.y, self.z)
|
|
|
|
def __repr__(self):
|
|
if self.z is None:
|
|
return "%s(x=%d, y=%d)" % (self.__class__.__name__, self.x, self.y)
|
|
else:
|
|
return "%s(x=%d, y=%d, z=%d)" % (self.__class__.__name__, self.x, self.y, self.z)
|
|
|
|
@staticmethod
|
|
def generate(from_x: int, to_x: int, from_y: int, to_y: int,
|
|
from_z: int = None, to_z: int = None) -> List[Coordinate]:
|
|
if from_z is None or to_z is None:
|
|
return [Coordinate(x, y) for x in range(from_x, to_x + 1) for y in range(from_y, to_y + 1)]
|
|
else:
|
|
return [
|
|
Coordinate(x, y, z)
|
|
for x in range(from_x, to_x + 1)
|
|
for y in range(from_y, to_y + 1)
|
|
for z in range(from_z, to_z + 1)
|
|
]
|
|
|
|
|
|
class Shape:
|
|
top_left: Coordinate
|
|
bottom_right: Coordinate
|
|
mode_3d: bool
|
|
|
|
def __init__(self, top_left: Coordinate, bottom_right: Coordinate):
|
|
"""
|
|
in 2D mode: top_left is the upper left corner and bottom_right the lower right
|
|
(top_left.x <= bottom_right.x and top_left.y <= bottom_right.y)
|
|
in 3D mode: same logic applied, just for 3D Coordinates
|
|
top_left is the upper left rear corner and bottom_right the lower right front
|
|
(top_left.x <= bottom_right.x and top_left.y <= bottom_right.y and top_left.z <= bottom_right.z)
|
|
"""
|
|
self.top_left = top_left
|
|
self.bottom_right = bottom_right
|
|
self.mode_3d = top_left.z is not None and bottom_right.z is not None
|
|
|
|
def size(self):
|
|
if not self.mode_3d:
|
|
return (self.bottom_right.x - self.top_left.x + 1) * (self.bottom_right.y - self.top_left.y + 1)
|
|
else:
|
|
return (
|
|
(self.bottom_right.x - self.top_left.x + 1)
|
|
* (self.bottom_right.y - self.top_left.y + 1)
|
|
* (self.bottom_right.z - self.top_left.z + 1)
|
|
)
|
|
|
|
def intersection(self, other: Shape) -> Union[Shape, None]:
|
|
"""
|
|
returns a Shape of the intersecting part, or None if the Shapes don't intersect
|
|
"""
|
|
if self.mode_3d != other.mode_3d:
|
|
raise ValueError("Cannot calculate intersection between 2d and 3d shape")
|
|
|
|
if not self.mode_3d:
|
|
intersect_top_left = Coordinate(
|
|
self.top_left.x if self.top_left.x > other.top_left.x else other.top_left.x,
|
|
self.top_left.y if self.top_left.y > other.top_left.y else other.top_left.y,
|
|
)
|
|
intersect_bottom_right = Coordinate(
|
|
self.bottom_right.x if self.bottom_right.x < other.bottom_right.x else other.bottom_right.x,
|
|
self.bottom_right.y if self.bottom_right.y < other.bottom_right.y else other.bottom_right.y,
|
|
)
|
|
else:
|
|
intersect_top_left = Coordinate(
|
|
self.top_left.x if self.top_left.x > other.top_left.x else other.top_left.x,
|
|
self.top_left.y if self.top_left.y > other.top_left.y else other.top_left.y,
|
|
self.top_left.z if self.top_left.z > other.top_left.z else other.top_left.z,
|
|
)
|
|
intersect_bottom_right = Coordinate(
|
|
self.bottom_right.x if self.bottom_right.x < other.bottom_right.x else other.bottom_right.x,
|
|
self.bottom_right.y if self.bottom_right.y < other.bottom_right.y else other.bottom_right.y,
|
|
self.bottom_right.z if self.bottom_right.z < other.bottom_right.z else other.bottom_right.z,
|
|
)
|
|
|
|
if intersect_top_left <= intersect_bottom_right:
|
|
return self.__class__(intersect_top_left, intersect_bottom_right)
|
|
|
|
def __and__(self, other):
|
|
return self.intersection(other)
|
|
|
|
def __rand__(self, other):
|
|
return self.intersection(other)
|
|
|
|
def __str__(self):
|
|
return "%s(%s -> %s)" % (self.__class__.__name__, self.top_left, self.bottom_right)
|
|
|
|
def __repr__(self):
|
|
return "%s(%s, %s)" % (self.__class__.__name__, self.top_left, self.bottom_right)
|
|
|
|
|
|
class Square(Shape):
|
|
def __init__(self, top_left, bottom_right):
|
|
super().__init__(top_left, bottom_right)
|
|
self.mode_3d = False
|
|
|
|
|
|
class Cube(Shape):
|
|
def __init__(self, top_left, bottom_right):
|
|
if top_left.z is None or bottom_right.z is None:
|
|
raise ValueError("Both Coordinates need to be 3D")
|
|
super().__init__(top_left, bottom_right)
|