def make_quadtree(points, size_u, size_v, **kwargs):
""" Generates a quadtree-like structure from surface control points.
This function generates a 2-dimensional list of control point coordinates. Considering the object-oriented
representation of a quadtree data structure, first dimension of the generated list corresponds to a list of
*QuadTree* classes. Second dimension of the generated list corresponds to a *QuadTree* data structure. The first
element of the 2nd dimension is the mid-point of the bounding box and the remaining elements are corner points of
the bounding box organized in counter-clockwise order.
To maintain stability for the data structure on the edges and corners, the function accepts ``extrapolate``
keyword argument. If it is *True*, then the function extrapolates the surface on the corners and edges to complete
the quad-like structure for each control point. If it is *False*, no extrapolation will be applied.
By default, ``extrapolate`` is set to *True*.
Please note that this function's intention is not generating a real quadtree structure but reorganizing the
control points in a very similar fashion to make them available for various geometric operations.
:param points: 1-dimensional array of surface control points
:type points: list, tuple
:param size_u: number of control points on the u-direction
:type size_u: int
:param size_v: number of control points on the v-direction
:type size_v: int
:return: control points organized in a quadtree-like structure
:rtype: tuple
"""
# Get keyword arguments
extrapolate = kwargs.get('extrapolate', True)
# Convert control points array into 2-dimensional form
points2d = []
for i in range(0, size_u):
row_list = []
for j in range(0, size_v):
row_list.append(points[j + (i * size_v)])
points2d.append(row_list)
# Traverse 2-dimensional control points to find neighbors
qtree = []
for u in range(size_u):
for v in range(size_v):
temp = [points2d[u][v]]
# Note: negative indexing actually works in Python, so we need explicit checking
if u + 1 < size_u:
temp.append(points2d[u + 1][v])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(
points2d[u - 1][v], points2d[u][v])
translated_point = linalg.point_translate(
points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if v + 1 < size_v:
temp.append(points2d[u][v + 1])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(
points2d[u][v - 1], points2d[u][v])
translated_point = linalg.point_translate(
points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if u - 1 >= 0:
temp.append(points2d[u - 1][v])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(
points2d[u + 1][v], points2d[u][v])
translated_point = linalg.point_translate(
points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if v - 1 >= 0:
temp.append(points2d[u][v - 1])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(
points2d[u][v + 1], points2d[u][v])
translated_point = linalg.point_translate(
points2d[u][v], extrapolated_edge)
temp.append(translated_point)
qtree.append(tuple(temp))
# Return generated quad-tree
return tuple(qtree)
def test_point_translate2():
pt = (1, 0, 0)
vec = (5, 5, 5)
result = [6, 5, 5]
to_check = linalg.point_translate(pt, vec)
assert to_check == result
def test_point_translate3():
with pytest.raises(TypeError):
linalg.point_translate(5, 9.7)
def test_point_translate1():
with pytest.raises(ValueError):
pt1 = ()
pt2 = (1, 2, 3)
linalg.point_translate(pt1, pt2)
def make_quadtree(points, size_u, size_v, **kwargs):
""" Generates a quadtree-like structure from surface control points.
This function generates a 2-dimensional list of control point coordinates. Considering the object-oriented
representation of a quadtree data structure, first dimension of the generated list corresponds to a list of
*QuadTree* classes. Second dimension of the generated list corresponds to a *QuadTree* data structure. The first
element of the 2nd dimension is the mid-point of the bounding box and the remaining elements are corner points of
the bounding box organized in counter-clockwise order.
To maintain stability for the data structure on the edges and corners, the function accepts ``extrapolate``
keyword argument. If it is *True*, then the function extrapolates the surface on the corners and edges to complete
the quad-like structure for each control point. If it is *False*, no extrapolation will be applied.
By default, ``extrapolate`` is set to *True*.
Please note that this function's intention is not generating a real quadtree structure but reorganizing the
control points in a very similar fashion to make them available for various geometric operations.
:param points: 1-dimensional array of surface control points
:type points: list, tuple
:param size_u: number of control points on the u-direction
:type size_u: int
:param size_v: number of control points on the v-direction
:type size_v: int
:return: control points organized in a quadtree-like structure
:rtype: tuple
"""
# Get keyword arguments
extrapolate = kwargs.get('extrapolate', True)
# Convert control points array into 2-dimensional form
points2d = []
for i in range(0, size_u):
row_list = []
for j in range(0, size_v):
row_list.append(points[j + (i * size_v)])
points2d.append(row_list)
# Traverse 2-dimensional control points to find neighbors
qtree = []
for u in range(size_u):
for v in range(size_v):
temp = [points2d[u][v]]
# Note: negative indexing actually works in Python, so we need explicit checking
if u + 1 < size_u:
temp.append(points2d[u+1][v])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(points2d[u - 1][v], points2d[u][v])
translated_point = linalg.point_translate(points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if v + 1 < size_v:
temp.append(points2d[u][v+1])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(points2d[u][v - 1], points2d[u][v])
translated_point = linalg.point_translate(points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if u - 1 >= 0:
temp.append(points2d[u-1][v])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(points2d[u + 1][v], points2d[u][v])
translated_point = linalg.point_translate(points2d[u][v], extrapolated_edge)
temp.append(translated_point)
if v - 1 >= 0:
temp.append(points2d[u][v-1])
else:
if extrapolate:
extrapolated_edge = linalg.vector_generate(points2d[u][v + 1], points2d[u][v])
translated_point = linalg.point_translate(points2d[u][v], extrapolated_edge)
temp.append(translated_point)
qtree.append(tuple(temp))
# Return generated quad-tree
return tuple(qtree)
def test_point_translate3():
with pytest.raises(TypeError):
linalg.point_translate(5, 9.7)
def test_point_translate2():
pt = (1, 0, 0)
vec = (5, 5, 5)
result = [6, 5, 5]
to_check = linalg.point_translate(pt, vec)
assert to_check == result
def test_point_translate1():
with pytest.raises(ValueError):
pt1 = ()
pt2 = (1, 2, 3)
linalg.point_translate(pt1, pt2)