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,10 +1,8 @@
-# dotSCAD 3.1
+# dotSCAD 3.2.1
 
 > **Reduce the burden of mathematics/algorithm when playing OpenSCAD.**
 
-![dotSCAD](featured_img/TorusKnotMaze.JPG)
-
-[![license/LGPL](LICENSE.svg)](https://github.com/JustinSDK/lib-openscad/blob/master/LICENSE)
+![dotSCAD](featured_img/Owls.JPG)
 
 ## Introduction
 
@@ -12,7 +10,7 @@ Some of my [3D models](https://github.com/JustinSDK/dotSCAD#examples) require co
 
 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. 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.
 
@@ -39,111 +37,110 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 
 [![examples](examples/images/gallery.JPG)](examples#dogfooding-examples)
 
-# API Documentation
+# API Reference
 
 ## 2D Module
 
  Signature | Description
 --|--
-[**arc**(radius, angle, width = 1, width_mode = "LINE_CROSS")](https://openhome.cc/eGossip/OpenSCAD/lib3x-arc.html) | create an arc.
+[**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.
-[**hull_polyline2d**(points, width = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hull_polyline2d.html) | create a 2D polyline from a list of `[x, y]`.
-[**line2d**(p1, p2, width = 1, p1Style = "CAP_SQUARE", p2Style = "CAP_SQUARE")](https://openhome.cc/eGossip/OpenSCAD/lib3x-line2d.html) | create a line from two points. 
-[**multi_line_text**(lines, line_spacing = 15, size = 10, font = "Arial", ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-multi_line_text.html) | create multi-line text from a list of strings.
+[**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 = 1, startingStyle = "CAP_SQUARE", endingStyle = "CAP_SQUARE", ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline2d.html) | create a polyline from a list of `[x, y]` coordinates.
+[**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 = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_square.html) | create a rounded square in the first quadrant.
+[**rounded_square**(size, corner_r[, center])](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_square.html) | create a rounded square in the first quadrant.
 
 ## 3D Module
 
  Signature | Description
 --|--
-[**crystal_ball**(radius, theta = 360, phi = 180, thickness = undef)](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).
-[**hull_polyline3d**(points, diameter = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-hull_polyline3d.html) | create a 3D polyline from a list of `[x, y, z]`.
-[**line3d**(p1, p2, diameter = 1, p1Style = "CAP_CIRCLE", p2Style = "CAP_CIRCLE")](https://openhome.cc/eGossip/OpenSCAD/lib3x-line3d.html) | create a 3D line from two points.
-[**loft**(sections, slices = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-loft.html) | develop a smooth skin between crosssections with different geometries.
+[**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 = "CAP_CIRCLE", endingStyle = "CAP_CIRCLE")](https://openhome.cc/eGossip/OpenSCAD/lib3x-polyline3d.html) | create a polyline from a list of `[x, y, z]`.
-[**rounded_cube**(size, corner_r, center = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cube.html) | create a cube in the first octant.
-[**rounded_cylinder**(radius, h, round_r, convexity = 2, center = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_cylinder.html) | create a rounded cylinder.
-[**starburst**(r1, r2, n, height)](https://openhome.cc/eGossip/OpenSCAD/lib3x-starburst.html) | a 3D version of [`shape_starburst`](https://openhome.cc/eGossip/OpenSCAD/lib3x-starburst.html).
-[**sweep**(sections, triangles = "SOLID")](https://openhome.cc/eGossip/OpenSCAD/lib3x-sweep.html) | develop a smooth skin from crosssections with the same umber of sides.
+[**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.
 
 ## Transformation
 
  Signature | Description
 --|--
-[**along_with**(points, angles, twist = 0, scale = 1.0, method = "AXIS_ANGLE")](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 = 24)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend.html) | bend a 3D object.
+[**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 = [0, 0], sy = [0, 0], sz = [0, 0])](https://openhome.cc/eGossip/OpenSCAD/lib3x-shear.html) | shear all child elements along the X-axis, Y-axis, or Z-axis.
+[**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.
 
 ## 2D Function
 
  Signature | Description
 --|--
-[**bijection_offset**(pts, d, epsilon = 0.0001)](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.
+[**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 = false, epsilon = 0.0001)](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_shape.html) | check whether a point is inside a shape.
-[**trim_shape**(shape_pts, from, to, epsilon = 0.0001)](https://openhome.cc/eGossip/OpenSCAD/lib3x-trim_shape.html) | trim a tangled-edge shape to a non-tangled shape.
+[**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/3D Function
 
  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 = 0.1, closed = false, angle_threshold = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bezier_smooth.html) | use bazier curves to smooth a path.
-[**cross_sections**(shape_pts, path_pts, angles, twist = 0, scale = 1.0)](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 = 0.0001)](https://openhome.cc/eGossip/OpenSCAD/lib3x-in_polyline.html) | check whether a point is on a line.
-[**lines_intersection**(line1, line2, ext = false, epsilon = 0.0001)](https://openhome.cc/eGossip/OpenSCAD/lib3x-lines_intersection.html) | find the intersection of two line segments. Return `[]` if lines don't intersect.
-[**paths2sections**(paths)](https://openhome.cc/eGossip/OpenSCAD/lib3x-paths2sections.html) | given a list of paths, this function returns all cross-sections described by those paths.
+[**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 = false)](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.
+[**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.
 
 ## Path
 
  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 = "CT_CLK")](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 = "CT_CLK")](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.
+[**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 = 0)](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 = "CT_CLK")](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 = "CT_CLK")](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 = "SPI_DOWN", rt_dir = "CT_CLK")](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 = 1, begin_angle = 0, end_angle = 0, ...) ](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]]`. 
+[**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 = 24)](https://openhome.cc/eGossip/OpenSCAD/lib3x-bend_extrude.html) | extrude and bend a 2D shape.
-[**box_extrude**(height, shell_thickness, bottom_thickness, offset_mode = "delta", chamfer = false, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-box_extrude.html) | create a box (container) from a 2D object.
-[**ellipse_extrude**(semi_minor_axis, height, center = false, convexity = 10, twist = 0, slices = 20)](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 = 90, twist = 0, convexity = 10)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rounded_extrude.html) | extrude a 2D object roundly from 0 to 180 degrees.
+[**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 = "LINE_CROSS")](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_arc.html) | return points on the path of an arc shape.
+[**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 = 30, t_step = 0.1)](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 = 1.0, closed = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_path_extend.html) | extend a 2D stroke along a path to create a 2D shape.
+[**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 = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_square.html) | return shape points of a rounded square or rectangle. 
-[**shape_starburst**(r1, r2, n)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_starburst.html) | returns shape points of a star. 
-[**shape_superformula**(phi_step, m1, m2, n1, n2 = 1, n3 = 1, a = 1, b = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_superformula.html) | return shape points of [Superformula](https://en.wikipedia.org/wiki/Superformula).
-[**shape_taiwan**(h, distance = 0)](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 = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shape_trapezium.html) | return shape points of an isosceles trapezoid. 
+[**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
 
@@ -153,7 +150,7 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 [**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.
+[**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
@@ -163,13 +160,13 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
  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 = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-has.html) | return `true` if `lt` contains elem.
+[**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 = 1)](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/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", idx = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sort.html) | sort a list.
+[**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.
@@ -181,8 +178,8 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
  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 = 0, max_value = 1, seed_value = undef)](https://openhome.cc/eGossip/OpenSCAD/lib3x-rand.html) | generate a pseudo random number.
-[**util/shuffle**(lt, seed = undef)](https://openhome.cc/eGossip/OpenSCAD/lib3x-shuffle.html) | randomizes the order of the elements.
+[**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
 
@@ -235,7 +232,7 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 [**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 = [0, 0], sy = [0, 0], sz = [0, 0])](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_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.
 
@@ -245,10 +242,10 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 --|--
 [**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 = 360, twist = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_ring.html) | transform a point inside a rectangle to a point of a ring. 
+[**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 = [180, 360])](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 = [360, 360], twist = 0)](https://openhome.cc/eGossip/OpenSCAD/lib3x-ptf_torus.html) | transform a point inside a rectangle to a point of a torus.
+[**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.
 
@@ -258,8 +255,8 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 --|--
 [**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_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.
@@ -270,10 +267,10 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 
  Signature | Description
 --|--
-[**turtle/footprints2**(cmds, start = [0, 0])](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 = [0, 0, 0])](https://openhome.cc/eGossip/OpenSCAD/lib3x-footprints3.html) | a 3D verion of `footprint2`.
-[**turtle/lsystem2**(axiom, rules, n, angle, leng = 1, heading = 0, ...)](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 = 1, heading = 0, ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-lsystem3.html) | 3D implementation of [L-system](https://en.wikipedia.org/wiki/L-system).
+[**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`.
 
@@ -281,40 +278,40 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 
  Signature | Description
 --|--
-[**voxel/vx_ascii**(char, center = false, invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_ascii.html) | generate 8x8 voxel points of printable ASCII characters (codes 32dec to 126dec).
+[**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 = false)](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 = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_contour.html) | return the contour which encircles the area.
-[**voxel/vx_curve**(points, tightness = 0)](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 = false, thickness = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_cylinder.html) | return points that can be used to draw a voxel-style cylinder.
+[**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 = false, invert = false)](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 = false, invert = false, normalize = false)](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_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 = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_polygon.html) | return points that can be used to draw a voxel-style polygon.
+[**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 = false, thickness = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vx_sphere.html) | return points that can be used to draw a voxel-style sphere.
+[**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.
 
 ## Part
 
  Signature | Description
 --|--
-[**part/cone**(radius, length = 0, spacing = 0.5, angle = 50, void = false, ends = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-cone.html) | create a cone for rotatable models.
-[**part/connector_peg**(radius, height, spacing = 0.5, void = false, ends = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-connector_peg.html) | create a connector peg.
-[**part/joint_T**(shaft_r, shaft_h, t_leng, thickness, spacing = 0.5, center = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-joint_T.html) | create a joint_T for rotatable models.
+[**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.
 
 ## Surface
 
  Signature | Description
 --|--
-[**surface/sf_bend**(levels, radius, thickness, depth, angle = 180, invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_bend.html) | bend a photo.
-[**surface/sf_ring**(levels, radius, thickness, depth, angle = 360, twist = 0, invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_ring.html) | turn a photo into a ring.
-[**surface/sf_solidify**(surface1, surface2, slicing = "SLASH")](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_solidify.html) | solidify two square surfaces.
-[**surface/sf_sphere**(levels, radius, thickness, depth, angle = [180, 360], invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_sphere.html) | map a photo onto a sphere.
-[**surface/sf_square**(levels, thickness, depth, x_twist = 0, y_twist = 0, invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_square.html) | turn a photo into a twistable square.
-[**surface/sf_torus**(levels, radius, thickness, depth, angle = [360, 360], twist = 0, invert = false)](https://openhome.cc/eGossip/OpenSCAD/lib3x-sf_torus.html) | turn a photo to a torus.
+[**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.
@@ -325,38 +322,54 @@ These examples incubate dotSCAD and dotSCAD refactors these examples. See [examp
 
  Signature | Description
 --|--
-[**noise/nz_cell**(points, p, dist = "euclidean")](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 = undef)](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 = undef)](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 = undef)](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 = undef)](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 = undef)](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 = undef)](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 = undef, grid_w = 10, dist = "euclidean")](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 = undef, grid_w = 10, dist = "euclidean")](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 = undef, tile_w = 10, dist = "euclidean")](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 = undef, tile_w = 10, dist = "euclidean")](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.
+[**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 = undef)](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 = 1, ...)](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 = undef, spacing = 1, ...)](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 = 1)](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 = undef, spacing = 1)](https://openhome.cc/eGossip/OpenSCAD/lib3x-vrn3_space.html) | create a [Voronoi](https://en.wikipedia.org/wiki/Voronoi_diagram) in the first octant. 
+[**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 = [0, 0], ...)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_square_cells.html) | return cell data of a square maze.
+[**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 = [0, 0], seed = undef)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_hamiltonian.html) | create a hamiltonian path from a maze.
-[**maze/mz_theta_cells**(rows, beginning_number, start = [0, 0], seed = undef)](https://openhome.cc/eGossip/OpenSCAD/lib3x-mz_theta_cells.html) | return cell data of a theta 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.
+
+----
+

RELEASE.md

@@ -1,5 +1,60 @@
 > 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:

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-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,7 +11,7 @@ Computes contour polygons by applying [marching squares](https://en.wikipedia.or
 
 ## Examples
 
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
 	use <surface/sf_thicken.scad>;
     use <contours.scad>;
 
@@ -23,10 +23,10 @@ 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)]
+        ]
     ];
 
     sf_thicken(points, 1);
@@ -36,7 +36,8 @@ Computes contour polygons by applying [marching squares](https://en.wikipedia.or
         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-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

@@ -7,7 +7,7 @@ This function gets the value of the specified key from a [util/map/hashmap](http
 ## 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_put.md

@@ -7,6 +7,10 @@ Puts a key/value pair to a [util/map/hashmap](https://openhome.cc/eGossip/OpenSC
 ## 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

@@ -20,10 +20,10 @@ Checks whether 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 whether 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-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

@@ -16,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

@@ -19,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)
@@ -32,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

@@ -14,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

@@ -18,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);
 	}
 
@@ -29,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);
 	}
 
@@ -40,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-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,7 +13,7 @@ Returns the 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
 ## Examples
 
     use <util/rand.scad>;
-    use <hull_polyline2d.scad>;
+    use <polyline_join.scad>;
     use <surface/sf_thicken.scad>;
     use <noise/nz_perlin2.scad>;
     use <contours.scad>;
@@ -31,7 +31,8 @@ Returns the 2D [Perlin noise](https://en.wikipedia.org/wiki/Perlin_noise) value
 
     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_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);

docs/lib3x-nz_worley3.md

@@ -26,7 +26,7 @@ It divides the space into grids. The nucleus of each cell is randomly placed in
 
     points = vx_sphere(20);
 
-    cells = [for(p = points) nz_worley3(p[0], p[1], p[2], seed, grid_w, dist)];
+    cells = [for(p = points) nz_worley3(p.x, p.y, p.z, seed, grid_w, dist)];
 
     max_dist = max([for(c = cells) c[3]]);
     for(i = [0:len(cells) - 1]) {

docs/lib3x-nz_worley3s.md

@@ -18,15 +18,15 @@ It divides the space into grids. The nucleus of each cell is randomly placed in
     use <voxel/vx_sphere.scad>;
     use <noise/nz_worley3s.scad>;
 
-    tile_w = 10;
+    grid_w = 10;
     dist = "euclidean"; // [euclidean, manhattan, chebyshev, border] 
     seed = 51;
 
     points = vx_sphere(20);
-    cells = nz_worley3s(points, seed, tile_w, dist);
+    cells = nz_worley3s(points, seed, grid_w, dist);
 
     for(i = [0:len(cells) - 1]) {
-        c = (norm([cells[i][0], cells[i][1], cells[i][2]]) % 20) / 20;
+        c = (norm([cells[i].x, cells[i].y, cells[i].z]) % 20) / 20;
         color([c, c, c])
         translate(points[i])
             cube(1);

docs/lib3x-path_extrude.md

@@ -255,29 +255,31 @@ So, which is the correct method? Both methods are correct when you provide only
 	shape_pentagram_pts = shape_pentagram(star_radius);
 
 	// not closed perfectly
-	translate([-8, 0, 0]) path_extrude(
-		shape_pentagram_pts, 
-		concat(pts, [pts[0]]), 
-		closed = true,
-		method = "AXIS_ANGLE"
-	);
+	translate([-8, 0, 0]) 
+		path_extrude(
+			shape_pentagram_pts, 
+			[each pts, pts[0]], 
+			closed = true,
+			method = "AXIS_ANGLE"
+		);
 
 	// adjust it 
 	path_extrude(
 		shape_pentagram_pts, 
-		concat(pts, [pts[0]]), 
+		[each pts, pts[0]], 
 		closed = true,
 		twist = 188,
 		method = "AXIS_ANGLE"
 	);
 
 	// "EULER_ANGLE" is easy in this situation
-	translate([0, 8, 0]) path_extrude(
-		shape_pentagram_pts, 
-		concat(pts, [pts[0]]), 
-		closed = true,
-		method = "EULER_ANGLE"
-	);
+	translate([0, 8, 0]) 
+		path_extrude(
+			shape_pentagram_pts, 
+			[each pts, pts[0]], 
+			closed = true,
+			method = "EULER_ANGLE"
+		);
 
 ![path_extrude](images/lib3x-path_extrude-9.JPG)	
 

docs/lib3x-path_scaling_sections.md

@@ -15,7 +15,7 @@ You can use any point as the first point of the edge path. Just remember that yo
 
 ## Examples
 
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <shape_taiwan.scad>;
 	use <path_scaling_sections.scad>;
 	use <sweep.scad>;
@@ -33,18 +33,18 @@ You can use any point as the first point of the edge path. Just remember that yo
 		fst_pt + [0, 0, 60]
 	];
 
-	#hull_polyline3d(edge_path);
+	#polyline_join(edge_path) 
+	    sphere(.5);
 	sweep(path_scaling_sections(taiwan, edge_path));
 
 ![path_scaling_sections](images/lib3x-path_scaling_sections-1.JPG)
 
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <shape_taiwan.scad>;
 	use <path_scaling_sections.scad>;
 	use <sweep.scad>;
 	use <bezier_curve.scad>;
 
-
 	taiwan = shape_taiwan(100);
 	fst_pt = [13, 0, 0];
 
@@ -58,7 +58,8 @@ You can use any point as the first point of the edge path. Just remember that yo
 		fst_pt + [0, 0, 60]
 	]);
 
-	#hull_polyline3d(edge_path);
+	#polyline_join(edge_path) 
+	    sphere(.5);
 	sweep(path_scaling_sections(taiwan, edge_path));
 
 ![path_scaling_sections](images/lib3x-path_scaling_sections-2.JPG)
@@ -67,7 +68,7 @@ You can use any point as the first point of the edge path. Just remember that yo
 	use <path_scaling_sections.scad>;
 	use <sweep.scad>;
 	use <bezier_curve.scad>;
-	use <rotate_p.scad>;
+	use <ptf/ptf_rotate.scad>;
 
 	taiwan = shape_taiwan(100);
 	fst_pt = [13, 0, 0];
@@ -91,7 +92,7 @@ You can use any point as the first point of the edge path. Just remember that yo
 		for(i = [0:leng - 1]) 
 		[
 			for(p = sections[i]) 
-				rotate_p(p, twist_step * i)        
+				ptf_rotate(p, twist_step * i)        
 		]
 	];
 
@@ -99,11 +100,11 @@ You can use any point as the first point of the edge path. Just remember that yo
 
 ![path_scaling_sections](images/lib3x-path_scaling_sections-3.JPG)	
 
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <shape_taiwan.scad>;
 	use <path_scaling_sections.scad>;
 	use <sweep.scad>;
-    use <rotate_p.scad>;
+    use <ptf/ptf_rotate.scad>;
 
 	taiwan = shape_taiwan(100);
 
@@ -115,15 +116,16 @@ You can use any point as the first point of the edge path. Just remember that yo
     a = atan2(fst_pt[1], fst_pt[0]);
 	edge_path = [
 		fst_pt,
-		fst_pt + rotate_p([0, 0, 10], a),
-		fst_pt + rotate_p([10, 0, 20], a),
-		fst_pt + rotate_p([8, 0, 30], a),
-		fst_pt + rotate_p([10, 0, 40], a),
-		fst_pt + rotate_p([0, 0, 50], a),
-		fst_pt + rotate_p([0, 0, 60], a)
+		fst_pt + ptf_rotate([0, 0, 10], a),
+		fst_pt + ptf_rotate([10, 0, 20], a),
+		fst_pt + ptf_rotate([8, 0, 30], a),
+		fst_pt + ptf_rotate([10, 0, 40], a),
+		fst_pt + ptf_rotate([0, 0, 50], a),
+		fst_pt + ptf_rotate([0, 0, 60], a)
 	];
 
-	#hull_polyline3d(edge_path);
+	#polyline_join(edge_path) 
+	    sphere(.5);
 	sweep(path_scaling_sections(taiwan, edge_path));
 
 ![path_scaling_sections](images/lib3x-path_scaling_sections-4.JPG)

docs/lib3x-paths2sections.md

@@ -11,7 +11,7 @@ You paths should be indexed count-clockwisely.
 ## Examples
 
 	use <paths2sections.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <sweep.scad>;
 	
 	paths = [
@@ -26,14 +26,15 @@ You paths should be indexed count-clockwisely.
 	sweep(sections);
 	
 	#for(path = paths) {
-	    hull_polyline3d(path, 0.5);
+	    polyline_join(path)
+		    sphere(.25);
 	}
 
 ![paths2sections](images/lib3x-paths2sections-1.JPG)
 
 	use <bezier_curve.scad>;
 	use <paths2sections.scad>;
-	use <hull_polyline3d.scad>;
+	use <polyline_join.scad>;
 	use <sweep.scad>;
 	
 	t_step = 0.05;
@@ -59,7 +60,8 @@ You paths should be indexed count-clockwisely.
 	sweep(sections);
 	
 	#for(path = paths) {
-	    hull_polyline3d(path, 0.5);
+	    polyline_join(path)
+		    sphere(.25);
 	}
 
 ![paths2sections](images/lib3x-paths2sections-2.JPG)

