Persson-dev/GDMC-2024
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Working debug roads

Browse Source
This commit is contained in:
Xeon0X
2024-06-15 19:58:58 +02:00
parent 4a611a4aa2
commit a04c3056c9
6 changed files with 191 additions and 43 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
networks/geometry/Point2D.py
View File

@@ -197,9 +197,33 @@ class Point2D:
self.coordinates = (self.x, self.y)
return self
def distance(self, point: "Point2D") -> int:
def distance(self, point: "Point2D") -> float:
return sqrt((point.x - self.x) ** 2 + (point.y - self.y) ** 2)
# def slope(self, point: "Point2D") -> int:
# try:
# slope = (point.y - self.y) / (point.x - self.x)
# return slope
# except ZeroDivisionError:
# return float('inf')
# def is_between_slopes(self, lower_slope: int, upper_slope: int) -> bool:
# slope = self.slope(Point2D(0, 0))
# print("sole", slope, (slope <= upper_slope), (slope >= lower_slope),
# ((slope <= upper_slope) and (slope >= lower_slope)))
# return ((slope <= upper_slope) and (slope >= lower_slope))
# def is_between_lines(self, point_1: "Point2D", point_2: "Point2D", point_a: "Point2D", point_b: "Point2D") -> bool:
# slope_1, slope_a = point_1.slope(point_2), point_a.slope(point_b)
# lower_slope, upper_slope = min(slope_1, slope_a), max(slope_1, slope_a)
# print(self.is_between_slopes(lower_slope, upper_slope), "slope",
# lower_slope, upper_slope, self.slope(Point2D(0, 0)))
# print(self.x <= max(point_1.x, point_2.x, point_a.x, point_b.x), "x max")
# print(self.x >= min(point_1.x, point_2.x, point_a.x, point_b.x), "x min")
# print(self.y <= max(point_1.y, point_2.y, point_a.y, point_b.y), "y max")
# print(self.y >= min(point_1.y, point_2.y, point_a.y, point_b.y), "y min")
# return self.is_between_slopes(lower_slope, upper_slope) and self.x <= max(point_1.x, point_2.x, point_a.x, point_b.x) and self.x >= min(point_1.x, point_2.x, point_a.x, point_b.x) and self.y <= max(point_1.y, point_2.y, point_a.y, point_b.y) and self.y >= min(point_1.y, point_2.y, point_a.y, point_b.y)
@staticmethod
def collinear(p0: "Point2D", p1: "Point2D", p2: "Point2D") -> bool:
# https://stackoverflow.com/questions/9608148/python-script-to-determine-if-x-y-coordinates-are-colinear-getting-some-e

64
networks/geometry/Point3D.py
View File

@@ -1,5 +1,6 @@
from math import sqrt
from typing import List
from typing import List, Union
from networks.geometry.Point2D import Point2D
import numpy as np
@@ -72,23 +73,52 @@ class Point3D:
return sqrt((point.x - self.x) ** 2 + (point.y - self.y) ** 2 + (point.z - self.z) ** 2)
@staticmethod
def to_vectors(points: List["Point3D"]):
vectors = []
for point in points:
vectors.append(np.array(point.coordinates))
if (len(vectors) == 1):
return vectors[0]
else:
def to_arrays(points: Union[List["Point3D"], "Point3D"]) -> Union[List[np.array], "Point3D"]:
if isinstance(points, list):
vectors = []
for point in points:
vectors.append(np.array(point.coordinates))
return vectors
else:
return np.array(points.coordinates)
@staticmethod
def from_arrays(vectors: List[np.array]) -> List["Point3D"]:
points = []
for vector in vectors:
points.append(Point3D(vector[0], vector[1], vector[2]))
if (len(points) == 1):
return points[0]
else:
def from_arrays(vectors: Union[List[np.array], "Point3D"]) -> Union[List["Point3D"], "Point3D"]:
if isinstance(vectors, list):
points = []
for vector in vectors:
points.append(Point3D(vector[0], vector[1], vector[2]))
return points
else:
return Point3D(vectors[0], vectors[1], vectors[2])
@staticmethod
def to_2d(points: List["Point3D"], removed_axis: str) -> List[Point2D]:
points_2d = []
if removed_axis == 'x':
for i in range(len(points)):
points_2d.append(Point2D(points[i].y, points[i].z))
if removed_axis == 'y':
for i in range(len(points)):
points_2d.append(Point2D(points[i].x, points[i].z))
if removed_axis == 'z':
for i in range(len(points)):
points_2d.append(Point2D(points[i].x, points[i].y))
return points_2d
@staticmethod
def insert_3d(points: List[Point2D], position: str, to_insert: List[int]) -> List["Point3D"]:
points_3d = []
if position == 'x':
for i in range(len(points)):
points_3d.append(
Point3D(to_insert[i], points[i].x, points[i].y))
if position == 'y':
for i in range(len(points)):
points_3d.append(
Point3D(points[i].x, to_insert[i], points[i].y))
if position == 'z':
for i in range(len(points)):
points_3d.append(
Point3D(points[i].x, points[i].y, to_insert[i]))
return points_3d

