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

Fix 3d bresenham

Browse Source
This commit is contained in:
Xeon0X
2024-06-12 20:49:20 +02:00
parent 7ad9b45f6c
commit bbdd59ca9b
4 changed files with 77 additions and 49 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
networks/geometry/Polyline.py
View File

@@ -18,21 +18,22 @@ class Polyline:
>>> Polyline((Point2D(0, 0), Point2D(0, 10), Point2D(50, 10), Point2D(20, 20)))
"""
self.coordinates = points
self.points = Point2D.to_vectors(points)
self.length_polyline = len(points)
if self.length_polyline < 4:
raise ValueError("The list must contain at least 4 elements.")
self.vectors = [None] * self.length_polyline
self.lengths = [None] * self.length_polyline
self.unit_vectors = [None] * self.length_polyline
self.tangente = [0] * self.length_polyline
self.vectors = [None] * self.length_polyline # v
self.lengths = [None] * self.length_polyline # l
self.unit_vectors = [None] * self.length_polyline # n
self.tangente = [0] * self.length_polyline # f
self.alpha_radii = [None] * self.length_polyline
self.alpha_radii = [None] * self.length_polyline # alpha
self.radii = [None] * self.length_polyline
self.centers = [None] * self.length_polyline
self.radii = [None] * self.length_polyline # r
self.centers = [None] * self.length_polyline # c
self._compute_requirements()
self._compute_alpha_radii()
@@ -42,19 +43,19 @@ class Polyline:
def __repr__(self):
return str(self.alpha_radii)
def get_radius(self):
def get_radii(self):
for i in range(1, self.length_polyline-1):
self.radii[i] = self.alpha_radii[i] * self.tangente[i]
self.radii[i] = round(self.alpha_radii[i] * self.tangente[i])
return self.radii
def get_centers(self):
print(self.radii)
for i in range(1, self.length_polyline-2):
print(i)
bi = (self.unit_vectors[i] + self.unit_vectors[i-1]) / \
np.linalg.norm(self.unit_vectors[i] - self.unit_vectors[i-1])
self.centers[i] = self.points[i] + \
sqrt(self.radii[i] ** 2 + self.alpha_radii[i] ** 2) * bi
for i in range(1, self.length_polyline-1):
bisector = (self.unit_vectors[i] - self.unit_vectors[i-1]) / (
np.linalg.norm(self.unit_vectors[i] + self.unit_vectors[i-1]))
array = self.points[i] + sqrt(self.radii[i]
** 2 + self.alpha_radii[i] ** 2) * bisector
self.centers[i] = Point2D(array[0], array[1]).round()
return self.centers
def _alpha_assign(self, start_index: int, end_index: int):
@@ -69,22 +70,21 @@ class Polyline:
alpha_b = min(
self.lengths[start_index] - self.alpha_radii[start_index], self.lengths[start_index + 1])
current_radius = max(self.tangente[start_index] * self.alpha_radii[start_index],
self.tangente[start_index + 1] * alpha_b) # Radis at initial segment
self.tangente[start_index + 1] * alpha_b) # Radius at initial segment
if current_radius < minimum_radius:
minimum_radius, minimum_index = current_radius, start_index # 8, 0
minimum_radius, minimum_index = current_radius, start_index
# 0, 8
alpha_low, alpha_high = self.alpha_radii[start_index], alpha_b
for i in range(start_index + 1, end_index - 1): # Radii for internal segments
alpha_a, alpha_b, current_radius = self._radius_balance(
i) # i = 1 # 4, 4, 4,
if current_radius < minimum_radius: # 4 < 8
minimum_radius, minimum_index = current_radius, i # 4, 1
alpha_low, alpha_high = alpha_a, alpha_b # 4, 4
alpha_a, alpha_b, current_radius = self._radius_balance(i)
if current_radius < minimum_radius:
minimum_radius, minimum_index = current_radius, i
alpha_low, alpha_high = alpha_a, alpha_b
alpha_a = min(self.lengths[end_index-2],
self.lengths[end_index-1]-self.alpha_radii[end_index]) # 8
self.lengths[end_index-1]-self.alpha_radii[end_index])
current_radius = max(self.tangente[end_index-1]*alpha_a, self.tangente[end_index]
* self.alpha_radii[end_index]) # Radius at final segment
@@ -106,13 +106,10 @@ class Polyline:
"""
Returns the radius that balances the radii on either end segement i.
"""
alpha_a = min(self.lengths[i-1], (self.lengths[i]*self.tangente[i+1]) /
(self.tangente[i] + self.tangente[i+1]))
alpha_b = min(self.lengths[i+1], self.lengths[i]-alpha_a)
print(alpha_a, alpha_b, max(
self.tangente[i]*alpha_a, self.tangente[i+1]*alpha_b))
return alpha_a, alpha_b, max(self.tangente[i]*alpha_a, self.tangente[i+1]*alpha_b)
return alpha_a, alpha_b, min(self.tangente[i]*alpha_a, self.tangente[i+1]*alpha_b)
def _compute_requirements(self):
# Between two points, there is only one segment
@@ -123,13 +120,9 @@ class Polyline:
# 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])
dot = np.dot(self.unit_vectors[k], -self.unit_vectors[k-1])
self.tangente[k] = sqrt((1+dot)/(1-dot))
def _compute_alpha_radii(self):
self.alpha_radii[0] = 0
self.alpha_radii[self.length_polyline-1] = 0
# for i in range(1, self.length_polyline-2):
# self.alpha_radii[i] = min(self.lengths[i-1] - self.alpha_radii[i-1], (self.lengths[i]
# * self.tangente[i+1])/(self.tangente[i]+self.tangente[i+1]))