docs/lib3x-pie.md

@@ -13,8 +13,10 @@ Creates a pie (circular sector). Its `$fa`, `$fs` and `$fn` are consistent with
     use <pie.scad>;
 
     pie(radius = 20, angle = [210, 310]);   
-    translate([-15, 0, 0]) pie(radius = 20, angle = [45, 135]);  
-    translate([15, 0, 0]) pie(radius = 20, angle = [45, 135], $fn = 12);  
+    translate([-15, 0, 0]) 
+        pie(radius = 20, angle = [45, 135]);  
+    translate([15, 0, 0]) 
+        pie(radius = 20, angle = [45, 135], $fn = 12);  
 
 ![pie](images/lib3x-pie-1.JPG)
 

docs/lib3x-polyhedra_dodecahedron.md

@@ -0,0 +1,22 @@
+# dodecahedron
+
+Creates a dodecahedron.
+
+**Since:** 3.2
+
+## Parameters
+
+- `radius` : Radius of the dodecahedron.
+- `detail` : Default to 0. Setting this to a value greater than 0 adds vertices making it no longer a dodecahedron.
+
+## Examples
+
+	use <polyhedra/dodecahedron.scad>;
+
+	for(i = [0:5]) {
+		translate([i * 2, 0])
+			dodecahedron(radius = 1, detail = i);
+	}
+
+![dodecahedron](images/lib3x-polyhedra_dodecahedron-1.JPG)
+

