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 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 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 test_Standard_Type(self) -> None: """ test that Standard_Type returns the correct type name """ edge = BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, 0), gp_Pnt(1, 0, 0)).Edge() curve, _, _ = BRep_Tool_Curve(edge) line = Geom_Line.DownCast(curve) self.assertEqual(line.DynamicType().Name(), "Geom_Line")
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 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 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 test_downcast_curve(self) -> None: """Test if a GeomCurve can be DownCasted to a GeomLine""" edge = BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, 0), gp_Pnt(1, 0, 0)).Edge() curve, _, _ = BRep_Tool_Curve(edge) self.assertTrue(isinstance(curve, Geom_Curve)) # The edge is internally a line, so we should be able to downcast it line = Geom_Line.DownCast(curve) self.assertTrue(isinstance(line, Geom_Curve)) # Hence, it should not be possible to downcast it as a B-Spline curve bspline = Geom_BSplineCurve.DownCast(curve) self.assertTrue(bspline is None)
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_b2(self, num=1): h_surf = BRep_Tool.Surface(self.b2) ray = Geom_Line(self.beam.Axis()) self.RayTrace.Perform(ray.GetHandle(), 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 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', '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 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 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 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(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 _line(pnt, dir) -> Curve: return Curve(Geom_Line(to_Pnt(pnt), to_Dir(dir)))
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
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()
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
class Sketch(object): 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 SetContext(self, theContext: AIS_InteractiveContext): self.myContext = theContext self.myAnalyserSnap.SetContext(self.myContext) self.myGUI.SetContext(theContext) for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetContext(self.myContext) def SetData(self, thedata: list): self.myData = thedata for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetData(self.myData) def SetRootNode(self, theNode): self.myNode = theNode for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetRootNode(self.myNode) def SetModel(self, theModel): self.myModel = theModel for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetModel(self.myModel) def GetData(self): return self.myData def SetCoordinateSystem(self, theCS: gp_Ax3): self.myCoordinateSystem = theCS self.myCurrentPlane.SetPosition(self.myCoordinateSystem) self.myAnalyserSnap.SetAx3(self.myCoordinateSystem) self.myGUI.SetAx3(self.myCoordinateSystem) for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetAx3(self.myCoordinateSystem) def GetCoordinateSystem(self): return self.myCoordinateSystem def SetPrecise(self, aPrecise: float): if aPrecise > 0: self.myAnalyserSnap.SetMinDistance(aPrecise) def SetColor(self, theColor: Quantity_Color): for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetColor(theColor) def SetType(self, theType: Sketch_ObjectType): for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetType(theType) def SetStyle(self, theLineStyle: Prs3d_LineAspect): for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] self.CurCommand.SetStyle(theLineStyle) def ObjectAction(self, theMethod: Sketch_ObjectTypeOfMethod): self.myCurrentMethod = theMethod self.SelectCurCommand() self.CurCommand.Action() if (self.myCurrentMethod == Sketch_ObjectTypeOfMethod.Line2P_Method or self.myCurrentMethod == Sketch_ObjectTypeOfMethod.ArcCenter2P_Method ) and self.PolylineFirstPointExist: self.CurCommand.SetPolylineFirstPnt(self.PolylineFirstPoint) else: self.PolylineFirstPointExist = False def GetStatus(self): return self.myCurrentMethod def ProjectPointOnPlane(self, v3dX, v3dY, v3dZ, projVx, projVy, projVz): self.myTempPnt.SetCoord(v3dX, v3dY, v3dZ) self.myCurrentDir.SetCoord(projVx, projVy, projVz) self.myCurrentLine.SetDirection(self.myCurrentDir) self.myCurrentLine.SetLocation(self.myTempPnt) # pnt=self.myCurrentPlane.Pln().Location () # print(pnt.X(),pnt.Y(),pnt.Z()) self.myIntCS.Perform( self.myCurrentLine, self.myCurrentPlane) # perfrom intersection calculation if self.myIntCS.NbPoints() >= 1: self.myTempPnt = self.myIntCS.Point(1) self.myCurrentPnt2d.SetX( (self.myTempPnt.X() - self.myCoordinateSystem.Location().X()) * self.myCoordinateSystem.XDirection().X() + (self.myTempPnt.Y() - self.myCoordinateSystem.Location().Y()) * self.myCoordinateSystem.XDirection().Y() + (self.myTempPnt.Z() - self.myCoordinateSystem.Location().Z()) * self.myCoordinateSystem.XDirection().Z()) self.myCurrentPnt2d.SetY( (self.myTempPnt.X() - self.myCoordinateSystem.Location().X()) * self.myCoordinateSystem.YDirection().X() + (self.myTempPnt.Y() - self.myCoordinateSystem.Location().Y()) * self.myCoordinateSystem.YDirection().Y() + (self.myTempPnt.Z() - self.myCoordinateSystem.Location().Z()) * self.myCoordinateSystem.YDirection().Z()) return True else: return False def OnMouseInputEvent(self, *kargs): theX, theY, buttons, modifier = kargs aView: V3d_View = self.myView v3dX, v3dY, v3dZ, projVx, projVy, projVz = aView.ConvertWithProj( theX, theY) if self.SnapToGridPoint: # grid echo v3dX, v3dY, v3dZ = self.myView.ConvertToGrid(theX, theY) self.myDisplay.Viewer.ShowGridEcho( self.myView, Graphic3d_Vertex(v3dX, v3dY, v3dZ)) self.myDisplay.Viewer.SetGridEcho(True) if self.ProjectPointOnPlane(v3dX, v3dY, v3dZ, projVx, projVy, projVz): self.SelectCurCommand() if self.CurCommand.MouseInputEvent(self.myCurrentPnt2d, buttons, modifier): self.myCurrentMethod = Sketch_ObjectTypeOfMethod.Nothing_Method def OnMouseMoveEvent(self, *kargs): theX, theY, buttons, modifier = kargs aView: V3d_View = self.myView v3dX, v3dY, v3dZ, projVx, projVy, projVz = aView.ConvertWithProj( theX, theY) if self.SnapToGridPoint: # grid echo v3dX, v3dY, v3dZ = self.myView.ConvertToGrid(theX, theY) self.myDisplay.Viewer.ShowGridEcho( self.myView, Graphic3d_Vertex(v3dX, v3dY, v3dZ)) self.myDisplay.Viewer.SetGridEcho(True) if self.ProjectPointOnPlane(v3dX, v3dY, v3dZ, projVx, projVy, projVz): self.SelectCurCommand() self.CurCommand.MouseMoveEvent(self.myCurrentPnt2d, buttons, modifier) def OnMouseReleaseEvent(self, *kargs): buttons, modifier = kargs self.SelectCurCommand() self.CurCommand.MouseReleaseEvent(buttons, modifier) def GetCurPoint2D(self): return self.myCurrentPnt2d def GetCurPoint3D(self): return elclib.To3d(self.myCoordinateSystem.Ax2(), self.myCurrentPnt2d) def SetPickTolerance(self, thePrecision): # selector selector_manager = self.myContext.MainSelector() # self._display.Context.SetPixelTolerance(5) selector_manager.SetPixelTolerance(thePrecision) print(selector_manager.PixelTolerance()) def OnCancel(self): self.SelectCurCommand() self.myAnalyserSnap.Cancel() if (self.myCurrentMethod == Sketch_ObjectTypeOfMethod.Line2P_Method and self.myCurrentMethod == Sketch_ObjectTypeOfMethod.ArcCenter2P_Method): self.PolylineFirstPointExist = self.CurCommand.GetPolylineFirstPnt( self.PolylineFirstPoint) self.CurCommand.CancelEvent() self.myCurrentMethod = Sketch_ObjectTypeOfMethod.Nothing_Method # Acitivate selection automaticlly # self.myContext.SetAutoActivateSelection(True) # self.SetPickTolerance(20) # self.myContext.ActivatedModes() # # for all the sketch object selectable # self.myContext.Deactivate() self.myContext.Activate(0) def DeleteSelectedObject(self): index = 0 while index < self.myNode.childCount(): child = self.myNode.child(index) assert isinstance(child, SketchObjectNode) myCurObject: Sketch_Geometry = child.getSketchObject() if self.myContext.IsSelected(myCurObject.GetAIS_Object()): myCurObject.RemoveDisplay() self.myNode.removeChild(index) else: index += 1 def ViewProperties(self): # for idx in range(len(self.myData)): # myCurObject: Sketch_Object = self.myData[idx] # if self.myContext.IsSelected(myCurObject.GetAIS_Object()): # self.myContext.ClearSelected(True) # self.myGUI.SetSketch_Object(myCurObject) # break for child in self.myNode.children(): assert isinstance(child, SketchObjectNode) myCurObject: Sketch_Geometry = child.getSketchObject() if self.myContext.IsSelected(myCurObject.GetAIS_Object()): self.myContext.ClearSelected(True) self.myGUI.SetSketch_Object(myCurObject) break def RedrawAll(self): for idx in range(len(self.myData)): myCurObject: Sketch_Object = self.myData[idx] if self.myContext.IsSelected(myCurObject.GetAIS_Object()): self.myContext.Display(myCurObject.GetAIS_Object(), True) def SetPolylineMode(self, amode): for idx in range(len(self.myCommands)): self.CurCommand = self.myCommands[idx] self.CurCommand.SetPolylineMode(amode) def SetSnap(self, theSnap): self.myAnalyserSnap.SetSnapType(theSnap) def GetSnap(self): return self.myAnalyserSnap.GetSnapType() def addCommand(self, theCommand: Sketch_Command): theCommand.SetData(self.myData) theCommand.SetContext(self.myContext) theCommand.SetRootNode(self.myNode) theCommand.SetAnalyserSnap(self.myAnalyserSnap) theCommand.SetAx3(self.myCoordinateSystem) self.myCommands.append(theCommand) def SelectCurCommand(self): for idx in range(len(self.myCommands)): self.CurCommand: Sketch_Command = self.myCommands[idx] if self.CurCommand.GetTypeOfMethod() == self.myCurrentMethod: # Acitivate selection automaticlly # This is a bug!! Remove the following line will lead to critical error when enable sketch command. self.myContext.SetAutoActivateSelection(False) break
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 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()