def build_part(self, params):
key = params.pop('classname', None)
if key in self.class_dict:
fixes = {}
for i in params:
try:
fixes[i] = float(params[i])
except:
pass
item = self.class_dict[key]
o = item.c(**fixes)
display(o)
def params(self, key):
if self.exists(key) == False:
abort(404)
t = self.k[key]
if t.built == False:
t.inst = t.c()
display(t.inst)
t.built = True
d = {}
pi = t.inst.params().items()
for i in pi:
# only grab the floats for now
if isinstance(i[1], float):
d[i] = i[1]
if isinstance(i[1], int):
d[i] = i[1]
info = t.info()
info['params'] = d
#if isinstance(t.inst,cqparts.Assembly):
# info['tree'] = t.inst.tree_str()
return info
from cqparts.utils.geometry import CoordSystem
from cqparts_gears import trapezoidal
class TestGear(trapezoidal.TrapezoidalGear):
effective_radius = PositiveFloat(90)
tooth_count = PositiveInt(20)
width = PositiveFloat(20)
class GearStack(cqparts.Part):
post = PositiveFloat(20)
offset = PositiveFloat(30)
def make(self):
wp = cq.Workplane("XY")
post = wp.circle(self.post).extrude(self.offset)
g1 = TestGear().make()
g2 = (TestGear(tooth_count=14, effective_radius=30).make().translate(
(0, 0, self.offset)))
post = post.union(g1)
post = post.union(g2)
return post
if __name__ == "__main__":
from cqparts.display import display
g = GearStack()
display(g)
self.components["base"].mate_front(),
),
Coincident(
self.components["Ldrive_b"].mate_corner(flip=-1),
self.components["base"].mate_RL(),
),
Coincident(
self.components["Rdrive_b"].mate_corner(flip=1),
self.components["base"].mate_RR(),
),
Coincident(
self.components["Ldrive_f"].mate_corner(flip=1),
self.components["base"].mate_RL(offset=self.length -
self.chamfer),
),
Coincident(
self.components["Rdrive_f"].mate_corner(flip=-1),
self.components["base"].mate_RR(offset=self.length -
self.chamfer),
),
]
return constr
if __name__ == "__main__":
from cqparts.display import display
# B = RobotBase()
B = Rover()
display(B)
# ------------------- Export / Display -------------------
from cqparts.utils.env import env_name
# ------- Models
wheel = Wheel()
axle = Axle()
chassis = Chassis()
wheeled_axle = WheeledAxle(right_width=2)
car = Car()
if env_name == 'cmdline':
wheel.exporter('gltf')('wheel.gltf')
axle.exporter('gltf')('axle.gltf')
chassis.exporter('gltf')('chassis.gltf')
wheeled_axle.exporter('gltf')('wheel-assembly.gltf')
print(wheeled_axle.tree_str(name='wheel_assembly'))
car.exporter('gltf')('car.gltf')
print(car.tree_str(name='car'))
car.find('chassis').exporter('gltf')('chassis-altered.gltf')
elif env_name == 'freecad':
pass # manually switchable for testing
#display(wheel)
#display(axle)
#display(chassis)
#display(wheeled_axle)
display(car)
#display(car.find('chassis'))
cutout = cq.Workplane("XY").circle(self.diam / 2).extrude(self.length)
return cutout
# TODO , mate for shafts
def get_cutout(self, clearance=0):
" clearance cut out for shaft "
return (cq.Workplane(
"XY", origin=(0, 0, 0)).circle((self.diam / 2) +
clearance).extrude(self.length * 2))
def mate_tip(self, offset=0):
return Mate(
self,
CoordSystem(origin=(0, 0, self.length),
xDir=(1, 0, 0),
normal=(0, 0, 1)),
)
class BearingMount(cqparts.Assembly):
pass
if __name__ == "__main__":
from cqparts.display import display
# sb = SimpleBearing()
t = BearingMount()
display(t)
'base': base,
'top': top,
'fastener': NutAndBoltFastener(parts=[base, top]),
}
def make_constraints(self):
base = self.components['base']
top = self.components['top']
fastener = self.components['fastener']
return [
Fixed(base.mate_bottom),
Coincident(top.mate_bottom, base.mate_top),
Coincident(fastener.mate_origin, top.mate_top),
]
thing = Thing()
# ------------------- Export -------------------
from cqparts.params import *
from cqparts.display import display
from cqparts.display import get_display_environment
env_name = get_display_environment().name
if env_name == 'freecad':
display(thing)
else:
thing.exporter('gltf')('thing.gltf', embed=False)
constr = [
Fixed(self.components["stepper"].mate_origin),
Coincident(
self.components["drive"].pulley_A_mate(offset=10),
self.components["stepper"].mate_origin,
),
Coincident(
self.components["idler"].mate_origin,
self.components["drive"].pulley_B_mate(offset=10),
),
]
return constr
def mate_mount(self, offset=0):
return Mate(
self,
CoordSystem(origin=(0, 0, 0), xDir=(1, 0, 0), normal=(0, 1, 0)))
## test setup
class MyPulley(Pulley):
rad = PositiveFloat(7)
if __name__ == "__main__":
from cqparts.display import display
p = BeltDrive(pulley=MyPulley, length=100)
# p = ThreadedDrive(length=50)
display(p)
cqparts.search.class_criteria[cls].get('name', set())
for cls in cqparts.solidtypes.threads.search()
]
names_list = set()
for name_set in name_sets:
names_list |= name_set
names_list = sorted(names_list)
from cqparts.utils.env import env_name
if (not args.name) and (env_name == 'freecad'):
args.name = 'triangular'
if not args.name or args.list:
# List screw drives and exit
for name in names_list:
print(" - %s" % name)
else:
thread = find(name=args.name)()
thread._simple = False # force complex threads
if env_name == 'freecad':
# force complex thread
from Helpers import show
show(thread.local_obj)
show(thread.profile)
else:
display(thread)
board = board.cut(holes)
return board
@register(export="controller")
class GlasgowRevC(PCBBoard):
length = PositiveFloat(80.0)
width = PositiveFloat(49)
thickness = PositiveFloat(1)
hole_size = PositiveFloat(3.2)
corner_radius = PositiveFloat(4)
hole_length = PositiveFloat(72.0)
hole_width = PositiveFloat(41.0)
def make(self):
board = super(GlasgowRevC, self).make()
return board
if __name__ == "__main__":
from cqparts.display import display
db = _Boards()
db.add(Arduino())
db.add(GlasgowRevC())
db.add(Pizero())
db.add(BeagleBoneBlack())
db.add(PCBBoard(length=100, width=30))
display(db)
mount = Mount(
width=60,
wall_thickness=1,
toggle_width=toggle.width,
toggle_height=toggle.height,
extra_space=0.1,
slot_width=2 * toggle.slot_width + toggle.pin_width,
bracket_width=10,
bracket_height=7,
mount_hole_diameter=screw_diameter,
probe_hole_distance=probe.radius +
(toggle.height - toggle.slot_height),
hide_front=True,
)
return {"toggle": toggle, "mount": mount, "probe": probe}
def make_constraints(self):
toggle = self.components["toggle"]
mount = self.components["mount"]
probe = self.components["probe"]
return [
cp.constraint.Fixed(mate=mount.mate_origin,
world_coords=CoordSystem()),
cp.constraint.Coincident(toggle.mate, probe.toggle_mate),
cp.constraint.Coincident(probe.screw_hole, mount.screw_hole)
]
assembly = Assembly()
display(assembly)
"top":
PencilCaseTop(
length=self.length,
width=self.width,
height=self.height,
thickness=self.thickness,
),
"bottom":
OpenBox(
length=self.length - 2 * self.thickness - self.clearance,
width=self.width - 2 * self.thickness - self.clearance,
height=self.height - self.thickness - self.clearance,
thickness=self.thickness,
),
}
return comps
def make_constraints(self):
constr = [
Fixed(self.components["bottom"].mate_origin),
Fixed(self.components["top"].mate_top()),
]
return constr
if __name__ == "__main__":
from cqparts.display import display
FB = PencilCase()
display(FB)
def get_cutout(self, clearance=0):
" clearance cut out for shaft "
return (
cq.Workplane("XY", origin=(0, 0, 0))
.circle((self.diam / 2) + clearance)
.extrude(self.length * 2)
)
def make_cutout(self, part, clearance=0):
part = part.local_obj.cut(
(self.world_coords - part.world_coords) + self.cutout(clearance=clearance)
)
def cutout(self, clearance=0):
so = cq.Workplane("XY").circle(clearance + self.diam / 2).extrude(self.length)
return so
def mate_tip(self, offset=0):
return Mate(
self,
CoordSystem(origin=(0, 0, self.length), xDir=(1, 0, 0), normal=(0, 0, 1)),
)
if __name__ == "__main__":
from cqparts.display import display
a = Shaft()
display(a)
}
return comps
def make_constraints(self):
return [
Fixed(self.components["cowl"].mate_origin),
Coincident(
self.components["motor"].mate_origin,
self.components["cowl"].mate_mount(),
),
Coincident(
self.components["turbine"].mate_origin,
self.components["cowl"].mate_mount(),
),
Coincident(
self.components["spinner"].mate_origin,
self.components["turbine"].mate_top(),
),
]
if __name__ == "__main__":
from cqparts.display import display
# display(Spinner())
# display(Cowl())
# display(Turbine())
# display(Blade())
# display(AeroMotor())
display(TurbineAssembly())
countZ = Int(1)
batt = PartRef(Li18650)
def make_components(self):
return {
"m":
Battpack(
batt=self.batt,
countX=self.countX,
countY=self.countY,
countZ=self.countZ,
)
}
def make_constraints(self):
return [Fixed(self.components["m"].mate_flat())]
if __name__ == "__main__":
from cqparts.display import display
# bv = _BattView()
# bv.add(AAA())
# bv.add(AA())
# bv.add(C())
# bv.add(D())
# bv = Battpack(batt=Li18650,countX=5,countY=3,countZ=2)
# bv = Battpack(batt=Li18650,countX=5,countY=1,countZ=1)
bv = _FlatBatt()
display(bv)
def make_components(self):
return {
'front_rod': ThreadedRod(),
'rear_rod': ThreadedRod(),
}
# def make_constraints(self):
# return [
# Fixed(self.components['front_rod'].mate_origin, CoordSystem()),
# Coincident(
# self.components['rear_rod'].mate_origin,
# Mate(self.components['front_rod'],
# CoordSystem((self.rod_offset, 0, 0))),
# ),
# ]
# ------------------- Display Result -------------------
# Could also export to another format
if __name__ != 'TestEngineWholeModel':
# not run as a module, so display result
# m = Train()
#m = Chassis()
# m = WheeledAxle()
# m = Axle()
# m = Wheel()
# m = Motor()
#m = ThreadedRod()
m = TopAssembly()
display(m)
return h.objects
def make(self):
# base plate
pl = cq.Workplane("XY").box(self.length, self.width, self.height)
pl = pl.translate((0, 0, self.height / 2))
# add the bosses
mp = self.mount_points()
for i in mp:
b = _boss(boss_height=self.boss_height,
boss_diameter=self.boss_diameter)
b = b.local_obj.translate((i.X, i.Y, self.height))
pl = pl.union(b)
# cur the holes
for i in mp:
h = (cq.Workplane("XY").circle(self.hole_diameter /
2).extrude(self.height +
self.boss_height))
h = h.translate((i.X, i.Y, 0))
pl = pl.cut(h)
pl = pl.faces(">Z[1]").edges("not(<X or >X or <Y or >Y)").fillet(1)
pl = pl.edges("|Z").fillet(3)
return pl
if __name__ == "__main__":
from cqparts.display import display
bb = BeardBoss(height=6, boss_height=20, boss_diameter=10, hole_diameter=5)
display(bb)
radius = PositiveFloat(8)
def make(self):
em = cq.Workplane("XY").circle(self.radius).extrude(self.height)
return em
@register(export="sensor")
class Sonar(PCBBoard):
length = PositiveFloat(45)
width = PositiveFloat(20)
corner_radius = PositiveFloat(0)
thickness = PositiveFloat(1.2)
hole_size = PositiveFloat(1.0)
def make(self):
obj = super(Sonar, self).make()
em1 = Emmitter().local_obj.translate((13.5, 0, 0))
em2 = Emmitter().local_obj.translate((-13.5, 0, 0))
obj = obj.union(em1)
obj = obj.union(em2)
return obj
if __name__ == "__main__":
from cqparts.display import display
# em = Emmitter()
em = Sonar()
display(em)
connected_exact = ConnectedPlanks()
connected_catalogue = ConnectedPlanksCatalogue()
if env_name == 'cmdline':
screw.exporter('gltf')('screw.gltf')
anchor.exporter('gltf')('anchor.gltf')
panel.exporter('gltf')('panel.gltf')
connected_exact.exporter('gltf')('connected_exact.gltf')
print(connected_exact.tree_str(name='connected'))
connected_catalogue.exporter('gltf')('connected_catalogue.gltf')
#display(connected_exact)
elif env_name == 'freecad':
pass # manually switchable for testing
#display(screw)
#display(screw.make_cutter())
#display(anchor)
#display(together)
display(connected_exact)
# ------------------- Catalogue : Cleanup -------------------
# Cleanup catalogue file (just for this script)
import os
os.unlink(catalogue_filename)
#print('catalogue: %s' % catalogue_filename)
from cqparts.display import render_props, display
class Box(cqparts.Part):
_render = render_props(template='red', alpha=0.2)
def make(self):
return cadquery.Workplane('XY').box(10, 10, 10)
red_box = Box()
# ------------------- Export -------------------
from cqparts.display import get_display_environment
env_name = get_display_environment().name
if env_name == 'freecad':
pass
#display(box)
#display(wheel)
#display(my_wheel)
#display(joined_wheel)
display(red_box)
else:
box.exporter('gltf')('box.gltf', embed=True)
wheel.exporter('gltf')('wheel.gltf', embed=True)
my_wheel.exporter('gltf')('holy-wheel.gltf', embed=True)
joined_wheel.exporter('gltf')('joined-wheel.gltf', embed=True)
red_box.exporter('gltf')('red-box.gltf', embed=True)
def make_alterations(self):
self.apply_cutout()
def boss_cutout(self, clearance=0):
bc = cq.Workplane("XY").circle(self.boss_size / 2).extrude(
self.shaft_length)
return bc
def cutout(self, part):
self.cut_boss(part)
def cut_boss(self, part, clearance=0):
co = self.boss_cutout(clearance=clearance)
lo = part.local_obj.cut((self.world_coords - part.world_coords) + co)
def mate_tip(self):
return Mate(
self,
CoordSystem(origin=(0, 0, self.shaft_length),
xDir=(1, 0, 0),
normal=(0, 0, 1)),
)
if __name__ == "__main__":
from cqparts.display import display
st = Stepper()
display(st)
import cadquery as cq
import cqparts
from cqparts.params import *
from cqparts.constraint import Fixed, Coincident
from cqparts_misc.basic.primatives import Box
from cqparts.display import render_props
from .manufacture import Lasercut
class Plank(Box, Lasercut):
length = PositiveFloat(90)
width = PositiveFloat(90)
thickness = PositiveFloat(3)
_render = render_props(template="wood")
fillet = PositiveFloat(3)
def make(self):
pl = cq.Workplane("XY").box(self.length, self.width, self.thickness)
pl = pl.translate((0, 0, self.thickness / 2))
if self.fillet > 0:
pl = pl.edges("|Z").fillet(self.fillet)
return pl
if __name__ == "__main__":
from cqparts.display import display
display(Plank())
cls = cqparts_fasteners.solidtypes.fastener_heads.find(name=name)
components[name] = cls(_render={'alpha': 0.5})
return components
def make_constraints(self):
constraints = []
index_width = int(math.sqrt(len(self.names)))
for (i, name) in enumerate(self.names):
(row, col) = ((i % index_width), int(i / index_width))
constraints.append(Fixed(
self.components[name].mate_origin,
CoordSystem(origin=(
row * (self.box_size + self.gap),
-col * (self.box_size + self.gap),
0
)),
))
return constraints
names = names_list
if args.name:
# single
names = [args.name]
showcase = Showcase(names=names)
display(showcase)
class FourArm(_MultiArm):
arms = Int(4)
@register(export="horns")
class ServoArm(_MultiArm):
arms = Int(6)
@register(export="horns")
class Circle(_ServoHorn):
length = PositiveFloat(20)
holes = Int(10)
def make(self):
c = self.circle()
c = c.union(self.hub())
c = c.cut(self.mount())
return c
if __name__ == "__main__":
from cqparts.display import display
sh = ShowHorns(offset=40)
sh.add(SingleArm())
for i in range(2, 7):
sh.add(_MultiArm(arms=i))
sh.add(Circle())
display(sh)
base2.mate_nut_top(i),
),
Coincident(
bolt_b.mate_head_end(rotation=(180, 0, 0)),
base3.mate_nut_bottom(i),
),
]
return constraints
def make_alterations(self):
# Cutout the inserted nuts
base = self.components["base"]
base2 = self.components["base2"]
base3 = self.components["base3"]
for i, size in enumerate(self.tests):
self.components[self.insert_bolt_name(size)].apply_cutout(base)
self.components[self.nut_on_top_name(size)].apply_cutout(base2)
self.components[self.bolt_on_bottom_name(size)].apply_cutout(base3)
# ------------------- Display Result -------------------
# Could also export to another format
if __name__ == "__cq_freecad_module__":
# r = Nut()
# r = Head()
# r = Bolt()
# r = Bolt(size = 'M3', embedded_length=3)
# r = Bolt(size = 'M3', embedded_length=3, show_cutout=True)
r = NutDisplay()
display(r)
rails = self.components["rails"]
for i, j in enumerate(rails.rail_pos()):
item = rails.components[rails.rail_name(i)]
item.make_cutout(part=de.components["block"])
item.make_cutout(part=ie.components["block"])
@register(export="cnc")
class BeltAxis(Axis):
drive = PartRef(BeltDrive)
@register(export="cnc")
class ThreadAxis(Axis):
drive = PartRef(ThreadedDrive)
class CNC_show(Arrange):
offset = PositiveFloat(100)
if __name__ == "__main__":
from cqparts.display import display
ar = CNC_show()
# ar.add(Axis(width=90, length=200, pos=100))
# ar.add(Axis(drive=BeltDrive, width=60, length=250, pos=50))
ar.add(Axis(drive=ThreadedDrive, length=200, width=100, pos=70))
# e = Axis()
display(ar)
# base shaft type
@register(export="misc")
class Shell(cqparts.Part):
length = PositiveFloat(124, doc="shaft length")
diam = PositiveFloat(40, doc="shaft diameter")
count = Int(5)
def make(self):
shft = cq.Workplane("XY").circle(self.diam / 2).extrude(self.length)
inc = 360.0 / float(self.count)
for i in range(self.count):
b = cq.Workplane("XY").circle(self.diam / 4).extrude(self.length /
2)
b = b.translate((self.diam / 2, 0, self.length / 8))
b = b.rotate((0, 0, 0), (0, 0, 1), float(i * inc))
shft = shft.union(b)
c = cq.Workplane("XY").circle(self.diam / 8).extrude(self.length -
6)
c = c.translate((self.diam / 2, 0, 0))
c = c.rotate((0, 0, 0), (0, 0, 1), float(i * inc))
shft = shft.union(c)
shft = shft.faces(">Z").shell(-1)
return shft
if __name__ == "__main__":
from cqparts.display import display
s = Shell()
display(s)
# cut all the mount points out of the target
if self.target is not None:
pass
pass
class OtherBatt(Battpack):
countX = Int(5)
countY = Int(2)
countZ = Int(1)
batt = PartRef(battery.AA)
class OtherController(MountedBoard):
board = PartRef(BeagleBoneBlack)
@register(export="electronics")
class type1(Electronics):
battpack = PartRef(OtherBatt)
controller = PartRef(OtherController)
motorcontroller = PartRef(MotorController)
target = PartRef() # what the electronics are bound to
if __name__ == "__main__":
from cqparts.display import display
e = Electronics()
display(e)
Coincident(
self.components['branch_r'].mate_origin,
self.components['trunk_split'].mate_right,
),
]
#house = Splitter()
#display(house)
#block_tree.world_coords = CoordSystem()
# ------------------- Export / Display -------------------
from cqparts.utils.env import get_env_name
env_name = get_env_name()
# ------- Models
block_tree = BlockTree(trunk_diam=7)
#import ipdb
#ipdb.set_trace()
if env_name == 'cmdline':
block_tree.exporter('gltf')('exports/block-tree.gltf', embed=True)
print(block_tree.tree_str(name="block_tree"))
elif env_name == 'freecad':
pass # manually switchable for testing
display(block_tree)
_PegSide(**params),
"spring":
_Spring(
diam=self.spring_diam,
arm_length=self.spring_arm_length,
wire_diam=self.spring_wire_diam,
width=self.width,
),
}
def make_constraints(self):
bottom = self.components["bottom"]
top = self.components["top"]
spring = self.components["spring"]
return [
constraint.Fixed(bottom.mate_side),
constraint.Coincident(
top.mate_spring_center,
bottom.mate_spring_center + CoordSystem(normal=(0, 0, -1)),
),
constraint.Coincident(spring.mate_origin,
bottom.mate_spring_center),
]
if __name__ == "__main__":
from cqparts.display import display
cp = ClothesPeg()
display(cp)