docs/lib3x-polyhedra_hexahedron.md

@@ -0,0 +1,22 @@
+# hexahedron
+
+Creates a hexahedron.
+
+**Since:** 3.2
+
+## Parameters
+
+- `radius` : Radius of the hexahedron.
+- `detail` : Default to 0. Setting this to a value greater than 0 adds vertices making it no longer a hexahedron.
+
+## Examples
+
+	use <polyhedra/hexahedron.scad>;
+
+	for(i = [0:5]) {
+		translate([i * 2, 0])
+			hexahedron(radius = 1, detail = i);
+	}
+
+![hexahedron](images/lib3x-polyhedra_hexahedron-1.JPG)
+

docs/lib3x-polyhedra_icosahedron.md

@@ -0,0 +1,22 @@
+# icosahedron
+
+Creates a icosahedron.
+
+**Since:** 3.2
+
+## Parameters
+
+- `radius` : Radius of the icosahedron.
+- `detail` : Default to 0. Setting this to a value greater than 0 adds vertices making it no longer a icosahedron.
+
+## Examples
+
+	use <polyhedra/icosahedron.scad>;
+
+	for(i = [0:5]) {
+		translate([i * 2, 0])
+			icosahedron(radius = 1, detail = i);
+	}
+
+![icosahedron](images/lib3x-polyhedra_icosahedron-1.JPG)
+

