Mods to allow panels and platters to be target specific or not.

printed/box.scad

@@ -31,29 +31,29 @@
 //!
 //! Normally the side sheets are the same type but they can be overridden individually as long as the substitute has the same thickness.
 //
-include <../utils/core/core.scad>
+include <../core.scad>
 use <../vitamins/sheet.scad>
-use <../vitamins/screw.scad>
-use <../vitamins/washer.scad>
 use <../vitamins/insert.scad>
 use <../utils/quadrant.scad>
+use <../utils/round.scad>
 
 bezel_clearance = 0.2;
 sheet_end_clearance = 1;
 sheet_slot_clearance = 0.2;
 
-function box_screw(type)     = type[0]; //! Screw type to be used at the corners
-function box_wall(type)      = type[1]; //! Wall thickness of 3D parts
-function box_sheets(type)    = type[2]; //! Sheet type used for the sides
-function box_top_sheet(type) = type[3]; //! Sheet type for the top
-function box_base_sheet(type)= type[4]; //! Sheet type for the bottom
-function box_feet(type)      = type[5]; //! True to enable feet on the bottom bezel
-function box_width(type)     = type[6]; //! Internal width
-function box_depth(type)     = type[7]; //! Internal depth
-function box_height(type)    = type[8]; //! Internal height
+function box_screw(type)       = type[0]; //! Screw type to be used at the corners
+function box_shelf_screw(type) = type[1]; //! Screw type to hold a shelf
+function box_wall(type)        = type[2]; //! Wall thickness of 3D parts
+function box_sheets(type)      = type[3]; //! Sheet type used for the sides
+function box_top_sheet(type)   = type[4]; //! Sheet type for the top
+function box_base_sheet(type)  = type[5]; //! Sheet type for the bottom
+function box_feet(type)        = type[6]; //! True to enable feet on the bottom bezel
+function box_width(type)       = type[7]; //! Internal width
+function box_depth(type)       = type[8]; //! Internal depth
+function box_height(type)      = type[9]; //! Internal height
 
-function box(screw, wall, sheets, top_sheet, base_sheet, size, feet = false) = //! Construct a property list for a box.
- concat([screw, wall, sheets, top_sheet, base_sheet, feet], size);
+function box(screw, wall, sheets, top_sheet, base_sheet, size, feet = false, shelf_screw = M3_dome_screw) = //! Construct a property list for a box.
+ concat([screw, shelf_screw, wall, sheets, top_sheet, base_sheet, feet], size);
 
 function box_bezel_clearance(type) = bezel_clearance;
 
@@ -62,6 +62,7 @@ function box_profile_overlap(type) = 3 + sheet_end_clearance / 2;
 
 function box_washer(type) = screw_washer(box_screw(type));
 function box_insert(type) = screw_insert(box_screw(type));
+function box_shelf_insert(type) = screw_insert(box_shelf_screw(type));
 
 function box_hole_inset(type) = washer_radius(box_washer(type)) + 1;
 function box_insert_r(type) = insert_hole_radius(box_insert(type));
@@ -90,23 +91,32 @@ function box_bezel_height(type, bottom) = //! Bezel height for top or bottom
 
 grill_hole = 5;
 grill_gap = 1.9;
