def topo2topotype(occtopology):
"""
This function converts the original OCCtopology of the given topology. e.g. an OCCcompound that is originally an OCCface etc.
Parameters
----------
occtopology : OCCtopology
The OCCtopology to be converted.
OCCtopology includes: OCCshape, OCCcompound, OCCcompsolid, OCCsolid, OCCshell, OCCface, OCCwire, OCCedge, OCCvertex
Returns
-------
original topology : OCCtopology
The original OCCtopology of the input.
"""
shapetype = occtopology.ShapeType()
if shapetype == TopAbs_COMPOUND: #compound
orig_topo = topods_Compound(occtopology)
if shapetype == TopAbs_COMPSOLID: #compsolid
orig_topo = topods_CompSolid(occtopology)
if shapetype == TopAbs_SOLID: #solid
orig_topo = topods_Solid(occtopology)
if shapetype == TopAbs_SHELL: #shell
orig_topo = topods_Shell(occtopology)
if shapetype == TopAbs_FACE: #face
orig_topo = topods_Face(occtopology)
if shapetype == TopAbs_WIRE: #wire
orig_topo = topods_Wire(occtopology)
if shapetype == TopAbs_EDGE: #edge
orig_topo = topods_Edge(occtopology)
if shapetype == TopAbs_VERTEX: #vertex
orig_topo = topods_Vertex(occtopology)
return orig_topo
def topo_explorer(occtopo2explore, topotype2find):
"""
This function explores and fetches the specified topological type from the given OCCtopology.
e.g. find a list of OCCfaces in an OCCcompound.
Parameters
----------
occtopo2explore : OCCtopology
The OCCtopology to be explored.
OCCtopology includes: OCCshape, OCCcompound, OCCcompsolid, OCCsolid, OCCshell, OCCface, OCCwire, OCCedge, OCCvertex
topotype2find : str
The string describing the topology to find.
The strings can be e.g. "compound", "compsolid", "solid", "shell", "face", "wire", "edge", "vertex".
Returns
-------
list of topology : list of OCCtopology
The list of OCCtopology found in the specified OCCtopology.
"""
geom_list = []
if topotype2find == "compound":
shapetype2find_topABS = TopAbs_COMPOUND
if topotype2find == "compsolid":
shapetype2find_topABS = TopAbs_COMPSOLID
if topotype2find == "solid":
shapetype2find_topABS = TopAbs_SOLID
if topotype2find == "shell":
shapetype2find_topABS = TopAbs_SHELL
if topotype2find == "face":
shapetype2find_topABS = TopAbs_FACE
if topotype2find == "wire":
shapetype2find_topABS = TopAbs_WIRE
if topotype2find == "edge":
shapetype2find_topABS = TopAbs_EDGE
if topotype2find == "vertex":
shapetype2find_topABS = TopAbs_VERTEX
ex = TopExp_Explorer(occtopo2explore, shapetype2find_topABS)
while ex.More():
if shapetype2find_topABS == 0:
geom = topods_Compound(ex.Current())
if shapetype2find_topABS == 1:
geom = topods_CompSolid(ex.Current())
if shapetype2find_topABS == 2:
geom = topods_Solid(ex.Current())
if shapetype2find_topABS == 3:
geom = topods_Shell(ex.Current())
if shapetype2find_topABS == 4:
geom = topods_Face(ex.Current())
if shapetype2find_topABS == 5:
geom = topods_Wire(ex.Current())
if shapetype2find_topABS == 6:
geom = topods_Edge(ex.Current())
if shapetype2find_topABS == 7:
geom = topods_Vertex(ex.Current())
geom_list.append(geom)
ex.Next()
return geom_list
def makeWholeWire():
global myWireProfile
xAxis = gp_OX()
# Set up the mirror
aTrsf = gp_Trsf()
aTrsf.SetMirror(xAxis)
# Apply the mirror transform
aBRepTrsf = BRepBuilderAPI_Transform(aWire, aTrsf)
# Convert mirrored shape to a wire
aMirroredShape = aBRepTrsf.Shape()
aMirroredWire = topods_Wire(aMirroredShape)
# Combine the two wires
mkWire = BRepBuilderAPI_MakeWire()
mkWire.Add(aWire)
mkWire.Add(aMirroredWire)
myWireProfile = mkWire.Wire()
return myWireProfile
def makeWholeWire(event=None):
global myWireProfile
xAxis = gp_OX()
# Set up the mirror
aTrsf = gp_Trsf()
aTrsf.SetMirror(xAxis)
# Apply the mirror transform
aBRepTrsf = BRepBuilderAPI_Transform(aWire, aTrsf)
# Convert mirrored shape to a wire
aMirroredShape = aBRepTrsf.Shape()
aMirroredWire = topods_Wire(aMirroredShape)
# Combine the two wires
mkWire = BRepBuilderAPI_MakeWire()
mkWire.Add(aWire)
mkWire.Add(aMirroredWire)
myWireProfile = mkWire.Wire()
display.DisplayColoredShape(myWireProfile, 'BLUE')
display.Repaint()
win.statusBar().showMessage('Make whole wire complete')
def loop(self, loop: TopoDS_Wire):
self._loop = topods_Wire(loop)
def __call__(self, obj, dst=None):
"""
This method performs the deformation on the CAD geometry. If `obj` is a
TopoDS_Shape, the method returns a TopoDS_Shape containing the deformed
geometry. If `obj` is a filename, the method deforms the geometry
contained in the file and writes the deformed shape to `dst` (which has
to be set).
:param obj: the input geometry.
:type obj: str or TopoDS_Shape
:param str dst: if `obj` is a string containing the input filename,
`dst` refers to the file where the deformed geometry is saved.
"""
# Manage input
if isinstance(obj, str): # if a input filename is passed
if dst is None:
raise ValueError(
'Source file is provided, but no destination specified')
shape = self.read_shape(obj)
elif isinstance(obj, TopoDS_Shape):
shape = obj
# Maybe do we need to handle also Compound?
else:
raise TypeError
#create compound to store modified faces
compound_builder = BRep_Builder()
compound = TopoDS_Compound()
compound_builder.MakeCompound(compound)
# cycle on the faces to get the control points
# iterator to faces (TopoDS_Shape) contained in the shape
faces_explorer = TopExp_Explorer(shape, TopAbs_FACE)
while faces_explorer.More():
# performing some conversions to get the right
# format (BSplineSurface)
# TopoDS_Face obtained from iterator
face = topods_Face(faces_explorer.Current())
# performing some conversions to get the right
# format (BSplineSurface)
bspline_surface = self._bspline_surface_from_face(face)
# add the required amount of poles in u and v directions
self._enrich_surface_knots(bspline_surface)
# deform the Bspline surface through FFD
self._deform_bspline_surface(bspline_surface)
# through moving the control points, we now changed the SURFACE
# underlying FACE we are processing. we now need to obtain the
# curves (actually, the WIRES) that define the bounds of the
# surface and TRIM the surface with them, to obtain the new FACE
#we now start really looping on the wires
#we will create a single curve joining all the edges in the wire
# the curve must be a bspline curve so we need to make conversions
# through all the way
# list that will contain the (single) outer wire of the face
outer_wires = []
# list that will contain all the inner wires (holes) of the face
inner_wires = []
# iterator to loop over TopoDS_Wire in the original (undeformed)
# face
wire_explorer = TopExp_Explorer(face, TopAbs_WIRE)
while wire_explorer.More():
# wire obtained from the iterator
wire = topods_Wire(wire_explorer.Current())
# getting a bpline curve joining all the edges of the wire
composite_curve = self._bspline_curve_from_wire(wire)
# adding all the required knots to the Bspline curve
self._enrich_curve_knots(composite_curve)
# deforming the Bspline curve through FFD
self._deform_bspline_curve(composite_curve)
# the GeomCurve corresponding to the whole edge has now
# been deformed. Now we must make it become an proper
# wire
# list of shapes (needed by the wire generator)
shapes_list = TopTools_ListOfShape()
# edge (to be converted to wire) obtained from the modified
# Bspline curve
modified_composite_edge = \
BRepBuilderAPI_MakeEdge(composite_curve).Edge()
# modified edge is added to shapes_list
shapes_list.Append(modified_composite_edge)
# wire builder
wire_maker = BRepBuilderAPI_MakeWire()
wire_maker.Add(shapes_list)
# deformed wire is finally obtained
modified_wire = wire_maker.Wire()
# now, the wire can be outer or inner. we store the outer
# and (possible) inner ones in different lists
# this is because we first need to trim the surface
# using the outer wire, and then we can trim it
# with the wires corresponding to all the holes.
# the wire order is important, in the trimming process
if wire == breptools_OuterWire(face):
outer_wires.append(modified_wire)
else:
inner_wires.append(modified_wire)
wire_explorer.Next()
# so once we finished looping on all the wires to modify them,
# we first use the only outer one to trim the surface
# face builder object
face_maker = BRepBuilderAPI_MakeFace(bspline_surface,
outer_wires[0])
# and then add all other inner wires for the holes
for inner_wire in inner_wires:
face_maker.Add(inner_wire)
# finally, we get our trimmed face with all its holes
trimmed_modified_face = face_maker.Face()
# trimmed_modified_face is added to the modified faces compound
compound_builder.Add(compound, trimmed_modified_face)
# and move to the next face
faces_explorer.Next()
## END SURFACES #################################################
if isinstance(dst, str): # if a input filename is passed
# save the shape exactly to the filename, aka `dst`
self.write_shape(dst, compound)
else:
return compound
polygon.Close()
wire = polygon.Wire()
face = BRepBuilderAPI_MakeFace(wire).Face()
builder.Add(shell, face)
# ==============================================================================
# Explore
# ==============================================================================
polygons = []
tool = BRep_Tool()
wires = TopExp_Explorer(shell, TopAbs_WIRE)
while wires.More():
wire = topods_Wire(wires.Current())
vertices = TopExp_Explorer(wire, TopAbs_VERTEX)
points = []
while vertices.More():
vertex = topods_Vertex(vertices.Current())
point = tool.Pnt(vertex)
x = point.X()
y = point.Y()
z = point.Z()
points.append([x, y, z])
vertices.Next()
polygons.append(points)
wires.Next()
def write_face(self, points_face, list_points_edge, topo_face, toledge):
"""
Method to recreate a Face associated to a geometric surface
after the modification of Face points. It returns a TopoDS_Face.
:param points_face: the new face points array.
:param list_points_edge: new edge points
:param topo_face: the face to be modified
:param toledge: tolerance on the surface creation after modification
:return: TopoDS_Face (Shape)
:rtype: TopoDS_Shape
"""
# convert Face to Geom B-spline Surface
nurbs_converter = BRepBuilderAPI_NurbsConvert(topo_face)
nurbs_converter.Perform(topo_face)
nurbs_face = nurbs_converter.Shape()
topo_nurbsface = topods.Face(nurbs_face)
h_geomsurface = BRep_Tool.Surface(topo_nurbsface)
h_bsurface = geomconvert_SurfaceToBSplineSurface(h_geomsurface)
bsurface = h_bsurface
nb_u = bsurface.NbUPoles()
nb_v = bsurface.NbVPoles()
# check consistency
if points_face.shape[0] != nb_u * nb_v:
raise ValueError("Input control points do not have not have the "
"same number as the geometric face!")
# cycle on the face points
indice_cpt = 0
for iu in range(1, nb_u + 1):
for iv in range(1, nb_v + 1):
cpt = points_face[indice_cpt]
bsurface.SetPole(iu, iv, gp_Pnt(cpt[0], cpt[1], cpt[2]))
indice_cpt += 1
# create modified new face
new_bspline_tface = BRepBuilderAPI_MakeFace()
toler = precision_Confusion()
new_bspline_tface.Init(bsurface, False, toler)
# cycle on the wires
face_wires_explorer = TopExp_Explorer(
topo_nurbsface.Oriented(TopAbs_FORWARD), TopAbs_WIRE)
ind_edge_total = 0
while face_wires_explorer.More():
# get old wire
twire = topods_Wire(face_wires_explorer.Current())
# cycle on the edges
ind_edge = 0
wire_explorer_edge = TopExp_Explorer(
twire.Oriented(TopAbs_FORWARD), TopAbs_EDGE)
# check edges order on the wire
mode3d = True
tolerance_edges = toledge
wire_order = ShapeAnalysis_WireOrder(mode3d, tolerance_edges)
# an edge list
deformed_edges = []
# cycle on the edges
while wire_explorer_edge.More():
tedge = topods_Edge(wire_explorer_edge.Current())
new_bspline_tedge = self.write_edge(
list_points_edge[ind_edge_total], tedge)
deformed_edges.append(new_bspline_tedge)
analyzer = topexp()
vfirst = analyzer.FirstVertex(new_bspline_tedge)
vlast = analyzer.LastVertex(new_bspline_tedge)
pt1 = BRep_Tool.Pnt(vfirst)
pt2 = BRep_Tool.Pnt(vlast)
wire_order.Add(pt1.XYZ(), pt2.XYZ())
ind_edge += 1
ind_edge_total += 1
wire_explorer_edge.Next()
# grouping the edges in a wire, then in the face
# check edges order and connectivity within the wire
wire_order.Perform()
# new wire to be created
stol = ShapeFix_ShapeTolerance()
new_bspline_twire = BRepBuilderAPI_MakeWire()
for order_i in range(1, wire_order.NbEdges() + 1):
deformed_edge_i = wire_order.Ordered(order_i)
if deformed_edge_i > 0:
# insert the deformed edge to the new wire
new_edge_toadd = deformed_edges[deformed_edge_i - 1]
stol.SetTolerance(new_edge_toadd, toledge)
new_bspline_twire.Add(new_edge_toadd)
if new_bspline_twire.Error() != 0:
stol.SetTolerance(new_edge_toadd, toledge * 10.0)
new_bspline_twire.Add(new_edge_toadd)
else:
deformed_edge_revers = deformed_edges[
np.abs(deformed_edge_i) - 1]
stol.SetTolerance(deformed_edge_revers, toledge)
new_bspline_twire.Add(deformed_edge_revers)
if new_bspline_twire.Error() != 0:
stol.SetTolerance(deformed_edge_revers, toledge * 10.0)
new_bspline_twire.Add(deformed_edge_revers)
# add new wire to the Face
new_bspline_tface.Add(new_bspline_twire.Wire())
face_wires_explorer.Next()
return topods.Face(new_bspline_tface.Face())
def parse_face(topo_face):
"""
Method to parse a single `Face` (a single patch nurbs surface).
It returns a matrix with all the coordinates of control points of the
`Face` and a second list with all the control points related to the
`Edges` of the `Face.`
:param Face topo_face: the input Face.
:return: control points of the `Face`, control points related to
`Edges`.
:rtype: tuple(numpy.ndarray, list)
"""
# get some Face - Edge - Vertex data map information
mesh_points_edge = []
face_exp_wire = TopExp_Explorer(topo_face, TopAbs_WIRE)
# loop on wires per face
while face_exp_wire.More():
twire = topods_Wire(face_exp_wire.Current())
wire_exp_edge = TopExp_Explorer(twire, TopAbs_EDGE)
# loop on edges per wire
while wire_exp_edge.More():
edge = topods_Edge(wire_exp_edge.Current())
bspline_converter = BRepBuilderAPI_NurbsConvert(edge)
bspline_converter.Perform(edge)
bspline_tshape_edge = bspline_converter.Shape()
h_geom_edge = BRep_Tool_Curve(
topods_Edge(bspline_tshape_edge))[0]
h_bspline_edge = geomconvert_CurveToBSplineCurve(h_geom_edge)
bspline_geom_edge = h_bspline_edge
nb_poles = bspline_geom_edge.NbPoles()
# Edge geometric properties
edge_ctrlpts = TColgp_Array1OfPnt(1, nb_poles)
bspline_geom_edge.Poles(edge_ctrlpts)
points_single_edge = np.zeros((0, 3))
for i in range(1, nb_poles + 1):
ctrlpt = edge_ctrlpts.Value(i)
ctrlpt_position = np.array(
[[ctrlpt.Coord(1),
ctrlpt.Coord(2),
ctrlpt.Coord(3)]])
points_single_edge = np.append(points_single_edge,
ctrlpt_position,
axis=0)
mesh_points_edge.append(points_single_edge)
wire_exp_edge.Next()
face_exp_wire.Next()
# extract mesh points (control points) on Face
mesh_points_face = np.zeros((0, 3))
# convert Face to Geom B-spline Face
nurbs_converter = BRepBuilderAPI_NurbsConvert(topo_face)
nurbs_converter.Perform(topo_face)
nurbs_face = nurbs_converter.Shape()
h_geomsurface = BRep_Tool.Surface(topods.Face(nurbs_face))
h_bsurface = geomconvert_SurfaceToBSplineSurface(h_geomsurface)
bsurface = h_bsurface
# get access to control points (poles)
nb_u = bsurface.NbUPoles()
nb_v = bsurface.NbVPoles()
ctrlpts = TColgp_Array2OfPnt(1, nb_u, 1, nb_v)
bsurface.Poles(ctrlpts)
for indice_u_direction in range(1, nb_u + 1):
for indice_v_direction in range(1, nb_v + 1):
ctrlpt = ctrlpts.Value(indice_u_direction, indice_v_direction)
ctrlpt_position = np.array(
[[ctrlpt.Coord(1),
ctrlpt.Coord(2),
ctrlpt.Coord(3)]])
mesh_points_face = np.append(mesh_points_face,
ctrlpt_position,
axis=0)
return mesh_points_face, mesh_points_edge