docs/lib3x-polyhedra_octahedron.md

@@ -0,0 +1,22 @@
+# octahedron
+
+Creates a octahedron.
+
+**Since:** 3.2
+
+## Parameters
+
+- `radius` : Radius of the octahedron.
+- `detail` : Default to 0. Setting this to a value greater than 0 adds vertices making it no longer a octahedron.
+
+## Examples
+
+	use <polyhedra/octahedron.scad>;
+
+	for(i = [0:5]) {
+		translate([i * 2, 0])
+			octahedron(radius = 1, detail = i);
+	}
+
+![octahedron](images/lib3x-polyhedra_octahedron-1.JPG)
+

docs/lib3x-polyhedra_polar_zonohedra.md

@@ -0,0 +1,22 @@
+# polar_zonohedra
+
+Creates a [polar zonohedra](https://mathworld.wolfram.com/PolarZonohedron.html).
+
+**Since:** 3.2
+
+## Parameters
+
+- `n` : n equal rhombs surrounding one vertex. (rotational symmetry)
+- `theta` : the pitch angle of the edges. Default to 35.5.
+
+## Examples
+
+	use <polyhedra/polar_zonohedra.scad>;
+
+	for(n = [3:8]) {
+		translate([0.5 * n * (n - 3), 0, 0])
+			polar_zonohedra(n);
+	}
+
+![polar_zonohedra](images/lib3x-polyhedra_polar_zonohedra-1.JPG)
+

docs/lib3x-polyhedra_star.md

@@ -0,0 +1,24 @@
+# star
+
+Create a star. Default to a pentagram.
+
+**Since:** 3.2
+
+## Parameters
+
+- `outer_radius`: The outer radius of the star. Default to 1.
+- `inner_radius`: The inner radius of the star. Default to 0.381966.
+- `height`: The star height. Default to 0.5.
+- `n`: The burst number. Default to 5.
+
+## Examples
+
+	use <polyhedra/star.scad>;
+
+	for(i = [3:6]) {
+		translate([(i - 3) * 2, 0])
+			star(n = i);
+	}
+
+![star](images/lib3x-polyhedra_star-1.JPG)
+

docs/lib3x-polyhedra_superellipsoid.md

@@ -0,0 +1,26 @@
+# superellipsoid
+
+Creates a [superellipsoid](https://en.wikipedia.org/wiki/Superellipsoid).
+
+**Since:** 3.2
+
+## Parameters
+
+- `e` :  The east-west parameter.
+- `n` : The north-south parameter.
+
+## Examples
+
+	use <polyhedra/superellipsoid.scad>;
+
+	$fn = 24;
+
+	step = 0.5;
+
+	for(e = [0:step:4], n = [0:step:4]) {
+		translate([e / step, n / step] * 3)
+			superellipsoid(e, n);
+	}
+
+![superellipsoid](images/lib3x-polyhedra_superellipsoid-1.JPG)
+

docs/lib3x-polyhedra_tetrahedron.md

@@ -0,0 +1,22 @@
+# tetrahedron
+
+Creates a tetrahedron.
+
+**Since:** 3.2
+
+## Parameters
+
+- `radius` : Radius of the tetrahedron.
+- `detail` : Default to 0. Setting this to a value greater than 0 adds vertices making it no longer a tetrahedron.
+
+## Examples
+
+	use <polyhedra/tetrahedron.scad>;
+
+	for(i = [0:5]) {
+		translate([i * 2, 0])
+			tetrahedron(radius = 1, detail = i);
+	}
+
+![tetrahedron](images/lib3x-polyhedra_tetrahedron-1.JPG)
+

docs/lib3x-polyline2d.md

@@ -23,16 +23,23 @@ Creates a polyline from a list of `[x, y]` coordinates. When the end points are
     use <polyline2d.scad>;
     
     $fn = 24;
-    polyline2d(points = [[1, 2], [-5, -4], [-5, 3], [5, 5]], width = 1,
-               endingStyle = "CAP_ROUND");
+    polyline2d(
+        points = [[1, 2], [-5, -4], [-5, 3], [5, 5]], 
+        width = 1,
+        endingStyle = "CAP_ROUND"
+    );
 
 ![polyline2d](images/lib3x-polyline2d-2.JPG)
 
     use <polyline2d.scad>;
     
     $fn = 24;
-	polyline2d(points = [[1, 2], [-5, -4], [-5, 3], [5, 5]], width = 1,
-               startingStyle = "CAP_ROUND", endingStyle = "CAP_ROUND");
+	polyline2d(
+        points = [[1, 2], [-5, -4], [-5, 3], [5, 5]], 
+        width = 1,
+        startingStyle = "CAP_ROUND", 
+        endingStyle = "CAP_ROUND"
+    );
 
 ![polyline2d](images/lib3x-polyline2d-3.JPG)
 

docs/lib3x-polyline_join.md

@@ -0,0 +1,42 @@
+# polyline_join
+
+Place a join on each point. Hull each pair of joins and union all convex hulls.
+
+**Since:** 3.2
+
+## Parameters
+
+- `points` : a list of points.
+
+## Examples
+  
+    use <polyline_join.scad>;
+    
+    polyline_join([[0, 0], [10, 0], [10, 10], [0, 10]]) 
+        square(1);
+        
+    polyline_join([[15, 0], [25, 0], [25, 10], [15, 10]]) {
+        square(1);
+        circle(1);
+        square(1);
+        circle(2);
+    }
+
+![polyline_join](images/lib3x-polyline_join-1.JPG)
+
+    use <polyline_join.scad>;
+        
+    polyline_join([[0, 0, 0], [10, 0, 0], [10, 0, 10], [10, 10, 10]]) 
+        cube(1);
+        
+    polyline_join([[15, 0, 0], [25, 0, 0], [25, 0, 10], [25, 10, 10]]) {
+        cube(1);
+        sphere(1);
+        cube(1);
+        sphere(2);
+    }
+
+![polyline_join](images/lib3x-polyline_join-2.JPG)
+
+
+

docs/lib3x-polysections.md

@@ -1,141 +0,0 @@
-# polysections
-
-Crosscutting a tube-like shape at different points gets several cross-sections. This module can operate reversely. It uses cross-sections to construct a tube-like shape. For example, imagine that you have the following cross-sections:
-
-![polysections](images/lib3x-polysections-1.JPG)
-
-This module can use them to construct the following model:
-
-![polysections](images/lib3x-polysections-2.JPG)
-
-Looks like extruding along the path? Yes, it can perform the task; however, it's more flexible. 
-
-You can also view it as a better polyline3d module if you want. If you have only the points of a path, using `polyline3d` or `hull_polyline3d` is a simple solution. If you know the cross sections along a path, you can use `polysections` to do more. 
-
-When using this module, you should use points to represent each cross section. The points of your cross section should have count-clockwise indexes. For example:
-
-![polysections](images/lib3x-polysections-10.JPG)
-
-If your cross section is hollow, set the `triangles` parameter to `"HOLLOW"` and index the points as the following:
-
-![polysections](images/lib3x-polysections-5.JPG)
-
-You can cut triangles by yourself. For example, the above shape can be cut into triangles such as:
-
-![polysections](images/lib3x-polysections-6.JPG)
-
-The indexes of the above triangles is:
-
-    [
-		[0, 3, 1],
-		[1, 3, 4],
-		[1, 4, 2],
-		[2, 4, 5],
-		[2, 5, 0],
-		[0, 5, 3]
-	]
-
-When defining triangles, you can use clockwise or counter-clockwise indexes. 
-
-## Parameters
-
-- `sections` : A list of cross-sections. Each cross-section is represented by a list of points. See the example below.
-- `triangles` : `"SOLID"` (default), `"HOLLOW"`,  or user-defined indexes. See example below.
-
-## Examples
-
-	use <rotate_p.scad>;
-	use <polysections.scad>;
-
-	section1 = [
-		[20, 0, 0],
-		[18, 9, 0],
-		[15, 10, 0],
-		[10, 0, 0]
-	];
-
-	// spin section1
-	sections = [
-		for(i = [0:55]) 
-			[
-				for(p = section1)
-					let(pt = rotate_p(p, [90, 0, 10 * i]))
-					[pt[0], pt[1] , pt[2] + i]
-			]
-	];
-
-	polysections(sections);
-
-![polysections](images/lib3x-polysections-7.JPG)
-
-	use <rotate_p.scad>;
-	use <polysections.scad>;
-	
-	section1 = [
-	    // outer
-		[20, 0, 0],
-		[18, 9, 0],
-		[15, 10, 0],
-		[10, 0, 0],
-	    // inner
-        [18, 2, 0],
-        [17, 7, 0],
-        [15, 7, 0],
-	    [12, 2, 0]
-	];
-	
-	// spin section1
-	sections = [
-	    for(i = [0:55]) 
-	        [
-	            for(p = section1)
-	                let(pt = rotate_p(p, [90, 0, 10 * i]))
-	                [pt[0], pt[1] , pt[2] + i]
-	        ]
-	];
-	    
-	polysections(sections, "HOLLOW");
-
-![polysections](images/lib3x-polysections-8.JPG)
-
-	use <rotate_p.scad>;
-	use <polysections.scad>;
-	
-	section1 = [
-	    // outer
-        [30, 0, 0],
-	    [15, 10, 0],
-	    [10, 0, 0],
-	    // inner
-	    [26, 1, 0],
-	    [15, 8, 0],
-	    [12, 1, 0],        
-	];
-	
-	// spin section1
-	sections = [
-	    for(i = [0:55]) 
-	        [
-	            for(p = section1)
-	                let(pt = rotate_p(p, [90, 0, 10 * i]))
-	                [pt[0], pt[1] , pt[2] + i]
-	        ]
-	];
-	    
-	polysections(
-	   sections = sections, 
-	   triangles = [
-            [0, 3, 1],
-            [1, 3, 4],
-            [1, 4, 2],
-            [2, 4, 5],
-            [2, 5, 0],
-            [0, 5, 3]
-        ]
-	);
-
-![polysections](images/lib3x-polysections-9.JPG)
-
-
-
-

docs/lib3x-ptf_bend.md

@@ -21,12 +21,10 @@ Transforms a point inside a rectangle to a point of an arc.
     radius = 20;
     angle = 180;
 
-    for(i = [0:len(t) - 1]) {
-        for(pt = vx_ascii(t[i], invert = true)) {
-            bended = ptf_bend(size, pt + [i * 8, 0], radius, angle);
-            translate(bended)
-                sphere(0.5, $fn = 24);
-        }
+    for(i = [0:len(t) - 1], pt = vx_ascii(t[i], invert = true)) {
+        bended = ptf_bend(size, pt + [i * 8, 0], radius, angle);
+        translate(bended)
+            sphere(0.5, $fn = 24);
     }
 
 ![ptf_bend](images/lib3x-ptf_bend-1.JPG)

docs/lib3x-ptf_circle.md

@@ -13,29 +13,31 @@ Transform a point inside a rectangle to a point inside a circle. You can use it
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_circle.scad>;
 
     size = [10, 10];
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         transformed = [for(p = line) ptf_circle(size, p)];
-        hull_polyline3d(transformed, thickness = .1);
+        polyline_join(transformed)
+		    sphere(.05);
     }
 
     for(line = columns) {
         transformed = [for(p = line) ptf_circle(size, p)];
-        hull_polyline3d(transformed, thickness = .1);
+        polyline_join(transformed)
+		    sphere(.05);
     }
 
 ![ptf_circle](images/lib3x-ptf_circle-2.JPG)

docs/lib3x-ptf_ring.md

@@ -16,30 +16,32 @@ Transforms a point inside a rectangle to a point of a ring. It can create things
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_ring.scad>;
 
     size = [20, 10];
     radius = 5;
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         transformed = [for(p = line) ptf_ring(size, p, radius, 360, 180)];
-        hull_polyline3d(transformed, thickness = .5);
+		polyline_join(transformed)
+		    sphere(.25);
     }
 
     for(line = columns) {
         transformed = [for(p = line) ptf_ring(size, p, radius, 360, 180)];
-        hull_polyline3d(transformed, thickness = .5);
+		polyline_join(transformed)
+		    sphere(.25);
     }
 
 ![ptf_ring](images/lib3x-ptf_ring-2.JPG)

docs/lib3x-ptf_rotate.md

@@ -22,11 +22,11 @@ Rotates a point `a` degrees around the axis of the coordinate system or an arbit
 	hull() {
 	    sphere(1);
 	    translate(ptf_rotate(point, a))    
-	       rotate(a)  
-	           sphere(1);   
+		rotate(a)  
+			sphere(1);   
 	}  
 
-![ptf_rotate](images/lib3x-rotate_p-1.JPG)
+![ptf_rotate](images/lib3x-ptf_rotate-1.JPG)
 
     use <ptf/ptf_rotate.scad>;
 
@@ -48,7 +48,7 @@ Rotates a point `a` degrees around the axis of the coordinate system or an arbit
 	
 	%sphere(radius);
 
-![ptf_rotate](images/lib3x-rotate_p-2.JPG)
+![ptf_rotate](images/lib3x-ptf_rotate-2.JPG)
 
 	use <ptf/ptf_rotate.scad>;
 
@@ -57,7 +57,7 @@ Rotates a point `a` degrees around the axis of the coordinate system or an arbit
 	hull() {
 		sphere(1);
 		translate(v)
-		sphere(1);   
+		    sphere(1);   
 	}
 
 	p = [10, 10, 0];
@@ -66,4 +66,4 @@ Rotates a point `a` degrees around the axis of the coordinate system or an arbit
 			sphere(1);  
 	}
 	
