Cosplay/nhf/touhou/houjuu_nue/wing.py

"""
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
    # 1/4" acrylic for the spacer. Anything thinner would threathen structural
    # strength
    spacer_thickness: float = 25.4 / 4

    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

    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)
        if self.flip:
            self.wrist_axle_loc = self.wrist_bot_loc * Cq.Location.from2d(0, self.wrist_height / 2)
        else:
            self.wrist_axle_loc = self.wrist_bot_loc

        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@<Z", "Point",
            #           param=self.shoulder_joint.height)
            .addS(self.outer_shell_s0(), name="outer_shell",
                  material=self.mat_panel, role=self.role_panel)
            .constrain("bot?corner", "outer_shell?bot", "Plane", param=0)
            .constrain("top?corner", "outer_shell?top", "Plane", param=0)
        )
        for o, tag in [
                (self.spacer_s0_shoulder().generate(), "shoulder"),
                (self.spacer_s0_base().generate(), "base"),
                (self.spacer_s0_mid3().generate(), "mid3"),
                (self.spacer_s0_mid2().generate(), "mid2"),
        ]:
            top_tag, bot_tag = "top", "bot"
            if self.flip:
                top_tag, bot_tag = bot_tag, top_tag
            (
                result
                .addS(o, name=tag,
                      role=Role.STRUCTURE | Role.CONNECTION,
                      material=self.mat_bracket)
                .constrain(f"{tag}?{bot_tag}", f"bot?{tag}", "Plane")
                .constrain(f"{tag}?{top_tag}", f"top?{tag}", "Plane")
                .constrain(f"{tag}?dir", f"top?{tag}_dir", "Axis")
            )
        return result.solve()


    ### s1, s2, s3 ###
    def profile(self) -> Cq.Sketch:
        """
        Generates profile from shoulder and above. Subclass should implement
        """
    @target(name="profile-s3-extra", kind=TargetKind.DXF)
    def profile_s3_extra(self) -> Optional[Cq.Sketch]:
        """
        Extra element to be glued on s3. Not needed for left side
        """
        return None

    def _elbow_joint_retract_cut_polygon(self, loc: Cq.Location) -> Cq.Sketch:
        """
        Creates a cutting polygon for removing the contraction part of a joint
        """
        theta = math.radians(self.elbow_joint.motion_span)
        h = self.elbow_height
        dx = h * math.tan(theta / 2)
        dy = h
        sign = -1 if self.flip else 1
        points = [
            (0, 0),
            (dx, sign * dy),
            (-dx, sign * dy),
        ]
        return (
            Cq.Sketch()
            .polygon([
                (loc * Cq.Location.from2d(*p)).to2d_pos()
                for p in points
            ])
        )
    def _wrist_joint_retract_cut_polygon(self, loc: Cq.Location) -> Optional[Cq.Sketch]:
        """
        Creates a cutting polygon for removing the contraction part of a joint
        """
        if not self.flip:
            """
            No cutting needed on RHS
            """
            return None
        theta = math.radians(self.wrist_joint.motion_span)
        dx = self.wrist_height * math.tan(theta)
        dy = self.wrist_height
        sign = -1 if self.flip else 1
        points = [
            (0, 0),
            (0, -sign * dy),
            (-dx, -sign * dy),
        ]
        return (
            Cq.Sketch()
            .polygon([
                (loc * Cq.Location.from2d(*p)).to2d_pos()
                for p in points
            ])
        )
    def _joint_extension_profile(
            self,
            axle_loc: Cq.Location,
            radius: float,
            angle_span: float,
            bot: bool = False) -> Cq.Sketch:
        """
        Creates a sector profile which accomodates extension
        """
        sign = -1 if bot else 1
        axle_loc = axle_loc * Cq.Location.rot2d(-90 if bot else 90)
        loc_h = Cq.Location.from2d(radius, 0)
        start = axle_loc * loc_h
        mid = axle_loc * Cq.Location.rot2d(-sign * angle_span/2) * loc_h
        end = axle_loc * Cq.Location.rot2d(-sign * angle_span) * loc_h
        return (
            Cq.Sketch()
            .segment(
                axle_loc.to2d_pos(),
                start.to2d_pos(),
            )
            .arc(
                start.to2d_pos(),
                mid.to2d_pos(),
                end.to2d_pos(),
            )
            .segment(
                end.to2d_pos(),
                axle_loc.to2d_pos(),
            )
            .assemble()
        )


    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) -> 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')
            .reset()
            .push([self.elbow_axle_loc])
            .each(self._elbow_joint_retract_cut_polygon, mode='s')
        )
        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)
    @target(name="profile-s1-bridge", kind=TargetKind.DXF)
    def profile_s1_bridge(self) -> Cq.Workplane:
        return (
            self.profile()
            #.reset()
            #.polygon(self._mask_elbow(), mode='i')
            .reset()
            .push([self.elbow_axle_loc])
            .each(self._elbow_joint_retract_cut_polygon, mode='i')
            .reset()
            .push([self.elbow_axle_loc])
            .each(lambda loc: self._joint_extension_profile(
                axle_loc=self.elbow_axle_loc,
                radius=self.elbow_height / 2,
                angle_span=self.elbow_joint.motion_span,
                bot=not self.flip,
            ), mode='a')
        )
    def surface_s1_bridge(self, front: bool = True) -> Cq.Workplane:
        profile = self.profile_s1_bridge()
        loc_elbow = Cq.Location.rot2d(self.elbow_rotate) * self.elbow_joint.parent_arm_loc()
        tags = [
            ("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)),
        ]
        return extrude_with_markers(
            profile, self.panel_thickness, tags, reverse=not 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@<Z", "Point",
                       param=self.s1_thickness)
            .addS(self.surface_s1_bridge(front=True), name="bridge_front",
                  material=self.mat_panel, role=self.role_panel)
            .constrain("front?elbow_bot", "bridge_front?elbow_bot", "Plane")
            .constrain("front?elbow_top", "bridge_front?elbow_top", "Plane")
            .addS(self.surface_s1_bridge(front=False), name="bridge_back",
                  material=self.mat_panel, role=self.role_panel)
            .constrain("back?elbow_bot", "bridge_back?elbow_bot", "Plane")
            .constrain("back?elbow_top", "bridge_back?elbow_top", "Plane")
        )
        for t in ["shoulder_bot", "shoulder_top", "elbow_bot", "elbow_top"]:
            is_top = t.endswith("_top")
            is_parent = t.startswith("shoulder")
            o = self.spacer_s1_shoulder().generate() if is_parent else self.spacer_s1_elbow().generate()
            self._assembly_insert_spacer(
                result,
                o,
                point_tag=t,
                flipped=not is_top,
            )
        return result.solve()

    @target(name="profile-s2", kind=TargetKind.DXF)
    def profile_s2(self) -> Cq.Sketch:
        profile = (
            self.profile()
            .reset()
            .polygon(self._mask_elbow(), mode='s')
            .reset()
            .polygon(self._mask_wrist(), mode='i')
            .reset()
            .push([self.elbow_axle_loc])
            .each(self._elbow_joint_retract_cut_polygon, mode='s')
        )
        if self.flip:
            profile = (
                profile
                .reset()
                .push([self.wrist_axle_loc])
                .each(self._wrist_joint_retract_cut_polygon, mode='s')
            )
        return profile
    def surface_s2(self, front: bool = True) -> Cq.Workplane:
        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)),
        ]
        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)
    @target(name="profile-s2-bridge", kind=TargetKind.DXF)
    def profile_s2_bridge(self) -> Cq.Workplane:
        # Generates the extension profile, which is required on both sides
        profile = self._joint_extension_profile(
            axle_loc=self.wrist_axle_loc,
            radius=self.wrist_height * (0.5 if self.flip else 1),
            angle_span=self.wrist_joint.motion_span,
            bot=self.flip,
        )
        # Generates the contraction (cut) profile. only required on the left
        if self.flip:
            extra = (
                self.profile()
                .reset()
                .push([self.wrist_axle_loc])
                .each(self._wrist_joint_retract_cut_polygon, mode='i')
            )
            profile = (
                profile
                .push([self.wrist_axle_loc])
                .each(lambda _: extra, mode='a')
            )
        return profile
    def surface_s2_bridge(self, front: bool = True) -> Cq.Workplane:
        profile = self.profile_s2_bridge()
        loc_wrist = Cq.Location.rot2d(self.wrist_rotate) * self.wrist_joint.parent_arm_loc()
        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)),
        ]
        return extrude_with_markers(
            profile, self.panel_thickness, tags, reverse=not 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@<Z", "Point",
                       param=self.s1_thickness)
            .addS(self.surface_s2_bridge(front=True), name="bridge_front",
                  material=self.mat_panel, role=self.role_panel)
            .constrain("front?wrist_bot", "bridge_front?wrist_bot", "Plane")
            .constrain("front?wrist_top", "bridge_front?wrist_top", "Plane")
            .addS(self.surface_s2_bridge(front=False), name="bridge_back",
                  material=self.mat_panel, role=self.role_panel)
            .constrain("back?wrist_bot", "bridge_back?wrist_bot", "Plane")
            .constrain("back?wrist_top", "bridge_back?wrist_top", "Plane")
        )
        for t in ["elbow_bot", "elbow_top", "wrist_bot", "wrist_top"]:
            is_top = t.endswith("_top")
            is_parent = t.startswith("elbow")
            o = self.spacer_s2_elbow() if is_parent else self.spacer_s2_wrist()
            self._assembly_insert_spacer(
                result,
                o.generate(),
                point_tag=t,
                flipped=is_top == is_parent,
                #rotate=not is_parent,
            )
        return result.solve()

    @target(name="profile-s3", kind=TargetKind.DXF)
    def profile_s3(self) -> Cq.Sketch:
        profile = (
            self.profile()
            .reset()
            .polygon(self._mask_wrist(), mode='s')
        )
        return profile
    def surface_s3(self,
                   front: bool = True) -> Cq.Workplane:
        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)
    def surface_s3_extra(self,
                         front: bool = True) -> Optional[Cq.Workplane]:
        profile = self.profile_s3_extra()
        if profile is None:
            return None
        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)),
        ]
        return extrude_with_markers(profile, self.panel_thickness, tags, reverse=not 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@<Z", "Point",
                       param=self.s1_thickness)
        )
        if not self.flip:
            (
                result
                .addS(self.surface_s3_extra(front=True), name="extra_front",
                      material=self.mat_panel, role=self.role_panel)
                .constrain("front?wrist_bot", "extra_front?wrist_bot", "Plane")
                .constrain("front?wrist_top", "extra_front?wrist_top", "Plane")
                .addS(self.surface_s3_extra(front=False), name="extra_back",
                      material=self.mat_panel, role=self.role_panel)
                .constrain("back?wrist_bot", "extra_back?wrist_bot", "Plane")
                .constrain("back?wrist_top", "extra_back?wrist_top", "Plane")
            )
        for t in ["wrist_bot", "wrist_top"]:
            is_top = t.endswith("_top")
            o = self.spacer_s3_wrist()
            self._assembly_insert_spacer(
                result,
                o.generate(),
                point_tag=t,
                flipped=is_top,
            )
        return result.solve()

    @assembly()
    def assembly(self,
                 parts: Optional[list[str]] = None,
                 shoulder_deflection: float = 0.0,
                 elbow_wrist_deflection: float = 0.0,
                 root_offset: int = 5,
                 fastener_pos: float = 0.0,
                 ) -> 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:
            angle = shoulder_deflection * self.shoulder_joint.angle_max_deflection
            result.add(self.shoulder_joint.assembly(
                fastener_pos=fastener_pos,
                deflection=angle), 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.motion_span * 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.motion_span * 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

    # Underapproximate the wrist tangent angle to leave no gaps on the blade
    blade_wrist_approx_tangent_angle: float = 40.0
    blade_overlap_arrow_height: float = 5.0
    # Some overlap needed to glue the two sides
    blade_overlap_angle: float = -1
    blade_hole_angle: float = 3
    blade_hole_diam: float = 12.0
    blade_hole_heights: list[float] = field(default_factory=lambda: [230, 260])
    blade_angle: float = 7

    # 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

    flip: bool = False

    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

        assert 0 > self.blade_overlap_angle > self.arrow_angle
        assert 0 < self.blade_hole_angle < self.blade_angle
        assert self.blade_wrist_approx_tangent_angle <= self.wrist_bot_loc.to2d_rot()

    @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 profile_s3_extra(self) -> Cq.Sketch:
        """
        Implements the blade part on Nue's wing
        """
        left_bot_loc = self.arrow_bot_loc * Cq.Location.rot2d(-1)
        hole_bot_loc = self.arrow_bot_loc * Cq.Location.rot2d(self.blade_hole_angle)
        right_bot_loc = self.arrow_bot_loc * Cq.Location.rot2d(self.blade_angle)
        h_loc = Cq.Location.from2d(0, self.arrow_height + self.blade_overlap_arrow_height)

        # Law of sines, uses the triangle of (wrist_bot_loc, arrow_bot_loc, ?)
        theta_wp = math.radians(90 - self.blade_wrist_approx_tangent_angle)
        theta_b = math.radians(self.blade_angle)
        h_blade = math.sin(theta_wp) / math.sin(math.pi - theta_b - theta_wp) * self.arrow_height
        h_blade_loc = Cq.Location.from2d(0, h_blade)
        return (
            Cq.Sketch()
            .segment(
                self.arrow_bot_loc.to2d_pos(),
                (left_bot_loc * h_loc).to2d_pos(),
            )
            .segment(
                (self.arrow_bot_loc * h_loc).to2d_pos(),
            )
            .segment(
                (right_bot_loc * h_blade_loc).to2d_pos(),
            )
            .close()
            .assemble()
            .reset()
            .push([
                (hole_bot_loc * Cq.Location.from2d(0, h)).to2d_pos()
                for h in self.blade_hole_heights
            ])
            .circle(self.blade_hole_diam / 2, mode='s')
        )


    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(260.0, 110.0, 0.0)
    elbow_height: float = 80.0

    wrist_angle: float = -45.0
    wrist_bot_loc: Cq.Location = Cq.Location.from2d(460.0, -10.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_x, elbow_top_y = self.elbow_top_loc.to2d_pos()
        _, wrist_bot_y = self.wrist_bot_loc.to2d_pos()
        wrist_top_x, wrist_top_y = self.wrist_top_loc.to2d_pos()
        return [
            (0, -l),
            (elbow_bot_x, wrist_bot_y),
            self.wrist_bot_loc.to2d_pos(),
            self.wrist_top_loc.to2d_pos(),
            (wrist_top_x, wrist_top_y + l),
            (elbow_top_x, elbow_top_y + l),
            (0, l),
        ]