def interpolate_points_to_spline_no_tangency(list_of_points,
filter_pts=True,
closed=False,
tolerance=TOLERANCE):
'''
GeomAPI_Interpolate is buggy: need to use `fix`
in order to get the right points in...
'''
def fix(li, _type):
'''function factory for 1-dimensional TCol* types'''
pts = _type(1, len(li))
for n, i in enumerate(li):
pts.SetValue(n + 1, i)
pts.thisown = False
return pts
if filter_pts:
list_of_points = filter_points_by_distance(list_of_points, 0.1)
fixed_points = fix(list_of_points, TColgp_HArray1OfPnt)
try:
interp = GeomAPI_Interpolate(fixed_points.GetHandle(), closed,
tolerance)
interp.Perform()
if interp.IsDone():
return interp.Curve()
except RuntimeError:
# the exception was unclear
raise RuntimeError('FAILED TO INTERPOLATE THE POINTS')
def _interpolate(pnts, tangs=None, closed=False):
_pnts = opencascade_h_array1_of_pnt(pnts)
algo = GeomAPI_Interpolate(_pnts, closed, 0.0000001)
if tangs is not None:
for i in range(len(tangs)):
if tangs[i] is None:
tangs[i] = vector3(0, 0, 0)
if (len(tangs) != 0):
_tangs = opencascade_array1_of_vec(tangs)
_bools = TColStd_HArray1OfBoolean(1, len(tangs))
for i in range(len(pnts)):
_bools.SetValue(i + 1, bool(numpy.linalg.norm(tangs[i]) != 0))
algo.Load(_tangs, _bools)
algo.Perform()
return Curve(algo.Curve())
def from_interpolation(cls, points, precision=1e-3):
"""Construct a NURBS curve by interpolating a set of points.
Parameters
----------
points : list[:class:`~compas.geometry.Point`]
The control points of the curve.
precision : float, optional
The precision of the interpolation.
Returns
-------
:class:`OCCNurbsCurve`
"""
interp = GeomAPI_Interpolate(harray1_from_points1(points), False,
precision)
interp.Perform()
curve = cls()
curve.occ_curve = interp.Curve()
return curve
def interpolate_points_to_spline(list_of_points,
start_tangent,
end_tangent,
filter_pts=True,
tolerance=TOLERANCE):
'''
GeomAPI_Interpolate is buggy: need to use `fix` in order
to get the right points in...
'''
def fix(li, _type):
'''function factory for 1-dimensional TCol* types'''
pts = _type(1, len(li))
for n, i in enumerate(li):
pts.SetValue(n + 1, i)
pts.thisown = False
return pts
if filter_pts:
list_of_points = filter_points_by_distance(list_of_points, 0.1)
fixed_points = fix(list_of_points, TColgp_HArray1OfPnt)
try:
interp = GeomAPI_Interpolate(fixed_points.GetHandle(), False,
tolerance)
interp.Load(start_tangent, end_tangent, False)
interp.Perform()
if interp.IsDone():
return interp.Curve()
except RuntimeError:
print("Failed to interpolate the shown points")
def interpolate_points_vectors_to_spline(list_of_points, list_of_vectors, vector_mask=None, tolerance=TOLERANCE):
'''
build a curve from a set of points and vectors
the vectors describe the tangent vector at the corresponding point
'''
# GeomAPI_Interpolate is buggy: need to use `fix` in order to
# get the right points in...
assert len(list_of_points) == len(list_of_vectors), 'vector and point list not of same length'
def fix(li, _type):
'''function factory for 1-dimensional TCol* types'''
pts = _type(1, len(li))
for n, i in enumerate(li):
pts.SetValue(n+1, i)
pts.thisown = False
return pts
if vector_mask is not None:
assert len(vector_mask) == len(list_of_points), 'length vector mask is not of length points list nor []'
else:
vector_mask = [True for i in range(len(list_of_points))]
fixed_mask = fix(vector_mask, TColStd_HArray1OfBoolean)
fixed_points = fix(list_of_points, TColgp_HArray1OfPnt)
fixed_vectors = fix(list_of_vectors, TColgp_Array1OfVec)
try:
interp = GeomAPI_Interpolate(fixed_points.GetHandle(), False, tolerance)
interp.Load(fixed_vectors, fixed_mask.GetHandle(), False)
interp.Perform()
if interp.IsDone():
return interp.Curve()
except RuntimeError:
# the exception was unclear
raise RuntimeError('FAILED TO INTERPOLATE THE POINTS')
def _generate_lower_face(self, maxDeg):
"""
Private method to generate the blade lower face.
:param int maxDeg: Define the maximal U degree of generated surface
"""
self._import_occ_libs()
# Initializes ThruSections algorithm for building a shell passing
# through a set of sections (wires). The generated faces between
# the edges of every two consecutive wires are smoothed out with
# a precision criterion = 1e-10
generator = BRepOffsetAPI_ThruSections(False, False, 1e-10)
generator.SetMaxDegree(maxDeg)
# Define upper edges (wires) for the face generation
for i in range(self.n_sections):
npoints = len(self.blade_coordinates_down[i][0])
vertices = TColgp_HArray1OfPnt(1, npoints)
for j in range(npoints):
vertices.SetValue(
j + 1,
gp_Pnt(1000 * self.blade_coordinates_down[i][0][j],
1000 * self.blade_coordinates_down[i][1][j],
1000 * self.blade_coordinates_down[i][2][j]))
# Initializes an algorithm for constructing a constrained
# BSpline curve passing through the points of the blade i-th
# section, with tolerance = 1e-9
bspline = GeomAPI_Interpolate(vertices, False, 1e-9)
bspline.Perform()
edge = BRepBuilderAPI_MakeEdge(bspline.Curve()).Edge()
if i == 0:
bound_root_edge = edge
# Add BSpline wire to the generator constructor
generator.AddWire(BRepBuilderAPI_MakeWire(edge).Wire())
# Returns the shape built by the shape construction algorithm
generator.Build()
# Returns the Face generated by each edge of the first section
self.generated_lower_face = generator.GeneratedFace(bound_root_edge)
def _generate_tip(self, maxDeg):
"""
Private method to generate the surface that closing the blade tip.
:param int maxDeg: Define the maximal U degree of generated surface
"""
self._import_occ_libs()
generator = BRepOffsetAPI_ThruSections(False, False, 1e-10)
generator.SetMaxDegree(maxDeg)
# npoints_up == npoints_down
npoints = len(self.blade_coordinates_down[-1][0])
vertices_1 = TColgp_HArray1OfPnt(1, npoints)
vertices_2 = TColgp_HArray1OfPnt(1, npoints)
for j in range(npoints):
vertices_1.SetValue(
j + 1,
gp_Pnt(1000 * self.blade_coordinates_down[-1][0][j],
1000 * self.blade_coordinates_down[-1][1][j],
1000 * self.blade_coordinates_down[-1][2][j]))
vertices_2.SetValue(
j + 1,
gp_Pnt(1000 * self.blade_coordinates_up[-1][0][j],
1000 * self.blade_coordinates_up[-1][1][j],
1000 * self.blade_coordinates_up[-1][2][j]))
# Initializes an algorithm for constructing a constrained
# BSpline curve passing through the points of the blade last
# section, with tolerance = 1e-9
bspline_1 = GeomAPI_Interpolate(vertices_1, False, 1e-9)
bspline_1.Perform()
bspline_2 = GeomAPI_Interpolate(vertices_2, False, 1e-9)
bspline_2.Perform()
edge_1 = BRepBuilderAPI_MakeEdge(bspline_1.Curve()).Edge()
edge_2 = BRepBuilderAPI_MakeEdge(bspline_2.Curve()).Edge()
# Add BSpline wire to the generator constructor
generator.AddWire(BRepBuilderAPI_MakeWire(edge_1).Wire())
generator.AddWire(BRepBuilderAPI_MakeWire(edge_2).Wire())
# Returns the shape built by the shape construction algorithm
generator.Build()
# Returns the Face generated by each edge of the first section
self.generated_tip = generator.GeneratedFace(edge_1)