-![ptf_rotate](images/lib3x-rotate_p-3.JPG)
+![ptf_rotate](images/lib3x-ptf_rotate-3.JPG)

docs/lib3x-ptf_sphere.md

@@ -15,7 +15,7 @@ Transforms a point inside a rectangle to a point of a sphere. It can create thin
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_sphere.scad>;
 
     size = [20, 10];
@@ -23,23 +23,25 @@ Transforms a point inside a rectangle to a point of a sphere. It can create thin
     angle = [180, 270];
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         transformed = [for(p = line) ptf_sphere(size, p, radius, angle)];
-        hull_polyline3d(transformed, thickness = .5);
+        polyline_join(transformed)
+            sphere(.25);
     }
 
     for(line = columns) {
         transformed = [for(p = line) ptf_sphere(size, p, radius, angle)];
-        hull_polyline3d(transformed, thickness = .5);
+        polyline_join(transformed)
+            sphere(.25);
     }
 
 ![ptf_sphere](images/lib3x-ptf_sphere-2.JPG)

docs/lib3x-ptf_torus.md

@@ -16,7 +16,7 @@ Transforms a point inside a rectangle to a point of a torus. It can create thing
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_torus.scad>;
 
     size = [20, 10];
@@ -25,23 +25,25 @@ Transforms a point inside a rectangle to a point of a torus. It can create thing
     twist = 90;
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         transformed = [for(p = line) ptf_torus(size, p, radius, angle, twist)];
-        hull_polyline3d(transformed, thickness = .5);
+        polyline_join(transformed)
+		    sphere(.25);
     }
 
     for(line = columns) {
         transformed = [for(p = line) ptf_torus(size, p, radius, angle, twist)];
-        hull_polyline3d(transformed, thickness = .5);
+        polyline_join(transformed)
+		    sphere(.25);
     }
 
 ![ptf_torus](images/lib3x-ptf_torus-2.JPG)