-module grill(width, height, r = 1000, poly = false, h = 0) { //! A staggered array of 5mm holes to make grills in sheets. Can be constrained to be circular. Set ```poly``` ```true``` for printing, ```false``` for milling.
+
+function box_grill_hole_r() = grill_hole / 2;
+
+module grill_hole_positions(width, height, r = 1000) {
     nx = floor(width / (grill_hole + grill_gap));
     xpitch = width / nx;
     ny = floor(height / ((grill_hole + grill_gap) * cos(30)));
     ypitch = height / ny;
 
+    for(y = [0 : ny - 1], x = [0 : nx - 1 - (y % 2)]) {
+        $x = -width / 2 + (x + 0.5 + (y % 2) / 2) * xpitch;
+        $y = -height / 2 + (y + 0.5) * ypitch;
+        if(sqrt(sqr($x) + sqr($y)) + grill_hole / 2 <= r)
+            translate([$x, $y])
+                children();
+    }
+}
+
+module grill(width, height, r = 1000, poly = false, h = 0) { //! A staggered array of 5mm holes to make grills in sheets. Can be constrained to be circular. Set ```poly``` ```true``` for printing, ```false``` for milling.
     extrude_if(h)
-        for(y = [0 : ny - 1], x = [0 : nx - 1 - (y % 2)]) {
-            x = -width / 2 + (x + 0.5 + (y % 2) / 2) * xpitch;
-            y = -height / 2 + (y + 0.5) * ypitch;
-            if(sqrt(sqr(x) + sqr(y)) + grill_hole / 2 <= r)
-                translate([x, y])
-                    if(poly)
-                        poly_circle(r = grill_hole / 2);
-                    else
-                        circle(d = grill_hole);
-        }
+        if(poly)
+            grill_hole_positions(width, height, r)
+                poly_circle(r = grill_hole / 2);
+        else
+            grill_hole_positions(width, height, r)
+                circle(d = grill_hole);
 }
 
 module box_corner_profile_2D(type) { //! The 2D shape of the corner profile.
@@ -178,6 +188,15 @@ module box_corner_profile_section(type, section, sections) { //! Generates inter
     }
 }
 
+module box_corner_profile_sections(type, section, sections) { //! Generate four copies of a corner profile section
+    stl("box_corner_profile");
+    offset = box_boss_r(type) + 1;
+    for(i = [0 : 3])
+        rotate(i * 90)
+            translate([offset, offset])
+                box_corner_profile_section(type, section, sections);
+}
+
 module box_corner_quadrants(type, width, depth)
     for(corner = [0:3]) {
         x = [-1,1,1,-1][corner];
@@ -261,10 +280,11 @@ dowel_length = 20;
 dowel_wall = extrusion_width * 3;
 dowel_h_wall = layer_height * 6;
 
-
 module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlocking sections of the bezel to allow it to be bigger than the printer
-    w = (box_width(type) + 2 * box_outset(type)) / cols;
-    h = (box_depth(type) + 2 * box_outset(type)) / rows;
+    tw = box_width(type) + 2 * box_outset(type);
+    w = tw / cols;
+    th = box_depth(type) + 2 * box_outset(type);
+    h = th / rows;
     bw = box_outset(type) - bezel_clearance / 2;
     bw2 = box_outset(type) + box_inset(type);
 
@@ -339,7 +359,7 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
         render() difference() {
             union() {
                 clip(xmin = 0, xmax = w, ymin = 0, ymax = h)
-                    translate([box_width(type) / 2 + box_outset(type) - x * w, box_depth(type) / 2 + box_outset(type) - y * h, box_profile_overlap(type)])
+                    translate([tw / 2 - x * w, th / 2 - y * h, box_profile_overlap(type)])
                         box_bezel(type, bottom);
 
                 if(x < cols - 1 && y == 0)
@@ -399,7 +419,6 @@ module box_bezel_section(type, bottom, rows, cols, x, y) { //! Generates interlo
     }
 }
 
-
 module box_screw_hole_positions(type)
     for(x = [-1, 1], y = [-1, 1])
         translate([x * (box_width(type) / 2 - box_hole_inset(type)), y * (box_depth(type) / 2 - box_hole_inset(type))])
@@ -442,6 +461,96 @@ module box_shelf_blank(type, sheet = false) { //! Generates a 2D template for a
     }
 }
 
+module box_shelf_screw_positions(type, screw_positions, thickness = 0, wall = undef) { //! Place children at the shelf screw positions
+    w = is_undef(wall) ? box_wall(type) : wall;
+    insert = box_shelf_insert(type);
+    translate_z(-insert_boss_radius(insert, w))
+        for(p = screw_positions)
+            multmatrix(p)
+                translate_z(thickness)
+                    children();
+}
+
+module box_shelf_bracket(type, screw_positions, wall = undef) { //! Generates a shelf bracket, the first optional child is a 2D cutout and the second 3D cutouts
+    stl("shelf_bracket");
+    w = is_undef(wall) ? box_wall(type) : wall;
+    insert = box_shelf_insert(type);
+    lip = 2 * insert_boss_radius(insert, w);
+    width = insert_length(insert) + w;
+
+    module shape()
+        difference() {
+            square([box_width(type), box_depth(type)], center = true);
+
+            offset(bezel_clearance / 2)
+                box_corner_quadrants(type, box_width(type), box_depth(type));
+
+            if($children)
+                hflip()
+                    children();
+        }
+
+    module boss()
+        translate_z(-width + eps)
+            linear_extrude(width - 2 * eps)
+                hull() {
+                    circle4n(r = lip / 2 - eps);
+
+                    translate([-lip / 2, -lip / 2 + eps])
+                        square([lip, eps]);
+                }
+
+    difference() {
+        union() {
+            linear_extrude(w)
+                difference() {
+                    shape()
+                        if($children)
+                            children(0);
+
+                    round(2) offset(-width)
+                        shape()
+                            if($children)
+                                children(0);
+                }
+
+            linear_extrude(lip)
+                difference() {
+                    shape()
+                        if($children)
+                            children(0);
+
+                    offset(-w)
+                        shape()
+                            if($children)
+                                children(0);
+                }
+
+            hflip()
+                box_shelf_screw_positions(type, screw_positions, 0, w)
+                    boss();
+        }
+        if($children > 1)
+            hflip()
+                children(1);
+
+        hflip()
+            box_shelf_screw_positions(type, screw_positions, 0, w)
+                insert_hole(insert, counterbore = 1, horizontal = true);
+    }
+}
+
+module box_shelf_bracket_section(type, rows, cols, x, y) { //! Generates sections of the shelf bracket to allow it to be bigger than the printer
+    tw = box_width(type);
+    w = tw / cols;
+    th = box_depth(type);
+    h = th / rows;
+
+    clip(xmin = 0, xmax = w, ymin = 0, ymax = h)
+        translate([tw / 2 - x * w, th / 2 - y * h])
+            children();
+}
+
 module box_left_blank(type, sheet = false) { //! Generates a 2D template for the left sheet, ```sheet``` can be set to override the type
     dxf("box_left");
 

printed/butt_box.scad

@@ -110,12 +110,9 @@ function fixing_block_positions(type) = let(
 
 function side_holes(type) = [for(p = fixing_block_positions(type), q = fixing_block_holes(bbox_screw(type))) p * q];
 
-module drill_holes(type, t)
-    for(list = [corner_holes(type), side_holes(type)], p = list)
-        let(q = t * p)
-            if(abs(transform([0, 0, 0], q).z) < eps)
-                multmatrix(q)
-                    drill(screw_clearance_radius(bbox_screw(type)), 0);
+module bbox_drill_holes(type, t)
+    position_children(concat(corner_holes(type), side_holes(type)), t)
+        drill(screw_clearance_radius(bbox_screw(type)), 0);
 
 module bbox_base_blank(type) { //! 2D template for the base
     dxf(str(bbox_name(type), "_base"));
@@ -123,7 +120,7 @@ module bbox_base_blank(type) { //! 2D template for the base
     difference() {
         sheet_2D(bbox_base_sheet(type), bbox_width(type), bbox_depth(type), 1);
 
-        drill_holes(type, translate(bbox_height(type) / 2));
+        bbox_drill_holes(type, translate(bbox_height(type) / 2));
     }
 }
 
@@ -136,7 +133,7 @@ module bbox_top_blank(type) { //! 2D template for the top
         translate([0, t / 2])
             sheet_2D(bbox_top_sheet(type), bbox_width(type) + 2 * t, bbox_depth(type) + t);
 
-        drill_holes(type, translate(-bbox_height(type) / 2));
+        bbox_drill_holes(type, translate(-bbox_height(type) / 2));
     }
 }
 
@@ -154,7 +151,7 @@ module bbox_left_blank(type, sheet = false) { //! 2D template for the left side
         translate([-t / 2, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_depth(type) + t, bbox_height(type) + bb);
 
-        drill_holes(type, rotate([0, 90, 90]) * translate([bbox_width(type) / 2, 0]));
+        bbox_drill_holes(type, rotate([0, 90, 90]) * translate([bbox_width(type) / 2, 0]));
     }
 }
 
@@ -168,7 +165,7 @@ module bbox_right_blank(type, sheet = false) { //! 2D template for the right sid
         translate([t / 2, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_depth(type) + t, bbox_height(type) + bb);
 
-        drill_holes(type, rotate([0, 90, 90]) * translate([-bbox_width(type) / 2, 0]));
+        bbox_drill_holes(type, rotate([0, 90, 90]) * translate([-bbox_width(type) / 2, 0]));
     }
 }
 
@@ -183,7 +180,7 @@ module bbox_front_blank(type, sheet = false, width = 0) { //! 2D template for th
         translate([0, (bt - bb) / 2])
             sheet_2D(subst_sheet(type, sheet), max(bbox_width(type) + 2 * t, width), bbox_height(type) + bb + bt);
 
-        drill_holes(type, rotate([-90, 0, 0]) * translate([0, bbox_depth(type) / 2]));
+        bbox_drill_holes(type, rotate([-90, 0, 0]) * translate([0, bbox_depth(type) / 2]));
     }
 }
 
@@ -197,7 +194,7 @@ module bbox_back_blank(type, sheet = false) { //! 2D template for the back
         translate([0, -bb / 2])
             sheet_2D(subst_sheet(type, sheet), bbox_width(type), bbox_height(type) + bb);
 
-        drill_holes(type, rotate([-90, 0, 0]) * translate([0, -bbox_depth(type) / 2]));
+        bbox_drill_holes(type, rotate([-90, 0, 0]) * translate([0, -bbox_depth(type) / 2]));
     }
 }
 

readme.md

@@ -235,7 +235,7 @@ Individual teeth are not drawn, instead they are represented by a lighter colour
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```belt(type, points, gap = 0, gap_pt = undef, belt_colour = grey20, tooth_colour = grey50)``` | Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified |
+| ```belt(type, points, gap = 0, gap_pt = undef, belt_colour = grey(20)``` | Draw a belt path given a set of points and pitch radii where the pulleys are. Closed loop unless a gap is specified |
 
 ![belts](tests/png/belts.png)
 
@@ -2591,10 +2591,10 @@ Linear rails with carriages.
 ### Modules
 | Module | Description |
 |:--- |:--- |
-| ```carriage(type, rail, end_colour = grey20, wiper_colour = grey20)``` | Draw the specified carriage |
+| ```carriage(type, rail, end_colour = grey(20)``` | Draw the specified carriage |
 | ```carriage_hole_positions(type)``` | Position children over screw holes |
 | ```rail(type, length)``` | Draw the specified rail |
-| ```rail_assembly(type, length, pos, carriage_end_colour = grey20, carriage_wiper_colour = grey20)``` | Rail and carriage assembly |
+| ```rail_assembly(type, length, pos, carriage_end_colour = grey(20)``` | Rail and carriage assembly |
 | ```rail_hole_positions(type, length, first = 0, screws = 100, both_ends = true)``` | Position children over screw holes |
 | ```rail_screws(type, length, thickness, screws = 100)``` | Place screws in the rail |
 
@@ -3872,6 +3872,7 @@ Normally the side sheets are the same type but they can be overridden individual
 | ```box_height(type)``` | Internal height |
 | ```box_screw(type)``` | Screw type to be used at the corners |
 | ```box_sheets(type)``` | Sheet type used for the sides |
+| ```box_shelf_screw(type)``` | Screw type to hold a shelf |
 | ```box_top_sheet(type)``` | Sheet type for the top |
 | ```box_wall(type)``` | Wall thickness of 3D parts |
 | ```box_width(type)``` | Internal width |
@@ -3879,7 +3880,7 @@ Normally the side sheets are the same type but they can be overridden individual
 ### Functions
 | Function | Description |
 |:--- |:--- |
-| ```box(screw, wall, sheets, top_sheet, base_sheet, size, feet = false)``` | Construct a property list for a box. |
+| ```box(screw, wall, sheets, top_sheet, base_sheet, size, feet = false, shelf_screw = M3_dome_screw)``` | Construct a property list for a box. |
 | ```box_bezel_height(type, bottom)``` | Bezel height for top or bottom |
 | ```box_corner_gap(type)``` | Gap between box_sheets at the corners to connect inside and outside profiles |
 | ```box_inset(type)``` | How much the bezel intrudes on the specified width and length, away from the corners |
@@ -3899,6 +3900,7 @@ Normally the side sheets are the same type but they can be overridden individual
 | ```box_corner_profile(type)``` | Generates the corner profile STL for 3D printing. |
 | ```box_corner_profile_2D(type)``` | The 2D shape of the corner profile. |
 | ```box_corner_profile_section(type, section, sections)``` | Generates interlocking sections of the corner profile to allow it to be taller than the printer |
+| ```box_corner_profile_sections(type, section, sections)``` | Generate four copies of a corner profile section |
 | ```box_front(type)``` | Default front, can be overridden to customise |
 | ```box_front_blank(type, sheet = false)``` | Generates a 2D template for the front sheet, ```sheet``` can be set to override the type |
 | ```box_left(type)``` | Default left side, can be overridden to customise |
@@ -3906,6 +3908,9 @@ Normally the side sheets are the same type but they can be overridden individual
 | ```box_right(type)``` | Default right side, can be overridden to customise |
 | ```box_right_blank(type, sheet = false)``` | Generates a 2D template for the right sheet, ```sheet``` can be set to override the type |
 | ```box_shelf_blank(type, sheet = false)``` | Generates a 2D template for a shelf sheet |
+| ```box_shelf_bracket(type, screw_positions, wall = undef)``` | Generates a shelf bracket, the first optional child is a 2D cutout and the second 3D cutouts |
+| ```box_shelf_bracket_section(type, rows, cols, x, y)``` | Generates sections of the shelf bracket to allow it to be bigger than the printer |
+| ```box_shelf_screw_positions(type, screw_positions, thickness = 0, wall = undef)``` | Place children at the shelf screw positions |
 | ```box_top(type)``` | Default top, can be overridden to customise |
 | ```box_top_blank(type)``` | Generates a 2D template for the top sheet |
 | ```grill(width, height, r = 1000, poly = false, h = 0)``` | A staggered array of 5mm holes to make grills in sheets. Can be constrained to be circular. Set ```poly``` ```true``` for printing, ```false``` for milling. |
@@ -5211,12 +5216,18 @@ Maths utilities for manipulating vectors and matrices.
 | Function | Description |
 |:--- |:--- |
 | ```angle_between(v1, v2)``` | Return the angle between two vectors |
+| ```augment(m)``` | Augment a matrix by adding an identity matrix to the right |
 | ```euler(R)``` | Convert a rotation matrix to a Euler rotation vector. |
 | ```identity(n, x = 1)``` | Construct an arbitrary size identity matrix |
+| ```invert(m)``` | Invert a matrix |
+| ```nearly_zero(x)``` | True if x is close to zero |
 | ```reverse(v)``` | Reverse a vector |
 | ```rot3_z(a)``` | Generate a 3x3 matrix to rotate around z |
 | ```rotate(a, v)``` | Generate a 4x4 rotation matrix, ```a``` can be a vector of three angles or a single angle around ```z```, or around axis ```v``` |
+| ```rowswap(m, i, j)``` | Swap two rows of a matrix |
 | ```scale(v)``` |  Generate a 4x4 matrix that scales by ```v```, which can be a vector of xyz factors or a scalar to scale all axes equally |
+| ```solve(m, i = 0, j = 0)``` | Solve each row ensuring diagonal is not zero |
+| ```solve_row(m, i)``` | Make diagonal one by dividing the row by it and subtract from other rows to make column zero |
 | ```transform(v, m)``` | Apply 4x4 transform to a 3 vector by extending it and cropping it again |
 | ```transform_points(path, m)``` | Apply transform to a path |
 | ```translate(v)``` | Generate a 4x4 translation matrix, ```v``` can be ```[x, y]```, ```[x, y, z]``` or ```z``` |
@@ -5225,6 +5236,11 @@ Maths utilities for manipulating vectors and matrices.
 | ```vec3(v)``` | Return a 3 vector with the first three elements of ```v``` |
 | ```vec4(v)``` | Return a 4 vector with the first three elements of ```v``` |
 
+### Modules
+| Module | Description |
+|:--- |:--- |
+| ```position_children(list, t)``` | Position children if they are on the Z = 0 plane when transformed by t |
+
 ![maths](tests/png/maths.png)
 
 

scripts/plateup.py

@@ -27,6 +27,7 @@ import c14n_stl
 from set_config import *
 from deps import *
 from shutil import copyfile
+import re
 
 source_dirs = { "stl" : "platters", "dxf" : "panels" }
 target_dirs = { "stl" : "printed",  "dxf" : "routed" }
@@ -38,43 +39,52 @@ def plateup(target, part_type, usage = None):
     top_dir = set_config(target, usage)
     parts_dir = top_dir + part_type + 's'
     target_dir = parts_dir + '/' + target_dirs[part_type]
-    source_dir = top_dir + source_dirs[part_type]
-    deps_dir = source_dir + "/deps"
-    if not os.path.isdir(source_dir):
-        return
-    if not os.path.isdir(target_dir):
-        os.makedirs(target_dir)
-    if not os.path.isdir(deps_dir):
-        os.makedirs(deps_dir)
+    source_dir1 = source_dirs[part_type]
+    source_dir2 = top_dir + source_dirs[part_type]
     #
-    # Decide which files to make
-    #
-    sources = [file for file in os.listdir(source_dir) if file.endswith('.scad')]
-    #
-    # Run OpenSCAD on the source files to make the targets
+    # Loop through source directories
     #
     used = []
-    for src in sources:
-        src_file = source_dir + '/' + src
-        part_file = target_dir + '/' + src[:-4] + part_type
-        dname = deps_name(deps_dir, src)
-        changed = check_deps(part_file, dname)
-        if changed:
-            print(changed)
-            openscad.run("-D$bom=1", "-d", dname, "-o", part_file, src_file)
-            if part_type == 'stl':
-                c14n_stl.canonicalise(part_file)
-            log_name = 'openscad.log'
-        else:
-            log_name = 'openscad.echo'
-            openscad.run_silent("-D$bom=1", "-o", log_name, src_file)
+    for dir in [source_dir1, source_dir2]:
+        if not os.path.isdir(dir):
+            continue
+        if not os.path.isdir(target_dir):
+            os.makedirs(target_dir)
         #
-        # Add the files on the BOM to the used list
+        # Make the deps dir
         #
-        with open(log_name) as file:
-            for line in file.readlines():
-                if line.startswith('ECHO: "~') and line.endswith('.' + part_type + '"\n'):
-                    used.append(line[8:-2])
+        deps_dir = dir + "/deps"
+        if not os.path.isdir(deps_dir):
+            os.makedirs(deps_dir)
+        #
+        # Decide which files to make
+        #
+        sources = [file for file in os.listdir(dir) if file.endswith('.scad')]
+        #
+        # Run OpenSCAD on the source files to make the targets
+        #
+        for src in sources:
+            src_file = dir + '/' + src
+            part_file = target_dir + '/' + src[:-4] + part_type
+            dname = deps_name(deps_dir, src)
+            changed = check_deps(part_file, dname)
+            if changed:
+                print(changed)
+                openscad.run("-D$bom=1", "-d", dname, "-o", part_file, src_file)
+                if part_type == 'stl':
+                    c14n_stl.canonicalise(part_file)
+                log_name = 'openscad.log'
+            else:
+                log_name = 'openscad.echo'
+                openscad.run_silent("-D$bom=1", "-o", log_name, src_file)
+            #
+            # Add the files on the BOM to the used list
+            #
+            with open(log_name) as file:
+                for line in file.readlines():
+                    match = re.match(r'^ECHO: "~(.*?\.' + part_type + r').*"$', line)
+                    if match:
+                        used.append(match.group(1))
     #
     # Copy file that are not included
     #

utils/core/core.scad

@@ -28,12 +28,12 @@ use <global.scad>
 
 module use_stl(name) {               //! Import an STL to make a build platter
     stl(name);
-
-    import(str("../stls/", name, ".stl"));
+    path = is_undef($target) ? "../stls/" : str("../", $target, "/stls/");
+    import(str(path, name, ".stl"));
 }
 
 module use_dxf(name) {               //! Import a DXF to make a build panel
     dxf(name);
-
-    import(str("../dxfs/", name, ".dxf"));
+    path = is_undef($target) ? "../dxfs/" : str("../", $target, "/dxfs/");
+    import(str(path, name, ".dxf"));
 }

utils/maths.scad

@@ -90,3 +90,42 @@ function euler(R) = let(ay = asin(-R[2][0]), cy = cos(ay)) //! Convert a rotatio
     cy ? [ atan2(R[2][1] / cy, R[2][2] / cy), ay, atan2(R[1][0] / cy, R[0][0] / cy) ]
        : R[2][0] < 0 ? [atan2( R[0][1],  R[0][2]),  180, 0]
                      : [atan2(-R[0][1], -R[0][2]), -180, 0];
+
+module position_children(list, t) //! Position children if they are on the Z = 0 plane when transformed by t
+    for(p = list)
+        let(q = t * p)
+            if(abs(transform([0, 0, 0], q).z) < 0.01)
+                multmatrix(q)
+                    children();
+
+// Matrix inversion: https://www.mathsisfun.com/algebra/matrix-inverse-row-operations-gauss-jordan.html
+
+function augment(m) = let(l = len(m), n = identity(l)) [ //! Augment a matrix by adding an identity matrix to the right
+    for(i = [0 : l - 1])
+        concat(m[i], n[i])
+];
+
+function rowswap(m, i, j) = [ //! Swap two rows of a matrix
+    for(k = [0 : len(m) - 1])
+        k == i ? m[j] : k == j ? m[i] : m[k]
+];
+
+function solve_row(m, i) = let(diag = m[i][i]) [ //! Make diagonal one by dividing the row by it and subtract from other rows to make column zero
+    for(j = [0 : len(m) - 1])
+        i == j ? m[j] / diag : m[j] - m[i] * m[j][i] / diag
+];
+
+function nearly_zero(x) = abs(x) < 1e-5; //! True if x is close to zero
+
+function solve(m, i = 0, j = 0) = //! Solve each row ensuring diagonal is not zero
+    i < len(m) ?
+        assert(i + j < len(m), "matrix is singular")
+         solve(!nearly_zero(m[i + j][i]) ? solve_row(j ? rowswap(m, i, i + j) : m, i) : solve(m, i, j + 1), i + 1)
+        : m;
+
+function invert(m) = let(n =len(m), m = solve(augment(m))) [ //! Invert a matrix
+    for(i = [0 : n - 1]) [
+        for(j = [n : 2 * n - 1])
+             each m[i][j]
+    ]
+];