Merge branch 'main' into touhou/houjuu-nue

fix: `Cq.Location.to2d_rot()` signature

README.md

@@ -1,7 +1,6 @@
 # Cosplay
 
-This is the design repository for NorCal Hakkero Factory No. 1, where we use
-parametric CAD to make cosplay props.
+This is the design repository for NorCal Hakkero Factory No. 1.
 
 ## Development
 
@@ -16,12 +15,6 @@ and this should succeed
 python3 -c "import nhf"
 ```
 
-To visualize an object, create a file `visualize.py`, and run `cq-editor`:
-
-``` sh
-python3 -m cq_editor visualize.py
-```
-
 ## Testing
 
 Run all tests with

nhf/build.py

@@ -90,7 +90,7 @@ class Target:
                 x = (
                     Cq.Workplane()
                     .add(x._faces)
-                    .add(x.wires)
+                    .add(x._wires)
                     .add(x._edges)
                 )
             assert isinstance(x, Cq.Workplane)
@@ -214,7 +214,7 @@ class Submodel:
     def write_to(self, obj, path: str):
         x = self._method(obj)
         assert isinstance(x, Model), f"Unexpected type: {type(x)}"
-        x.build_all(path, prefix=False)
+        x.build_all(path)
 
     @classmethod
     def methods(cls, subject):
@@ -271,17 +271,11 @@ class Model:
             total += 1
         return total
 
-    def build_all(
-            self,
-            output_dir: Union[Path, str] = "build",
-            prefix: bool = True,
-            verbose=1):
+    def build_all(self, output_dir: Union[Path, str] = "build", verbose=1):
         """
         Build all targets in this model and write the results to file
         """
         output_dir = Path(output_dir)
-        if prefix:
-            output_dir = output_dir / self.name
         targets = Target.methods(self)
         for t in targets.values():
             file_name = t.file_name

nhf/primitive.py

@@ -1,12 +0,0 @@
-import cadquery as Cq
-
-def mystery():
-    return (
-        Cq.Workplane("XY")
-        .box(10, 5, 5)
-        .faces(">Z")
-        .workplane()
-        .hole(1)
-        .edges("|Z")
-        .fillet(2)
-    )

nhf/tool/light_panel.py

@@ -1,146 +0,0 @@
-from dataclasses import dataclass
-import cadquery as Cq
-from nhf import Material, Role
-from nhf.build import Model, target, assembly, TargetKind, submodel
-from nhf.parts.box import MountingBox, Hole
-from nhf.parts.electronics import ArduinoUnoR3
-import nhf.utils
-
-@dataclass
-class LightPanel(Model):
-
-    # Dimensions of the base panel
-    length: float = 300.0
-    width: float = 200.0
-
-    attach_height: float = 20.0
-    attach_diam: float = 8.0
-    attach_depth: float = 12.7
-
-    grid_height: float = 20.0
-    grid_top_height: float = 5.0
-    # Distance from grid to edge
-    grid_margin: float = 20.0
-    # Number of holes in each row of the grid
-    grid_holes: int = 9
-    grid_layers: int = 6
-    grid_hole_width: float = 15.0
-
-    base_thickness: float = 25.4/16
-    grid_thickness: float = 25.4/4
-    base_material: Material = Material.WOOD_BIRCH
-    grid_material: Material = Material.ACRYLIC_TRANSPARENT
-
-    controller: ArduinoUnoR3 = ArduinoUnoR3()
-
-    def __post_init__(self):
-        assert self.grid_holes >= 2
-        super().__init__(name="light-panel")
-
-    @property
-    def grid_spacing_y(self) -> float:
-        return (self.width - 2 * self.grid_margin - self.grid_thickness) / (self.grid_layers - 1)
-
-    @target(name="grid", kind=TargetKind.DXF)
-    def grid_profile(self):
-        w = self.length - self.grid_margin * 2
-        h = self.grid_height + self.grid_top_height
-
-        # The width of one hole (w0) satisfies
-        # n * w0 + (n+1) t = w
-        # where t is the thickness of the edge
-        n = self.grid_holes
-        w0 = self.grid_hole_width
-        t = (w - n * w0) / (n + 1)
-        # The spacing is such that the first and last holes are a distance `margin`
-        # away from the edges, so it satisfies
-        # t + w0/2 + (n-1) * s + w0/2 + t = w
-        step = (w - t*2 - w0) / (n - 1)
-        return (
-            Cq.Sketch()
-            .push([(0, h/2)])
-            .rect(w, h)
-            .push([
-                (i * step + t + w0/2 - w/2, self.grid_height/2)
-                for i in range(0, n)
-            ])
-            .rect(w0, self.grid_height, mode='s')
-        )
-
-    def grid(self) -> Cq.Workplane:
-        return (
-            Cq.Workplane('XY')
-            .placeSketch(self.grid_profile())
-            .extrude(self.grid_thickness)
-        )
-
-    @submodel(name="base")
-    def base(self) -> MountingBox:
-        xshift = self.length / 2 - self.controller.length - self.grid_margin / 2
-        yshift = self.grid_margin / 2
-        holes = [
-            Hole(
-                x=x + xshift, y=y + yshift,
-                diam=self.controller.hole_diam,
-                tag=f"controller_conn{i}",
-            )
-            for i, (x, y) in enumerate(self.controller.holes)
-        ]
-        return MountingBox(
-            holes=holes,
-            hole_diam=self.controller.hole_diam,
-            length=self.length,
-            width=self.width,
-            centred=(True, False),
-            thickness=self.base_thickness,
-        )
-
-    @target(name="attachment")
-    def attachment(self) -> Cq.Workplane:
-        l = self.length / 2
-        w = self.width / 2
-        return (
-            Cq.Workplane('XY')
-            .box(
-                l, w, self.attach_height,
-                centered=(True, True, False),
-            )
-            .faces(">Z")
-            .hole(self.attach_diam, self.attach_depth)
-        )
-
-
-    def assembly(self) -> Cq.Assembly:
-        assembly = (
-            Cq.Assembly()
-            .addS(
-                self.base().generate(),
-                name="base",
-                role=Role.STRUCTURE,
-                material=self.base_material,
-            )
-        )
-        # Grid thickness t is fixed, so the spacing of the grid satisfies
-        # margin + t + (n-1) * spacing + margin = width
-        spacing = self.grid_spacing_y
-        shift = self.grid_margin + self.grid_thickness / 2
-        for i in range(self.grid_layers):
-            assembly = assembly.addS(
-                self.grid(),
-                name=f"grid_{i}",
-                role=Role.STRUCTURE,
-                material=self.grid_material,
-                loc=Cq.Location(0, spacing * i + shift, self.base_thickness, 90, 0, 0),
-            )
-        return assembly
-
-
-if __name__ == '__main__':
-    import sys
-
-    p = LightPanel()
-    print(p.grid_spacing_y)
-
-    if len(sys.argv) == 1:
-        p.build_all()
-        sys.exit(0)

nhf/touhou/houjuu_nue/README.org

@@ -0,0 +1,14 @@
+#+title: Cosplay: Houjuu Nue
+
+* Controller
+
+This part describes the electrical connections and the microcontroller code.
+
+* Structure
+
+This part describes the 3d printed and laser cut structures. ~structure.blend~
+is an overall sketch of the shapes and looks of the wing.
+
+* Pattern
+
+This part describes the sewing patterns.

nhf/touhou/houjuu_nue/__init__.py

@@ -0,0 +1,204 @@
+"""
+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
+from typing import Optional
+import cadquery as Cq
+from nhf.build import Model, TargetKind, target, assembly, submodel
+import nhf.touhou.houjuu_nue.wing as MW
+import nhf.touhou.houjuu_nue.trident as MT
+import nhf.touhou.houjuu_nue.joints as MJ
+import nhf.touhou.houjuu_nue.harness as MH
+import nhf.touhou.houjuu_nue.electronics as ME
+from nhf.parts.item import Item
+import nhf.utils
+
+WING_DEFLECT_ODD = 0.0
+WING_DEFLECT_EVEN = 25.0
+@dataclass
+class Parameters(Model):
+    """
+    Defines dimensions for the Houjuu Nue cosplay
+    """
+
+    harness: MH.Harness = field(default_factory=lambda: MH.Harness())
+
+    wing_r1: MW.WingR = field(default_factory=lambda: MW.WingR(
+        name="r1",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(0,1,1,1),
+            parent_substrate_cull_edges=(0,0,1,0),
+        ),
+        shoulder_angle_bias=WING_DEFLECT_ODD,
+        s0_top_hole=False,
+        s0_bot_hole=True,
+        arrow_height=350.0
+    ))
+    wing_r2: MW.WingR = field(default_factory=lambda: MW.WingR(
+        name="r2",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(1,1,1,1),
+            parent_substrate_cull_edges=(0,0,1,0),
+        ),
+        electronic_board=ME.ElectronicBoardControl(),
+        shoulder_angle_bias=WING_DEFLECT_EVEN,
+        s0_top_hole=True,
+        s0_bot_hole=True,
+    ))
+    wing_r3: MW.WingR = field(default_factory=lambda: MW.WingR(
+        name="r3",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(1,1,1,0),
+            parent_substrate_cull_edges=(0,0,1,0),
+        ),
+        shoulder_angle_bias=WING_DEFLECT_ODD,
+        s0_top_hole=True,
+        s0_bot_hole=False,
+    ))
+    wing_l1: MW.WingL = field(default_factory=lambda: MW.WingL(
+        name="l1",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(1,0,1,1),
+            parent_substrate_cull_edges=(1,0,0,0),
+        ),
+        shoulder_angle_bias=WING_DEFLECT_EVEN,
+        wrist_angle=-60.0,
+        s0_top_hole=False,
+        s0_bot_hole=True,
+    ))
+    wing_l2: MW.WingL = field(default_factory=lambda: MW.WingL(
+        name="l2",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(1,1,1,1),
+            parent_substrate_cull_edges=(1,0,0,0),
+        ),
+        wrist_angle=-30.0,
+        shoulder_angle_bias=WING_DEFLECT_ODD,
+        s0_top_hole=True,
+        s0_bot_hole=True,
+    ))
+    wing_l3: MW.WingL = field(default_factory=lambda: MW.WingL(
+        name="l3",
+        root_joint=MJ.RootJoint(
+            parent_substrate_cull_corners=(1,1,0,1),
+            parent_substrate_cull_edges=(1,0,0,0),
+        ),
+        shoulder_angle_bias=WING_DEFLECT_EVEN,
+        wrist_angle=-0.0,
+        s0_top_hole=True,
+        s0_bot_hole=False,
+    ))
+
+    trident: MT.Trident = field(default_factory=lambda: MT.Trident())
+
+    def __post_init__(self):
+        super().__init__(name="houjuu-nue")
+
+    @submodel(name="harness")
+    def submodel_harness(self) -> Model:
+        return self.harness
+
+    @submodel(name="wing-r1")
+    def submodel_wing_r1(self) -> Model:
+        return self.wing_r1
+    @submodel(name="wing-r2")
+    def submodel_wing_r2(self) -> Model:
+        return self.wing_r2
+    @submodel(name="wing-r3")
+    def submodel_wing_r3(self) -> Model:
+        return self.wing_r3
+    @submodel(name="wing-l1")
+    def submodel_wing_l1(self) -> Model:
+        return self.wing_l1
+    @submodel(name="wing-l2")
+    def submodel_wing_l2(self) -> Model:
+        return self.wing_l2
+    @submodel(name="wing-l3")
+    def submodel_wing_l3(self) -> Model:
+        return self.wing_l3
+
+    @assembly()
+    def wings_harness_assembly(self,
+                               parts: Optional[list[str]] = None,
+                               **kwargs) -> Cq.Assembly:
+        """
+        Assembly of harness with all the wings
+        """
+        result = (
+            Cq.Assembly()
+            .add(self.harness.assembly(), name="harness", loc=Cq.Location((0, 0, 0)))
+            .add(self.wing_r1.assembly(parts, root_offset=9, **kwargs), name="wing_r1")
+            .add(self.wing_r2.assembly(parts, root_offset=7, **kwargs), name="wing_r2")
+            .add(self.wing_r3.assembly(parts, root_offset=6, **kwargs), name="wing_r3")
+            .add(self.wing_l1.assembly(parts, root_offset=19, **kwargs), name="wing_l1")
+            .add(self.wing_l2.assembly(parts, root_offset=20, **kwargs), name="wing_l2")
+            .add(self.wing_l3.assembly(parts, root_offset=21, **kwargs), name="wing_l3")
+        )
+        for tag in ["r1", "r2", "r3", "l1", "l2", "l3"]:
+            self.harness.add_root_joint_constraint(
+                result,
+                "harness/base",
+                f"wing_{tag}/root",
+                tag
+            )
+        return result.solve()
+
+    @submodel(name="trident")
+    def submodel_trident(self) -> Model:
+        return self.trident
+
+    def stat(self) -> dict[str, float]:
+        a = self.wings_harness_assembly()
+        bbox = a.toCompound().BoundingBox()
+        return {
+            "wing-span": bbox.xlen,
+            "wing-depth": bbox.ylen,
+            "wing-height": bbox.zlen,
+            "wing-mass": a.total_mass(),
+            "wing-centre-of-mass": a.centre_of_mass().toTuple(),
+            "items": Item.count(a),
+        }
+
+
+if __name__ == '__main__':
+    import sys
+
+    p = Parameters()
+    if len(sys.argv) == 1:
+        p.build_all()
+        sys.exit(0)
+
+    if sys.argv[1] == 'stat':
+        print(p.stat())
+    elif sys.argv[1] == 'model':
+        file_name = sys.argv[2]
+        a = p.wings_harness_assembly()
+        a.save(file_name, exportType='STEP')

nhf/touhou/houjuu_nue/common.py

@@ -0,0 +1,18 @@
+from nhf.parts.fasteners import FlatHeadBolt, HexNut, ThreaddedKnob
+
+NUT_COMMON = HexNut(
+    # FIXME: measure
+    mass=0.0,
+    diam_thread=4.0,
+    pitch=0.7,
+    thickness=3.2,
+    width=7.0,
+)
+BOLT_COMMON = FlatHeadBolt(
+    # FIXME: measure
+    mass=0.0,
+    diam_head=8.0,
+    height_head=2.0,
+    diam_thread=4.0,
+    height_thread=20.0,
+)

nhf/touhou/houjuu_nue/controller/controller.ino

@@ -0,0 +1,68 @@
+#include <FastLED.h>
+
+// Main LED strip setup
+#define LED_PIN 5
+#define NUM_LEDS 100
+#define LED_PART 50
+#define BRIGHTNESS 250
+#define LED_TYPE WS2811
+CRGB leds[NUM_LEDS];
+
+CRGB color_red;
+CRGB color_blue;
+CRGB color_green;
+
+#define DIAG_PIN 6
+
+
+void setup() {
+  // Calculate colors
+  hsv2rgb_spectrum(CHSV(4, 255, 100), color_red);
+  hsv2rgb_spectrum(CHSV(170, 255, 100), color_blue);
+  hsv2rgb_spectrum(CHSV(90, 255, 100), color_green);
+  pinMode(LED_BUILTIN, OUTPUT);
+  pinMode(LED_PIN, OUTPUT);
+  pinMode(DIAG_PIN, OUTPUT);
+  
+  // Main LED strip
+  FastLED.addLeds<LED_TYPE, LED_PIN, RGB>(leds, NUM_LEDS);
+}
+
+void loop() {
+  fill_segmented(CRGB::Green, CRGB::Orange);
+  delay(500);
+
+  flash(leds, NUM_LEDS, color_red, 10, 20);
+  delay(500);
+  flash(leds, NUM_LEDS, color_blue, 10, 20);
+  delay(500);
+}
+
+void fill_segmented(CRGB c1, CRGB c2)
+{
+  //fill_solid(leds, LED_PART, c1);
+  fill_gradient_RGB(leds, LED_PART, CRGB::Black ,c1);
+  fill_gradient_RGB(leds + LED_PART, NUM_LEDS - LED_PART, CRGB::Black, c2);
+  FastLED.show(); 
+}
+void flash(CRGB *ptr, uint16_t num, CRGB const& lead, int steps, int step_time)
+{
+  digitalWrite(LED_BUILTIN, LOW);
+
+  //fill_solid(leds, NUM_LEDS, CRGB::Black);
+  for (int i = 0; i < steps; ++i)
+  {
+    uint8_t factor = 255 * i / steps;
+    analogWrite(DIAG_PIN, factor);
+    CRGB tail = blend(lead, CRGB::Black, factor);
+    uint16_t front = factor * (int) num / 255;
+    fill_solid(ptr, front, tail);
+    //fill_gradient_RGB(ptr, front, tail, lead);
+    //fill_solid(leds + front, NUM_LEDS - front, CRGB::Black);
+    FastLED.show(); 
+    delay(step_time);
+  }
+  fill_gradient_RGB(ptr, num, CRGB::Black, lead);
+  FastLED.show(); 
+  analogWrite(DIAG_PIN, LOW);
+}

nhf/touhou/houjuu_nue/electronics.py

@@ -0,0 +1,540 @@
+"""
+Electronic components
+"""
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+import math
+import cadquery as Cq
+from nhf.build import Model, TargetKind, target, assembly, submodel
+from nhf.materials import Role, Material
+from nhf.parts.box import MountingBox, Hole
+from nhf.parts.fibre import tension_fibre
+from nhf.parts.item import Item
+from nhf.parts.fasteners import FlatHeadBolt, HexNut
+from nhf.parts.electronics import ArduinoUnoR3, BatteryBox18650
+from nhf.touhou.houjuu_nue.common import NUT_COMMON, BOLT_COMMON
+import nhf.utils
+
+@dataclass(frozen=True)
+class LinearActuator(Item):
+    stroke_length: float
+    shaft_diam: float = 9.04
+
+    front_hole_ext: float = 4.41
+    front_hole_diam: float = 4.41
+    front_length: float = 9.55
+    front_width: float = 9.24
+    front_height: float = 5.98
+
+    segment1_length: float = 37.54
+    segment1_width: float = 15.95
+    segment1_height: float = 11.94
+
+    segment2_length: float = 37.37
+    segment2_width: float = 20.03
+    segment2_height: float = 15.03
+
+    back_hole_ext: float = 4.58
+    back_hole_diam: float = 4.18
+    back_length: float = 9.27
+    back_width: float = 10.16
+    back_height: float = 8.12
+
+    @property
+    def name(self) -> str:
+        return f"LinearActuator {self.stroke_length}mm"
+
+    @property
+    def role(self) -> Role:
+        return Role.MOTION
+
+    @property
+    def conn_length(self):
+        return self.segment1_length + self.segment2_length + self.front_hole_ext + self.back_hole_ext
+
+    def generate(self, pos: float=0) -> Cq.Assembly:
+        assert -1e-6 <= pos <= 1 + 1e-6, f"Illegal position: {pos}"
+        stroke_x = pos * self.stroke_length
+        front = (
+            Cq.Workplane('XZ')
+            .cylinder(
+                radius=self.front_width / 2,
+                height=self.front_height,
+                centered=True,
+            )
+            .box(
+                length=self.front_hole_ext,
+                width=self.front_width,
+                height=self.front_height,
+                combine=True,
+                centered=(False, True, True)
+            )
+            .copyWorkplane(Cq.Workplane('XZ'))
+            .cylinder(
+                radius=self.front_hole_diam / 2,
+                height=self.front_height,
+                centered=True,
+                combine='cut',
+            )
+        )
+        front.copyWorkplane(Cq.Workplane('XZ')).tagPlane('conn')
+        if stroke_x > 0:
+            shaft = (
+                Cq.Workplane('YZ')
+                .cylinder(
+                    radius=self.shaft_diam / 2,
+                    height=stroke_x,
+                    centered=(True, True, False)
+                )
+            )
+        else:
+            shaft = None
+        segment1 = (
+            Cq.Workplane()
+            .box(
+                length=self.segment1_length,
+                height=self.segment1_width,
+                width=self.segment1_height,
+                centered=(False, True, True),
+            )
+        )
+        segment2 = (
+            Cq.Workplane()
+            .box(
+                length=self.segment2_length,
+                height=self.segment2_width,
+                width=self.segment2_height,
+                centered=(False, True, True),
+            )
+        )
+        back = (
+            Cq.Workplane('XZ')
+            .cylinder(
+                radius=self.back_width / 2,
+                height=self.back_height,
+                centered=True,
+            )
+            .box(
+                length=self.back_hole_ext,
+                width=self.back_width,
+                height=self.back_height,
+                combine=True,
+                centered=(False, True, True)
+            )
+            .copyWorkplane(Cq.Workplane('XZ'))
+            .cylinder(
+                radius=self.back_hole_diam / 2,
+                height=self.back_height,
+                centered=True,
+                combine='cut',
+            )
+        )
+        back.faces(">X").tag("dir")
+        back.copyWorkplane(Cq.Workplane('XZ')).tagPlane('conn')
+        result = (
+            Cq.Assembly()
+            .add(front, name="front",
+                 loc=Cq.Location((-self.front_hole_ext, 0, 0)))
+            .add(segment1, name="segment1",
+                 loc=Cq.Location((stroke_x, 0, 0)))
+            .add(segment2, name="segment2",
+                 loc=Cq.Location((stroke_x + self.segment1_length, 0, 0)))
+            .add(back, name="back",
+                 loc=Cq.Location((stroke_x + self.segment1_length + self.segment2_length + self.back_hole_ext, 0, 0), (0, 1, 0), 180))
+        )
+        if shaft:
+            result.add(shaft, name="shaft")
+        return result
+
+@dataclass(frozen=True)
+class MountingBracket(Item):
+    """
+    Mounting bracket for a linear actuator
+    """
+    mass: float = 1.6
+    hole_diam: float = 4.0
+    width: float = 8.0
+    height: float = 12.20
+    thickness: float = 0.98
+    length: float = 13.00
+    hole_to_side_ext: float = 8.25
+
+    def __post_init__(self):
+        assert self.hole_to_side_ext - self.hole_diam / 2 > 0
+
+    @property
+    def name(self) -> str:
+        return f"MountingBracket M{int(self.hole_diam)}"
+
+    @property
+    def role(self) -> Role:
+        return Role.MOTION
+
+    def generate(self) -> Cq.Workplane:
+        result = (
+            Cq.Workplane('XY')
+            .box(
+                length=self.hole_to_side_ext,
+                width=self.width,
+                height=self.height,
+                centered=(False, True, True)
+            )
+            .copyWorkplane(Cq.Workplane('XY'))
+            .cylinder(
+                height=self.height,
+                radius=self.width / 2,
+                combine=True,
+            )
+            .copyWorkplane(Cq.Workplane('XY'))
+            .box(
+                length=2 * (self.hole_to_side_ext - self.thickness),
+                width=self.width,
+                height=self.height - self.thickness * 2,
+                combine='cut',
+            )
+            .copyWorkplane(Cq.Workplane('XY'))
+            .cylinder(
+                height=self.height,
+                radius=self.hole_diam / 2,
+                combine='cut'
+            )
+            .copyWorkplane(Cq.Workplane('YZ'))
+            .cylinder(
+                height=self.hole_to_side_ext * 2,
+                radius=self.hole_diam / 2,
+                combine='cut'
+            )
+        )
+        result.copyWorkplane(Cq.Workplane('YZ', origin=(self.hole_to_side_ext, 0, 0))).tagPlane("conn_side")
+        result.copyWorkplane(Cq.Workplane('XY', origin=(0, 0, self.height/2))).tagPlane("conn_top")
+        result.copyWorkplane(Cq.Workplane('YX', origin=(0, 0, -self.height/2))).tagPlane("conn_bot")
+        result.copyWorkplane(Cq.Workplane('XY')).tagPlane("conn_mid")
+        return result
+
+
+LINEAR_ACTUATOR_50 = LinearActuator(
+    mass=40.8,
+    stroke_length=50,
+    shaft_diam=9.05,
+    front_hole_ext=4.32,
+    back_hole_ext=4.54,
+    segment1_length=57.35,
+    segment1_width=15.97,
+    segment1_height=11.95,
+    segment2_length=37.69,
+    segment2_width=19.97,
+    segment2_height=14.96,
+
+    front_length=9.40,
+    front_width=9.17,
+    front_height=6.12,
+    back_length=9.18,
+    back_width=10.07,
+    back_height=8.06,
+)
+LINEAR_ACTUATOR_30 = LinearActuator(
+    mass=34.0,
+    stroke_length=30,
+)
+LINEAR_ACTUATOR_21 = LinearActuator(
+    # FIXME: Measure
+    mass=0.0,
+    stroke_length=21,
+    front_hole_ext=4,
+    back_hole_ext=4,
+    segment1_length=34,
+    segment2_length=34,
+)
+LINEAR_ACTUATOR_10 = LinearActuator(
+    mass=41.3,
+    stroke_length=10,
+    front_hole_ext=4.02,
+    back_hole_ext=4.67,
+    segment1_length=13.29,
+    segment1_width=15.88,
+    segment1_height=12.07,
+    segment2_length=42.52,
+    segment2_width=20.98,
+    segment2_height=14.84,
+)
+LINEAR_ACTUATOR_HEX_NUT = HexNut(
+    mass=0.8,
+    diam_thread=4,
+    pitch=0.7,
+    thickness=4.16,
+    width=6.79,
+)
+LINEAR_ACTUATOR_BOLT = FlatHeadBolt(
+    mass=1.7,
+    diam_head=6.68,
+    height_head=2.98,
+    diam_thread=4.0,
+    height_thread=15.83,
+)
+LINEAR_ACTUATOR_BRACKET = MountingBracket()
+
+BATTERY_BOX = BatteryBox18650()
+
+# Acrylic hex nut
+ELECTRONIC_MOUNT_HEXNUT = HexNut(
+    mass=0.8,
+    diam_thread=4,
+    pitch=0.7,
+    thickness=3.57,
+    width=6.81,
+)
+
+@dataclass(kw_only=True, frozen=True)
+class Winch:
+    linear_motion_span: float
+
+    actuator: LinearActuator = LINEAR_ACTUATOR_21
+    nut: HexNut = LINEAR_ACTUATOR_HEX_NUT
+    bolt: FlatHeadBolt = LINEAR_ACTUATOR_BOLT
+    bracket: MountingBracket = LINEAR_ACTUATOR_BRACKET
+
+@dataclass(kw_only=True)
+class Flexor:
+    """
+    Actuator assembly which flexes, similar to biceps
+    """
+    motion_span: float
+    arm_radius: Optional[float] = None
+    pos_smaller: bool = True
+
+    actuator: LinearActuator = LINEAR_ACTUATOR_50
+    nut: HexNut = LINEAR_ACTUATOR_HEX_NUT
+    bolt: FlatHeadBolt = LINEAR_ACTUATOR_BOLT
+    bracket: MountingBracket = LINEAR_ACTUATOR_BRACKET
+    # Length of line attached to the flexor
+    line_length: float = 0.0
+    line_thickness: float = 0.5
+    # By how much is the line permitted to slack. This reduces the effective stroke length
+    line_slack: float = 0.0
+
+    def __post_init__(self):
+        assert self.line_slack <= self.line_length, f"Insufficient length: {self.line_slack} >= {self.line_length}"
+        assert self.line_slack < self.actuator.stroke_length
+
+    @property
+    def mount_height(self):
+        return self.bracket.hole_to_side_ext
+
+    @property
+    def d_open(self):
+        return self.actuator.conn_length + self.actuator.stroke_length + self.line_length - self.line_slack
+    @property
+    def d_closed(self):
+        return self.actuator.conn_length + self.line_length
+
+    def open_pos(self) -> Tuple[float, float, float]:
+        r, phi, r_ = nhf.geometry.contraction_span_pos_from_radius(
+            d_open=self.d_open,
+            d_closed=self.d_closed,
+            theta=math.radians(self.motion_span),
+            r=self.arm_radius,
+            smaller=self.pos_smaller,
+        )
+        return r, math.degrees(phi), r_
+
+    def target_length_at_angle(
+            self,
+            angle: float = 0.0
+        ) -> float:
+        """
+        Length of the actuator at some angle
+        """
+        assert 0 <= angle <= self.motion_span
+        r, phi, rp = self.open_pos()
+        th = math.radians(phi - angle)
+
+        result = math.sqrt(r * r + rp * rp - 2 * r * rp * math.cos(th))
+        #result = math.sqrt((r * math.cos(th) - rp) ** 2 + (r * math.sin(th)) ** 2)
+        assert self.d_closed -1e-6 <= result <= self.d_open + 1e-6,\
+            f"Illegal length: {result} not in [{self.d_closed}, {self.d_open}]"
+        return result
+
+
+    def add_to(
+            self,
+            a: Cq.Assembly,
+            target_length: float,
+            tag_prefix: Optional[str] = None,
+            tag_hole_front: Optional[str] = None,
+            tag_hole_back: Optional[str] = None,
+            tag_dir: Optional[str] = None):
+        """
+        Adds the necessary mechanical components to this assembly. Does not
+        invoke `a.solve()`.
+        """
+        draft = max(0, target_length - self.d_closed - self.line_length)
+        pos = draft / self.actuator.stroke_length
+        line_l = target_length - draft - self.actuator.conn_length
+        if tag_prefix:
+            tag_prefix = tag_prefix + "_"
+        else:
+            tag_prefix = ""
+        name_actuator = f"{tag_prefix}actuator"
+        name_bracket_front = f"{tag_prefix}bracket_front"
+        name_bracket_back = f"{tag_prefix}bracket_back"
+        name_bolt_front = f"{tag_prefix}front_bolt"
+        name_bolt_back = f"{tag_prefix}back_bolt"
+        name_nut_front = f"{tag_prefix}front_nut"
+        name_nut_back = f"{tag_prefix}back_nut"
+        (
+            a
+            .add(self.actuator.assembly(pos=pos), name=name_actuator)
+            .add(self.bracket.assembly(), name=name_bracket_front)
+            .add(self.bolt.assembly(), name=name_bolt_front)
+            .add(self.nut.assembly(), name=name_nut_front)
+            .constrain(f"{name_bolt_front}?root", f"{name_bracket_front}?conn_top",
+                       "Plane", param=0)
+            .constrain(f"{name_nut_front}?bot", f"{name_bracket_front}?conn_bot",
+                       "Plane")
+            .add(self.bracket.assembly(), name=name_bracket_back)
+            .add(self.bolt.assembly(), name=name_bolt_back)
+            .add(self.nut.assembly(), name=name_nut_back)
+            .constrain(f"{name_actuator}/back?conn", f"{name_bracket_back}?conn_mid",
+                       "Plane", param=0)
+            .constrain(f"{name_bolt_back}?root", f"{name_bracket_back}?conn_top",
+                       "Plane", param=0)
+            .constrain(f"{name_nut_back}?bot", f"{name_bracket_back}?conn_bot",
+                       "Plane")
+        )
+        if self.line_length == 0.0:
+            a.constrain(
+                f"{name_actuator}/front?conn",
+                f"{name_bracket_front}?conn_mid",
+                "Plane", param=0)
+        else:
+            (
+                a
+                .addS(tension_fibre(
+                    length=line_l,
+                    hole_diam=self.nut.diam_thread,
+                    thickness=self.line_thickness,
+                ), name="fibre", role=Role.CONNECTION)
+                .constrain(
+                    f"{name_actuator}/front?conn",
+                    "fibre?male",
+                    "Plane"
+                )
+                .constrain(
+                    f"{name_bracket_front}?conn_mid",
+                    "fibre?female",
+                    "Plane"
+                )
+            )
+        if tag_hole_front:
+            a.constrain(tag_hole_front, f"{name_bracket_front}?conn_side", "Plane")
+        if tag_hole_back:
+            a.constrain(tag_hole_back, f"{name_bracket_back}?conn_side", "Plane")
+        if tag_dir:
+            a.constrain(tag_dir, f"{name_bracket_front}?conn_mid", "Axis", param=0)
+
+
+@dataclass
+class ElectronicBoard(Model):
+
+    name: str = "electronic-board"
+    nut: HexNut = NUT_COMMON
+    bolt: FlatHeadBolt = BOLT_COMMON
+    length: float = 70.0
+    width: float = 170.0
+    mount_holes: list[Hole] = field(default_factory=lambda: [
+        Hole(x=25, y=75),
+        Hole(x=25, y=-75),
+        Hole(x=-25, y=75),
+        Hole(x=-25, y=-75),
+    ])
+    panel_thickness: float = 25.4 / 16
+    mount_panel_thickness: float = 25.4 / 4
+    material: Material = Material.WOOD_BIRCH
+
+    @property
+    def mount_hole_diam(self) -> float:
+        return self.bolt.diam_thread
+
+    def __post_init__(self):
+        super().__init__(name=self.name)
+
+    def panel(self) -> MountingBox:
+        return MountingBox(
+            holes=self.mount_holes,
+            hole_diam=self.mount_hole_diam,
+            length=self.length,
+            width=self.width,
+            centred=(True, True),
+            thickness=self.panel_thickness,
+            generate_reverse_tags=True,
+        )
+
+    def assembly(self) -> Cq.Assembly:
+        panel = self.panel()
+        result = (
+            Cq.Assembly()
+            .addS(panel.generate(), name="panel",
+                  role=Role.ELECTRONIC | Role.STRUCTURE, material=self.material)
+        )
+        for hole in self.mount_holes:
+            bolt_name = f"{hole.tag}_bolt"
+            (
+                result
+                .add(self.bolt.assembly(), name=bolt_name)
+                .constrain(
+                    f"{bolt_name}?root",
+                    f"panel?{hole.tag}",
+                    "Plane", param=0
+                )
+            )
+        return result.solve()
+
+@dataclass
+class ElectronicBoardBattery(ElectronicBoard):
+    name: str = "electronic-board-battery"
+    battery_box: BatteryBox18650 = BATTERY_BOX
+
+    @submodel(name="panel")
+    def panel_out(self) -> MountingBox:
+        return self.panel()
+
+@dataclass
+class ElectronicBoardControl(ElectronicBoard):
+    name: str = "electronic-board-control"
+
+    controller_datum: Cq.Location = Cq.Location.from2d(-25, 23, -90)
+
+    controller: ArduinoUnoR3 = ArduinoUnoR3()
+
+    def panel(self) -> MountingBox:
+        box = super().panel()
+        def transform(i, x, y):
+            pos = self.controller_datum * Cq.Location.from2d(x, self.controller.width - y)
+            x, y = pos.to2d_pos()
+            return Hole(
+                x=x, y=y,
+                diam=self.controller.hole_diam,
+                tag=f"controller_conn{i}",
+            )
+        box.holes = box.holes.copy() + [
+            transform(i, x, y)
+            for i, (x, y) in enumerate(self.controller.holes)
+        ]
+        return box
+
+    @submodel(name="panel")
+    def panel_out(self) -> MountingBox:
+        return self.panel()
+
+    def assembly(self) -> Cq.Assembly:
+        result = super().assembly()
+        result.add(self.controller.assembly(), name="controller")
+        for i in range(len(self.controller.holes)):
+            result.constrain(f"controller?conn{i}", f"panel?controller_conn{i}", "Plane")
+        return result.solve()
+
+@dataclass(frozen=True)
+class LightStrip:
+
+    width: float = 10.0
+    height: float = 4.5

nhf/touhou/houjuu_nue/harness.py

@@ -0,0 +1,204 @@
+from dataclasses import dataclass, field
+import cadquery as Cq
+from nhf.parts.joints import HirthJoint
+from nhf import Material, Role
+from nhf.build import Model, TargetKind, target, assembly, submodel
+from nhf.touhou.houjuu_nue.joints import RootJoint
+from nhf.parts.box import MountingBox
+import nhf.utils
+
+@dataclass(frozen=True, kw_only=True)
+class Mannequin:
+    """
+    A mannequin for calibration
+    """
+
+    shoulder_width: float = 400
+    shoulder_to_waist: float = 440
+    waist_width: float = 250
+    head_height: float = 220.0
+    neck_height: float = 105.0
+    neck_diam: float = 140
+    head_diam: float = 210
+    torso_thickness: float = 150
+
+    def generate(self) -> Cq.Workplane:
+        head_neck = (
+            Cq.Workplane("XY")
+            .cylinder(
+                radius=self.neck_diam/2,
+                height=self.neck_height,
+                centered=(True, True, False))
+            .faces(">Z")
+            .workplane()
+            .cylinder(
+                radius=self.head_diam/2,
+                height=self.head_height,
+                combine=True, centered=(True, True, False))
+        )
+        result = (
+            Cq.Workplane("XY")
+            .rect(self.waist_width, self.torso_thickness)
+            .workplane(offset=self.shoulder_to_waist)
+            .rect(self.shoulder_width, self.torso_thickness)
+            .loft(combine=True)
+            .union(head_neck.translate((0, 0, self.shoulder_to_waist)))
+        )
+        return result.translate((0, self.torso_thickness / 2, 0))
+
+
+BASE_POS_X = 70.0
+BASE_POS_Y = 100.0
+
+@dataclass(kw_only=True)
+class Harness(Model):
+    thickness: float = 25.4 / 8
+    width: float = 200.0
+    height: float = 304.8
+    fillet: float = 10.0
+
+    wing_base_pos: list[tuple[str, float, float]] = field(default_factory=lambda: [
+        ("r1", BASE_POS_X, BASE_POS_Y),
+        ("l1", -BASE_POS_X, BASE_POS_Y),
+        ("r2", BASE_POS_X, 0),
+        ("l2", -BASE_POS_X, 0),
+        ("r3", BASE_POS_X, -BASE_POS_Y),
+        ("l3", -BASE_POS_X, -BASE_POS_Y),
+    ])
+
+    root_joint: RootJoint = field(default_factory=lambda: RootJoint())
+
+    mannequin: Mannequin = Mannequin()
+
+    def __post_init__(self):
+        super().__init__(name="harness")
+
+    @submodel(name="bridge-pair-horizontal")
+    def bridge_pair_horizontal(self) -> MountingBox:
+        return self.root_joint.bridge_pair_horizontal(centre_dx=BASE_POS_X * 2)
+    @submodel(name="bridge-pair-vertical")
+    def bridge_pair_vertical(self) -> MountingBox:
+        return self.root_joint.bridge_pair_vertical(centre_dy=BASE_POS_Y)
+
+    @target(name="profile", kind=TargetKind.DXF)
+    def profile(self) -> Cq.Sketch:
+        """
+        Creates the harness shape
+        """
+        w, h = self.width / 2, self.height / 2
+        sketch = (
+            Cq.Sketch()
+            .polygon([
+                (w, h),
+                (w, -h),
+                (-w, -h),
+                (-w, h),
+                #(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.fillet)
+        )
+        for tag, x, y in self.wing_base_pos:
+            conn = [(px + x, py + y) for px, py in self.root_joint.corner_pos()]
+            sketch = (
+                sketch
+                .push(conn)
+                .tag(tag)
+                .circle(self.root_joint.corner_hole_diam / 2, mode='s')
+                .reset()
+            )
+        return sketch
+
+    def surface(self) -> Cq.Workplane:
+        """
+        Creates the harness shape
+        """
+        result = (
+            Cq.Workplane('XZ')
+            .placeSketch(self.profile())
+            .extrude(self.thickness)
+        )
+        result.faces(">Y").tag("mount")
+        plane = result.faces(">Y").workplane()
+        for tag, x, y in self.wing_base_pos:
+            conn = [(px + x, py + y) for px, py
+                    in self.root_joint.corner_pos()]
+            for i, (px, py) in enumerate(conn):
+                plane.moveTo(px, py).tagPlane(f"{tag}_{i}")
+        return result
+
+    def add_root_joint_constraint(
+            self,
+            a: Cq.Assembly,
+            harness_tag: str,
+            joint_tag: str,
+            mount_tag: str):
+        for i in range(4):
+            a.constrain(f"{harness_tag}?{mount_tag}_{i}", f"{joint_tag}/parent?h{i}", "Point")
+
+
+    @assembly()
+    def assembly(self, with_root_joint: bool = False) -> Cq.Assembly:
+        harness = self.surface()
+        mannequin_z = self.mannequin.shoulder_to_waist * 0.6
+
+        result = (
+            Cq.Assembly()
+            .addS(
+                harness, name="base",
+                material=Material.WOOD_BIRCH,
+                role=Role.STRUCTURE)
+            .constrain("base", "Fixed")
+            .addS(
+                self.mannequin.generate(),
+                name="mannequin",
+                role=Role.FIXTURE,
+                loc=Cq.Location((0, -self.thickness, -mannequin_z), (0, 0, 1), 180))
+            .constrain("mannequin", "Fixed")
+        )
+        bridge_h = self.bridge_pair_horizontal().generate()
+        for i in [1,2,3]:
+            name = f"r{i}l{i}_bridge"
+            (
+                result
+                .addS(
+                    bridge_h, name=name,
+                    role=Role.FIXTURE,
+                    material=Material.WOOD_BIRCH,
+                )
+                .constrain(f"{name}?conn0_rev", f"base?r{i}_1", "Point")
+                .constrain(f"{name}?conn1_rev", f"base?l{i}_0", "Point")
+                .constrain(f"{name}?conn2_rev", f"base?l{i}_3", "Point")
+                .constrain(f"{name}?conn3_rev", f"base?r{i}_2", "Point")
+            )
+        bridge_v = self.bridge_pair_vertical().generate()
+        (
+            result
+            .addS(bridge_v, name="r1_bridge", role=Role.FIXTURE, material=Material.WOOD_BIRCH)
+            .constrain("r1_bridge?conn0_rev", "base?r1_3", 'Plane')
+            .constrain("r1_bridge?conn1_rev", "base?r2_0", 'Plane')
+            .addS(bridge_v, name="r2_bridge", role=Role.FIXTURE, material=Material.WOOD_BIRCH)
+            .constrain("r2_bridge?conn0_rev", "base?r2_3", 'Plane')
+            .constrain("r2_bridge?conn1_rev", "base?r3_0", 'Plane')
+            .addS(bridge_v, name="l1_bridge", role=Role.FIXTURE, material=Material.WOOD_BIRCH)
+            .constrain("l1_bridge?conn0_rev", "base?l1_2", 'Plane')
+            .constrain("l1_bridge?conn1_rev", "base?l2_1", 'Plane')
+            .addS(bridge_v, name="l2_bridge", role=Role.FIXTURE, material=Material.WOOD_BIRCH)
+            .constrain("l2_bridge?conn0_rev", "base?l2_2", 'Plane')
+            .constrain("l2_bridge?conn1_rev", "base?l3_1", 'Plane')
+        )
+        if with_root_joint:
+            for name in ["l1", "l2", "l3", "r1", "r2", "r3"]:
+                result.addS(
+                    self.root_joint.assembly(), name=name,
+                    role=Role.PARENT,
+                    material=Material.PLASTIC_PLA)
+                self.add_root_joint_constraint(result, "base", name, name)
+        result.solve()
+        return result

nhf/touhou/houjuu_nue/test.py

@@ -0,0 +1,130 @@
+import unittest
+import cadquery as Cq
+import nhf.touhou.houjuu_nue as M
+import nhf.touhou.houjuu_nue.joints as MJ
+import nhf.touhou.houjuu_nue.electronics as ME
+from nhf.checks import pairwise_intersection
+
+class TestElectronics(unittest.TestCase):
+
+    def test_actuator_length(self):
+        self.assertAlmostEqual(
+            ME.LINEAR_ACTUATOR_50.conn_length, 103.9
+        )
+        self.assertAlmostEqual(
+            ME.LINEAR_ACTUATOR_30.conn_length, 83.9
+        )
+        self.assertAlmostEqual(
+            ME.LINEAR_ACTUATOR_10.conn_length, 64.5
+        )
+        self.assertAlmostEqual(
+            ME.LINEAR_ACTUATOR_21.conn_length, 76.0
+        )
+
+    def test_flexor(self):
+        flexor = ME.Flexor(
+            motion_span=60,
+        )
+        self.assertAlmostEqual(
+            flexor.target_length_at_angle(0),
+            flexor.actuator.stroke_length + flexor.actuator.conn_length)
+        self.assertAlmostEqual(
+            flexor.target_length_at_angle(flexor.motion_span),
+            flexor.actuator.conn_length)
+
+
+class TestJoints(unittest.TestCase):
+
+    def test_shoulder_collision_of_torsion_joint(self):
+        j = MJ.ShoulderJoint()
+        assembly = j.torsion_joint.rider_track_assembly()
+        self.assertEqual(pairwise_intersection(assembly), [])
+
+    def test_shoulder_collision_0(self):
+        j = MJ.ShoulderJoint()
+        assembly = j.assembly()
+        self.assertEqual(pairwise_intersection(assembly), [])
+
+    def test_shoulder_align(self):
+        j = MJ.ShoulderJoint()
+        a = j.assembly()
+        l_t_c0 = a.get_abs_location("parent_top/lip?conn0")
+        l_b_c0 = a.get_abs_location("parent_bot/lip?conn0")
+        v = l_t_c0 - l_b_c0
+        self.assertAlmostEqual(v.x, 0)
+        self.assertAlmostEqual(v.y, 0)
+
+    def test_shoulder_joint_dist(self):
+        """
+        Tests the arm radius
+        """
+        j = MJ.ShoulderJoint()
+        for deflection in [0, 40, j.angle_max_deflection]:
+            with self.subTest(deflection=deflection):
+                a = j.assembly(deflection=deflection)
+                # Axle
+                o = a.get_abs_location("parent_top/track?spring")
+                l_c1 = a.get_abs_location("parent_top/lip?conn0")
+                l_c2= a.get_abs_location("parent_top/lip?conn1")
+                v_c = 0.5 * ((l_c1 - o) + (l_c2 - o))
+                v_c.z = 0
+                self.assertAlmostEqual(v_c.Length, j.parent_lip_ext)
+
+    def test_disk_collision_0(self):
+        j = MJ.DiskJoint()
+        assembly = j.assembly(angle=0)
+        self.assertEqual(pairwise_intersection(assembly), [])
+    def test_disk_collision_mid(self):
+        j = MJ.DiskJoint()
+        assembly = j.assembly(angle=j.movement_angle / 2)
+        self.assertEqual(pairwise_intersection(assembly), [])
+    def test_disk_collision_max(self):
+        j = MJ.DiskJoint()
+        assembly = j.assembly(angle=j.movement_angle)
+        self.assertEqual(pairwise_intersection(assembly), [])
+
+    def test_elbow_joint_dist(self):
+        """
+        Tests the arm radius
+        """
+        j = MJ.ElbowJoint()
+        for angle in [0, 10, 20, j.disk_joint.movement_angle]:
+            with self.subTest(angle=angle):
+                a = j.assembly(angle=angle)
+                o = a.get_abs_location("child/disk?mate_bot")
+                l_c1 = a.get_abs_location("child/lip?conn_top0")
+                l_c2 = a.get_abs_location("child/lip?conn_bot0")
+                v_c = 0.5 * ((l_c1 - o) + (l_c2 - o))
+                v_c.z = 0
+                self.assertAlmostEqual(v_c.Length, j.child_arm_radius)
+
+                l_p1 = a.get_abs_location("parent_upper/lip?conn_top0")
+                l_p2 = a.get_abs_location("parent_upper/lip?conn_bot0")
+                v_p = 0.5 * ((l_p1 - o) + (l_p2 - o))
+                v_p.z = 0
+                self.assertAlmostEqual(v_p.Length, j.parent_arm_radius)
+
+
+class Test(unittest.TestCase):
+
+    def test_hs_joint_parent(self):
+        p = M.Parameters()
+        obj = p.harness.hs_joint_parent()
+        self.assertIsInstance(obj.val().solids(), Cq.Solid, msg="H-S joint must be in one piece")
+
+    def test_wings_assembly(self):
+        p = M.Parameters()
+        p.wings_harness_assembly()
+    def test_trident_assembly(self):
+        p = M.Parameters()
+        assembly = p.trident.assembly()
+        bbox = assembly.toCompound().BoundingBox()
+        length = bbox.zlen
+        self.assertGreater(length, 1300)
+        self.assertLess(length, 1700)
+    #def test_assemblies(self):
+    #    p = M.Parameters()
+    #    p.check_all()
+
+if __name__ == '__main__':
+    unittest.main()

nhf/touhou/houjuu_nue/trident.py

@@ -0,0 +1,88 @@
+import math
+from dataclasses import dataclass, field
+import cadquery as Cq
+from nhf import Material, Role
+from nhf.parts.handle import Handle, BayonetMount
+from nhf.build import Model, target, assembly
+import nhf.utils
+
+@dataclass
+class Trident(Model):
+    handle: Handle = field(default_factory=lambda: Handle(
+        diam=38,
+        diam_inner=38-2 * 25.4/8,
+        diam_connector_internal=18,
+        simplify_geometry=False,
+        mount=BayonetMount(n_pin=3),
+    ))
+    terminal_height: float = 80
+    terminal_hole_diam: float = 24
+    terminal_bottom_thickness: float = 10
+    segment_length: float = 24 * 25.4
+
+    @target(name="handle-connector")
+    def handle_connector(self):
+        return self.handle.connector()
+    @target(name="handle-insertion")
+    def handle_insertion(self):
+        return self.handle.insertion()
+    @target(name="proto-handle-terminal-connector", prototype=True)
+    def proto_handle_connector(self):
+        return self.handle.one_side_connector(height=15)
+
+    @target(name="handle-terminal-connector")
+    def handle_terminal_connector(self):
+        result = self.handle.one_side_connector(height=self.terminal_height)
+        #result.faces("<Z").circle(radius=25/2).cutThruAll()
+        h = self.terminal_height + self.handle.insertion_length - self.terminal_bottom_thickness
+        result = result.faces(">Z").hole(self.terminal_hole_diam, depth=h)
+        return result
+
+    @assembly()
+    def assembly(self):
+        def segment():
+            return self.handle.segment(self.segment_length)
+
+        terminal = (
+            self.handle
+            .one_side_connector(height=self.terminal_height)
+            .faces(">Z")
+            .hole(15, self.terminal_height + self.handle.insertion_length - 10)
+        )
+        mat_c = Material.PLASTIC_PLA
+        mat_i = Material.RESIN_TOUGH_1500
+        mat_s = Material.ACRYLIC_BLACK
+        role_i = Role.CONNECTION
+        role_c = Role.CONNECTION
+        role_s = Role.STRUCTURE
+        a = (
+            Cq.Assembly()
+            .addS(self.handle.insertion(), name="i0",
+                  material=mat_i, role=role_i)
+            .constrain("i0", "Fixed")
+            .addS(segment(), name="s1",
+                  material=mat_s, role=role_s)
+            .constrain("i0?rim", "s1?mate1", "Plane", param=0)
+            .addS(self.handle.insertion(), name="i1",
+                  material=mat_i, role=role_i)
+            .addS(self.handle.connector(), name="c1",
+                  material=mat_c, role=role_c)
+            .addS(self.handle.insertion(), name="i2",
+                  material=mat_i, role=role_i)
+            .constrain("s1?mate2", "i1?rim", "Plane", param=0)
+            .constrain("i1?mate", "c1?mate1", "Plane")
+            .constrain("i2?mate", "c1?mate2", "Plane")
+            .addS(segment(), name="s2",
+                  material=mat_s, role=role_s)
+            .constrain("i2?rim", "s2?mate1", "Plane", param=0)
+            .addS(self.handle.insertion(), name="i3",
+                  material=mat_i, role=role_i)
+            .constrain("s2?mate2", "i3?rim", "Plane", param=0)
+            .addS(self.handle.one_side_connector(), name="head",
+                  material=mat_c, role=role_c)
+            .constrain("i3?mate", "head?mate", "Plane")
+            .addS(terminal, name="terminal",
+                  material=mat_c, role=role_c)
+            .constrain("i0?mate", "terminal?mate", "Plane")
+        )
+        return a.solve()

pyproject.toml

@@ -6,22 +6,15 @@ authors = ["Leni Aniva <v@leni.sh>"]
 readme = "README.md"
 
 [tool.poetry.dependencies]
-python = ">=3.10,<3.13"
-cadquery = "2.5.2"
-numpy = ">=2,<3"
+python = "^3.10"
+cadquery = {git = "https://github.com/CadQuery/cadquery.git"}
+build123d = "^0.5.0"
+numpy = "^1.26.4"
 colorama = "^0.4.6"
 
 # cadquery dependency
 multimethod = "^1.12"
 scipy = "^1.14.0"
-typish = "^1.9.3"
-
-[tool.poetry.group.dev.dependencies]
-cq-editor = {git = "https://github.com/CadQuery/CQ-editor.git"}
-pyqt5 = "^5.15.11"
-logbook = "^1.8.0"
-spyder = "^5"
-pyqtgraph = "^0.13.7"
 
 [build-system]
 requires = ["poetry-core"]