""" This file describes the shapes of the wing shells. The joints are defined in `__init__.py`. """ import math from enum import Enum from dataclasses import dataclass, field from typing import Mapping, Tuple, Optional import cadquery as Cq from nhf import Material, Role from nhf.build import Model, TargetKind, target, assembly, submodel from nhf.parts.box import box_with_centre_holes, MountingBox, Hole from nhf.parts.joints import HirthJoint from nhf.touhou.houjuu_nue.joints import RootJoint, ShoulderJoint, ElbowJoint, DiskJoint from nhf.parts.planar import extrude_with_markers import nhf.utils @dataclass(kw_only=True) class WingProfile(Model): name: str = "wing" base_width: float = 80.0 root_joint: RootJoint = field(default_factory=lambda: RootJoint()) panel_thickness: float = 25.4 / 16 spacer_thickness: float = 25.4 / 8 shoulder_joint: ShoulderJoint = field(default_factory=lambda: ShoulderJoint( )) shoulder_angle_bias: float = 0.0 shoulder_width: float = 36.0 shoulder_tip_x: float = -260.0 shoulder_tip_y: float = 165.0 shoulder_mid_x: float = -125.0 shoulder_mid_y: float = 75.0 s1_thickness: float = 25.0 elbow_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint( disk_joint=DiskJoint( movement_angle=55, ), hole_diam=6.0, angle_neutral=15.0, )) # Distance between the two spacers on the elbow, halved elbow_h2: float = 5.0 s2_thickness: float = 25.0 wrist_joint: ElbowJoint = field(default_factory=lambda: ElbowJoint( disk_joint=DiskJoint( movement_angle=30, radius_disk=13.0, radius_housing=15.0, ), hole_pos=[10, 20], lip_length=50, child_arm_radius=23.0, parent_arm_radius=30.0, hole_diam=4.0, angle_neutral=30.0, )) # Distance between the two spacers on the elbow, halved wrist_h2: float = 5.0 s3_thickness: float = 25.0 mat_panel: Material = Material.ACRYLIC_TRANSLUSCENT mat_bracket: Material = Material.ACRYLIC_TRANSPARENT mat_hs_joint: Material = Material.PLASTIC_PLA role_panel: Role = Role.STRUCTURE # Subclass must populate elbow_bot_loc: Cq.Location elbow_height: float wrist_bot_loc: Cq.Location wrist_height: float elbow_rotate: float = -5.0 wrist_rotate: float = 30.0 # False for the right side, True for the left side flip: bool = False def __post_init__(self): super().__init__(name=self.name) self.elbow_top_loc = self.elbow_bot_loc * Cq.Location.from2d(0, self.elbow_height) self.wrist_top_loc = self.wrist_bot_loc * Cq.Location.from2d(0, self.wrist_height) self.elbow_axle_loc = self.elbow_bot_loc * Cq.Location.from2d(0, self.elbow_height / 2) self.wrist_axle_loc = self.wrist_bot_loc * Cq.Location.from2d(0, self.wrist_height / 2) assert self.elbow_joint.total_thickness < min(self.s1_thickness, self.s2_thickness) assert self.wrist_joint.total_thickness < min(self.s2_thickness, self.s3_thickness) self.shoulder_joint.angle_neutral = -self.shoulder_angle_neutral - self.shoulder_angle_bias self.shoulder_axle_loc = Cq.Location.from2d(self.shoulder_tip_x, self.shoulder_tip_y - self.shoulder_width / 2, self.shoulder_angle_bias) self.shoulder_joint.child_guard_width = self.s1_thickness + self.panel_thickness * 2 assert self.spacer_thickness == self.root_joint.child_mount_thickness @submodel(name="shoulder-joint") def submodel_shoulder_joint(self) -> Model: return self.shoulder_joint @submodel(name="elbow-joint") def submodel_elbow_joint(self) -> Model: return self.elbow_joint @submodel(name="wrist-joint") def submodel_wrist_joint(self) -> Model: return self.wrist_joint @property def root_height(self) -> float: return self.shoulder_joint.height @property def shoulder_height(self) -> float: return self.shoulder_joint.height def outer_profile_s0(self) -> Cq.Sketch: """ The outer boundary of s0, used to produce the curved panel and the top/bottom slots """ tip_x = self.shoulder_tip_x tip_y = self.shoulder_tip_y return ( Cq.Sketch() .spline([ (0, 0), (-30.0, 80.0), (tip_x, tip_y) ]) #.segment( # (tip_x, tip_y), # (tip_x - 10, tip_y), #) ) @property def shoulder_angle_neutral(self) -> float: """ Returns the neutral angle of the shoulder """ dx = self.shoulder_mid_x - self.shoulder_tip_x dy = -(self.shoulder_mid_y - (self.shoulder_tip_y - self.shoulder_width)) result = math.degrees(math.atan2(dy, dx)) assert result >= 0 return result @target(name="profile-s0", kind=TargetKind.DXF) def profile_s0(self) -> Cq.Sketch: tip_x = self.shoulder_tip_x tip_y = self.shoulder_tip_y mid_x = self.shoulder_mid_x mid_y = self.shoulder_mid_y sw = self.shoulder_width sketch = ( self.outer_profile_s0() .segment((-self.base_width, 0), (0, 0)) .segment( (tip_x, tip_y), (tip_x, tip_y - sw), ) .segment( (tip_x, tip_y - sw), (mid_x, mid_y), ) .segment( (mid_x, mid_y), (-self.base_width, 0), ) .assemble() .push([self.shoulder_axle_loc.to2d_pos()]) .circle(self.shoulder_joint.radius, mode='a') .circle(self.shoulder_joint.bolt.diam_head / 2, mode='s') ) return sketch def outer_shell_s0(self) -> Cq.Workplane: t = self.panel_thickness profile = Cq.Wire.assembleEdges(self.outer_profile_s0().edges().vals()) result = ( Cq.Workplane('XZ') .rect(t, self.root_height + t*2, centered=(False, False)) .sweep(profile) ) plane = result.copyWorkplane(Cq.Workplane('XZ')) plane.moveTo(0, 0).tagPlane("bot") plane.moveTo(0, self.root_height + t*2).tagPlane("top") return result @submodel(name="spacer-s0-shoulder") def spacer_s0_shoulder(self) -> MountingBox: """ Shoulder side serves double purpose for mounting shoulder joint and structural support """ holes = [ hole for i, (x, y) in enumerate(self.shoulder_joint.parent_conn_hole_pos) for hole in [ Hole(x=x, y=y, tag=f"conn_top{i}"), Hole(x=-x, y=y, tag=f"conn_bot{i}"), ] ] return MountingBox( length=self.shoulder_joint.height, width=self.shoulder_joint.parent_lip_width, thickness=self.spacer_thickness, holes=holes, hole_diam=self.shoulder_joint.parent_conn_hole_diam, centred=(True, True), flip_y=self.flip, ) @submodel(name="spacer-s0-shoulder") def spacer_s0_base(self) -> MountingBox: """ Base side connects to H-S joint """ assert self.root_joint.child_width < self.base_width assert self.root_joint.child_corner_dx * 2 < self.base_width assert self.root_joint.child_corner_dz * 2 < self.root_height dy = self.root_joint.child_corner_dx dx = self.root_joint.child_corner_dz holes = [ Hole(x=-dx, y=-dy), Hole(x=dx, y=-dy), Hole(x=dx, y=dy), Hole(x=-dx, y=dy), ] return MountingBox( length=self.root_height, width=self.root_joint.child_width, thickness=self.spacer_thickness, holes=holes, hole_diam=self.root_joint.corner_hole_diam, centred=(True, True), flip_y=self.flip, ) @submodel(name="spacer-s0-mid3") def spacer_s0_mid3(self) -> MountingBox: return MountingBox( length=self.root_height, width=40, thickness=self.spacer_thickness, flip_y=self.flip ) @submodel(name="spacer-s0-mid2") def spacer_s0_mid2(self) -> MountingBox: return MountingBox( length=self.root_height, width=60, thickness=self.spacer_thickness, flip_y=self.flip ) def surface_s0(self, top: bool = False) -> Cq.Workplane: base_dx = -(self.base_width - self.root_joint.child_width) / 2 - 10 base_dy = self.root_joint.hirth_joint.joint_height loc_tip = Cq.Location(0, -self.shoulder_joint.parent_lip_width / 2) mid_spacer_loc = ( Cq.Location.from2d(0, -self.shoulder_width/2) * self.shoulder_axle_loc * Cq.Location.rot2d(self.shoulder_joint.angle_neutral) ) tags = [ ("shoulder", self.shoulder_axle_loc * self.shoulder_joint.parent_arm_loc() * loc_tip), ("base", Cq.Location.from2d(base_dx, base_dy, 90)), ("mid3", mid_spacer_loc * Cq.Location.from2d(90, 0)), ("mid2", mid_spacer_loc * Cq.Location.from2d(150, 0)), ] result = extrude_with_markers( self.profile_s0(), self.panel_thickness, tags, reverse=not top, ) h = self.panel_thickness if top else 0 result.copyWorkplane(Cq.Workplane('XZ')).moveTo(0, h).tagPlane("corner") return result @assembly() def assembly_s0(self) -> Cq.Assembly: result = ( Cq.Assembly() .addS(self.surface_s0(top=True), name="bot", material=self.mat_panel, role=self.role_panel) .addS(self.surface_s0(top=False), name="top", material=self.mat_panel, role=self.role_panel, loc=Cq.Location((0, 0, self.root_height + self.panel_thickness))) .constrain("bot", "Fixed") .constrain("top", "Fixed") #.constrain("bot@faces@>Z", "top@faces@ Cq.Sketch: """ Generates profile from shoulder and above """ def _assembly_insert_spacer( self, a: Cq.Assembly, spacer: Cq.Workplane, point_tag: str, front_tag: str = "front", back_tag: str = "back", flipped: bool = False, rotate: bool = False, ): """ For a child joint facing up, front panel should be on the right, back panel on the left """ site_front, site_back = "right", "left" if flipped: site_front, site_back = site_back, site_front angle = 180 if rotate else 0 ( a .addS( spacer, name=point_tag, material=self.mat_bracket, role=self.role_panel) .constrain(f"{front_tag}?{point_tag}", f"{point_tag}?{site_front}", "Plane") .constrain(f"{back_tag}?{point_tag}", f"{point_tag}?{site_back}", "Plane") .constrain(f"{point_tag}?dir", f"{front_tag}?{point_tag}_dir", "Axis", param=angle) ) def _mask_elbow(self) -> list[Tuple[float, float]]: """ Polygon shape to mask out parts above the elbow """ def _mask_wrist(self) -> list[Tuple[float, float]]: """ Polygon shape to mask wrist """ def spacer_of_joint( self, joint: ElbowJoint, segment_thickness: float, dx: float, bot=False) -> MountingBox: length = joint.lip_length / 2 - dx holes = [ Hole(x - dx) for x in joint.hole_pos ] mbox = MountingBox( length=length, width=segment_thickness, thickness=self.spacer_thickness, holes=holes, hole_diam=joint.hole_diam, centred=(False, True), ) return mbox @target(name="profile-s1", kind=TargetKind.DXF) def profile_s1(self) -> Cq.Sketch: profile = ( self.profile() .reset() .polygon(self._mask_elbow(), mode='i') ) return profile def surface_s1(self, front: bool = True) -> Cq.Workplane: shoulder_h = self.shoulder_joint.child_height h = (self.shoulder_joint.height - shoulder_h) / 2 tags_shoulder = [ ("shoulder_bot", Cq.Location.from2d(0, h, 90)), ("shoulder_top", Cq.Location.from2d(0, h + shoulder_h, 270)), ] h = self.elbow_height / 2 loc_elbow = Cq.Location.rot2d(self.elbow_rotate) * self.elbow_joint.parent_arm_loc() tags_elbow = [ ("elbow_bot", self.elbow_axle_loc * loc_elbow * Cq.Location.from2d(0, -self.elbow_h2)), ("elbow_top", self.elbow_axle_loc * loc_elbow * Cq.Location.from2d(0, self.elbow_h2)), ] profile = self.profile_s1() tags = tags_shoulder + tags_elbow return extrude_with_markers( profile, self.panel_thickness, tags, reverse=front) @submodel(name="spacer-s1-shoulder") def spacer_s1_shoulder(self) -> MountingBox: holes = [ Hole(x) for x in self.shoulder_joint.child_conn_hole_pos ] return MountingBox( length=50.0, # FIXME: magic width=self.s1_thickness, thickness=self.spacer_thickness, holes=holes, hole_diam=self.shoulder_joint.child_conn_hole_diam, ) @submodel(name="spacer-s1-elbow") def spacer_s1_elbow(self) -> MountingBox: return self.spacer_of_joint( joint=self.elbow_joint, segment_thickness=self.s1_thickness, dx=self.elbow_h2, ) @assembly() def assembly_s1(self) -> Cq.Assembly: result = ( Cq.Assembly() .addS(self.surface_s1(front=True), name="front", material=self.mat_panel, role=self.role_panel) .constrain("front", "Fixed") .addS(self.surface_s1(front=False), name="back", material=self.mat_panel, role=self.role_panel) .constrain("front@faces@>Z", "back@faces@ Cq.Sketch: profile = ( self.profile() .reset() .polygon(self._mask_elbow(), mode='s') .reset() .polygon(self._mask_wrist(), mode='i') ) return profile def surface_s2(self, front: bool = True) -> Cq.Workplane: h = self.elbow_height / 2 loc_elbow = Cq.Location.rot2d(self.elbow_rotate) * self.elbow_joint.child_arm_loc(flip=self.flip) tags_elbow = [ ("elbow_bot", self.elbow_axle_loc * loc_elbow * Cq.Location.from2d(0, self.elbow_h2)), ("elbow_top", self.elbow_axle_loc * loc_elbow * Cq.Location.from2d(0, -self.elbow_h2)), ] h = self.wrist_height / 2 loc_wrist = Cq.Location.rot2d(self.wrist_rotate) * self.wrist_joint.parent_arm_loc() tags_wrist = [ ("wrist_bot", self.wrist_axle_loc * loc_wrist * Cq.Location.from2d(0, -self.wrist_h2)), ("wrist_top", self.wrist_axle_loc * loc_wrist * Cq.Location.from2d(0, self.wrist_h2)), ] profile = self.profile_s2() tags = tags_elbow + tags_wrist return extrude_with_markers(profile, self.panel_thickness, tags, reverse=front) @submodel(name="spacer-s2-elbow") def spacer_s2_elbow(self) -> MountingBox: return self.spacer_of_joint( joint=self.elbow_joint, segment_thickness=self.s2_thickness, dx=self.elbow_h2, ) @submodel(name="spacer-s2-wrist") def spacer_s2_wrist(self) -> MountingBox: return self.spacer_of_joint( joint=self.wrist_joint, segment_thickness=self.s2_thickness, dx=self.wrist_h2, ) @assembly() def assembly_s2(self) -> Cq.Assembly: result = ( Cq.Assembly() .addS(self.surface_s2(front=True), name="front", material=self.mat_panel, role=self.role_panel) .constrain("front", "Fixed") .addS(self.surface_s2(front=False), name="back", material=self.mat_panel, role=self.role_panel) .constrain("front@faces@>Z", "back@faces@ Cq.Sketch: profile = ( self.profile() .reset() .polygon(self._mask_wrist(), mode='s') ) return profile def surface_s3(self, front: bool = True) -> Cq.Workplane: h = self.wrist_height / 2 loc_wrist = Cq.Location.rot2d(self.wrist_rotate) * self.wrist_joint.child_arm_loc(flip=not self.flip) tags = [ ("wrist_bot", self.wrist_axle_loc * loc_wrist * Cq.Location.from2d(0, self.wrist_h2)), ("wrist_top", self.wrist_axle_loc * loc_wrist * Cq.Location.from2d(0, -self.wrist_h2)), ] profile = self.profile_s3() return extrude_with_markers(profile, self.panel_thickness, tags, reverse=front) @submodel(name="spacer-s3-wrist") def spacer_s3_wrist(self) -> MountingBox: return self.spacer_of_joint( joint=self.wrist_joint, segment_thickness=self.s3_thickness, dx=self.wrist_h2, ) @assembly() def assembly_s3(self) -> Cq.Assembly: result = ( Cq.Assembly() .addS(self.surface_s3(front=True), name="front", material=self.mat_panel, role=self.role_panel) .constrain("front", "Fixed") .addS(self.surface_s3(front=False), name="back", material=self.mat_panel, role=self.role_panel) .constrain("front@faces@>Z", "back@faces@ Cq.Assembly(): if parts is None: parts = ["root", "s0", "shoulder", "s1", "elbow", "s2", "wrist", "s3"] result = ( Cq.Assembly() ) tag_top, tag_bot = "top", "bot" if self.flip: tag_top, tag_bot = tag_bot, tag_top if "s0" in parts: result.add(self.assembly_s0(), name="s0") if "root" in parts: result.addS(self.root_joint.assembly( offset=root_offset, fastener_pos=fastener_pos, ), name="root") result.constrain("root/parent", "Fixed") if "s0" in parts and "root" in parts: ( result .constrain("s0/base?conn0", "root/child?conn0", "Plane", param=0) .constrain("s0/base?conn1", "root/child?conn1", "Plane", param=0) .constrain("s0/base?conn2", "root/child?conn2", "Plane", param=0) ) if "shoulder" in parts: result.add(self.shoulder_joint.assembly( fastener_pos=fastener_pos, deflection=shoulder_deflection * 80), name="shoulder") if "s0" in parts and "shoulder" in parts: ( result .constrain(f"s0/shoulder?conn_top0", f"shoulder/parent_{tag_top}/lip?conn0", "Plane") .constrain(f"s0/shoulder?conn_top1", f"shoulder/parent_{tag_top}/lip?conn1", "Plane") .constrain(f"s0/shoulder?conn_bot0", f"shoulder/parent_{tag_bot}/lip?conn0", "Plane") .constrain(f"s0/shoulder?conn_bot1", f"shoulder/parent_{tag_bot}/lip?conn1", "Plane") ) if "s1" in parts: result.add(self.assembly_s1(), name="s1") if "s1" in parts and "shoulder" in parts: ( result .constrain("s1/shoulder_top?conn0", f"shoulder/child/lip_{tag_top}?conn0", "Plane") .constrain("s1/shoulder_top?conn1", f"shoulder/child/lip_{tag_top}?conn1", "Plane") .constrain("s1/shoulder_bot?conn0", f"shoulder/child/lip_{tag_bot}?conn0", "Plane") .constrain("s1/shoulder_bot?conn1", f"shoulder/child/lip_{tag_bot}?conn1", "Plane") ) if "elbow" in parts: angle = self.elbow_joint.disk_joint.movement_angle * elbow_wrist_deflection result.add(self.elbow_joint.assembly(angle=angle), name="elbow") if "s1" in parts and "elbow" in parts: ( result .constrain("s1/elbow_top?conn0", f"elbow/parent_upper/lip?conn_{tag_top}0", "Plane") .constrain("s1/elbow_top?conn1", f"elbow/parent_upper/lip?conn_{tag_top}1", "Plane") .constrain("s1/elbow_bot?conn0", f"elbow/parent_upper/lip?conn_{tag_bot}0", "Plane") .constrain("s1/elbow_bot?conn1", f"elbow/parent_upper/lip?conn_{tag_bot}1", "Plane") ) if "s2" in parts: result.add(self.assembly_s2(), name="s2") if "s2" in parts and "elbow" in parts: ( result .constrain("s2/elbow_top?conn0", f"elbow/child/lip?conn_{tag_top}0", "Plane") .constrain("s2/elbow_top?conn1", f"elbow/child/lip?conn_{tag_top}1", "Plane") .constrain("s2/elbow_bot?conn0", f"elbow/child/lip?conn_{tag_bot}0", "Plane") .constrain("s2/elbow_bot?conn1", f"elbow/child/lip?conn_{tag_bot}1", "Plane") ) if "wrist" in parts: angle = self.wrist_joint.disk_joint.movement_angle * elbow_wrist_deflection result.add(self.wrist_joint.assembly(angle=angle), name="wrist") if "s2" in parts and "wrist" in parts: # Mounted backwards to bend in other direction ( result .constrain("s2/wrist_top?conn0", f"wrist/parent_upper/lip?conn_{tag_bot}0", "Plane") .constrain("s2/wrist_top?conn1", f"wrist/parent_upper/lip?conn_{tag_bot}1", "Plane") .constrain("s2/wrist_bot?conn0", f"wrist/parent_upper/lip?conn_{tag_top}0", "Plane") .constrain("s2/wrist_bot?conn1", f"wrist/parent_upper/lip?conn_{tag_top}1", "Plane") ) if "s3" in parts: result.add(self.assembly_s3(), name="s3") if "s3" in parts and "wrist" in parts: ( result .constrain("s3/wrist_top?conn0", f"wrist/child/lip?conn_{tag_bot}0", "Plane") .constrain("s3/wrist_top?conn1", f"wrist/child/lip?conn_{tag_bot}1", "Plane") .constrain("s3/wrist_bot?conn0", f"wrist/child/lip?conn_{tag_top}0", "Plane") .constrain("s3/wrist_bot?conn1", f"wrist/child/lip?conn_{tag_top}1", "Plane") ) if len(parts) > 1: result.solve() return result @dataclass(kw_only=True) class WingR(WingProfile): """ Right side wings """ elbow_bot_loc: Cq.Location = Cq.Location.from2d(290.0, 30.0, 27.0) elbow_height: float = 111.0 wrist_bot_loc: Cq.Location = Cq.Location.from2d(403.0, 289.0, 45.0) wrist_height: float = 60.0 # Extends from the wrist to the tip of the arrow arrow_height: float = 300 arrow_angle: float = -8 # Relative (in wrist coordinate) centre of the ring ring_rel_loc: Cq.Location = Cq.Location.from2d(45.0, 25.0) ring_radius_inner: float = 22.0 def __post_init__(self): super().__post_init__() assert self.arrow_angle < 0, "Arrow angle cannot be positive" self.arrow_bot_loc = self.wrist_bot_loc \ * Cq.Location.from2d(0, -self.arrow_height) self.arrow_other_loc = self.arrow_bot_loc \ * Cq.Location.rot2d(self.arrow_angle) \ * Cq.Location.from2d(0, self.arrow_height + self.wrist_height) self.ring_loc = self.wrist_top_loc * self.ring_rel_loc assert self.ring_radius > self.ring_radius_inner @property def ring_radius(self) -> float: (dx, dy), _ = self.ring_rel_loc.to2d() return (dx * dx + dy * dy) ** 0.5 def profile(self) -> Cq.Sketch: """ Net profile of the wing starting from the wing root with no divisions """ result = ( Cq.Sketch() .segment( (0, 0), (0, self.shoulder_joint.height), tag="shoulder") .spline([ (0, self.shoulder_joint.height), self.elbow_top_loc.to2d_pos(), self.wrist_top_loc.to2d_pos(), ], tag="s1_top") #.segment( # (self.wrist_x, self.wrist_y), # (wrist_top_x, wrist_top_y), # tag="wrist") .spline([ (0, 0), self.elbow_bot_loc.to2d_pos(), self.wrist_bot_loc.to2d_pos(), ], tag="s1_bot") ) result = ( result .segment( self.wrist_bot_loc.to2d_pos(), self.arrow_bot_loc.to2d_pos(), ) .segment( self.arrow_bot_loc.to2d_pos(), self.arrow_other_loc.to2d_pos(), ) .segment( self.arrow_other_loc.to2d_pos(), self.wrist_top_loc.to2d_pos(), ) ) # Carve out the ring result = result.assemble() result = ( result .push([self.ring_loc.to2d_pos()]) .circle(self.ring_radius, mode='a') .circle(self.ring_radius_inner, mode='s') .clean() ) return result def _mask_elbow(self) -> list[Tuple[float, float]]: l = 200 elbow_x, _ = self.elbow_bot_loc.to2d_pos() elbow_top_x, _ = self.elbow_top_loc.to2d_pos() return [ (0, -l), (elbow_x, -l), self.elbow_bot_loc.to2d_pos(), self.elbow_top_loc.to2d_pos(), (elbow_top_x, l), (0, l) ] def _mask_wrist(self) -> list[Tuple[float, float]]: l = 200 wrist_x, _ = self.wrist_bot_loc.to2d_pos() _, wrist_top_y = self.wrist_top_loc.to2d_pos() return [ (0, -l), (wrist_x, -l), self.wrist_bot_loc.to2d_pos(), self.wrist_top_loc.to2d_pos(), #(self.wrist_top_x, self.wrist_top_y), (0, wrist_top_y), ] @dataclass(kw_only=True) class WingL(WingProfile): elbow_bot_loc: Cq.Location = Cq.Location.from2d(250.0, 110.0, 10.0) elbow_height: float = 80.0 wrist_angle: float = -45.0 wrist_bot_loc: Cq.Location = Cq.Location.from2d(480.0, 0.0, -45.0) wrist_height: float = 43.0 shoulder_bezier_ext: float = 120.0 shoulder_bezier_drop: float = 15.0 elbow_bezier_ext: float = 80.0 wrist_bezier_ext: float = 30.0 arrow_length: float = 135.0 arrow_height: float = 120.0 flip: bool = True def __post_init__(self): assert self.wrist_height <= self.shoulder_joint.height self.wrist_bot_loc = self.wrist_bot_loc.with_angle_2d(self.wrist_angle) self.elbow_joint.angle_neutral = 15.0 self.elbow_rotate = 5.0 self.wrist_joint.angle_neutral = self.wrist_bot_loc.to2d_rot() + 30.0 self.wrist_rotate = -self.wrist_joint.angle_neutral super().__post_init__() def arrow_to_abs(self, x, y) -> Tuple[float, float]: rel = Cq.Location.from2d(x * self.arrow_length, y * self.arrow_height / 2 + self.wrist_height / 2) return (self.wrist_bot_loc * rel).to2d_pos() def profile(self) -> Cq.Sketch: result = ( Cq.Sketch() .segment( (0,0), (0, self.shoulder_height) ) .bezier([ (0, 0), (self.shoulder_bezier_ext, -self.shoulder_bezier_drop), (self.elbow_bot_loc * Cq.Location.from2d(-self.elbow_bezier_ext, 0)).to2d_pos(), self.elbow_bot_loc.to2d_pos(), ]) .bezier([ (0, self.shoulder_joint.height), (self.shoulder_bezier_ext, self.shoulder_joint.height), (self.elbow_top_loc * Cq.Location.from2d(-self.elbow_bezier_ext, 0)).to2d_pos(), self.elbow_top_loc.to2d_pos(), ]) .bezier([ self.elbow_bot_loc.to2d_pos(), (self.elbow_bot_loc * Cq.Location.from2d(self.elbow_bezier_ext, 0)).to2d_pos(), (self.wrist_bot_loc * Cq.Location.from2d(-self.wrist_bezier_ext, 0)).to2d_pos(), self.wrist_bot_loc.to2d_pos(), ]) .bezier([ self.elbow_top_loc.to2d_pos(), (self.elbow_top_loc * Cq.Location.from2d(self.elbow_bezier_ext, 0)).to2d_pos(), (self.wrist_top_loc * Cq.Location.from2d(-self.wrist_bezier_ext, 0)).to2d_pos(), self.wrist_top_loc.to2d_pos(), ]) ) # arrow base positions base_u, base_v = 0.3, 0.3 result = ( result .bezier([ self.wrist_top_loc.to2d_pos(), (self.wrist_top_loc * Cq.Location.from2d(self.wrist_bezier_ext, 0)).to2d_pos(), self.arrow_to_abs(base_u, base_v), ]) .bezier([ self.wrist_bot_loc.to2d_pos(), (self.wrist_bot_loc * Cq.Location.from2d(self.wrist_bezier_ext, 0)).to2d_pos(), self.arrow_to_abs(base_u, -base_v), ]) ) # Create the arrow arrow_beziers = [ [ (0, 1), (0.3, 1), (0.8, .2), (1, 0), ], [ (0, 1), (0.1, 0.8), (base_u, base_v), ] ] arrow_beziers = [ l2 for l in arrow_beziers for l2 in [l, [(x, -y) for x,y in l]] ] for line in arrow_beziers: result = result.bezier([self.arrow_to_abs(x, y) for x,y in line]) return result.assemble() def _mask_elbow(self) -> list[Tuple[float, float]]: l = 200 elbow_bot_x, _ = self.elbow_bot_loc.to2d_pos() elbow_top_x, _ = self.elbow_top_loc.to2d_pos() return [ (0, -l), (elbow_bot_x, -l), self.elbow_bot_loc.to2d_pos(), self.elbow_top_loc.to2d_pos(), (elbow_top_x, l), (0, l) ] def _mask_wrist(self) -> list[Tuple[float, float]]: l = 200 elbow_bot_x, _ = self.elbow_bot_loc.to2d_pos() _, elbow_top_y = self.elbow_top_loc.to2d_pos() _, wrist_bot_y = self.wrist_bot_loc.to2d_pos() return [ (0, -l), (elbow_bot_x, wrist_bot_y), self.wrist_bot_loc.to2d_pos(), self.wrist_top_loc.to2d_pos(), (elbow_bot_x, elbow_top_y + l), (0, l), ]