def sxy_tar(self):
prf = self.dir + self.tar.name + "_" + "sz" + "_profile.txt"
sx = float(getline(prf, 7).split()[1])
sy = float(getline(prf, 8).split()[1])
sxy = gp_Pnt(sx, sy, 0).Transformed(self.tar.trf)
h_srf = BRep_Tool.Surface(self.tar.srf)
self.tar.sxy = GeomAPI_ProjectPointOnSurf(sxy, h_srf).Point(1)
def __init__(self):
plotocc.__init__(self)
self.shell = read_step_file(self.tmpdir + "SurfUV.stp")
print(self.shell)
top = TopExp_Explorer(self.shell, TopAbs_FACE)
self.face = top.Current()
print(top.Depth())
print(self.face)
self.surf = BRep_Tool.Surface(self.face)
u0, u1, v0, v1 = shapeanalysis_GetFaceUVBounds(self.face)
print(u0, u1, v0, v1)
sas = ShapeAnalysis_Surface(self.surf)
print(sas.Value(u0, v0))
print(sas.Value(u0, v1))
print(sas.Value(u1, v0))
print(sas.Value(u1, v1))
u = u0
while u <= u1:
v = v0
while v <= v1:
p = sas.Value(u, v)
self.display.DisplayShape(p, update=False)
v += 1 / 3
u += 1 / 4
def setup_sxy(filename, ext="ex"):
axs, srf, trf = set_axs_pln(filename)
prf = filename + "_" + ext + "_profile.txt"
sx = float(getline(prf, 7).split()[1])
sy = float(getline(prf, 8).split()[1])
sxy = gp_Pnt(sx, sy, 0).Transformed(trf)
h_srf = BRep_Tool.Surface(srf)
sxy = GeomAPI_ProjectPointOnSurf(sxy, h_srf).Point(1)
return axs, srf, trf, sxy
def project_to_UV(self):
assert self.face != None
surface = BRep_Tool.Surface(self.face)
analysis_surface = ShapeAnalysis_Surface(surface)
xyz = gp_Pnt(self.x, self.y, self.z)
uv = analysis_surface.ValueOfUV(xyz, 0.0001)
self.u = uv.X()
self.v = uv.Y()
if self.face.Orientation() == TopAbs_REVERSED:
self.reverse_u()
def Reflect(self):
h_surf = BRep_Tool.Surface(self.tar.srf)
g_line = gp_Lin(self.ini.beam.Location(), self.ini.beam.Direction())
ray = Geom_Line(g_line)
if GeomAPI_IntCS(ray, h_surf).NbPoints():
self.tar.beam = reflect(self.ini.beam, self.tar.srf)
else:
pln = make_plane(self.tar.axs.Location(),
dir_to_vec(self.tar.axs.Direction()), 500, -500,
500, -500)
self.tar.beam = reflect(self.ini.beam, pln)
def reflect(beam, face, axs=gp_Ax3()):
p0, v0 = beam.Location(), dir_to_vec(beam.Direction())
h_surf = BRep_Tool.Surface(face)
ray = Geom_Line(gp_Lin(p0, vec_to_dir(v0)))
if GeomAPI_IntCS(ray, h_surf).NbPoints() == 0:
print("Out of Surface", axs.Location())
pln = make_plane(axs.Location(), dir_to_vec(axs.Direction()), 500,
-500, 500, -500)
h_surf = BRep_Tool.Surface(pln)
GeomAPI_IntCS(ray, h_surf).IsDone()
uvw = GeomAPI_IntCS(ray, h_surf).Parameters(1)
u, v, w = uvw
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(h_surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy)
vx.Normalize()
vy.Normalize()
vz.Normalize()
v1 = v0.Mirrored(gp_Ax2(p1, vec_to_dir(vz), vec_to_dir(vx)))
return gp_Ax3(p1, vec_to_dir(v1), beam.XDirection().Reversed())
def getPntsEdgesFacesIntersect(edgesShape, facesShape):
pnts = []
faces = getShapeItems(facesShape, TopAbs_FACE)
edges = getShapeItems(edgesShape, TopAbs_EDGE)
for edge in edges:
for face in faces:
curve3 = BRep_Tool.Curve(edge)
curve = Geom_TrimmedCurve(curve3[0],curve3[1],curve3[2])
surface = BRep_Tool.Surface(face)
pntsToAdd = getPntsCurveSurfaceIntersect(curve, surface)
pnts += pntsToAdd
return pnts
def reflect(p0, v0, face):
h_surf = BRep_Tool.Surface(face)
ray = Geom_Line(gp_Lin(p0, vec_to_dir(v0)))
uvw = GeomAPI_IntCS(ray.GetHandle(), h_surf).Parameters(1)
u, v, w = uvw
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(h_surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy)
vx.Normalize()
vy.Normalize()
vz.Normalize()
v1 = v0.Mirrored(gp_Ax2(p1, vec_to_dir(vz)))
return p1, v1
def xyz_from_uv_face_unnormlized(uv, face):
"""
Given a face and a uv coordinate, return the xyz coordinate
"""
# print(uv)
result = BRep_Tool.Surface(
face
) ###result[0] is the handle of curve;result[1] is the umin; result[2] is umax
aPnt = result.GetObject().Value(
uv[0],
uv[1]) ###handle_Geom_Curve.GetObject() will give the Geom_Curve
return aPnt
def Reflect(self):
h_surf = BRep_Tool.Surface(self.tar.srf)
g_line = gp_Lin(self.ini.beam.Location(), self.ini.beam.Direction())
ray = Geom_Line(g_line)
if GeomAPI_IntCS(ray, h_surf).NbPoints():
self.tar.beam = reflect(self.ini.beam, self.tar.srf)
else:
pln = make_plane(self.tar.axs.Location(),
dir_to_vec(self.tar.axs.Direction()), 500, -500,
500, -500)
h_surf = BRep_Tool.Surface(pln)
self.tar.beam = reflect(self.ini.beam, pln)
print(self.ini.beam.Location())
print(self.tar.beam.Location())
GeomAPI_IntCS(ray, h_surf).IsDone()
uvw = GeomAPI_IntCS(ray, h_surf).Parameters(1)
u, v, w = uvw
print(u, v, w)
vz, v1, v2, r1, r2 = axs_curvature(h_surf, u, v)
tar_surf_axs = gp_Ax3(self.tar.beam.Location(), vec_to_dir(vz),
vec_to_dir(v1))
tar_surf = wavefront([r1, r2], tar_surf_axs)
self.display.DisplayShape(tar_surf, color="BLUE")
self.display.DisplayShape(axs_pln(tar_surf_axs))
self.GO_Prop(w)
h_tar_wave = BRep_Tool.Surface(self.ini_wave)
vz, v1, v2, r1, r2 = axs_curvature(h_tar_wave, u, v)
tar_wave_axs = self.tar.beam.Translated(gp_Vec(0, 0, 0))
tar_wave_axs.SetXDirection(vec_to_dir(v1))
self.tar.wave = wavefront([r1, r2], tar_wave_axs)
self.display.DisplayShape(self.tar.wave, color="RED")
self.display.DisplayShape(axs_pln(tar_wave_axs))
def export_sfc1_axs(self, sfcfile="pln1_mat.sfc", name="pln1 Mat"):
surf = BRep_Tool.Surface(self.surf)
trf = set_trf(self.axs, gp_Ax3())
xy0 = dispocc.proj_pnt_pln(self, surf.Value(0, 0), self.pln, self.axs)
xy1 = dispocc.proj_pnt_pln(self, surf.Value(1, 1), self.pln, self.axs)
xy0.Transform(trf)
xy1.Transform(trf)
m2_trf = set_trf(gp_Ax3(), self.axs)
m2_pln = BRep_Tool.Surface(self.pln)
for px in np.linspace(-100, 100, 10):
for py in np.linspace(-100, 100, 10):
p0 = gp_Pnt(px, py, 0).Transformed(m2_trf)
p1 = obj.proj_pnt_pln(p0, self.surf, self.axs)
#ix0, ix1 = m2.surf_pts.LowerRow(), m2.surf_pts.UpperRow()
#iy0, iy1 = m2.surf_pts.LowerCol(), m2.surf_pts.UpperCol()
#xy0 = m2.surf_pts.Value(ix0, iy0).Transformed(trf)
#xy1 = m2.surf_pts.Value(ix1, iy1).Transformed(trf)
nx, ny = 200, 200
xs, xe = xy0.X(), xy1.X()
ys, ye = xy0.Y(), xy1.Y()
fp = open(sfcfile, "w")
fp.write(" {} \n".format(name))
fp.write(" {:.2e} {:.2e} {:.2e} {:.2e}\n".format(xs, ys, xe, ye))
fp.write(" {:d} {:d}\n".format(nx, ny))
for ix in np.linspace(0, 1, nx):
for iy in np.linspace(0, 1, ny):
p0 = surf.Value(ix, iy)
p1 = dispocc.proj_pnt_pln(self, p0, self.pln, self.axs)
pz = p1.Transformed(trf)
z = p0.Distance(p1)
fp.write(" {:.5e} ".format(z))
fp.write("\n")
fp.close()
print(xy0)
def xyz_from_uv_face(uv, face):
"""
Given a face and a uv coordinate, return the xyz coordinate
"""
# print(uv)
[umin, umax, vmin, vmax] = face_extreme(face)
u = umin + (umax - umin) * uv[0]
v = vmin + (vmax - vmin) * uv[1]
result = BRep_Tool.Surface(
face
) ###result[0] is the handle of curve;result[1] is the umin; result[2] is umax
aPnt = result.GetObject().Value(
u, v) ###handle_Geom_Curve.GetObject() will give the Geom_Curve
return aPnt
def get_ellips(axs, wxy, face=None):
wx, wy = wxy
if wx >= wy:
ax2 = axs
r0, r1 = wx, wy
else:
ax2 = axs.Rotated(axs.Axis(), np.deg2rad(90))
r0, r1 = wy, wx
el = Geom_Ellipse(ax2, r0, r1)
if face == None:
return el
else:
curv = geomprojlib_Project(el.GetHandle(), BRep_Tool.Surface(face))
return curv
def proj_pln_show(self,
face,
nxy=[10, 10],
ux=[0, 1],
uy=[0, 1],
axs=gp_Ax3()):
trf = set_trf(gp_Ax3(), axs)
pln = self.make_plane_axs(axs, [-1000, 1000], [-1000, 1000])
surf = BRep_Tool.Surface(face)
for px in np.linspace(ux[0], ux[1], nxy[0]):
for py in np.linspace(uy[0], uy[1], nxy[1]):
p0 = surf.Value(px, py)
p1 = self.proj_pnt_pln(p0, pln, axs)
self.display.DisplayShape(p0)
self.display.DisplayShape(p1)
def __init__(self):
super().__init__()
self.axs = gp_Ax3()
self.radi = [500, 200]
self.rxyz = [1.5, 1.2, 1.5]
mat = gp_Mat(self.rxyz[0], 0, 0, 0, self.rxyz[1], 0, 0, 0,
self.rxyz[2])
gtrf = gp_GTrsf(mat, gp_XYZ(0, 0, 0))
#self.t = Geom_ToroidalSurface(self.axs, *self.radi)
self.t = Geom_SphericalSurface(self.axs, 100.0)
self.face = BRepBuilderAPI_MakeFace(self.t, 1e-6).Face()
self.face = BRepBuilderAPI_GTransform(self.face, gtrf).Shape()
self.surf = BRep_Tool.Surface(self.face)
self.prop = GeomLProp_SLProps(self.surf, 0.0, 0.0, 1, 1.0)
self.export_stp(self.face)
print(self.t.UPeriod())
def _bspline_surface_from_face(self, face):
"""
Private method that takes a TopoDS_Face and transforms it into a
Bspline_Surface.
:param TopoDS_Face face: the TopoDS_Face to be converted
:rtype: Geom_BSplineSurface
"""
if not isinstance(face, TopoDS_Face):
raise TypeError("face must be a TopoDS_Face")
# TopoDS_Face converted to Nurbs
nurbs_face = topods_Face(BRepBuilderAPI_NurbsConvert(face).Shape())
# GeomSurface obtained from Nurbs face
surface = BRep_Tool.Surface(nurbs_face)
# surface is now further converted to a bspline surface
bspline_surface = geomconvert_SurfaceToBSplineSurface(surface)
return bspline_surface
def _unify_faces_array(input):
ret = []
fset = {}
for i in input:
surface = BRep_Tool.Surface(i.Face())
adaptor_surface = BRepAdaptor_Surface(i.Face())
surface_type = adaptor_surface.GetType()
if surface_type == GeomAbs_Plane:
pln = Geom_Plane.DownCast(surface)
pln0 = pln.Pln()
found = False
for key, arr in fset.items():
pnt = gp_Pnt()
key.D0(0, 0, pnt)
pln1 = key.Pln()
dir0 = pln0.Axis().Direction()
dir1 = pln1.Axis().Direction()
if (dir0.IsEqual(dir1, 0.00001) and
abs(pln0.Distance(pln1.Axis().Location())) < 0.0000001
and abs(pln1.Distance(
pln0.Axis().Location())) < 0.0000001):
found = True
arr.append(i)
break
if found == False:
fset[pln] = [i]
else:
ret.append(i)
continue
for key, arr in fset.items():
farr = _union(arr)
ret.append(_unify_face(farr))
return ret
def __init__(self):
plotocc.__init__(self)
self.b1 = self.get_face(gen_ellipsoid(rxyz=[100, 100, 105]))
self.b2 = self.get_face(gen_ellipsoid(rxyz=[210, 210, 210]))
self.beam = gp_Ax3(gp_Pnt(0, 150, 0), gp_Dir(1, 1.5, 0))
print(self.b1)
h_surf = BRep_Tool.Surface(self.b2)
ray = Geom_Line(self.beam.Axis())
self.RayTrace = GeomAPI_IntCS(ray, h_surf)
print(self.RayTrace.NbPoints())
self.num = 0
self.pts = [self.beam.Location()]
for i in range(5):
self.beam = self.reflect_b1(num=1)
self.beam = self.reflect_b1(num=2)
self.beam = self.reflect_b2(num=1)
self.beam = self.reflect_b2(num=2)
def GO_Prop(self, s=0):
h_ini_wave = BRep_Tool.Surface(self.ini.wave)
vz, v1, v2, r1, r2 = axs_curvature(h_ini_wave, 0.5, 0.5)
r1_z = r1 + s / 2
r2_z = r2 + s / 2
ini_wave_axs = self.ini.beam.Translated(
dir_to_vec(self.ini.beam.Direction()).Scaled(s / 2))
ini_wave_axs.SetXDirection(vec_to_dir(v1))
ini_wave = wavefront([r1_z, r2_z], ini_wave_axs)
self.display.DisplayShape(ini_wave)
r1_z = r1 + s
r2_z = r2 + s
self.ini_wave_axs = self.ini.beam.Translated(
dir_to_vec(self.ini.beam.Direction()).Scaled(s))
self.ini_wave_axs.SetXDirection(vec_to_dir(v1))
self.ini_wave = wavefront([r1_z, r2_z], self.ini_wave_axs)
self.display.DisplayShape(self.ini_wave)
def __init__(self, pnt=gp_Pnt(-10, 0, -10), vec=gp_Vec(10, 20, 100)):
plotocc.__init__(self)
self.solver = ode(self.newton).set_integrator('dopri5')
self.initial_conditions = self.gen_condition(pnt, vec)
self.m = 10.0
self.k = 0.0
ray = spl_2pnt()
px = np.linspace(-1, 1, 50) * 750
py = np.linspace(-1, 1, 50) * 750
mesh = np.meshgrid(px, py)
surf = mesh[0]**2 / 500 + mesh[1]**2 / 750
self.grd_axs = gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(-0.25, 0, 1))
#self.grd = pln_for_axs(self.grd_axs, [500, 500])
self.grd = spl_face(*mesh, surf)
self.h_surf = BRep_Tool.Surface(self.grd)
self.p_trce = GeomAPI_IntCS(ray, self.h_surf)
self.pts, self.vel = [], []
def reflect_axs2(beam, surf, axs=gp_Ax3(), indx=1):
p0, v0 = beam.Location(), dir_to_vec(beam.Direction())
h_surf = BRep_Tool.Surface(surf)
ray = Geom_Line(gp_Lin(p0, vec_to_dir(v0)))
if GeomAPI_IntCS(ray, h_surf).NbPoints() == 0:
return beam, beam, None
elif GeomAPI_IntCS(ray, h_surf).NbPoints() == 1:
return beam, beam, None
GeomAPI_IntCS(ray, h_surf).IsDone()
u, v, w = GeomAPI_IntCS(ray, h_surf).Parameters(indx)
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(h_surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy)
vx.Normalize()
vy.Normalize()
vz.Normalize()
v1 = v0.Mirrored(gp_Ax2(p1, vec_to_dir(vz), vec_to_dir(vx)))
norm_ax = gp_Ax3(p1, vec_to_dir(vz), vec_to_dir(vx))
beam_ax = gp_Ax3(p1, vec_to_dir(v1), beam.XDirection().Reversed())
return beam_ax, norm_ax, 1
def Reflect(self, beam=gp_Ax3(), surf=make_plane()):
h_surf = BRep_Tool.Surface(surf)
ray = Geom_Line(beam.Location(), beam.Direction())
if GeomAPI_IntCS(ray, h_surf).NbPoints() == 0:
beam_v1 = beam
else:
GeomAPI_IntCS(ray, h_surf).IsDone()
uvw = GeomAPI_IntCS(ray, h_surf).Parameters(1)
u, v, w = uvw
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(h_surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy)
vx.Normalize()
vy.Normalize()
vz.Normalize()
norm = gp_Ax3(p1, vec_to_dir(vz), vec_to_dir(vx))
beam_v0 = beam
beam_v0.SetLocation(p1)
beam_v1 = beam_v0.Mirrored(norm.Ax2())
beam_v1.XReverse()
return beam_v1
def makeEdgesFacesIntersectPoints(edgesShape, facesShape):
def findIntersectPoints(curve, surface):
ps = []
tool = GeomAPI_IntCS(curve, surface)
pCount = tool.NbPoints()
for i in range(1, pCount + 1):
ps += [tool.Point(i)]
return ps
intersectPoints = []
aEdges = getShapeItems(edgesShape, TopAbs_EDGE)
aFaces = getShapeItems(facesShape, TopAbs_FACE)
for aEdge in aEdges:
for aFace in aFaces:
# noinspection PyTypeChecker
edgeCurves = BRep_Tool.Curve(aEdge)
edgeTrimmedCurve = Geom_TrimmedCurve(edgeCurves[0], edgeCurves[1], edgeCurves[2])
# noinspection PyTypeChecker
faceSurface = BRep_Tool.Surface(aFace)
foundIntersectPoints = findIntersectPoints(edgeTrimmedCurve, faceSurface)
intersectPoints += foundIntersectPoints
return intersectPoints
def reflect_b2(self, num=1):
h_surf = BRep_Tool.Surface(self.b2)
ray = Geom_Line(self.beam.Axis())
self.RayTrace.Perform(ray, h_surf)
if self.RayTrace.NbPoints() == 0:
beam = self.beam
else:
self.num += 1
uvw = self.RayTrace.Parameters(num)
u, v, w = uvw
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(h_surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy).Reversed()
norm = gp_Ax3(p1, vec_to_dir(vz), vec_to_dir(vx))
self.show_axs_pln(norm, scale=10)
beam = self.beam
beam.SetLocation(p1)
beam.SetDirection(beam.Direction().Reversed())
beam.Mirror(norm.Axis())
print(self.num, self.b2, p1)
self.pts.append(p1)
# self.beam.XReverse()
# self.beam.Mirror(norm.Ax2())
return beam
def reflect_beam(self, beam0=gp_Ax3(), tr=0):
v0 = dir_to_vec(beam0.Direction())
v1 = dir_to_vec(beam0.XDirection())
surf = BRep_Tool.Surface(self.surf)
ray = Geom_Line(beam0.Axis())
uvw = GeomAPI_IntCS(ray, surf).Parameters(1)
u, v, w = uvw
p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec()
GeomLProp_SurfaceTool.D1(surf, u, v, p1, vx, vy)
vz = vx.Crossed(vy)
if vz.Dot(v0) > 0:
vz.Reverse()
vx.Normalize()
vy.Normalize()
vz.Normalize()
self.beam = gp_Ax3(p1, vec_to_dir(v0.Reversed()),
vec_to_dir(v1.Reversed()))
self.norm = gp_Ax3(p1, vec_to_dir(vz), vec_to_dir(vx))
if tr == 0:
self.beam.Mirror(self.norm.Ax2())
if self.beam.Direction().Dot(self.norm.Direction()) < 0:
self.beam.ZReverse()
elif tr == 1:
self.beam.ZReverse()
1e-6).Face()
display.DisplayShape(surf)
display.DisplayShape(obj)
#display.DisplayShape(axs_pln(axs))
display.FitAll()
start_display()
init = "surf1"
surf = ["surf2", "surf3", "surf4"]
surf1 = SurfSystem("../input/", "surf1")
surf2 = SurfSystem("../input/", "surf2")
h_surf = BRep_Tool.Surface(surf1.srf)
second_derivative(h_surf, 0.5, 0.5)
second_derivative(h_surf, 0.5, 0.0)
second_derivative(h_surf, 0.0, 0.5)
"""h_surf = BRep_Tool.Surface(surf2.srf)
second_derivative(h_surf, 0.5, 0.5)
second_derivative(h_surf, 0.5, 0.0)
second_derivative(h_surf, 0.0, 0.5)
second_derivative(h_surf, 0.0, 0.0)"""
"""print(surf1.name, surf1.axs.Location())
print(surf2.name, surf2.axs.Location())
print(surf2.srf)
loc_surf = surf2.srf
loc_trsf = gp_Trsf()
loc_trsf.SetTransformation(gp_Ax3(), surf2.axs)
loc_face = TopLoc_Location(loc_trsf)
# https://www.opencascade.com/doc/occt-7.4.0/refman/html/class_b_rep_builder_a_p_i___make_face.html
if __name__ == '__main__':
obj = plotocc()
obj.show_axs_pln(obj.base_axs, scale=1)
px = np.linspace(-1, 1, 10) * 5
py = np.linspace(-1, 1, 10) * 5
mesh = np.meshgrid(px, py)
data = mesh[0]**2 / 10 + mesh[1]**2 / 20
axis = gp_Ax3(gp_Pnt(0.5, 0.0, 0.0), gp_Dir(0, 0, 1))
face = spl_face(*mesh, data, axs=axis)
#face = bez_face(*mesh, data, axs=axis)
trsf = face.Location().Transformation()
surf = BRep_Tool.Surface(face)
axis_0 = axis.Transformed(trsf)
axis_0.Translate(gp_Pnt(0, 0, 0), gp_Pnt(2, 0, 0))
poly_0 = obj.make_EllipWire(rxy=[1.1, 1.0], axs=axis_0)
proj = BRepProj_Projection(poly_0, face, axis.Direction())
bound_poly_0 = proj.Current()
axis_1 = axis.Transformed(trsf)
axis_1.Translate(gp_Pnt(0, 0, 0), gp_Pnt(-2, 0, 0))
poly_1 = obj.make_PolyWire(num=6, axs=axis_1)
proj = BRepProj_Projection(poly_1, face, axis.Direction())
bound_poly_1 = proj.Current()
axis_2 = axis.Transformed(trsf)
axis_2.Translate(gp_Pnt(0, 0, 0), gp_Pnt(0, 2, 0))
def proj_pnt_pln(self, pnt, surf, axs=gp_Ax3()):
lin = gp_Lin(pnt, axs.Direction())
sxy = GeomAPI_IntCS(Geom_Line(lin), BRep_Tool.Surface(surf)).Point(1)
return sxy
def Prj_pnt_to_face(axs, pnt, face):
lin = gp_Lin(pnt, axs.Direction())
sxy = GeomAPI_IntCS(Geom_Line(lin).GetHandle(),
BRep_Tool.Surface(face)).Point(1)
return sxy
obj = dispocc(touch=True)
axs = gp_Ax3(gp_Pnt(100, -100, 200), gp_Dir(0, 0.5, 1.0),
gp_Dir(0.5, 1.0, 0))
qp = gp_Quaternion()
qp.SetRotation(gp_Vec(0, 0, 100), gp_Vec(50, 0, 0))
print(qp)
obj.show_axs_pln(axs, scale=50, name="axs0")
trf = gp_Trsf()
trf.SetTransformation(qp, gp_Vec(0, 0, 1))
ax1 = axs.Transformed(trf)
obj.show_axs_pln(ax1, scale=50, name="axs1")
ax2 = obj.prop_axs(ax1, scale=50)
obj.show_axs_pln(ax2, scale=50, name="axs2")
ax3 = obj.rot_axis(ax2, xyz="z", deg=45)
obj.show_axs_pln(ax3, scale=50)
pln1 = obj.show_plane(ax3, scale=25, trs=0.9, color="RED")
srf1 = BRep_Tool.Surface(pln1)
ax3 = obj.rot_axis(ax3, xyz="x", deg=5)
obj.show_axs_pln(ax3, scale=50)
pln2 = obj.show_plane(ax3, scale=25, trs=0.9, color="BLUE")
srf2 = BRep_Tool.Surface(pln2)
api = GeomAPI_IntSS(srf1, srf2, 0.1E-3)
obj.display.DisplayShape(api.Line(1))
obj.show_axs_pln(scale=25)
obj.show()