481 lines
16 KiB
Python
481 lines
16 KiB
Python
"""
|
|
To build, execute
|
|
```
|
|
python3 nhf/touhou/houjuu_nue/__init__.py
|
|
```
|
|
|
|
This cosplay consists of 3 components:
|
|
|
|
## Trident
|
|
|
|
The trident is composed of individual segments, made of acrylic, and a 3D
|
|
printed head (convention rule prohibits metal) with a metallic paint. To ease
|
|
transportation, the trident handle has individual segments with threads and can
|
|
be assembled on site.
|
|
|
|
## Snake
|
|
|
|
A 3D printed snake with a soft material so it can wrap around and bend
|
|
|
|
## Wings
|
|
|
|
This is the crux of the cosplay and the most complex component. The wings mount
|
|
on a wearable harness. Each wing consists of 4 segments with 3 joints. Parts of
|
|
the wing which demands transluscency are created from 1/16" acrylic panels.
|
|
These panels serve double duty as the exoskeleton.
|
|
|
|
The wings are labeled r1,r2,r3,l1,l2,l3. The segments of the wings are labeled
|
|
from root to tip s0 (root),
|
|
s1, s2, s3. The joints are named (from root to tip)
|
|
shoulder, elbow, wrist in analogy with human anatomy.
|
|
"""
|
|
from dataclasses import dataclass, field
|
|
import unittest
|
|
import cadquery as Cq
|
|
from nhf import Material, Role
|
|
from nhf.build import Model, TargetKind, target
|
|
from nhf.parts.joints import HirthJoint, TorsionJoint
|
|
from nhf.parts.handle import Handle
|
|
import nhf.touhou.houjuu_nue.wing as MW
|
|
import nhf.touhou.houjuu_nue.trident as MT
|
|
import nhf.utils
|
|
|
|
@dataclass
|
|
class Parameters(Model):
|
|
"""
|
|
Defines dimensions for the Houjuu Nue cosplay
|
|
"""
|
|
|
|
# Thickness of the exoskeleton panel in millimetres
|
|
panel_thickness: float = 25.4 / 16
|
|
|
|
# Harness
|
|
harness_thickness: float = 25.4 / 8
|
|
harness_width: float = 300
|
|
harness_height: float = 400
|
|
harness_fillet: float = 10
|
|
|
|
harness_wing_base_pos: list[tuple[str, float, float]] = field(default_factory=lambda: [
|
|
("r1", 70, 150),
|
|
("l1", -70, 150),
|
|
("r2", 100, 0),
|
|
("l2", -100, 0),
|
|
("r3", 70, -150),
|
|
("l3", -70, -150),
|
|
])
|
|
|
|
# Holes drilled onto harness for attachment with HS joint
|
|
harness_to_root_conn_diam: float = 6
|
|
|
|
hs_hirth_joint: HirthJoint = field(default_factory=lambda: HirthJoint(
|
|
radius=30,
|
|
radius_inner=20,
|
|
tooth_height=10,
|
|
base_height=5
|
|
))
|
|
|
|
# Wing root properties
|
|
#
|
|
# The Houjuu-Scarlett joint mechanism at the base of the wing
|
|
hs_joint_base_width: float = 85
|
|
hs_joint_base_thickness: float = 10
|
|
hs_joint_corner_fillet: float = 5
|
|
hs_joint_corner_cbore_diam: float = 12
|
|
hs_joint_corner_cbore_depth: float = 2
|
|
hs_joint_corner_inset: float = 12
|
|
|
|
hs_joint_axis_diam: float = 12
|
|
hs_joint_axis_cbore_diam: float = 20
|
|
hs_joint_axis_cbore_depth: float = 3
|
|
|
|
# Exterior radius of the wing root assembly
|
|
wing_root_radius: float = 40
|
|
wing_root_wall_thickness: float = 8
|
|
|
|
shoulder_torsion_joint: TorsionJoint = field(default_factory=lambda: TorsionJoint(
|
|
track_disk_height=5.0,
|
|
rider_disk_height=7.0,
|
|
radius_axle=8.0,
|
|
))
|
|
|
|
# Two holes on each side (top and bottom) are used to attach the shoulder
|
|
# joint. This governs the distance between these two holes
|
|
shoulder_attach_dist: float = 25
|
|
shoulder_attach_diam: float = 8
|
|
|
|
"""
|
|
Heights for various wing joints, where the numbers start from the first
|
|
joint.
|
|
"""
|
|
wing_s0_thickness: float = 40
|
|
wing_s0_height: float = 100
|
|
|
|
# Length of the spacer
|
|
wing_s1_thickness: float = 20
|
|
wing_s1_spacer_thickness: float = 25.4 / 8
|
|
wing_s1_spacer_width: float = 20
|
|
|
|
trident_handle: Handle = field(default_factory=lambda: Handle(
|
|
diam=38,
|
|
diam_inner=38-2 * 25.4/8,
|
|
# M27-3
|
|
diam_threading=27,
|
|
thread_pitch=3,
|
|
diam_connector_internal=18,
|
|
simplify_geometry=False,
|
|
))
|
|
|
|
material_panel: Material = Material.ACRYLIC_TRANSPARENT
|
|
material_bracket: Material = Material.ACRYLIC_TRANSPARENT
|
|
|
|
def __post_init__(self):
|
|
super().__init__(name="houjuu-nue")
|
|
assert self.wing_root_radius > self.hs_hirth_joint.radius,\
|
|
"Wing root must be large enough to accomodate joint"
|
|
|
|
@target(name="trident/handle-connector")
|
|
def handle_connector(self):
|
|
return self.trident_handle.connector()
|
|
@target(name="trident/handle-insertion")
|
|
def handle_insertion(self):
|
|
return self.trident_handle.insertion()
|
|
|
|
|
|
def harness_profile(self) -> Cq.Sketch:
|
|
"""
|
|
Creates the harness shape
|
|
"""
|
|
w, h = self.harness_width / 2, self.harness_height / 2
|
|
sketch = (
|
|
Cq.Sketch()
|
|
.polygon([
|
|
(0.7 * w, h),
|
|
(w, 0),
|
|
(0.7 * w, -h),
|
|
(0.7 * -w, -h),
|
|
(-w, 0),
|
|
(0.7 * -w, h),
|
|
])
|
|
#.rect(self.harness_width, self.harness_height)
|
|
.vertices()
|
|
.fillet(self.harness_fillet)
|
|
)
|
|
for tag, x, y in self.harness_wing_base_pos:
|
|
conn = [(px + x, py + y) for px, py in self.hs_joint_harness_conn()]
|
|
sketch = (
|
|
sketch
|
|
.push(conn)
|
|
.tag(tag)
|
|
.circle(self.harness_to_root_conn_diam / 2, mode='s')
|
|
.reset()
|
|
)
|
|
return sketch
|
|
|
|
@target(name="harness", kind=TargetKind.DXF)
|
|
def harness(self) -> Cq.Shape:
|
|
"""
|
|
Creates the harness shape
|
|
"""
|
|
result = (
|
|
Cq.Workplane('XZ')
|
|
.placeSketch(self.harness_profile())
|
|
.extrude(self.harness_thickness)
|
|
)
|
|
result.faces(">Y").tag("mount")
|
|
plane = result.faces(">Y").workplane()
|
|
for tag, x, y in self.harness_wing_base_pos:
|
|
conn = [(px + x, py + y) for px, py
|
|
in self.hs_joint_harness_conn()]
|
|
for i, (px, py) in enumerate(conn):
|
|
(
|
|
plane
|
|
.moveTo(px, py)
|
|
.circle(1, forConstruction='True')
|
|
.edges()
|
|
.tag(f"{tag}_{i}")
|
|
)
|
|
return result
|
|
|
|
def hs_joint_harness_conn(self) -> list[tuple[int, int]]:
|
|
"""
|
|
Generates a set of points corresponding to the connectorss
|
|
"""
|
|
dx = self.hs_joint_base_width / 2 - self.hs_joint_corner_inset
|
|
return [
|
|
(dx, dx),
|
|
(dx, -dx),
|
|
(-dx, -dx),
|
|
(-dx, dx),
|
|
]
|
|
|
|
@target(name="hs_joint_parent")
|
|
def hs_joint_parent(self):
|
|
"""
|
|
Parent part of the Houjuu-Scarlett joint, which is composed of a Hirth
|
|
coupling, a cylindrical base, and a mounting base.
|
|
"""
|
|
hirth = self.hs_hirth_joint.generate()
|
|
conn = self.hs_joint_harness_conn()
|
|
result = (
|
|
Cq.Workplane('XY')
|
|
.box(
|
|
self.hs_joint_base_width,
|
|
self.hs_joint_base_width,
|
|
self.hs_joint_base_thickness,
|
|
centered=(True, True, False))
|
|
.translate((0, 0, -self.hs_joint_base_thickness))
|
|
.edges("|Z")
|
|
.fillet(self.hs_joint_corner_fillet)
|
|
.faces(">Z")
|
|
.workplane()
|
|
.pushPoints(conn)
|
|
.cboreHole(
|
|
diameter=self.harness_to_root_conn_diam,
|
|
cboreDiameter=self.hs_joint_corner_cbore_diam,
|
|
cboreDepth=self.hs_joint_corner_cbore_depth)
|
|
)
|
|
# Creates a plane parallel to the holes but shifted to the base
|
|
plane = result.faces(">Z").workplane(offset=-self.hs_joint_base_thickness)
|
|
|
|
for i, (px, py) in enumerate(conn):
|
|
(
|
|
plane
|
|
.pushPoints([(px, py)])
|
|
.circle(1, forConstruction='True')
|
|
.edges()
|
|
.tag(f"h{i}")
|
|
)
|
|
result = (
|
|
result
|
|
.faces(">Z")
|
|
.workplane()
|
|
.union(hirth, tol=0.1)
|
|
.clean()
|
|
)
|
|
result = (
|
|
result.faces("<Z")
|
|
.workplane()
|
|
.cboreHole(
|
|
diameter=self.hs_joint_axis_diam,
|
|
cboreDiameter=self.hs_joint_axis_cbore_diam,
|
|
cboreDepth=self.hs_joint_axis_cbore_depth,
|
|
)
|
|
.clean()
|
|
)
|
|
result.faces("<Z").tag("base")
|
|
return result
|
|
|
|
#@target(name="wing/joining-plate", kind=TargetKind.DXF)
|
|
#def joining_plate(self) -> Cq.Workplane:
|
|
# return self.wing_joining_plate.plate()
|
|
|
|
@target(name="wing_root")
|
|
def wing_root(self) -> Cq.Assembly:
|
|
"""
|
|
Generate the wing root which contains a Hirth joint at its base and a
|
|
rectangular opening on its side, with the necessary interfaces.
|
|
"""
|
|
return MW.wing_root(
|
|
joint=self.hs_hirth_joint,
|
|
shoulder_attach_dist=self.shoulder_attach_dist,
|
|
shoulder_attach_diam=self.shoulder_attach_diam,
|
|
wall_thickness=self.wing_root_wall_thickness,
|
|
conn_height=self.wing_s0_height,
|
|
conn_thickness=self.wing_s0_thickness,
|
|
)
|
|
|
|
@target(name="shoulder_parent")
|
|
def shoulder_parent_joint(self) -> Cq.Workplane:
|
|
result = (
|
|
self.shoulder_torsion_joint.rider()
|
|
.copyWorkplane(Cq.Workplane(
|
|
'YZ', origin=Cq.Vector((90, 0, self.wing_root_wall_thickness))))
|
|
.rect(25, 7, centered=(True, False))
|
|
.extrude("next")
|
|
.copyWorkplane(Cq.Workplane(
|
|
'YX', origin=Cq.Vector((55, 0, self.wing_root_wall_thickness))))
|
|
.hole(self.shoulder_attach_diam)
|
|
.moveTo(0, self.shoulder_attach_dist)
|
|
.hole(self.shoulder_attach_diam)
|
|
)
|
|
result.moveTo(0, 0).tagPlane('conn0')
|
|
result.moveTo(0, self.shoulder_attach_dist).tagPlane('conn1')
|
|
return result
|
|
|
|
@target(name="shoulder_child")
|
|
def shoulder_child_joint(self) -> Cq.Assembly:
|
|
# FIXME: half of conn_height
|
|
h = 100 / 2
|
|
dh = h - self.shoulder_torsion_joint.total_height
|
|
core = (
|
|
Cq.Workplane('XY')
|
|
.moveTo(0, 15)
|
|
.box(50, 40, 2 * dh, centered=(True, False, True))
|
|
)
|
|
loc_rotate = Cq.Location((0, 0, 0), (1, 0, 0), 180)
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(core, name="core", loc=Cq.Location())
|
|
.add(self.shoulder_torsion_joint.track(), name="track_top",
|
|
loc=Cq.Location((0, 0, dh), (0, 0, 1), -90))
|
|
.add(self.shoulder_torsion_joint.track(), name="track_bot",
|
|
loc=Cq.Location((0, 0, -dh), (0, 0, 1), -90) * loc_rotate)
|
|
)
|
|
return result
|
|
|
|
@target(name="wing/s1-spacer", kind=TargetKind.DXF)
|
|
def wing_s1_spacer(self) -> Cq.Workplane:
|
|
result = (
|
|
Cq.Workplane('XZ')
|
|
.sketch()
|
|
.rect(self.wing_s1_spacer_width, self.wing_s1_thickness)
|
|
.finalize()
|
|
.extrude(self.wing_s1_spacer_thickness)
|
|
)
|
|
result.faces("<Z").tag("mate1")
|
|
result.faces(">Z").tag("mate2")
|
|
result.faces(">Y").tag("dir")
|
|
return result
|
|
|
|
@target(name="wing/r1s1", kind=TargetKind.DXF)
|
|
def wing_r1s1_profile(self) -> Cq.Sketch:
|
|
return MW.wing_r1s1_profile()
|
|
|
|
def wing_r1s1_panel(self, front=True) -> Cq.Workplane:
|
|
profile = self.wing_r1s1_profile()
|
|
anchors = [
|
|
("shoulder_bot", 10, 10),
|
|
("middle", 50, -20),
|
|
("tip", 390, -150),
|
|
]
|
|
result = (
|
|
Cq.Workplane("XY")
|
|
.placeSketch(profile)
|
|
.extrude(self.panel_thickness)
|
|
)
|
|
plane = result.faces(">Z" if front else "<Z").workplane()
|
|
sign = 1 if front else -1
|
|
tag_direction = "+Y" if front else "-Y"
|
|
for name, px, py in anchors:
|
|
plane.moveTo(px, sign * py).tagPlane(name)
|
|
#plane.moveTo(px, sign * py).tagPlane(f"{name}_dir", direction=tag_direction)
|
|
return result
|
|
|
|
######################
|
|
# Assemblies #
|
|
######################
|
|
|
|
def trident_assembly(self) -> Cq.Assembly:
|
|
return MT.trident_assembly(self.trident_handle)
|
|
|
|
def harness_assembly(self) -> Cq.Assembly:
|
|
harness = self.harness()
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(harness, name="base", color=Material.WOOD_BIRCH.color)
|
|
.constrain("base", "Fixed")
|
|
)
|
|
for name in ["l1", "l2", "l3", "r1", "r2", "r3"]:
|
|
j = self.hs_joint_parent()
|
|
(
|
|
result
|
|
.add(j, name=name, color=Role.PARENT.color)
|
|
.constrain("base?mount", f"{name}?base", "Axis")
|
|
)
|
|
for i in range(4):
|
|
result.constrain(f"base?{name}_{i}", f"{name}?h{i}", "Point")
|
|
result.solve()
|
|
return result
|
|
|
|
def shoulder_assembly(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(self.shoulder_child_joint(), name="child",
|
|
color=Role.CHILD.color)
|
|
.constrain("child/core", "Fixed")
|
|
# Top parent joint
|
|
.add(self.shoulder_torsion_joint.spring(), name="spring_top",
|
|
color=Role.DAMPING.color)
|
|
.constrain("child/track_top?spring", "spring_top?top", "Plane")
|
|
.constrain("child/track_top?directrix", "spring_top?directrix_bot", "Axis")
|
|
.add(self.shoulder_parent_joint(), name="parent_top",
|
|
color=Role.PARENT.color)
|
|
.constrain("parent_top?spring", "spring_top?bot", "Plane")
|
|
.constrain("parent_top?directrix0", "spring_top?directrix_top", "Axis")
|
|
# Bottom parent joint
|
|
.add(self.shoulder_torsion_joint.spring(), name="spring_bot",
|
|
color=Role.DAMPING.color)
|
|
.constrain("child/track_bot?spring", "spring_bot?top", "Plane")
|
|
.constrain("child/track_bot?directrix", "spring_bot?directrix_bot", "Axis")
|
|
.add(self.shoulder_parent_joint(), name="parent_bot",
|
|
color=Role.PARENT.color)
|
|
.constrain("parent_bot?spring", "spring_bot?bot", "Plane")
|
|
.constrain("parent_bot?directrix0", "spring_bot?directrix_top", "Axis")
|
|
.solve()
|
|
)
|
|
return result
|
|
|
|
def wing_r1s1_assembly(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(self.wing_r1s1_panel(front=True), name="panel_front",
|
|
color=self.material_panel.color)
|
|
.add(self.wing_r1s1_panel(front=False), name="panel_back",
|
|
color=self.material_panel.color)
|
|
.constrain("panel_front@faces@>Z", "panel_back@faces@<Z", "Point",
|
|
param=self.wing_s1_thickness)
|
|
)
|
|
for tag in ["shoulder_bot", "middle", "tip"]:
|
|
(
|
|
result
|
|
.add(self.wing_s1_spacer(), name=f"{tag}_spacer",
|
|
color=self.material_bracket.color)
|
|
.constrain(f"panel_front?{tag}", f"{tag}_spacer?mate1", "Plane")
|
|
.constrain(f"panel_back?{tag}", f"{tag}_spacer?mate2", "Plane")
|
|
)
|
|
|
|
result.solve()
|
|
return result
|
|
|
|
|
|
def wing_r1_assembly(self) -> Cq.Assembly:
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(self.wing_root(), name="r1")
|
|
.add(self.shoulder_assembly(), name="shoulder")
|
|
.constrain("r1/scaffold", "Fixed")
|
|
.constrain("r1/scaffold?conn_top0", "shoulder/parent_top?conn0", "Plane")
|
|
.constrain("r1/scaffold?conn_top1", "shoulder/parent_top?conn1", "Plane")
|
|
.constrain("r1/scaffold?conn_bot0", "shoulder/parent_bot?conn0", "Plane")
|
|
.constrain("r1/scaffold?conn_bot1", "shoulder/parent_bot?conn1", "Plane")
|
|
.solve()
|
|
)
|
|
return result
|
|
|
|
def wings_assembly(self) -> Cq.Assembly:
|
|
"""
|
|
Assembly of harness with all the wings
|
|
"""
|
|
a_tooth = self.hs_hirth_joint.tooth_angle
|
|
|
|
result = (
|
|
Cq.Assembly()
|
|
.add(self.harness_assembly(), name="harness", loc=Cq.Location((0, 0, 0)))
|
|
.add(self.wing_root(), name="w0_r1")
|
|
.add(self.wing_root(), name="w0_l1")
|
|
.constrain("harness/base", "Fixed")
|
|
.constrain("w0_r1/joint?mate", "harness/r1?mate", "Plane")
|
|
.constrain("w0_r1/joint?directrix", "harness/r1?directrix",
|
|
"Axis", param=7 * a_tooth)
|
|
.constrain("w0_l1/joint?mate", "harness/l1?mate", "Plane")
|
|
.constrain("w0_l1/joint?directrix", "harness/l1?directrix",
|
|
"Axis", param=-1 * a_tooth)
|
|
.solve()
|
|
)
|
|
return result
|
|
|
|
|
|
if __name__ == '__main__':
|
|
p = Parameters()
|
|
p.build_all()
|