ship 3.2.1

umber -> number in readme

LICENSE

@@ -1,7 +1,7 @@
                    GNU LESSER GENERAL PUBLIC LICENSE
                        Version 3, 29 June 2007
 
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 

LICENSE.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="84" height="20"><linearGradient id="b" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient><clipPath id="a"><rect width="84" height="20" rx="3" fill="#fff"/></clipPath><g clip-path="url(#a)"><path fill="#555" d="M0 0h47v20H0z"/><path fill="#007ec6" d="M47 0h37v20H47z"/><path fill="url(#b)" d="M0 0h84v20H0z"/></g><g fill="#fff" text-anchor="middle" font-family="DejaVu Sans,Verdana,Geneva,sans-serif" font-size="11"><text x="23.5" y="15" fill="#010101" fill-opacity=".3">license</text><text x="23.5" y="14">license</text><text x="64.5" y="15" fill="#010101" fill-opacity=".3">LGPL</text><text x="64.5" y="14">LGPL</text></g></svg>

README.md

@@ -1,32 +1,28 @@
-# dotSCAD 3.0
+# dotSCAD 3.2.1
 
 > **Reduce the burden of mathematics/algorithm when playing OpenSCAD.**
 
-![dotSCAD](featured_img/RandomCityTaiwan.JPG)
-
-[![license/LGPL](LICENSE.svg)](https://github.com/JustinSDK/lib-openscad/blob/master/LICENSE)
+![dotSCAD](featured_img/Owls.JPG)
 
 ## Introduction
 
-**This version Breaks Backward Compatibility and requires OpenSCAD 2021.01 or later!! Please see [Release Notes](RELEASE.md). You can still download v2.5 or older versions from [Releases](https://github.com/JustinSDK/dotSCAD/tags).**
-
 Some of my [3D models](https://github.com/JustinSDK/dotSCAD#examples) require complex mathematics/algorithm. I extract them into dotSCAD. Hope it helps when you're playing OpenSCAD.
 
 The idea of the name dotSCAD comes from the filename extension ".scad" of OpenSCAD. 
 
-## Get Started
+## Getting started
 
-OpenSCAD uses three library locations, the installation library, built-in library, and user defined libraries. It's convenient to set `OPENSCADPATH`. Check [Setting OPENSCADPATH](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Libraries#Setting_OPENSCADPATH) in [OpenSCAD User Manual/Libraries](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Libraries) for details.
+OpenSCAD uses three library locations, the installation library, built-in library, and user defined libraries. Check [Setting OPENSCADPATH](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Libraries#Setting_OPENSCADPATH) in [OpenSCAD User Manual/Libraries](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Libraries) for details.
 
-**I set `OPENSCADPATH` to the `src` folder of dotSCAD so all examples here start searching modules or functions from `src`.**
+**I set `OPENSCADPATH` to the `src` folder of dotSCAD so all examples here start searching modules/functions from `src`.**
 
-Every module or function is located in the file which has the same name as the module or the function. For example, if you want to use the `line2d` module to draw a line, `use <line2d.scad>;` first. 
+Every public module/function has the same name as the .scad file. Here's an example using the `line2d` module: 
 
 	use <line2d.scad>;
 
 	line2d(p1 = [0, 0], p2 = [5, 0], width = 1);
 
-Some module files are organized in a directory. For example, px_circle.scad exists in `pixel` directory. You have to prefix the directory name when including `px_circle`.
+The library uses directories to categorize some modules/functions. For example, vx_circle.scad exists in `voxel` directory. Prefix the directory name when using `vx_circle`.
 
     use <voxel/vx_circle.scad>;
 	
@@ -41,232 +37,339 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 
 [![examples](examples/images/gallery.JPG)](examples#dogfooding-examples)
 
-## Documentation
+# API Reference
 
-### 2D Module
-- [arc](https://openhome.cc/eGossip/OpenSCAD/lib3x-arc.html)
-- [hexagons](https://openhome.cc/eGossip/OpenSCAD/lib3x-hexagons.html)
-- [hull_polyline2d](https://openhome.cc/eGossip/OpenSCAD/lib3x-hull_polyline2d.html)
-- [line2d](https://openhome.cc/eGossip/OpenSCAD/lib3x-line2d.html)
-- [multi_line_text](https://openhome.cc/eGossip/OpenSCAD/lib3x-multi_line_text.html)
-- [pie](https://openhome.cc/eGossip/OpenSCAD/lib3x-pie.html)
-- [polyline2d](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline2d.html)
-- [polygon_hull](https://openhome.cc/eGossip/OpenSCAD/lib3x-polygon_hull.html)
-- [rounded_square](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_square.html)
+## 2D Module
 
-### 3D Module
-- [crystal_ball](https://openhome.cc/eGossip/OpenSCAD/lib3x-crystal_ball.html)
-- [function_grapher](https://openhome.cc/eGossip/OpenSCAD/lib3x-function_grapher.html)
-- [hull_polyline3d](https://openhome.cc/eGossip/OpenSCAD/lib3x-hull_polyline3d.html)
-- [line3d](https://openhome.cc/eGossip/OpenSCAD/lib3x-line3d.html)
-- [loft](https://openhome.cc/eGossip/OpenSCAD/lib3x-loft.html)
-- [polyhedron_hull](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedron_hull.html)
-- [polyline3d](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline3d.html)
-- [rounded_cube](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cube.html)
-- [rounded_cylinder](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cylinder.html)
-- [starburst](https://openhome.cc/eGossip/OpenSCAD/lib3x-starburst.html)
-- [sweep](https://openhome.cc/eGossip/OpenSCAD/lib3x-sweep.html)
+ Signature | Description
+--|--
+[**arc**(radius, angle[, width, width_mode"])](https://openhome.cc/eGossip/OpenSCAD/lib3x-arc.html) | create an arc.
+[**hexagons**(radius, spacing, levels)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hexagons.html) | create hexagons in a hexagon.
+[**line2d**(p1, p2[, width, p1Style, p2Style])](https://openhome.cc/eGossip/OpenSCAD/lib3x-line2d.html) | create a line from two points. 
+[**multi_line_text**(lines[, line_spacing, size, font, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-multi_line_text.html) | create multi-line text from a list of strings.
+[**pie**(radius, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-pie.html) | create polyline2de a pie (circular sector).
+[**polyline2d**(points[, width, startingStyle, endingStyle, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline2d.html) | create a polyline from a list of `[x, y]` coordinates.
+[**polygon_hull**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polygon_hull.html) | create a convex polygon by hulling a list of points. It avoids using hull and small 2D primitives to create the polygon.
+[**rounded_square**(size, corner_r[, center])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_square.html) | create a rounded square in the first quadrant.
 
-### Transformation
-- [along_with](https://openhome.cc/eGossip/OpenSCAD/lib3x-along_with.html)
-- [bend](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend.html)
-- [hollow_out](https://openhome.cc/eGossip/OpenSCAD/lib3x-hollow_out.html)
-- [shear](https://openhome.cc/eGossip/OpenSCAD/lib3x-shear.html)
+## 3D Module
 
-### 2D Function
-- [bijection_offset](https://openhome.cc/eGossip/OpenSCAD/lib3x-bijection_offset.html)
-- [contours](https://openhome.cc/eGossip/OpenSCAD/lib3x-contours.html)
-- [in_shape](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_shape.html)	
-- [trim_shape](https://openhome.cc/eGossip/OpenSCAD/lib3x-trim_shape.html)
+ Signature | Description
+--|--
+[**crystal_ball**(radius[, theta, phi, thickness])](https://openhome.cc/eGossip/OpenSCAD/lib3x-crystal_ball.html) | create a crystal ball based on [spherical coordinates (r, θ, φ) used in mathematics](https://en.wikipedia.org/wiki/Spherical_coordinate_system).
+[**line3d**(p1, p2[, diameter, p1Style, p2Style])](https://openhome.cc/eGossip/OpenSCAD/lib3x-line3d.html) | create a 3D line from two points.
+[**loft**(sections[, slices])](https://openhome.cc/eGossip/OpenSCAD/lib3x-loft.html) | develop a smooth skin between crosssections with different geometries.
+[**polyhedron_hull**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedron_hull.html) | create a convex polyhedron by hulling a list of points. It avoids using `hull` and small 3D primitives to create the polyhedron.
+[**polyline3d**(points, diameter[, startingStyle, endingStyle])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline3d.html) | create a polyline from a list of `[x, y, z]`.
+[**rounded_cube**(size, corner_r[, center])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cube.html) | create a cube in the first octant.
+[**rounded_cylinder**(radius, h, round_r[, convexity, center])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cylinder.html) | create a rounded cylinder.
+[**sweep**(sections[, triangles])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sweep.html) | develop a smooth skin from crosssections with the same number of sides.
 
-### 2D/3D Function
-- [angle_between](https://openhome.cc/eGossip/OpenSCAD/lib3x-angle_between.html)
-- [bezier_surface](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_surface.html)	
-- [bezier_smooth](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_smooth.html)	
-- [cross_sections](https://openhome.cc/eGossip/OpenSCAD/lib3x-cross_sections.html)
-- [in_polyline](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_polyline.html)
-- [lines_intersection](https://openhome.cc/eGossip/OpenSCAD/lib3x-lines_intersection.html)
-- [paths2sections](https://openhome.cc/eGossip/OpenSCAD/lib3x-paths2sections.html)
-- [path_scaling_sections](https://openhome.cc/eGossip/OpenSCAD/lib3x-path_scaling_sections.html)
-- [midpt_smooth](https://openhome.cc/eGossip/OpenSCAD/lib3x-midpt_smooth.html)
+## Transformation
 
-### Path
-- [arc_path](https://openhome.cc/eGossip/OpenSCAD/lib3x-arc_path.html)
-- [archimedean_spiral](https://openhome.cc/eGossip/OpenSCAD/lib3x-archimedean_spiral.html)
-- [bauer_spiral](https://openhome.cc/eGossip/OpenSCAD/lib3x-bauer_spiral.html)
-- [bezier_curve](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_curve.html)
-- [bspline_curve](https://openhome.cc/eGossip/OpenSCAD/lib3x-bspline_curve.html)
-- [curve](https://openhome.cc/eGossip/OpenSCAD/lib3x-curve.html)
-- [fibonacci_lattice](https://openhome.cc/eGossip/OpenSCAD/lib3x-fibonacci_lattice.html)
-- [golden_spiral](https://openhome.cc/eGossip/OpenSCAD/lib3x-golden_spiral.html)
-- [helix](https://openhome.cc/eGossip/OpenSCAD/lib3x-helix.html)
-- [sphere_spiral](https://openhome.cc/eGossip/OpenSCAD/lib3x-sphere_spiral.html)
-- [torus_knot](https://openhome.cc/eGossip/OpenSCAD/lib3x-torus_knot.html)
+ Signature | Description
+--|--
+[**along_with**(points, angles[, twist, scale, method])](https://openhome.cc/eGossip/OpenSCAD/lib3x-along_with.html) | put children along the given path. If there's only one child, put the child for each point.
+[**bend**(size, angle[, frags])](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend.html) | bend a 3D object.
+[**hollow_out**(shell_thickness) ](https://openhome.cc/eGossip/OpenSCAD/lib3x-hollow_out.html)| hollow out a 2D object.
+[**shear**([sx, sy, sz])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shear.html) | shear all child elements along the X-axis, Y-axis, or Z-axis.
+[**select**(i)](https://openhome.cc/eGossip/OpenSCAD/lib3x-select.html) | select module objects.
+[**polyline_join**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline_join.html) | place a join on each point. Hull each pair of joins and union all convex hulls.
 
-### Extrusion
-- [bend_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend_extrude.html)	
-- [box_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-box_extrude.html)
-- [ellipse_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-ellipse_extrude.html)
-- [rounded_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_extrude.html)
-- [stereographic_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-stereographic_extrude.html)
+## 2D Function
 
-### 2D Shape
-- [shape_arc](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_arc.html)
-- [shape_circle](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_circle.html)
-- [shape_cyclicpolygon](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_cyclicpolygon.html)
-- [shape_ellipse](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_ellipse.html)
-- [shape_liquid_splitting](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_liquid_splitting.html)
-- [shape_path_extend](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_path_extend.html)
-- [shape_pentagram](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_pentagram.html)
-- [shape_pie](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_pie.html)	
-- [shape_square](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_square.html)
-- [shape_starburst](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_starburst.html)
-- [shape_superformula](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_superformula.html)
-- [shape_taiwan](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_taiwan.html)
-- [shape_trapezium](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_trapezium.html)
+ Signature | Description
+--|--
+[**bijection_offset**(pts, d[, epsilon])](https://openhome.cc/eGossip/OpenSCAD/lib3x-bijection_offset.html) | move 2D outlines outward or inward by a given amount. Each point of the offsetted shape is paired with exactly one point of the original shape.
+[**contours**(points, threshold)](https://openhome.cc/eGossip/OpenSCAD/lib3x-contours.html) | compute contour polygons by applying [marching squares](https://en.wikipedia.org/wiki/Marching_squares) to a rectangular list of numeric values.
+[**in_shape**(shapt_pts, pt[, include_edge, epsilon])](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_shape.html) | check whether a point is inside a shape.
+[**trim_shape**(shape_pts, from, to[, epsilon])](https://openhome.cc/eGossip/OpenSCAD/lib3x-trim_shape.html) | trim a tangled-edge shape to a non-tangled shape.
 
-### 2D Shape Extrusion
-- [archimedean_spiral_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-archimedean_spiral_extrude.html)
-- [golden_spiral_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-golden_spiral_extrude.html)
-- [helix_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-helix_extrude.html)
-- [path_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-path_extrude.html)
-- [ring_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-ring_extrude.html)
-- [sphere_spiral_extrude](https://openhome.cc/eGossip/OpenSCAD/lib3x-sphere_spiral_extrude.html)
+## 2D/3D Function
 
-### Util
-- list
-	- [util/bsearch](https://openhome.cc/eGossip/OpenSCAD/lib3x-bsearch.html)
-	- [util/has](https://openhome.cc/eGossip/OpenSCAD/lib3x-has.html)
-	- [util/find_index](https://openhome.cc/eGossip/OpenSCAD/lib3x-find_index.html)
-	- [util/dedup](https://openhome.cc/eGossip/OpenSCAD/lib3x-dedup.html)	
-	- [util/flat](https://openhome.cc/eGossip/OpenSCAD/lib3x-flat.html)
-	- [util/reverse](https://openhome.cc/eGossip/OpenSCAD/lib3x-reverse.html)
-	- [util/slice](https://openhome.cc/eGossip/OpenSCAD/lib3x-slice.html)
-	- [util/sort](https://openhome.cc/eGossip/OpenSCAD/lib3x-sort.html)
-	- [util/sum](https://openhome.cc/eGossip/OpenSCAD/lib3x-sum.html)
-	- [util/swap](https://openhome.cc/eGossip/OpenSCAD/lib3x-swap.html)
-	- [util/zip](https://openhome.cc/eGossip/OpenSCAD/lib3x-zip.html)
-	- [util/every](https://openhome.cc/eGossip/OpenSCAD/lib3x-every.html)
-	- [util/some](https://openhome.cc/eGossip/OpenSCAD/lib3x-some.html)
-- random
-	- [util/choose](https://openhome.cc/eGossip/OpenSCAD/lib3x-choose.html)
-	- [util/rand](https://openhome.cc/eGossip/OpenSCAD/lib3x-rand.html)
-	- [util/shuffle](https://openhome.cc/eGossip/OpenSCAD/lib3x-shuffle.html)
-- string
-	- [util/parse_number](https://openhome.cc/eGossip/OpenSCAD/lib3x-parse_number.html)
-	- [util/split_str](https://openhome.cc/eGossip/OpenSCAD/lib3x-split_str.html)
-	- [util/sub_str](https://openhome.cc/eGossip/OpenSCAD/lib3x-sub_str.html)
-- math
-	- [util/degrees](https://openhome.cc/eGossip/OpenSCAD/lib3x-degrees.html)
-	- [util/radians](https://openhome.cc/eGossip/OpenSCAD/lib3x-radians.html)
-	- [util/polar_coordinate](https://openhome.cc/eGossip/OpenSCAD/lib3x-polar_coordinate.html)
-	- [util/spherical_coordinate](https://openhome.cc/eGossip/OpenSCAD/lib3x-spherical_coordinate.html)
-	- [util/lerp](https://openhome.cc/eGossip/OpenSCAD/lib3x-lerp.html)
-	- [util/fibseq](https://openhome.cc/eGossip/OpenSCAD/lib3x-fibseq.html)	
-- set
-    - [util/set/hashset](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset.html)
-	- [util/set/hashset_add](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_add.html)
-	- [util/set/hashset_has](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_has.html)
-	- [util/set/hashset_del](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_del.html)
-	- [util/set/hashset_len](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_len.html)
-	- [util/set/hashset_elems](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_elems.html)
-- map
-    - [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html)
-	- [util/map/hashmap_put](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_put.html)
-	- [util/map/hashmap_get](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_get.html)
-	- [util/map/hashmap_del](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_del.html)
-	- [util/map/hashmap_len](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_len.html)
-	- [util/map/hashmap_keys](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_keys.html)
-	- [util/map/hashmap_values](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_values.html)
-	- [util/map/hashmap_entries](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_entries.html)
+ Signature | Description
+--|--
+[**angle_between**(vt1, vt2)](https://openhome.cc/eGossip/OpenSCAD/lib3x-angle_between.html) | return the angle between two vectors.
+[**bezier_smooth**(path_pts, round_d[, t_step, closed, angle_threshold])](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_smooth.html) | use bezier curves to smooth a path.
+[**cross_sections**(shape_pts, path_pts, angles[, twist, scale])](https://openhome.cc/eGossip/OpenSCAD/lib3x-cross_sections.html) | given a 2D shape, points and angles along the path, this function returns all cross-sections.
+[**in_polyline**(line_pts, pt[, epsilon])](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_polyline.html) | check whether a point is on a line.
+[**lines_intersection**(line1, line2[, ext, epsilon])](https://openhome.cc/eGossip/OpenSCAD/lib3x-lines_intersection.html) | find the intersection of two line segments. Return `[]` if lines don't intersect.
+[**rails2sections**(rails)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rails2sections.html) | create sections along rails.
+[**path_scaling_sections**(shape_pts, edge_path)](https://openhome.cc/eGossip/OpenSCAD/lib3x-path_scaling_sections.html) | given an edge path with the first point at the outline of a shape, this function uses the path to calculate scaling factors and returns all scaled sections in the reversed order of the edge path. 
+[**midpt_smooth**(points, n[, closed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-midpt_smooth.html) | given a 2D path, this function constructs a mid-point smoothed version by joining the mid-points of the lines of the path.
 
-### Matrix
-- [matrix/m_determinant](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_determinant.html)
-- [matrix/m_mirror](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_mirror.html)
-- [matrix/m_rotation](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_rotation.html)
-- [matrix/m_scaling](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_scaling.html)
-- [matrix/m_shearing](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_shearing.html)
-- [matrix/m_translation](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_translation.html)
+## Path
 
-### Point Transformation
-- [ptf/ptf_bend](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_bend.html)
-- [ptf/ptf_circle](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_circle.html)
-- [ptf/ptf_ring](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_ring.html)
-- [ptf/ptf_rotate](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_rotate.html)
-- [ptf/ptf_sphere](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_sphere.html)
-- [ptf/ptf_torus](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_torus.html)
-- [ptf/ptf_x_twist](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_x_twist.html)
-- [ptf/ptf_y_twist](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_y_twist.html)
+ Signature | Description
+--|--
+[**arc_path**(radius, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-arc_path.html) | create an arc path.
+[**archimedean_spiral**(arm_distance, init_angle, point_distance, num_of_points[, rt_dir])](https://openhome.cc/eGossip/OpenSCAD/lib3x-archimedean_spiral.html) | get all points and angles on the path of an archimedean spiral. 
+[**bauer_spiral**(n, radius = 1[, rt_dir])](https://openhome.cc/eGossip/OpenSCAD/lib3x-bauer_spiral.html) | create visually even spacing of n points on the surface of the sphere. Successive points will all be approximately the same distance apart.
+[**bezier_curve**(t_step, points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_curve.html) | given a set of control points, this function returns points of the Bézier path.
+[**bspline_curve**(t_step, degree, points, knots, weights)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bspline_curve.html) | B-spline interpolation using [de Boor's algorithm](https://en.wikipedia.org/wiki/De_Boor%27s_algorithm). 
+[**curve**(t_step, points[, tightness])](https://openhome.cc/eGossip/OpenSCAD/lib3x-curve.html) | create a curved path. An implementation of [Centripetal Catmull-Rom spline](https://en.wikipedia.org/wiki/Centripetal_Catmull%E2%80%93Rom_spline). 
+[**fibonacci_lattice**(n, radius = 1[, dir])](https://openhome.cc/eGossip/OpenSCAD/lib3x-fibonacci_lattice.html) | create visually even spacing of n points on the surface of the sphere. Nearest-neighbor points will all be approximately the same distance apart. 
+[**golden_spiral**(from, to, point_distance[, rt_dir)]](https://openhome.cc/eGossip/OpenSCAD/lib3x-golden_spiral.html) | get all points and angles on the path of a golden spiral based on Fibonacci numbers. The distance between two points is almost constant.
+[**helix**(radius, levels, level_dist[, vt_dir, rt_dir])](https://openhome.cc/eGossip/OpenSCAD/lib3x-helix.html) | get all points on the path of a spiral around a cylinder. 
+[**sphere_spiral**(radius, za_step[, z_circles, begin_angle, end_angle, ...]) ](https://openhome.cc/eGossip/OpenSCAD/lib3x-sphere_spiral.html)| create all points and angles on the path of a spiral around a sphere. It returns a vector of `[[x, y, z], [ax, ay, az]]`. 
+[**torus_knot**(p, q, phi_step)](https://openhome.cc/eGossip/OpenSCAD/lib3x-torus_knot.html) | generate a path of [The (p,q)-torus knot](https://en.wikipedia.org/wiki/Torus_knot).
+
+## Extrusion
+
+ Signature | Description
+--|--
+[**bend_extrude**(size, thickness, angle[, frags])](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend_extrude.html) | extrude and bend a 2D shape.
+[**box_extrude**(height, shell_thickness, bottom_thickness[, offset_mode, chamfer, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-box_extrude.html) | create a box (container) from a 2D object.
+[**ellipse_extrude**(semi_minor_axis, height[, center, convexity, twist, slices])](https://openhome.cc/eGossip/OpenSCAD/lib3x-ellipse_extrude.html) | extrude a 2D object along the path of an ellipse from 0 to 180 degrees.
+[**rounded_extrude**(size, round_r[, angle, twist, convexity])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_extrude.html) | extrude a 2D object roundly from 0 to 180 degrees.
+[**stereographic_extrude**(shadow_side_leng)](https://openhome.cc/eGossip/OpenSCAD/lib3x-stereographic_extrude.html) | take a 2D polygon as input and extend it onto a sphere.
+
+## 2D Shape
+
+ Signature | Description
+--|--
+[**shape_arc**(radius, angle, width[, width_mode])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_arc.html) | return points on the path of an arc shape.
+[**shape_circle**(radius, n)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_circle.html) | return points on the path of a circle.
+[**shape_cyclicpolygon**(sides, circle_r, corner_r)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_cyclicpolygon.html) | return points on the path of a regular cyclic polygon.
+[**shape_ellipse**(axes)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_ellipse.html) | return points on the path of an ellipse.
+[**shape_liquid_splitting**(radius, centre_dist[, tangent_angle, t_step])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_liquid_splitting.html) | return shape points of two splitting liquid shapes, kind of how cells divide. 
+[**shape_path_extend**(stroke_pts, path_pts[, scale, closed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_path_extend.html) | extend a 2D stroke along a path to create a 2D shape.
+[**shape_pentagram**(r)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_pentagram.html) | return shape points of a pentagram.
+[**shape_pie**(radius, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_pie.html) | return shape points of a pie (circular sector) shape. 
+[**shape_square**(size[, corner_r])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_square.html) | return shape points of a rounded square or rectangle. 
+[**shape_star**([outer_radius, inner_radius, n])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_star.html) | create a 2D star.
+[**shape_superformula**(phi_step, m1, m2, n1, [n2, n3, a, b])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_superformula.html) | return shape points of [Superformula](https://en.wikipedia.org/wiki/Superformula).
+[**shape_taiwan**(h[, distance])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_taiwan.html) | return shape points of [Taiwan](https://www.google.com.tw/maps?q=taiwan&um=1&ie=UTF-8&sa=X&ved=0ahUKEwjai9XrqurTAhVIopQKHbEHClwQ_AUICygC). 
+[**shape_trapezium**(length, h[, corner_r])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_trapezium.html) | return shape points of an isosceles trapezoid. 
+
+## 2D Shape Extrusion
+
+ Signature | Description
+--|--
+[**archimedean_spiral_extrude**(shape_pts, arm_distance, init_angle, point_distance, num_of_points, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-archimedean_spiral_extrude.html) | extrude a 2D shape along the path of an archimedean spiral.
+[**golden_spiral_extrude**(shape_pts, from, to, point_distance, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-golden_spiral_extrude.html) | extrude a 2D shape along the path of a golden spiral.
+[**helix_extrude**(shape_pts, radius, levels, level_dist, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-helix_extrude.html) | extrude a 2D shape along a helix path.
+[**path_extrude**(shape_pts, path_pts, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-path_extrude.html) | extrude a 2D shape along a path.
+[**ring_extrude**(shape_pts, radius[, angle = 360])](https://openhome.cc/eGossip/OpenSCAD/lib3x-ring_extrude.html) | rotational extrusion spins a 2D shape around the Z-axis.
+[**sphere_spiral_extrude**(shape_pts, radius, za_step, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sphere_spiral_extrude.html) | extrude a 2D shape along the path of a sphere spiral.
+
+## Util
+
+### util/list
+
+ Signature | Description
+--|--
+[**util/bsearch**(sorted, target)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bsearch.html) | search a value in a list whose elements must be sorted by zyx.
+[**util/has**(lt, elem[, sorted])](https://openhome.cc/eGossip/OpenSCAD/lib3x-has.html) | return `true` if `lt` contains elem.
+[**util/find_index**(lt, test)](https://openhome.cc/eGossip/OpenSCAD/lib3x-find_index.html) | return the index of the first element that satisfies the testing function. 
+[**util/dedup**(lt, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-dedup.html) | eliminate duplicate vectors.
+[**util/flat**(lt[, depth])](https://openhome.cc/eGossip/OpenSCAD/lib3x-flat.html) | return a new list with all sub-list elements concatenated into it recursively up to the specified depth.
+[**util/reverse**(lt)](https://openhome.cc/eGossip/OpenSCAD/lib3x-reverse.html) | reverse a list.
+[**util/slice**(lt, begin, end)](https://openhome.cc/eGossip/OpenSCAD/lib3x-slice.html) | return a list selected from `begin` to `end`, or to the `end` of the list (`end` not included).
+[**util/sort**(lt[, by, idx])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sort.html) | sort a list.
+[**util/sum**(lt)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sum.html) | use `+` to sum up all elements in a list.
+[**util/swap**(lt, i, j)](https://openhome.cc/eGossip/OpenSCAD/lib3x-swap.html) | swap two elements in a list.
+[**util/zip**(lts, combine)](https://openhome.cc/eGossip/OpenSCAD/lib3x-zip.html) | make a list that aggregates elements from each of the lists.
+[**util/every**(lt, test)](https://openhome.cc/eGossip/OpenSCAD/lib3x-every.html) | test whether all elements in the list pass the test implemented by the provided function.
+[**util/some**(lt, test)](https://openhome.cc/eGossip/OpenSCAD/lib3x-some.html) | test whether at least one element in the list passes the test implemented by the provided function.
+
+### util/random
+
+ Signature | Description
+--|--
+[**util/choose**(choices, seed)](https://openhome.cc/eGossip/OpenSCAD/lib3x-choose.html) | choose an element from the given list.
+[**util/rand**([min_value, max_value, seed_value])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rand.html) | generate a pseudo random number.
+[**util/shuffle**(lt[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shuffle.html) | randomizes the order of the elements.
+
+### util/string
+
+ Signature | Description
+--|--
+[**util/parse_number**(t)](https://openhome.cc/eGossip/OpenSCAD/lib3x-parse_number.html) | parse the string argument as an number.
+[**util/split_str**(t, delimiter)](https://openhome.cc/eGossip/OpenSCAD/lib3x-split_str.html) | split the given string around matches of the given delimiting character.
+[**util/sub_str**(t, begin, end)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sub_str.html) | return the part of the string from `begin` to `end`, or to the `end` of the string (`end` not included).
+
+### util/math
+
+ Signature | Description
+--|--
+[**util/degrees**(radians)](https://openhome.cc/eGossip/OpenSCAD/lib3x-degrees.html) | convert a radian measurement to the corresponding value in degrees.
+[**util/radians**(degrees)](https://openhome.cc/eGossip/OpenSCAD/lib3x-radians.html) | convert a degree measurement to the corresponding value in radians.
+[**util/polar_coordinate**(point)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polar_coordinate.html) | convert from Cartesian to Polar coordinates.
+[**util/spherical_coordinate**(point)](https://openhome.cc/eGossip/OpenSCAD/lib3x-spherical_coordinate.html) | convert from Cartesian to Spherical coordinates (used in mathematics). 
+[**util/lerp**(v1, v2, amt)](https://openhome.cc/eGossip/OpenSCAD/lib3x-lerp.html) | linear interpolate the vector v1 to v2.
+[**util/fibseq**(from, to)](https://openhome.cc/eGossip/OpenSCAD/lib3x-fibseq.html) | generate a Fibonacci sequence.	
+
+### util/set
+
+ Signature | Description
+--|--
+[**util/set/hashset**(lt, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset.html) | model the mathematical set, backed by a hash table. 
+[**util/set/hashset_add**(set, elem, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_add.html) | add an element to a `hashset`.
+[**util/set/hashset_has**(set, elem, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_has.html) | return `true` if a `hashset` contains the specified element.
+[**util/set/hashset_del**(set, elem, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_del.html) | del an element from a `hashset`.
+[**util/set/hashset_len**(set)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_len.html) | return the length of the elements in a `hashset`.
+[**util/set/hashset_elems**(set)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashset_elems.html) | returns a list containing all elements in a `hashset`. No guarantees to the order.
+
+### util/map
+
+ Signature | Description
+--|--
+[**util/map/hashmap**(kv_lt, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html) | map keys to values.
+[**util/map/hashmap_put**(map, key, value, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_put.html) | put a key/value pair to a `hashmap`.
+[**util/map/hashmap_get**(map, key, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_get.html) | get the value of the specified key from a `hashmap`.
+[**util/map/hashmap_del**(map, key, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_del.html) | delete the mapping for the specified key from a `hashmap` if present.
+[**util/map/hashmap_len**(map)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_len.html) | return the length of a `hashmap`.
+[**util/map/hashmap_keys**(map)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_keys.html) | return a list containing all keys in a `hashmap`.
+[**util/map/hashmap_values**(map)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_values.html) | return a list containing all values in a `hashmap`.
+[**util/map/hashmap_entries**(map)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap_entries.html) | return a list containing all `[key, value]`s in a `hashmap`.
+
+## Matrix
+
+ Signature | Description
+--|--
+[**matrix/m_determinant**(m)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_determinant.html) | calculate a determinant of a square matrix.
+[**matrix/m_mirror**(v)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_mirror.html) | generate a transformation matrix which can pass into `multmatrix` to mirror the child element on a plane through the origin.
+[**matrix/m_rotation**(a, v)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_rotation.html) | Generate a transformation matrix which can pass into `multmatrix` to rotate the child element about the axis of the coordinate system or around an arbitrary axis.
+[**matrix/m_scaling**(s)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_scaling.html) | generate a transformation matrix which can pass into `multmatrix` to scale its child elements using the specified vector.
+[**matrix/m_shearing**([sx, sy, sz])](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_shearing.html) | generate a transformation matrix which can pass into `multmatrix` to shear all child elements along the X-axis, Y-axis, or Z-axis in 3D.
+[**matrix/m_translation**(v)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_translation.html) | generate a transformation matrix which can pass into multmatrix to translates (moves) its child elements along the specified vector.
+[**maxtrix/m_transpose**(m)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_transpose.html) | transpose a matrix.
+
+## Point Transformation
+
+ Signature | Description
+--|--
+[**ptf/ptf_bend**(size, point, radius, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_bend.html) | transform a point inside a rectangle to a point of an arc.
+[**ptf/ptf_circle**(size, point)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_circle.html) | transform a point inside a rectangle to a point inside a circle. 
+[**ptf/ptf_ring**(size, point, radius[, angle, twist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_ring.html) | transform a point inside a rectangle to a point of a ring. 
+[**ptf/ptf_rotate**(point, a, v)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_rotate.html) | rotate a point a degrees around the axis of the coordinate system or an arbitrary axis.
+[**ptf/ptf_sphere**(size, point, radius[, angle])](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_sphere.html) | transform a point inside a rectangle to a point of a sphere.
+[**ptf/ptf_torus**(size, point, radius[, angle, twist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_torus.html) | transform a point inside a rectangle to a point of a torus.
+[**ptf/ptf_x_twist**(size, point, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_x_twist.html) | twist a point along the x-axis.
+[**ptf/ptf_y_twist**(size, point, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_y_twist.html) | twist a point along the y-axis.
+
+## Triangle
+
+ Signature | Description
+--|--
+[**triangle/tri_circumcenter**(shape_pts)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_circumcenter.html) | return the circumcenter of a triangle.
+[**triangle/tri_incenter**(shape_pts)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_incenter.html) | return the incenter of a triangle.
+[**triangle/tri_ear_clipping**(shape_pts[, ret, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_ear_clipping.html) | triangulation by [ear clipping](https://en.wikipedia.org/wiki/Polygon_triangulation#Ear_clipping_method).
+[**triangle/tri_delaunay**(points[, ret])](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay.html) | Join a set of points to make a [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation).
+[**triangle/tri_delaunay_indices**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_indices.html) | return triangle indices from a delaunay object.
+[**triangle/tri_delaunay_shapes**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_shapes.html) | return triangle shapes from a delaunay object.
+[**triangle/tri_delaunay_voronoi**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_voronoi.html) | return [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) cells from a delaunay object.
 
 ----
 
-### Turtle
-- [turtle/footprints2](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprints2.html)
-- [turtle/footprints3](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprints3.html)
-- [turtle/lsystem2](https://openhome.cc/eGossip/OpenSCAD/lib3x-lsystem2.html)
-- [turtle/lsystem3](https://openhome.cc/eGossip/OpenSCAD/lib3x-lsystem3.html)
-- [turtle/t2d](https://openhome.cc/eGossip/OpenSCAD/lib3x-t2d.html)
-- [turtle/t3d](https://openhome.cc/eGossip/OpenSCAD/lib3x-t3d.html)
+## Turtle
 
-### Voxel
-- [voxel/vx_ascii](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_ascii.html)
-- [voxel/vx_bezier](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_bezier.html)
-- [voxel/vx_contour](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_contour.html)
-- [voxel/vx_circle](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_circle.html)
-- [voxel/vx_curve](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_curve.html)
-- [voxel/vx_cylinder](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_cylinder.html)
-- [voxel/vx_difference](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_difference.html)
-- [voxel/vx_from](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_from.html)
-- [voxel/vx_gray](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_gray.html)
-- [voxel/vx_intersection](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_intersection.html)
-- [voxel/vx_line](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_line.html)
-- [voxel/vx_polygon](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_polygon.html)
-- [voxel/vx_polyline](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_polyline.html)
-- [voxel/vx_sphere](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_sphere.html)
-- [voxel/vx_union](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_union.html)
+ Signature | Description
+--|--
+[**turtle/footprints2**(cmds[, start])](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprints2.html) | drive a turtle with `["forward", length]` or `["turn", angle]`. This function is intended to use a turtle to imitate freehand drawing.
+[**turtle/footprints3**(cmds[, start])](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprints3.html) | a 3D verion of `footprint2`.
+[**turtle/lsystem2**(axiom, rules, n, angle[, leng, heading, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-lsystem2.html) | 2D implementation of [L-system](https://en.wikipedia.org/wiki/L-system).
+[**turtle/lsystem3**(axiom, rules, n, angle[, leng, heading, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-lsystem3.html) | 3D implementation of [L-system](https://en.wikipedia.org/wiki/L-system).
+[**turtle/t2d**(t, cmd, point, angle, leng)](https://openhome.cc/eGossip/OpenSCAD/lib3x-t2d.html) | an implementation of Turtle Graphics.
+[**turtle/t3d**(t, cmd, point, unit_vectors, leng, angle)](https://openhome.cc/eGossip/OpenSCAD/lib3x-t3d.html) | a 3D version of `t2d`.
 
-### Part
-- [part/connector_peg](https://openhome.cc/eGossip/OpenSCAD/lib3x-connector_peg.html)
-- [part/cone](https://openhome.cc/eGossip/OpenSCAD/lib3x-cone.html)
-- [part/joint_T](https://openhome.cc/eGossip/OpenSCAD/lib3x-joint_T.html)
+## Voxel
 
-### Surface
-- [surface/sf_bend](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_bend.html)
-- [surface/sf_ring](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_ring.html)
-- [surface/sf_solidify](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_solidify.html)
-- [surface/sf_sphere](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_sphere.html)
-- [surface/sf_square](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_square.html)
-- [surface/sf_torus](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_torus.html)
+ Signature | Description
+--|--
+[**voxel/vx_ascii**(char[, center, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_ascii.html) | generate 8x8 voxel points of printable ASCII characters (codes 32dec to 126dec).
+[**voxel/vx_bezier**(p1, p2, p3, p4)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_bezier.html) | return voxel-by-voxel points of Bézier Curve.
+[**voxel/vx_circle**(radius[, filled])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_circle.html) | return points that can be used to draw a voxel-style circle.
+[**voxel/vx_contour**(points[, sorted])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_contour.html) | return the contour which encircles the area.
+[**voxel/vx_curve**(points[, tightness])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_curve.html) | the curve is drawn only from the 2nd control point to the second-last control point.
+[**voxel/vx_cylinder**(r, h[, filled, thickness])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_cylinder.html) | return points that can be used to draw a voxel-style cylinder.
+[**voxel/vx_difference**(points1, points2)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_difference.html) | create a difference of two lists of points.
+[**voxel/vx_from**(binaries[, center, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_from.html) | given a list of 0s and 1s that represent a black-and-white image. This function translates them into voxel points.
+[**voxel/vx_gray**(levels[, center, invert, normalize])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_gray.html) | given a list of numbers (0 ~ 255) that represent a gray image. This function translates them into a list of `[x, y, level]`s.
+[**voxel/vx_intersection**(points1, points2)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_intersection.html) | create an intersection of two lists of points.
+[**voxel/vx_line**(p1, p2)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_line.html) | given two points. it returns points that can be used to draw a voxel-style line.
+[**voxel/vx_polygon**(points[, filled])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_polygon.html) | return points that can be used to draw a voxel-style polygon.
+[**voxel/vx_polyline**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_polyline.html) | return points that can be used to draw a voxel-style polyline.
+[**voxel/vx_sphere**(radius[, filled, thickness])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_sphere.html) | return points that can be used to draw a voxel-style sphere.
+[**voxel/vx_union**(points1, points2)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_union.html) | create a union of two lists of points.
 
-### Noise
-- [noise/nz_cell](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_cell.html)
-- [noise/nz_perlin1](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin1.html)
-- [noise/nz_perlin1s](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin1s.html)
-- [noise/nz_perlin2](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin2.html)
-- [noise/nz_perlin2s](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin2s.html)
-- [noise/nz_perlin3](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin3.html)
-- [noise/nz_perlin3s](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin3s.html)
-- [noise/nz_worley2](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley2.html)
-- [noise/nz_worley2s](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley2s.html)
-- [noise/nz_worley3](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley3.html)
-- [noise/nz_worley3s](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley3s.html)
+## Part
 
-### Voronoi
+ Signature | Description
+--|--
+[**part/cone**(radius[, length, spacing, angle, void, ends])](https://openhome.cc/eGossip/OpenSCAD/lib3x-cone.html) | create a cone for rotatable models.
+[**part/connector_peg**(radius, height[, spacing, void, ends])](https://openhome.cc/eGossip/OpenSCAD/lib3x-connector_peg.html) | create a connector peg.
+[**part/joint_T**(shaft_r, shaft_h, t_leng, thickness,[ spacing, center])](https://openhome.cc/eGossip/OpenSCAD/lib3x-joint_T.html) | create a joint_T for rotatable models.
 
-- [voronoi/vrn2_cells_from](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_cells_from.html)
-- [voronoi/vrn2_cells_space](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_cells_space.html)
-- [voronoi/vrn2_from](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_from.html)
-- [voronoi/vrn2_space](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_space.html)
-- [voronoi/vrn3_from](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn3_from.html)
-- [voronoi/vrn3_space](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn3_space.html)
+## Surface
 
-### Maze
+ Signature | Description
+--|--
+[**surface/sf_bend**(levels, radius, thickness, depth[, angle, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_bend.html) | bend a photo.
+[**surface/sf_ring**(levels, radius, thickness, depth[, angle, twist, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_ring.html) | turn a photo into a ring.
+[**surface/sf_solidify**(surface1, surface2[, slicing])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_solidify.html) | solidify two square surfaces.
+[**surface/sf_sphere**(levels, radius, thickness, depth[, angle, invert)]](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_sphere.html) | map a photo onto a sphere.
+[**surface/sf_square**(levels, thickness, depth[, x_twist, y_twist, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_square.html) | turn a photo into a twistable square.
+[**surface/sf_torus**(levels, radius, thickness, depth[, angle, twist, invert])](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_torus.html) | turn a photo to a torus.
+[**surface/sf_curve**(levels, curve_path, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_curve.html) | curve a photo.
+[**surface/sf_splines**(ctrl_pts, row_spline, column_spline)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_splines.html) | generalized-spline surface.
+[**surface/sf_thicken**(points, thickness, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_thicken.html) | thicken a surface.
+[**surface/sf_solidifyT**(points1, points2, triangles)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_solidifyT.html) | solidify two surfaces with triangular mesh.
+[**surface/sf_thickenT**(points, thickness, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_thickenT.html) | thicken a surface with triangular mesh.
+
+## Noise
+
+ Signature | Description
+--|--
+[**noise/nz_cell**(points, p[, dist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_cell.html) | an implementation of [Worley noise](https://en.wikipedia.org/wiki/Worley_noise).
+[**noise/nz_perlin1**(x[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin1.html) | return the 1D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value at the x coordinate.
+[**noise/nz_perlin1s**(xs[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin1s.html) | return 1D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at x coordinates.
+[**noise/nz_perlin2**(x, y[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin2.html) | return the 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value at the (x, y) coordinate.
+[**noise/nz_perlin2s**(points[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin2s.html) | return 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at (x, y) coordinates.
+[**noise/nz_perlin3**(x, y, z[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin3.html) | return the 3D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value at the (x, y, z) coordinate.
+[**noise/nz_perlin3s**(points[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_perlin3s.html) | return 3D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at (x, y, z) coordinates.
+[**noise/nz_worley2**(x, y[, seed, grid_w, dist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley2.html) | return the 2D [Worley noise](https://en.wikipedia.org/wiki/Worley_noise) value at the (x, y) coordinate.
+[**noise/nz_worley2s**(points[, seed, grid_w, dist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley2s.html) | return 2D [Worley noise](https://en.wikipedia.org/wiki/Worley_noise) values at (x, y) coordinates.
+[**noise/nz_worley3**(x, y, z[, seed, grid_w, dist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley3.html) | return the 3D [Worley noise](https://en.wikipedia.org/wiki/Worley_noise) value at the (x, y, z) coordinate.
+[**noise/nz_worley3s**(points[, seed, grid_w, dist])](https://openhome.cc/eGossip/OpenSCAD/lib3x-nz_worley3s.html) | return 3D [Worley noise](https://en.wikipedia.org/wiki/Worley_noise) values at (x, y, z) coordinates.
+
+## Voronoi
+
+ Signature | Description
+--|--
+[**voronoi/vrn2_cells_from**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_cells_from.html) | create cell shapes of [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) from a list of points.
+[**voronoi/vrn2_cells_space**(size, grid_w[, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_cells_space.html) | create cell shapes of [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) in the first quadrant.
+[**voronoi/vrn2_from**(points[, spacing, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_from.html) | create a [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) from a list of points.
+[**voronoi/vrn2_space**(size, grid_w[, seed, spacing, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn2_space.html) | create a [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) in the first quadrant.
+[**voronoi/vrn3_from**(points[, spacing])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn3_from.html) | create a 3D version of [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram).
+[**voronoi/vrn3_space**(size, grid_w[, seed, spacing])](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn3_space.html) | create a [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) in the first octant. 
+
+## Maze
+
+ Signature | Description
+--|--
+[**maze/mz_square_cells**(rows, columns[, start, ...])](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_cells.html) | return cell data of a square maze.
+[**maze/mz_square_get**(cell, query)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_get.html) | a helper for getting data from a square-maze cell.
+[**maze/mz_square_walls**(cells, rows, columns, cell_width, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_walls.html) | a helper for creating square wall data from maze cells.
+[**maze/mz_hex_walls**(cells, rows, columns, cell_radius, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_hex_walls.html) | a helper for creating hex wall data from maze cells.
+[**maze/mz_square_initialize**(rows, columns, mask)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_initialize.html) | a helper for initializing cell data of a maze.
+[**maze/mz_hamiltonian**(rows, columns[, start, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_hamiltonian.html) | create a hamiltonian path from a maze.
+[**maze/mz_theta_cells**(rows, beginning_number[, start, seed])](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_theta_cells.html) | return cell data of a theta maze.
+[**maze/mz_theta_get**(cell, query)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_theta_get.html) | a helper for getting data from a theta-maze cell.
+
+## Polyhedra
+
+ Signature | Description
+--|--
+[**polyhedra/star**([outerRadius, innerRadius, height, n])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_star.html) | create a 3D star.
+[**polyhedra/polar_zonohedra**(n[, theta])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_polar_zonohedra.html) | create a [polar zonohedra](https://mathworld.wolfram.com/PolarZonohedron.html).
+[**polyhedra/tetrahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_tetrahedron.html) | create a tetrahedron.
+[**polyhedra/hexahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_hexahedron.html) | create a hexahedron.
+[**polyhedra/octahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_octahedron.html) | create a octahedron.
+[**polyhedra/dodecahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_dodecahedron.html) | create a dodecahedron.
+[**polyhedra/icosahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_icosahedron.html) | create a icosahedron.
+[**polyhedra/superellipsoid**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_superellipsoid.html) | create a superellipsoid.
+
+----
 
-- [maze/mz_square_cells](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_cells.html)
-- [maze/mz_square_get](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_get.html)
-- [maze/mz_square_walls](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_walls.html)
-- [maze/mz_hex_walls](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_hex_walls.html)
-- [maze/mz_square_initialize](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_initialize.html)
-- [maze/mz_hamiltonian](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_hamiltonian.html)
-- [maze/mz_theta_cells](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_theta_cells.html)
-- [maze/mz_theta_get](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_theta_get.html)

RELEASE.md

@@ -1,5 +1,99 @@
 > Version numbers are based on [Semantic Versioning](https://semver.org/).
 
+# v3.2.1
+
+Maintenance release: bug fixes & performance improvements.
+
+# v3.2
+
+## Deprecated:
+
+ Name | Description
+--|--
+**paths2sections** | use **rails2sections** instead.
+**hull_polyline2d**, **hull_polyline3d** | use **polyline_join** instead.
+**shape_starburst**, **shape_pentagram** | use **shape_star** instead.
+**starburst** | use **polyhedra/star** instead.
+
+## New parameters:
+
+- `angle_between` adds `ccw`.
+
+## New modules/functions:
+
+### Matrix
+
+## 2D/3D Function
+
+ Signature | Description
+--|--
+[**rails2sections**(rails)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rails2sections.html) | create sections along rails.
+
+## Transformation
+
+ Signature | Description
+--|--
+[**select**(i)](https://openhome.cc/eGossip/OpenSCAD/lib3x-select.html) | select module objects.
+[**polyline_join**(points)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline_join.html) | place a join on each point. Hull each pair of joins and union all convex hulls.
+
+## 2D Shape
+
+ Signature | Description
+--|--
+[**shape_star**([outer_radius, inner_radius, n])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_star.html) | create a 2D star.
+
+## Polyhedra
+
+ Signature | Description
+--|--
+[**polyhedra/star**([outerRadius, innerRadius, height, n])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_star.html) | create a 3D star.
+[**polyhedra/polar_zonohedra**(n[, theta])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_polar_zonohedra.html) | create a [polar zonohedra](https://mathworld.wolfram.com/PolarZonohedron.html).
+[**polyhedra/tetrahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_tetrahedron.html) | create a tetrahedron.
+[**polyhedra/hexahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_hexahedron.html) | create a hexahedron.
+[**polyhedra/octahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_octahedron.html) | create a octahedron.
+[**polyhedra/dodecahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_dodecahedron.html) | create a dodecahedron.
+[**polyhedra/icosahedron**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_icosahedron.html) | create a icosahedron.
+[**polyhedra/superellipsoid**(radius[, detail])](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyhedra_superellipsoid.html) | create a superellipsoid.
+
+# v3.1
+
+## Deprecated:
+
+ Name | Description
+--|--
+**bezier_surface** | use **surface/sf_splines** instead.
+**function_grapher** | use **surface/sf_thicken** instead.
+
+## New modules/functions:
+
+### Matrix
+
+ Signature | Description
+--|--
+[**maxtrix/m_transpose**(m)](https://openhome.cc/eGossip/OpenSCAD/lib3x-m_transpose.html) | transpose a matrix.
+
+### Surface
+
+ Signature | Description
+--|--
+[**surface/sf_curve**(levels, curve_path, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_curve.html) | curve a photo.
+[**surface/sf_splines**(ctrl_pts, row_spline, column_spline)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_splines.html) | generalized-spline surface.
+[**surface/sf_thicken**(points, thickness, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_thicken.html) | thicken a surface.
+[**surface/sf_solidifyT**(points1, points2, triangles)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_solidifyT.html) | solidify two surfaces with triangular mesh.
+[**surface/sf_thickenT**(points, thickness, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_thickenT.html) | thicken a surface with triangular mesh.
+
+### Triangle
+
+ Signature | Description
+--|--
+[**triangle/tri_circumcenter**(shape_pts)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_circumcenter.html) | return the circumcenter of a triangle.
+[**triangle/tri_incenter**(shape_pts)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_incenter.html) | return the incenter of a triangle.
+[**triangle/tri_ear_clipping**(shape_pts,  ret = "TRI_INDICES", ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_ear_clipping.html) | triangulation by [ear clipping](https://en.wikipedia.org/wiki/Polygon_triangulation#Ear_clipping_method).
+[**triangle/tri_delaunay**(points, ret = "TRI_INDICES")](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay.html) | Join a set of points to make a [Delaunay triangulation](https://en.wikipedia.org/wiki/Delaunay_triangulation).
+[**triangle/tri_delaunay_indices**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_indices.html) | return triangle indices from a delaunay object.
+[**triangle/tri_delaunay_shapes**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_shapes.html) | return triangle shapes from a delaunay object.
+[**triangle/tri_delaunay_voronoi**(d)](https://openhome.cc/eGossip/OpenSCAD/lib3x-tri_delaunay_voronoi.html) | return [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) cells from a delaunay object.
+
 # v3.0
 
 **It's a version that Breaks Backward Compatibility!!**

docs/lib3x-along_with.md

@@ -57,9 +57,9 @@ Puts children along the given path. If there's only one child, it will put the c
 	angles = [for(p_a = pts_angles) p_a[1]];
 
 	along_with(points, angles)
-		rotate([90, 0, 0]) 
-			linear_extrude(1, center = true) 
-				text("A", valign = "center", halign = "center");
+	rotate([90, 0, 0]) 
+	linear_extrude(1, center = true) 
+		text("A", valign = "center", halign = "center");
 
 ![along_with](images/lib3x-along_with-3.JPG)
 
@@ -69,20 +69,20 @@ Puts children along the given path. If there's only one child, it will put the c
 	module scales() {
 		module one_scale() {
 			rotate([0, 60, 0]) 
-				linear_extrude(1, center = true) 
-					scale([2, 1]) 
-						circle(1.25, $fn = 24);    
+			linear_extrude(1, center = true) 
+			scale([2, 1]) 
+				circle(1.25, $fn = 24);    
 		}
 
 		for(a = [0:30:330]) {
 			rotate(a) 
-				translate([5, 0, 0]) 
-					one_scale();
-			rotate(a + 15) 
-				translate([5, 0, 1.75]) 
-					one_scale();
-		}
+			translate([5, 0, 0]) 
+				one_scale();
 
+			rotate(a + 15) 
+			translate([5, 0, 1.75]) 
+				one_scale();
+		}
 	}
 
 	t_step = 0.01;

docs/lib3x-arc_path.md

@@ -11,21 +11,23 @@ Creates an arc path. You can pass a 2 element vector to define the central angle
 
 ## Examples
   
-    use <arc_path.scad>;
-    use <hull_polyline2d.scad>;
-    
-    $fn = 24;
-    points = arc_path(radius = 20, angle = [45, 290]);
-    hull_polyline2d(points, width = 2);
+	use <arc_path.scad>;
+	use <polyline_join.scad>;
+
+	$fn = 24;
+	points = arc_path(radius = 20, angle = [45, 290]);
+	polyline_join(points) 
+        circle(1);
 
 ![arc_path](images/lib3x-arc_path-1.JPG)
 
     use <arc_path.scad>;
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
     
     $fn = 24;
     points = arc_path(radius = 20, angle = 135);
-    hull_polyline2d(points, width = 2);
+    polyline_join(points) 
+        circle(1);
 
 ![arc_path](images/lib3x-arc_path-2.JPG)
 

docs/lib3x-archimedean_spiral.md

@@ -47,22 +47,22 @@ An `init_angle` less than 180 degrees is not recommended because the function us
 	}
 
 ![archimedean_spiral](images/lib3x-archimedean_spiral-2.JPG)
-
-    include <archimedean_spiral.scad>;
-    
-    t = "3.141592653589793238462643383279502884197169399375105820974944592307816406286";
-
-	points = archimedean_spiral(
+	
+	use <archimedean_spiral.scad>;
+	
+	t = "3.141592653589793238462643383279502884197169399375105820974944592307816406286";
+	
+	points_angles = archimedean_spiral(
 	    arm_distance = 15,
 	    init_angle = 450, 
 	    point_distance = 12, 
 	    num_of_points = len(t) 
 	); 
 	
-	for(i = [0: len(points) - 1]) {
-	    translate(points[i][0])          
-	        rotate(points[i][1] + 90)  
-	            text(t[i], valign = "center", halign = "center");
+	for(i = [0: len(points_angles) - 1]) {
+	    translate(points_angles[i][0])          
+	    rotate(points_angles[i][1] + 90)  
+	        text(t[i], valign = "center", halign = "center");
 	}
 
 ![archimedean_spiral](images/lib3x-archimedean_spiral-3.JPG)

docs/lib3x-bauer_spiral.md

@@ -15,7 +15,7 @@ Creates visually even spacing of n points on the surface of the sphere. Successi
 ## Examples
 
     use <bauer_spiral.scad>;
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
 
     n = 200;
     radius = 20;
@@ -26,7 +26,8 @@ Creates visually even spacing of n points on the surface of the sphere. Successi
             sphere(1, $fn = 24);
     }
 
-    hull_polyline3d(pts, 1);
+    polyline_join(pts) 
+        sphere(.5);
 
 ![bauer_spiral](images/lib3x-bauer_spiral-1.JPG)
 

docs/lib3x-bend.md

@@ -34,7 +34,8 @@ Once you have the size of the containing cube, you can use it as the `size` argu
 	*cube(size = [x, y, z]);
 	
 	bend(size = [x, y, z], angle = 270)
-	    linear_extrude(z) text("A");
+	linear_extrude(z) 
+		text("A");
 
 ![bend](images/lib3x-bend-2.JPG)
 
@@ -47,8 +48,8 @@ The arc shape is smoother if the `frags` value is larger.
 	z = 1;  
 	
 	bend(size = [x, y, z], angle = 270, frags = 360)
-	    linear_extrude(z) 
-	        text("A");
+	linear_extrude(z) 
+		text("A");
 
 ![bend](images/lib3x-bend-3.JPG)
 

docs/lib3x-bezier_curve.md

@@ -1,21 +1,21 @@
 # bezier_curve
 
-Given a set of control points, the `bezier_curve` function returns points of the Bézier path. Combined with the `polyline`, `polyline3d` or `hull_polyline3d` module defined in my library, you can create a Bézier curve.
+Given a set of control points, the `bezier_curve` function returns points of the Bézier path. 
 
 ## Parameters
 
-- `t_step` : The distance between two points of the Bézier path.
+- `t_step` : 0 ~ 1. Control the distance between two points of the Bézier path.
 - `points` : A list of `[x, y]` or `[x, y, z]` control points.
 
 ## Examples
 
-If you have four control points and combine with the `hull_polyline3d` module:
+If you have four control points:
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
 	use <bezier_curve.scad>;
 
 	t_step = 0.05;
-	width = 2;
+	radius = 2;
 	
 	p0 = [0, 0, 0];
 	p1 = [40, 60, 35];
@@ -26,6 +26,7 @@ If you have four control points and combine with the `hull_polyline3d` module:
 	    [p0, p1, p2, p3]
 	);
 	
-	hull_polyline3d(points, width);      
+	polyline_join(points)
+	    sphere(radius);      
 
 ![bezier_curve](images/lib3x-bezier_curve-1.JPG)

docs/lib3x-bezier_smooth.md

@@ -12,7 +12,7 @@ Given a path, the `bezier_smooth` function uses bazier curves to smooth all corn
 
 ## Examples
 
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <bezier_smooth.scad>;
 
 	width = 2;
@@ -25,15 +25,15 @@ Given a path, the `bezier_smooth` function uses bazier curves to smooth all corn
 		[-10, -10, 50]
 	];
 
-	hull_polyline3d(
-		path_pts, width
-	);
+	polyline_join(path_pts)
+	    sphere(width / 2);
 
 	smoothed_path_pts = bezier_smooth(path_pts, round_d);
 
-	color("red") translate([30, 0, 0]) hull_polyline3d(
-		smoothed_path_pts, width
-	);
+	color("red") 
+	translate([30, 0, 0]) 
+	polyline_join(smoothed_path_pts) 
+	    sphere(width / 2);
 
 ![bezier_smooth](images/lib3x-bezier_smooth-1.JPG)
 
@@ -51,6 +51,7 @@ Given a path, the `bezier_smooth` function uses bazier curves to smooth all corn
 
 	smoothed_path_pts = bezier_smooth(path_pts, round_d, closed = true);
 
-	translate([50, 0, 0]) polygon(smoothed_path_pts);
+	translate([50, 0, 0]) 
+	    polygon(smoothed_path_pts);
 
 ![bezier_smooth](images/lib3x-bezier_smooth-2.JPG)

docs/lib3x-bezier_surface.md

@@ -1,34 +0,0 @@
-# bezier_surface
-
-Given a set of control points, the `bezier_surface` function returns points of the Bézier surface. Combined with the `function_grapher` module defined in my library, you can create a Bézier surface.
-
-## Parameters
-
-- `t_step` : The distance between two points of the Bézier path.
-- `points` : A set of control points. See examples below.
-
-## Examples
-
-If you have 16 control points and combine with the `function_grapher` module:
-
-	use <bezier_surface.scad>; 
-	use <function_grapher.scad>;
-
-	t_step = 0.05;
-	thickness = 0.5;
-
-	ctrl_pts = [
-		[[0, 0, 20],  [60, 0, -35],   [90, 0, 60],    [200, 0, 5]],
-		[[0, 50, 30], [100, 60, -25], [120, 50, 120], [200, 50, 5]],
-		[[0, 100, 0], [60, 120, 35],  [90, 100, 60],  [200, 100, 45]],
-		[[0, 150, 0], [60, 150, -35], [90, 180, 60],  [200, 150, 45]]
-	];
-
-	g = bezier_surface(t_step, ctrl_pts);
-	function_grapher(g, thickness);    
-
-![bezier_surface](images/lib3x-bezier_surface-1.JPG)
-
-The following figure shows controll points and bazier curves around the surface.
-
-![bezier_surface](images/lib3x-bezier_surface-2.JPG)

docs/lib3x-bijection_offset.md

@@ -22,11 +22,11 @@ Move 2D outlines outward or inward by a given amount. Each point of the offsette
 		[-15, 0]
 	];
 
-	color("red") polygon(bijection_offset(shape, 3));
+	color("red")    polygon(bijection_offset(shape, 3));
 	color("orange") polygon(bijection_offset(shape, 2));
 	color("yellow") polygon(bijection_offset(shape, 1));
-	color("green") polygon(shape);
-	color("blue") polygon(bijection_offset(shape, -1));
+	color("green")  polygon(shape);
+	color("blue")   polygon(bijection_offset(shape, -1));
 	color("indigo") polygon(bijection_offset(shape, -2));
 	color("purple") polygon(bijection_offset(shape, -3));
 
@@ -43,7 +43,6 @@ Move 2D outlines outward or inward by a given amount. Each point of the offsette
 		[-5, 0]
 	];
 	offsetted = bijection_offset(shape, 1);
-
 	offsetted2 = bijection_offset(shape, 2);
 	offsetted3 = bijection_offset(shape, 3);
 

docs/lib3x-bspline_curve.md

@@ -1,6 +1,6 @@
 # bspline_curve
 
-[B-spline](https://en.wikipedia.org/wiki/B-spline) interpolation using [de Boor's algorithm](https://en.wikipedia.org/wiki/De_Boor%27s_algorithm). This function returns points of the B-spline path. Combined with the `polyline`, `polyline3d` or `hull_polyline3d` module, you can create a B-spline curve.
+[B-spline](https://en.wikipedia.org/wiki/B-spline) interpolation using [de Boor's algorithm](https://en.wikipedia.org/wiki/De_Boor%27s_algorithm). This function returns points of the B-spline path. 
 
 **Since:** 2.1
 
@@ -49,7 +49,8 @@
     // a non-uniform B-spline curve
     knots = [0, 1/8, 1/4, 1/2, 3/4, 4/5, 1];
     
-	color("red") for(p = points) {
+	color("red") 
+	for(p = points) {
 		translate(p) 
 			sphere(0.5);
 	}
@@ -73,7 +74,8 @@
 	// For a clamped B-spline curve, the first `degree + 1` and the last `degree + 1` knots must be identical.
 	knots = [0, 0, 0, 1, 2, 2, 2];
 
-	color("red") for(p = points) {
+	color("red") 
+	for(p = points) {
 		translate(p) 
 			sphere(0.5);
 	}

docs/lib3x-circle_path.md

@@ -21,9 +21,9 @@ Sometimes you need all points on the path of a circle. Here's the function. Its
 	step_angle = 360 / leng;
 	for(i = [0:leng - 1]) {
 	    translate(points[i]) 
-	        rotate([90, 0, 90 + i * step_angle]) 
-	            linear_extrude(1, center = true) 
-	                text("A", valign = "center", halign = "center");
+		rotate([90, 0, 90 + i * step_angle]) 
+		linear_extrude(1, center = true) 
+			text("A", valign = "center", halign = "center");
 	}
 
 ![circle_path](images/lib3x-circle_path-1.JPG)

docs/lib3x-contours.md

@@ -11,8 +11,8 @@ Computes contour polygons by applying [marching squares](https://en.wikipedia.or
 
 ## Examples
 
-    use <hull_polyline2d.scad>;
-    use <function_grapher.scad>;
+    use <polyline_join.scad>;
+	use <surface/sf_thicken.scad>;
     use <contours.scad>;
 
     min_value =  1;
@@ -23,20 +23,21 @@ Computes contour polygons by applying [marching squares](https://en.wikipedia.or
     
     points = [
         for(y = [min_value:resolution:max_value])
-            [
-                for(x = [min_value:resolution:max_value]) 
-                    [x, y, f(x, y)]
-            ]
+        [
+            for(x = [min_value:resolution:max_value]) 
+                [x, y, f(x, y)]
+        ]
     ];
 
-    function_grapher(points, 1);
+    sf_thicken(points, 1);
 
     translate([max_value, 0, 0]) 
     for(z = [-30:5:30]) {
         translate([0, 0, z])
         linear_extrude(1)
         for(isoline = contours(points, z)) {
-            hull_polyline2d(isoline, width = 1);
+            polyline_join(isoline)
+			    circle(.5);
         }    
     }
 

docs/lib3x-curve.md

@@ -6,7 +6,7 @@ Draws a curved line from control points. The curve is drawn only from the 2nd co
 
 ## Parameters
 
-- `t_step` : The distance between two points of the generated curve.
+- `t_step` : 0 ~ 1. Control the distance between two points of the generated curve.
 - `points` : A list of `[x, y]` or `[x, y, z]` control points.
 - `tightness` : You can view it as the curve tigntness if you provide a value between 0.0 and 1.0. The default value is 0.0. The value 1.0 connects all the points with straight lines. The value greater than 1.0 or less than 0.0 is also acceptable because it defines how to generate a bezier curve every four control points.
 
@@ -17,7 +17,7 @@ Draws a curved line from control points. The curve is drawn only from the 2nd co
 ## Examples
 
 	use <curve.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 
 	pts = [
 		[28, 2, 1],
@@ -32,12 +32,14 @@ Draws a curved line from control points. The curve is drawn only from the 2nd co
 	tightness = 0;
 	points = curve(t_step, pts, tightness);
 
-	hull_polyline3d(points, 1);   
+	polyline_join(points)
+	    sphere(.5);   
 
 	#for(pt = pts) {
 		translate(pt)
 			sphere(1);
 	}
-	#hull_polyline3d(pts, .1);  
+	#polyline_join(pts)
+	    sphere(.05);  
 
 ![curve](images/lib3x-curve-3.JPG)

docs/lib3x-ellipse_extrude.md

@@ -34,7 +34,9 @@ Extrudes a 2D object along the path of an ellipse from 0 to 180 degrees. The sem
 	 
 	ellipse_extrude(semi_minor_axis) 
 	    text("♥", size = 40, valign = "center", halign = "center");
-	mirror([0, 0, 1]) ellipse_extrude(semi_minor_axis) 
+		
+	mirror([0, 0, 1]) 
+	ellipse_extrude(semi_minor_axis) 
 	    text("♥", size = 40, valign = "center", halign = "center");
 
 ![ellipse_extrude](images/lib3x-ellipse_extrude-3.JPG)

docs/lib3x-fibonacci_lattice.md

@@ -31,7 +31,7 @@ Creates visually even spacing of n points on the surface of the sphere. Nearest-
 ![fibonacci_lattice](images/lib3x-fibonacci_lattice-1.JPG)
 
     use <fibonacci_lattice.scad>;
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
 
     n = 200;
     radius = 20;
@@ -49,7 +49,8 @@ Creates visually even spacing of n points on the surface of the sphere. Nearest-
     ];
 
     for(spiral = spirals) {
-        hull_polyline3d(spiral, 1);	
+        polyline_join(spiral)
+		    sphere(.5);	
     }
         
 ![fibonacci_lattice](images/lib3x-fibonacci_lattice-2.JPG)

docs/lib3x-flat.md

@@ -16,26 +16,21 @@ returns a new list with all sub-list elements concatenated into it recursively u
 	vt = [[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]];
 
 	assert(
-		flat([1, 2, [3, 4]]) == 
-			[1, 2, 3, 4]
+		flat([1, 2, [3, 4]]) == [1, 2, 3, 4]
 	);
 
 	assert(
-		flat([[1, 2], [3, 4]]) == 
-			[1, 2, 3, 4]
+		flat([[1, 2], [3, 4]]) == [1, 2, 3, 4]
 	);
 
 	assert(
-		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]]) == 
-			[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]]) == [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
 	);
 
 	assert(
-		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]], 2) == 
-			[[1, 2], [3, 4], [5, 6], [7, 8]]
+		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]], 2) == [[1, 2], [3, 4], [5, 6], [7, 8]]
 	);
 
 	assert(
-		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]], 3) == 
-			[1, 2, 3, 4, 5, 6, 7, 8]
+		flat([[[[1, 2], [3, 4]], [[5, 6], [7, 8]]]], 3) == [1, 2, 3, 4, 5, 6, 7, 8]
 	);

docs/lib3x-footprints2.md

@@ -11,7 +11,7 @@ Drive a turtle with `["forward", length]` or `["turn", angle]`. This function is
 
 ## Examples
 	    
-	use <polyline2d.scad>;
+	use <polyline_join.scad>;
 	use <turtle/footprints2.scad>;
 	
 	function arc_cmds(radius, angle, steps) = 
@@ -20,35 +20,33 @@ Drive a turtle with `["forward", length]` or `["turn", angle]`. This function is
 			ta = fa / 2,
 			leng = sin(ta) * radius * 2
 		)
-		concat(
-			[["turn", ta]],
-			[
+        [
+            ["turn", ta],
+            each [
 				for(i = [0:steps - 2])
 				each [["forward", leng], ["turn", fa]]
 			],
-			[["forward", leng], ["turn", ta]]
-		);
+            ["forward", leng], 
+            ["turn", ta]
+        ];
 		
 	poly = footprints2(
-		concat(
-			[
-				["forward", 10],
-				["turn", 90],
-				["forward", 10] 
-			], 
-			arc_cmds(5, 180, 12),
-			[
-				["turn", -90],
-				["forward", 10],
-				["turn", 90],
-				["forward", 10],
-				["turn", 90],
-				["forward", 10]
-			]
-		)
+        [
+            ["forward", 10],
+		    ["turn", 90],
+			["forward", 10],
+            each arc_cmds(5, 180, 12),
+            ["turn", -90],
+            ["forward", 10],
+            ["turn", 90],
+            ["forward", 10],
+            ["turn", 90],
+            ["forward", 10]
+        ]
 	);
 
-	polyline2d(poly, width = 1);
+	polyline_join(poly)
+	    circle(.5);
 
 ![footprints2](images/lib3x-footprints2-1.JPG)
 

docs/lib3x-footprints3.md

@@ -11,7 +11,7 @@ A 3D verion of [footprint2](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprint
 
 ## Examples
 	    
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <turtle/footprints3.scad>;
 	
 	function xy_arc_cmds(radius, angle, steps) = 
@@ -20,36 +20,32 @@ A 3D verion of [footprint2](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprint
 			ta = fa / 2,
 			leng = sin(ta) * radius * 2
 		)
-		concat(
-			[["turn", ta]],
-			[
+        [
+            ["turn", ta],
+            each [
 				for(i = [0:steps - 2])
 				each [["forward", leng], ["turn", fa]]
 			],
-			[["forward", leng], ["turn", ta]]
-		);
+            ["forward", leng], 
+            ["turn", ta]
+        ];
 
 	poly = footprints3(
-		concat(
-			[
-				["forward", 10],
-				["turn", 90],
-				["forward", 10] 
-			], 
-			xy_arc_cmds(5, 180, 12),
-			[
-				["pitch", 90],
-				["forward", 10],
-				["roll", 90]
-			],
-			xy_arc_cmds(5, 180, 12),
-			[
-				["forward", 10]
-			]
-		)
+        [
+            ["forward", 10],
+            ["turn", 90],
+            ["forward", 10],
+            each xy_arc_cmds(5, 180, 12),
+            ["pitch", 90],
+            ["forward", 10],
+            ["roll", 90],
+            each xy_arc_cmds(5, 180, 12),
+            ["forward", 10]
+        ]
 	);
 
-	hull_polyline3d(poly, thickness = 1);
+	polyline_join(poly)
+	    sphere(.5);
 
 ![footprints3](images/lib3x-footprints3-1.JPG)
 

docs/lib3x-function_grapher.md

@@ -1,78 +0,0 @@
-# function_grapher
-
-Given a list of points `[x, y, f(x, y)]` where `f(x, y)` is a mathematics function, the `function_grapher` module can create the graph of `f(x, y)`.
-
-## Parameters
-
-- `points` : A list of points `[x, y, f(x, y)]`. See examples below.
-- `thickness` : The face or line thickness. Default to 1.
-- `style` : The style of the graph. It accepts `"FACES"`, `"LINES"`, `"HULL_FACES"` and `"HULL_LINES"`. The default value is `"FACES"` which simply takes `f(x, y) - thickness` for each point to build a bottom. It may cause thickness problems when slopes is high. The `"HULL_FACES"` value can solve the problem but is slow. When assigning `"LINES"`, it uses lines to connect points. The `"HULL_LINES"` is very very slow; however, the model might look smoother if you have a small `$fn`.
-- `$fa`, `$fs`, `$fn` : Used by the `circle` or `sphere` module internally. It affects the speed of rending. For example, a large `$fn` may be very slow when rending. Check [the circle module](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Using_the_2D_Subsystem#circle) or [the sphere module](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids#sphere) for more details. 
-
-## Examples
-
-	use <function_grapher.scad>;
-	
-	points = [
-	    [[0, 0, 1], [1, 0, 2], [2, 0, 2], [3, 0, 3]],
-	    [[0, 1, 1], [1, 1, 4], [2, 1, 0], [3, 1, 3]],
-	    [[0, 2, 1], [1, 2, 3], [2, 2, 1], [3, 2, 3]],
-	    [[0, 3, 1], [1, 3, 3], [2, 3, 1], [3, 3, 3]]
-	];
-	
-	thickness = 0.5;
-	
-	function_grapher(points, thickness);
-
-![function_grapher](images/lib3x-function_grapher-1.JPG)
-
-	use <function_grapher.scad>;
-	
-	function f(x, y) = 
-	   30 * (
-	       cos(sqrt(pow(x, 2) + pow(y, 2))) + 
-	       cos(3 * sqrt(pow(x, 2) + pow(y, 2)))
-	   );
-	
-	thickness = 2;
-	min_value =  -200;
-	max_value = 200;
-	resolution = 10;
-	
-	points = [
-	    for(y = [min_value:resolution:max_value])
-	        [
-	            for(x = [min_value:resolution:max_value]) 
-	                [x, y, f(x, y)]
-	        ]
-	];
-	
-	function_grapher(points, thickness);
-
-![function_grapher](images/lib3x-function_grapher-2.JPG)
-
-	use <function_grapher.scad>;
-
-	function f(x, y) = 
-	   30 * (
-	       cos(sqrt(pow(x, 2) + pow(y, 2))) + 
-	       cos(3 * sqrt(pow(x, 2) + pow(y, 2)))
-	   );
-	
-	thickness = 2;
-	min_value =  -200;
-	max_value = 200;
-	resolution = 10;
-	style = "LINES"; 
-	
-	points = [
-	    for(y = [min_value:resolution:max_value])
-	        [
-	            for(x = [min_value:resolution:max_value]) 
-	                [x, y, f(x, y)]
-	        ]
-	];
-	
-	function_grapher(points, thickness, style);
-
-![function_grapher](images/lib3x-function_grapher-3.JPG)

docs/lib3x-golden_spiral.md

@@ -38,9 +38,9 @@ It returns a vector of `[[x, y], angle]`.
 	    
 	for(pt_angle = pts_angles) {
 	    translate(pt_angle[0]) 
-	        rotate([90, 0, pt_angle[1]])
-	            linear_extrude(1, center = true) 
-	                text("A", valign = "center", halign = "center");
+		rotate([90, 0, pt_angle[1]])
+		linear_extrude(1, center = true) 
+			text("A", valign = "center", halign = "center");
 	}
     
 ![golden_spiral](images/lib3x-golden_spiral-2.JPG)

docs/lib3x-hashmap.md

@@ -39,9 +39,9 @@ This function maps keys to values. You can use the following to process the retu
     m3 = hashmap_del(m2, "k1");
     assert(hashmap_get(m3, "k1") == undef);
 
-    echo(hashmap_keys(m3));    // a list contains "k2", "k2", "k3"
-    echo(hashmap_values(m3));  // a list contains 20, 30, 40
-    echo(hashmap_entries(m3)); // a list contains ["k2", 20], ["k3", 30], ["k4", 40]
+    assert(hashmap_keys(m3) == ["k2", "k3", "k4"]); 
+    assert(hashmap_values(m3) == [20, 30, 40]); 
+    assert(hashmap_entries(m3) == [["k2", 20], ["k3", 30], ["k4", 40]]);
 
 Want to simulate class-based OO in OpenSCAD? Here's my experiment.
 
@@ -54,7 +54,7 @@ Want to simulate class-based OO in OpenSCAD? Here's my experiment.
     function clz_list(data) = function(name) _(name,
         methods([
             ["get", function(i) data[i]],
-            ["append", function(n) clz_list(concat(data, [n]))]
+            ["append", function(n) clz_list([each data, n])]
         ])
     );
 

docs/lib3x-hashmap_del.md

@@ -7,7 +7,7 @@ This function deletes the mapping for the specified key from a [util/map/hashmap
 ## Parameters
 
 - `map` : The original map.
-- `key` : Adds the specified element to the specified set
+- `key` : The specified key.
 - `eq` : A equality function. If it's ignored, use `==` to compare elements.
 - `hash` : A hash function. If it's ignored, convert each element to a string and hash it. 
 

docs/lib3x-hashmap_get.md

@@ -1,13 +1,13 @@
 # hashmap_get
 
-This function gets the value of the specified key from a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html).
+This function gets the value of the specified key from a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html). If the key doesn't exist, return `undef`.
 
 **Since:** 3.0
 
 ## Parameters
 
 - `map` : The original map.
-- `key` : Adds the specified element to the specified set
+- `key` : The specified key.
 - `eq` : A equality function. If it's ignored, use `==` to compare elements.
 - `hash` : A hash function. If it's ignored, convert each element to a string and hash it. 
 

docs/lib3x-hashmap_len.md

@@ -1,6 +1,6 @@
 # hashmap_len
 
-This function puts a key/value to a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html). It returns a new map containing the key/value.
+Returns the length of a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html).
 
 **Since:** 3.0
 

docs/lib3x-hashmap_put.md

@@ -1,12 +1,16 @@
 # hashmap_put
 
-This function returns the length of a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html).
+Puts a key/value pair to a [util/map/hashmap](https://openhome.cc/eGossip/OpenSCAD/lib3x-hashmap.html).
 
 **Since:** 3.0
 
 ## Parameters
 
 - `map` : The original map.
+- `key` : The specified key.
+- `value` : The specified value.
+- `eq` : A equality function. If it's ignored, use `==` to compare elements.
+- `hash` : A hash function. If it's ignored, convert each element to a string and hash it. 
 
 ## Examples
 

docs/lib3x-hashset.md

@@ -35,4 +35,4 @@ This function models the mathematical set, backed by a hash table. You can use t
     s3 = hashset_del(s2, 2);
     assert(!hashset_has(s3, 2));
 
-    echo(hashset_elems(s3)); // a list contains 1, 3, 4, 5, 9
+    assert(hashset_elems(s3) == [1, 3, 4, 5, 9]); 

docs/lib3x-hashset_elems.md

@@ -14,5 +14,5 @@ Returns a list containing all elements in a [util/set/hashset](https://openhome.
     use <util/set/hashset_elems.scad>;
 
     s = hashset([1, 2, 3, 4, 5]);
-    echo(hashset_elems(s));  // a list contains 1, 2, 3, 4, 5
+    assert(hashset_elems(s) == [1, 2, 3, 4, 5]); 
 

docs/lib3x-helix.md

@@ -14,7 +14,7 @@ Gets all points on the path of a spiral around a cylinder. Its `$fa`, `$fs` and
 ## Examples
     
 	use <helix.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	
 	$fn = 12;
 	
@@ -27,15 +27,17 @@ Gets all points on the path of a spiral around a cylinder. Its `$fa`, `$fs` and
 	);
 	
 	for(p = points) {
-	    translate(p) sphere(5);
+	    translate(p) 
+		    sphere(5);
 	}
 	
-	hull_polyline3d(points, 2);
+	polyline_join(points)
+	    sphere(1);
 
 ![helix](images/lib3x-helix-1.JPG)
 
 	use <helix.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 
 	$fn = 12;
 
@@ -47,7 +49,8 @@ Gets all points on the path of a spiral around a cylinder. Its `$fa`, `$fs` and
 		rt_dir = "CLK"
 	);
 
-	hull_polyline3d(points, 2);
+	polyline_join(points)
+	    sphere(1);
 
 	%cylinder(h = 100, r1 = 40, r2 = 20);
 

docs/lib3x-hollow_out.md

@@ -10,7 +10,10 @@ Hollows out a 2D object.
 
     use <hollow_out.scad>;
 
-	hollow_out(shell_thickness = 1) circle(r = 3, $fn = 48);
-    hollow_out(shell_thickness = 1) square([10, 5]);
+	hollow_out(shell_thickness = 1) 
+        circle(r = 3, $fn = 48);
+    
+    hollow_out(shell_thickness = 1) 
+        square([10, 5]);
 
 ![hollow_out](images/lib3x-hollow_out-1.JPG)

docs/lib3x-hull_polyline2d.md

@@ -1,22 +0,0 @@
-# hull_polyline2d
-
-Creates a 2D polyline from a list of `[x, y]` coordinates. As the name says, it uses the built-in hull operation for each pair of points (created by the `circle` module). It's slow. However, it can be used to create metallic effects for a small `$fn`, large `$fa` or `$fs`.
-
-## Parameters
-
-- `points` : The list of `[x, y]` points of the polyline. The points are indexed from 0 to n-1.
-- `width` : The line width. Default to 1.
-- `$fa`, `$fs`, `$fn` : Check [the circle module](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Using_the_2D_Subsystem#circle) for more details.
-
-## Examples
-
-	use <hull_polyline2d.scad>;
-	
-	$fn = 4;
-	
-	hull_polyline2d(
-	    points = [[1, 2], [-5, -4], [-5, 3], [5, 5]], 
-	    width = 1
-	);
-
-![hull_polyline3d](images/lib3x-hull_polyline2d-1.JPG)

docs/lib3x-hull_polyline3d.md

@@ -1,45 +0,0 @@
-# hull_polyline3d
-
-Creates a 3D polyline from a list of `[x, y, z]` coordinates. As the name says, it uses the built-in hull operation for each pair of points (created by the `sphere` module). It's slow. However, it can be used to create metallic effects for a small `$fn`, large `$fa` or `$fs`.
-
-## Parameters
-
-- `points` : The list of `[x, y, z]` points of the polyline. The points are indexed from 0 to n-1.
-- `diameter` : The line diameter. Default to 1.
-- `$fa`, `$fs`, `$fn` : Check [the sphere module](https://en.wikibooks.org/wiki/OpenSCAD_User_Manual/Primitive_Solids#sphere) for more details.
-
-## Examples
-
-    use <hull_polyline3d.scad>;
-
-	hull_polyline3d(
-	    points = [
-	        [1, 2, 3], 
-	        [4, -5, -6], 
-	        [-1, -3, -5], 
-	        [0, 0, 0]
-	    ], 
-	    diameter = 1, 
-	    $fn = 3
-	);
-
-![polyline3d](images/lib3x-hull_polyline3d-1.JPG)
-
-    use <hull_polyline3d.scad>;
-    
-	r = 50;
-	points = [
-	    for(a = [0:180]) 
-	        [
-	           r * cos(-90 + a) * cos(a), 
-	           r * cos(-90 + a) * sin(a), 
-	           r * sin(-90 + a)
-	        ]
-	];
-	
-	for(i = [0:7]) {
-	    rotate(45 * i) 
-	        hull_polyline3d(points, 2, $fn = 3);
-	}
-
-![polyline3d](images/lib3x-hull_polyline3d-2.JPG)

docs/lib3x-in_polyline.md

@@ -1,6 +1,6 @@
 # in_polyline
 
-Checks wether a point is on a line.
+Checks whether a point is on a line.
 
 **Since:** 1.3
 
@@ -20,10 +20,10 @@ Checks wether a point is on a line.
         [10, 10]
     ];
 
-    echo(in_polyline(pts, [-2, -3]));  // false
-    echo(in_polyline(pts, [5, 0]));    // true
-    echo(in_polyline(pts, [10, 5]));   // true
-    echo(in_polyline(pts, [10, 15]));  // false
+    assert(!in_polyline(pts, [-2, -3])); 
+    assert(in_polyline(pts, [5, 0]));    
+    assert(in_polyline(pts, [10, 5]));   
+    assert(!in_polyline(pts, [10, 15]));
 
 ----
 
@@ -35,7 +35,7 @@ Checks wether a point is on a line.
         [20, 10, 10]
     ]; 
 
-    echo(in_polyline(pts, [10, 0, 10]));  // true
-    echo(in_polyline(pts, [15, 0, 10]));  // true
-    echo(in_polyline(pts, [15, 1, 10]));  // false
-    echo(in_polyline(pts, [20, 11, 10])); // false    
+    assert(in_polyline(pts, [10, 0, 10]));  
+    assert(in_polyline(pts, [15, 0, 10]));  
+    assert(!in_polyline(pts, [15, 1, 10])); 
+    assert(!in_polyline(pts, [20, 11, 10])); 

docs/lib3x-in_shape.md

@@ -1,6 +1,6 @@
 # in_shape
 
-Checks wether a point is inside a shape.
+Checks whether a point is inside a shape.
 
 **Since:** 1.3
 

docs/lib3x-lerp.md

@@ -6,8 +6,8 @@ Linear interpolate the vector v1 to v2.
 
 ## Parameters
 
-- `v1` : Minimum value of random number range. Default to 0.
-- `v2` : Maximum value of random number range. Default to 1.
+- `v1` : The vector v1.
+- `v2` : The vector v2.
 - `amt` : The amount of interpolation. Some value between 0.0 and 1.0.
 
 ## Examples

docs/lib3x-loft.md

@@ -11,7 +11,7 @@ When having uniform cross sections, you can use [sweep](https://openhome.cc/eGos
 
 ## Examples
 
-	use <shape_starburst.scad>;
+	use <shape_star.scad>;
 	use <shape_circle.scad>;
 	use <ptf/ptf_rotate.scad>;
 	use <loft.scad>;
@@ -19,7 +19,7 @@ When having uniform cross sections, you can use [sweep](https://openhome.cc/eGos
 	sects = [
 		for(i = 10; i >= 4; i = i - 1)
 		[
-			for(p = shape_starburst(15, 12, i % 2 == 1 ? i : i - 1)) ptf_rotate([p[0], p[1], 5 * (i - 4)], i * 10)
+			for(p = shape_star(15, 12, i % 2 == 1 ? i : i - 1)) ptf_rotate([p.x, p.y, 5 * (i - 4)], i * 10)
 		]
 	];
 	loft(sects, slices = 3);
@@ -28,16 +28,16 @@ When having uniform cross sections, you can use [sweep](https://openhome.cc/eGos
 	difference() {
 		loft(
 			[
-				[for(p = shape_circle(10, $fn = 3)) [p[0], p[1], 15]],
-				[for(p = shape_circle(15, $fn = 24)) [p[0], p[1], 0]]        
+				[for(p = shape_circle(10, $fn = 3)) [p.x, p.y, 15]],
+				[for(p = shape_circle(15, $fn = 24)) [p.x, p.y, 0]]        
 			],
 			slices = 4
 		);
 
 		loft(
 			[
-				[for(p = shape_circle(8, $fn = 3)) [p[0], p[1], 15.1]],
-				[for(p = shape_circle(13, $fn = 24)) [p[0], p[1], -0.1]]        
+				[for(p = shape_circle(8, $fn = 3)) [p.x, p.y, 15.1]],
+				[for(p = shape_circle(13, $fn = 24)) [p.x, p.y, -0.1]]        
 			],
 			slices = 4
 		);    

docs/lib3x-lsystem3.md

@@ -33,14 +33,11 @@
 [lsystem3-collections.scad](https://github.com/JustinSDK/dotSCAD/blob/master/examples/turtle/lsystem3_collection.scad) collects several L-system grammars. Here's one of them.
 
 	use <turtle/lsystem3.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 
 	for(line = hilbert_curve()) {
-		hull_polyline3d(
-			[line[0], line[1]], 
-			thickness = 0.5, 
-			$fn = 4
-		);
+		polyline_join([line[0], line[1]])
+		    sphere(.25, $fn = 4);
 	}  
 
 	function hilbert_curve(n = 3, angle = 90, leng = 1, heading = 0, start = [0, 0, 0]) = 
@@ -60,14 +57,11 @@
     // a stochastic L-system
 
 	use <turtle/lsystem3.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 
 	for(line = vine()) {
-		hull_polyline3d(
-			[line[0], line[1]], 
-			thickness = 0.5, 
-			$fn = 4
-		);
+		polyline_join([line[0], line[1]])
+		    sphere(.25, $fn = 4);
 	}  
 
 	function vine(n = 3, angle = 18, leng = 1, heading = 0, start = [0, 0, 0]) = 

docs/lib3x-m_mirror.md

@@ -1,7 +1,5 @@
 # m_mirror
 
-The dir changed since 2.0. 
-
 Generate a 4x4 transformation matrix which can pass into `multmatrix` to mirror the child element on a plane through the origin. 
 
 **Since:** 1.1
@@ -18,8 +16,8 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to mirror
 		cube([3, 2, 1]);
 		
 	multmatrix(m_mirror([1, 1, 0]))
-		rotate([0, 0, 10]) 
-			cube([3, 2, 1]);
+	rotate([0, 0, 10]) 
+		cube([3, 2, 1]);
 
 ![m_mirror](images/lib3x-m_mirror-1.JPG)
 

docs/lib3x-m_rotation.md

@@ -1,7 +1,5 @@
 # m_rotation
 
-The dir changed since 2.0. 
-
 Generate a 4x4 transformation matrix which can pass into `multmatrix` to rotate the child element about the axis of the coordinate system or around an arbitrary axis. 
 
 **Since:** 1.1
@@ -21,8 +19,8 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to rotate
 	hull() {
 		sphere(1);
 		multmatrix(m_rotation(a))    
-			translate(point) 
-				sphere(1);   
+		translate(point) 
+			sphere(1);   
 	}  
 
 ![m_rotation](images/lib3x-m_rotation-1.JPG)
@@ -34,14 +32,14 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to rotate
 	hull() {
 		sphere(1);
 		translate(v)
-		sphere(1);   
+		    sphere(1);   
 	}
 
 	p = [10, 10, 0];
 	for(i = [0:20:340]) {
 		multmatrix(m_rotation(a = i, v = v))
-			translate(p) 
-				sphere(1);  
+		translate(p) 
+			sphere(1);  
 	}
 
 ![m_rotation](images/lib3x-m_rotation-2.JPG)

docs/lib3x-m_scaling.md

@@ -1,7 +1,5 @@
 # m_scaling
 
-The dir changed since 2.0. 
-
 Generate a 4x4 transformation matrix which can pass into `multmatrix` to scale its child elements using the specified vector.
 
 **Since:** 1.1
@@ -16,8 +14,8 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to scale i
 
 	cube(10);
 	translate([15, 0, 0]) 
-		multmatrix(m_scaling([0.5, 1, 2]))
-			cube(10);
+	multmatrix(m_scaling([0.5, 1, 2]))
+		cube(10);
 
 ![m_scaling](images/lib3x-m_scaling-1.JPG)
 

docs/lib3x-m_shearing.md

@@ -1,7 +1,5 @@
 # m_shearing
 
-The dir changed since 2.0. 
-
 Generate a 4x4 transformation matrix which can pass into `multmatrix` to shear all child elements along the X-axis, Y-axis, or Z-axis in 3D.
 
 **Since:** 1.1
@@ -20,10 +18,12 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to shear a
 		multmatrix(m_shearing(sx = [1, 0]))
 			cube(1);
 			
-		translate([2, 0, 0]) multmatrix(m_shearing(sx = [0, 1]))
+		translate([2, 0, 0]) 
+		multmatrix(m_shearing(sx = [0, 1]))
 			cube(1);
 			
-		translate([4, 0, 0]) multmatrix(m_shearing(sx = [1, 1]))
+		translate([4, 0, 0]) 
+		multmatrix(m_shearing(sx = [1, 1]))
 			cube(1);
 	}
 
@@ -31,10 +31,12 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to shear a
 		multmatrix(m_shearing(sy = [1, 0]))
 			cube(1);
 			
-		translate([2, 0, 0]) multmatrix(m_shearing(sy = [0, 1]))
+		translate([2, 0, 0]) 
+		multmatrix(m_shearing(sy = [0, 1]))
 			cube(1);
 			
-		translate([4, 0, 0]) multmatrix(m_shearing(sy = [1, 1]))
+		translate([4, 0, 0]) 
+		multmatrix(m_shearing(sy = [1, 1]))
 			cube(1);
 	}
 
@@ -42,10 +44,12 @@ Generate a 4x4 transformation matrix which can pass into `multmatrix` to shear a
 		multmatrix(m_shearing(sz = [1, 0]))
 			cube(1);
 			
-		translate([2, 0, 0]) multmatrix(m_shearing(sz = [0, 1]))
+		translate([2, 0, 0]) 
+		multmatrix(m_shearing(sz = [0, 1]))
 			cube(1);
 			
-		translate([4, 0, 0]) multmatrix(m_shearing(sz = [1, 1]))
+		translate([4, 0, 0]) 
+		multmatrix(m_shearing(sz = [1, 1]))
 			cube(1);
 	}
 

docs/lib3x-m_translation.md

@@ -1,7 +1,5 @@
 # m_translation
 
-The dir changed since 2.0. 
-
 Generate a 4x4 transformation matrix which can pass into `multmatrix` to translates (moves) its child elements along the specified vector.
 
 **Since:** 1.1

docs/lib3x-m_transpose.md

@@ -0,0 +1,30 @@
+# m_transpose
+
+It transposes a matrix.
+
+**Since:** 3.1
+
+## Parameters
+
+- `m` : A matrix.
+
+## Examples
+
+    use <matrix/m_transpose.scad>;
+
+    original_m = [
+        [1, 2, 3, 4],
+        [5, 6, 7, 8],
+        [9, 10, 11, 12]
+    ];
+
+    traget = [
+        [1, 5, 9],
+        [2, 6, 10],
+        [3, 7, 11],
+        [4, 8, 12]
+    ];
+
+    transposed = m_transpose(original_m);
+
+    assert(transposed == traget);

docs/lib3x-midpt_smooth.md

@@ -12,14 +12,19 @@ Given a 2D path, this function constructs a mid-point smoothed version by joinin
 
 ## Examples
 
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
     use <shape_taiwan.scad>;
     use <midpt_smooth.scad>;
 
     taiwan = shape_taiwan(50);  
     smoothed = midpt_smooth(taiwan, 20, true);
 
-    translate([0, 0, 0]) hull_polyline2d(taiwan, .25); 
-    #translate([10, 0, 0]) hull_polyline2d(smoothed, .25);
+    translate([0, 0, 0]) 
+    polyline_join(taiwan) 
+        circle(.125); 
+
+    #translate([10, 0, 0]) 
+    polyline_join(smoothed) 
+        circle(.125);
 
 ![midpt_smooth](images/lib3x-midpt_smooth-1.JPG)

docs/lib3x-mz_hamiltonian.md

@@ -14,13 +14,14 @@ Creates a hamiltonian path from a maze. The path is the result of maze traversal
 ## Examples
     
     use <maze/mz_hamiltonian.scad>;
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
 
     rows = 5;
     columns = 10;
 
     path = mz_hamiltonian(rows, columns, [0, 0]);
-    hull_polyline2d(path, .5);
+    polyline_join(path)
+	    circle(.25);
 
 ![mz_hamiltonian](images/lib3x-mz_hamiltonian-1.JPG)
 

docs/lib3x-mz_hex_walls.md

@@ -17,7 +17,7 @@ It's a helper for creating wall data from maze cells. You can transform wall poi
     
 	use <maze/mz_square_cells.scad>;
 	use <maze/mz_hex_walls.scad>;
-	use <hull_polyline2d.scad>;
+	use <polyline_join.scad>;
 
 	rows = 10;
 	columns = 12;
@@ -28,7 +28,8 @@ It's a helper for creating wall data from maze cells. You can transform wall poi
 	walls = mz_hex_walls(cells, rows, columns, cell_width);
 
 	for(wall = walls) {
-		hull_polyline2d(wall, wall_thickness, $fn = 24);
+		polyline_join(wall) 
+		    circle(wall_thickness, $fn = 24);
 	}
 	
 ![mz_hex_walls](images/lib3x-mz_hex_walls-1.JPG)

docs/lib3x-mz_square_cells.md

@@ -41,11 +41,9 @@ The cell data is seperated from views. You can use cell data to construct [diffe
 	cells = mz_square_cells(rows, columns);
 
 	for(cell = cells) {
-		x = cell[0];
-		y = cell[1];
 		type = cell[2];
 		
-		translate([x, y] * cell_width) {
+		translate([cell.x, cell.y] * cell_width) {
 			if(type == TOP_WALL || type == TOP_RIGHT_WALL) {
 				line2d([0, cell_width], [cell_width, cell_width], wall_thickness);
 			}
@@ -56,8 +54,8 @@ The cell data is seperated from views. You can use cell data to construct [diffe
 		}
 	}
 
-	line2d([0, 0], [cell_width * rows, 0], wall_thickness);
-	line2d([0, 0], [0, cell_width * columns], wall_thickness);
+	line2d([0, 0], [cell_width * columns, 0], wall_thickness);
+	line2d([0, 0], [0, cell_width * rows], wall_thickness);
 
 ![mz_square_cells](images/lib3x-mz_square_cells-1.JPG)
 

docs/lib3x-mz_square_get.md

@@ -25,7 +25,7 @@ It's a helper for getting data from a square-maze cell.
 	for(cell = cells) {
 		x = mz_square_get(cell, "x");
 		y = mz_square_get(cell, "y");
-		type = mz_square_get(cell, "t");;
+		type = mz_square_get(cell, "t");
 		
 		translate([x, y] * cell_width) {
 			if(type == "TOP_WALL" || type == "TOP_RIGHT_WALL") {
@@ -38,7 +38,7 @@ It's a helper for getting data from a square-maze cell.
 		}
 	}
 
-	line2d([0, 0], [cell_width * rows, 0], wall_thickness);
-	line2d([0, 0], [0, cell_width * columns], wall_thickness);
+	line2d([0, 0], [cell_width * columns, 0], wall_thickness);
+	line2d([0, 0], [0, cell_width * rows], wall_thickness);
 
 ![mz_square_get](images/lib3x-mz_square_get-1.JPG)

docs/lib3x-mz_square_initialize.md

@@ -68,12 +68,10 @@ It's a helper for initializing cell data of a maze.
     // Mask
     mask_width = cell_width + wall_thickness;
     translate([-wall_thickness / 2, -wall_thickness / 2])
-    for(i = [0:rows - 1]) {
-        for(j = [0:columns - 1]) {
-                if(mask[i][j] == 0) {
-                    translate([cell_width * j, cell_width * (rows - i - 1)])
-                        square(mask_width);
-                }
+    for(i = [0:rows - 1], j = [0:columns - 1]) {
+        if(mask[i][j] == 0) {
+            translate([cell_width * j, cell_width * (rows - i - 1)])
+                square(mask_width);
         }
     }
 	

docs/lib3x-mz_theta_cells.md

@@ -25,7 +25,7 @@ The value of `type` is the wall type of the cell. It can be `0`, `1`, `2` or `3`
 ## Examples
     
 	use <maze/mz_theta_cells.scad>;
-	use <hull_polyline2d.scad>;
+	use <polyline_join.scad>;
 
 	rows = 8;
 	beginning_number = 8;
@@ -42,29 +42,29 @@ The value of `type` is the wall type of the cell. It can be `0`, `1`, `2` or `3`
 	maze = mz_theta_cells(rows, beginning_number);
 
 	// draw cell walls
-	for(rows = maze) {
-		for(cell = rows) {
-			ri = cell[0];
-			ci = cell[1];
-			type = cell[2];
-			thetaStep = 360 / len(maze[ri]);
-			innerR = (ri + 1) * cell_width;
-			outerR = (ri + 2) * cell_width;
-			theta1 = thetaStep * ci;
-			theta2 = thetaStep * (ci + 1);
-			
-			innerVt1 = vt_from_angle(theta1, innerR);
-			innerVt2 = vt_from_angle(theta2, innerR);
-			outerVt2 = vt_from_angle(theta2, outerR);
-			
-			if(type == INWARD_WALL || type == INWARD_CCW_WALL) {
-				hull_polyline2d([innerVt1, innerVt2], width = wall_thickness);
-			}
+	for(rows = maze, cell = rows) {		
+		ri = cell[0];
+		ci = cell[1];
+		type = cell[2];
+		thetaStep = 360 / len(maze[ri]);
+		innerR = (ri + 1) * cell_width;
+		outerR = (ri + 2) * cell_width;
+		theta1 = thetaStep * ci;
+		theta2 = thetaStep * (ci + 1);
+		
+		innerVt1 = vt_from_angle(theta1, innerR);
+		innerVt2 = vt_from_angle(theta2, innerR);
+		outerVt2 = vt_from_angle(theta2, outerR);
+		
+		if(type == INWARD_WALL || type == INWARD_CCW_WALL) {
+			polyline_join([innerVt1, innerVt2])
+				circle(wall_thickness / 2);
+		}
 
-			if(type == CCW_WALL || type == INWARD_CCW_WALL) {
-				hull_polyline2d([innerVt2, outerVt2], width = wall_thickness);
-			}
-		} 
+		if(type == CCW_WALL || type == INWARD_CCW_WALL) {
+			polyline_join([innerVt2, outerVt2])
+				circle(wall_thickness / 2);
+		}
 	}
 
     // outmost walls
@@ -73,7 +73,8 @@ The value of `type` is the wall type of the cell. It can be `0`, `1`, `2` or `3`
 	for(theta = [0:thetaStep:360 - thetaStep]) {
 		vt1 = vt_from_angle(theta, r);
 		vt2 = vt_from_angle(theta + thetaStep, r);
-		hull_polyline2d([vt1, vt2], width = wall_thickness);
+		polyline_join([vt1, vt2])
+			circle(wall_thickness / 2);
 	} 
 
 ![mz_theta_cells](images/lib3x-mz_theta_cells-3.JPG)

docs/lib3x-mz_theta_get.md

@@ -13,7 +13,7 @@ It's a helper for getting data from a theta-maze cell.
     
 	use <maze/mz_theta_cells.scad>;
 	use <maze/mz_theta_get.scad>;
-	use <hull_polyline2d.scad>;
+	use <polyline_join.scad>;
 
 	rows = 8;
 	beginning_number = 8;
@@ -23,29 +23,29 @@ It's a helper for getting data from a theta-maze cell.
 	function vt_from_angle(theta, r) = [r * cos(theta), r * sin(theta)];
 
 	maze = mz_theta_cells(rows, beginning_number);
-	for(rows = maze) {
-		for(cell = rows) {
-			ri = mz_theta_get(cell, "r");
-			ci = mz_theta_get(cell, "c");
-			type = mz_theta_get(cell, "t");
-			thetaStep = 360 / len(maze[ri]);
-			innerR = (ri + 1) * cell_width;
-			outerR = (ri + 2) * cell_width;
-			theta1 = thetaStep * ci;
-			theta2 = thetaStep * (ci + 1);
-			
-			innerVt1 = vt_from_angle(theta1, innerR);
-			innerVt2 = vt_from_angle(theta2, innerR);
-			outerVt2 = vt_from_angle(theta2, outerR);
-			
-			if(type == "INWARD_WALL" || type == "INWARD_CCW_WALL") {
-				hull_polyline2d([innerVt1, innerVt2], width = wall_thickness);
-			}
+	for(rows = maze, cell = rows) {
+		ri = mz_theta_get(cell, "r");
+		ci = mz_theta_get(cell, "c");
+		type = mz_theta_get(cell, "t");
+		thetaStep = 360 / len(maze[ri]);
+		innerR = (ri + 1) * cell_width;
+		outerR = (ri + 2) * cell_width;
+		theta1 = thetaStep * ci;
+		theta2 = thetaStep * (ci + 1);
+		
+		innerVt1 = vt_from_angle(theta1, innerR);
+		innerVt2 = vt_from_angle(theta2, innerR);
+		outerVt2 = vt_from_angle(theta2, outerR);
+		
+		if(type == "INWARD_WALL" || type == "INWARD_CCW_WALL") {
+			polyline_join([innerVt1, innerVt2])
+				circle(wall_thickness / 2);
+		}
 
-			if(type == "CCW_WALL" || type == "INWARD_CCW_WALL") {
-				hull_polyline2d([innerVt2, outerVt2], width = wall_thickness);
-			}
-		} 
+		if(type == "CCW_WALL" || type == "INWARD_CCW_WALL") {
+			polyline_join([innerVt2, outerVt2])
+				circle(wall_thickness / 2);
+		}
 	}
 
 	thetaStep = 360 / len(maze[rows - 1]);
@@ -53,7 +53,8 @@ It's a helper for getting data from a theta-maze cell.
 	for(theta = [0:thetaStep:360 - thetaStep]) {
 		vt1 = vt_from_angle(theta, r);
 		vt2 = vt_from_angle(theta + thetaStep, r);
-		hull_polyline2d([vt1, vt2], width = wall_thickness);
+		polyline_join([vt1, vt2])
+			circle(wall_thickness / 2);
 	} 
 
 ![mz_theta_get](images/lib3x-mz_theta_get-1.JPG)

docs/lib3x-nz_cell.md

@@ -26,9 +26,8 @@ It's an implementation of [Worley noise](https://en.wikipedia.org/wiki/Worley_no
 
     feature_points = [for(pt_angle = pts_angles) pt_angle[0] + half_size];
     noised = [
-        for(y = [0:size[1] - 1]) 
-            for(x = [0:size[0] - 1]) 
-                [x, y, nz_cell(feature_points, [x, y])]
+        for(y = [0:size.y - 1], x = [0:size.x - 1]) 
+        [x, y, nz_cell(feature_points, [x, y])]
     ];
 
     max_dist = max([for(n = noised) n[2]]);

docs/lib3x-nz_perlin1.md

@@ -11,13 +11,12 @@ Returns the 1D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
 
 ## Examples
 
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
     use <util/rand.scad>;
     use <noise/nz_perlin1.scad>;
 
-    seed = rand();
-    hull_polyline2d(
-        [for(x = [0:.1:10]) [x, nz_perlin1(x, seed)]], width = .1
-    );
+    seed = rand(0, 255);
+    polyline_join([for(x = [0:.1:10]) [x, nz_perlin1(x, seed)]])
+	    circle(.05);
 
 ![nz_perlin1](images/lib3x-nz_perlin1-1.JPG)

docs/lib3x-nz_perlin1s.md

@@ -11,13 +11,14 @@ Returns 1D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at
 
 ## Examples
 
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
     use <noise/nz_perlin1s.scad>;
 
     xs = [for(x = [0:.1:10]) x];
     ys = nz_perlin1s(xs);
     points = [for(i = [0:len(xs) - 1]) [xs[i], ys[i]]];
 
-    hull_polyline2d(points, width = .1);
+    polyline_join(points)
+	    circle(.05);
 
 ![nz_perlin1s](images/lib3x-nz_perlin1s-1.JPG)

docs/lib3x-nz_perlin2.md

@@ -13,8 +13,8 @@ Returns the 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
 ## Examples
 
     use <util/rand.scad>;
-    use <hull_polyline2d.scad>;
-    use <function_grapher.scad>;
+    use <polyline_join.scad>;
+    use <surface/sf_thicken.scad>;
     use <noise/nz_perlin2.scad>;
     use <contours.scad>;
 
@@ -27,11 +27,12 @@ Returns the 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
         ]
     ];
 
-    function_grapher(points, 1);
+    sf_thicken(points, .1);
 
     translate([11, 0])
     for(isoline = contours(points, 0)) {
-        hull_polyline2d(isoline, width = .1);
-    }  
+        polyline_join(isoline)
+		    circle(.05);
+    }   
 
 ![nz_perlin2](images/lib3x-nz_perlin2-1.JPG)

docs/lib3x-nz_perlin2s.md

@@ -12,10 +12,7 @@ Returns 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at
 ## Examples
 
     use <util/rand.scad>;
-    use <hull_polyline2d.scad>;
-    use <function_grapher.scad>;
     use <noise/nz_perlin2s.scad>;
-    use <contours.scad>;
 
     seed = rand(0, 255);
 

docs/lib3x-nz_perlin3.md

@@ -18,15 +18,13 @@ Returns the 3D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
 
     seed = rand(0, 255);
     noised = [
-        for(z = [0:.2:5])
-            for(y = [0:.2:5])
-                for(x = [0:.2:5])
-                    [x, y, z, nz_perlin3(x, y, z, seed)]
+        for(z = [0:.2:5], y = [0:.2:5], x = [0:.2:5])
+        [x, y, z, nz_perlin3(x, y, z, seed)]
     ];    
 
     for(nz = noised) {
         if(nz[3] > 0.2) {
-            translate([nz[0], nz[1], nz[2]])
+            translate([nz.x, nz.y, nz.z])
                 cube(.2);
         }
     }

docs/lib3x-nz_perlin3s.md

@@ -27,11 +27,11 @@ Returns 3D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at
 
     points_with_h = [
             for(ri = [0:len(points) - 1])
-                let(ns = nz_perlin2s(points[ri], seed))
-                    [
-                        for(ci = [0:len(ns) - 1])
-                            [points[ri][ci][0], points[ri][ci][1], ns[ci] + 1]
-                    ]
+            let(ns = nz_perlin2s(points[ri], seed))
+            [
+                for(ci = [0:len(ns) - 1])
+                    [points[ri][ci][0], points[ri][ci][1], ns[ci] + 1]
+            ]
         ];
 
     h_scale = 1.5;
@@ -39,7 +39,7 @@ Returns 3D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) values at
         for(i = [0:len(row) - 1]) {
             p = row[i];
             pts = [
-                for(z = [0:.2:p[2] * h_scale]) [p[0], p[1], z]
+                for(z = [0:.2:p[2] * h_scale]) [p.x, p.y, z]
             ];
             noise = nz_perlin3s(pts, seed);
             for(j = [0:len(pts) - 1]) {

docs/lib3x-nz_worley2.md

@@ -27,12 +27,11 @@ It divides the space into grids. The nucleus of each cell is randomly placed in
     seed = 51;
 
     points = [
-        for(y = [0:size[1] - 1]) 
-            for(x = [0:size[0] - 1]) 
-                [x, y]
+        for(y = [0:size.y - 1], x = [0:size.x - 1]) 
+        [x, y]
     ];
 
-    cells = [for(p = points) nz_worley2(p[0], p[1], seed, grid_w, dist)];
+    cells = [for(p = points) nz_worley2(p.x, p.y, seed, grid_w, dist)];
 
     max_dist = max([for(c = cells) c[2]]);
     for(i = [0:len(cells) - 1]) {
@@ -43,7 +42,7 @@ It divides the space into grids. The nucleus of each cell is randomly placed in
             square(1);
     }
 
-    cells_pts = dedup([for(c = cells) [c[0], c[1]]]);
+    cells_pts = dedup([for(c = cells) [c.x, c.y]]);
     for(p = cells_pts) {
         translate(p)
         linear_extrude(max_dist)

docs/lib3x-nz_worley2s.md

@@ -25,9 +25,8 @@ It divides the space into grids. The nucleus of each cell is randomly placed in
     seed = 51;
 
     points = [
-        for(y = [0:size[1] - 1]) 
-            for(x = [0:size[0] - 1]) 
-                [x, y]
+        for(y = [0:size.y - 1], x = [0:size.x - 1]) 
+        [x, y]
     ];
 
     cells = nz_worley2s(points, seed, grid_w, dist);