Merge branch 'master' into issue1692

Author: revarbat

README.md

@@ -15,13 +15,13 @@ Requires OpenSCAD 2021.01 or later.
 
 The BOSL2 library is an enormous library that provides many different kinds of capabilities to simplify the development of models in OpenSCAD, and to make things possible that are difficult in native OpenSCAD.  Some of the things BOSL2 provides are:
 
-* **Attachments.**  Unless you make models containing just one object the attachments features can revolutionize your modeling.  They let you position components of a model relative to other components so you don't have to keep track of the positions and orientations of parts of the model.  You can instead place an something on the TOP of something else, perhaps aligned to the RIGHT.  For a full introduction to attachments, consult the [Attachments Tutorial.](https://github.com/BelfrySCAD/BOSL2/wiki/Tutorial-Attachments)
-* **Rounding and filleting.**  Rounding and filleting is hard in OpenSCAD.  The library provides modules like [cuboid()](https://github.com/BelfrySCAD/BOSL2/wiki/shapes3d.scad#module-cuboid) to make a cube with any of the edges rounded, [offset_sweep()](https://github.com/BelfrySCAD/BOSL2/wiki/rounding.scad#functionmodule-offset_sweep) to round the ends of a linear extrusion, and [prism_connector()](https://github.com/BelfrySCAD/BOSL2/wiki/rounding.scad#module-prism_connector) which works with the attachments feature to create filleted prisms between a variety of objects, or even rounded holes through a single object.  You can also use [edge_profile()](https://github.com/BelfrySCAD/BOSL2/wiki/attachments.scad#module-edge_profile) to apply a variety of different mask profiles to chosen edges of a cubic shape, or you can directly subtract 3d mask shapes from an edge of objects that are not cubes. 
+* **Attachments.**  Unless you make models containing just one object, the attachments features can revolutionize your modeling.  They let you position components of a model relative to other components so you don't have to keep track of the positions and orientations of parts of the model.  You can instead place something on the TOP of something else, perhaps aligned to the RIGHT.  For a full introduction to attachments, consult the [Attachments Tutorial.](https://github.com/BelfrySCAD/BOSL2/wiki/Tutorial-Attachments)
+* **Rounding and filleting.**  Rounding and filleting is hard in OpenSCAD.  The library provides modules like [cuboid()](https://github.com/BelfrySCAD/BOSL2/wiki/shapes3d.scad#module-cuboid) to make a cube with any of the edges rounded, [offset_sweep()](https://github.com/BelfrySCAD/BOSL2/wiki/rounding.scad#functionmodule-offset_sweep) to round the ends of a linear extrusion, and [prism_connector()](https://github.com/BelfrySCAD/BOSL2/wiki/rounding.scad#module-prism_connector) which works with the attachments feature to create filleted prisms between a variety of objects, or holes through a single object with rounded edges at the ends.  You can also use [edge_profile()](https://github.com/BelfrySCAD/BOSL2/wiki/attachments.scad#module-edge_profile) to apply a variety of different mask profiles to chosen edges of a cubic shape, or you can directly subtract 3d mask shapes from an edge of objects that are not cubes. 
 * **Complex object support.**  The [path_sweep()](https://github.com/BelfrySCAD/BOSL2/wiki/skin.scad#functionmodule-path_sweep) function/module takes a 2d polygon moves it through space along a path and sweeps out a 3d shape as it moves.  You can link together a series of arbitrary polygons with [skin()](https://github.com/BelfrySCAD/BOSL2/wiki/skin.scad#functionmodule-skin) or [vnf_vertex_array().](https://github.com/BelfrySCAD/BOSL2/wiki/vnf.scad#functionmodule-vnf_vertex_array)  Support for [beziers](https://github.com/BelfrySCAD/BOSL2/wiki/beziers.scad) and [NURBS](https://github.com/BelfrySCAD/BOSL2/wiki/nurbs.scad) can help you construct the building blocks you need.  [Metaballs](https://github.com/BelfrySCAD/BOSL2/wiki/isosurface.scad#functionmodule-metaballs) can create organic surfaces that blend shapes together.  
 * **Building Blocks.** OpenSCAD provides cubes, cones and spheres.  The BOSL2 library extends this to provide different kinds of prisms, tubes, and other abstract geometrical building blocks. In many cases the BOSL2 objects include options to round their edges.  Basic objects have extensions like the ability to specify the **inner** radius of a circle to create holes with a guaranteed minimum size.  
 * **Texturing.**  Many kinds of objects can be created with [textures](https://github.com/BelfrySCAD/BOSL2/wiki/skin.scad#section-texturing) applied.  This can create knurling, but it can do much more than that.  A texture can be any repeating pattern, and applying a texture can actually replace the base object with something different based on repeating copies of the texture element.  A texture can also be an image; using texturing you can emboss an arbitrary image onto your model. 
 * **Parts library.**  The parts library includes many useful specific functional parts including [gears](https://github.com/BelfrySCAD/BOSL2/wiki/gears.scad), generic [threading](https://github.com/BelfrySCAD/BOSL2/wiki/threading.scad#section-generic-threading), and specific threading to match plastic [bottles](https://github.com/BelfrySCAD/BOSL2/wiki/bottlecaps.scad), [pipe fittings](https://github.com/BelfrySCAD/BOSL2/wiki/threading.scad#module-npt_threaded_rod), or standard [screws.](https://github.com/BelfrySCAD/BOSL2/wiki/screws.scad)  Also included are [clips](https://github.com/BelfrySCAD/BOSL2/wiki/joiners.scad#section-tension-clips), [hinges](https://github.com/BelfrySCAD/BOSL2/wiki/hinges.scad), and [dovetail joints.](https://github.com/BelfrySCAD/BOSL2/wiki/joiners.scad#section-dovetails)
-* **Shorthands.** The shorthands make your code a little shorter, and more importantly, they can make it significantly easier to read.  Compare `up(x)` to `translate([0,0,x])`.  The shorthands include operations for creating [copies of objects](https://github.com/BelfrySCAD/BOSL2/wiki/distributors.scad) and for applying [transformations](https://github.com/BelfrySCAD/BOSL2/wiki/transforms.scad) to objects, including [rot()](https://github.com/BelfrySCAD/BOSL2/wiki/transforms.scad#functionmodule-rot) which extends rotate in some useful ways that are not easy to do directly. 
+* **Shorthands.** The shorthands make your code a little shorter, and more importantly, they can make it significantly easier to read.  Compare `up(z)` to `translate([0,0,z])`.  The shorthands include operations for creating [copies of objects](https://github.com/BelfrySCAD/BOSL2/wiki/distributors.scad) and for applying [transformations](https://github.com/BelfrySCAD/BOSL2/wiki/transforms.scad) to objects, including [rot()](https://github.com/BelfrySCAD/BOSL2/wiki/transforms.scad#functionmodule-rot) which extends rotate in some useful ways that are not easy to do directly. 
 * **Geometrical operations on data.**  In OpenSCAD, geometrical operations happen on geometry, and information can never be extracted from geometry.  The BOLS2 library provides operations on 2d point lists (called "paths" or "regions") to make [rounded paths](https://github.com/BelfrySCAD/BOSL2/wiki/rounding.scad#function-round_corners) from ones with corners or do operations like [intersection](https://github.com/BelfrySCAD/BOSL2/wiki/regions.scad#functionmodule-intersection) and [offset](https://github.com/BelfrySCAD/BOSL2/wiki/regions.scad#function-offset).  It can also do some limited operations on three dimensional data.
 * **Programming aids.** The library provides basic [mathematical operations](https://github.com/BelfrySCAD/BOSL2/wiki/math.scad) including solutions to [linear systems of equations](https://github.com/BelfrySCAD/BOSL2/wiki/linalg.scad#function-linear_solve) and [generic](https://github.com/BelfrySCAD/BOSL2/wiki/math.scad#function-root_find) and [polynomial](https://github.com/BelfrySCAD/BOSL2/wiki/math.scad#function-real_roots) numerical root finding.  It provides [geometrical operations](https://github.com/BelfrySCAD/BOSL2/wiki/geometry.scad) like [line intersection](https://github.com/BelfrySCAD/BOSL2/wiki/geometry.scad#function-line_intersection) or [circle intersection](https://github.com/BelfrySCAD/BOSL2/wiki/geometry.scad#function-circle_circle_intersection), [coordinate transformations](https://github.com/BelfrySCAD/BOSL2/wiki/coords.scad), [string manipulation,](https://github.com/BelfrySCAD/BOSL2/wiki/strings.scad) and [list processing](https://github.com/BelfrySCAD/BOSL2/wiki/lists.scad).   
 

attachments.scad

@@ -4079,81 +4079,94 @@ function _find_anchor(anchor, geom)=
         let(
             rpts = apply(rot(from=anchor, to=RIGHT) * move(point3d(-cp)), vnf[0]),
             maxx = max(column(rpts,0)),
-            idxs = [for (i = idx(rpts)) if (approx(rpts[i].x, maxx)) i],
-            // We want to catch the case where the points lie on an edge.  The complication is that the edge
-            // may appear twice WITH DIFFERENT VERTEX INDICES if repeated points appear in the vnf.  
-            edges_faces = len(idxs)==2 ?  // Simple case, no repeated points, [idxs] gives the edge
-                               approx(vnf[0][idxs[0]],vnf[0][idxs[1]]) ? []   // Are edge points identical?
-                             : let( facelist = _vnf_find_edge_faces(vnf,idxs))
-                               len(facelist)==2 ? [[idxs], facelist] : []
-                        : len(idxs)!=4 ? []       // If we don't have four points it's not an edge pair
-                        : let(
-                              pts = select(vnf[0],idxs),
-                              matchind = [for(i=[1:3]) if (approx(pts[i],pts[0])) i]   // indices where actual vertex point is the same as point zero
-                          )
-                          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]]),
-                              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,
-            dir = len(idxs)>2 && edges_faces==[] ? [anchor,oang]
-                : edges_faces!=[] ?
-                    let( 
-                        faces = edges_faces[1],
-                        edge = select(vnf[0],edges_faces[0][0]),
-                        facenormals = [for(face=faces) polygon_normal(select(vnf[0],vnf[1][face]))],
-                        direction= unit(mean(facenormals)),
-                        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],
-                        spin = horiz_face==[] ?
-                                   let(  
-                                       edgedir = edge[1]-edge[0],
-                                       nz = [for(i=[0:2]) if (!approx(edgedir[i],0)) i],
-                                       flip = edgedir[last(nz)] < 0 ? -1 : 1
-                                   )
-                                   _compute_spin(direction, flip*edgedir)
-                            :
-                                let(
-                                       hedge = len(edges_faces[0])==1 ? edges_faces[0][0]
-                                                                      : edges_faces[0][horiz_face[0]],
-                                       face = select(vnf[1],faces[horiz_face[0]]),
-                                       edgeind = search([hedge[0]], face)[0],
-                                       flip = select(face,edgeind+1)== hedge[1] ? 1 : -1, 
-                                       edgedir = edge[1]-edge[0]
-                                   )
-                                   _compute_spin(direction, flip*edgedir)
-                    ) 
-                    [direction,spin,[["edge_angle",ang],["edge_length",norm(edge[0]-edge[1])]]]
-                :   let(   // This section handles corner anchors, currently spins just point up
-                       vertices = vnf[0],
-                       faces = vnf[1],
-                       cornerfaces = _vnf_find_corner_faces(vnf,idxs[0]),    // faces = [3,9,12] indicating which faces
-                       normals = [for(faceind=cornerfaces) polygon_normal(select(vnf[0], faces[faceind]))],
-                       angles = [for(faceind=cornerfaces)
-                                    let(
-                                        thisface = faces[faceind],
-                                        vind = search(idxs[0],thisface)[0]
-                                    )
-                                    vector_angle(select(vertices, select(thisface,vind-1,vind+1)))
-                                 ],
-                       direc = unit(angles*normals)
-                    )
-                    [direc, atan2(direc.y,direc.x)+90],
-            avep = sum(select(rpts,idxs))/len(idxs),
-            mpt = approx(point2d(anchor),[0,0])? [maxx,0,0] : avep,
-            pos = point3d(cp) + rot(from=RIGHT, to=anchor, p=mpt)
-        ) [anchor, default(override[0],pos),default(override[1],dir[0]),default(override[2],dir[1]),if (len(dir)==3) dir[2]]
+
+            idxmax = [for (i = idx(rpts)) approx(rpts[i].x, maxx)],
+            idxs = [for (i = idx(rpts)) if(approx(rpts[i].x, maxx)) i],
+            veflist=[
+                     for(face=vnf[1])
+                       let(
+                           facemax = [for(vertind=face) if (idxmax[vertind]) vertind],
+                           flip = facemax[0]==face[0] && facemax[1]==last(face)
+                       )
+                       [
+                         if (len(facemax)==1) facemax else [],
+                         if (len(facemax)==2) (flip ? reverse(facemax):facemax) else [],
+                         if (len(facemax)>2) facemax else []
+                       ]],
+            vlist = [for(i=idx(veflist)) if (veflist[i][0]!=[]) veflist[i][0]],
+            elist = [for(i=idx(veflist)) if (veflist[i][1]!=[] && !approx(rpts[veflist[i][1][0]],rpts[veflist[i][1][1]])) veflist[i][1]],
+            flist = [for(i=idx(veflist)) if (veflist[i][2]!=[])  veflist[i][2]],
+            faceinfo = [for(face=flist) let(poly=select(vnf[0],face)) [polygon_area(poly), centroid(poly)]],  //[ area, centroid]
+            facearea = len(faceinfo)==0 ? 0 : sum(column(faceinfo,0)),
+            basic_spin = _compute_spin(anchor, v_abs(anchor)==UP ? BACK: UP),
+            res = len(flist)>0 && !approx(facearea,0) ?
+                      let(
+                          center = column(faceinfo,0)*column(faceinfo,1)/facearea
+                      )
+                      [center,anchor,basic_spin]
+                : len(elist)==2 ?  // One edge (which appears twice, once in each direction)
+                      let(
+                          edge = select(vnf[0],elist[0]),
+                          center = mean(edge),
+                          edgefaces = _vnf_find_edge_faces(vnf,elist), //unique([for(e=elist) each _vnf_find_edge_faces(vnf,e)]),
+                          facenormals = [for(face=edgefaces) polygon_normal(select(vnf[0],vnf[1][face]))],
+                          direction = unit(mean(facenormals)),
+                          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],  // index of horizontal face, at most one exists
+                          spin = horiz_face==[] ?
+                                     let(
+                                         edgedir = edge[1]-edge[0],
+                                         nz = [for(i=[0:2]) if (!approx(edgedir[i],0)) i],
+                                         flip = edgedir[last(nz)] < 0 ? -1 : 1
+                                     )
+                                     _compute_spin(direction, flip*edgedir)
+                                  :
+                                     let(  // Determine whether the edge is the right or wrong direction compared to the horizongal face
+                                           // which will determine what clockwise means so we can assign spin
+                                         face = select(vnf[1],edgefaces[horiz_face[0]]),
+                                         endptidx=search(column(elist,0),face),
+                                         hedge = elist[endptidx[0]!=[] ? 0:1],
+                                         edgedir = deltas(select(vnf[0],hedge))[0],
+                                         flip = select(face,flatten(endptidx)[0]+1)== hedge[1] ? 1 : -1
+                                     )
+                                     _compute_spin(direction, flip*edgedir)
+                      )
+                      [center,direction,spin,[["edge_angle",ang],["edge_length",norm(edge[1]-edge[0])]]]
+                : len(elist)>2 ?   // multiple edges, which must be coplanar, use average of edge endpoints
+                      let(
+                           plist = select(vnf[0],flatten(edge)),
+                           center = mean(plist)
+                      )
+                      [center,anchor,basic_spin]
+                : len(vlist)==0 ? assert(false,"Cannot find anchor on the VNF")
+                : let(
+                      vlist = flatten(vlist),
+                      uind = unique_approx_indexed(select(vnf[0],vlist)),
+                      ulist = select(vlist,uind)
+                  )
+                  len(ulist)>1 ?   // Multiple vertices: return average
+                      let(
+                           center = mean(select(vnf[0],ulist))
+                      )
+                      [center, anchor, basic_spin]
+                : let(    // one vertex case
+                      vuniq = unique(vlist),
+                      vertices = vnf[0],
+                      faces = vnf[1],
+                      cornerfaces = _vnf_find_corner_faces(vnf,vuniq),    // faces = [3,9,12] indicating which faces
+                      normals = [for(faceind=cornerfaces) polygon_normal(select(vertices, faces[faceind]))],
+                      angles = [for(faceind=cornerfaces)
+                                  let(
+                                       thisface = faces[faceind],
+                                       vind = flatten(search(vuniq,thisface))[0]
+                                  )
+                                  vector_angle(select(vertices, select(thisface,vind-1,vind+1)))
+                               ],
+                             direc = unit(angles*normals)
+                   )
+                   [vnf[0][ulist[0]], direc, atan2(direc.y,direc.x)+90]
+        ) [anchor, default(override[0],res[0]),default(override[1],res[1]),default(override[2],res[2]),if (len(res)==3) res[2]]        
     ) : type == "trapezoid"? ( //size, size2, shift, override
         let(all_comps_good = [for (c=anchor) if (c!=sign(c)) 1]==[])
         assert(all_comps_good, "All components of an anchor for a rectangle/trapezoid must be -1, 0, or 1")