def line(): # create a line p1 = gp_Pnt(2., 3., 4.) d1 = gp_Dir(4., 5., 6.) line1 = Geom_Line(p1, d1) ais_line1 = AIS_Line(line1) # if we need to edit color, we can simply use SetColor # ais_line1.SetColor(Quantity_NOC_RED) # but actually we need to edit more, not just color. Line width and style as well # To do that, we need to do use AIS_Drawer and apply it to ais_line1 drawer = Prs3d_Drawer() ais_line1.SetAttributes(drawer) display.Context.Display(ais_line1, False) # we can apply the same rule for other lines by just doing a for loop for i in range(1, 5): p2 = gp_Pnt(i, 2., 5.) d2 = gp_Dir(4 * i, 6., 9.) line2 = Geom_Line(p2, d2) ais_line2 = AIS_Line(line2) width = float(i) drawer = ais_line2.Attributes() # asp : first parameter color, second type, last width asp = Prs3d_LineAspect(9 * i, i, width) drawer.SetLineAspect(asp) ais_line2.SetAttributes(drawer) display.Context.Display(ais_line2, False) start_display()
def make_axis_triedron(self): self.x_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(1, 0, 0))))) self.y_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(0, 1, 0))))) self.z_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(0, 0, 1))))) self.x_axis.SetColor(Quantity_Color(1, 0, 0, Quantity_TOC_RGB)) self.y_axis.SetColor(Quantity_Color(0, 1, 0, Quantity_TOC_RGB)) self.z_axis.SetColor(Quantity_Color(0, 0, 1, Quantity_TOC_RGB))
def to_Geom_Line(self): return Geom_Line( gp_Lin( gp_Pnt(0, 0, 0), gp_Dir( gp_XYZ(self._coords[0], self._coords[1], self._coords[2]))))
def geomLineBldr(self, cline): """Convert native cline to type: <Geom_Line>.""" a, b, c = cline gpLin2d = gp_Lin2d(a, b, c) gpDir2d = gpLin2d.Direction() gpPnt2d = gpLin2d.Location() gpPnt = gp_Pnt(gpPnt2d.X(), gpPnt2d.Y(), 0).Transformed(self.Trsf) gpDir = gp_Dir(gpDir2d.X(), gpDir2d.Y(), 0).Transformed(self.Trsf) return Geom_Line(gpPnt, gpDir)
def mk_colored_line(self, start, direction, color, linestyle, width): line = Geom_Line(start, direction) ais_line = AIS_Line(line) drawer = ais_line.Attributes() aspect = Prs3d_LineAspect(color, linestyle, width) drawer.SetLineAspect(aspect) ais_line.SetAttributes(drawer) return ais_line
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(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 addLines(self): origin = (0, 0, 0) ais_list = [] for name, color, direction in zip(('X', 'Y', 'Z'), ('ff0000', '00ff00', '0000ff'), ((1, 0, 0), (0, 1, 0), (0, 0, 1))): line_placement = Geom_Line( gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction))) line = AIS_Line(line_placement) self.Helpers.addChild(ObjectTreeItem(name, ais=line, color=color)) ais_list.append(line) self.sigObjectsAdded.emit(ais_list)
def FindGeometry(self, object: AIS_InteractiveObject): if object.Type() == AIS_KOI_Shape: shape = self.myContext.SelectedShape() if shape.ShapeType() == TopAbs_VERTEX: pass elif shape.ShapeType() == TopAbs_EDGE: curve = BRepAdaptor_Curve(shape) curve_type = curve.GetType() if curve_type == GeomAbs_BezierCurve: return curve.Bezier() elif curve_type == GeomAbs_BSplineCurve: return curve.BSpline() elif curve_type == GeomAbs_Circle: return Geom_Circle(curve.Circle()) elif curve_type == GeomAbs_Line: return Geom_Line(curve.Line()) elif shape.ShapeType() == TopAbs_FACE: pass
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 addLines(self): origin = (0, 0, 0) ais_list = [] for name, color, direction in zip(('X', 'Y', 'Z'), (RED, GREEN, BLUE), ((1, 0, 0), (0, 1, 0), (0, 0, 1))): line_placement = Geom_Line( gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction))) line = AIS_Line(line_placement) line.SetColor(color) self.Helpers.addChild(ObjectTreeItem(name, ais=line)) ais_list.append(line) self.sigObjectsAdded.emit(ais_list) self.tree.expandToDepth(1)
def addLines(self): origin = (0, 0, 0) ais_list = [] for name, color, direction in zip(('X', 'Y', 'Z'), ('red', 'lawngreen', 'blue'), ((1, 0, 0), (0, 1, 0), (0, 0, 1))): line_placement = Geom_Line( gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction))) line = AIS_Line(line_placement) line.SetColor(to_occ_color(color)) self.Helpers.addChild(ObjectTreeItem(name, ais=line)) ais_list.append(line) self.sigObjectsAdded.emit(ais_list)
def intersections_with_line(self, line): """Compute the intersections with a line. Parameters ---------- line : :class:`~compas.geometry.Line` Returns ------- list[:class:`~compas.geometry.Point`] """ intersection = GeomAPI_IntCS(Geom_Line(line.to_occ()), self.occ_surface) points = [] for index in range(intersection.NbPoints()): pnt = intersection.Point(index + 1) point = Point.from_occ(pnt) points.append(point) return points
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 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 __init__(self, theDisplay, sg: Sketch_QTGUI = None): self.myCoordinateSystem = gp_Ax3(gp.XOY()) self.myContext: AIS_InteractiveContext = theDisplay.Context self.myDisplay = theDisplay self.myView: V3d_View = theDisplay.View self.myGUI = sg self.myGUI.SetAx3(self.myCoordinateSystem) self.myGUI.SetContext(self.myContext) self.myCurrentMethod = Sketch_ObjectTypeOfMethod.Nothing_Method self.myCurrentDir: gp_Dir = gp.DZ() self.myTempPnt: gp_Pnt = gp.Origin() self.myCurrentPnt2d: gp_Pnt2d = gp.Origin2d() self.myCurrentPlane = Geom_Plane(self.myCoordinateSystem) self.myCurrentLine = Geom_Line(self.myTempPnt, self.myCurrentDir) self.myIntCS = GeomAPI_IntCS() self.PolylineFirstPoint = gp.Origin2d() self.PolylineFirstPointExist = False self.myData = [] self.myNode: SketchObjectNode = None self.myModel = None self.SnapToGridPoint = False self.myCommands = [] self.myAnalyserSnap = Sketch_AnalyserSnap(self.myContext, self.myData, self.myCoordinateSystem) self.addCommand(Sketch_CommandPoint()) self.addCommand(Sketch_CommandLine2P()) self.addCommand(Sketch_CommandBezierCurve()) self.addCommand(Sketch_CommandArcCenter2P()) self.addCommand(Sketch_CommandCircleCenterRadius()) self.addCommand(Sketch_CommandBSpline()) self.addCommand(Sketch_CommandPointToBSpline()) self.addCommand(Sketch_CommandMoveObject()) self.addCommand(Sketch_CommandNurbCircleSquare()) self.addCommand(Sketch_CommandNurbCircleTriangle())
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 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 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()
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 __init__(self): plotocc.__init__(self) self.compound = TopoDS_Compound() self.builder = BRep_Builder() self.builder.MakeCompound(self.compound) self.beam = gp_Ax3() self.beam.SetLocation(gp_Pnt(0.5, 0.5, 0.0)) self.beam.SetDirection(gp_Dir(0.0, 0.5, 1.0)) self.beam_line = line_from_axs(self.beam, length=20) self.builder.Add(self.compound, self.beam_line) ax = gp_Ax3(gp_Pnt(0, 0, 10), gp_Dir(0, 0, -1)) px = np.linspace(-1, 1, 10) * 10 py = np.linspace(-1, 1, 10) * 10 mesh = np.meshgrid(px, py) surf = mesh[0]**2 / 100 + mesh[1]**2 / 150 self.surf = spl_face(*mesh, surf, ax) self.surf_bound = self.make_PolySurf(radi=5, axs=ax) self.beam_glin = Geom_Line(self.beam.Location(), self.beam.Direction()) self.ics = GeomAPI_IntCS(self.beam_glin, BRep_Tool.Surface(self.surf)) print(self.ics.NbPoints()) # print(self.ics.Point(1)) self.ics = GeomAPI_IntCS(self.beam_glin, BRep_Tool.Surface(self.surf_bound)) print(self.ics.NbPoints()) #self.display.DisplayShape(self.surf, transparency=0.7) self.display.DisplayShape(self.surf_bound, transparency=0.7) self.plns = TopoDS_Shell() self.builder.MakeShell(self.plns) for ix in np.linspace(0, 1, 5): for iy in np.linspace(0, 1, 5): p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec() GeomLProp_SurfaceTool.D1(BRep_Tool.Surface(self.surf), ix, iy, p1, vx, vy) vz = vx.Crossed(vy) axs = gp_Ax3(p1, vec_to_dir(vz), vec_to_dir(vx)) pln = self.make_PolyPlane(axs=axs, radi=2.5, shft=15.0) print(pln) self.builder.Add(self.compound, make_vertex(p1)) self.builder.Add(self.plns, pln) self.builder.Add(self.compound, self.plns) for face in Topo(self.plns).faces(): self.ics.Perform(self.beam_glin, BRep_Tool.Surface(face)) uvw = self.ics.Parameters(1) u, v, w = uvw p1, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec() GeomLProp_SurfaceTool.D1(BRep_Tool.Surface(face), u, v, p1, vx, vy) vz = vx.Crossed(vy) if u > 0 and v > 0: print(u, v) print(p1) print(self.ics.Point(1)) self.display.DisplayShape(p1) self.display.DisplayShape(face, color="BLUE") else: print(u, v)
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
points1.append(Point(-7, 2, 2)) points1.append(Point(-6, 3, 1)) points1.append(Point(-4, 3, -1)) points1.append(Point(-3, 5, -2)) spline1 = BSplineCurve.from_points(points1) points2 = [] points2.append(Point(-4, 0, 2)) points2.append(Point(-2, 2, 0)) points2.append(Point(2, 3, -1)) points2.append(Point(3, 7, -2)) points2.append(Point(4, 9, -1)) spline2 = BSplineCurve.from_points(points2) surface = BSplineSurface.from_fill(spline1, spline2) line = Geom_Line(gp_Pnt(0, 4, 0), gp_Dir(0, 0, 1)) # ============================================================================== # Intersection # ============================================================================== intersection = GeomAPI_IntCS(line, surface.occ_surface) pnt = intersection.Point(1) point = Point.from_occ(pnt) # ============================================================================== # Viz # ============================================================================== mesh = surface.to_vizmesh()
# obj.show_ball() axs = gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(1, 1, 1)) elp = gen_ellipsoid(axs, [10, 20, 30]) obj.display.DisplayShape(elp, transparency=0.7, color="BLUE") obj.show_axs_pln(axs, scale=20) axs = gp_Ax3(gp_Pnt(30, 0, 0), gp_Dir(1, 1, 0)) elp = gen_ellipsoid(axs, [10, 20, 30]) obj.display.DisplayShape(elp, transparency=0.7, color="BLUE") obj.show_axs_pln(axs, scale=20) #elp = gen_ellipsoid_geom(axs, [10, 20, 30]) top_api = Topo(elp) print(top_api.number_of_faces()) for face in top_api.faces(): elp_face = face print(elp_face) elp_surf = BRep_Tool_Surface(elp_face) print(elp_surf) lin = Geom_Line(gp_Ax1(axs.Location(), gp_Dir(0, 1, 1))) api = GeomAPI_IntCS(lin, elp_surf) obj.display.DisplayShape(lin) print(api.Point(1)) print(api.Point(2)) obj.show()
def show_line(self, origin=(0, 0, 0), direction=(0, 0, 1)): line_placement = Geom_Line(gp_Ax1(gp_Pnt(*origin), gp_Dir(*direction))) line = AIS_Line(line_placement) self._display_ais(line)
def doscreen_impl(model, path, size, yaw=None, pitch=None, triedron=True): scn = Scene() try: mmm = model if isinstance(mmm, evalcache.LazyObject): mmm = mmm.unlazy() c = zencad.default_color() if REVERSE_COLOR: c = (c[2], c[1], c[0]) scn.add(mmm, c) except: for m in model: if isinstance(m, (tuple, list)): c = m[1] m = m[0] else: c = zencad.default_color() if REVERSE_COLOR: c = (c[2], c[1], c[0]) mod = m if isinstance(mod, evalcache.LazyObject): mod = mod.unlazy() if isinstance(mod, zencad.util.point3): c = Color(1, 0, 0) if REVERSE_COLOR: c = (c[2], c[1], c[0]) scn.add(mod, c) else: scn.add(mod, c) #viewer = scn.viewer # if triedron: # Always add triedron # viewer.set_triedron_axes() #view = viewer.create_view() # view.set_triedron(False) #view.set_virtual_window(size[0], size[1]) if yaw is None: yaw = math.pi * (7 / 16) + math.pi / 2 if pitch is None: pitch = math.pi * -0.15 render = OffscreenRenderer(path, size) for i in scn.interactives: render.Context.Display(i.ais_object, True) i.bind_context(render.Context) if triedron: x_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(1, 0, 0))))) y_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(0, 1, 0))))) z_axis = AIS_Axis( Geom_Line(gp_Lin(gp_Pnt(0, 0, 0), gp_Dir(gp_XYZ(0, 0, 1))))) x_axis.SetColor(Quantity_Color(1, 0, 0, Quantity_TOC_RGB)) y_axis.SetColor(Quantity_Color(0, 1, 0, Quantity_TOC_RGB)) z_axis.SetColor(Quantity_Color(0, 0, 1, Quantity_TOC_RGB)) render.Context.Display(x_axis, True) render.Context.Display(y_axis, True) render.Context.Display(z_axis, True) render.View.Camera().SetDirection(gp_Dir( math.cos(pitch) * math.cos(yaw), math.cos(pitch) * math.sin(yaw), math.sin(pitch), )) render.View.Camera().SetUp(gp_Dir(0, 0, 1)) render.View.FitAll(0.07) render.DoIt()
surf = BRep_Tool.Surface(face) surf.Rotate(gp_Ax1(ax0.Location(), ax0.Direction()), np.deg2rad(15)) ax1 = gp_Ax3(gp_Pnt(150, 150, -20), gp_Dir(0.5, 0.1, 1.0), gp_Dir(0.0, 0.1, 1.0)) pnt = ax1.Location() api = GeomAPI_ProjectPointOnSurf(pnt, surf) print(api.NbPoints(), api.NearestPoint()) for i in range(api.NbPoints()): idx = i + 1 u, v = api.Parameters(idx) obj.display.DisplayShape(api.Point(idx)) print(idx, u, v) print(GeomAPI_IntCS(Geom_Line(ax1.Axis()), surf).NbPoints()) u, v, w = GeomAPI_IntCS(Geom_Line(ax1.Axis()), surf).Parameters(1) p, vx, vy = gp_Pnt(), gp_Vec(), gp_Vec() api = GeomLProp_SLProps(surf, u, v, 1, 0.1E-03) pnt = api.Value() dst = pnt.Distance(ax1.Location()) ax2 = obj.prop_axs(ax1, dst) rim_u = surf.UIso(u) rim_v = surf.VIso(v) print(v, rim_u.FirstParameter(), rim_u.LastParameter()) print(u, rim_v.FirstParameter(), rim_v.LastParameter()) obj.display.DisplayShape(rim_u, color="BLUE") obj.display.DisplayShape(rim_v, color="BLUE") print(api.GaussianCurvature()) print(api.MinCurvature(), api.MeanCurvature(), api.MaxCurvature()) print(dir_to_vec(api.Normal()))
def _line(pnt, dir) -> Curve: return Curve(Geom_Line(to_Pnt(pnt), to_Dir(dir)))