def get_edges(shape, unique=True):
"""
Get edges from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:param bool unique: Option to return only unique edges.
:return: Edges of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Edge]
"""
if isinstance(shape, TopoDS_Edge):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_EDGE)
edges = []
while exp.More():
ei = exp.Current()
edge = TopoDS.Edge_(ei)
if unique:
is_unique = True
for e in edges:
if e.IsSame(edge):
is_unique = False
break
if is_unique:
edges.append(edge)
else:
edges.append(edge)
exp.Next()
return edges
def get_vertices(shape, unique=True):
"""
Get vertices from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:param bool unique: Option to return only unique vertices.
:return: Vertices of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Vertex]
"""
if isinstance(shape, TopoDS_Vertex):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_VERTEX)
vertices = []
while exp.More():
vi = exp.Current()
vertex = TopoDS.Vertex_(vi)
if unique:
is_unique = True
for v in vertices:
if v.IsSame(vertex):
is_unique = False
break
if is_unique:
vertices.append(vertex)
else:
vertices.append(vertex)
exp.Next()
return vertices
def split_edge_with_face(event=None):
display.EraseAll()
p0 = gp_Pnt()
vnorm = gp_Dir(1, 0, 0)
pln = gp_Pln(p0, vnorm)
face = BRepBuilderAPI_MakeFace(pln, -10, 10, -10, 10).Face()
p1 = gp_Pnt(0, 0, 15)
p2 = gp_Pnt(0, 0, -15)
edge = BRepBuilderAPI_MakeEdge(p1, p2).Edge()
# Initialize splitter
splitter = BOPAlgo_Splitter()
# Add the edge as an argument and the face as a tool. This will split
# the edge with the face.
splitter.AddArgument(edge)
splitter.AddTool(face)
splitter.Perform()
edges = []
exp = TopExp_Explorer(splitter.Shape(), TopAbs_EDGE)
while exp.More():
edges.append(exp.Current())
exp.Next()
print('Number of edges in split shape: ', len(edges))
display.DisplayShape(edges[0], color='red')
display.DisplayShape(edges[1], color='green')
display.DisplayShape(edges[2], color='yellow')
display.FitAll()
def draft_angle(event=None):
S = BRepPrimAPI_MakeBox(200., 300., 150.).Shape()
adraft = BRepOffsetAPI_DraftAngle(S)
topExp = TopExp_Explorer()
topExp.Init(S, TopAbs_FACE)
while topExp.More():
face = topods_Face(topExp.Current())
surf = Geom_Plane.DownCast(BRep_Tool_Surface(face))
dirf = surf.Pln().Axis().Direction()
ddd = gp_Dir(0, 0, 1)
if dirf.IsNormal(ddd, precision_Angular()):
adraft.Add(face, ddd, math.radians(15), gp_Pln(gp_Ax3(gp_XOY())))
topExp.Next()
adraft.Build()
display.DisplayShape(adraft.Shape(), update=True)
def get_faces(_shape):
""" return the faces from `_shape`
:param _shape: TopoDS_Shape, or a subclass like TopoDS_Solid
:return: a list of faces found in `_shape`
"""
topExp = TopExp_Explorer()
topExp.Init(_shape, TopAbs_FACE)
_faces = []
while topExp.More():
fc = topods_Face(topExp.Current())
_faces.append(fc)
topExp.Next()
return _faces
def _get_shapes(self, type_):
"""
Get sub-shapes of a specified type from the shape.
"""
explorer = TopExp_Explorer(self.object, type_)
shapes = []
while explorer.More():
si = Shape.wrap(explorer.Current())
is_unique = True
for s in shapes:
if s.is_same(si):
is_unique = False
break
if is_unique:
shapes.append(si)
explorer.Next()
return shapes
def get_solids(shape):
"""
Get solids from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:return: Solids of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Solid]
"""
if isinstance(shape, TopoDS_Solid):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_SOLID)
solids = []
while exp.More():
si = exp.Current()
solid = TopoDS.Solid_(si)
solids.append(solid)
exp.Next()
return solids
def get_faces(shape):
"""
Get faces from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:return: Faces of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Face]
"""
if isinstance(shape, TopoDS_Face):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_FACE)
faces = []
while exp.More():
fi = exp.Current()
face = TopoDS.Face_(fi)
faces.append(face)
exp.Next()
return faces
def get_wires(shape):
"""
Get wires from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:return: Wires of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Wire]
"""
if isinstance(shape, TopoDS_Wire):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_WIRE)
wires = []
while exp.More():
wi = exp.Current()
wire = TopoDS.Wire_(wi)
wires.append(wire)
exp.Next()
return wires
def get_compounds(shape):
"""
Get compounds from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:return: Compounds of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Compound]
"""
if isinstance(shape, TopoDS_Compound):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_COMPOUND)
compounds = []
while exp.More():
ci = exp.Current()
compound = TopoDS.Compound_(ci)
compounds.append(compound)
exp.Next()
return compounds
def get_shells(shape):
"""
Get shells from a shape.
:param OCCT.TopoDS.TopoDS_Shape shape: The shape.
:return: Shells of shape.
:rtype: list[OCCT.TopoDS.TopoDS_Shell]
"""
if isinstance(shape, TopoDS_Shell):
return [shape]
exp = TopExp_Explorer(shape, TopAbs_SHELL)
shells = []
while exp.More():
si = exp.Current()
shell = TopoDS.Shell_(si)
shells.append(shell)
exp.Next()
return shells
def simple_mesh():
#
# Create the shape
#
theBox = BRepPrimAPI_MakeBox(200, 60, 60).Shape()
theSphere = BRepPrimAPI_MakeSphere(gp_Pnt(100, 20, 20), 80).Shape()
shape = BRepAlgoAPI_Fuse(theSphere, theBox).Shape()
#
# Mesh the shape
#
BRepMesh_IncrementalMesh(shape, 0.8)
builder = BRep_Builder()
comp = TopoDS_Compound()
builder.MakeCompound(comp)
bt = BRep_Tool()
ex = TopExp_Explorer(shape, TopAbs_FACE)
while ex.More():
face = topods_Face(ex.Current())
location = TopLoc_Location()
facing = (bt.Triangulation(face, location))
tab = facing.Nodes()
tri = facing.Triangles()
for i in range(1, facing.NbTriangles() + 1):
trian = tri.Value(i)
index1, index2, index3 = trian.Get()
for j in range(1, 4):
if j == 1:
m = index1
n = index2
elif j == 2:
n = index3
elif j == 3:
m = index2
me = BRepBuilderAPI_MakeEdge(tab.Value(m), tab.Value(n))
if me.IsDone():
builder.Add(comp, me.Edge())
ex.Next()
display.EraseAll()
display.DisplayShape(shape)
display.DisplayShape(comp, update=True)
def _build_solid(compound, divide_closed):
"""
Method to try and build a valid solid from an OpenVSP component.
"""
# Get all the faces in the compound. The surfaces must be split. Discard
# any with zero area.
top_exp = TopExp_Explorer(compound, TopAbs_FACE)
faces = []
while top_exp.More():
shape = top_exp.Current()
face = CheckShape.to_face(shape)
fprop = GProp_GProps()
BRepGProp.SurfaceProperties_(face, fprop, 1.0e-7)
a = fprop.Mass()
if a <= 1.0e-7:
top_exp.Next()
continue
faces.append(face)
top_exp.Next()
# Replace any planar B-Spline surfaces with planes
non_planar_faces = []
planar_faces = []
for f in faces:
hsrf = BRep_Tool.Surface_(f)
try:
is_pln = GeomLib_IsPlanarSurface(hsrf, 1.0e-7)
if is_pln.IsPlanar():
w = ShapeAnalysis.OuterWire_(f)
# Fix the wire because they are usually degenerate edges in
# the planar end caps.
builder = BRepBuilderAPI_MakeWire()
for e in ExploreShape.get_edges(w):
if LinearProps(e).length > 1.0e-7:
builder.Add(e)
w = builder.Wire()
fix = ShapeFix_Wire()
fix.Load(w)
geom_pln = Geom_Plane(is_pln.Plan())
fix.SetSurface(geom_pln)
fix.FixReorder()
fix.FixConnected()
fix.FixEdgeCurves()
fix.FixDegenerated()
w = fix.WireAPIMake()
# Build the planar face
fnew = BRepBuilderAPI_MakeFace(w, True).Face()
planar_faces.append(fnew)
else:
non_planar_faces.append(f)
except RuntimeError:
non_planar_faces.append(f)
# Make a compound of the faces
shape = CreateShape.compound(non_planar_faces + planar_faces)
# Split closed faces
if divide_closed:
divide = ShapeUpgrade_ShapeDivideClosed(shape)
divide.Perform()
shape = divide.Result()
# Sew shape
sew = BRepBuilderAPI_Sewing(1.0e-7)
sew.Load(shape)
sew.Perform()
sewn_shape = sew.SewedShape()
if sewn_shape.ShapeType() == TopAbs_FACE:
face = sewn_shape
sewn_shape = TopoDS_Shell()
builder = BRep_Builder()
builder.MakeShell(sewn_shape)
builder.Add(sewn_shape, face)
# Attempt to unify planar domains
unify_shp = ShapeUpgrade_UnifySameDomain(sewn_shape, False, True, False)
unify_shp.Build()
shape = unify_shp.Shape()
# Make solid
shell = ExploreShape.get_shells(shape)[0]
solid = ShapeFix_Solid().SolidFromShell(shell)
# Limit tolerance
FixShape.limit_tolerance(solid)
# Check shape validity
check_shp = BRepCheck_Analyzer(solid, True)
if check_shp.IsValid():
return solid, True, []
else:
invalid_shapes = _topods_iterator_check(solid, check_shp)
return solid, False, invalid_shapes
topexp_FirstVertex, topexp_LastVertex)
from OCCT.TopAbs import TopAbs_VERTEX, TopAbs_EDGE
from OCCT.TopTools import (TopTools_IndexedDataMapOfShapeListOfShape,
TopTools_ListIteratorOfListOfShape)
from OCCT.TopoDS import topods_Vertex, topods_Edge
from OCC.Display.SimpleGui import init_display
display, start_display, add_menu, add_function_to_menu = init_display()
# create shape
cube = BRepPrimAPI_MakeBox(100, 100, 100).Shape()
topExp = TopExp_Explorer()
topExp.Init(cube, TopAbs_VERTEX)
# get two vertices
vertA = topods_Vertex(topExp.Current())
topExp.Next()
vertB = topods_Vertex(topExp.Current())
def vertex_fillet(cube_shp, vert):
# apply a fillet on incident edges on a vertex
afillet = BRepFilletAPI_MakeFillet(cube_shp)
cnt = 0
# find edges from vertex
_map = TopTools_IndexedDataMapOfShapeListOfShape()
topexp_MapShapesAndAncestors(cube_shp, TopAbs_VERTEX, TopAbs_EDGE, _map)
results = _map.FindFromKey(vert)
topology_iterator = TopTools_ListIteratorOfListOfShape(results)
while topology_iterator.More():
edge = topods_Edge(topology_iterator.Value())
class Topo(object):
'''
Topology traversal
'''
def __init__(self, myShape, ignore_orientation=False):
"""
implements topology traversal from any TopoDS_Shape
this class lets you find how various topological entities are connected from one to another
find the faces connected to an edge, find the vertices this edge is made from, get all faces connected to
a vertex, and find out how many topological elements are connected from a source
*note* when traversing TopoDS_Wire entities, its advised to use the specialized
``WireExplorer`` class, which will return the vertices / edges in the expected order
:param myShape: the shape which topology will be traversed
:param ignore_orientation: filter out TopoDS_* entities of similar TShape but different Orientation
for instance, a cube has 24 edges, 4 edges for each of 6 faces
that results in 48 vertices, while there are only 8 vertices that have a unique
geometric coordinate
in certain cases ( computing a graph from the topology ) its preferable to return
topological entities that share similar geometry, though differ in orientation
by setting the ``ignore_orientation`` variable
to True, in case of a cube, just 12 edges and only 8 vertices will be returned
for further reference see TopoDS_Shape IsEqual / IsSame methods
"""
self.myShape = myShape
self.ignore_orientation = ignore_orientation
# the topoFactory dicts maps topology types and functions that can
# create this topology
self.topoFactory = {
TopAbs_VERTEX: topods.Vertex,
TopAbs_EDGE: topods.Edge,
TopAbs_FACE: topods.Face,
TopAbs_WIRE: topods.Wire,
TopAbs_SHELL: topods.Shell,
TopAbs_SOLID: topods.Solid,
TopAbs_COMPOUND: topods.Compound,
TopAbs_COMPSOLID: topods.CompSolid
}
def _loop_topo(self,
topologyType,
topologicalEntity=None,
topologyTypeToAvoid=None):
'''
this could be a faces generator for a python TopoShape class
that way you can just do:
for face in srf.faces:
processFace(face)
'''
topoTypes = {
TopAbs_VERTEX: TopoDS_Vertex,
TopAbs_EDGE: TopoDS_Edge,
TopAbs_FACE: TopoDS_Face,
TopAbs_WIRE: TopoDS_Wire,
TopAbs_SHELL: TopoDS_Shell,
TopAbs_SOLID: TopoDS_Solid,
TopAbs_COMPOUND: TopoDS_Compound,
TopAbs_COMPSOLID: TopoDS_CompSolid
}
assert topologyType in topoTypes.keys(), '%s not one of %s' % (
topologyType, topoTypes.keys())
self.topExp = TopExp_Explorer()
# use self.myShape if nothing is specified
if topologicalEntity is None and topologyTypeToAvoid is None:
self.topExp.Init(self.myShape, topologyType)
elif topologicalEntity is None and topologyTypeToAvoid is not None:
self.topExp.Init(self.myShape, topologyType, topologyTypeToAvoid)
elif topologyTypeToAvoid is None:
self.topExp.Init(topologicalEntity, topologyType)
elif topologyTypeToAvoid:
self.topExp.Init(topologicalEntity, topologyType,
topologyTypeToAvoid)
seq = []
hashes = [] # list that stores hashes to avoid redundancy
occ_seq = TopTools_ListOfShape()
while self.topExp.More():
current_item = self.topExp.Current()
current_item_hash = current_item.__hash__()
if not current_item_hash in hashes:
hashes.append(current_item_hash)
occ_seq.Append(current_item)
self.topExp.Next()
# Convert occ_seq to python list
occ_iterator = TopTools_ListIteratorOfListOfShape(occ_seq)
while occ_iterator.More():
topo_to_add = self.topoFactory[topologyType](occ_iterator.Value())
seq.append(topo_to_add)
occ_iterator.Next()
if self.ignore_orientation:
# filter out those entities that share the same TShape
# but do *not* share the same orientation
filter_orientation_seq = []
for i in seq:
_present = False
for j in filter_orientation_seq:
if i.IsSame(j):
_present = True
break
if _present is False:
filter_orientation_seq.append(i)
return filter_orientation_seq
else:
return iter(seq)
def faces(self):
'''
loops over all faces
'''
return self._loop_topo(TopAbs_FACE)
def _number_of_topo(self, iterable):
n = 0
for i in iterable:
n += 1
return n
def number_of_faces(self):
return self._number_of_topo(self.faces())
def vertices(self):
'''
loops over all vertices
'''
return self._loop_topo(TopAbs_VERTEX)
def number_of_vertices(self):
return self._number_of_topo(self.vertices())
def edges(self):
'''
loops over all edges
'''
return self._loop_topo(TopAbs_EDGE)
def number_of_edges(self):
return self._number_of_topo(self.edges())
def wires(self):
'''
loops over all wires
'''
return self._loop_topo(TopAbs_WIRE)
def number_of_wires(self):
return self._number_of_topo(self.wires())
def shells(self):
'''
loops over all shells
'''
return self._loop_topo(TopAbs_SHELL, None)
def number_of_shells(self):
return self._number_of_topo(self.shells())
def solids(self):
'''
loops over all solids
'''
return self._loop_topo(TopAbs_SOLID, None)
def number_of_solids(self):
return self._number_of_topo(self.solids())
def comp_solids(self):
'''
loops over all compound solids
'''
return self._loop_topo(TopAbs_COMPSOLID)
def number_of_comp_solids(self):
return self._number_of_topo(self.comp_solids())
def compounds(self):
'''
loops over all compounds
'''
return self._loop_topo(TopAbs_COMPOUND)
def number_of_compounds(self):
return self._number_of_topo(self.compounds())
def ordered_vertices_from_wire(self, wire):
'''
@param wire: TopoDS_Wire
'''
we = WireExplorer(wire)
return we.ordered_vertices()
def number_of_ordered_vertices_from_wire(self, wire):
return self._number_of_topo(self.ordered_vertices_from_wire(wire))
def ordered_edges_from_wire(self, wire):
'''
@param wire: TopoDS_Wire
'''
we = WireExplorer(wire)
return we.ordered_edges()
def number_of_ordered_edges_from_wire(self, wire):
return self._number_of_topo(self.ordered_edges_from_wire(wire))
def _map_shapes_and_ancestors(self, topoTypeA, topoTypeB,
topologicalEntity):
'''
using the same method
@param topoTypeA:
@param topoTypeB:
@param topologicalEntity:
'''
topo_set = set()
_map = TopTools_IndexedDataMapOfShapeListOfShape()
topexp_MapShapesAndAncestors(self.myShape, topoTypeA, topoTypeB, _map)
results = _map.FindFromKey(topologicalEntity)
if results.IsEmpty():
yield None
topology_iterator = TopTools_ListIteratorOfListOfShape(results)
while topology_iterator.More():
topo_entity = self.topoFactory[topoTypeB](
topology_iterator.Value())
# return the entity if not in set
# to assure we're not returning entities several times
if not topo_entity in topo_set:
if self.ignore_orientation:
unique = True
for i in topo_set:
if i.IsSame(topo_entity):
unique = False
break
if unique:
yield topo_entity
else:
yield topo_entity
topo_set.add(topo_entity)
topology_iterator.Next()
def _number_shapes_ancestors(self, topoTypeA, topoTypeB,
topologicalEntity):
'''returns the number of shape ancestors
If you want to know how many edges a faces has:
_number_shapes_ancestors(self, TopAbs_EDGE, TopAbs_FACE, edg)
will return the number of edges a faces has
@param topoTypeA:
@param topoTypeB:
@param topologicalEntity:
'''
topo_set = set()
_map = TopTools_IndexedDataMapOfShapeListOfShape()
topexp_MapShapesAndAncestors(self.myShape, topoTypeA, topoTypeB, _map)
results = _map.FindFromKey(topologicalEntity)
if results.IsEmpty():
return None
topology_iterator = TopTools_ListIteratorOfListOfShape(results)
while topology_iterator.More():
topo_set.add(topology_iterator.Value())
topology_iterator.Next()
return len(topo_set)
# ======================================================================
# EDGE <-> FACE
# ======================================================================
def faces_from_edge(self, edge):
"""
:param edge:
:return:
"""
return self._map_shapes_and_ancestors(TopAbs_EDGE, TopAbs_FACE, edge)
def number_of_faces_from_edge(self, edge):
"""
:param edge:
:return:
"""
return self._number_shapes_ancestors(TopAbs_EDGE, TopAbs_FACE, edge)
def edges_from_face(self, face):
"""
:param face:
:return:
"""
return self._loop_topo(TopAbs_EDGE, face)
def number_of_edges_from_face(self, face):
cnt = 0
for i in self._loop_topo(TopAbs_EDGE, face):
cnt += 1
return cnt
# ======================================================================
# VERTEX <-> EDGE
# ======================================================================
def vertices_from_edge(self, edg):
return self._loop_topo(TopAbs_VERTEX, edg)
def number_of_vertices_from_edge(self, edg):
cnt = 0
for i in self._loop_topo(TopAbs_VERTEX, edg):
cnt += 1
return cnt
def edges_from_vertex(self, vertex):
return self._map_shapes_and_ancestors(TopAbs_VERTEX, TopAbs_EDGE,
vertex)
def number_of_edges_from_vertex(self, vertex):
return self._number_shapes_ancestors(TopAbs_VERTEX, TopAbs_EDGE,
vertex)
# ======================================================================
# WIRE <-> EDGE
# ======================================================================
def edges_from_wire(self, wire):
return self._loop_topo(TopAbs_EDGE, wire)
def number_of_edges_from_wire(self, wire):
cnt = 0
for i in self._loop_topo(TopAbs_EDGE, wire):
cnt += 1
return cnt
def wires_from_edge(self, edg):
return self._map_shapes_and_ancestors(TopAbs_EDGE, TopAbs_WIRE, edg)
def wires_from_vertex(self, edg):
return self._map_shapes_and_ancestors(TopAbs_VERTEX, TopAbs_WIRE, edg)
def number_of_wires_from_edge(self, edg):
return self._number_shapes_ancestors(TopAbs_EDGE, TopAbs_WIRE, edg)
# ======================================================================
# WIRE <-> FACE
# ======================================================================
def wires_from_face(self, face):
return self._loop_topo(TopAbs_WIRE, face)
def number_of_wires_from_face(self, face):
cnt = 0
for i in self._loop_topo(TopAbs_WIRE, face):
cnt += 1
return cnt
def faces_from_wire(self, wire):
return self._map_shapes_and_ancestors(TopAbs_WIRE, TopAbs_FACE, wire)
def number_of_faces_from_wires(self, wire):
return self._number_shapes_ancestors(TopAbs_WIRE, TopAbs_FACE, wire)
# ======================================================================
# VERTEX <-> FACE
# ======================================================================
def faces_from_vertex(self, vertex):
return self._map_shapes_and_ancestors(TopAbs_VERTEX, TopAbs_FACE,
vertex)
def number_of_faces_from_vertex(self, vertex):
return self._number_shapes_ancestors(TopAbs_VERTEX, TopAbs_FACE,
vertex)
def vertices_from_face(self, face):
return self._loop_topo(TopAbs_VERTEX, face)
def number_of_vertices_from_face(self, face):
cnt = 0
for i in self._loop_topo(TopAbs_VERTEX, face):
cnt += 1
return cnt
# ======================================================================
# FACE <-> SOLID
# ======================================================================
def solids_from_face(self, face):
return self._map_shapes_and_ancestors(TopAbs_FACE, TopAbs_SOLID, face)
def number_of_solids_from_face(self, face):
return self._number_shapes_ancestors(TopAbs_FACE, TopAbs_SOLID, face)
def faces_from_solids(self, solid):
return self._loop_topo(TopAbs_FACE, solid)
def number_of_faces_from_solids(self, solid):
cnt = 0
for i in self._loop_topo(TopAbs_FACE, solid):
cnt += 1
return cnt
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
from OCCT.STEPControl import STEPControl_Reader
from OCCT.TopAbs import TopAbs_FACE
from OCCT.TopExp import TopExp_Explorer
from OCCT.Visualization.WxViewer import ShapeViewerWx
# Read the file and get the shape
reader = STEPControl_Reader()
tr = reader.WS().TransferReader()
reader.ReadFile('./models/shape_names.step')
reader.TransferRoots()
shape = reader.OneShape()
gui = ShapeViewerWx()
# Explore the faces of the shape (these are known to be named)
exp = TopExp_Explorer(shape, TopAbs_FACE)
while exp.More():
rgb = None
s = exp.Current()
exp.Next()
item = tr.EntityFromShapeResult(s, 1)
name = item.Name().ToCString()
if name:
print('Found entity: {}'.format(name))
rgb = (1, 0, 0)
gui.add(s, rgb)
gui.start()
mkWire.Add(aMirroredWire)
myWireProfile = mkWire.Wire()
# The face that we'll sweep to make the prism
myFaceProfile = BRepBuilderAPI_MakeFace(myWireProfile)
# We want to sweep the face along the Z axis to the height
aPrismVec = gp_Vec(0, 0, height)
myBody = BRepPrimAPI_MakePrism(myFaceProfile.Face(), aPrismVec)
# Add fillets to all edges through the explorer
mkFillet = BRepFilletAPI_MakeFillet(myBody.Shape())
anEdgeExplorer = TopExp_Explorer(myBody.Shape(), TopAbs_EDGE)
while anEdgeExplorer.More():
anEdge = topods.Edge(anEdgeExplorer.Current())
mkFillet.Add(thickness / 12.0, anEdge)
anEdgeExplorer.Next()
myBody = mkFillet
# Create the neck of the bottle
neckLocation = gp_Pnt(0, 0, height)
neckAxis = gp_DZ()
neckAx2 = gp_Ax2(neckLocation, neckAxis)
myNeckRadius = thickness / 4.0
myNeckHeight = height / 10.0
mkCylinder = BRepPrimAPI_MakeCylinder(neckAx2, myNeckRadius, myNeckHeight)
def _loop_topo(self,
topology_type,
topological_entity=None,
topology_type_to_avoid=None):
""" this could be a faces generator for a python TopoShape class
that way you can just do:
for face in srf.faces:
processFace(face)
"""
allowed_types = self.topo_types.keys()
if topology_type not in allowed_types:
raise TypeError('%s not one of %s' %
(topology_type, allowed_types))
shape = self.shape
if shape is None:
return []
topo_exp = TopExp_Explorer()
# use self.myShape if nothing is specified
if topological_entity is None and topology_type_to_avoid is None:
topo_exp.Init(shape, topology_type)
elif topological_entity is None and topology_type_to_avoid is not None:
topo_exp.Init(shape, topology_type, topology_type_to_avoid)
elif topology_type_to_avoid is None:
topo_exp.Init(topological_entity, topology_type)
elif topology_type_to_avoid:
topo_exp.Init(topological_entity, topology_type,
topology_type_to_avoid)
items = set() # list that stores hashes to avoid redundancy
occ_seq = TopTools_ListOfShape()
while topo_exp.More():
current_item = topo_exp.Current()
if current_item not in items:
items.add(current_item)
occ_seq.Append(current_item)
topo_exp.Next()
# Convert occ_seq to python list
seq = []
factory = self.topo_factory[topology_type]
occ_iterator = TopTools_ListIteratorOfListOfShape(occ_seq)
while occ_iterator.More():
topo_to_add = factory(occ_iterator.Value())
seq.append(topo_to_add)
occ_iterator.Next()
if not self.ignore_orientation:
return seq
# else filter out those entities that share the same TShape
# but do *not* share the same orientation
filter_orientation_seq = []
for i in seq:
present = False
for j in filter_orientation_seq:
if i.IsSame(j):
present = True
break
if present is False:
filter_orientation_seq.append(i)
return filter_orientation_seq
