def hilbert_3D_test():
l = 1
d = 0.2 * l
r = d
regions = []
with brlcad_tcl("hilbert_3d_test.g", "Hilbert-pipe 3D",
stl_quality=0.5) as brl_db:
for o1 in (-1, 1):
for o2 in (-1, 1):
for crt_dir in NEGATE:
points_generator = generate_points(2,
direction=crt_dir,
order=(o1, o2),
x_vec=(l, 0, 0),
y_vec=(0, l, 0),
z_vec=(0, 0, l))
segments = [(x, d, 0, r) for x in points_generator]
shape_name = "hilbert_pipe_{}{}{}{}{}.s".format(
o1, o2, *crt_dir)
region_name = "hilbert_pipe_{}{}{}{}{}.r".format(
o1, o2, *crt_dir)
brl_db.pipe(shape_name, points=segments)
brl_db.region(region_name, 'u {}'.format(shape_name))
regions.append(region_name)
# process the tcl script into a g database by calling mged
brl_db.save_g()
# process the g database into an STL file with a list of regions
brl_db.save_stl(regions)
def hilbert_pipe(file_name,
size=10,
recursions=4,
dc=0.2,
direction=ZP,
variant=0,
x_vec=(1, 0, 0),
y_vec=(0, 1, 0),
z_vec=(0, 0, 1)):
l = float(size) / (2**recursions)
d = dc * l
r = d
points = [(x, d, 0, r) for x in generate_points(recursions,
direction=direction,
variant=variant,
x_vec=Vector(x_vec) * l,
y_vec=Vector(y_vec) * l,
z_vec=Vector(z_vec) * l)]
with brlcad_tcl(file_name, "Hilbert-pipe 3D", stl_quality=0.5) as brl_db:
pipe_name = "hilbert_3d.s"
brl_db.pipe(pipe_name, points)
region_name = "hilbert_3d.r"
brl_db.region(region_name, 'u {}'.format(pipe_name))
# process the tcl script into a g database by calling mged
brl_db.save_g()
# process the g database into an STL file with a list of regions
brl_db.save_stl([region_name])
def main(argv): with brlcad_tcl(argv[1], "My Database") as brl_db: new_cone_example = cone_example(brl_db) # All units in the database file are stored in millimeters. This constrains # the arguments to the mk_* routines to also be in millimeters. # process the tcl script into a g database by calling mged brl_db.save_g() # process the g database into an STL file with a list of regions brl_db.save_stl(['new_cone_example'])
def main(argv):
#with wdb.WDB(argv[1], "My Database") as brl_db:
with brlcad_tcl(argv[1], "My Database") as brl_db:
shed = shed_example(brl_db)
# All units in the database file are stored in millimeters. This constrains
# the arguments to the mk_* routines to also be in millimeters.
# process the tcl script into a g database by calling mged
brl_db.save_g()
# process the g database into an STL file with a list of regions
#brl_db.save_stl(['room', 'mainroof', 'roof_window1', 'roof_window2'])
brl_db.save_stl(['shed'])
def spiral_channel(width,
height,
inner_radius,
outer_radius,
degree_interval=0.1,
radius_interval=0.5):
x = None
y = None
t = 0
ang = 0
method = 'use_square'
# default keypoint is bottom corner, the box base center is at x: 0, y: 0
xkey = 0
ykey = 0
with brlcad_tcl("spiral.tcl", "Spiral", stl_quality=0.5) as brl_db:
segments = []
while inner_radius < outer_radius:
x = inner_radius * math.cos(t)
y = inner_radius * math.sin(t)
inner_radius += radius_interval
ang = 90.0 - math.atan2(y, x) * 180.0 / math.pi
shape_name = "spiral_segment_{}_{}.s".format(ang, inner_radius)
#shape_name = "spiral_segment_{}_{}.s".format(t, inner_radius)
if method == 'use_cylinder':
brl_db.rcc(shape_name, (x, y, 0), (0, 0, height), width / 2.0)
else:
brl_db.rpp(shape_name, (x - width / 2.0, y - width / 2.0, 0),
(x + width / 2.0, y + width / 2.0, height))
#brl_db.rotate_primitive(shape_name, 0,0, 1, t%360.0)
brl_db.rotate_primitive(shape_name, 0, 0, ang)
#ang+=45
#brl_db.rotate_primitive(shape_name, 1,1, 0, degree_interval)
t += degree_interval
segments.append(shape_name)
brl_db.region('spiral.r', 'u ' + ' u '.join(segments))
#region_name = "hilbert_pipe_{}{}{}{}{}.r".format(o1, o2, *crt_dir)
#brl_db.region(region_name, 'u {}'.format(shape_name))
# process the tcl script into a g database by calling mged
brl_db.save_g()
# process the g database into an STL file with a list of regions
brl_db.save_stl(['spiral.r'])
'flow_out',
*get_box_face_center_coord(c3, c4, xyz_desired=[1, 0, 0]))
self.final_name = self.get_next_name(self, "COMPLETE.r")
# finally create a region (a special combination that means it's going to be rendered)
# by unioning together the main combinations we just created
brl_db.region(
self.final_name,
'u {} u {} u {} u {}'.format(self.f1, self.f2, self.f3,
self.flowtube))
print('pump done')
if __name__ == "__main__":
g_path_out = check_cmdline_args(__file__)
with brlcad_tcl(g_path_out, "My Database") as brl_db:
pump = peristaltic_3_finger_pump(brl_db)
# tack on some pipes to the pneumatic and hydraluic connections
# scale the 'away vector' dimension by 5000 to get some length
# the 'away vector' will contain ONLY a single non-zero item
# so the multiplication has no effect on non-set directions
# (at least for cube faces, in the current implementation)
a = pump.get_connection('flow_control_a_coord')
brl_db.circular_cylinder('ap.s',
a[1], [_c * 5000 for _c in a[2]],
radius=750)
b = pump.get_connection('flow_control_b_coord')
brl_db.circular_cylinder('bp.s',
b[1], [_c * 5000 for _c in b[2]],
def main(argv):
with brlcad_tcl(argv[1], "My Database") as brl_db:
new_grip_example = grip_example(brl_db)
brl_db.save_g()
brl_db.save_stl(['new_grip_example'])
"""
A small python-brlcad-tcl example that creates a spring with the pipe primitive
It creates a tcl file, then sends it to mged which creates and populates a .g file database,
then the .g file is converted with g-stl to produce an STL file.
Run with:
python spring.py spring.tcl
"""
from python_brlcad_tcl.brlcad_tcl import *
if __name__ == "__main__":
g_path_out = check_cmdline_args(__file__)
with brlcad_tcl(g_path_out, "My Database1", stl_quality=0.5) as brl_db:
# create a lookup table for 4 X,Y points on the spring circumference
spring_outline_x_y_tuples = [(-50, -50), (-50, 50), (50, 50),
(50, -50)]
# create points, using the 10 for the z-step between points on the circumference.
# the number of circumference points (4) times the z-step (10) yields 40, which is used to mod the z-value
# this gets a series of 0,1,2,3 repeating, which is used as an index to the circumference X,Y values list
# these tuples then get unpacked into the two x and y values using the * notation
z_step = 10
points = []
for z in range(0, 110, 10):
circumference_xy_index = (
z % (len(spring_outline_x_y_tuples) * z_step)) / z_step
x, y = spring_outline_x_y_tuples[circumference_xy_index]
point = brl_db.pipe_point(x=x,
y=y,
z=z,
def createPencilSharpener():
#Create the two cylinders for the bottom layer
#Also we're working in Inches
brl = brlcad_tcl(tcl_filepath=outFileTCL,
title="Pencil Sharpener Gear",
make_g=False,
make_stl=True,
stl_quality=stlQuality,
units='in')
#Create our cylinders, regions, names, etc...
bottom = 'b'
bottomNegative = 'bn'
bottomRing = 'br'
bottomFinal = 'bf'
middle = 'm'
middleNegative = 'mn'
middleRing = 'mr'
middleWithGuide = 'mh'
middleFinal = 'mf'
middleTop = 'mt'
middleTopNegative = 'mtn'
middleTopRing = 'mtr'
top = 't'
topNegative = 'tn'
topRing = 'tr'
topFinal = 'tf'
shavingsHole = 'sh'
leftGuide = 'l'
rightGuide = 'r'
gearName = 'gf'
toothName = 'tooth'
allFinal = 'finished'
#Variables for their sizes and positions, in inches
bottomOuterRadius = 0.650
bottomInnerRadius = 0.460
bottomHeight = 0.262
bottomPosition = (0, 0, 0)
middleOuterRadius = 0.502
middleInnerRadius = 0.4575
middleHeight = 0.275
middlePosition = (0, 0, bottomHeight
) #Placed right on top of the bottom one
topOuterRadius = 0.49 / 2 #Measured diameter with Callipers
topInnerRadius = 0.3937 / 2 #Measured diameter with Callipers
topHeight = 0.383
topPosition = (0, 0, bottomHeight + middleHeight)
middleTopOuterRadius = middleOuterRadius #This acts as the top for the middle, since it is too thin
middleTopInnerRadius = topInnerRadius #This is the hole that goes through the top, so the bushel can go through
middleTopHeight = -middleHeight * 0.25 #Negative because we're going from the top downward
middleTopPosition = (0, 0, bottomHeight + middleHeight)
leftGuideOuterRadius = 0.0625 #GET BETTER MEASUREMENT?!?
rightGuideOuterRadius = leftGuideOuterRadius
leftGuideHeight = topHeight / 2 #ALSO GET BETTER
rightGuideHeight = leftGuideHeight
leftGuideYOffset = -leftGuideOuterRadius / 2 #Apparently they are offset a little.
leftGuidePosition = (middleOuterRadius - leftGuideOuterRadius,
leftGuideYOffset, bottomHeight + middleHeight)
rightGuidePosition = (-leftGuidePosition[0], leftGuidePosition[1],
leftGuidePosition[2]) #Put it on the other side
#Now we need the box that'll make our pencil shavings hole
holeWidthFull = 0.75
holeWidth = holeWidthFull / 2
holeHeightFull = middleHeight
holeHeight = holeHeightFull / 2
holeDepthFull = middleOuterRadius
holeCenterHeight = bottomHeight + (middleHeight / 2)
#Create the 8 points that make the box
holePoints = (
(-holeWidth, 0, holeCenterHeight - holeHeight),
(holeWidth, 0, holeCenterHeight - holeHeight),
(holeWidth, 0, holeCenterHeight + holeHeight),
(-holeWidth, 0, holeCenterHeight + holeHeight),
(-holeWidth, holeDepthFull, holeCenterHeight - holeHeight),
(holeWidth, holeDepthFull, holeCenterHeight - holeHeight),
(holeWidth, holeDepthFull, holeCenterHeight + holeHeight),
(-holeWidth, holeDepthFull, holeCenterHeight + holeHeight),
)
#Get the lines for the gears
toothHalfWidth = 0.27
toothDepth = bottomInnerRadius + (
(bottomOuterRadius - bottomInnerRadius) / 2)
toothHeight = bottomHeight * 0.75 #3/4 of the height
#Now we start building all of our shapes
#Start with bottom...
brl.rcc(bottom, bottomPosition, (0, 0, bottomHeight), bottomOuterRadius)
brl.rcc(bottomNegative, bottomPosition, (0, 0, bottomHeight),
bottomInnerRadius)
#Now subtract inner from outer
brl.region(bottomRing, subtract(bottom, bottomNegative))
#Now make the middle and cut it into a ring
brl.rcc(middle, middlePosition, (0, 0, middleHeight), middleOuterRadius)
brl.rcc(middleNegative, middlePosition, (0, 0, middleHeight),
middleInnerRadius)
brl.region(middleRing, subtract(middle, middleNegative))
#Now turn the top into a ring
brl.rcc(top, topPosition, (0, 0, topHeight), topOuterRadius)
brl.rcc(topNegative, topPosition, (0, 0, topHeight), topInnerRadius)
brl.region(topRing, subtract(top, topNegative))
#Now going from top down, we'll turn the top into a top-hat
brl.rcc(middleTop, middleTopPosition, (0, 0, middleTopHeight),
middleTopOuterRadius)
brl.rcc(middleTopNegative, middleTopPosition, (0, 0, middleTopHeight),
middleTopInnerRadius)
brl.region(middleTopRing, subtract(middleTop, middleTopNegative))
#And now add it to the top
brl.region(topFinal, union(topRing, middleTopRing))
#Next we will add the guides to the middle...
brl.rcc(leftGuide, leftGuidePosition, (0, 0, leftGuideHeight),
leftGuideOuterRadius)
brl.rcc(rightGuide, rightGuidePosition, (0, 0, rightGuideHeight),
rightGuideOuterRadius)
#Now add them
brl.region(middleWithGuide, union(middleRing, leftGuide, rightGuide))
#And now cut the hole for pencil shavings
brl.arb8(shavingsHole, holePoints)
brl.region(middleFinal, subtract(middleWithGuide, shavingsHole))
#Finally, we'll cut the gears out of the bottom...
#Get all the content for the gears
gearLines, gearName = toothGen.createGears(gearName=gearName,
toFile=False,
toothHalfWidth=toothHalfWidth,
toothDepth=toothDepth,
toothHeight=toothHeight,
toothBaseName=toothName)
#Now add those lines to the object...
linesFlat = '\n'.join(gearLines)
brl.add_script_string(linesFlat)
#Now we want to subtract the gear from the bottom
brl.region(bottomFinal, subtract(bottomRing, gearName))
#We now have a bunch of final regions. Combine them into the final gear housing
brl.region(allFinal, union(bottomFinal, middleFinal, topFinal))
#Now we can convert the .g into a .stl, using the final region. save_stl requires a list.
brl.run_and_save_stl([allFinal])
0)
brl_db.remove_object_from_combination(combination_name,
self.center_input)
brl_db.end_combination_edit()
all_items += to_union
combinations.append(combination_name)
all_arms = brl_db.combination('all_arms_combo.r',
'u {}'.format(' u '.join(combinations)))
return all_arms
if __name__ == "__main__":
g_path_out = check_cmdline_args(__file__)
with brlcad_tcl(g_path_out, "My Database", make_g=True,
verbose=False) as brl_db:
device = tobacco_mesophyll_protoplast_fusion_device(
input_port_diameter=1200,
input_symmetric_bifurcation_inner_width=200,
input_symmetric_bifurcation_outer_width=900,
symmetric_bifurcation_post_w=20,
symmetric_bifurcation_post_h=30,
symmetric_bifurcation_post_roundness=15,
symmetric_bifurcation_post_pitch=40,
length_catcher=3200,
width_catcher=900,
catcher_post_w=20,
catcher_post_h=30,
catcher_post_roundness=20,
catcher_post_pitch=20 + (20 / 2),
distance_output_port_from_center=3200 + 200 + 800,
def main(argv):
with brlcad_tcl(argv[1], "My Database") as brl_db:
new_polyhedron = polyhedron_example(brl_db)
brl_db.save_g()
brl_db.save_stl(['new_polyhedron'])
def main(argv):
with brlcad_tcl(argv[1], "My Database") as brl_db:
example = wdb_example(brl_db)
brl_db.save_g()
brl_db.save_stl(['example'])
pmax=(
self.keyway_base_diameter / 2.0, # x
self.shaft_y_offset + (self.key_width / 2.0), # y
key_end) # z
)
print 'Completed step 4 of shaft, part name: {}'.format(shaft4)
shaft_key = self.get_next_name(self, "shaft_key.c")
self.brl_db.combination(shaft_key, 'u {} + {}'.format(shaft3, shaft4))
print 'Completed step 5 of shaft, part name: {}'.format(shaft_key)
# Make a region that is the union of these two objects. To accomplish
# this, we don't need anymore to create any linked list of the items ;-).
shaft = self.get_next_name(self, "shaft.c")
self.brl_db.combination(
shaft, 'u {} u {} u {}'.format(shaft1, shaft2, shaft_key))
return shaft
def wires(self):
pass
if __name__ == "__main__":
#with wdb.WDB(argv[1], "My Database") as brl_db:
g_path_out = check_cmdline_args(__file__)
with brlcad_tcl(g_path_out, "My Database", make_g=True) as brl_db:
motor = motor_28BYJ_48(brl_db)
# All units in the database file are stored in millimeters. This constrains
# the arguments to the mk_* routines to also be in millimeters.
brl_db.save_stl([motor.final_name])
(-tangent_chord_offset) * sin(angle_rad), 0)
brl_db.remove_object_from_combination(combination_name, self.center_input)
brl_db.end_combination_edit()
all_items += to_union
combinations.append(combination_name)
all_arms = brl_db.combination('all_arms_combo.r',
'u {}'
.format(' u '.join(combinations)))
return all_arms
if __name__ == "__main__":
g_path_out = check_cmdline_args(__file__)
with brlcad_tcl(g_path_out, "My Database", make_g=True, verbose=False) as brl_db:
device = tobacco_mesophyll_protoplast_fusion_device(input_port_diameter=1200,
input_symmetric_bifurcation_inner_width=200,
input_symmetric_bifurcation_outer_width=900,
symmetric_bifurcation_post_w=20,
symmetric_bifurcation_post_h=30,
symmetric_bifurcation_post_roundness=15,
symmetric_bifurcation_post_pitch=40,
length_catcher=3200,
width_catcher=900,
catcher_post_w=20,
catcher_post_h=30,
catcher_post_roundness=20,
catcher_post_pitch=20 + (20 / 2),
distance_output_port_from_center=3200 + 200 + 800,
dist_center_catcher_to_center_device=(3200 / 2) + 800,
