def Geometry(self):
theta = 2*npy.pi/Z #theta=theta2 +theta3
R = O.Translation(vm.point2D((self.L8*npy.cos(alphaR),-self.L8*npy.sin(alphaR))))
K = R.Translation(vm.point2D((0,DF/2)))
H = K.Rotation(R,theta2)
M = K.Rotation(R,theta2+theta3)
a1 = vm.Arc2D(K,H,M)
J1 = R.Translation(vm.Point2D((0,DI/2)))
J=J1.Rotation(R,(theta2-theta1)/2)
#est ce un probleme de ne pas controler directement la pente du créneau ? (on ne se sert pas de alphaJ)
#sinon on pourrait remplacer les deux lignes précédentes par:J=K.Translation(vm.point2D((-self.L9*npy.sin(alphaJ),-self.L9*npy.cos(alphaJ))))
#Dans ce cas il faudrait peut être paramétrer H de la même façon
I=J.Rotation(R,theta1)
l1=primitives2D.RoundedLineSegments2D([K,J,I,H],{'''je ne sais pas trop quoi mettre ici'''})
L=[a1,l1]
for i in range(Z-1):
thetar=(i+1)*theta
L.append(a1.Rotation(R,thetar,True))
L.append(l1.Rotation(R,thetar,True))
c1=vm.Contour2D(L)
c1.MPLPlot()
def contour(self):
points = [
vm.Point2D((0, 0)),
vm.Point2D((0, 1)),
vm.Point2D((1, 1)),
vm.Point2D((1, 0))
]
crls = p2d.ClosedRoundedLineSegments2D(points=points, radius={})
return vm.Contour2D(crls.primitives)
def update(self, new_height, new_side):
return Component(self.center, new_side, self.vectors[0],
self.vectors[1], new_height, self.plane)
self.points = self.compo_points()
self.primitives = [
vm.LineSegment2D(self.points[0], self.points[1]),
vm.LineSegment2D(self.points[1], self.points[2]),
vm.LineSegment2D(self.points[2], self.points[3]),
vm.LineSegment2D(self.points[3], self.points[0])
]
self.contour = vm.Contour2D(self.primitives)
self.solid = self.compo_solid()
return
def __init__(self, center, compo_side, vector1, vector2, height, plane):
self.center = center
self.compo_side = compo_side
self.vectors = [vector1, vector2]
self.height = height
self.plane = plane
self.points = self.compo_points()
self.primitives = [
vm.LineSegment2D(self.points[0], self.points[1]),
vm.LineSegment2D(self.points[1], self.points[2]),
vm.LineSegment2D(self.points[2], self.points[3]),
vm.LineSegment2D(self.points[3], self.points[0])
]
self.contour = vm.Contour2D(self.primitives)
self.solid = self.compo_solid()
def babylon(self, xy_position, z_position):
primitives = []
## AFFICHAGE EN CYLINDRE ##
# pos = vm.Point3D((xy_position[0], xy_position[1], z_position))
# axis = vm.Vector3D((0,0,1))
# radius = self.diameter/2
# length = self.length
# cylinder = p3d.Cylinder(pos, axis, radius, length)
# primitives.append(cylinder)
## AFFICHAGE EN ROUE DENTEE ##
plane_origin = vm.Point3D(
(xy_position[0], xy_position[1], z_position - self.length / 2))
x = vm.x3D
y = vm.y3D
vector = vm.Vector3D((0, 0, self.length))
if self.n_teeth is None:
n_teeth = int(round(self.diameter * 100, 0))
else:
n_teeth = self.n_teeth
angle = 2 * math.pi / n_teeth
inner_diameter = 0.90 * self.diameter
teeth_l = (2 * math.pi * self.diameter / 2) / (1.5 * n_teeth)
pt1 = vm.Point2D(
(-teeth_l / 2, (inner_diameter**2 / 4 - teeth_l**2 / 4)**0.5))
pt5 = vm.Point2D(
(teeth_l / 2, (inner_diameter**2 / 4 - teeth_l**2 / 4)**0.5))
pt2 = vm.Point2D((pt1.vector[0] / 2, self.diameter / 2))
pt4 = vm.Point2D((pt5.vector[0] / 2, self.diameter / 2))
rls_points = [pt1, pt2, pt4, pt5]
for i in range(n_teeth - 1):
new_pt1 = rls_points[-4].Rotation(vm.o2D, -angle)
new_pt2 = rls_points[-3].Rotation(vm.o2D, -angle)
new_pt4 = rls_points[-2].Rotation(vm.o2D, -angle)
new_pt5 = rls_points[-1].Rotation(vm.o2D, -angle)
rls_points.extend([new_pt1, new_pt2, new_pt4, new_pt5])
rls_points.reverse()
rls = p2d.OpenedRoundedLineSegments2D(rls_points, {})
outer_contour2d = vm.Contour2D([rls])
extrusion = p3d.ExtrudedProfile(plane_origin, x, y, outer_contour2d,
[], vector)
primitives.append(extrusion)
return primitives
p5 = p4.Rotation(pc, theta2)
p6 = p1.Rotation(pc, theta)
l1 = primitives2D.RoundedLineSegments2D([p3, p4, p5, p6], {1: r3, 2: r3})
#l1=primitives2D.RoundedLines2D([p1,p2,p3,p4],{0:0.01,2:0.01})
#l2=vm.Circle2D(p5,0.01)
L = [a1, l1]
for i in range(Z - 1):
thetar = (i + 1) * theta
L.append(a1.Rotation(pc, thetar, True))
L.append(l1.Rotation(pc, thetar, True))
#p7=vm.Point2D((0,r4))
l2 = vm.Circle2D(pc, r4)
c1 = vm.Contour2D(L)
c2 = vm.Contour2D([l2])
po = vm.Point3D((0, 0, 0))
xp = vm.Vector3D((1, 0, 0))
yp = vm.Vector3D((0, 1, 0))
#c1.MPLPlot()
#extr_vect=vm.Vector3D((0,0,e))
profile_straight = primitives3D.ExtrudedProfile(po,
xp,
yp,
c1, [c2], (0, 0, e),
name='straight')
#
20) / 100 #Idem but with circle's normal
print('param1', phi1, theta1, offset_phi1, offset_theta1)
#You have to create a cutting pattern in 2D
pt1, pt2, pt3, pt4 = volmdlr.Point2D(
(offset_theta1, offset_phi1)), volmdlr.Point2D(
(offset_theta1, offset_phi1 + phi1)), volmdlr.Point2D(
(offset_theta1 + theta1, offset_phi1 + phi1)), volmdlr.Point2D(
(offset_theta1 + theta1, offset_phi1))
seg1, seg2, seg3, seg4 = volmdlr.LineSegment2D(
pt1, pt2), volmdlr.LineSegment2D(pt2, pt3), volmdlr.LineSegment2D(
pt3, pt4), volmdlr.LineSegment2D(pt4, pt1)
edges = [seg1, seg2, seg3, seg4]
contours2d = [volmdlr.Contour2D(edges)]
points = [theta1, phi1]
theta2 = random.randrange(angle_min, angle_max, 20) / 100 #Tore's length
phi2 = random.randrange(angle_min, angle_max, 20) / 100 #angle of circle
offset_theta2 = random.randrange(
angle_min, angle_max,
20) / 100 #Theta's offset if you want to turn it with normal's reference
offset_phi2 = random.randrange(angle_min, angle_max,
20) / 100 #Idem but with circle's normal
print('param2', phi2, theta2, offset_phi2, offset_theta2)
#You have to create a cutting pattern in 2D
pt1_2, pt2_2, pt3_2, pt4_2 = volmdlr.Point2D(
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri May 12 10:04:09 2017
@author: steven
"""
import volmdlr as vm
l = 0.1
p1 = vm.Point2D((0, 0))
p2 = vm.Point2D((l, 0))
p3 = vm.Point2D((l, l))
p4 = vm.Point2D((0, l))
l1 = vm.LineSegment2D(p1, p2)
l2 = vm.LineSegment2D(p2, p3)
l3 = vm.LineSegment2D(p3, p4)
l4 = vm.LineSegment2D(p4, p1)
p5 = vm.Point2D((l / 2, l / 2))
c1 = vm.Circle2D(p5, l / 5)
ct1 = vm.Contour2D([l4, l3, l2, l1])
ct2 = vm.Contour2D([c1])
mesh = vm.Mesh2D([ct1, ct2], {}, 0.01)
print(mesh.GeoScript('mesh2D.geo'))
import volmdlr as vm
import volmdlr.primitives3D as primitives3D
import volmdlr.primitives2D as primitives2D
#import math
p1=vm.Point2D((0, 0))
p2=vm.Point2D((0.1, 0.))
p3=vm.Point2D((0.1, 0.2))
p4=vm.Point2D((0, 0.1))
p5=vm.Point2D((-0.01, 0.05))
#p6=vm.Point2D((0.1,0.3))
l1=primitives2D.RoundedLineSegments2D([p1, p2, p3, p4], {2: 0.01}, False)
l2=vm.Arc2D(p4, p5, p1)
c1=vm.Contour2D([l1, l2])
c2=c1.Rotation(vm.Point2D((0,0)),npy.pi,True)
c1.MPLPlot()
c2.MPLPlot()
c3=vm.Contour2D([c1, c2])
c3.MPLPlot()
po = vm.Point3D((0, 0, 0))
xp = vm.Vector3D((1, 0, 0))
yp = vm.Vector3D((0, 1, 0))
profile = primitives3D.ExtrudedProfile(po, xp, yp, c1, [], vm.Vector3D((0, 0.1, 0.2)))
model = vm.VolumeModel([('', [profile])])
"""
import numpy as npy
import volmdlr as volmdlr
import volmdlr.primitives3D as primitives3D
import volmdlr.primitives2D as primitives2D
import matplotlib.pyplot as plt
import random
######## SWEEP TEST RANDOM
nb_point1, nb_point2 = 6, 5
radius_circle1, radius_circle2 = 0.008, 0.01
c1 = volmdlr.Circle2D(volmdlr.Point2D((0, 0)), radius_circle1)
contour1 = volmdlr.Contour2D([c1])
c2 = volmdlr.Circle2D(volmdlr.Point2D((0, 0)), radius_circle2)
contour2 = volmdlr.Contour2D([c2])
mini, maxi = -1, 1
pts1 = []
for k in range(nb_point1):
a1, a2, a3 = random.randint(mini, maxi), random.randint(
mini, maxi), random.randint(mini, maxi)
c1, c2, c3 = random.randrange(0, 100, 1), random.randrange(
0, 100, 1), random.randrange(0, 100, 1)
pts1.append(volmdlr.Point3D((a1 * c1 / 100, a2 * c2 / 100, a3 * c3 / 100)))
radius1 = {
1: 0.03,
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Tue Feb 12 19:23:27 2019 @author: steven """ import volmdlr as vm import math r = 0.23 p1 = vm.Point2D((0, 0)) p2 = vm.Point2D((r, r)) p3 = vm.Point2D((2 * r, 0)) a = vm.Arc2D(p1, p2, p3) l = vm.LineSegment2D(p3, p1) c = vm.Contour2D([a, l]) f, ax = c.MPLPlot() cog = c.CenterOfMass() cog.MPLPlot(ax) assert math.isclose(a.radius, r) assert math.isclose(c.Area(), math.pi * r**2 / 2.) assert math.isclose(cog[0], r) print(cog[1], 4 * r / 3. * math.pi) assert math.isclose(cog[1], 4 * r / 3. / math.pi)
#%%
p1 = vm.Point2D((0, 0))
p2 = vm.Point2D((0, 2))
p3 = vm.Point2D((2, 4))
p4 = vm.Point2D((4, 4))
p5 = vm.Point2D((4, 3))
p6 = vm.Point2D((3, 2))
p7 = vm.Point2D((3, 0))
l1 = p2d.OpenedRoundedLineSegments2D([p7, p1, p2], {})
l2 = vm.Arc2D(p2, vm.Point2D((math.sqrt(2) / 2, 3 + math.sqrt(2) / 2)), p3)
l3 = p2d.OpenedRoundedLineSegments2D([p3, p4, p5, p6], {}, adapt_radius=True)
l4 = vm.Arc2D(p6, vm.Point2D((4, 1)), p7)
#l4=vm.Arc2D(p7, vm.Point2D((4, 1)), p6)
c1 = vm.Contour2D([l1, l2, l3, l4])
p8 = vm.Point2D((1, 1))
p9 = vm.Point2D((2, 1))
p10 = vm.Point2D((2, 2))
p11 = vm.Point2D((1, 2))
#inner=vm.Circle2D(vm.Point2D((2,2)), 0.5)
inner = p2d.ClosedRoundedLineSegments2D([p8, p9, p10, p11], {})
c2 = vm.Contour2D([inner])
#ax = l1.MPLPlot()
#l2.MPLPlot(ax=ax)
#l3.MPLPlot(ax=ax)
#l4.MPLPlot(ax=ax)
profile = p3d.ExtrudedProfile(vm.o3D, vm.x3D, vm.y3D, c1, [c2],
p2 = vm.Point2D((0.3, 0))
p3 = vm.Point2D((0.33, 0.22))
p4 = vm.Point2D((0.2, 0.08))
p5 = vm.Point2D((0.16, 0.18))
p6 = vm.Point2D((0.05, 0.20))
inner_rl = primitives2D.RoundedLineSegments2D([p1, p2, p3, p4, p5, p6], {
0: 0.01,
1: 0.01,
2: 0.015,
3: 0.010,
4: 0.012,
5: 0.008
}, True)
outer_rl = inner_rl.Offset(-thickness)
inner_contour = vm.Contour2D([inner_rl])
outer_contour = vm.Contour2D([outer_rl])
f, a = inner_contour.MPLPlot()
outer_contour.MPLPlot(a)
sides = primitives3D.ExtrudedProfile(vm.o3D, vm.x3D, vm.y3D, outer_contour,
[inner_contour],
(height - 2 * thickness) * vm.z3D,
'sides')
bottom = primitives3D.ExtrudedProfile(vm.o3D, vm.x3D, vm.y3D, outer_contour,
[], -thickness * vm.z3D, 'bottom')
screw_holes_rl = inner_rl.Offset(-(thickness + screw_holes_clearance +
0.5 * screw_holes_diameter))
screw_holes = []
p0, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10, p11, p12, p13, p14, p15
]
c1 = primitives2D.ClosedRoundedLineSegments2D(points1, {
2: 0.005,
3: 0.005,
4: 0.005,
8: 0.005,
9: 0.005,
10: 0.005,
14: 0.005
})
circle0 = vm.Circle2D(vm.Point2D((0.12, 0.25)), 0.02)
circle1 = vm.Circle2D(vm.Point2D((0.19, 0.25)), 0.02)
circle2 = vm.Circle2D(vm.Point2D((0.15, 0.08)), 0.08)
c2 = vm.Contour2D([circle0])
c3 = vm.Contour2D([circle1])
c4 = vm.Contour2D([circle2])
e0 = vm.Point2D((0, 0.00))
e1 = vm.Point2D((0, 0.03))
e2 = vm.Point2D((0.11, 0.03))
e3 = vm.Point2D((0.11, 0.04))
e4 = vm.Point2D((0.13, 0.04))
e5 = vm.Point2D((0.13, 0))
points2 = [e0, e1, e2, e3, e4, e5]
c5 = primitives2D.ClosedRoundedLineSegments2D(points2, {})
profile = primitives3D.ExtrudedProfile(vm.O3D,
vm.Y3D,
name='sides_floor')
list_component_hat.append(sides_floor)
primitive_of_floor.append(sides_floor)
if with_borders:
r = 0.15
arc = vm.Arc2D(
vm.Point2D((0, 0)),
vm.Point2D(
((-1 + math.sqrt(2) / 2) * r, r * math.sqrt(2) / 2)),
vm.Point2D((-r, r)))
contour_sweep = outer_contour_floor.Offset(r)
contour = vm.Contour2D([arc])
wire_sweep = vm.Wire3D([
p.To3D(
origin +
extrusion_vector * list_height_polyfloor[enum + 1], x, y)
for p in contour_sweep.primitives
])
sweep = primitives3D.Sweep(contour,
wire_sweep,
alpha=alpha,
name='congé')
list_component_hat.append(sweep)
list_contour_floor.append(contour_sweep)
else:
r = 0
"""
Created on Tue May 12 17:14:06 2020
@author: masfaraud
"""
import numpy as npy
import volmdlr as volmdlr
import volmdlr.primitives3D as primitives3D
import volmdlr.primitives2D as primitives2D
import matplotlib.pyplot as plt
import random
radius_circle = 0.008
c = volmdlr.Circle2D(volmdlr.Point2D((0, 0)), radius_circle)
contour = volmdlr.Contour2D([c])
pt0 = volmdlr.Point3D((0.01, 0.04, 0.16))
pt1 = volmdlr.Point3D((0.03, 0, 0.2))
pt2 = volmdlr.Point3D((0.45, 0.01, 0.1))
pt3 = volmdlr.Point3D((0.45, 0, -0.1))
pt4 = volmdlr.Point3D((0.3, 0.04, -0.02))
pts = [pt0, pt1, pt2, pt3, pt4]
radius = {1: 0.03, 2: 0.01, 3: 0.07}
rl = primitives3D.OpenedRoundedLineSegments3D(pts,
radius,
adapt_radius=True,
name='wire')
sweep = primitives3D.Sweep(contour, rl, name='pipe')
pt10 = volmdlr.Point3D((0.02, 0.22, 0.25))
pt11 = volmdlr.Point3D((0.02, 0.24, 0.25))
circles = []
delta_angle = 2*math.pi/number_holes
inner_circle = volmdlr.Circle2D(volmdlr.O2D, 0.04)
first_circle = volmdlr.Circle2D(volmdlr.Point2D((0, 0.05)), 0.005)
circles = [inner_circle, first_circle]
for i in range(1, number_holes):
circles.append(first_circle.Rotation(volmdlr.O2D, i*delta_angle))
xn, yn, zn = random.randrange(posmin, posmax, 1)/100, random.randrange(posmin, posmax, 1)/100, random.randrange(posmin, posmax, 1)/100
xc, yc, zc = random.randrange(posmin, posmax, 1)/100, random.randrange(posmin, posmax, 1)/100, random.randrange(posmin, posmax, 1)/100
n = volmdlr.Vector3D([xn,yn,zn])
n.Normalize()
c = volmdlr.Point3D((xc,yc,zc))
#Plane to place your PlaneFace3D
plane = volmdlr.Plane3D.from_normal(c, n)
#To do a PlaneFace3D, you need to use contours2D
#The first is always the basis, the others are used to cut the basis
contours = [volmdlr.Contour2D([outer_circle]), volmdlr.Contour2D([circles[0]]),
volmdlr.Contour2D([circles[1]]), volmdlr.Contour2D([circles[2]]),
volmdlr.Contour2D([circles[3]]),volmdlr.Contour2D([circles[4]]),
volmdlr.Contour2D([circles[5]])]
planeface = volmdlr.PlaneFace3D(contours, plane)
shell = volmdlr.Shell3D([planeface])
m = volmdlr.VolumeModel([shell])
m.babylonjs()
pi1 = vm.Point2D((-B / 2, d / 2))
pi2 = vm.Point2D((-B / 2, d1 / 2))
pi3 = vm.Point2D((-0.5 * D_balls * math.sin(theta_b), d1 / 2))
pi4 = vm.Point2D((0, y_ball0 - D_balls / 2))
pi5 = vm.Point2D((0.5 * D_balls * math.sin(theta_b), d1 / 2))
pi6 = vm.Point2D((B / 2, d1 / 2))
pi7 = vm.Point2D((B / 2, d / 2))
li1 = vm.Line2D(pi1, pi2)
li2 = vm.Line2D(pi2, pi3)
ci3 = vm.Arc2D(pi3, pi4, pi5)
li4 = vm.Line2D(pi5, pi6)
li5 = vm.Line2D(pi6, pi7)
li6 = vm.Line2D(pi7, pi1)
ci = vm.Contour2D([li1, li2, ci3, li4, li5, li6])
inner = primitives3D.RevolvedProfile(center, x, y, [ci], center, x,
math.pi * 2, 'innerring')
primitives.append(inner)
# outter
po1 = vm.Point2D((-B / 2, D / 2))
po2 = vm.Point2D((-B / 2, D1 / 2))
po3 = vm.Point2D((-0.5 * D_balls * math.sin(theta_b), D1 / 2))
po4 = vm.Point2D((0, y_ball0 + D_balls / 2))
po5 = vm.Point2D((0.5 * D_balls * math.sin(theta_b), D1 / 2))
po6 = vm.Point2D((B / 2, D1 / 2))
po7 = vm.Point2D((B / 2, D / 2))
lo1 = vm.Line2D(po1, po2)
lo2 = vm.Line2D(po2, po3)
h1 = random.randrange(hmin, hmax, 5) / 100
center2d = c1.To2D(c1, plane1.vectors[0], plane1.vectors[1])
#Classic Contour
segbh = volmdlr.LineSegment2D(center2d, center2d + volmdlr.Point2D(
(0, h1))) #### Minus Pt2D because of Step adaptation
circlestart = volmdlr.LineSegment2D(
segbh.points[1], segbh.points[1] + volmdlr.Point2D(
(2 * math.pi * 3 / 4, 0))) #You can change 2*pi by an other angle
seghb = volmdlr.LineSegment2D(circlestart.points[1],
circlestart.points[1] - segbh.points[1])
circlend = volmdlr.LineSegment2D(seghb.points[1], segbh.points[0])
edges = [segbh, circlestart, seghb, circlend]
points = edges[0].points
contours = [volmdlr.Contour2D(edges)]
cyl1 = volmdlr.CylindricalFace3D(contours, cylsurface1, points)
pts1, tangle1 = cyl1.triangulation(resolution=12)
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
[pt.MPLPlot(ax=ax) for pt in pts1]
# number_holes = 5
# outer_circle = volmdlr.Circle2D(volmdlr.O2D, 0.06)
# circles = []
# delta_angle = 2*math.pi/number_holes
cylsurface1 = volmdlr.CylindricalSurface3D(frame1, r1) cylsurface2 = volmdlr.CylindricalSurface3D(frame2, r2) hmin, hmax = 0, 100 h1, h2 = random.randrange(hmin, hmax, 5)/100, random.randrange(hmin, hmax, 5)/100 #Height of cylinder # center2d = c1.To2D(c1, plane1.vectors[0], plane1.vectors[1]) center2d = volmdlr.Point2D((0,0)) segbh = volmdlr.LineSegment2D(center2d, center2d + volmdlr.Point2D((0,h1))) #### Minus Pt2D because of Step adaptation circlestart = volmdlr.LineSegment2D(segbh.points[1], segbh.points[1]+volmdlr.Point2D((2*math.pi*3/4,0))) #You can change 2*pi by an other angle seghb = volmdlr.LineSegment2D(circlestart.points[1],circlestart.points[1]-segbh.points[1]) circlend = volmdlr.LineSegment2D(seghb.points[1],segbh.points[0]) edges = [segbh, circlestart, seghb, circlend] points = edges[0].points contours = [volmdlr.Contour2D(edges)] # center2d2 = c2.To2D(c2, plane2.vectors[0], plane2.vectors[1]) center2d2 = volmdlr.Point2D((0,0)) segbh2 = volmdlr.LineSegment2D(center2d2, center2d2 + volmdlr.Point2D((0,h2))) #### Minus Pt2D because of Step adaptation circlestart2 = volmdlr.LineSegment2D(segbh2.points[1], segbh2.points[1]+volmdlr.Point2D((2*math.pi,0))) #You can change 2*pi by an other angle seghb2 = volmdlr.LineSegment2D(circlestart2.points[1],circlestart2.points[1]-segbh2.points[1]) circlend2 = volmdlr.LineSegment2D(seghb2.points[1],segbh2.points[0]) edges2 = [segbh2, circlestart2, seghb2, circlend2] points2 = edges2[0].points contours2 = [volmdlr.Contour2D(edges2)] cyl1 = volmdlr.CylindricalFace3D(contours, cylsurface1, points) cyl2 = volmdlr.CylindricalFace3D(contours2, cylsurface2, points2)
center = vm.Point3D([0, 0, 0]) #Choose the coordinate of the center
normal1 = vm.Vector3D([0, 0, 1]) #Choose the normal of the generative
normal1.Normalize() #Normalize the normal if it is not the case
vec1 = normal1.deterministic_unit_normal_vector()
frame = vm.Frame3D(center, vec1, normal1.Cross(vec1),
normal1) #Frame in the center of the generative arc3D
toroidalsurface3d = vm.ToroidalSurface3D(frame, r1, r2)
theta = 4 * math.pi / 3 #Tore's length
phi = 2 * math.pi #angle of circle
offset_theta = math.pi / 4 #Theta's offset if you want to turn it with normal's reference
offset_phi = math.pi #Idem but with circle's normal
#You have to create a cutting pattern in 2D
pt1, pt2, pt3, pt4 = vm.Point2D((offset_theta, offset_phi)), vm.Point2D(
(offset_theta, offset_phi + phi)), vm.Point2D(
(offset_theta + theta, offset_phi + phi)), vm.Point2D(
(offset_theta + theta, offset_phi))
seg1, seg2, seg3, seg4 = vm.LineSegment2D(pt1, pt2), vm.LineSegment2D(
pt2, pt3), vm.LineSegment2D(pt3, pt4), vm.LineSegment2D(pt4, pt1)
edges = [seg1, seg2, seg3, seg4]
contours2d = [vm.Contour2D(edges)]
points = [theta, phi]
toroidalface = vm.ToroidalFace3D(contours2d, toroidalsurface3d, points)
shell = vm.Shell3D([toroidalface])
m = vm.VolumeModel([shell])
m.babylonjs(debug=True)
Created on Wed Mar 14 15:32:37 2018 @author: Steven Masfaraud [email protected] """ import volmdlr as vm import volmdlr.primitives2D as primitives2D import numpy as npy #for i in range(20): triangle_points = [vm.Point2D(npy.random.random(2)) for i in range(3)] triangle = vm.Polygon2D(triangle_points) cog_triangle = triangle.CenterOfMass() c1 = vm.CompositePrimitive2D([triangle, cog_triangle]) c1.MPLPlot() print(triangle.Area()) p0 = vm.Point2D((-1, 0)) p1 = vm.Point2D((-npy.cos(npy.pi / 4), npy.sin(npy.pi / 4))) p2 = vm.Point2D((0, 1)) a = vm.Arc2D(p2, p1, p0) l = vm.LineSegment2D(p2, a.center) list_node = a.Discretise() c = vm.Contour2D([a, l] + list_node) print(c.plot_data()) c2 = vm.CompositePrimitive2D([c]) c2.MPLPlot(style='ob') print(c.Area())
p6 = vm.Point2D((0.05, 0.05))
p7 = vm.Point2D((0.06, 0.05))
p8 = vm.Point2D((0.04, 0.07))
radius = {0: 0.01, 2: 0.01, 3: 0.015}
outer_profile = primitives2D.RoundedLineSegments2D([p1, p2, p3, p4, p5],
radius,
closed=True)
#hole = vm.Circle2D(p6, 0.01)
#inner_profile = primitives2D.RoundedLineSegments2D([p6, p7, p8], {0: }, closed = True)
l1 = vm.LineSegment2D(p6, p7)
l2 = vm.LineSegment2D(p7, p8)
l3 = vm.LineSegment2D(p8, p6)
c2 = vm.Contour2D([l1, l2, l3])
c1 = vm.Contour2D([outer_profile])
#c2 = vm.Contour2D([inner_profile])
po = vm.Point3D((0, 0, 0))
xp = vm.Vector3D((1, 0, 0))
yp = vm.Vector3D((0, 1, 0))
f, a = c1.MPLPlot()
c2.MPLPlot(a)
profile = primitives3D.ExtrudedProfile(po,
xp,
yp,
c1, [c2],
vm.Vector3D((0, 0, 0.2)),
