def viz(self,position):
"""
Generates a OpenScad model to visualize the sun position
"""
## Generating the hemisphere ##
starting_sphere = solid.sphere(self.r, segments= 64)
box_sub = solid.utils.down(((self.r * 2 + 10)/2))(solid.cube((self.r * 2 + 10), center= True))
hemisphere = starting_sphere - box_sub
hemisphere = PolyMesh(generator= hemisphere).simplified()
#hemisphere = (solid.utils.color([0.75,0.75,0.75,0.1]))(hemisphere.get_generator()) #this sucks...need to do this way in order do render
#hemisphere = PolyMesh(generator= hemisphere)
## Generate the sphere for the sun ##
sun_sphere = solid.sphere(5, segments= 64)
vector = position
sun_sphere = (solid.translate(vector))(sun_sphere)
sun_sphere = PolyMesh(generator= sun_sphere).simplified()
L1 = Layer(hemisphere, name= "hem", color=[200,200,200,1000])
L2 = Layer(sun_sphere, name="sun", color='yellow')
B1 = Block([L1, L2])
return B1.show(is_2d= False)
def handle_bar(points):
return sp.union()([
sp.hull()(
sp.translate(points[i])(sp.sphere(d=hand_grip_diameter,
segments=32)),
sp.translate(points[i + 1])(sp.sphere(d=hand_grip_diameter,
segments=32)),
) for i in range(len(points) - 1)
])
def ell_main():
return S.translate([0, 0, pot_w])(
S.difference()(
S.scale([1, pot_lw_ratio, 1])(S.sphere(pot_w)),
# cut out inside
S.scale([s2, pot_lw_ratio * s2, s2])(S.sphere(pot_w)),
S.translate([-rectl / 2, -rectl / 2,
-pot_w + 50])(S.cube([rectl, rectl, rectl])),
))
def sarms(): hand = solid.sphere(r=4) arm = solid.translate([0,0,4])( solid.cylinder(r=4, h = 68)) shoulder = solid.translate([0,0,72])( solid.sphere(r=4)) a1 = hand+arm+shoulder a2 = solid.translate([50,0,70])(a1) a1 = solid.translate([-40,0,70])(a1) a1 = solid.rotate([0,10,0])(a1) a2 = solid.rotate([0,-10,0])(a2) return a1+a2
def __init__(self, cone, offset, radius):
super(DerivativeNoseCone,
self).__init__(length=cone.length,
thickness=cone.thickness,
outer_diameter=cone.outer_diameter,
inner_diameter=cone.inner_diameter)
offset = to_mm(offset)
radius = to_mm(radius)
self.cone = cone.cone - up(offset + radius)(sphere(r=radius))
if self.thickness:
thickness = to_mm(self.thickness)
self.cone = self.cone + hull()(cone.cone) * up(offset + radius)(
sphere(r=radius + thickness) - sphere(r=radius))
def rounded_cube(x, y, z, r, segments=32, center=True):
out = s.minkowski()(
s.cube([x - 2 * r, y - 2 * r, z - 2 * r], center=center),
s.sphere(r=r, segments=segments),
)
return out
def create_ommatidum(outer_sphere_radius,
inner_sphere_radius, ommatidum_radius):
"""Create an hexagonal based pyramid."""
# Outer shell
outer_shell = [tuple(np.round(sph2cart(ommatidum_radius, az, 0), 2))
for az in np.arange(0, 359, 60)]
outer_points = [[0, 0, 0]] + [[outer_sphere_radius, x, y]
for x, y, _ in outer_shell]
# Inner shell
inner_shell = [tuple(np.round(
sph2cart(ommatidum_radius - thickness, az, 0), 2))
for az in np.arange(0, 359, 60)]
inner_points = [[0, 0, 0]] + [[outer_sphere_radius, x, y]
for x, y, _ in inner_shell]
# Define Faces
faces = [
[0, 1, 2],
[0, 2, 3],
[0, 3, 4],
[0, 4, 5],
[0, 5, 6],
[0, 6, 1],
[1, 2, 3, 4, 5, 6]]
# Create ommatidum
ommatidum = solid.difference()(
solid.hull()(solid.polyhedron(outer_points, faces)),
solid.hull()(solid.polyhedron(inner_points, faces)),
solid.sphere(inner_sphere_radius)
)
return ommatidum
def spaceship_earth():
""" Creates a model of EPCOT's spaceship earth """
(vs, es, fs) = geo.sphere(v=8)
fms = geo.face_matrices(fs, vs)
fts = geo.face_triangles_2d(fs, vs, fms)
def shape_at_face(m, ft):
center = np.array([0, 0])
panel1 = np.vstack((ft[0], ft[1], center))
panel2 = np.vstack((ft[1], ft[2], center))
panel3 = np.vstack((ft[2], ft[0], center))
panel_angle = 20
def panel_shape(panel_tri):
edge_midpoint = 0.5 * (panel_tri[0] + panel_tri[1])
rotation_vector = panel_tri[1] - panel_tri[0]
transform = lambda x: solid.translate(
edge_midpoint)(solid.rotate(a=panel_angle, v=rotation_vector)
(solid.translate(-edge_midpoint)(x)))
return transform(
solid.linear_extrude(0.01)(solid.polygon(panel_tri * 0.9)))
return solid.multmatrix(m)(
solid.union()(*[panel_shape(p) for p in (panel1, panel2, panel3)]))
inner_radius = np.mean(np.linalg.norm(np.array(fms)[:, 0:3, 3], axis=1))
return solid.union()(solid.sphere(r=inner_radius, segments=FN * 4),
*[shape_at_face(m, ft) for m, ft in zip(fms, fts)])
def createElementModule(name, sp):
elModSrc = "module " + sp.name + "(pos=[0,0,0]){" + useOpenScadVariable(
sld.translate("%%%positionExprPlaceholder%%%")(sld.color(
convertWebColorToOpenScad(sp.cpk_color))(sld.sphere(
r * sp.covalent_radius / maxRad))),
{"%%%positionExprPlaceholder%%%": "pos*lFact"}) + "\n}"
return elModSrc
def make_lamp_scad(filename, bright_stars, stick_figures, radius, thickness):
"""Use bright stars and input arguements to create the scad lamp."""
# Create a main shell to be inscribed on
shell = solid.difference()(solid.sphere(r=radius),
solid.sphere(r=radius - thickness / 2),
sutil.down(radius)(solid.cube(2 * radius,
center=True)))
# Add stick figures
i_shell = make_stick_figures(shell, stick_figures, radius, 0.5)
# i_shell = shell
# Add another layer of shell (without inscription)
c_shell = solid.difference()(solid.sphere(r=radius - thickness / 2),
solid.sphere(r=radius - thickness),
sutil.down(radius)(solid.cube(2 * radius,
center=True)))
# Add stars to both the i_shell and c_shell
i_stars = solid.difference()
i_stars.add(i_shell)
for _, az, alt, _, rad in bright_stars:
i_stars.add(
solid.rotate(a=[0, -1 * (90 - alt), az])(solid.cylinder(rad,
h=radius)))
c_stars = solid.difference()
c_stars.add(c_shell)
for _, az, alt, _, rad in bright_stars:
c_stars.add(
solid.rotate(a=[0, -1 * (90 - alt), az])(solid.cylinder(rad,
h=radius)))
complete = solid.union()(i_stars, c_stars)
# Render to file
solid.scad_render_to_file(i_stars,
filename + '-inscription' + '.scad',
file_header='$fn = %s;' % SEGMENTS)
solid.scad_render_to_file(c_stars,
filename + '-stars' + '.scad',
file_header='$fn = %s;' % SEGMENTS)
solid.scad_render_to_file(complete,
filename + '-complete' + '.scad',
file_header='$fn = %s;' % SEGMENTS)
def minkowski_rounded_cube(size, corner_radius, segments=None, center=False):
if isinstance(size, (int, float)):
size = XYZ(
size - 2 * corner_radius,
size - 2 * corner_radius,
size - 2 * corner_radius,
)
else:
size = XYZ(*size) - 2 * corner_radius
return translate((corner_radius, corner_radius,
corner_radius))(minkowski()(cube(size),
sphere(corner_radius,
segments=segments)))
def golfball():
""" Creates a golfball by putting dimples at vertices """
(vs, es, fs) = geo.sphere(v=5)
vms = geo.vertex_matrices(vs)
def shape_at_vertex(m):
return solid.multmatrix(m)(solid.utils.up(0.09)(solid.sphere(r=0.12)))
shape = solid.difference()(
solid.sphere(r=1, segments=FN * 4),
solid.union()(*[shape_at_vertex(m) for m in vms]))
return shape
def __init__(self, retainer_diameter, height, depth, threads_per_inch, cap_diameter, hole_diameter, cap_thickness,**kwargs):
r_r = to_mm(retainer_diameter/2.)
height = to_mm(height)
h_r = to_mm(hole_diameter/2.)
c_r = to_mm(cap_diameter/2.)
c_t = to_mm(cap_thickness)
threads_per_inch = threads_per_inch
o_d = kwargs.get('outer_diameter')
i_d = kwargs.get('inner_diameter')
if 'bodytube' in kwargs:
o_d = kwargs['bodytube'].outer_diameter
i_d = kwargs['bodytube'].inner_diameter
print i_d
i_r = to_mm(i_d/2.)
o_r = to_mm(o_d/2.)
print retainer_diameter
flange_d = to_mm(kwargs.get('flange_diameter'), safe=True)
flange_t = to_mm(kwargs.get('flange_thickness'), safe=True)
spine_diameter = to_mm(kwargs.get('spine_diameter'), safe=True)
round_radius = to_mm(kwargs.get('round_radius',0))
if flange_d and flange_t:
flange = cylinder(h=flange_t, r=flange_d/2.)
else:
flange = cylinder(h=height, r=o_r/2.) # HACK because this will be removed
self.retainer = difference() (self.threaded_male_column(height, to_mm(retainer_diameter), threads_per_inch) + flange,
cylinder(h=height, r=o_r),
up(height-depth), cylinder(h=depth, r=i_r))
self.cap = difference()(cylinder(h=height,r=c_r),
self.threaded_female_column(height-c_t, to_mm(retainer_diameter), threads_per_inch),
cylinder(h=height, r=h_r))
if spine_diameter:
no_spines = kwargs.get('spines',0)
spines = []
for idx in xrange(0, no_spines):
spines.append(rotate([0,0,360/no_spines*idx])(right(c_r)(cylinder(h=height-c_t-spine_diameter/2, r=spine_diameter/2)+
up(height-c_t-spine_diameter/2)(sphere(r=spine_diameter/2.)))))
self.cap+=union()(*spines)
self.round = rotate_extrude()(right(c_r-round_radius)(square([round_radius,round_radius])*circle(round_radius)))
self.cap -= up(height-round_radius)(rotate_extrude()(right(c_r-round_radius)(square([round_radius,round_radius]))))
self.cap += up(height-round_radius)(self.round)
def genAsOpenscad(self): """Generates zebrafish geometry as solid python object. Useful if geometry is used to be passed to openscad. Returns: solid.solidpython.openscad_object: Solid python object. """ outerBall=solid.translate([self.center[0],self.center[1],-self.outerRadius])(solid.sphere(r=self.outerRadius)) innerBall=solid.translate([self.center[0],self.center[1],-self.outerRadius-self.centerDist])(solid.sphere(r=self.innerRadius)) return outerBall-innerBall
def __init__(self, typ, r, center=None, h=None):
self.rot = ()
self.R = float(r)
self.H = h
self.type = typ
if not center:
self.center = np.zeros(3)
else:
self.center = center
if typ == 0:
self.geometry = sld.sphere(r=self.R)
self.geometry = sld.color(gen_colr())(self.geometry)
elif typ == 1:
self.geometry = sld.cube(size=self.R, center=True)
self.geometry = sld.color(gen_colr())(self.geometry)
elif typ == 2:
self.geometry = sld.cylinder(r=self.R, h=self.H, center=True)
self.geometry = sld.color(gen_colr())(self.geometry)
else:
raise ValueError
def __post_init__(self):
"""
create the dish
calculates
chord_length: y offest
"""
if self.top_dims is None:
self.top_dims = [12.16, 14.16]
self.key_x, self.key_y = self.top_dims
if self.dish_type == "cylinder":
c_length = chord_length(self.key_x, self.depth)
radius = rad_chord(self.key_x, self.depth)
self.dish = s.cylinder(h=100,
r=radius,
center=True,
segments=self.segments)
if self.inverted:
self.dish = s.translate([0, -c_length, 0])(self.dish)
else:
self.dish = s.translate([0, c_length, 0])(self.dish)
self.dish = s.rotate([90, 0, 0])(self.dish)
elif self.dish_type == "sphere":
self.chord = pow((pow(self.key_x, 2) + pow(self.key_y, 2)), .5)
c_length = chord_length(self.chord, self.depth)
self.radius = rad_chord(self.chord, self.depth)
self.dish = s.scale([
self.chord / 2 / self.depth, self.chord / 2 / self.depth
])(s.sphere(r=self.depth, segments=self.segments))
self.dish = s.translate([0, 0, self.key_z])(self.dish)
''' heights 0-1, base 1-4, lighting 5-6 floor/pane 7-top, chamber ''' out_file = make_output() orange = t55_to_1([255,127,0]) battery = solid.color([1,0,0])(solid.cylinder(r=1,h=3)) battery += solid.color([0,0,0])(solid.translate([0,0,3])(solid.cylinder(r=1,h=3))) battery = solid.translate([11,2,2])(solid.rotate([0,90,0])(battery)) led = solid.cylinder(r=1,h=1, segments = 20) led += solid.translate([0,0,1])(solid.sphere(r=1, segments= 20)) wire = solid.cube([.2,.2,1]) led += solid.translate([-.1,.8,-1])(wire)+ solid.translate([-.1,-1,-1])(wire) led = solid.color(orange)(led) led2 = solid.translate([5,3,1.5])(led) led = solid.translate([9,3,1.5])(led) vessel = solid.cube([20,7,15])- solid.translate([1,1,1])(solid.cube([18,5,15])) vessel -= solid.translate([1,-1,6])(solid.cube([18,3,10])) vessel -= solid.translate([.5,.25,5.5])(solid.cube([19,.5,10])) vessel -= solid.translate([1,1,1])(solid.cube([20,5,3])) vessel -= solid.translate([.5,.5, 5.25])(solid.cube([20,6,.5])) vessel = solid.color([0,.5,9])(vessel) pane1 = solid.translate([.5,.25,5.5])(solid.cube([19,.5,9.5])) pane2 = solid.translate([.5,.5, 5.25])(solid.cube([19.5,6,.5]))
def connector_sphere_hole(diameter: float = DEFAULT_SPHERE_HOLE_DIAMETER, ):
return sphere(r=diameter / 2, segments=16)
Dmax = Dbase + rim theta = np.arctan((H) / ((Dmax - Dmin) / 2)) * 180 / np.pi Dinsert = 133.7 Hinsert = 43.2 Dhollow = 68.2 Hhollow = 150 Dsmoke = 1.5 * 25.4 Hsmoke = 5 * 25.4 upper_plane = solid.cube(BIG, center=True) upper_plane = solid.translate([0, 0, BIG / 2])(upper_plane) ball_min = solid.sphere(d=Dmin, segments=resolution) ball_min = solid.translate([0, 0, H])(ball_min) ball_max = solid.sphere(d=Dmax, segments=resolution) nosecone = solid.hull()(ball_min, ball_max) # nosecone = solid.intersection()(upper_plane, nosecone) taper = solid.cylinder(d1=Dbase, d2=BIG + Dbase, h=BIG, segments=resolution) nosecone = solid.intersection()(taper, nosecone) minifin_top = solid.cube([17, 2.5, 10 + 3.6], center=True) minifin_bot = solid.cube([17 + 7.2, 2, 10], center=True) minifin = solid.hull()(minifin_top, minifin_bot) minifin = solid.rotate([0, 90 - theta, 0])(minifin) minifin = solid.translate([-60, 0, 24])(minifin) nosecone += minifin nose_groove = solid.translate([22, 0, 0])(solid.circle(2)) nose_groove = solid.rotate_extrude()(nose_groove) nose_groove = solid.translate([0, 0, H - 22])(nose_groove)
def shape_at_vertex(m):
return solid.multmatrix(m)(solid.utils.up(0.09)(solid.sphere(r=0.12)))
def screw_insert_shape(bottom_radius, top_radius, height):
shape = sl.union()(
sl.cylinder(r1=bottom_radius, r2=top_radius, h=height, center=True),
sl.translate([0, 0, (height / 2)])(sl.sphere(top_radius)),
)
return shape
def shape_at_vertex(m):
return solid.multmatrix(m)(solid.sphere(r=0.05))
def grow(thickness, target):
radius = thickness / 2
return minkowski()(target, sphere(r=radius, segments=24))
def test_body(self) -> None:
self.assertTrue(
utils.compare_openscad_objects(
sphere.Sphere(diameter=15.0).body, solid.sphere(d=15.0)),
msg="Should produce the expected OpenSCAD object",
)
def shape_at_vertex(m, ve):
shape = solid.sphere(r=0.05)
if len(ve) == highlight_valence:
shape = solid.color("red")(shape)
return solid.multmatrix(m)(shape)
import solid cube = solid.cube(10) kugle = solid.sphere(10) cyl = solid.cylinder(r=10, h=5) sum = cube + cyl solid.scad_render_to_file(sum,'../ZZ3DModels/min3D.scad')
#!/usr/bin/env python3
import json
import solid
import numpy as np
def eisenstein(x,y):
a = x-y/2
b = y*np.sqrt(3)/2
return a,b
r = .35
knot = json.load(open('conwayKnot.json'))
# print(knot)
# print(dir(solid))
ball = solid.sphere(r, segments=6)
ball = solid.rotate([0, 0, 30])(ball)
points = [[*eisenstein(*point[:2]), point[2]] for point in knot['path']]
# print(points)
balls = [solid.translate(p)(ball) for p in points]
bars = [solid.hull()(a,b) for a,b in zip(balls, balls[1:])]
result = solid.union()(*bars)
result = solid.scale(10)(result)
print(solid.scad_render(result))
def draw_knob():
sphere = solid.sphere(r=1, segments=1000)
knob = sphere - utils.forward(3)(solid.cube(6))
return knob
R_carve = 3 * 25.4
R_carve = 140.7 / 2
shift = .6 * 25.4
upper_plane = solid.cube(BIG, center=True)
upper_plane = solid.translate([0, 0, BIG / 2])(upper_plane)
block = solid.cylinder(d1=Dmax, d2=Dmin, h=H - trans, segments=resolution)
block = solid.translate([0, 0, trans])(block)
block += solid.cylinder(d=Dmax, h=trans, segments=resolution)
lower = solid.cylinder(d=ID, h=id_insert + epsilon, segments=resolution)
lower = solid.translate([0, 0, -id_insert])(lower)
block += lower
block = solid.sphere(d=Dmax, segments=resolution)
block = solid.scale([1, 1, 2])(block)
block = solid.intersection()(block, upper_plane)
carve = solid.cylinder(r=R_carve, h=3 * H, center=True, segments=resolution)
carve = solid.hull()(
carve,
solid.translate([BIG * np.cos(theta), BIG * np.sin(theta), 0])(carve),
solid.translate([BIG * np.cos(theta), -BIG * np.sin(theta), 0])(carve),
)
carve = solid.translate([R_carve + shift, 0, 0])(carve)
carve = solid.union()(
carve,
solid.rotate([0, 0, 120])(carve),
solid.rotate([0, 0, 240])(carve),
)
def rounded_triangle_prism(a, b, c, thickness, corner_radius, segments=32):
return minkowski()(triangle_prism(a, b, c, thickness - 2 * corner_radius),
sphere(corner_radius, segments=segments))
''' import solid import math inf = 1000 upper_half_space = solid.cube(2 * inf, center=True) upper_half_space = solid.translate([0, 0, inf])(upper_half_space) outer_d = 155 outer_w = 2.5 core_d = 29.5 core_w = 14 base = solid.sphere(d=1) base = solid.scale([3 * core_d, outer_d, core_d])(base) base = solid.intersection()(base, upper_half_space) disc_cut = solid.cylinder(d=outer_d, h=outer_w, center=True) disc_cut = solid.rotate([0, 90, 0])(disc_cut) disc_cut = solid.translate([0, 0, outer_d / 2])(disc_cut) drain_hole = solid.cylinder(d=3 * outer_w, h=outer_d, center=True) horiz = core_w * 1.1 vert = outer_d * .125 lift = 2 xy_shift = [(0, -vert), (-horiz, vert), (horiz, vert)] for x, y in xy_shift:
