Merge a2131ce23d into 9717497174

attachments.scad

@@ -35,14 +35,9 @@ $parent_orient = UP;
 $parent_size = undef;
 $parent_geom = undef;
 
-$edge_angle = undef;
-$edge_length = undef;
-
 $tags_shown = "ALL";
 $tags_hidden = [];
 
-
-
 _ANCHOR_TYPES = ["intersect","hull"];
 
 
@@ -491,8 +486,6 @@ _ANCHOR_TYPES = ["intersect","hull"];
 // Side Effects:
 //   `$attach_anchor` for each `from=` anchor given, this is set to the `[ANCHOR, POSITION, ORIENT, SPIN]` information for that anchor.
 //   `$attach_to` is set to `undef`.
-//   `$edge_angle` is set to the angle of the edge if the anchor is on an edge and the parent is a prismoid, or vnf with "hull" anchoring
-//   `$edge_length` is set to the length of the edge if the anchor is on an edge and the parent is a prismoid, or vnf with "hull" anchoring
 // Example:
 //   spheroid(d=20) {
 //       position(TOP) cyl(l=10, d1=10, d2=5, anchor=BOTTOM);
@@ -512,8 +505,6 @@ module position(at,from)
     two_d = _attach_geom_2d($parent_geom);
     for (anchr = anchors) {
         anch = _find_anchor(anchr, $parent_geom);
-        $edge_angle = len(anch)==5 ? struct_val(anch[4],"edge_angle") : undef;
-        $edge_length = len(anch)==5 ? struct_val(anch[4],"edge_length") : undef;
         $attach_to = undef;
         $attach_anchor = anch;
         translate(anch[1]) children();
@@ -981,7 +972,6 @@ module attach(parent, child, overlap, align, spin=0, norot, inset=0, shiftout=0,
         anchor_data = _find_anchor(anchor, $parent_geom);
         $edge_angle = len(anchor_data)==5 ? struct_val(anchor_data[4],"edge_angle") : undef;
         $edge_length = len(anchor_data)==5 ? struct_val(anchor_data[4],"edge_length") : undef;
-        $edge_end1 = len(anchor_data)==5 ? struct_val(anchor_data[4],"vec") : undef;
         anchor_pos = anchor_data[1];
         anchor_dir = factor*anchor_data[2];
         anchor_spin = two_d || !inside || anchor==TOP || anchor==BOT ? anchor_data[3]
@@ -1965,7 +1955,7 @@ module face_mask(faces=[LEFT,RIGHT,FRONT,BACK,BOT,TOP]) {
 // Usage:
 //   PARENT() edge_mask([edges], [except]) CHILDREN;
 // Description:
-//   Takes a 3D mask shape, and attaches it to the given edges of a cuboid parent, with the appropriate orientation to be
+//   Takes a 3D mask shape, and attaches it to the given edges, with the appropriate orientation to be
 //   differenced away.  The mask shape should be vertically oriented (Z-aligned) with the back-right
 //   quadrant (X+Y+) shaped to be diffed away from the edge of parent attachable shape.  If no tag is set
 //   then `edge_mask` sets the tag for children to "remove" so that it will work with the default {{diff()}} tag.
@@ -2006,8 +1996,6 @@ module edge_mask(edges=EDGES_ALL, except=[]) {
         vcount = (vec.x?1:0) + (vec.y?1:0) + (vec.z?1:0);
         dummy=assert(vcount == 2, "Not an edge vector!");
         anch = _find_anchor(vec, $parent_geom);
-        $edge_angle = len(anch)==5 ? struct_val(anch[4],"edge_angle") : undef;
-        $edge_length = len(anch)==5 ? struct_val(anch[4],"edge_length") : undef;
         $attach_to = undef;
         $attach_anchor = anch;
         rotang =
@@ -3191,13 +3179,12 @@ function reorient(
 //   orient = A vector pointing in the direction parts should project from the anchor position.  Default: UP
 //   spin = If needed, the angle to rotate the part around the direction vector.  Default: 0
 //   ---
-//   info = structure listing info to be propagated to the attached child, e.g. "edge_anchor"
 //   rot = A 4x4 rotations matrix, which may include a translation
 //   flip = If true, flip the anchor the opposite direction.  Default: false
-function named_anchor(name, pos, orient, spin, rot, flip, info) =
+function named_anchor(name, pos, orient, spin, rot, flip) =
   assert(num_defined([orient,spin])==0 || num_defined([rot,flip])==0, "Cannot mix orient or spin with rot or flip")
   assert(num_defined([pos,rot])>0, "Must give pos or rot")
-  is_undef(rot) ? [name, pos, default(orient,UP), default(spin,0), if (info) info]
+  is_undef(rot) ? [name, pos, default(orient,UP), default(spin,0)]
  : 
   let(
       flip = default(flip,false),
@@ -3211,7 +3198,7 @@ function named_anchor(name, pos, orient, spin, rot, flip, info) =
       decode=rot_decode(rot(to=UP,from=dir)*_force_rot(rot)),
       spin = decode[0]*sign(decode[1].z)
   )
-  [name, pos, dir, spin, if (info) info];
+  [name, pos, dir, spin];
   
 
 // Function: attach_geom()
@@ -3265,7 +3252,7 @@ function named_anchor(name, pos, orient, spin, rot, flip, info) =
 //   anchors = If given as a list of anchor points, allows named anchor points.
 //   two_d = If true, the attachable shape is 2D.  If false, 3D.  Default: false (3D)
 //   axis = The vector pointing along the axis of a geometry.  Default: UP
-//   override = Function that takes an anchor and returns a pair `[position,direction,spin]` to use for that anchor to override the normal one.  You can also supply a lookup table that is a list of `[anchor, [position, direction,spin]]` entries.  If the direction/position/spin that is returned is undef then the default will be used.
+//   override = Function that takes an anchor and returns a pair `[position,direction]` to use for that anchor to override the normal one.  You can also supply a lookup table that is a list of `[anchor, [position, direction]]` entries.  If the direction/position that is returned is undef then the default will be used.
 //
 // Example(NORENDER): Null/Point Shape
 //   geom = attach_geom();
@@ -3736,18 +3723,6 @@ function _get_cp(geom) =
 /// Arguments:
 ///   anchor = Vector or named anchor string.
 ///   geom = The geometry description of the shape.
-
-function _three_edge_corner_dir(facevecs,edges) =
-      let(
-           v1 = vector_bisect(facevecs[0],facevecs[2]),
-           v2 = vector_bisect(facevecs[1],facevecs[2]),
-           p1 = plane_from_normal(rot(v=edges[0],a=90,p=v1)),
-           p2 = plane_from_normal(rot(v=edges[1],a=-90,p=v2)),
-           line = plane_intersection(p1,p2),
-           v3 = unit(line[1]-line[0],UP)
-       )
-       unit(v3,UP);
-
 function _find_anchor(anchor, geom)=
     is_string(anchor)? (
           anchor=="origin"? [anchor, CENTER, UP, 0]    // Ok that this returns 3d anchor in the 2d case?
@@ -3804,28 +3779,16 @@ function _find_anchor(anchor, geom)=
             dir = anch==CENTER? UP
                 : len(facevecs)==1? unit(facevecs[0],UP)
                 : len(facevecs)==2? vector_bisect(facevecs[0],facevecs[1])
-                : _three_edge_corner_dir(facevecs,[FWD,LEFT])*anch.z,            
-            edgeang = len(facevecs)==2 ? 180-vector_angle(facevecs[0], facevecs[1]) : undef,
-            edgelen = anch.z==0 ? norm(edge)
-                    : anch.z>0 ? abs([size2.y,size2.x]*axy)
-                    : abs([size.y,size.x]*axy),
-            endvecs = len(facevecs)!=2 ? undef
-                    : anch.z==0 ? [DOWN, UP]
                 : let(
-                          raxy = zrot(-90,axy),
+                      v1 = vector_bisect(facevecs[0],facevecs[2]),
-                          bot1 = point3d(v_mul(point2d(size )/2, raxy), -h/2),
+                      v2 = vector_bisect(facevecs[1],facevecs[2]),
-                          top1 = point3d(v_mul(point2d(size2)/2, raxy) + shift, h/2),
+                      p1 = plane_from_normal(yrot(90,p=v1)),
-                          edge1 = top1-bot1,
+                      p2 = plane_from_normal(xrot(-90,p=v2)),
-                          vec1 = (raxy.x!=0) ? unit(rot(from=UP, to=[edge1.x,0,max(0.01,h)], p=[raxy.x,0,0]), UP)
+                      line = plane_intersection(p1,p2),
-                               :               unit(rot(from=UP, to=[0,edge1.y,max(0.01,h)], p=[0,raxy.y,0]), UP),
+                      v3 = unit(line[1]-line[0],UP) * anch.z
-                          raxy2 = zrot(90,axy),
-                          bot2 = point3d(v_mul(point2d(size )/2, raxy2), -h/2),
-                          top2 = point3d(v_mul(point2d(size2)/2, raxy2) + shift, h/2),
-                          edge2 = top2-bot2,
-                          vec2 = (raxy2.y!=0) ? unit(rot(from=UP, to=[edge.x,0,max(0.01,h)], p=[raxy2.x,0,0]), UP)
-                               :               unit(rot(from=UP, to=[0,edge.y,max(0.01,h)], p=[0,raxy2.y,0]), UP)
                   )
-                      [vec1,vec2],
+                  unit(v3,UP),
+            edgeang = len(facevecs)==2 ? 180-vector_angle(facevecs[0], facevecs[1]) : undef,
             final_dir = default(override[1],anch==CENTER?UP:rot(from=UP, to=axis, p=dir)),
             final_pos = default(override[0],rot(from=UP, to=axis, p=pos)),
 
@@ -3838,8 +3801,7 @@ function _find_anchor(anchor, geom)=
                  : anch.z!=0 && sum(v_abs(anch))==2 ? _compute_spin(final_dir, rot(from=UP, to=axis, p=anch.z*[anch.y,-anch.x,0])) 
                  : norm(anch)==3 ? _compute_spin(final_dir, final_dir==DOWN || final_dir==UP ? BACK : UP)
                  : oang        // face anchors point UP/BACK
-        ) [anchor, final_pos, final_dir, default(override[2],spin),
+        ) [anchor, final_pos, final_dir, default(override[2],spin), if (is_def(edgeang)) [["edge_angle",edgeang],["edge_length",norm(edge)]]]
-           if (is_def(edgeang)) [["edge_angle",edgeang],["edge_length",edgelen], ["vec", endvecs]]]
     ) : type == "conoid"? ( //r1, r2, l, shift
         let(
             rr1=geom[1],
@@ -3979,41 +3941,16 @@ function _find_anchor(anchor, geom)=
                           len(matchind)!=1 ? []
                         : let(   // After this runs we have two edges as index pairs, and their associated faces as index values
                               match1 = select(idxs,[0,matchind[0]]),
-                              match2 = list_remove(idxs,[0,matchind[0]]),
+                              match2 = list_remove_values(idxs,match1),
-                              facelists = [for(i=[0:1], j=[0:1])
-                                              let(
-                                                   ed = [match1[i],match2[j]],
-                                                   fl = _vnf_find_edge_faces(vnf,ed)
-                                              )
-                                              if (fl!=[]) [ed,fl]
-                                          ],
-                              final = [column(facelists,0), flatten(column(facelists,1))]
-                          )
-                          assert(len(final[1])==2, "invalid!")
-                          final,
-
-
-            /*[column(facelists,0), column(facelists
-
-                              
-
-                              
                               face1 = _vnf_find_edge_faces(vnf,[match1[0],match2[0]]),
                               face2 = _vnf_find_edge_faces(vnf,[match1[0],match2[1]]),
-                              face1a = _vnf_find_edge_faces(vnf,[match1[1],match2[0]]),
-                              face2a = _vnf_find_edge_faces(vnf,[match1[1],match2[1]]),
-feet=                              echo(facelist1 =select(vnf[1],face1a), facelist2=select(vnf[1],face2a)),
                               edge1 = [match1[0], face1==[] ? match2[1] : match2[0]],
                               edge2 = list_remove_values(idxs,edge1),
-                              fee=echo(edxs=idxs, edge1=edge1, edge2=edge2,alt=[match1[1],match2[0]],[match1[1],match2[1]],
-                                       edgefaces = _vnf_find_edge_faces(vnf,edge1),_vnf_find_edge_faces(vnf,edge2)  ),
                               face3 = _vnf_find_edge_faces(vnf,edge2),
-                              allfaces = concat(face1,face2,face3),
+                              allfaces = concat(face1,face2,face3)
-                              f=echo(pts=pts,matchind=matchind,match1=match1,match2=match2,face1=face1,face2=face2,face3=face3,edge1=edge1,edge2=edge2,face1a=face1a,face2a=face2a)
                           )
-                          assert(len(allfaces)==2, str("Invalid polyhedron encountered while computing VNF anchor",len(allfaces)))
+                          assert(len(allfaces)==2, "Invalid polyhedron encountered while computing VNF anchor")
-                          [[edge1,edge2], allfaces],*/
+                          [[edge1,edge2], allfaces],
-//            fe=echo(edge_faces=edges_faces),
             dir = len(idxs)>2 && edges_faces==[] ? [anchor,oang]
                 : edges_faces!=[] ?
                     let( 
@@ -4024,7 +3961,6 @@ feet=                              echo(facelist1 =select(vnf[1],face1a), faceli
                         projnormals = project_plane(point4d(cross(facenormals[0],facenormals[1])), facenormals),
                         ang = 180- posmod(v_theta(projnormals[1])-v_theta(projnormals[0]),360),
                         horiz_face = [for(i=[0:1]) if (approx(v_abs(facenormals[i]),UP)) i],
-fda=                        echo(horiz=horiz_face),
                         spin = horiz_face==[] ?
                                    let(  
                                        edgedir = edge[1]-edge[0],

constants.scad

@@ -44,8 +44,6 @@ _UNDEF="LRG+HX7dy89RyHvDlAKvb9Y04OTuaikpx205CTh8BSI";
 //   The correct hole should hold the plug when the long block is turned upside-down.
 //   The number in front of that hole will indicate the `$slop` value that is ideal for your printer.
 //   Remember to set that slop value in your scripts after you include the BOSL2 library:  ie: `$slop = 0.15;`
-//   .
-//   Note that the `$slop` value may be different using different materials even on the same printer.  
 // Example(3D,Med): Slop Calibration Part.
 //   min_slop = 0.00;
 //   slop_step = 0.05;
@@ -217,36 +215,6 @@ CENTER = [ 0,  0,  0];  // Centered zero vector.
 CTR = CENTER;
 CENTRE = CENTER;
 
-// Function: EDGE()
-// Synopsis: Named edge anchor constants
-// Topics: Constants, Attachment
-// Usage:
-//   EDGE(i)
-//   EDGE(direction,i)
-// Description:
-//   A shorthand for the named anchors "edge0", "top_edge0", "bot_edge0", etc.
-//   Use `EDGE(i)` to get "edge<i>".  Use `EDGE(TOP,i)` to get "top_edge<i>" and
-//   use `EDGE(BOT,i)` to get "bot_edge(i)".  You can also use
-//   `EDGE(CTR,i)` to get "edge<i>" and you can replace TOP or BOT with simply 1 or -1.
-
-function EDGE(a,b) =
-    is_undef(b) ? str("edge",a)
-  : assert(in_list(a,[TOP,BOT,CTR,1,0,-1]),str("Invalid direction: ",a))
-    let(
-        choices=["bot_","","top_"],
-        ind=is_vector(a) ? a.z : a
-    )
-    str(choices[ind+1],"edge",b);
-
-// Function: FACE()
-// Synopsis: Named face anchor constants
-// Topics: Constants, Attachment
-// Usage:
-//   FACE(i)
-// Description:
-//   A shorthand for the named anchors "face0", "face1", etc. 
-
-function FACE(i) = str("face",i);
 
 // Section: Line specifiers
 //   Used by functions in geometry.scad for specifying whether two points

masks3d.scad

@@ -25,7 +25,7 @@
 //   Difference it from the object to be chamfered.  The center of
 //   the mask object should align exactly with the edge to be chamfered.
 // Arguments:
-//   l/h/length/height = Length of mask.  Default: $edge_length if defined
+//   l/h/length/height = Length of mask.
 //   chamfer = Size of chamfer.
 //   excess = The extra amount to add to the length of the mask so that it differences away from other shapes cleanly.  Default: `0.1`
 //   ---
@@ -49,8 +49,7 @@
 //   }
 function chamfer_edge_mask(l, chamfer=1, excess=0.1, h, length, height, anchor=CENTER, spin=0, orient=UP) = no_function("chamfer_edge_mask");
 module chamfer_edge_mask(l, chamfer=1, excess=0.1, h, length, height, anchor=CENTER, spin=0, orient=UP) {
-    l = is_def($edge_length) && !any_defined([l,length,h,height]) ? $edge_length
+    l = one_defined([l, h, height, length], "l,h,height,length");
-      : one_defined([l,length,h,height],"l,length,h,height");
     default_tag("remove") {
         attachable(anchor,spin,orient, size=[chamfer*2, chamfer*2, l]) {
             cylinder(r=chamfer, h=l+excess, center=true, $fn=4);
@@ -170,35 +169,28 @@ module chamfer_cylinder_mask(r, chamfer, d, ang=45, from_end=false, anchor=CENTE
 }
 
 
+
 // Section: Rounding Masks
 
 // Module: rounding_edge_mask()
 // Synopsis: Creates a shape to round a 90° edge.
 // SynTags: Geom
 // Topics: Masks, Rounding, Shapes (3D)
-// See Also: edge_profile(), rounding_corner_mask(), default_tag(), diff() 
+// See Also: rounding_corner_mask(), default_tag(), diff() 
 // Usage:
-//   rounding_edge_mask(l|h=|length=|height=, r|d=, [ang], [excess=], [rounding=|chamfer=], ) [ATTACHMENTS];
+//   rounding_edge_mask(l|h=|length=|height=, r|d=, [ang], [excess=]) [ATTACHMENTS];
-//   rounding_edge_mask(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=], [rounding=|chamfer=]) [ATTACHMENTS];
+//   rounding_edge_mask(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=]) [ATTACHMENTS];
 // Description:
-//   Creates a mask shape that can be used to round a straight edge at any angle, with
+//   Creates a shape that can be used to round a straight edge at any angle.  
-//   different rounding radii at each end.  The corner of the mask appears on the Z axis with one face on the XZ plane.
+//   Difference it from the object to be rounded.  The center of the mask
-//   You must align the mask corner with the edge you want to round.  If your parent object is a cuboid, the easiest way to
+//   object should align exactly with the edge to be rounded.  You can use it with {{diff()}} and
-//   do this is to use {{diff()}} and {{edge_mask()}}.  However, this method is somewhat inflexible regarding orientation of a tapered
+//   {{edge_mask()}} to attach masks automatically to objects.  The default "remove" tag is set
-//   mask, and it does not support other parent shapes.  You can attach the mask to a larger range of shapes using 
+//   automatically.  
-//   {{attach()}} to anchor the `LEFT+FWD` anchor of the mask to a desired corner on the parent with `inside=true`.
-//   Many shapes propagate `$edge_angle` and `$edge_length` which can aid in configuring the mask, and you can adjust the
-//   mask as needed to align the taper as desired.  The default "remove" tag is set so {{diff()}} will automatically difference
-//   away the mask.  You can of course also position the mask manually and use `difference()`.
-//   .
-//   For mating with other roundings or chamfers on cuboids or regular prisms, you can choose end roundings and end chamfers.  These affect
-//   only the curved edge of the mask ends and will only work if the terminating face is perpendicular to the masked edge.  The `excess`
-//   parameter will add extra length to the mask when you use these settings.  
 //   
 // Arguments:
-//   l/h/length/height = Length of mask.  Default: $edge_length if defined
+//   l/h/length/height = Length of mask.
 //   r = Radius of the rounding.
-//   ang = Angle between faces for rounding.  Default: $edge_angle if defined, otherwise 90
+//   ang = Angle between faces for rounding.  Default: 90
 //   ---
 //   r1 = Bottom radius of rounding.
 //   r2 = Top radius of rounding.
@@ -206,12 +198,6 @@ module chamfer_cylinder_mask(r, chamfer, d, ang=45, from_end=false, anchor=CENTE
 //   d1 = Bottom diameter of rounding.
 //   d2 = Top diameter of rounding.
 //   excess = Extra size for the mask.  Defaults: 0.1
-//   rounding = Radius of roundong along ends.  Default: 0
-//   rounding1 = Radius of rounding along bottom end
-//   rounding2 = Radius of rounding along top end
-//   chamfer = Chamfer size of end chamfers.  Default: 0
-//   chamfer1 = Chamfer size of chamfer at bottom end
-//   chamfer2 = Chamfer size of chamfer at top end
 //   anchor = Translate so anchor point is at origin (0,0,0).  See [anchor](attachments.scad#subsection-anchor).  Default: `CENTER`
 //   spin = Rotate this many degrees around the Z axis after anchor.  See [spin](attachments.scad#subsection-spin).  Default: `0`
 //   orient = Vector to rotate top towards, after spin.  See [orient](attachments.scad#subsection-orient).  Default: `UP`
@@ -263,85 +249,34 @@ module chamfer_cylinder_mask(r, chamfer, d, ang=45, from_end=false, anchor=CENTE
 //               rounding_edge_mask(l=p.z, r=25);
 //       }
 //   }
-// Example(3D,VPT=[5.02872,6.37039,-0.503894],VPR=[75.3,0,107.4],VPD=74.4017): Mask shape with end rounding at the top, chamfer at the bottom, and a large excess value:
-//   rounding_edge_mask(r=10,h=20, chamfer1=3, rounding2=3, excess=1);
-// Example(3D,VPT=[1.05892,1.10442,2.20513],VPR=[60.6,0,118.1],VPD=74.4017): Attaching masks using {{attach()}} with automatic angle and length from the parent.  Note that sometimes the automatic length is too short because it is the length of the edge itself.  
-//   diff()
-//   prismoid([20,30],[12,19], h=10,shift=[4,7])
-//     attach([TOP+RIGHT,RIGHT+FRONT],LEFT+FWD,inside=true)
-//       rounding_edge_mask(r1=2,r2=4);
-// Example(3D): The mask does not need to be the full length of the edge
-//   diff()
-//   cuboid(20)
-//     attach(RIGHT+TOP,LEFT+FWD,inside=true,inset=-.1,align=FWD)
-//       rounding_edge_mask(r1=0,r2=10,length=10);
 
 function rounding_edge_mask(l, r, ang=90, r1, r2, d, d1, d2, excess=0.1, anchor=CENTER, spin=0, orient=UP, h,height,length) = no_function("rounding_edge_mask");
-module rounding_edge_mask(l, r, ang, r1, r2, excess=0.01, d1, d2,d,r,length, h, height, anchor=CENTER, spin=0, orient=UP,
+module rounding_edge_mask(l, r, ang=90, r1, r2, excess=0.01, d1, d2,d,r,length, h, height, anchor=CENTER, spin=0, orient=UP,
-                          rounding,rounding1,rounding2,chamfer,chamfer1,chamfer2,
                          _remove_tag=true)
 {
-    ang = first_defined([ang,$edge_angle,90]);
+    length = one_defined([l,length,h,height],"l,length,h,height");
-    length = is_def($edge_length) && !any_defined([l,length,h,height]) ? $edge_length
-           : one_defined([l,length,h,height],"l,length,h,height");
     r1 = get_radius(r1=r1, d1=d1,d=d,r=r);
     r2 = get_radius(r2=r2, d1=d2,d=d,r=r);
-    dummy1 = assert(num_defined([chamfer,rounding])<2, "Cannot give both rounding and chamfer")
-            assert(num_defined([chamfer1,rounding1])<2, "Cannot give both rounding1 and chamfer1")
-            assert(num_defined([chamfer2,rounding2])<2, "Cannot give both rounding2 and chamfer2");
-    rounding1 = first_defined([rounding1,rounding,0]);
-    rounding2 = first_defined([rounding2,rounding,0]);
-    chamfer1 = first_defined([chamfer1,chamfer,0]);
-    chamfer2 = first_defined([chamfer2,chamfer,0]);
     dummy = assert(all_nonnegative([r1,r2]), "radius/diameter value(s) must be nonnegative")
             assert(all_positive([length]), "length/l/h/height must be a positive value")
-            assert(is_finite(ang) && ang>0 && ang<180, "ang must be a number between 0 and 180")
+            assert(is_finite(ang) && ang>0 && ang<180, "ang must be a number between 0 and 180");
-            assert(all_nonnegative([chamfer1,chamfer2,rounding1,rounding2]), "chamfers and roundings must be nonnegative");
     steps = ceil(segs(max(r1,r2))*(180-ang)/360);
     function make_path(r) =
-         r==0 ? repeat([0,0],steps+1)
+        let(
-              : arc(n=steps+1, r=r, corner=[polar_to_xy(r,ang),[0,0],[r,0]]);
+             arc = r==0 ? repeat([0,0],steps+1)
+                        : arc(n=steps+1, r=r, corner=[polar_to_xy(r,ang),[0,0],[r,0]]),
+             maxx = last(arc).x,
+             maxy = arc[0].y,
+             cp = [-excess/tan(ang/2),-excess]
+        )
+        [
+          [maxx, -excess],
+          cp, 
+          arc[0] + polar_to_xy(excess, 90+ang),
+          each arc
+        ];
     path1 = path3d(make_path(r1),-length/2);
     path2 = path3d(make_path(r2),length/2);
-
-    function getarc(bigr,r,chamfer,p1,p2,h,print=false) =
-      r==0 && chamfer==0? [p2]
-    :  
-      let(
-          steps = ceil(segs(r)/4)+1,
-          center = [bigr/tan(ang/2), bigr,h],
-          refplane = plane_from_normal([-(p2-center).y, (p2-center).x, 0], p2),
-          refnormal = plane_normal(refplane), 
-          mplane = plane3pt(p2,p1,center),
-          A = plane_normal(mplane),
-          basept = lerp(p2,p1,max(r,chamfer)/2/h),
-          corner = [basept+refnormal*(refplane[3]-basept*refnormal)/(refnormal*refnormal),
-                    p2,
-                    center],
-          bare_arc = chamfer ? [p2+chamfer*unit(corner[0]-corner[1]),p2+chamfer*unit(corner[2]-corner[1])]
-                  : arc(r=r, corner = corner, n=steps),
-          arc_with_excess = [each bare_arc, up(excess, last(bare_arc))], 
-          arc = [for(pt=arc_with_excess) pt+refnormal*(mplane[3]-pt*A)/(refnormal*A)]
-      )
-      arc;
-    cp = [-excess/tan(ang/2), -excess];
-    extra1 = rounding1 || chamfer1 ? [0,0,excess] : CTR;
-    extra2 = rounding2 || chamfer2 ? [0,0,excess] : CTR;    
-    pathlist = [for(i=[0:len(path1)-1])
-                  let(
-                       path = [
-                               if (i==0) move(polar_to_xy( excess, 90+ang),path1[i]-extra1)
-                                 else if (i==len(path1)-1) fwd(excess,last(path1)-extra1)
-                                 else point3d(cp,-length/2-extra1.z),
-                               each reverse(zflip(getarc(r1,rounding1,chamfer1,zflip(path2[i]), zflip(path1[i]),length/2))),
-                               each getarc(r2,rounding2,chamfer2,path1[i],path2[i],length/2,print=rounding2!=0&&!is_undef(rounding2)&&i==3),
-                               if (i==0) move(polar_to_xy( excess, 90+ang),path2[i]+extra2)
-                                 else if (i==len(path2)-1) fwd(excess,last(path2)+extra2)
-                                 else point3d(cp, length/2+extra2.z),
-                       ]
-                   )
-                   path];
-
     left_normal = cylindrical_to_xyz(1,90+ang,0);
     left_dir = cylindrical_to_xyz(1,ang,0);
     zdir = unit([length, 0,-(r2-r1)/tan(ang/2)]);
@@ -380,7 +315,7 @@ module rounding_edge_mask(l, r, ang, r1, r2, excess=0.01, d1, d2,d,r,length, h,
        [BACK+RIGHT+TOP, [cylindrical_to_xyz(cutfact*r2,ang/2,length/2), zrot(ang/2,zdir)+UP,ang/2+90]],
        [BACK+RIGHT+BOT, [cylindrical_to_xyz(cutfact*r1,ang/2,-length/2), zrot(ang/2,zdir)+DOWN,ang/2+90]],
        ];
-    vnf = vnf_vertex_array(reverse(pathlist), col_wrap=true,caps=true);
+    vnf = vnf_vertex_array([path1,path2],caps=true,col_wrap=true);
     default_tag("remove", _remove_tag)
       attachable(anchor,spin,orient,size=[1,1,length],override=override){
         vnf_polyhedron(vnf);

rounding.scad

@@ -1348,10 +1348,7 @@ module offset_stroke(path, width=1, rounded=true, start, end, check_valid=true,
 //   will get a similar or better looking model with fewer vertices using "round" instead of
 //   "chamfer".  Use the "chamfer" style offset only in cases where the number of steps is very small or just one (such as when using
 //   the `os_chamfer` profile type).
-//   .
+//
-//   This module offers four anchor types.  The default is "hull" in which VNF anchors are placed on the VNF of the **unrounded** object.  You
-//   can also use "intersect" to get the intersection anchors to the unrounded object. If you prefer anchors that respect the rounding
-//   then use "surf_hull" or "intersect_hull". 
 // Arguments:
 //   path = 2d path (list of points) to extrude
 //   height / length / l / h = total height (including rounded portions, but not extra sections) of the output.  Default: combined height of top and bottom end treatments.
@@ -1378,7 +1375,7 @@ module offset_stroke(path, width=1, rounded=true, start, end, check_valid=true,
 //   atype = Select "hull", "intersect", "surf_hull" or "surf_intersect" anchor types.  Default: "hull"
 //   cp = Centerpoint for determining "intersect" anchors or centering the shape.  Determintes the base of the anchor vector.  Can be "centroid", "mean", "box" or a 3D point.  Default: "centroid"
 // Anchor Types:
-//   hull = Anchors to the convex hull of the linear sweep of the path, ignoring any end roundings.  (default)
+//   hull = Anchors to the convex hull of the linear sweep of the path, ignoring any end roundings. 
 //   intersect = Anchors to the surface of the linear sweep of the path, ignoring any end roundings.
 //   surf_hull = Anchors to the convex hull of the offset_sweep shape, including end treatments.
 //   surf_intersect = Anchors to the surface of the offset_sweep shape, including any end treatments.
@@ -2033,11 +2030,7 @@ function _rp_compute_patches(top, bot, rtop, rsides, ktop, ksides, concave) =
 //   vnf = rounded_prism(bottom, [top], [height=|h=|length=|l=], [joint_top=], [joint_bot=], [joint_sides=], [k=], [k_top=], [k_bot=], [k_sides=], [splinesteps=], [debug=]);
 // Description:
 //   Construct a generalized prism with continuous curvature rounding.  You supply the polygons for the top and bottom of the prism.  The only
-//   limitation is that joining the edges must produce a valid polyhedron with coplanar side faces.  The vertices of the top and bottom
+//   limitation is that joining the edges must produce a valid polyhedron with coplanar side faces.  You specify the rounding by giving
-//   are joined in the order listed.  The top should have the standard vertex order for a polyhedron: clockwise as seen when viewing the prism
-//   from the outside. 
-//   .
-//   You specify the rounding by giving
 //   the joint distance away from the corner for the rounding curve.  The k parameter ranges from 0 to 1 with a default of 0.5.  Larger
 //   values give a more abrupt transition and smaller ones a more gradual transition.  If you set the value much higher
 //   than 0.8 the curvature changes abruptly enough that though it is theoretically continuous, it may
@@ -2066,30 +2059,14 @@ function _rp_compute_patches(top, bot, rtop, rsides, ktop, ksides, concave) =
 //   construct a top that is a single point or two points.  This means you can completely round a cube by setting the joint to half of
 //   the cube's width.  
 //   If you set `debug` to true the module version will display the polyhedron even when it is invalid and it will show the bezier patches at the corners.
-//   This can help troubleshoot problems with your parameters.  With the function form setting debug to true causes run even on invalid cases and to return [patches,vnf] where
+//   This can help troubleshoot problems with your parameters.  With the function form setting debug to true causes it to return [patches,vnf] where
 //   patches is a list of the bezier control points for the corner patches.
 //   .
-//   This module offers five anchor types.  The default is "hull" in which VNF anchors are placed on the VNF of the **unrounded** object.  You
-//   can also use "intersect" to get the intersection anchors to the unrounded object. If you prefer anchors that respect the rounding
-//   then use "surf_hull" or "intersect_hull".  Lastly, in the special case of a prism with four sides, you can use "prismoid" anchoring
-//   which will attempt to assign standard prismoid anchors to the shape by assigning as RIGHT the face that is closest to the RIGHT direction,
-//   and defining the other anchors around the shape baesd on that choice.  
-//   .
 //   Note that rounded_prism() is not well suited to rounding shapes that have already been rounded, or that have many points.
 //   It works best when the top and bottom are polygons with well-defined corners.  When the polygons have been rounded already,
 //   further rounding generates tiny bezier patches patches that can more easily
 //   interfere, giving rise to an invalid polyhedron.  It's also slow because you get bezier patches for every corner in the model.  
 //   .
-// Named Anchors:
-//   "origin" = The native position of the prism.
-//   "top" = Top face, with spin BACK if face is parallel to the XY plane, or with positive Z otherwise
-//   "bot" = Bottom face, with spin BACK if face is parallel to the XY plane, or with positive Z otherwise
-//   "edge0", "edge1", etc. = Center of each side edge, spin pointing up along the edge
-//   "face0", "face1", etc. = Center of each side face, spin pointing up
-//   "top_edge0", "top_edge1", etc = Center of each top edge, spin pointing clockwise (from top)
-//   "bot_edge0", "bot_edge1", etc = Center of each bottom edge, spin pointing clockwise (from bottom)
-//   "top_corner0", "top_corner1", etc = Top corner, pointing in direction of associated edge anchor, spin up along associated edge
-//   "bot_corner0", "bot_2corner1", etc = Bottom corner, pointing in direction of associated edge anchor, spin up along associated edge
 // Arguments:
 //   bottom = 2d or 3d path describing bottom polygon
 //   top = 2d or 3d path describing top polygon (must be the same dimension as bottom)
@@ -2108,23 +2085,11 @@ function _rp_compute_patches(top, bot, rtop, rsides, ktop, ksides, concave) =
 //   anchor = Translate so anchor point is at the origin.  (module only) Default: "origin"
 //   spin = Rotate this many degrees around Z axis after anchor.  (module only) Default: 0
 //   orient = Vector to rotate top towards after spin  (module only)
-//   atype = Select "prismoid", "hull", "intersect", "surf_hull" or "surf_intersect" anchor types. (module only) Default: "hull"
+//   atype = Select "hull" or "intersect" anchor types.  (module only) Default: "hull"
 //   cp = Centerpoint for determining "intersect" anchors or centering the shape.  Determintes the base of the anchor vector.  Can be "centroid", "mean", "box" or a 3D point.  (module only) Default: "centroid"
 // Named Anchors:
-//   "top" = center of top face pointing normal to that face
+//   "origin" = The native position of the prism.
-//   "bot" = center of bottom face pointing normal to that face
-//   "edge0", "edge1", etc. = Center of each side edge, spin pointing up along the edge.  Can access with EDGE(i)
-//   "face0", "face1", etc. = Center of each side face, spin pointing up.  Can access with FACE(i)
-//   "top_edge0", "top_edge1", etc = Center of each top edge, spin pointing clockwise (from top). Can access with EDGE(TOP,i)
-//   "bot_edge0", "bot_edge1", etc = Center of each bottom edge, spin pointing clockwise (from bottom).  Can access with EDGE(BOT,i)
-//   "top_corner0", "top_corner1", etc = Top corner, pointing in direction of associated edge anchor, spin up along associated edge
-//   "bot_corner0", "bot_corner1", etc = Bottom corner, pointing in direction of associated edge anchor, spin up along associated edge
 // Anchor Types:
-//   hull = Anchors to the convex hull of the linear sweep of the path, ignoring any end roundings.  (default)
-//   intersect = Anchors to the surface of the linear sweep of the path, ignoring any end roundings.
-//   surf_hull = Anchors to the convex hull of the offset_sweep shape, including end treatments.
-//   surf_intersect = Anchors to the surface of the offset_sweep shape, including any end treatments.
-
 //   "hull" = Anchors to the virtual convex hull of the prism. 
 //   "intersect" = Anchors to the surface of the prism.
 // Example: Uniformly rounded pentagonal prism
@@ -2207,24 +2172,11 @@ module rounded_prism(bottom, top, joint_bot=0, joint_top=0, joint_sides=0, k_bot
                      k=0.5, splinesteps=16, h, length, l, height, convexity=10, debug=false,
                      anchor="origin",cp="centroid",spin=0, orient=UP, atype="hull")
 {
-  dummy1 = assert(in_list(atype, ["intersect","hull","surf_intersect","surf_hull","prismoid"]),
+  assert(in_list(atype, _ANCHOR_TYPES), "Anchor type must be \"hull\" or \"intersect\"");
-                  "Anchor type must be one of: \"hull\", \"intersect\", \"surf_hull\", \"surf_intersect\" or \"prismoid\"")
-           assert(atype!="prismoid" || len(bottom)==4, "Anchor type \"prismoid\" requires that len(bottom)=4");
   result = rounded_prism(bottom=bottom, top=top, joint_bot=joint_bot, joint_top=joint_top, joint_sides=joint_sides,
-                         k_bot=k_bot, k_top=k_top, k_sides=k_sides, k=k, splinesteps=splinesteps, h=h, length=length, height=height, l=l,
+                         k_bot=k_bot, k_top=k_top, k_sides=k_sides, k=k, splinesteps=splinesteps, h=h, length=length, height=height, l=l,debug=debug);
-                         debug=debug, _full_info=true);
+  vnf = debug ? result[1] : result;
-
+  attachable(anchor=anchor, spin=spin, orient=orient, vnf=vnf, extent=atype=="hull", cp=cp)
-  top = is_undef(top) ? path3d(bottom,height/2) :
-        len(top[0])==2 ? path3d(top,height/2) :
-        top;
-  bottom = len(bottom[0])==2 ? path3d(bottom,-height/2) : bottom;
-  unrounded = vnf_vertex_array([top,bottom],caps=true, col_wrap=true,reverse=true);
-
-  vnf = result[1];
-  geom = atype=="prismoid" ? attach_geom(size=[1,1,1],anchors=result[2], override=result[3])
-       : in_list(atype,["hull","intersect"]) ? attach_geom(vnf=unrounded, extent=atype=="hull", cp=cp, anchors=result[2])
-       : attach_geom(vnf=vnf, extent=atype=="surf_hull", cp=cp, anchors=result[2]);
-  attachable(anchor=anchor, spin=spin, orient=orient, geom=geom)
   {
     if (debug){
         vnf_polyhedron(vnf, convexity=convexity);
@@ -2237,7 +2189,7 @@ module rounded_prism(bottom, top, joint_bot=0, joint_top=0, joint_sides=0, k_bot
 
 
 function rounded_prism(bottom, top, joint_bot=0, joint_top=0, joint_sides=0, k_bot, k_top, k_sides, k=0.5, splinesteps=16,
-                       h, length, l, height, debug=false, _full_info=false) =
+                       h, length, l, height, debug=false) =
    let(
        bottom = force_path(bottom,"bottom"),
        top = force_path(top,"top")
@@ -2395,81 +2347,9 @@ function rounded_prism(bottom, top, joint_bot=0, joint_top=0, joint_sides=0, k_b
                           for(pts=edge_points) vnf_vertex_array(pts),
                           debug ? vnf_from_polygons(faces,fast=true) 
                                 : vnf_triangulate(vnf_from_polygons(faces))
-                       ]),
+                       ])
-        topnormal = unit(cross(top[0]-top[1],top[2]-top[1])),
-        botnormal = -unit(cross(bottom[0]-bottom[1],bottom[2]-bottom[1])),
-        sidenormal = [for(i=idx(top))
-                         unit(cross(select(top,i+1)-top[i], bottom[i]-top[i]))],
-
-        //pos, orient, spin, info=...
-        
-        anchors = [
-            for(i=idx(top))
-              let(
-                   face = concat(select(top,[i+1,i]), select(bottom,i,i+1)),
-                   face_ctr = mean(concat(select(top,[i+1,i]), select(bottom,i,i+1))),
-                   bot_edge = bottom[i]-select(bottom,i+1), 
-                   bot_edge_ctr = mean(select(bottom,i,i+1)),
-                   bot_edge_normal = unit(mean([sidenormal[i],botnormal])),
-                   top_edge_normal = unit(mean([sidenormal[i],topnormal])),
-                   top_edge = select(top,i+1)-top[i],
-                   top_edge_ctr = mean(select(top,i,i+1)),
-                   top_edge_dir = select(top,i+1)-top[i],
-                   edge = [top[i],bottom[i]],
-                   edge_ctr = mean([top[i],bottom[i]]),
-                   edge_normal = unit(mean(select(sidenormal,[i,i-1]))),
-                   top_corner_dir = _three_edge_corner_dir([select(sidenormal,i-1),sidenormal[i],topnormal],
-                                                           [top[i]-select(top,i-1), top_edge]),
-                   bot_corner_dir = _three_edge_corner_dir([select(sidenormal,i-1),sidenormal[i],botnormal],
-                                                           [bottom[i]-select(bottom,i-1), bot_edge])
     )
-              each[
+    debug ? [concat(top_patch, bot_patch), vnf] : vnf;
-                named_anchor(EDGE(i),edge_ctr,edge_normal, _compute_spin(edge_normal,top[i]-bottom[i]),
-                             info=[["edge_angle",180-vector_angle(sidenormal[i],select(sidenormal,i-1))], ["edge_length",norm(top[i]-bottom[i])]]),
-                named_anchor(EDGE(UP,i),top_edge_ctr, top_edge_normal, _compute_spin(top_edge_normal,  top_edge),
-                             info=[["edge_angle",180-vector_angle(topnormal,sidenormal[i])], ["edge_length",norm(top_edge)]]),
-                named_anchor(EDGE(DOWN,i),bot_edge_ctr, bot_edge_normal, _compute_spin(bot_edge_normal,  bot_edge),
-                             info=[["edge_angle",180-vector_angle(botnormal,sidenormal[i])], ["edge_length",norm(bot_edge)]]), 
-                named_anchor(FACE(i),mean(face), sidenormal[i], _compute_spin(sidenormal[i],UP)),
-                named_anchor(str("top_corner",i),top[i], top_corner_dir, _compute_spin(top_corner_dir,UP)), 
-                named_anchor(str("bot_corner",i),bottom[i], bot_corner_dir, _compute_spin(bot_corner_dir,UP)) 
-              ],
-            named_anchor("top", mean(top), topnormal, _compute_spin(topnormal, approx(v_abs(topnormal),UP)?BACK:UP)),
-            named_anchor("bot", mean(bottom), botnormal, _compute_spin(botnormal, approx(v_abs(botnormal),UP)?BACK:UP)),
-        ],
-        override = len(top)!=4 ? undef
-           :
-            let(
-                stddir = [RIGHT,FWD,LEFT,BACK],
-                getanch = function(name) search([name], anchors, num_returns_per_match=1)[0],
-                dir_angle = [for(i=[0:3])  vector_angle(anchors[6*i+3][2],RIGHT)],
-                ofs = search([min(dir_angle)], dir_angle, num_returns_per_match=1)[0]
-            )
-            [
-              [UP, select(anchors[24],1,3)],
-              [DOWN, select(anchors[25],1,3)],
-              for(i=[0:3])
-                let(
-                    edgeanch=anchors[((i+ofs)%4)*6],
-                    upedge=anchors[((i+ofs)%4)*6+1],
-                    downedge=anchors[((i+ofs)%4)*6+2],                    
-                    faceanch=anchors[((i+ofs)%4)*6+3],
-                    upcorner=anchors[((i+ofs)%4)*6+4],
-                    downcorner=anchors[((i+ofs)%4)*6+5]
-                )    
-                each [
-                      [stddir[i],select(faceanch,1,3)],
-                      [stddir[i]+select(stddir,i-1), select(edgeanch,1,3)],
-                      [stddir[i]+UP, select(upedge,1,3)], 
-                      [stddir[i]+DOWN, select(downedge,1,3)],
-                      [stddir[i]+select(stddir,i-1)+UP, select(upcorner,1,3)],
-                      [stddir[i]+select(stddir,i-1)+DOWN, select(downcorner,1,3)],
-                     ] 
-           ]
-    )
-    !debug && !_full_info ? vnf
-  : _full_info ? [concat(top_patch, bot_patch), vnf, anchors, override]
-  : [concat(top_patch, bot_patch), vnf];
 
 
 

shapes3d.scad

@@ -599,8 +599,8 @@ function cuboid(
 //   specifying `size2=[100,undef]` sets the size in the X direction but allows the size in the Y direction to be computed based on yang.
 //   .
 //   The anchors on the top and bottom faces have spin pointing back.  The anchors on the side faces have spin point UP.
-//   The anchors on the top and bottom edges also have anchors that point clockwise as viewed from outside the shapep.
+//   The anchors on the top and bottom edges also have anchors that point up.  The anchors on the side edges and the corners
-//   The anchors on the side edges and the corners have spin with positive Z component, pointing along the edge where the anchor is located.
+//   have spin with positive Z component, pointing along the edge where the anchor is located. 
 // Arguments:
 //   size1 = [width, length] of the bottom end of the prism.
 //   size2 = [width, length] of the top end of the prism.
@@ -835,7 +835,7 @@ function octahedron(size=1, anchor=CENTER, spin=0, orient=UP) =
 // Synopsis: Creates a regular prism with roundovers and chamfering
 // SynTags: Geom, VNF
 // Topics: Textures, Rounding, Chamfers
-// See Also: cyl(), rounded_prism(), texture(), linear_sweep(), EDGE(), FACE()
+// See Also: cyl(), rounded_prism(), texture(), linear_sweep()
 // Usage: Normal prisms
 //   regular_prism(n, h|l=|height=|length=, r, [center=], [realign=]) [ATTACHMENTS];
 //   regular_prism(n, h|l=|height=|length=, d=|id=|od=|ir=|or=|side=, ...) [ATTACHMENTS];
@@ -863,24 +863,22 @@ function octahedron(size=1, anchor=CENTER, spin=0, orient=UP) =
 //   .
 //   Anchors are based on the VNF of the prism.  Especially for tapered or shifted prisms, this may give unexpected anchor positions, such as top side anchors
 //   being located at the bottom of the shape, so confirm anchor positions before use.  
-//   Additional named face and edge anchors are located on the side faces and vertical edges of the prism.
+//   Additional face and edge anchors are located on the side faces and vertical edges of the prism.
-//   You can use `EDGE(i)`, `EDGE(TOP,i)` and `EDGE(BOT,i)` as a shorthand for accessing the named edge anchors, and `FACE(i)` for the face anchors.
+//   When you use `shift`, which moves the top face of the prism, the spin for the side face and edges anchors will align the child with the edge or face direction.
-//   When you use `shift`, which moves the top face of the prism, the spin for the side face and edges anchors will align
+//   Named anchors located along the top and bottom edges and corners are pointed in the direction of the associated face or edge to enable positioning
-//   the child with the edge or face direction.  The "edge0" anchor identifies an edge located along the X+ axis, and then edges
+//   in the direction of the side faces but positioned at the top/bottom, since {{align()}} cannot be used for this task.  These edge and corners anchors do
-//   are labeled counting up in the clockwise direction.  Similarly "face0" is the face immediately clockwise from "edge0", and face
+//   not split the edge/corner angle like the standard anchors.  
-//   labeling proceeds clockwise.  The top and bottom edge anchors label edges directly above and below the face with the same label.
-//   If you set `realign=true` then "face0" is oriented in the X+ direction.  
 //   .
 //   This module is very similar to {{cyl()}}.  It differs in the following ways:  you can specify side length or inner radius/diameter, you can apply roundings with
 //   different `$fn` than the number of prism faces, you can apply texture to the flat faces without forcing a high facet count,
 //   anchors are located on the true object instead of the ideal cylinder and you can anchor to the edges and faces.  
 // Named Anchors:
-//   "edge0", "edge1", etc. = Center of each side edge, spin pointing up along the edge.  Can access with EDGE(i)
+//   "edge0", "edge1", etc. = Center of each side edge, spin pointing up along the edge
-//   "face0", "face1", etc. = Center of each side face, spin pointing up.  Can access with FACE(i)
+//   "face0", "face1", etc. = Center of each side face, spin pointing up
-//   "top_edge0", "top_edge1", etc = Center of each top edge, spin pointing clockwise (from top). Can access with EDGE(TOP,i)
+//   "topedge0", "topedge1", etc = Center of each top edge, pointing in direction of associated side face, spin up
-//   "bot_edge0", "bot_edge1", etc = Center of each bottom edge, spin pointing clockwise (from bottom).  Can access with EDGE(BOT,i)
+//   "botedge0", "botedge1", etc = Center of each bottom edge, pointing in direction of associated side face, spin up
-//   "top_corner0", "top_corner1", etc = Top corner, pointing in direction of associated edge anchor, spin up along associated edge
+//   "topcorner0", "topcorner1", etc = Top corner, pointing in direction of associated edge anchor, spin up along associated edge
-//   "bot_corner0", "bot_corner1", etc = Bottom corner, pointing in direction of associated edge anchor, spin up along associated edge
+//   "botcorner0", "botcorner1", etc = Bottom corner, pointing in direction of associated edge anchor, spin up along associated edge
 // Arguments:
 //   l / h / length / height = Length of prism
 //   r = Outer radius of prism.  
@@ -1133,18 +1131,33 @@ function regular_prism(n,
         ovnf = apply(skmat, vnf),
         edge_face = [ [r2-r1,0,height],[(r2-r1)/sc,0,height]],  // regular edge, then face edge, in xz plane
         names = ["edge","face"],
-        anchors = let(
+        anchors = approx(shift,[0,0]) ? 
+                     [for(i=[0:n-1], j=[0:1])
+                       let(
+                           M = zrot(-(i+j/2-(realign?1/2:0))*360/n),
+                           edge =  apply(M,edge_face[j]),
+                           dir = apply(M,[height,0,-edge_face[j].x]),
+                           spin = sign(dir.x)*vector_angle(edge - (edge*dir)*dir, rot(from=UP,to=dir,p=BACK))
+                       )
+                       each [
+                          named_anchor(str(names[j],i), apply(M,[(r1+r2)/2/(j==0?1:sc),0,0]), dir, spin),
+                          named_anchor(str(j==0?"top_corner":"top_edge",i), apply(M,[r2/(j==0?1:sc),0,height/2]), dir, spin),
+                          named_anchor(str(j==0?"bot_corner":"bot_edge",i), apply(M,[r1/(j==0?1:sc),0,-height/2]), dir, spin),                      
+                       ]
+                     ]
+                :
+                  let(
                       faces = [
                                for(i=[0:n-1])
                                   let(
-                                      M1 = skmat*zrot(-i*360/n),      // map to point i
+                                      M1 = skmat*zrot(-i*360/n),
-                                      M2 = skmat*zrot(-(i+1)*360/n),  // map to point i+1
+                                      M2 = skmat*zrot(-(i+1)*360/n),
-                                      edge1 = apply(M1,[[r2,0,height/2], [r1,0,-height/2]]),  // "vertical" edge at i
+                                      edge1 = apply(M1,[[r2,0,height/2], [r1,0,-height/2]]),
-                                      edge2 = apply(M2,[[r2,0,height/2], [r1,0,-height/2]]),  // "vertical" edge at i+1
+                                      edge2 = apply(M2,[[r2,0,height/2], [r1,0,-height/2]]),
-                                      face_edge = (edge1+edge2)/2,         // "vertical" edge across side face between i and i+1
+                                      face_edge = (edge1+edge2)/2,
                                       facenormal = unit(cross(edge1[0]-edge1[1], edge2[1]-edge1[0]))
-                                  )   // [normal to face, edge through face center vector, actual edge vector, top edge vector]
+                                  )
-                                  [facenormal,face_edge[0]-face_edge[1],edge1[0]-edge1[1],edge2[0]-edge1[0]]  
+                                  [facenormal,face_edge[0]-face_edge[1],edge1[0]-edge1[1]]  // [normal to face, edge through face center, actual edge]
                               ]
                   )
                   [for(i=[0:n-1])
@@ -1152,34 +1165,20 @@ function regular_prism(n,
                            Mface = skmat*zrot(-(i+1/2)*360/n),
                            faceedge = faces[i][1],
                            facenormal = faces[i][0], 
-                           //facespin = _compute_spin(facenormal, faceedge), // spin along centerline of face instead of pointing up---seems to be wrong choice
+                           //facespin = _compute_spin(facenormal, faceedge), // spin along centerline of face instea of pointing up---seems to be wrong choice
                            facespin = _compute_spin(facenormal, UP), 
                            edgenormal = unit(vector_bisect(facenormal,select(faces,i-1)[0])),
                            Medge = skmat*zrot(-i*360/n),
                            edge = faces[i][2], 
-                           edgespin = _compute_spin(edgenormal, edge),
+                           edgespin = _compute_spin(edgenormal, edge)
-                           topedge = unit(faces[i][3]),
-                           topnormal = unit(facenormal+UP),
-                           botnormal = unit(facenormal+DOWN),
-                           topedgespin = _compute_spin(topnormal, topedge),
-                           botedgespin = _compute_spin(botnormal, -topedge),
-                           topedgeangle = 180-vector_angle(UP,facenormal),
-                           sideedgeangle = 180-vector_angle(facenormal, select(faces,i-1)[0]),
-                           edgelen = norm(select(faces,i)[2])
                       )
                       each [
                           named_anchor(str("face",i), apply(Mface,[(r1+r2)/2/sc,0,0]), facenormal, facespin),
-                          named_anchor(str("edge",i), apply(Medge,[(r1+r2)/2,0,0]), edgenormal, edgespin,
+                          named_anchor(str("edge",i), apply(Medge,[(r1+r2)/2,0,0]), edgenormal, edgespin),
-                                       info=[["edge_angle",sideedgeangle], ["edge_length",edgelen]]),
+                          named_anchor(str("top_edge",i), apply(Mface,[r2/sc,0,height/2]), facenormal, facespin),
-                          named_anchor(str("top_edge",i), apply(Mface,[r2/sc,0,height/2]), topnormal, topedgespin,
+                          named_anchor(str("top_corner",i), apply(Medge,[r2,0,height/2]), edgenormal, edgespin),
-                                       info=[["edge_angle",topedgeangle],["edge_length",2*sin(180/n)*r2]]),
+                          named_anchor(str("bot_edge",i), apply(Mface,[r1/sc,0,-height/2]), facenormal, facespin),
-                          named_anchor(str("bot_edge",i), apply(Mface,[r1/sc,0,-height/2]), botnormal, botedgespin,
+                          named_anchor(str("bot_corner",i), apply(Medge,[r1,0,-height/2]), edgenormal, edgespin)
-                                       info=[["edge_angle",180-topedgeangle],["edge_length",2*sin(180/n)*r1]]),
-                          named_anchor(str("top_corner",i), apply(Medge,[r2,0,height/2]), unit(edgenormal+UP),
-                                       _compute_spin(unit(edgenormal+UP),edge)),
-                          named_anchor(str("bot_corner",i), apply(Medge,[r1,0,-height/2]), unit(edgenormal+DOWN),
-                                       _compute_spin(unit(edgenormal+DOWN),edge))
-                          
                       ]
                   ],
         override = approx(shift,[0,0]) ? undef : [[UP, [point3d(shift,height/2), UP]]],
@@ -3667,34 +3666,20 @@ module path_text(path, text, font, size, thickness, lettersize, offset=0, revers
 // Description:
 //   Creates a shape that can be unioned into a concave joint between two faces, to fillet them.
 //   Note that this module is the same as {{rounding_edge_mask()}}, except that it does not
-//   apply the default "remove" tag and has a different default angle.
+//   apply the default "remove" tag.  
-//   It can be convenient to {{attach()}} the fillet to the edge of a parent object.
+//
-//   Many objects propagate the $edge_angle and $edge_length which are used as defaults for the fillet.
-//   If you attach the fillet to the edge, it will be hovering in space and you need to apply {{yrot()}}
-//   to place it on the parent object, generally either 90 degrees or -90 degrees dependong on which
-//   face you want the fillet.  
 // Usage: 
-//   fillet(l|h=|length=|height=, r|d=, [ang=], [excess=], [rounding=|chamfer=]) [ATTACHMENTS];
+//   fillet(l|h=|length=|height=, r|d=, [ang=], [excess=]) [ATTACHMENTS];
-//   fillet(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=], [rounding=|chamfer=]) [ATTACHMENTS];
+//   fillet(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=]) [ATTACHMENTS];
 //
 // Arguments:
-//   l/h/length/height = Length of mask.  Default: $edge_length if defined
+//   l / length / h / height = Length of edge to fillet.
-//   r = Radius of the rounding.
+//   r = Radius of fillet.
-//   ang = Angle between faces for rounding.  Default: 180-$edge_angle if defined, otherwise 90
+//   ang = Angle between faces to fillet.
+//   excess = Overlap size for unioning with faces.
 //   ---
-//   r1 = Bottom radius of fillet.
+//   d = Diameter of fillet.
-//   r2 = Top radius of fillet.
+//   anchor = Translate so anchor point is at origin (0,0,0).  See [anchor](attachments.scad#subsection-anchor).  Default: `FRONT+LEFT`
-//   d = Diameter of the fillet.
-//   d1 = Bottom diameter of fillet.
-//   d2 = Top diameter of fillet.
-//   excess = Extra size for the fillet.  Defaults: .1
-//   rounding = Radius of roundong along ends.  Default: 0
-//   rounding1 = Radius of rounding along bottom end
-//   rounding2 = Radius of rounding along top end
-//   chamfer = Chamfer size of end chamfers.  Default: 0
-//   chamfer1 = Chamfer size of chamfer at bottom end
-//   chamfer2 = Chamfer size of chamfer at top end
-//   anchor = Translate so anchor point is at origin (0,0,0).  See [anchor](attachments.scad#subsection-anchor).  Default: `CENTER`
 //   spin = Rotate this many degrees around the Z axis after anchor.  See [spin](attachments.scad#subsection-spin).  Default: `0`
 //   orient = Vector to rotate top towards, after spin.  See [orient](attachments.scad#subsection-orient).  Default: `UP`
 //
@@ -3728,14 +3713,6 @@ module path_text(path, text, font, size, thickness, lettersize, offset=0, revers
 //     align(TOP,RIGHT,inset=10) fillet(l=50,r=10,orient=FWD);
 //     align(TOP,RIGHT,inset=20) cuboid([4,50,20],anchor=BOT);
 //   }   
-// Example(3D,VPT=[3.03052,-2.34905,8.07573],VPR=[70.4,0,326.2],VPD=82.6686): Automatic positioning of the fillet at the odd angle of this shifted prismoid is simple using {{attach()}} with the inherited $edge_angle.  
-//  $fn=64;
-//  prismoid([20,15],[12,17], h=10, shift=[3,5]){
-//    attach(TOP+RIGHT,FWD+LEFT,inside=false)  
-//      yrot(90)fillet(r=4);
-//    attach(RIGHT,BOT)
-//      cuboid([22,22,2]);
-//  }
 
 module interior_fillet(l=1.0, r, ang=90, overlap=0.01, d, length, h, height, anchor=CENTER, spin=0, orient=UP)
 {
@@ -3745,13 +3722,9 @@ module interior_fillet(l=1.0, r, ang=90, overlap=0.01, d, length, h, height, anc
 
 
 function fillet(l, r, ang, r1, r2, d, d1, d2, excess=0.1, anchor=CENTER, spin=0, orient=UP, h,height,length) = no_function("fillet");
-module fillet(l, r, ang, r1, r2, excess=0.01, d1, d2,d,length, h, height, anchor=CENTER, spin=0, orient=UP,
+module fillet(l, r, ang=90, r1, r2, excess=0.01, d1, d2,d,length, h, height, anchor=CENTER, spin=0, orient=UP)
-                                        rounding,rounding1,rounding2,chamfer,chamfer1,chamfer2)
 {
-  ang = first_defined([ang, u_add(u_mul($edge_angle,-1),180), 90]);
-  //echo(ang,180-$edge_angle);
   rounding_edge_mask(l=l, r1=r1, r2=r2, ang=ang, excess=excess, d1=d1, d2=d2,d=d,r=r,length=length, h=h, height=height,
-                     chamfer1=chamfer1, chamfer2=chamfer2, chamfer=chamfer, rounding1=rounding1, rounding2=rounding2, rounding=rounding,
                      anchor=anchor, spin=spin, orient=orient, _remove_tag=false)
     children();
 }