def fillet(event=None):
Box = BRepPrimAPI_MakeBox(gp_Pnt(-400, 0, 0), 200, 230, 180).Shape()
fillet_ = BRepFilletAPI_MakeFillet(Box)
# Add fillet on each edge
for e in TopologyExplorer(Box).edges():
fillet_.Add(20, e)
blendedBox = fillet_.Shape()
P1 = gp_Pnt(250, 150, 75)
S1 = BRepPrimAPI_MakeBox(300, 200, 200).Shape()
S2 = BRepPrimAPI_MakeBox(P1, 120, 180, 70).Shape()
Fuse = BRepAlgoAPI_Fuse(S1, S2)
FusedShape = Fuse.Shape()
fill = BRepFilletAPI_MakeFillet(FusedShape)
for e in TopologyExplorer(FusedShape).edges():
fill.Add(e)
for i in range(1, fill.NbContours() + 1):
length = fill.Length(i)
Rad = 0.15 * length
fill.SetRadius(Rad, i, 1)
blendedFusedSolids = fill.Shape()
display.EraseAll()
display.DisplayShape(blendedBox)
display.DisplayShape(blendedFusedSolids)
display.FitAll()
def extrusion(event=None):
# Make a box
Box = BRepPrimAPI_MakeBox(400., 250., 300.)
S = Box.Shape()
# Choose the first Face of the box
F = next(TopologyExplorer(S).faces())
surf = BRep_Tool_Surface(F)
# Make a plane from this face
Pln = Geom_Plane.DownCast(surf)
# Get the normal of this plane. This will be the direction of extrusion.
D = Pln.Axis().Direction()
# Inverse normal
D.Reverse()
# Create the 2D planar sketch
MW = BRepBuilderAPI_MakeWire()
p1 = gp_Pnt2d(200., -100.)
p2 = gp_Pnt2d(100., -100.)
aline = GCE2d_MakeLine(p1, p2).Value()
Edge1 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2))
MW.Add(Edge1.Edge())
p1 = p2
p2 = gp_Pnt2d(100., -200.)
aline = GCE2d_MakeLine(p1, p2).Value()
Edge2 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2))
MW.Add(Edge2.Edge())
p1 = p2
p2 = gp_Pnt2d(200., -200.)
aline = GCE2d_MakeLine(p1, p2).Value()
Edge3 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2))
MW.Add(Edge3.Edge())
p1 = p2
p2 = gp_Pnt2d(200., -100.)
aline = GCE2d_MakeLine(p1, p2).Value()
Edge4 = BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2))
MW.Add(Edge4.Edge())
# Build Face from Wire. NB: a face is required to generate a solid.
MKF = BRepBuilderAPI_MakeFace()
MKF.Init(surf, False, 1e-6)
MKF.Add(MW.Wire())
FP = MKF.Face()
breplib_BuildCurves3d(FP)
MKP = BRepFeat_MakePrism(S, FP, F, D, False, True)
MKP.Perform(200.)
# TODO MKP completes, seeing a split operation but no extrusion
assert MKP.IsDone()
res1 = MKP.Shape()
display.EraseAll()
display.DisplayColoredShape(res1, 'BLUE')
display.FitAll()
def test_hash(self):
"""
Test __hash__ method.
"""
s1 = BRepPrimAPI_MakeBox(1, 1, 1).Shape()
s2 = BRepPrimAPI_MakeBox(1, 1, 1).Shape()
s3 = BRepPrimAPI_MakeBox(1, 1, 1).Shape()
self.assertEqual(len({s1, s2, s3}), 3)
self.assertEqual(len({s1, s1, s2}), 2)
def test_Box2DQuad(self):
"""
Test a quadrilateral mesh of a simple box.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_2D(0, 0, gen)
hyp.SetAllowQuadrangles(True)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTriangles(), 0)
self.assertEqual(mesh.NbQuadrangles(), 600)
self.assertEqual(mesh.NbNodes(), 602)
def brep_feat_local_revolution(event=None):
S = BRepPrimAPI_MakeBox(400., 250., 300.).Shape()
faces = list(TopologyExplorer(S).faces())
F1 = faces[2]
surf = BRep_Tool_Surface(F1)
D = gp_OX()
MW1 = BRepBuilderAPI_MakeWire()
p1 = gp_Pnt2d(100., 100.)
p2 = gp_Pnt2d(200., 100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge())
p1 = gp_Pnt2d(200., 100.)
p2 = gp_Pnt2d(150., 200.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge())
p1 = gp_Pnt2d(150., 200.)
p2 = gp_Pnt2d(100., 100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW1.Add(BRepBuilderAPI_MakeEdge(aline, surf, 0., p1.Distance(p2)).Edge())
MKF1 = BRepBuilderAPI_MakeFace()
MKF1.Init(surf, False, 1e-6)
MKF1.Add(MW1.Wire())
FP = MKF1.Face()
breplib_BuildCurves3d(FP)
MKrev = BRepFeat_MakeRevol(S, FP, F1, D, 1, True)
F2 = faces[4]
MKrev.Perform(F2)
display.EraseAll()
display.DisplayShape(MKrev.Shape())
display.FitAll()
def test_Box3D():
"""
Test a tetrahedral mesh of a simple solid box
"""
from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox
from OCCT.NETGENPlugin import (NETGENPlugin_SimpleHypothesis_3D,
NETGENPlugin_NETGEN_2D3D)
from OCCT.SMESH import SMESH_Gen
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
assert success
assert mesh.NbTetras() == 4767
assert mesh.NbNodes() == 1189
def test_LocalEdgeLength(self):
"""
Test a mesh on a box with a local edge length enforced on one edge.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
edge = TopExp_Explorer(box, TopAbs_EDGE).Current()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp3d = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp3d.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
hyp1d = StdMeshers_LocalLength(2, 0, gen)
hyp1d.SetLength(0.1)
StdMeshers_Regular_1D(3, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
mesh.AddHypothesis(edge, 2)
mesh.AddHypothesis(edge, 3)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTetras(), 31547)
self.assertEqual(mesh.NbNodes(), 6205)
def glue_solids_edges(event=None):
display.EraseAll()
display.Context.RemoveAll(True)
# With common edges
S3 = BRepPrimAPI_MakeBox(500., 400., 300.).Shape()
S4 = BRepPrimAPI_MakeBox(gp_Pnt(0., 0., 300.), gp_Pnt(200., 200.,
500.)).Shape()
faces_S3 = get_faces(S3)
faces_S4 = get_faces(S4)
# tagging allows to visually find the right faces to glue
tag_faces(faces_S3, "BLUE", "s3")
tag_faces(faces_S4, "GREEN", "s4")
F3, F4 = faces_S3[5], faces_S4[4]
glue2 = BRepFeat_Gluer(S4, S3)
glue2.Bind(F4, F3)
glue2.Build()
shape = glue2.Shape()
# move the glued shape, such to be able to inspect input and output
# of glueing operation
trsf = gp_Trsf()
trsf.SetTranslation(gp_Vec(750, 0, 0))
shape.Move(TopLoc_Location(trsf))
common_edges = LocOpe_FindEdges(F4, F3)
common_edges.InitIterator()
n = 0
while common_edges.More():
edge_from = common_edges.EdgeFrom()
edge_to = common_edges.EdgeTo()
tag_edge(edge_from, "edge_{0}_from".format(n))
tag_edge(edge_to, "edge_{0}_to".format(n))
glue2.Bind(edge_from, edge_to)
common_edges.Next()
n += 1
tag_faces(get_faces(shape), "BLACK", "")
display.FitAll()
def offset_cube(event=None):
S2 = BRepPrimAPI_MakeBox(gp_Pnt(300, 0, 0), 220, 140, 180).Shape()
offsetB = BRepOffsetAPI_MakeOffsetShape(S2, -20, 0.01, BRepOffset_Skin,
False, False, GeomAbs_Arc)
offB = display.DisplayColoredShape(S2, 'BLUE')
display.Context.SetTransparency(offB, 0.3, True)
display.DisplayColoredShape(offsetB.Shape(), 'GREEN')
display.FitAll()
def compute_minimal_distance_between_cubes():
""" compute the minimal distance between 2 cubes
the line between the 2 points is rendered in cyan
"""
b1 = BRepPrimAPI_MakeBox(gp_Pnt(100, 0, 0), 10., 10., 10.).Shape()
b2 = BRepPrimAPI_MakeBox(gp_Pnt(45, 45, 45), 10., 10., 10.).Shape()
display.DisplayShape([b1, b2])
dss = BRepExtrema_DistShapeShape()
dss.LoadS1(b1)
dss.LoadS2(b2)
dss.Perform()
assert dss.IsDone()
edg = make_edge(dss.PointOnShape1(1), dss.PointOnShape2(1))
display.DisplayColoredShape([edg], color="CYAN")
def glue_solids(event=None):
display.EraseAll()
display.Context.RemoveAll(True)
# Without common edges
S1 = BRepPrimAPI_MakeBox(gp_Pnt(500., 500., 0.), gp_Pnt(100., 250.,
300.)).Shape()
facesA = get_faces(S1)
tag_faces(facesA, "BLUE", "facesA")
# the face to glue
F1 = facesA[5]
S2 = BRepPrimAPI_MakeBox(gp_Pnt(400., 400., 300.),
gp_Pnt(200., 300., 500.)).Shape()
facesB = get_faces(S2)
tag_faces(facesB, "GREEN", "facesB")
# the face to glue of the opposite shape
F2 = facesB[4]
# perform glueing operation
glue1 = BRepFeat_Gluer(S2, S1)
glue1.Bind(F2, F1)
shape = glue1.Shape()
display.SetModeHLR()
# move the glued shape, such to be able to inspect input and output
# of glueing operation
trsf = gp_Trsf()
trsf.SetTranslation(gp_Vec(500, 0, 0))
shape.Move(TopLoc_Location(trsf))
tag_faces(get_faces(shape), "BLACK", "")
# render glued shape
display.DisplayShape(shape)
display.FitAll()
def thick_solid(event=None):
S = BRepPrimAPI_MakeBox(150, 200, 110).Shape()
topo = TopologyExplorer(S)
vert = next(topo.vertices())
shapes = TopTools_ListOfShape()
for f in topo.faces_from_vertex(vert):
shapes.Append(f)
_thick_solid = BRepOffsetAPI_MakeThickSolid(S, shapes, 15, 0.01)
display.EraseAll()
display.DisplayShape(_thick_solid.Shape())
display.FitAll()
def shape_faces_surface():
""" Compute the surface of each face of a shape
"""
# first create the shape
the_shape = BRepPrimAPI_MakeBox(50., 30., 10.).Shape()
# then loop over faces
t = TopologyExplorer(the_shape)
props = GProp_GProps()
shp_idx = 1
for face in t.faces():
brepgprop_SurfaceProperties(face, props)
face_surf = props.Mass()
print("Surface for face nbr %i : %f" % (shp_idx, face_surf))
shp_idx += 1
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 cube_inertia_properties():
""" Compute the inertia properties of a shape
"""
# Create and display cube
print("Creating a cubic box shape (50*50*50)")
cube_shape = BRepPrimAPI_MakeBox(50., 50., 50.).Shape()
# Compute inertia properties
props = GProp_GProps()
brepgprop_VolumeProperties(cube_shape, props)
# Get inertia properties
mass = props.Mass()
cog = props.CentreOfMass()
matrix_of_inertia = props.MatrixOfInertia()
# Display inertia properties
print("Cube mass = %s" % mass)
cog_x, cog_y, cog_z = cog.Coord()
print("Center of mass: x = %f;y = %f;z = %f;" % (cog_x, cog_y, cog_z))
print("Matrix of inertia", matrix_of_inertia)
def split_shape(event=None):
S = BRepPrimAPI_MakeBox(gp_Pnt(-100, -60, -80), 150, 200, 170).Shape()
asect = BRepAlgoAPI_Section(S, gp_Pln(1, 2, 1, -15), False)
asect.ComputePCurveOn1(True)
asect.Approximation(True)
asect.Build()
R = asect.Shape()
asplit = BRepFeat_SplitShape(S)
for edg in TopologyExplorer(R).edges():
face = TopoDS_Face()
if asect.HasAncestorFaceOn1(edg, face):
asplit.Add(edg, face)
asplit.Build()
display.EraseAll()
display.DisplayShape(asplit.Shape())
display.FitAll()
def ConvertBndToShape(theBox):
aBaryCenter = theBox.Center()
aXDir = theBox.XDirection()
aYDir = theBox.YDirection()
aZDir = theBox.ZDirection()
aHalfX = theBox.XHSize()
aHalfY = theBox.YHSize()
aHalfZ = theBox.ZHSize()
ax = gp_XYZ(aXDir.X(), aXDir.Y(), aXDir.Z())
ay = gp_XYZ(aYDir.X(), aYDir.Y(), aYDir.Z())
az = gp_XYZ(aZDir.X(), aZDir.Y(), aZDir.Z())
p = gp_Pnt(aBaryCenter.X(), aBaryCenter.Y(), aBaryCenter.Z())
anAxes = gp_Ax2(p, gp_Dir(aZDir), gp_Dir(aXDir))
anAxes.SetLocation(
gp_Pnt(p.XYZ() - ax * aHalfX - ay * aHalfY - az * aHalfZ))
aBox = BRepPrimAPI_MakeBox(anAxes, 2.0 * aHalfX, 2.0 * aHalfY,
2.0 * aHalfZ).Shape()
return aBox
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 brepfeat_prism(event=None):
box = BRepPrimAPI_MakeBox(400, 250, 300).Shape()
faces = TopologyExplorer(box).faces()
for i in range(5):
face = next(faces)
srf = BRep_Tool_Surface(face)
c = gp_Circ2d(gp_Ax2d(gp_Pnt2d(200, 130), gp_Dir2d(1, 0)), 75)
circle = Geom2d_Circle(c)
wire = BRepBuilderAPI_MakeWire()
wire.Add(BRepBuilderAPI_MakeEdge(circle, srf, 0., pi).Edge())
wire.Add(BRepBuilderAPI_MakeEdge(circle, srf, pi, 2. * pi).Edge())
wire.Build()
display.DisplayShape(wire.Wire())
mkf = BRepBuilderAPI_MakeFace()
mkf.Init(srf, False, 1e-6)
mkf.Add(wire.Wire())
mkf.Build()
new_face = mkf.Face()
breplib_BuildCurves3d(new_face)
display.DisplayShape(new_face)
prism = BRepFeat_MakeDPrism(box, mkf.Face(), face, 100, True, True)
prism.Perform(400)
assert prism.IsDone()
display.EraseAll()
display.DisplayShape(prism.Shape())
display.DisplayColoredShape(wire.Wire(), 'RED')
display.FitAll()
def test_Box3D(self):
"""
Test a tetrahedral mesh of a simple solid box.
"""
box = BRepPrimAPI_MakeBox(10, 10, 10).Solid()
gen = SMESH_Gen()
mesh = gen.CreateMesh(0, True)
hyp = NETGENPlugin_SimpleHypothesis_3D(0, 0, gen)
hyp.SetLocalLength(1.0)
NETGENPlugin_NETGEN_2D3D(1, 0, gen)
mesh.ShapeToMesh(box)
mesh.AddHypothesis(box, 0)
mesh.AddHypothesis(box, 1)
success = gen.Compute(mesh, box)
self.assertTrue(success)
self.assertEqual(mesh.NbTetras(), 4741)
self.assertEqual(mesh.NbNodes(), 1185)
def variable_filleting(event=None):
display.EraseAll()
# Create Box
Box = BRepPrimAPI_MakeBox(200, 200, 200).Shape()
# Fillet
Rake = BRepFilletAPI_MakeFillet(Box)
ex = TopologyExplorer(Box).edges()
next(ex)
next(ex)
next(ex)
Rake.Add(8, 50, next(ex))
Rake.Build()
if Rake.IsDone():
evolvedBox = Rake.Shape()
display.DisplayShape(evolvedBox)
else:
print("Rake not done.")
# Create Cylinder
Cylinder = BRepPrimAPI_MakeCylinder(
gp_Ax2(gp_Pnt(-300, 0, 0), gp_Dir(0, 0, 1)), 100, 200).Shape()
fillet_ = BRepFilletAPI_MakeFillet(Cylinder)
TabPoint2 = TColgp_Array1OfPnt2d(0, 20)
for i in range(0, 20):
Point2d = gp_Pnt2d(i * 2 * pi / 19,
60 * cos(i * pi / 19 - pi / 2) + 10)
TabPoint2.SetValue(i, Point2d)
exp2 = TopologyExplorer(Cylinder).edges()
fillet_.Add(TabPoint2, next(exp2))
fillet_.Build()
if fillet_.IsDone():
LawEvolvedCylinder = fillet_.Shape()
display.DisplayShape(LawEvolvedCylinder)
else:
print("fillet not done.") ## TODO : fillet not done
P = gp_Pnt(350, 0, 0)
Box2 = BRepPrimAPI_MakeBox(P, 200, 200, 200).Shape()
afillet = BRepFilletAPI_MakeFillet(Box2)
TabPoint = TColgp_Array1OfPnt2d(1, 6)
P1 = gp_Pnt2d(0., 8.)
P2 = gp_Pnt2d(0.2, 16.)
P3 = gp_Pnt2d(0.4, 25.)
P4 = gp_Pnt2d(0.6, 55.)
P5 = gp_Pnt2d(0.8, 28.)
P6 = gp_Pnt2d(1., 20.)
TabPoint.SetValue(1, P1)
TabPoint.SetValue(2, P2)
TabPoint.SetValue(3, P3)
TabPoint.SetValue(4, P4)
TabPoint.SetValue(5, P5)
TabPoint.SetValue(6, P6)
exp = TopologyExplorer(Box2).edges()
next(exp)
next(exp)
next(exp)
afillet.Add(TabPoint, next(exp))
afillet.Build()
if afillet.IsDone():
LawEvolvedBox = afillet.Shape()
display.DisplayShape(LawEvolvedBox)
else:
print("aFillet not done.")
display.FitAll()
ay = gp_XYZ(aYDir.X(), aYDir.Y(), aYDir.Z())
az = gp_XYZ(aZDir.X(), aZDir.Y(), aZDir.Z())
p = gp_Pnt(aBaryCenter.X(), aBaryCenter.Y(), aBaryCenter.Z())
anAxes = gp_Ax2(p, gp_Dir(aZDir), gp_Dir(aXDir))
anAxes.SetLocation(
gp_Pnt(p.XYZ() - ax * aHalfX - ay * aHalfY - az * aHalfZ))
aBox = BRepPrimAPI_MakeBox(anAxes, 2.0 * aHalfX, 2.0 * aHalfY,
2.0 * aHalfZ).Shape()
return aBox
obb = Bnd_OBB()
# choose n random vertices
n = 10
for _ in range(n):
x = random.uniform(100, 1000)
y = random.uniform(100, 1000)
z = random.uniform(100, 1000)
p = BRepBuilderAPI_MakeVertex(gp_Pnt(x, y, z)).Shape()
display.DisplayShape(p)
brepbndlib_AddOBB(p, obb)
obb_shape = ConvertBndToShape(obb)
display.DisplayShape(obb_shape)
# a ref box
b = BRepPrimAPI_MakeBox(10, 10, 10).Shape()
display.DisplayShape(b, update=True)
start_display()
print("Shape selected: ", shape)
print(kwargs)
def compute_bbox(shp, *kwargs):
print("Compute bbox for %s " % shp)
for shape in shp:
bbox = Bnd_Box()
brepbndlib_Add(shape, bbox)
xmin, ymin, zmin, xmax, ymax, zmax = bbox.Get()
dx = xmax - xmin
dy = ymax - ymin
dz = zmax - zmin
print("Selected shape bounding box : dx=%f, dy=%f, dz=%f." %
(dx, dy, dz))
print(" bounding box center: x=%f, y=%f, z=%f" %
(xmin + dx / 2., ymin + dy / 2., zmin + dz / 2.))
display, start_display, add_menu, add_function_to_menu = init_display()
# register callbacks
display.register_select_callback(print_xy_click)
display.register_select_callback(compute_bbox)
# creating geometry
my_torus = BRepPrimAPI_MakeBox(10., 20., 30.).Shape()
my_box = BRepPrimAPI_MakeTorus(30., 5.).Shape()
# and finally display geometry
display.DisplayShape(my_torus)
display.DisplayShape(my_box, update=True)
start_display()
## ##pythonOCC is distributed in the hope that it will be useful, ##but WITHOUT ANY WARRANTY; without even the implied warranty of ##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ##GNU Lesser General Public License for more details. ## ##You should have received a copy of the GNU Lesser General Public License ##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox from OCCT.AIS import AIS_Shape from OCC.Display.SimpleGui import init_display display, start_display, add_menu, add_function_to_menu = init_display() myBox = BRepPrimAPI_MakeBox(60, 60, 50).Shape() context = display.Context context.SetAutoActivateSelection(False) aisShape = AIS_Shape(myBox) context.Display(aisShape, True) # Set shape transparency, a float number from 0.0 to 1.0 context.SetTransparency(aisShape, 0.6, True) owner = aisShape.GetOwner() drawer = aisShape.DynamicHilightAttributes() # TODO: how do we set the color ? Quantity_NOC_RED context.HilightWithColor(aisShape, drawer, True) display.View_Iso() display.FitAll()
##but WITHOUT ANY WARRANTY; without even the implied warranty of
##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
##GNU Lesser General Public License for more details.
##
##You should have received a copy of the GNU Lesser General Public License
##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>.
from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox
from OCCT.SMESH import SMESH_Gen
from OCCT.StdMeshers import (StdMeshers_Arithmetic1D, StdMeshers_Regular_1D,
StdMeshers_TrianglePreference, StdMeshers_MEFISTO_2D,
StdMeshers_QuadranglePreference, StdMeshers_Quadrangle_2D)
#Create the shape to mesh
aShape = BRepPrimAPI_MakeBox(10, 20, 40).Shape()
aMeshGen = SMESH_Gen()
aMesh = aMeshGen.CreateMesh(0, True)
def ComputeMesh(MEFISTO2=False):
an1DHypothesis = StdMeshers_Arithmetic1D(0,0,aMeshGen)
#print dir(an1DHypothesis)
#print an1DHypothesis.SaveTo()
an1DHypothesis.SetLength(1.,False)
an1DHypothesis.SetLength(2.,True)
an1DAlgo = StdMeshers_Regular_1D(1,0,aMeshGen)
if MEFISTO2:
#2D
def brep_feat_extrusion_protrusion(event=None):
# Extrusion
S = BRepPrimAPI_MakeBox(400., 250., 300.).Shape()
faces = TopologyExplorer(S).faces()
F = next(faces)
surf1 = BRep_Tool_Surface(F)
Pl1 = Geom_Plane.DownCast(surf1)
D1 = Pl1.Pln().Axis().Direction().Reversed()
MW = BRepBuilderAPI_MakeWire()
p1, p2 = gp_Pnt2d(200., -100.), gp_Pnt2d(100., -100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge())
p1, p2 = gp_Pnt2d(100., -100.), gp_Pnt2d(100., -200.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge())
p1, p2 = gp_Pnt2d(100., -200.), gp_Pnt2d(200., -200.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge())
p1, p2 = gp_Pnt2d(200., -200.), gp_Pnt2d(200., -100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW.Add(BRepBuilderAPI_MakeEdge(aline, surf1, 0., p1.Distance(p2)).Edge())
MKF = BRepBuilderAPI_MakeFace()
MKF.Init(surf1, False, 1e-6)
MKF.Add(MW.Wire())
FP = MKF.Face()
breplib_BuildCurves3d(FP)
display.EraseAll()
MKP = BRepFeat_MakePrism(S, FP, F, D1, 0, True)
MKP.PerformThruAll()
res1 = MKP.Shape()
display.DisplayShape(res1)
# Protrusion
next(faces)
F2 = next(faces)
surf2 = BRep_Tool_Surface(F2)
Pl2 = Geom_Plane.DownCast(surf2)
D2 = Pl2.Pln().Axis().Direction().Reversed()
MW2 = BRepBuilderAPI_MakeWire()
p1, p2 = gp_Pnt2d(100., 100.), gp_Pnt2d(200., 100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge())
p1, p2 = gp_Pnt2d(200., 100.), gp_Pnt2d(150., 200.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge())
p1, p2 = gp_Pnt2d(150., 200.), gp_Pnt2d(100., 100.)
aline = GCE2d_MakeLine(p1, p2).Value()
MW2.Add(BRepBuilderAPI_MakeEdge(aline, surf2, 0., p1.Distance(p2)).Edge())
MKF2 = BRepBuilderAPI_MakeFace()
MKF2.Init(surf2, False, 1e-6)
MKF2.Add(MW2.Wire())
MKF2.Build()
FP = MKF2.Face()
breplib_BuildCurves3d(FP)
MKP2 = BRepFeat_MakePrism(res1, FP, F2, D2, 0, True)
MKP2.PerformThruAll()
display.EraseAll()
trf = gp_Trsf()
trf.SetTranslation(gp_Vec(0, 0, 300))
gtrf = gp_GTrsf()
gtrf.SetTrsf(trf)
tr = BRepBuilderAPI_GTransform(MKP2.Shape(), gtrf, True)
fused = BRepAlgoAPI_Fuse(tr.Shape(), MKP2.Shape())
fused.Build()
display.DisplayShape(fused.Shape())
display.FitAll()
def setUpClass(cls):
"""
Set up with a BRepPrimAPI_MakeBox.
"""
cls._builder = BRepPrimAPI_MakeBox(10, 10, 10)
def build_shape():
boxshp = BRepPrimAPI_MakeBox(50., 50., 50.).Shape()
ais_boxshp = display.DisplayShape(boxshp, update=True)
return ais_boxshp
##GNU Lesser General Public License for more details.
##
##You should have received a copy of the GNU Lesser General Public License
##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>.
from OCCT.Visualization import Tesselator
from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox
try:
import numpy as np
HAVE_NUMPY = True
except ImportError:
HAVE_NUMPY = False
# create the shape
box_s = BRepPrimAPI_MakeBox(10, 20, 30).Shape()
# compute the tesselation
tess = Tesselator(box_s)
tess.Compute()
# get vertices
vertices_position = tess.GetVerticesPositionAsTuple()
number_of_triangles = tess.ObjGetTriangleCount()
number_of_vertices = len(vertices_position)
# number of vertices should be a multiple of 3
if number_of_vertices % 3 != 0:
raise AssertionError("wrong number of vertices returned by the teselator")
if number_of_triangles * 9 != number_of_vertices:
##You should have received a copy of the GNU Lesser General Public License ##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>. """ The very first pythonocc example. This uses to be the script used to check the following points: pythonocc installation is correct, i.e. pythonocc modules are found and properly imported a GUI manager is installed. Wether it is wxpython or pyqt/pyside, it's necessary to display a 3d window the rendering window can be initialized and set up, that is to say the graphic driver and OpenGl works correctly. If this example run on your machine, that means you're ready to explore the wide pythonocc world and run all the other examples. """ from OCC.Display.SimpleGui import init_display from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox from OCCT.AIS import AIS_Manipulator display, start_display, add_menu, add_function_to_menu = init_display() my_box = BRepPrimAPI_MakeBox(10., 20., 30.).Shape() display.View.TriedronErase() ais_shp = display.DisplayShape(my_box, update=True) manip = AIS_Manipulator() manip.Attach(ais_shp) start_display()
