def intersect_shape_by_line(topods_shape, line, low_parameter=0.0, hi_parameter=float("+inf")):
"""
finds the intersection of a shape and a line
:param shape: any TopoDS_*
:param line: gp_Lin
:param low_parameter:
:param hi_parameter:
:return: a list with a number of tuples that corresponds to the number
of intersections found
the tuple contains ( gp_Pnt, TopoDS_Face, u,v,w ), respectively the
intersection point, the intersecting face
and the u,v,w parameters of the intersection point
:raise:
"""
from OCC.IntCurvesFace import IntCurvesFace_ShapeIntersector
shape_inter = IntCurvesFace_ShapeIntersector()
shape_inter.Load(topods_shape, TOLERANCE)
shape_inter.PerformNearest(line, low_parameter, hi_parameter)
with assert_isdone(shape_inter, "failed to computer shape / line intersection"):
return (shape_inter.Pnt(1),
shape_inter.Face(1),
shape_inter.UParameter(1),
shape_inter.VParameter(1),
shape_inter.WParameter(1))
def make_shell(*args):
shell = BRepBuilderAPI_MakeShell(*args)
st = ShapeToTopology()
with assert_isdone(shell, 'failed to produce shell'):
result = shell.Shell()
shell.Delete()
return st(result)
def make_prism(profile, vec):
'''
makes a finite prism
'''
pri = BRepPrimAPI_MakePrism(profile, vec, True)
with assert_isdone(pri, 'failed building prism'):
pri.Build()
return pri.Shape()
def distance_on_curve(self, distance, close_parameter, estimate_parameter, check_seam=True):
'''returns the parameter if there is a parameter
on the curve with a distance length from u
raises OutOfBoundary if no such parameter exists
'''
ccc = GCPnts_AbscissaPoint(self.adaptor, distance, close_parameter, estimate_parameter, 1e-5)
with assert_isdone(ccc, 'couldnt compute distance on curve'):
return ccc.Parameter()
def mirror_pnt_dir(brep, pnt, direction, copy=False):
'''
@param brep:
@param line:
'''
trns = gp_Trsf()
trns.SetMirror(gp_Ax1(pnt, direction))
brep_trns = BRepBuilderAPI_Transform(brep, trns, copy)
with assert_isdone(brep_trns, 'could not produce mirror'):
brep_trns.Build()
return brep_trns.Shape()
def mirror_axe2(brep, axe2, copy=False):
'''
@param brep:
@param line:
'''
trns = gp_Trsf()
trns.SetMirror(axe2)
brep_trns = BRepBuilderAPI_Transform(brep, trns, copy)
with assert_isdone(brep_trns, 'could not produce mirror'):
brep_trns.Build()
return brep_trns.Shape()
def wire_to_curve(wire, tolerance=TOLERANCE, order=GeomAbs_C2, max_segment=200, max_order=12):
'''
a wire can consist of many edges.
these edges are merged given a tolerance and a curve
@param wire:
'''
adap = BRepAdaptor_CompCurve(wire)
hadap = BRepAdaptor_HCompCurve(adap)
from OCC.Approx import Approx_Curve3d
approx = Approx_Curve3d(hadap.GetHandle(), tolerance, order, max_segment, max_order)
with assert_isdone(approx, 'not able to compute approximation from wire'):
return approx.Curve().GetObject()
def make_closed_polygon(*args):
poly = BRepBuilderAPI_MakePolygon()
for pt in args:
if isinstance(pt, list) or isinstance(pt, tuple):
for i in pt:
poly.Add(i)
else:
poly.Add(pt)
poly.Build()
poly.Close()
with assert_isdone(poly, 'failed to produce wire'):
result = poly.Wire()
return result
def rotate(brep, axe, degree, copy=False):
'''
@param brep:
@param axe:
@param degree:
'''
from math import radians
trns = gp_Trsf()
trns.SetRotation(axe, radians(degree))
brep_trns = BRepBuilderAPI_Transform(brep, trns, copy)
with assert_isdone(brep_trns, 'could not produce rotation'):
brep_trns.Build()
return ST(brep_trns.Shape())
def resample_curve_with_uniform_deflection(curve, deflection=0.5, degreeMin=3, degreeMax=8, continuity=GeomAbs_C2, tolerance=1e-4):
'''
fits a bspline through the samples on `curve`
@param curve: TopoDS_Wire, TopoDS_Edge, curve
@param n_samples:
'''
from OCC.GCPnts import GCPnts_UniformDeflection
crv = to_adaptor_3d(curve)
defl = GCPnts_UniformDeflection(crv, deflection)
with assert_isdone(defl, 'failed to compute UniformDeflection'):
print 'number of points:', defl.NbPoints()
sampled_pnts = [defl.Value(i) for i in xrange(1, defl.NbPoints())]
resampled_curve = GeomAPI_PointsToBSpline(point_list_to_TColgp_Array1OfPnt(sampled_pnts), degreeMin, degreeMax, continuity, tolerance)
return resampled_curve.Curve().GetObject()
def make_wire(*args):
# if we get an iterable, than add all edges to wire builder
if isinstance(args[0], list) or isinstance(args[0], tuple):
wire = BRepBuilderAPI_MakeWire()
#from OCC.TopTools import TopTools_ListOfShape
for i in args[0]:
wire.Add(i)
wire.Build()
return wire.Wire()
wire = BRepBuilderAPI_MakeWire(*args)
wire.Build()
with assert_isdone(wire, 'failed to produce wire'):
result = wire.Wire()
return result
def make_polygon(args, closed=False):
poly = BRepBuilderAPI_MakePolygon()
for pt in args:
# support nested lists
if isinstance(pt, list) or isinstance(pt, tuple):
for i in pt:
poly.Add(i)
else:
poly.Add(pt)
if closed:
poly.Close()
poly.Build()
with assert_isdone(poly, 'failed to produce wire'):
result = poly.Wire()
return result
def make_loft(elements, ruled=False, tolerance=TOLERANCE, continuity=GeomAbs_C2, check_compatibility=True):
from OCC.BRepOffsetAPI import BRepOffsetAPI_ThruSections
sections = BRepOffsetAPI_ThruSections(False, ruled, tolerance)
for i in elements:
if isinstance(i, TopoDS_Wire):
sections.AddWire(i)
elif isinstance(i, TopoDS_Vertex):
sections.AddVertex(i)
else:
raise TypeError('elements is a list of TopoDS_Wire or TopoDS_Vertex, found a %s fool' % ( i.__class__ ))
sections.CheckCompatibility(check_compatibility)
sections.SetContinuity(continuity)
sections.Build()
with assert_isdone(sections, 'failed lofting'):
te = ShapeToTopology()
loft = te(sections.Shape())
return loft
def minimum_distance(shp1, shp2):
'''
compute minimum distance between 2 BREP's
@param shp1: any TopoDS_*
@param shp2: any TopoDS_*
@return: minimum distance,
minimum distance points on shp1
minimum distance points on shp2
'''
from OCC.BRepExtrema import BRepExtrema_DistShapeShape
bdss = BRepExtrema_DistShapeShape(shp1, shp2)
bdss.Perform()
with assert_isdone(bdss, 'failed computing minimum distances'):
min_dist = bdss.Value()
min_dist_shp1, min_dist_shp2 = [], []
for i in range(1, bdss.NbSolution()+1):
min_dist_shp1.append(bdss.PointOnShape1(i))
min_dist_shp2.append(bdss.PointOnShape2(i))
return min_dist, min_dist_shp1, min_dist_shp2
def curve_to_bspline(crv_handle, tolerance=TOLERANCE, continuity=GeomAbs_C1, sections=300, degree=12):
approx_curve = GeomConvert_ApproxCurve(crv_handle, tolerance, continuity, sections, degree)
with assert_isdone(approx_curve, 'could not compute bspline from curve'):
return approx_curve.Curve()
def make_solid(*args):
sld = BRepBuilderAPI_MakeSolid(*args)
with assert_isdone(sld, 'failed to produce solid'):
result = sld.Solid()
sld.Delete()
return result
def make_face(*args):
face = BRepBuilderAPI_MakeFace(*args)
with assert_isdone(face, 'failed to produce face'):
result = face.Face()
face.Delete()
return result
def make_box(*args):
box = BRepPrimAPI_MakeBox(*args)
box.Build()
with assert_isdone(box, 'failed to built a cube...'):
return box.Shape()
def make_edge(*args):
edge = BRepBuilderAPI_MakeEdge(*args)
with assert_isdone(edge, 'failed to produce edge'):
result = edge.Edge()
edge.Delete()
return result
def make_pipe(spine, profile):
from OCC.BRepOffsetAPI import BRepOffsetAPI_MakePipe
pipe = BRepOffsetAPI_MakePipe(spine, profile)
with assert_isdone(pipe, 'failed building pipe'):
pipe.Build()
return pipe.Shape()
def make_evolved(spine, profile):
evol = BRepOffsetAPI_MakeEvolved(spine, profile)
with assert_isdone(evol, 'failed buillding evolved'):
evol.Build()
return evol.Evolved()
def make_vertex(*args):
vert = BRepBuilderAPI_MakeVertex(*args)
with assert_isdone(vert, 'failed to produce vertex'):
result = vert.Vertex()
vert.Delete()
return result