docs/lib3x-ptf_x_twist.md

@@ -14,29 +14,31 @@ Twist a point along the x-axis. You can use it to create something such as a [tw
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_x_twist.scad>;
 
     size = [20, 10];
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         twisted = [for(p = line) ptf_x_twist(size, p, 90)];
-        hull_polyline3d(twisted, thickness = .1);
+        polyline_join(twisted)
+		    sphere(.05);
     }
 
     for(line = columns) {
         twisted = [for(p = line) ptf_x_twist(size, p, 90)];
-        hull_polyline3d(twisted, thickness = .1);
+        polyline_join(twisted)
+		    sphere(.05);
     }
 
 ![ptf_x_twist](images/lib3x-ptf_x_twist-1.JPG)

docs/lib3x-ptf_y_twist.md

@@ -14,29 +14,31 @@ Twist a point along the y-axis. You can use it to create something such as a [tw
 
 ## Examples
 
-    use <hull_polyline3d.scad>;
+    use <polyline_join.scad>;
     use <ptf/ptf_y_twist.scad>;
 
     size = [10, 20];
 
     rows = [
-        for(y = [0:size[1]])
-            [for(x = [0:size[0]]) [x, y]]
+        for(y = [0:size.y])
+            [for(x = [0:size.x]) [x, y]]
     ];
 
     columns = [
-        for(x = [0:size[0]])
-            [for(y = [0:size[1]]) [x, y]]
+        for(x = [0:size.x])
+            [for(y = [0:size.y]) [x, y]]
     ];
 
     for(line = rows) {
         twisted = [for(p = line) ptf_y_twist(size, p, 90)];
-        hull_polyline3d(twisted, thickness = .1);
+        polyline_join(twisted)
+		    sphere(.05);
     }
 
     for(line = columns) {
         twisted = [for(p = line) ptf_y_twist(size, p, 90)];
-        hull_polyline3d(twisted, thickness = .1);
+        polyline_join(twisted)
+		    sphere(.05);
     }
 
 ![ptf_y_twist](images/lib3x-ptf_y_twist-1.JPG)

docs/lib3x-rails2sections.md

@@ -0,0 +1,69 @@
+# rails2sections
+
+Create sections along rails. Combined with the `sweep` module, you can describe a more complex model.
+
+Rails should be indexed count-clockwisely.
+
+**Since:** 3.2
+
+## Parameters
+
+- `rails` : A list of rails used to describe the surface of the model.
+
+## Examples
+
+	use <rails2sections.scad>;
+	use <polyline_join.scad>;
+	use <sweep.scad>;
+	
+	rails = [
+	    [[5, 0, 5], [15, 10, 10], [25, 20, 5]],
+	    [[-5, 0, 5], [-15, 10, 10], [-25, 20, 5]],
+	    [[-5, 0, -5], [-15, 10, -10], [-25, 20, -5]],  
+	    [[5, 0, -5], [15, 10, -10], [25, 20, -5]]
+	];
+	
+	sections = rails2sections(rails);
+	
+	sweep(sections);
+	
+	#for(path = rails) {
+	    polyline_join(path)
+		    sphere(.25);
+	}
+
+![rails2sections](images/lib3x-rails2sections-1.JPG)
+
+	use <bezier_curve.scad>;
+	use <rails2sections.scad>;
+	use <polyline_join.scad>;
+	use <sweep.scad>;
+	
+	t_step = 0.05;
+	
+	rails = [
+	    bezier_curve(t_step, 
+	        [[1.25, 0, 5], [5, 20, 5], [16, 20, -2], [18, 20, 10], [30, 15, 8]]
+	    ),
+	    bezier_curve(t_step, 
+	        [[-1.25, 0, 5], [0, 20, 5],  [16, 22, -2], [18, 20, 10], [30, 25, 8]]
+	    ),
+	    bezier_curve(t_step, 
+	        [[-1.25, 0, -5], [0, 20, -5], [16, 20, 1], [18, 27, -3], [20, 27, -5]]
+	    ),
+	    bezier_curve(t_step, 
+	        [[1.25, 0, -5], [5, 20, -5], [16, 20, 1], [18, 17.5, -3], [20, 17.5, -5]]
+	    )
+	];
+	
+	
+	sections = rails2sections(rails);
+	
+	sweep(sections);
+	
+	#for(path = rails) {
+	    polyline_join(path)
+		    sphere(.25);
+	}
+
+![rails2sections](images/lib3x-rails2sections-2.JPG)

