def occ_triangle_mesh(event=None):
#
# Mesh the shape
#
BRepMesh_IncrementalMesh(aShape, 0.1)
builder = BRep_Builder()
Comp = TopoDS_Compound()
builder.MakeCompound(Comp)
ex = TopExp_Explorer(aShape, TopAbs_FACE)
while ex.More():
F = topods_Face(ex.Current())
L = TopLoc_Location()
facing = (BRep_Tool().Triangulation(F, L)).GetObject()
tab = facing.Nodes()
tri = facing.Triangles()
for i in range(1, facing.NbTriangles() + 1):
trian = tri.Value(i)
#print trian
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.DisplayShape(Comp, update=True)
def writeBRep(filename, shapeList):
aRes = TopoDS_Compound()
aBuilder = BRep_Builder()
aBuilder.MakeCompound(aRes)
for shape in shapeList:
aBuilder.Add(aRes, shape)
breptools_Write(aRes, filename)
def regions2step(splinegons, filename, application_protocol='AP203'):
"""Writes splinegon regions to a STEP file.
Parameters
----------
splinegons : list
Each member of the list is a `TopoDS_Face` object, the surface of a region.
filename : str
Name of the file the regions are saved into.
application_protocol : {'AP203', 'AP214IS', 'AP242DIS'}, optional
Version of schema used for the output STEP file. The default is 'AP203'.
Returns
-------
None
See Also
--------
splinegonize
write_step_file
"""
# Initialize a container that we will populate with the splinegons
builder = BRep_Builder()
compound = TopoDS_Compound()
builder.MakeCompound(compound)
# Combine multiple faces
for splinegon in splinegons:
builder.Add(compound, splinegon)
# Write to STEP file
write_step_file(compound, filename, application_protocol)
def export(self, event):
""" Export the current model to stl """
from OCC.StlAPI import StlAPI_Writer
from OCC.BRepMesh import BRepMesh_IncrementalMesh
#: TODO: All parts
options = event.parameters.get('options')
if not isinstance(options, ExportOptions):
return False
exporter = StlAPI_Writer()
exporter.SetASCIIMode(not options.binary)
#: Make a compound of compounds (if needed)
compound = TopoDS_Compound()
builder = BRep_Builder()
builder.MakeCompound(compound)
for part in self.parts:
#: Must mesh the shape first
if isinstance(part, Part):
builder.Add(compound, part.proxy.shape)
else:
builder.Add(compound, part.proxy.shape.Shape())
#: Build the mesh
mesh = BRepMesh_IncrementalMesh(compound, options.linear_deflection,
options.relative,
options.angular_deflection)
mesh.Perform()
if not mesh.IsDone():
raise ExportError("Failed to create the mesh")
exporter.Write(compound, options.path)
def make_shell(occfacelist):
builder = BRep_Builder()
shell = TopoDS_Shell()
builder.MakeShell(shell)
for occface in occfacelist:
builder.Add(shell, occface)
return shell
def mkCompaund(f1,f2):
u"""Об'єднує форми для експорту в формат BRep"""
from OCC.BRep import BRep_Builder
f=TopoDS_Compound()
bb=BRep_Builder()
bb.MakeCompound(f)
bb.Add(f,f1)
bb.Add(f,f2)
return f
def get_compound(self):
""" Create and returns a compound from the _shapes list
"""
# Create a compound
compound = TopoDS_Compound()
B = BRep_Builder()
B.MakeCompound(compound)
# Populate the compound
for shape in self._shapes:
B.Add(compound, shape)
return compound
def update_shape(self, change):
""" Create the toolkit shape for the proxy object.
"""
builder = BRep_Builder()
shape = self.shape
builder.MakeCompound(shape)
for s in self.shapes:
if hasattr(s.shape, 'Shape'):
builder.Add(shape, s.shape.Shape())
elif s.shape is not None:
builder.Add(shape, s.shape)
self.builder = builder
def read_step_file(filename, as_compound=True, verbosity=True):
""" read the STEP file and returns a compound
filename: the file path
verbosity: optional, False by default.
as_compound: True by default. If there are more than one shape at root,
gather all shapes into one compound. Otherwise returns a list of shapes.
"""
if not os.path.isfile(filename):
raise FileNotFoundError("%s not found." % filename)
step_reader = STEPControl_Reader()
status = step_reader.ReadFile(filename)
if status == IFSelect_RetDone: # check status
if verbosity:
failsonly = False
step_reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
step_reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
transfer_result = step_reader.TransferRoots()
if not transfer_result:
raise AssertionError("Transfer failed.")
_nbs = step_reader.NbShapes()
if _nbs == 0:
raise AssertionError("No shape to transfer.")
elif _nbs == 1: # most cases
return step_reader.Shape(1)
elif _nbs > 1:
print("Number of shapes:", _nbs)
shps = []
# loop over root shapes
for k in range(1, _nbs + 1):
new_shp = step_reader.Shape(k)
if not new_shp.IsNull():
shps.append(new_shp)
if as_compound:
builder = BRep_Builder()
compound = TopoDS_Compound()
builder.MakeCompound(compound)
for s in shps:
builder.Add(compound, s)
# shps = compound
# compound, result = list_of_shapes_to_compound(shps)
# if not result:
# print("Warning: all shapes were not added to the compound")
return compound
else:
print("Warning, returns a list of shapes.")
return shps
else:
raise AssertionError("Error: can't read file.")
return None
def make_compound(shape_array):
"""
Creates a TopoDS_Compund from a list of TopoDS_Shapes
:param shape_array: list of shapes
:return: TopoDS_Compound
"""
b = BRep_Builder()
c = TopoDS_Compound()
b.MakeCompound(c)
for shape in shape_array:
b.Add(c, shape)
return c
def read_iges_file(filename, return_as_shapes=False, verbosity=False):
""" read the IGES file and returns a compound
filename: the file path
return_as_shapes: optional, False by default. If True returns a list of shapes,
else returns a single compound
verbosity: optionl, False by default.
"""
assert os.path.isfile(filename)
iges_reader = IGESControl_Reader()
status = iges_reader.ReadFile(filename)
_shapes = []
if status == IFSelect_RetDone: # check status
if verbosity:
failsonly = False
iges_reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
iges_reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
iges_reader.TransferRoots()
nbr = iges_reader.NbRootsForTransfer()
for n in range(1, nbr + 1):
nbs = iges_reader.NbShapes()
if nbs == 0:
print("At least one shape in IGES cannot be transfered")
elif nbr == 1 and nbs == 1:
aResShape = iges_reader.Shape(1)
if aResShape.IsNull():
print("At least one shape in IGES cannot be transferred")
else:
_shapes.append(aResShape)
else:
for i in range(1, nbs + 1):
aShape = iges_reader.Shape(i)
if aShape.IsNull():
print(
"At least one shape in STEP cannot be transferred")
else:
_shapes.append(aShape)
# if not return as shapes
# create a compound and store all shapes
# TODO
if not return_as_shapes:
builder = BRep_Builder()
Comp = TopoDS_Compound()
builder.MakeCompound(Comp)
for s in _shapes:
builder.Add(Comp, s)
_shapes = Comp
return _shapes
def export(self):
""" Export a DeclaraCAD model from an enaml file to an STL based on the
given options.
Parameters
----------
options: declaracad.occ.plugin.ExportOptions
"""
from OCC.BRep import BRep_Builder
from OCC.BRepMesh import BRepMesh_IncrementalMesh
from OCC.StlAPI import StlAPI_Writer
from OCC.TopoDS import TopoDS_Compound
# Make a compound of compounds (if needed)
compound = TopoDS_Compound()
builder = BRep_Builder()
builder.MakeCompound(compound)
# Load the enaml model file
parts = load_model(self.filename)
for part in parts:
# Render the part from the declaration
shape = part.render()
# Must mesh the shape firsts
if hasattr(shape, 'Shape'):
builder.Add(compound, shape.Shape())
else:
builder.Add(compound, shape)
#: Build the mesh
exporter = StlAPI_Writer()
exporter.SetASCIIMode(not self.binary)
mesh = BRepMesh_IncrementalMesh(
compound,
self.linear_deflection,
self.relative,
self.angular_deflection
)
mesh.Perform()
if not mesh.IsDone():
raise RuntimeError("Failed to create the mesh")
exporter.Write(compound, self.path)
if not os.path.exists(self.path):
raise RuntimeError("Failed to write shape")
def test_default_constructor_DEFINE_STANDARD_ALLOC(self):
''' OCE classes the defines standard alllocator can be instanciated
if they're not abstract nor define any protected or private
constructor '''
BRep_Builder()
TopoDS_Builder()
ShapeAnalysis_Curve()
def get_brep():
from OCC.BRep import BRep_Builder
from OCC.BRepTools import breptools_Read
from OCC.TopoDS import TopoDS_Shape
cylinder_head = TopoDS_Shape()
builder = BRep_Builder()
breptools_Read(cylinder_head, './models/cylinder_head.brep', builder)
return cylinder_head
def step_reader(step_string):
from OCC.StlAPI import StlAPI_Writer
from OCC.STEPControl import STEPControl_Reader
from OCC.BRep import BRep_Builder
from OCC.TopoDS import TopoDS_Compound
from OCC.IFSelect import IFSelect_RetDone, IFSelect_ItemsByEntity
builder = BRep_Builder()
comp = TopoDS_Compound()
builder.MakeCompound(comp)
stl_writer = StlAPI_Writer()
stl_writer.SetASCIIMode(True)
with io.tmpfile(contents=io.shapes()[shape_name][:][0]) as tmpfile:
step_reader = STEPControl_Reader()
status = step_reader.ReadFile(tmpfile[1])
if status == IFSelect_RetDone: # check status
failsonly = False
step_reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
step_reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
ok = step_reader.TransferRoot(1)
nbs = step_reader.NbShapes()
l = []
for i in range(1, nbs + 1):
shape = step_reader.Shape(i)
builder.Add(comp, shape)
with io.tmpfile(suffix='.stl') as tmpf:
stl_writer.Write(comp, tmpf[1])
tmpf[0].flush()
reader = vtk.vtkSTLReader()
reader.SetFileName(tmpf[1])
reader.Update()
return reader
def occ_load_file(filename):
"""
load in pythonocc a igs or step file
:param filename: a filename with extension
:return: a topods_shape
"""
from OCC.STEPControl import STEPControl_Reader
from OCC.IGESControl import IGESControl_Reader
from OCC.BRep import BRep_Builder
from OCC.TopoDS import TopoDS_Compound
from OCC.IFSelect import IFSelect_RetDone,\
IFSelect_ItemsByEntity
reader_switch = {
'stp': STEPControl_Reader,
'step': STEPControl_Reader,
'igs': IGESControl_Reader,
'iges': IGESControl_Reader
}
builder = BRep_Builder()
comp = TopoDS_Compound()
builder.MakeCompound(comp)
reader = reader_switch[os.path.splitext(filename)[1][1:].lower()]()
status = reader.ReadFile(filename)
if status == IFSelect_RetDone: # check status
failsonly = False
reader.PrintCheckLoad(failsonly, IFSelect_ItemsByEntity)
reader.PrintCheckTransfer(failsonly, IFSelect_ItemsByEntity)
ok = reader.TransferRoots()
nbs = reader.NbShapes()
for i in range(1, nbs + 1):
shape = reader.Shape(i)
builder.Add(comp, shape)
return comp
def create_shape(self):
d = self.declaration
if not d.source:
return
if os.path.exists(d.source):
svg = etree.parse(d.source).getroot()
else:
svg = etree.fromstring(d.source)
node = OccSvgDoc(element=svg)
builder = BRep_Builder()
shape = TopoDS_Compound()
builder.MakeCompound(shape)
shapes = node.create_shape()
for s in shapes:
builder.Add(shape, s)
self.wires = shapes
self.shape = shape
def simple_mesh():
#
# Create the shape
#
shape = BRepPrimAPI_MakeBox(200, 200, 200).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)).GetObject()
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 vstep(step_str):
step = int(step_str)
positions = dpos_data[nbobjs * step:nbobjs * step + nbobjs, 2:]
builder = BRep_Builder()
comp = TopoDS_Compound()
builder.MakeCompound(comp)
for _id in range(positions.shape[0]):
q0, q1, q2, q3, q4, q5, q6 = [float(x) for x in positions[_id, :]]
obj = obj_by_id[_id + 1]
q = Quaternion((q3, q4, q5, q6))
for shape_name, avatar in zip(io.instances()[obj], avatars(obj)):
offset = get_offset(obj, shape_name)
p = q.rotate(offset[0])
r = q * Quaternion(offset[1])
tr = gp_Trsf()
qocc = gp_Quaternion(r[1], r[2], r[3], r[0])
tr.SetRotation(qocc)
xyz = gp_XYZ(q0 + p[0], q1 + p[1], q2 + p[2])
vec = gp_Vec(xyz)
tr.SetTranslationPart(vec)
loc = TopLoc_Location(tr)
display.Context.SetLocation(avatar, loc)
moved_shape = BRepBuilderAPI_Transform(
avatar.GetObject().Shape(), tr, True).Shape()
builder.Add(comp, moved_shape)
display.Context.UpdateCurrentViewer()
write_step((step_str, comp))
def discretize(shape, tol):
"""This method discretizes the OpenCascade shape.
:param shape: Shape to discretize
:type shape:
:return: discretized face; profile coordinates; id of the surface the\
coordinates belong to
:rtype: OCC.TopoDS.TopoDS_Compound; numpy.ndarray; numpy.ndarray
"""
BRepMesh_IncrementalMesh(shape, tol, False, 5)
builder = BRep_Builder()
comp = TopoDS_Compound()
builder.MakeCompound(comp)
bt = BRep_Tool()
ex = TopExp_Explorer(shape, TopAbs_EDGE)
edge_coords = np.zeros([0, 3])
edge_ids = np.zeros([0], dtype=int)
edge_id = 0
while ex.More():
edge = topods_Edge(ex.Current())
location = TopLoc_Location()
edging = (bt.Polygon3D(edge, location)).GetObject()
tab = edging.Nodes()
for i in range(1, edging.NbNodes() + 1):
p = tab.Value(i)
edge_coords = np.append(edge_coords,
[[p.X(), p.Y(), p.Z()]],
axis=0)
edge_ids = np.append(edge_ids, edge_id)
mv = BRepBuilderAPI_MakeVertex(p)
if mv.IsDone():
builder.Add(comp, mv.Vertex())
edge_id += 1
ex.Next()
edge_coords = np.round(edge_coords, 8)
return edge_coords, edge_ids
def read_brep(filename):
"""
Reads in a brep file
:return: The shape
"""
if not Path(filename).is_file():
print("File not found: " + filename)
raise FileNotFoundError(filename)
b = BRep_Builder()
shape = TopoDS_Shape()
if not breptools_Read(shape, filename, b):
raise RuntimeError("Cannot read brep file: " + filename)
return shape
def read_brep(brep_filepath):
"""
This function writes a 3D model into brep format.
Parameters
----------
brep_filepath : str
The file path of the brep file.
Returns
-------
occtopology : OCCtopology
Geometries read from the brep.
OCCtopology includes: OCCshape, OCCcompound, OCCcompsolid, OCCsolid, OCCshell, OCCface, OCCwire, OCCedge, OCCvertex
"""
from OCC.BRepTools import breptools_Read
from OCC.TopoDS import TopoDS_Shape
from OCC.BRep import BRep_Builder
shape = TopoDS_Shape()
builder = BRep_Builder()
breptools_Read(shape, brep_filepath, builder)
return shape
def draw_lineandvertices(event=None):
Line_1 = TopoDS_Shape()
Vertex_1 = TopoDS_Shape()
Vertex_2 = TopoDS_Shape()
builder = BRep_Builder()
builder1 = BRep_Builder()
compound = TopoDS_Compound()
builder1.MakeCompound(compound)
breptools_Read(Line_1, 'Line_1.brep', builder)
breptools_Read(Vertex_1, 'Vertex_1.brep', builder)
breptools_Read(Vertex_2, 'Vertex_2.brep', builder)
builder1.Add(compound,Line_1)
builder1.Add(compound,Vertex_1)
builder1.Add(compound,Vertex_2)
#display.DisplayShape({Line_1, Vertex_1, Vertex_2}, update=True)
#display.DisplayShape(Group_1, update=True)
display.DisplayShape(compound, update=True)
breptools_Write(compound, 'compound.brep')
display.FitAll()
point = gp_Pnt(X1, Y1, Z1) sphere_r1 = BRepPrimAPI_MakeSphere(point, radius) sphere_r1_shape = sphere_r1.Shape() radius = 0.01 sphere_r01 = BRepPrimAPI_MakeSphere(point, radius) sphere_r01_shape = sphere_r01.Shape() radius = 0.001 sphere_r001 = BRepPrimAPI_MakeSphere(point, radius) sphere_r001_shape = sphere_r001.Shape() from OCC.BRep import BRep_Builder from OCC.TopoDS import TopoDS_Compound builder = BRep_Builder() comp = TopoDS_Compound() builder.MakeCompound(comp) from OCC.BRep import BRep_Builder from OCC.TopoDS import TopoDS_Compound builder.Add(comp, sphere_r1_shape) radius = 1.0 point = gp_Pnt(4., 0., 0.) sphere_r1_t = BRepPrimAPI_MakeSphere(point, radius) sphere_r1_t_shape = sphere_r1_t.Shape() builder.Add(comp, sphere_r1_t_shape)
anEdge2OnSurf2 = BRepBuilderAPI_MakeEdge(aSegment.Value(),
Handle_Geom_Surface(aCyl2))
threadingWire1 = BRepBuilderAPI_MakeWire(anEdge1OnSurf1.Edge(),
anEdge2OnSurf1.Edge())
threadingWire2 = BRepBuilderAPI_MakeWire(anEdge1OnSurf2.Edge(),
anEdge2OnSurf2.Edge())
# Compute the 3D representations of the edges/wires
breplib.BuildCurves3d(threadingWire1.Shape())
breplib.BuildCurves3d(threadingWire2.Shape())
# Create the surfaces of the threading
aTool = BRepOffsetAPI_ThruSections(True)
aTool.AddWire(threadingWire1.Wire())
aTool.AddWire(threadingWire2.Wire())
aTool.CheckCompatibility(False)
myThreading = aTool.Shape()
# Build the resulting compound
aRes = TopoDS_Compound()
aBuilder = BRep_Builder()
aBuilder.MakeCompound(aRes)
aBuilder.Add(aRes, myBody.Shape())
aBuilder.Add(aRes, myThreading)
display, start_display, add_menu, add_function_to_menu = init_display('wx')
display.DisplayColoredShape(aRes)
start_display()
import ifcopenshell.geom
# Specify to return pythonOCC shapes from ifcopenshell.geom.create_shape()
settings = ifcopenshell.geom.settings()
settings.set(settings.USE_PYTHON_OPENCASCADE, True)
# Initialize a graphical display window
occ_display = ifcopenshell.geom.utils.initialize_display()
# Open the IFC file using IfcOpenShell
ifc_file = ifcopenshell.open("castest_01.ifc")
# Making compound
compound = TopoDS_Compound()
builder = BRep_Builder()
builder.MakeCompound(compound)
# Display the geometrical contents of the file using Python OpenCascade
products = ifc_file.by_type("IfcProduct")
for product in products:
# Adding a element to compund maked
if product.is_a("IfcOpeningElement"): continue
if product.Representation:
shape = ifcopenshell.geom.create_shape(settings, product).geometry
display_shape = ifcopenshell.geom.utils.display_shape(shape)
builder.Add(compound,shape)
if product.is_a("IfcPlate"):
# Plates are the transparent parts of the window assembly
# in the IfcOpenHouse model
ifcopenshell.geom.utils.set_shape_transparency(display_shape, 0.8)
def write(self, mesh_points, filename, tolerance=None):
"""
Writes a output file, called filename, copying all the structures from self.filename but
the coordinates. mesh_points is a matrix that contains the new coordinates to
write in the output file.
:param numpy.ndarray mesh_points: it is a `n_points`-by-3 matrix containing
the coordinates of the points of the mesh
:param string filename: name of the output file.
:param float tolerance: tolerance for the construction of the faces and wires
in the write function. If not given it uses `self.tolerance`.
"""
self._check_filename_type(filename)
self._check_extension(filename)
self._check_infile_instantiation()
self.outfile = filename
if tolerance is not None:
self.tolerance = tolerance
# cycle on the faces to update the control points position
# init some quantities
faces_explorer = TopExp_Explorer(self.shape, TopAbs_FACE)
n_faces = 0
control_point_position = self._control_point_position
compound_builder = BRep_Builder()
compound = OCC.TopoDS.TopoDS_Compound()
compound_builder.MakeCompound(compound)
while faces_explorer.More():
# similar to the parser method
face = OCC.TopoDS.topods_Face(faces_explorer.Current())
nurbs_converter = BRepBuilderAPI_NurbsConvert(face)
nurbs_converter.Perform(face)
nurbs_face = nurbs_converter.Shape()
face_aux = OCC.TopoDS.topods_Face(nurbs_face)
brep_face = BRep_Tool.Surface(OCC.TopoDS.topods_Face(nurbs_face))
bspline_face = geomconvert_SurfaceToBSplineSurface(brep_face)
occ_face = bspline_face.GetObject()
n_poles_u = occ_face.NbUPoles()
n_poles_v = occ_face.NbVPoles()
i = 0
for pole_u_direction in range(n_poles_u):
for pole_v_direction in range(n_poles_v):
control_point_coordinates = mesh_points[
i + control_point_position[n_faces], :]
point_xyz = gp_XYZ(*control_point_coordinates)
gp_point = gp_Pnt(point_xyz)
occ_face.SetPole(pole_u_direction + 1,
pole_v_direction + 1, gp_point)
i += 1
# construct the deformed wire for the trimmed surfaces
wire_maker = BRepBuilderAPI_MakeWire()
tol = ShapeFix_ShapeTolerance()
brep = BRepBuilderAPI_MakeFace(occ_face.GetHandle(),
self.tolerance).Face()
brep_face = BRep_Tool.Surface(brep)
# cycle on the edges
edge_explorer = TopExp_Explorer(nurbs_face, TopAbs_EDGE)
while edge_explorer.More():
edge = OCC.TopoDS.topods_Edge(edge_explorer.Current())
# edge in the (u,v) coordinates
edge_uv_coordinates = BRep_Tool.CurveOnSurface(edge, face_aux)
# evaluating the new edge: same (u,v) coordinates, but different (x,y,x) ones
edge_phis_coordinates_aux = BRepBuilderAPI_MakeEdge(\
edge_uv_coordinates[0], brep_face)
edge_phis_coordinates = edge_phis_coordinates_aux.Edge()
tol.SetTolerance(edge_phis_coordinates, self.tolerance)
wire_maker.Add(edge_phis_coordinates)
edge_explorer.Next()
# grouping the edges in a wire
wire = wire_maker.Wire()
# trimming the surfaces
brep_surf = BRepBuilderAPI_MakeFace(occ_face.GetHandle(),
wire).Shape()
compound_builder.Add(compound, brep_surf)
n_faces += 1
faces_explorer.Next()
self.write_shape_to_file(compound, self.outfile)
def load_brep(BRepFile):
BRepShape = TopoDS_Shape()
builder = BRep_Builder()
breptools_Read(BRepShape, BRepFile, builder)
return BRepShape
# Number of points
n = 100000
# List for storing TopoDS_Shape instances of vertices if required.
vertexList = []
# Set the side length
side_length = 10.0
# The side length of the box that contains the shapes that will be tested
xSideLength = ySideLength = zSideLength = 0.0
xMin = xMax = yMin = yMax = zMin = zMax = 0.0
# Read the file to get the shape to be sampled.
shape = TopoDS_Shape()
builder = BRep_Builder()
breptools_Read(shape, "cubeWithHole.brep", builder)
# Loop over the shape pulled from the input and look for solids.
solids = [] # A list for storing solids from the file
i = 0 # A counter for writing vertices/points
allPointsDataFrame = pd.DataFrame([]) # A dataframe for ALL points
# OpenCASCADE can only successfully execute point inclusion queries if the
# shape in question is a full solid, which is defined in their topology as
# TopAbs_SOLID. Each solid in the file can sampled individually by pulling
# it from the compound.
if shape.ShapeType() != TopAbs_SOLID:
# Create a topology explorer and pull all the solids from the shape
explorer = TopExp_Explorer(shape, TopAbs_SOLID)
# Loop over all the solids
while explorer.More():
def load_brep(self, path):
""" Load a brep model """
shape = TopoDS_Shape()
builder = BRep_Builder()
breptools_Read(shape, path, builder)
return shape
