def create_shape(self):
d = self.declaration
if not d.source:
return
if os.path.exists(os.path.expanduser(d.source)):
svg = etree.parse(os.path.expanduser(d.source)).getroot()
else:
svg = etree.fromstring(d.source)
node = OccSvgDoc(element=svg)
builder = BRep_Builder()
shape = TopoDS_Compound()
builder.MakeCompound(shape)
shapes = node.create_shape()
for s in shapes:
builder.Add(shape, s)
bbox = self.get_bounding_box(shape)
cx, cy = bbox.dx / 2, bbox.dy / 2
# Move to position and align along direction axis
t = gp_Trsf()
axis = gp_Ax3()
axis.SetDirection(d.direction.proxy)
t.SetTransformation(axis)
pos = d.position-(cx, cy, 0)
t.SetTranslationPart(gp_Vec(*pos))
self.shape = BRepBuilderAPI_Transform(shape, t, False).Shape()
def get_transform(self):
d = self.declaration
result = gp_Trsf()
#: TODO: Order matters... how to configure it???
if d.operations:
for op in d.operations:
t = gp_Trsf()
if isinstance(op, Translate):
t.SetTranslation(gp_Vec(op.x, op.y, op.z))
elif isinstance(op, Rotate):
t.SetRotation(
gp_Ax1(gp_Pnt(*op.point), gp_Dir(*op.direction)),
op.angle)
elif isinstance(op, Mirror):
Ax = gp_Ax2 if op.plane else gp_Ax1
t.SetMirror(Ax(gp_Pnt(*op.point), gp_Dir(op.x, op.y,
op.z)))
elif isinstance(op, Scale):
t.SetScale(gp_Pnt(*op.point), op.s)
result.Multiply(t)
else:
axis = gp_Ax3()
axis.SetDirection(d.direction.proxy)
result.SetTransformation(axis)
result.SetTranslationPart(gp_Vec(*d.position))
if d.rotation:
t = gp_Trsf()
t.SetRotation(gp_Ax1(d.position.proxy, d.direction.proxy),
d.rotation)
result.Multiply(t)
return result
def points_from_intersection():
'''
@param display:
'''
plane = gp_Pln(gp_Ax3(gp_XOY()))
minor_radius, major_radius = 5., 8.
ellips = gp_Elips(gp_YOZ(), major_radius, minor_radius)
intersection = IntAna_IntConicQuad(ellips, plane, precision_Angular(),
precision_Confusion())
a_plane = GC_MakePlane(plane).Value()
a_surface = Geom_RectangularTrimmedSurface(a_plane, -8., 8., -12., 12.,
True, True)
display.DisplayShape(a_surface, update=True)
anEllips = GC_MakeEllipse(ellips).Value()
display.DisplayShape(anEllips)
if intersection.IsDone():
nb_results = intersection.NbPoints()
if nb_results > 0:
for i in range(1, nb_results + 1):
P = intersection.Point(i)
pstring = "P%i" % i
display.DisplayShape(P)
display.DisplayMessage(P, pstring)
def test_Perform(self):
"""
Test Font_BRepTextBuilder::Perform.
"""
# Get a font (os dependent)
font_names = TColStd_SequenceOfHAsciiString()
font_mgr = Font_FontMgr.GetInstance_()
font_mgr.GetAvailableFontsNames(font_names)
self.assertGreater(font_names.Size(), 0)
font_family = TCollection_AsciiString(font_names.First().ToCString())
font_style = Font_FontAspect.Font_FA_Regular
# Create the font
font = Font_BRepFont()
self.assertTrue(font.FindAndInit(font_family, font_style, 12.0))
# Create builder
builder = Font_BRepTextBuilder()
# Parameters
text = NCollection_String("pyOCCT".encode("utf-8"))
pos = gp_Ax3()
halign = Graphic3d_HTA_LEFT
valign = Graphic3d_VTA_BOTTOM
topods_shape = builder.Perform(font, text, pos, halign, valign)
self.assertFalse(topods_shape.IsNull())
def set_position(self, position, direction=None):
d = self.declaration
direction = direction or d.direction
clip_plane = self.clip_plane
pln = clip_plane.ToPlane()
pln.SetPosition(gp_Ax3(gp_Pnt(*position), gp_Dir(*direction)))
clip_plane.SetEquation(pln)
self.update_viewer()
def setUpClass(cls):
"""
Set up with a Geom_SphericalSurface.
"""
p = gp_Pnt()
v = gp_Dir()
a = gp_Ax3(p, v)
s = gp_Sphere(a, 1.0)
cls._surf = Geom_SphericalSurface(s)
def axis():
p1 = gp_Pnt(2., 3., 4.)
d = gp_Dir(4., 5., 6.)
a = gp_Ax3(p1, d)
a_IsDirect = a.Direct()
print("a is direct:", a_IsDirect)
# a_XDirection = a.XDirection()
# a_YDirection = a.YDirection()
p2 = gp_Pnt(5., 3., 4.)
a2 = gp_Ax3(p2, d)
a2.YReverse()
# axis3 is now left handed
a2_IsDirect = a2.Direct()
print("a2 is direct:", a2_IsDirect)
# a2_XDirection = a2.XDirection()
# a2_YDirection = a2.YDirection()
gui.add(p1)
gui.add(p2)
def axis():
p1 = gp_Pnt(2., 3., 4.)
d = gp_Dir(4., 5., 6.)
a = gp_Ax3(p1, d)
a_IsDirect = a.Direct()
print("a is direct:", a_IsDirect)
# a_XDirection = a.XDirection()
# a_YDirection = a.YDirection()
p2 = gp_Pnt(5., 3., 4.)
a2 = gp_Ax3(p2, d)
a2.YReverse()
# axis3 is now left handed
a2_IsDirect = a2.Direct()
print("a2 is direct:", a2_IsDirect)
# a2_XDirection = a2.XDirection()
# a2_YDirection = a2.YDirection()
display.DisplayShape(p1, update=True)
display.DisplayShape(p2, update=True)
display.DisplayMessage(p1, "P1")
display.DisplayMessage(p2, "P2")
def create_shape(self):
""" Create the shape by loading it from the given path. """
d = self.declaration
font = self.font
axis = gp_Ax3(coerce_axis(d.axis))
attr = 'Graphic3d_HTA_{}'.format(d.horizontal_alignment.upper())
halign = getattr(Graphic3d, attr)
attr = 'Graphic3d_VTA_{}'.format(d.vertical_alignment.upper())
valign = getattr(Graphic3d, attr)
text = NCollection.NCollection_String(d.text.encode("utf-8"))
self.shape = self.builder.Perform(self.font, text, axis, halign,
valign)
def draft_angle(event=None):
S = BRepPrimAPI_MakeBox(200., 300., 150.).Shape()
adraft = BRepOffsetAPI_DraftAngle(S)
topExp = TopExp_Explorer()
topExp.Init(S, TopAbs_FACE)
while topExp.More():
face = topods_Face(topExp.Current())
surf = Geom_Plane.DownCast(BRep_Tool_Surface(face))
dirf = surf.Pln().Axis().Direction()
ddd = gp_Dir(0, 0, 1)
if dirf.IsNormal(ddd, precision_Angular()):
adraft.Add(face, ddd, math.radians(15), gp_Pln(gp_Ax3(gp_XOY())))
topExp.Next()
adraft.Build()
display.DisplayShape(adraft.Shape(), update=True)
def round_tooth(wedge):
round_x = 2.6
round_z = 0.06 * pitch
round_radius = pitch
# Determine where the circle used for rounding has to start and stop
p2d_1 = gp_Pnt2d(top_radius - round_x, 0)
p2d_2 = gp_Pnt2d(top_radius, round_z)
# Construct the rounding circle
round_circle = GccAna_Circ2d2TanRad(p2d_1, p2d_2, round_radius, 0.01)
if (round_circle.NbSolutions() != 2):
sys.exit(-2)
round_circle_2d_1 = round_circle.ThisSolution(1)
round_circle_2d_2 = round_circle.ThisSolution(2)
if (round_circle_2d_1.Position().Location().Coord()[1] >= 0):
round_circle_2d = round_circle_2d_1
else:
round_circle_2d = round_circle_2d_2
# Remove the arc used for rounding
trimmed_circle = GCE2d_MakeArcOfCircle(round_circle_2d, p2d_1, p2d_2).Value()
# Calculate extra points used to construct lines
p1 = gp_Pnt(p2d_1.X(), 0, p2d_1.Y())
p2 = gp_Pnt(p2d_2.X(), 0, p2d_2.Y())
p3 = gp_Pnt(p2d_2.X() + 1, 0, p2d_2.Y())
p4 = gp_Pnt(p2d_2.X() + 1, 0, p2d_1.Y() - 1)
p5 = gp_Pnt(p2d_1.X(), 0, p2d_1.Y() - 1)
# Convert the arc and four extra lines into 3D edges
plane = gp_Pln(gp_Ax3(gp_Origin(), gp_DY().Reversed(), gp_DX()))
arc1 = BRepBuilderAPI_MakeEdge(geomapi_To3d(trimmed_circle, plane)).Edge()
lin1 = BRepBuilderAPI_MakeEdge(p2, p3).Edge()
lin2 = BRepBuilderAPI_MakeEdge(p3, p4).Edge()
lin3 = BRepBuilderAPI_MakeEdge(p4, p5).Edge()
lin4 = BRepBuilderAPI_MakeEdge(p5, p1).Edge()
# Make a wire composed of the edges
round_wire = BRepBuilderAPI_MakeWire(arc1)
round_wire.Add(lin1)
round_wire.Add(lin2)
round_wire.Add(lin3)
round_wire.Add(lin4)
# Turn the wire into a face
round_face = BRepBuilderAPI_MakeFace(round_wire.Wire()).Shape()
# Revolve the face around the Z axis over the tooth angle
rounding_cut_1 = BRepPrimAPI_MakeRevol(round_face, gp_OZ(), tooth_angle).Shape()
# Construct a mirrored copy of the first cutting shape
mirror = gp_Trsf()
mirror.SetMirror(gp_XOY())
mirrored_cut_1 = BRepBuilderAPI_Transform(rounding_cut_1, mirror, True).Shape()
# and translate it so that it ends up on the other side of the wedge
translate = gp_Trsf()
translate.SetTranslation(gp_Vec(0, 0, thickness))
rounding_cut_2 = BRepBuilderAPI_Transform(mirrored_cut_1, translate, False).Shape()
# Cut the wedge using the first and second cutting shape
cut_1 = BRepAlgoAPI_Cut(wedge, rounding_cut_1).Shape()
cut_2 = BRepAlgoAPI_Cut(cut_1, rounding_cut_2).Shape()
return cut_2
def get_transform(self):
d = self.declaration
t = gp_Trsf()
t.SetTransformation(gp_Ax3(coerce_axis(d.axis)))
return t
# 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)
def face():
p1 = gp_Pnt()
p2 = gp_Pnt()
p3 = gp_Pnt()
p4 = gp_Pnt()
p5 = gp_Pnt()
p6 = gp_Pnt()
# The white Face
sphere = gp_Sphere(gp_Ax3(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)), 150)
green_face = BRepBuilderAPI_MakeFace(sphere, 0.1, 0.7, 0.2, 0.9)
# The red face
p1.SetCoord(-15, 200, 10)
p2.SetCoord(5, 204, 0)
p3.SetCoord(15, 200, 0)
p4.SetCoord(-15, 20, 15)
p5.SetCoord(-5, 20, 0)
p6.SetCoord(15, 20, 35)
array = TColgp_Array2OfPnt(1, 3, 1, 2)
array.SetValue(1, 1, p1)
array.SetValue(2, 1, p2)
array.SetValue(3, 1, p3)
array.SetValue(1, 2, p4)
array.SetValue(2, 2, p5)
array.SetValue(3, 2, p6)
curve = GeomAPI_PointsToBSplineSurface(array, 3, 8, GeomAbs_C2,
0.001).Surface()
red_face = BRepBuilderAPI_MakeFace(curve, 1e-6)
#The brown face
circle = gp_Circ(gp_Ax2(gp_Pnt(0, 0, 0), gp_Dir(1, 0, 0)), 80)
Edge1 = BRepBuilderAPI_MakeEdge(circle, 0, math.pi)
Edge2 = BRepBuilderAPI_MakeEdge(gp_Pnt(0, 0, -80), gp_Pnt(0, -10, 40))
Edge3 = BRepBuilderAPI_MakeEdge(gp_Pnt(0, -10, 40), gp_Pnt(0, 0, 80))
##TopoDS_Wire YellowWire
MW1 = BRepBuilderAPI_MakeWire(Edge1.Edge(), Edge2.Edge(), Edge3.Edge())
if not MW1.IsDone():
raise AssertionError("MW1 is not done.")
yellow_wire = MW1.Wire()
brown_face = BRepBuilderAPI_MakeFace(yellow_wire)
#The pink face
p1.SetCoord(35, -200, 40)
p2.SetCoord(50, -204, 30)
p3.SetCoord(65, -200, 30)
p4.SetCoord(35, -20, 45)
p5.SetCoord(45, -20, 30)
p6.SetCoord(65, -20, 65)
array2 = TColgp_Array2OfPnt(1, 3, 1, 2)
array2.SetValue(1, 1, p1)
array2.SetValue(2, 1, p2)
array2.SetValue(3, 1, p3)
array2.SetValue(1, 2, p4)
array2.SetValue(2, 2, p5)
array2.SetValue(3, 2, p6)
BSplineSurf = GeomAPI_PointsToBSplineSurface(array2, 3, 8, GeomAbs_C2,
0.001)
aFace = BRepBuilderAPI_MakeFace(BSplineSurf.Surface(), 1e-6).Face()
##
##//2d lines
P12d = gp_Pnt2d(0.9, 0.1)
P22d = gp_Pnt2d(0.2, 0.7)
P32d = gp_Pnt2d(0.02, 0.1)
##
line1 = Geom2d_Line(P12d, gp_Dir2d((0.2 - 0.9), (0.7 - 0.1)))
line2 = Geom2d_Line(P22d, gp_Dir2d((0.02 - 0.2), (0.1 - 0.7)))
line3 = Geom2d_Line(P32d, gp_Dir2d((0.9 - 0.02), (0.1 - 0.1)))
##
##//Edges are on the BSpline surface
Edge1 = BRepBuilderAPI_MakeEdge(line1, BSplineSurf.Surface(), 0,
P12d.Distance(P22d)).Edge()
Edge2 = BRepBuilderAPI_MakeEdge(line2, BSplineSurf.Surface(), 0,
P22d.Distance(P32d)).Edge()
Edge3 = BRepBuilderAPI_MakeEdge(line3, BSplineSurf.Surface(), 0,
P32d.Distance(P12d)).Edge()
##
Wire1 = BRepBuilderAPI_MakeWire(Edge1, Edge2, Edge3).Wire()
Wire1.Reverse()
pink_face = BRepBuilderAPI_MakeFace(aFace, Wire1).Face()
breplib_BuildCurves3d(pink_face)
display.DisplayColoredShape(green_face.Face(), 'GREEN')
display.DisplayColoredShape(red_face.Face(), 'RED')
display.DisplayColoredShape(pink_face, Quantity_Color(Quantity_NOC_PINK))
display.DisplayColoredShape(brown_face.Face(), 'BLUE')
display.DisplayColoredShape(yellow_wire, 'YELLOW', update=True)
##the Free Software Foundation, either version 3 of the License, or
##(at your option) any later version.
##
##pythonOCC is distributed in the hope that it will be useful,
##but WITHOUT ANY WARRANTY; without even the implied warranty of
##MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
##GNU Lesser General Public License for more details.
##
##You should have received a copy of the GNU Lesser General Public License
##along with pythonOCC. If not, see <http://www.gnu.org/licenses/>.
from math import pi
from OCCT.gp import gp_Pnt2d, gp_XOY, gp_Lin2d, gp_Ax3, gp_Dir2d
from OCCT.BRepBuilderAPI import BRepBuilderAPI_MakeEdge
from OCCT.Geom import Geom_CylindricalSurface
from OCCT.GCE2d import GCE2d_MakeSegment
from OCC.Display.WebGl import threejs_renderer
# First buil an helix
aCylinder = Geom_CylindricalSurface(gp_Ax3(gp_XOY()), 6.0)
aLine2d = gp_Lin2d(gp_Pnt2d(0.0, 0.0), gp_Dir2d(1.0, 1.0))
aSegment = GCE2d_MakeSegment(aLine2d, 0.0, pi * 2.0)
helix_edge = BRepBuilderAPI_MakeEdge(aSegment.Value(), aCylinder, 0.0,
6.0 * pi).Edge()
display = threejs_renderer.ThreejsRenderer()
display.DisplayShape(helix_edge, color=(1, 0, 0), line_width=1.)
display.render()