docs/lib3x-rotate_p.md

@@ -1,82 +0,0 @@
-# rotate_p
-
-Rotates a point `a` degrees about the axis of the coordinate system or around an arbitrary axis. It behaves as the built-in `rotate` module
-
-## Parameters
-
-- `point` : A 3D point `[x, y, z]` or a 2D point `[x, y]`.
-- `a` : If it's `[deg_x, deg_y, deg_z]`, the rotation is applied in the order `x`, `y`, `z`. If it's `[deg_x, deg_y]`, the rotation is applied in the order `x`, `y`.  If it's`[deg_x]`, the rotation is only applied to the `x` axis. If it's an number, the rotation is only applied to the `z` axis or an arbitrary axis.
-- `v`: A vector allows you to set an arbitrary axis about which the object will be rotated. When `a` is an array, the `v` argument is ignored. **Since:** 1.1.
-
-## Examples
-    
-You can use the code below to create a line.
-
-    use <rotate_p.scad>;
-
-	hull() {
-	    sphere(1);
-	    rotate([0, -45, 45]) 
-	        translate([20, 0, 0]) 
-	            sphere(1);   
-	}  
-
-The following code has the same effect.
-
-    use <rotate_p.scad>;
-
-	point = [20, 0, 0];
-	a = [0, -45, 45];
-	
-	hull() {
-	    sphere(1);
-	    translate(rotate_p(point, a))    
-	       rotate(a)  
-	           sphere(1);   
-	}  
-
-![rotate_p](images/lib3x-rotate_p-1.JPG)
-
-The `rotate_p` function is useful in some situations. For example, you probably want to get all points on the path of a spiral around a sphere. 
-
-    use <rotate_p.scad>;
-
-	radius = 40;
-	step_angle = 10;
-	z_circles = 20;
-	
-	points = [for(a = [0:step_angle:90 * z_circles]) 
-	    rotate_p(
-	        [radius, 0, 0], 
-	        [0, -90 + 2 * a / z_circles, a]
-	    )
-	];
-	
-	// Once you get all points on the path, you can place anything at each point.
-	// I just place a sphere as a simple demonstration.
-	for(p = points) {
-	    translate(p) 
-	        sphere(1);
-	}
-	
-	%sphere(radius);
-
-![rotate_p](images/lib3x-rotate_p-2.JPG)
-
-	use <rotate_p.scad>;
-
-	v = [10, 10, 10];
-
-	hull() {
-		sphere(1);
-		translate(v)
-		sphere(1);   
-	}
-
-	p = [10, 10, 0];
-	for(i = [0:20:340]) {
-		translate(rotate_p(p, a = i, v = v)) 
-			sphere(1);  
-	}
-	
-![rotate_p](images/lib3x-rotate_p-3.JPG)

docs/lib3x-select.md

@@ -0,0 +1,37 @@
+# select
+
+Selects module objects. 
+
+**Since:** 3.2
+
+## Parameters
+
+- `i` : An index value, range, or list. Select all module objects if `i` is ignored.
+
+## Examples
+
+If you write code like this:
+	
+	i = 0;
+
+	if(i == 0) {
+		sphere(1);
+	}
+	else if(i == 1) {
+		cube(1);
+	}
+	else if(i == 2) {
+		cylinder(1, 1);
+	}
+
+You may use `select`:
+
+	use <select.scad>;
+
+	i = 0;
+
+	select(i) {
+		sphere(1);
+		cube(1);
+		cylinder(1, 1);
+	}