== Uporaba modula PythonOCCT == Projekt **PythonOCCT** je še ena priredba knjižnice OpenCASCADE 7.2.0 za programiranje v jeziku Python in je na voljo na strani https://github.com/LaughlinResearch/pyOCCT Od PythonOCC-ja se razlikuje v verziji OpenCASCADE in [https://pyocct.readthedocs.io/en/latest/dev.html v klicanju metod]. Primer kocke, ki je lahko poženemo v urejevalniku {{{pycharm}}} na strežiku viz.hpc.fs.uni-lj.si. {{{ #!python from OCCT.Visualization import BasicViewer from OCCT.BRepPrimAPI import BRepPrimAPI_MakeBox from OCCT.Graphic3d import Graphic3d_NOM_ALUMINIUM v = BasicViewer() v.set_white_background() shape = BRepPrimAPI_MakeBox(10, 20 ,30) v.display_shape(shape.Shape(), rgb=(0.8, 0.8, 0.5), material=Graphic3d_NOM_ALUMINIUM) v.start() }}} Statične funkcije se v **PythonOCC** uvozijo kar na modularnem nivoju: {{{#!python from OCC.TodoDS import topods_Edge }}} Med tem ko v PythonOCCT so statične funkcije znotraj razredov in imajo na koncu še podčrtaj {{{#!python from OCCT.TopoDS import TopoDS edge = TopoDS.Edge_(shape) }}} Prav tako se v PythonOCCT ne uporablja več metod **GetHandle**, **Downcast** in **GetObject**, ker se že v kodi PythonOCCT vse avtomatsko to naredi: V **PythonOCC** {{{#!python handle_geom = line.Copy() new_line = Handle_Geom_Line.Downcast(handle_geom).GetObject() }}} V **PythonOCCT** {{{#!python new_line = line.Copy() }}} To naredi stvari precej pitonične, saj lahko direktno ugotovimo tip geometrije z uporabo python metode **isinstance**: {{{#!python # S pomočjo PythonOCC-ja preverimo če je TopoDS_Shape Geom_Plane. hs = BRep_Tool_Surface(face) downcast_result = Geom_Plane.DownCast(hs) # Če je downcast_result tipa None, spremenljivka face ni Geom_Plane. if downcast_result is None: return False else: return True }}} {{{#!python # S pomočjo PythonOCCT-ja preverimo če je TopoDS_Shape Geom_Plane. hs = BRep_Tool_Surface(face) if isinstance(hs, Geom_Plane): return True else: return False }}} === Izdelava primera Bottle z uporabo programskega jezika Python in knjižnice OCCT === Naslednji primer prikazuje izdelavo primera BottleCAD. Podrobnejši razdelek posameznih delov programske kode dobimo na [[http://trac.lecad.si/vaje/wiki/OpenCascade|MakeBottleCAD(C++)]]. Za vizualizacijo se uporablja SALOME-8.5.0 [[Image(bottle.png, right)]] {{{ #!python ##Uredil in posodobil 2018 Gregor Simic (gregor.simic@lecad.fs.uni-lj.si) import math # from OCCT.gp import gp_Pnt, gp_OX, gp_Vec, gp_Trsf, gp_DZ, gp_Ax2, gp_Ax3, gp_Pnt2d, gp_Dir2d, gp_Ax2d from OCCT.gp import gp_Pnt, gp, gp_Vec, gp_Trsf, gp_Ax2, gp_Ax3, gp_Pnt2d, gp_Dir2d, gp_Ax2d # Classes gp_OX, gp_DZ are statical methods and in OCCT stored inside # OCCT.gp.gp as OX_ and DZ_ respectively. from OCCT.GC import GC_MakeArcOfCircle, GC_MakeSegment from OCCT.GCE2d import GCE2d_MakeSegment from OCCT.Geom import Geom_Plane, Geom_CylindricalSurface, Geom_Surface from OCCT.Geom2d import Geom2d_Ellipse, Geom2d_TrimmedCurve, Geom2d_Ellipse, Geom2d_Curve from OCCT.BRepBuilderAPI import BRepBuilderAPI_MakeEdge, BRepBuilderAPI_MakeWire, BRepBuilderAPI_MakeFace, \ BRepBuilderAPI_Transform from OCCT.BRepPrimAPI import BRepPrimAPI_MakePrism, BRepPrimAPI_MakeCylinder from OCCT.BRepFilletAPI import BRepFilletAPI_MakeFillet from OCCT.BRepAlgoAPI import BRepAlgoAPI_Fuse from OCCT.BRepOffsetAPI import BRepOffsetAPI_MakeThickSolid, BRepOffsetAPI_ThruSections # from OCC.Core.BRepLib import breplib # In OCCT the modules preserve the case. from OCCT.BRepLib import BRepLib # from OCC.Core.BRep import BRep_Tool_Surface, BRep_Builder from OCCT.BRep import BRep_Tool, BRep_Builder # OCCT does not have OCCT.Core but rather all modules are accessed directly # from OCCT. Again BRep_Tool_Surface from OCC is a static method to create # a Surface, hence in OCCT it is called from BRep_Tools as Surface_ from OCCT.TopoDS import TopoDS, TopoDS_Edge, TopoDS_Compound from OCCT.TopExp import TopExp_Explorer from OCCT.TopAbs import TopAbs_EDGE, TopAbs_FACE from OCCT.TopTools import TopTools_ListOfShape def face_is_plane(face): """ Returns True if the TopoDS_Shape is a Geom_Plane, False otherwise. """ hs = BRep_Tool.Surface_(face) # downcast_result = Geom_Plane.DownCast(hs) # OCCT 7.2.0 does not have the DownCast function anymore, in this case # we use we simply use the isinstance method to check if the shape # is a Geom_Plane. if isinstance(hs, Geom_Plane): return True else: # Othe cases when it returns false are, Geom_CylindricalSurface, # Geom_ToroidalSurface, Geom_SphericalSurface return False def geom_plane_from_face(aFace): """ Returns the geometric plane entity from a planar surface """ # return Geom_Plane.DownCast(BRep_Tool.Surface_(aFace)) return BRep_Tool.Surface_(aFace).Pln() height = 70 width = 50 thickness = 30 print("creating bottle") # The points we'll use to create the profile of the bottle's body aPnt1 = gp_Pnt(-width / 2.0, 0, 0) aPnt2 = gp_Pnt(-width / 2.0, -thickness / 4.0, 0) aPnt3 = gp_Pnt(0, -thickness / 2.0, 0) aPnt4 = gp_Pnt(width / 2.0, -thickness / 4.0, 0) aPnt5 = gp_Pnt(width / 2.0, 0, 0) aArcOfCircle = GC_MakeArcOfCircle(aPnt2, aPnt3, aPnt4) aSegment1 = GC_MakeSegment(aPnt1, aPnt2) aSegment2 = GC_MakeSegment(aPnt4, aPnt5) # Could also construct the line edges directly using the points instead of the resulting line aEdge1 = BRepBuilderAPI_MakeEdge(aSegment1.Value()) aEdge2 = BRepBuilderAPI_MakeEdge(aArcOfCircle.Value()) aEdge3 = BRepBuilderAPI_MakeEdge(aSegment2.Value()) # Create a wire out of the edges aWire = BRepBuilderAPI_MakeWire(aEdge1.Edge(), aEdge2.Edge(), aEdge3.Edge()) # Quick way to specify the X axis # xAxis = gp_OX() # From OCC xAxis = gp.OX_() # Set up the mirror aTrsf = gp_Trsf() aTrsf.SetMirror(xAxis) # Apply the mirror transformation aBRespTrsf = BRepBuilderAPI_Transform(aWire.Wire(), aTrsf) # Get the mirrored shape back out of the transformation and convert back to a wire aMirroredShape = aBRespTrsf.Shape() # A wire instead of a generic shape now # aMirroredWire = topods.Wire(aMirroredShape) # From OCC aMirroredWire = TopoDS.Wire_(aMirroredShape) # Combine the two constituent wires mkWire = BRepBuilderAPI_MakeWire() mkWire.Add(aWire.Wire()) mkWire.Add(aMirroredWire) myWireProfile = mkWire.Wire() # The face that we'll sweep to make the prism myFaceProfile = BRepBuilderAPI_MakeFace(myWireProfile) # We want to sweep the face along the Z axis to the height aPrismVec = gp_Vec(0, 0, height) myBody = BRepPrimAPI_MakePrism(myFaceProfile.Face(), aPrismVec) # Add fillets to all edges through the explorer mkFillet = BRepFilletAPI_MakeFillet(myBody.Shape()) anEdgeExplorer = TopExp_Explorer(myBody.Shape(), TopAbs_EDGE) while anEdgeExplorer.More(): anEdge = TopoDS.Edge_(anEdgeExplorer.Current()) mkFillet.Add(thickness / 12.0, anEdge) anEdgeExplorer.Next() myBody = mkFillet # Create the neck of the bottle neckLocation = gp_Pnt(0, 0, height) # neckAxis = gp_DZ() # From OCC neckAxis = gp.DZ_() neckAx2 = gp_Ax2(neckLocation, neckAxis) myNeckRadius = thickness / 4.0 myNeckHeight = height / 10.0 mkCylinder = BRepPrimAPI_MakeCylinder(neckAx2, myNeckRadius, myNeckHeight) myBody = BRepAlgoAPI_Fuse(myBody.Shape(), mkCylinder.Shape()) # Our goal is to find the highest Z face and remove it faceToRemove = None zMax = -1 # We have to work our way through all the faces to find the highest Z face so we can remove it for the shell aFaceExplorer = TopExp_Explorer(myBody.Shape(), TopAbs_FACE) while aFaceExplorer.More(): # aFace = topods.Face(aFaceExplorer.Current()) # From OCC aFace = TopoDS.Face_(aFaceExplorer.Current()) if face_is_plane(aFace): aPlane = geom_plane_from_face(aFace) # We want the highest Z face, so compare this to the previous faces aPnt = aPlane.Location() aZ = aPnt.Z() if aZ > zMax: zMax = aZ faceToRemove = aFace aFaceExplorer.Next() facesToRemove = TopTools_ListOfShape() facesToRemove.Append(faceToRemove) myBody = BRepOffsetAPI_MakeThickSolid(myBody.Shape(), facesToRemove, -thickness / 50.0, 0.001) # Set up our surfaces for the threading on the neck neckAx2_Ax3 = gp_Ax3(neckLocation, gp.DZ_()) aCyl1 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 0.99) aCyl2 = Geom_CylindricalSurface(neckAx2_Ax3, myNeckRadius * 1.05) # Set up the curves for the threads on the bottle's neck aPnt = gp_Pnt2d(2.0 * math.pi, myNeckHeight / 2.0) aDir = gp_Dir2d(2.0 * math.pi, myNeckHeight / 4.0) anAx2d = gp_Ax2d(aPnt, aDir) aMajor = 2.0 * math.pi aMinor = myNeckHeight / 10.0 anEllipse1 = Geom2d_Ellipse(anAx2d, aMajor, aMinor) anEllipse2 = Geom2d_Ellipse(anAx2d, aMajor, aMinor / 4.0) anArc1 = Geom2d_TrimmedCurve(anEllipse1, 0, math.pi) anArc2 = Geom2d_TrimmedCurve(anEllipse2, 0, math.pi) anEllipsePnt1 = anEllipse1.Value(0) anEllipsePnt2 = anEllipse1.Value(math.pi) aSegment = GCE2d_MakeSegment(anEllipsePnt1, anEllipsePnt2) # Build edges and wires for threading anEdge1OnSurf1 = BRepBuilderAPI_MakeEdge(anArc1, aCyl1) anEdge2OnSurf1 = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCyl1) anEdge1OnSurf2 = BRepBuilderAPI_MakeEdge(anArc2, aCyl2) anEdge2OnSurf2 = BRepBuilderAPI_MakeEdge(aSegment.Value(), 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()) # From OCC # breplib.BuildCurves3d(threadingWire2.Shape()) # From OCC 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 bottle = TopoDS_Compound() aBuilder = BRep_Builder() aBuilder.MakeCompound(bottle) aBuilder.Add(bottle, myBody.Shape()) aBuilder.Add(bottle, myThreading) print("bottle finished") # if __name__ == "__main__": # from OCC.Display.SimpleGui import init_display # display, start_display, add_menu, add_function_to_menu = init_display() # display.DisplayColoredShape(bottle, update=True) # start_display() # Display in GEOM from GEOM_OCCT import fromPythonOCCT fromPythonOCCT(bottle, 'bottle') }}}