31
networks/geometry/Polyline.py
View File

@@ -47,7 +47,7 @@ class Polyline:
# list of tuple of points (first intersection, corresponding corner, last intersection)
self.acrs_intersections = [None] * self.length_polyline
self.arcs = [[]] * self.length_polyline # list of points
# self.not_arcs = [[]] * self.length_polyline
self.bisectors = [None] * self.length_polyline
# For n points, there is n-1 segments. Last element should stays None.
self.segments = [None] * \
@@ -106,16 +106,11 @@ class Polyline:
for j in range(len(circle.points)):
if circle.points[j].is_in_triangle(self.acrs_intersections[i][0], self.acrs_intersections[i][1], self.acrs_intersections[i][2]):
self.arcs[i].append(circle.points[j])
# for j in range(len(circle.points)):
# if (circle.points[j] in Segment2D(self.acrs_intersections[i][0], self.acrs_intersections[i][1]).segment(LINE_OVERLAP.MINOR)):
# self.not_arcs[i].append(circle.points[j])
# print("hzeh")
# if (circle.points[j] in Segment2D(self.acrs_intersections[i][1], self.acrs_intersections[i][2]).segment(LINE_OVERLAP.MINOR)):
# self.not_arcs[i].append(circle.points[j])
# print("hzeh")
# if (circle.points[j] in Segment2D(self.acrs_intersections[i][2], self.acrs_intersections[i][0]).segment(LINE_OVERLAP.MINOR)):
# self.not_arcs[i].append(circle.points[j])
# print("hzeh")
self.bisectors[i] = Point2D.to_arrays(
self.centers[i]) + (self.unit_vectors[i-1] - self.points_array[i])
(self.unit_vectors[i]+self.unit_vectors[i-1]) / \
np.linalg.norm(self.unit_vectors[i]-self.unit_vectors[i-1])
return self.arcs
def get_segments(self) -> List[Segment2D]:
@@ -133,14 +128,14 @@ class Polyline:
self.points_array[0]), self.acrs_intersections[1][0])
# Get segments between arcs
for i in range(2, self.length_polyline - 2):
for i in range(2, self.length_polyline - 1):
self.segments[i] = Segment2D(Point2D(self.acrs_intersections[i][0].x, self.acrs_intersections[i][0].y), Point2D(
self.acrs_intersections[i-1][-1].x, self.acrs_intersections[i-1][-1].y))
# Get last segment. Index is -2 because last index -1 should be None due to the same list lenght.
# For n points, there are n-1 segments.
self.segments[-2] = Segment2D(Point2D.from_arrays(
self.points_array[-1]), self.acrs_intersections[-2][2])
self.segments[-2] = Segment2D(self.acrs_intersections[-2][2], Point2D.from_arrays(
self.points_array[-1]))
return self.segments
@@ -205,9 +200,11 @@ class Polyline:
self.unit_vectors[j] = self.vectors[j]/self.lengths[j]
# Between two segments, there is only one angle
for k in range(1, self.length_polyline-1):
dot = np.dot(self.unit_vectors[k], self.unit_vectors[k-1])
self.tangente[k] = sqrt((1+dot)/(1-dot))
for i in range(1, self.length_polyline-1):
dot = np.dot(self.unit_vectors[i], self.unit_vectors[i-1])
self.tangente[i] = sqrt((1+dot)/(1-dot))
# self.bisectors[i] = (self.unit_vectors[i]+self.unit_vectors[i-1]) / \
# np.linalg.norm(self.unit_vectors[i]-self.unit_vectors[i-1])
def _compute_alpha_radii(self):
self.alpha_radii[0] = 0