////////////////////////////////////////////////////////////////////// // LibFile: shapes2d.scad // Common useful 2D shapes. // To use, add the following lines to the beginning of your file: // ``` // include // ``` ////////////////////////////////////////////////////////////////////// // Section: 2D Drawing Helpers // Module: stroke() // Usage: // stroke(path, [width], [closed], [endcaps], [endcap_width], [endcap_length], [endcap_extent], [trim]); // stroke(path, [width], [closed], [endcap1], [endcap2], [endcap_width1], [endcap_width2], [endcap_length1], [endcap_length2], [endcap_extent1], [endcap_extent2], [trim1], [trim2]); // Description: // Draws a 2D or 3D path with a given line width. Endcaps can be specified for each end individually. // Figure(2D,Big): Endcap Types // endcaps = [ // ["butt", "square", "round", "chisel", "tail", "tail2"], // ["line", "cross", "dot", "diamond", "x", "arrow", "arrow2"] // ]; // for (x=idx(endcaps), y=idx(endcaps[x])) { // cap = endcaps[x][y]; // right(x*60-60+5) fwd(y*10+15) { // right(28) color("black") text(text=cap, size=5, halign="left", valign="center"); // stroke([[0,0], [20,0]], width=3, endcap_width=3, endcap1=false, endcap2=cap); // color("black") stroke([[0,0], [20,0]], width=0.25, endcaps=false); // } // } // Arguments: // path = The 2D path to draw along. // width = The width of the line to draw. If given as a list of widths, (one for each path point), draws the line with varying thickness to each point. // closed = If true, draw an additional line from the end of the path to the start. // endcaps = Specifies the endcap type for both ends of the line. If a 2D path is given, use that to draw custom endcaps. // endcap1 = Specifies the endcap type for the start of the line. If a 2D path is given, use that to draw a custom endcap. // endcap2 = Specifies the endcap type for the end of the line. If a 2D path is given, use that to draw a custom endcap. // endcap_width = Some endcap types are wider than the line. This specifies the size of endcaps, in multiples of the line width. Default: 3.5 // endcap_width1 = This specifies the size of starting endcap, in multiples of the line width. Default: 3.5 // endcap_width2 = This specifies the size of ending endcap, in multiples of the line width. Default: 3.5 // endcap_length = Length of endcaps, in multiples of the line width. Default: `endcap_width*0.5` // endcap_length1 = Length of starting endcap, in multiples of the line width. Default: `endcap_width1*0.5` // endcap_length2 = Length of ending endcap, in multiples of the line width. Default: `endcap_width2*0.5` // endcap_extent = Extents length of endcaps, in multiples of the line width. Default: `endcap_width*0.5` // endcap_extent1 = Extents length of starting endcap, in multiples of the line width. Default: `endcap_width1*0.5` // endcap_extent2 = Extents length of ending endcap, in multiples of the line width. Default: `endcap_width2*0.5` // endcap_angle = Extra axial rotation given to flat endcaps for 3D paths, in degrees. If not given, the endcaps are fully spun. Default: `undef` (Fully spun cap) // endcap_angle1 = Extra axial rotation given to a flat starting endcap for 3D paths, in degrees. If not given, the endcap is fully spun. Default: `undef` (Fully spun cap) // endcap_angle2 = Extra axial rotation given to a flat ending endcap for 3D paths, in degrees. If not given, the endcap is fully spun. Default: `undef` (Fully spun cap) // trim = Trim the the start and end line segments by this much, to keep them from interfering with custom endcaps. // trim1 = Trim the the starting line segment by this much, to keep it from interfering with a custom endcap. // trim2 = Trim the the ending line segment by this much, to keep it from interfering with a custom endcap. // convexity = Max number of times a line could intersect a wall of an endcap. // hull = If true, use `hull()` to make higher quality joints between segments, at the cost of being much slower. Default: true // Example(2D): Drawing a Path // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // stroke(path, width=20); // Example(2D): Closing a Path // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // stroke(path, width=20, endcaps=true, closed=true); // Example(2D): Fancy Arrow Endcaps // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // stroke(path, width=10, endcaps="arrow2"); // Example(2D): Modified Fancy Arrow Endcaps // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // stroke(path, width=10, endcaps="arrow2", endcap_width=6, endcap_length=3, endcap_extent=2); // Example(2D): Mixed Endcaps // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // stroke(path, width=10, endcap1="tail2", endcap2="arrow2"); // Example(2D): Custom Endcap Shapes // path = [[0,100], [100,100], [200,0], [100,-100], [100,0]]; // arrow = [[0,0], [2,-3], [0.5,-2.3], [2,-4], [0.5,-3.5], [-0.5,-3.5], [-2,-4], [-0.5,-2.3], [-2,-3]]; // stroke(path, width=10, trim=3.5, endcaps=arrow); // Example(2D): Variable Line Width // path = circle(d=50,$fn=18); // widths = [for (i=idx(path)) 10*i/len(path)+2]; // stroke(path,width=widths,$fa=1,$fs=1); // Example: 3D Path with Endcaps // path = rot([15,30,0], p=path3d(pentagon(d=50))); // stroke(path, width=2, endcaps="arrow2", $fn=18); // Example: 3D Path with Flat Endcaps // path = rot([15,30,0], p=path3d(pentagon(d=50))); // stroke(path, width=2, endcaps="arrow2", endcap_angle=0, $fn=18); // Example: 3D Path with Mixed Endcaps // path = rot([15,30,0], p=path3d(pentagon(d=50))); // stroke(path, width=2, endcap1="arrow2", endcap2="tail", endcap_angle2=0, $fn=18); module stroke( path, width=1, closed=false, endcaps, endcap1, endcap2, trim, trim1, trim2, endcap_width, endcap_width1, endcap_width2, endcap_length, endcap_length1, endcap_length2, endcap_extent, endcap_extent1, endcap_extent2, endcap_angle, endcap_angle1, endcap_angle2, convexity=10, hull=true ) { function _endcap_shape(cap,linewidth,w,l,l2) = ( let(sq2=sqrt(2), l3=l-l2) (cap=="round" || cap==true)? circle(d=1, $fn=max(8, segs(w/2))) : cap=="chisel"? [[-0.5,0], [0,0.5], [0.5,0], [0,-0.5]] : cap=="square"? [[-0.5,-0.5], [-0.5,0.5], [0.5,0.5], [0.5,-0.5]] : cap=="diamond"? [[0,w/2], [w/2,0], [0,-w/2], [-w/2,0]] : cap=="dot"? circle(d=3, $fn=max(12, segs(w*3/2))) : cap=="x"? [for (a=[0:90:270]) each rot(a,p=[[w+sq2/2,w-sq2/2]/2, [w-sq2/2,w+sq2/2]/2, [0,sq2/2]]) ] : cap=="cross"? [for (a=[0:90:270]) each rot(a,p=[[1,w]/2, [-1,w]/2, [-1,1]/2]) ] : cap=="line"? [[w/2,0.5], [w/2,-0.5], [-w/2,-0.5], [-w/2,0.5]] : cap=="arrow"? [[0,0], [w/2,-l2], [w/2,-l2-l], [0,-l], [-w/2,-l2-l], [-w/2,-l2]] : cap=="arrow2"? [[0,0], [w/2,-l2-l], [0,-l], [-w/2,-l2-l]] : cap=="tail"? [[0,0], [w/2,l2], [w/2,l2-l], [0,-l], [-w/2,l2-l], [-w/2,l2]] : cap=="tail2"? [[w/2,0], [w/2,-l], [0,-l-l2], [-w/2,-l], [-w/2,0]] : is_path(cap)? cap : [] ) * linewidth; assert(is_bool(closed)); assert(is_list(path)); if (len(path) > 1) { assert(is_path(path,[2,3]), "The path argument must be a list of 2D or 3D points."); } path = deduplicate( closed? close_path(path) : path ); assert(is_num(width) || (is_vector(width) && len(width)==len(path))); width = is_num(width)? [for (x=path) width] : width; endcap1 = first_defined([endcap1, endcaps, "round"]); endcap2 = first_defined([endcap2, endcaps, "round"]); assert(is_bool(endcap1) || is_string(endcap1) || is_path(endcap1)); assert(is_bool(endcap2) || is_string(endcap2) || is_path(endcap2)); endcap_width1 = first_defined([endcap_width1, endcap_width, 3.5]); endcap_width2 = first_defined([endcap_width2, endcap_width, 3.5]); assert(is_num(endcap_width1)); assert(is_num(endcap_width2)); endcap_length1 = first_defined([endcap_length1, endcap_length, endcap_width1*0.5]); endcap_length2 = first_defined([endcap_length2, endcap_length, endcap_width2*0.5]); assert(is_num(endcap_length1)); assert(is_num(endcap_length2)); endcap_extent1 = first_defined([endcap_extent1, endcap_extent, endcap_width1*0.5]); endcap_extent2 = first_defined([endcap_extent2, endcap_extent, endcap_width2*0.5]); assert(is_num(endcap_extent1)); assert(is_num(endcap_extent2)); endcap_angle1 = first_defined([endcap_angle1, endcap_angle]); endcap_angle2 = first_defined([endcap_angle2, endcap_angle]); assert(is_undef(endcap_angle1)||is_num(endcap_angle1)); assert(is_undef(endcap_angle2)||is_num(endcap_angle2)); endcap_shape1 = _endcap_shape(endcap1, select(width,0), endcap_width1, endcap_length1, endcap_extent1); endcap_shape2 = _endcap_shape(endcap2, select(width,-1), endcap_width2, endcap_length2, endcap_extent2); trim1 = select(width,0) * first_defined([ trim1, trim, (endcap1=="arrow")? endcap_length1-0.01 : (endcap1=="arrow2")? endcap_length1*3/4 : 0 ]); assert(is_num(trim1)); trim2 = select(width,-1) * first_defined([ trim2, trim, (endcap2=="arrow")? endcap_length2-0.01 : (endcap2=="arrow2")? endcap_length2*3/4 : 0 ]); assert(is_num(trim2)); if (len(path) == 1) { if (len(path[0]) == 2) { translate(path[0]) circle(d=width[0]); } else { translate(path[0]) sphere(d=width[0]); } } else { spos = path_pos_from_start(path,trim1,closed=false); epos = path_pos_from_end(path,trim2,closed=false); path2 = path_subselect(path, spos[0], spos[1], epos[0], epos[1]); widths = concat( [lerp(width[spos[0]], width[(spos[0]+1)%len(width)], spos[1])], [for (i = [spos[0]+1:1:epos[0]]) width[i]], [lerp(width[epos[0]], width[(epos[0]+1)%len(width)], epos[1])] ); start_vec = select(path,0) - select(path,1); end_vec = select(path,-1) - select(path,-2); if (len(path[0]) == 2) { // Straight segments for (i = idx(path2,end=-2)) { seg = select(path2,i,i+1); delt = seg[1] - seg[0]; translate(seg[0]) { rot(from=BACK,to=delt) { trapezoid(w1=widths[i], w2=widths[i+1], h=norm(delt), anchor=FRONT); } } } // Joints for (i = [1:1:len(path2)-2]) { $fn = quantup(segs(widths[i]/2),4); if (hull) { hull() { translate(path2[i]) { rot(from=BACK, to=path2[i]-path2[i-1]) circle(d=widths[i]); rot(from=BACK, to=path2[i+1]-path2[i]) circle(d=widths[i]); } } } else { translate(path2[i]) { rot(from=BACK, to=path2[i]-path2[i-1]) circle(d=widths[i]); rot(from=BACK, to=path2[i+1]-path2[i]) circle(d=widths[i]); } } } // Endcap1 translate(path[0]) { start_vec = select(path,0) - select(path,1); rot(from=BACK, to=start_vec) { polygon(endcap_shape1); } } // Endcap2 translate(select(path,-1)) { rot(from=BACK, to=end_vec) { polygon(endcap_shape2); } } } else { quatsums = Q_Cumulative([ for (i = idx(path2,end=-2)) let( vec1 = i==0? UP : unit(path2[i]-path2[i-1], UP), vec2 = unit(path2[i+1]-path2[i], UP), axis = vector_axis(vec1,vec2), ang = vector_angle(vec1,vec2) ) Quat(axis,ang) ]); rotmats = [for (q=quatsums) Q_Matrix4(q)]; sides = [ for (i = idx(path2,end=-2)) quantup(segs(max(widths[i],widths[i+1])/2),4) ]; // Straight segments for (i = idx(path2,end=-2)) { dist = norm(path2[i+1] - path2[i]); w1 = widths[i]/2; w2 = widths[i+1]/2; $fn = sides[i]; translate(path2[i]) { multmatrix(rotmats[i]) { cylinder(r1=w1, r2=w2, h=dist, center=false); } } } // Joints for (i = [1:1:len(path2)-2]) { $fn = sides[i]; translate(path2[i]) { if (hull) { hull(){ multmatrix(rotmats[i]) { sphere(d=widths[i]); } multmatrix(rotmats[i-1]) { sphere(d=widths[i]); } } } else { multmatrix(rotmats[i]) { sphere(d=widths[i]); } multmatrix(rotmats[i-1]) { sphere(d=widths[i]); } } } } // Endcap1 translate(path[0]) { multmatrix(rotmats[0] * xrot(180)) { $fn = sides[0]; if (is_undef(endcap_angle1)) { rotate_extrude(convexity=convexity) { right_half(planar=true) { polygon(endcap_shape1); } } } else { rotate([90,0,endcap_angle1]) { linear_extrude(height=widths[0], center=true, convexity=convexity) { polygon(endcap_shape1); } } } } } // Endcap2 translate(select(path,-1)) { multmatrix(select(rotmats,-1)) { $fn = select(sides,-1); if (is_undef(endcap_angle2)) { rotate_extrude(convexity=convexity) { right_half(planar=true) { polygon(endcap_shape2); } } } else { rotate([90,0,endcap_angle2]) { linear_extrude(height=select(widths,-1), center=true, convexity=convexity) { polygon(endcap_shape2); } } } } } } } } // Function&Module: arc() // Usage: 2D arc from 0º to `angle` degrees. // arc(N, r|d, angle); // Usage: 2D arc from START to END degrees. // arc(N, r|d, angle=[START,END]) // Usage: 2D arc from `start` to `start+angle` degrees. // arc(N, r|d, start, angle) // Usage: 2D circle segment by `width` and `thickness`, starting and ending on the X axis. // arc(N, width, thickness) // Usage: Shortest 2D or 3D arc around centerpoint `cp`, starting at P0 and ending on the vector pointing from `cp` to `P1`. // arc(N, cp, points=[P0,P1],[long],[cw],[ccw]) // Usage: 2D or 3D arc, starting at `P0`, passing through `P1` and ending at `P2`. // arc(N, points=[P0,P1,P2]) // Description: // If called as a function, returns a 2D or 3D path forming an arc. // If called as a module, creates a 2D arc polygon or pie slice shape. // Arguments: // N = Number of vertices to form the arc curve from. // r = Radius of the arc. // d = Diameter of the arc. // angle = If a scalar, specifies the end angle in degrees. If a vector of two scalars, specifies start and end angles. // cp = Centerpoint of arc. // points = Points on the arc. // long = if given with cp and points takes the long arc instead of the default short arc. Default: false // cw = if given with cp and 2 points takes the arc in the clockwise direction. Default: false // ccw = if given with cp and 2 points takes the arc in the counter-clockwise direction. Default: false // width = If given with `thickness`, arc starts and ends on X axis, to make a circle segment. // thickness = If given with `width`, arc starts and ends on X axis, to make a circle segment. // start = Start angle of arc. // wedge = If true, include centerpoint `cp` in output to form pie slice shape. // Examples(2D): // arc(N=4, r=30, angle=30, wedge=true); // arc(r=30, angle=30, wedge=true); // arc(d=60, angle=30, wedge=true); // arc(d=60, angle=120); // arc(d=60, angle=120, wedge=true); // arc(r=30, angle=[75,135], wedge=true); // arc(r=30, start=45, angle=75, wedge=true); // arc(width=60, thickness=20); // arc(cp=[-10,5], points=[[20,10],[0,35]], wedge=true); // arc(points=[[30,-5],[20,10],[-10,20]], wedge=true); // arc(points=[[5,30],[-10,-10],[30,5]], wedge=true); // Example(2D): // path = arc(points=[[5,30],[-10,-10],[30,5]], wedge=true); // stroke(closed=true, path); // Example(FlatSpin): // path = arc(points=[[0,30,0],[0,0,30],[30,0,0]]); // trace_polyline(path, showpts=true, color="cyan"); function arc(N, r, angle, d, cp, points, width, thickness, start, wedge=false, long=false, cw=false, ccw=false) = // First try for 2D arc specified by width and thickness is_def(width) && is_def(thickness)? ( assert(!any_defined([r,cp,points]) && !any([cw,ccw,long]),"Conflicting or invalid parameters to arc") assert(width>0, "Width must be postive") assert(thickness>0, "Thickness must be positive") arc(N,points=[[width/2,0], [0,thickness], [-width/2,0]],wedge=wedge) ) : is_def(angle)? ( let( parmok = !any_defined([points,width,thickness]) && ((is_vector(angle,2) && is_undef(start)) || is_num(angle)) ) assert(parmok,"Invalid parameters in arc") let( cp = first_defined([cp,[0,0]]), start = is_def(start)? start : is_vector(angle) ? angle[0] : 0, angle = is_vector(angle)? angle[1]-angle[0] : angle, r = get_radius(r=r, d=d) ) assert(is_vector(cp,2),"Centerpoint must be a 2d vector") assert(angle!=0, "Arc has zero length") assert(r>0, "Arc radius invalid") let( N = max(3, is_undef(N)? ceil(segs(r)*abs(angle)/360) : N), arcpoints = [for(i=[0:N-1]) let(theta = start + i*angle/(N-1)) r*[cos(theta),sin(theta)]+cp], extra = wedge? [cp] : [] ) concat(extra,arcpoints) ) : assert(is_path(points,[2,3]),"Point list is invalid") // Arc is 3D, so transform points to 2D and make a recursive call, then remap back to 3D len(points[0])==3? ( assert(!(cw || ccw), "(Counter)clockwise isn't meaningful in 3d, so `cw` and `ccw` must be false") assert(is_undef(cp) || is_vector(cp,3),"points are 3d so cp must be 3d") let( thirdpoint = is_def(cp) ? cp : points[2], center2d = is_def(cp) ? project_plane(cp,thirdpoint,points[0],points[1]) : undef, points2d = project_plane(points,thirdpoint,points[0],points[1]) ) lift_plane(arc(N,cp=center2d,points=points2d,wedge=wedge,long=long),thirdpoint,points[0],points[1]) ) : is_def(cp)? ( // Arc defined by center plus two points, will have radius defined by center and points[0] // and extent defined by direction of point[1] from the center assert(is_vector(cp,2), "Centerpoint must be a 2d vector") assert(len(points)==2, "When pointlist has length 3 centerpoint is not allowed") assert(points[0]!=points[1], "Arc endpoints are equal") assert(cp!=points[0]&&cp!=points[1], "Centerpoint equals an arc endpoint") assert(count_true([long,cw,ccw])<=1, str("Only one of `long`, `cw` and `ccw` can be true",cw,ccw,long)) let( angle = vector_angle(points[0], cp, points[1]), v1 = points[0]-cp, v2 = points[1]-cp, prelim_dir = sign(det2([v1,v2])), // z component of cross product dir = prelim_dir != 0 ? prelim_dir : assert(cw || ccw, "Collinear inputs don't define a unique arc") 1, r=norm(v1), final_angle = long || (ccw && dir<0) || (cw && dir>0) ? -dir*(360-angle) : dir*angle ) arc(N,cp=cp,r=r,start=atan2(v1.y,v1.x),angle=final_angle,wedge=wedge) ) : ( // Final case is arc passing through three points, starting at point[0] and ending at point[3] let(col = collinear(points[0],points[1],points[2])) assert(!col, "Collinear inputs do not define an arc") let( cp = line_intersection(_normal_segment(points[0],points[1]),_normal_segment(points[1],points[2])), // select order to be counterclockwise dir = det2([points[1]-points[0],points[2]-points[1]]) > 0, points = dir? select(points,[0,2]) : select(points,[2,0]), r = norm(points[0]-cp), theta_start = atan2(points[0].y-cp.y, points[0].x-cp.x), theta_end = atan2(points[1].y-cp.y, points[1].x-cp.x), angle = posmod(theta_end-theta_start, 360), arcpts = arc(N,cp=cp,r=r,start=theta_start,angle=angle,wedge=wedge) ) dir ? arcpts : reverse(arcpts) ); module arc(N, r, angle, d, cp, points, width, thickness, start, wedge=false) { path = arc(N=N, r=r, angle=angle, d=d, cp=cp, points=points, width=width, thickness=thickness, start=start, wedge=wedge); polygon(path); } function _normal_segment(p1,p2) = let(center = (p1+p2)/2) [center, center + norm(p1-p2)/2 * line_normal(p1,p2)]; // Function: turtle() // Usage: // turtle(commands, [state], [return_state]) // Description: // Use a sequence of turtle graphics commands to generate a path. The parameter `commands` is a list of // turtle commands and optional parameters for each command. The turtle state has a position, movement direction, // movement distance, and default turn angle. If you do not give `state` as input then the turtle starts at the // origin, pointed along the positive x axis with a movement distance of 1. By default, `turtle` returns just // the computed turtle path. If you set `full_state` to true then it instead returns the full turtle state. // You can invoke `turtle` again with this full state to continue the turtle path where you left off. // // The turtle state is a list with three entries: the path constructed so far, the current step as a 2-vector, and the current default angle. // // For the list below, `dist` is the current movement distance. // // Commands | Arguments | What it does // ------------ | ------------------ | ------------------------------- // "move" | [dist] | Move turtle scale*dist units in the turtle direction. Default dist=1. // "xmove" | [dist] | Move turtle scale*dist units in the x direction. Default dist=1. Does not change turtle direction. // "ymove" | [dist] | Move turtle scale*dist units in the y direction. Default dist=1. Does not change turtle direction. // "xymove" | vector | Move turtle by the specified vector. Does not change turtle direction. // "untilx" | xtarget | Move turtle in turtle direction until x==xtarget. Produces an error if xtarget is not reachable. // "untily" | ytarget | Move turtle in turtle direction until y==ytarget. Produces an error if xtarget is not reachable. // "jump" | point | Move the turtle to the specified point // "xjump" | x | Move the turtle's x position to the specified value // "yjump | y | Move the turtle's y position to the specified value // "turn" | [angle] | Turn turtle direction by specified angle, or the turtle's default turn angle. The default angle starts at 90. // "left" | [angle] | Same as "turn" // "right" | [angle] | Same as "turn", -angle // "angle" | angle | Set the default turn angle. // "setdir" | dir | Set turtle direction. The parameter `dir` can be an angle or a vector. // "length" | length | Change the turtle move distance to `length` // "scale" | factor | Multiply turtle move distance by `factor` // "addlength" | length | Add `length` to the turtle move distance // "repeat" | count, commands | Repeats a list of commands `count` times. // "arcleft" | radius, [angle] | Draw an arc from the current position toward the left at the specified radius and angle. The turtle turns by `angle`. A negative angle draws the arc to the right instead of the left, and leaves the turtle facing right. A negative radius draws the arc to the right but leaves the turtle facing left. // "arcright" | radius, [angle] | Draw an arc from the current position toward the right at the specified radius and angle // "arcleftto" | radius, angle | Draw an arc at the given radius turning toward the left until reaching the specified absolute angle. // "arcrightto" | radius, angle | Draw an arc at the given radius turning toward the right until reaching the specified absolute angle. // "arcsteps" | count | Specifies the number of segments to use for drawing arcs. If you set it to zero then the standard `$fn`, `$fa` and `$fs` variables define the number of segments. // // Arguments: // commands = List of turtle commands // state = Starting turtle state (from previous call) or starting point. Default: start at the origin, pointing right. // full_state = If true return the full turtle state for continuing the path in subsequent turtle calls. Default: false // repeat = Number of times to repeat the command list. Default: 1 // // Example(2D): Simple rectangle // path = turtle(["xmove",3, "ymove", "xmove",-3, "ymove",-1]); // stroke(path,width=.1); // Example(2D): Pentagon // path=turtle(["angle",360/5,"move","turn","move","turn","move","turn","move"]); // stroke(path,width=.1,closed=true); // Example(2D): Pentagon using the repeat argument // path=turtle(["move","turn",360/5],repeat=5); // stroke(path,width=.1,closed=true); // Example(2D): Pentagon using the repeat turtle command, setting the turn angle // path=turtle(["angle",360/5,"repeat",5,["move","turn"]]); // stroke(path,width=.1,closed=true); // Example(2D): Pentagram // path = turtle(["move","left",144], repeat=4); // stroke(path,width=.05,closed=true); // Example(2D): Sawtooth path // path = turtle([ // "turn", 55, // "untily", 2, // "turn", -55-90, // "untily", 0, // "turn", 55+90, // "untily", 2.5, // "turn", -55-90, // "untily", 0, // "turn", 55+90, // "untily", 3, // "turn", -55-90, // "untily", 0 // ]); // stroke(path, width=.1); // Example(2D): Simpler way to draw the sawtooth. The direction of the turtle is preserved when executing "yjump". // path = turtle([ // "turn", 55, // "untily", 2, // "yjump", 0, // "untily", 2.5, // "yjump", 0, // "untily", 3, // "yjump", 0, // ]); // stroke(path, width=.1); // Example(2DMed): square spiral // path = turtle(["move","left","addlength",1],repeat=50); // stroke(path,width=.2); // Example(2DMed): pentagonal spiral // path = turtle(["move","left",360/5,"addlength",1],repeat=50); // stroke(path,width=.2); // Example(2DMed): yet another spiral, without using `repeat` // path = turtle(concat(["angle",71],flatten(repeat(["move","left","addlength",1],50)))); // stroke(path,width=.2); // Example(2DMed): The previous spiral grows linearly and eventually intersects itself. This one grows geometrically and does not. // path = turtle(["move","left",71,"scale",1.05],repeat=50); // stroke(path,width=.05); // Example(2D): Koch Snowflake // function koch_unit(depth) = // depth==0 ? ["move"] : // concat( // koch_unit(depth-1), // ["right"], // koch_unit(depth-1), // ["left","left"], // koch_unit(depth-1), // ["right"], // koch_unit(depth-1) // ); // koch=concat(["angle",60,"repeat",3],[concat(koch_unit(3),["left","left"])]); // polygon(turtle(koch)); function turtle(commands, state=[[[0,0]],[1,0],90,0], full_state=false, repeat=1) = let( state = is_vector(state) ? [[state],[1,0],90,0] : state ) repeat == 1? _turtle(commands,state,full_state) : _turtle_repeat(commands, state, full_state, repeat); function _turtle_repeat(commands, state, full_state, repeat) = repeat==1? _turtle(commands,state,full_state) : _turtle_repeat(commands, _turtle(commands, state, true), full_state, repeat-1); function _turtle_command_len(commands, index) = let( one_or_two_arg = ["arcleft","arcright", "arcleftto", "arcrightto"] ) commands[index] == "repeat"? 3 : // Repeat command requires 2 args // For these, the first arg is required, second arg is present if it is not a string in_list(commands[index], one_or_two_arg) && len(commands)>index+2 && !is_string(commands[index+2]) ? 3 : is_string(commands[index+1])? 1 : // If 2nd item is a string it's must be a new command 2; // Otherwise we have command and arg function _turtle(commands, state, full_state, index=0) = index < len(commands) ? _turtle(commands, _turtle_command(commands[index],commands[index+1],commands[index+2],state,index), full_state, index+_turtle_command_len(commands,index) ) : ( full_state ? state : state[0] ); // Turtle state: state = [path, step_vector, default angle] function _turtle_command(command, parm, parm2, state, index) = command == "repeat"? assert(is_num(parm),str("\"repeat\" command requires a numeric repeat count at index ",index)) assert(is_list(parm2),str("\"repeat\" command requires a command list parameter at index ",index)) _turtle_repeat(parm2, state, true, parm) : let( path = 0, step=1, angle=2, arcsteps=3, parm = !is_string(parm) ? parm : undef, parm2 = !is_string(parm2) ? parm2 : undef, needvec = ["jump", "xymove"], neednum = ["untilx","untily","xjump","yjump","angle","length","scale","addlength"], needeither = ["setdir"], chvec = !in_list(command,needvec) || is_vector(parm,2), chnum = !in_list(command,neednum) || is_num(parm), vec_or_num = !in_list(command,needeither) || (is_num(parm) || is_vector(parm,2)), lastpt = select(state[path],-1) ) assert(chvec,str("\"",command,"\" requires a vector parameter at index ",index)) assert(chnum,str("\"",command,"\" requires a numeric parameter at index ",index)) assert(vec_or_num,str("\"",command,"\" requires a vector or numeric parameter at index ",index)) command=="move" ? list_set(state, path, concat(state[path],[default(parm,1)*state[step]+lastpt])) : command=="untilx" ? ( let( int = line_intersection([lastpt,lastpt+state[step]], [[parm,0],[parm,1]]), xgood = sign(state[step].x) == sign(int.x-lastpt.x) ) assert(xgood,str("\"untilx\" never reaches desired goal at index ",index)) list_set(state,path,concat(state[path],[int])) ) : command=="untily" ? ( let( int = line_intersection([lastpt,lastpt+state[step]], [[0,parm],[1,parm]]), ygood = is_def(int) && sign(state[step].y) == sign(int.y-lastpt.y) ) assert(ygood,str("\"untily\" never reaches desired goal at index ",index)) list_set(state,path,concat(state[path],[int])) ) : command=="xmove" ? list_set(state, path, concat(state[path],[default(parm,1)*norm(state[step])*[1,0]+lastpt])): command=="ymove" ? list_set(state, path, concat(state[path],[default(parm,1)*norm(state[step])*[0,1]+lastpt])): command=="xymove" ? list_set(state, path, concat(state[path], [lastpt+parm])): command=="jump" ? list_set(state, path, concat(state[path],[parm])): command=="xjump" ? list_set(state, path, concat(state[path],[[parm,lastpt.y]])): command=="yjump" ? list_set(state, path, concat(state[path],[[lastpt.x,parm]])): command=="turn" || command=="left" ? list_set(state, step, rot(default(parm,state[angle]),p=state[step],planar=true)) : command=="right" ? list_set(state, step, rot(-default(parm,state[angle]),p=state[step],planar=true)) : command=="angle" ? list_set(state, angle, parm) : command=="setdir" ? ( is_vector(parm) ? list_set(state, step, norm(state[step]) * unit(parm)) : list_set(state, step, norm(state[step]) * [cos(parm),sin(parm)]) ) : command=="length" ? list_set(state, step, parm*unit(state[step])) : command=="scale" ? list_set(state, step, parm*state[step]) : command=="addlength" ? list_set(state, step, state[step]+unit(state[step])*parm) : command=="arcsteps" ? list_set(state, arcsteps, parm) : command=="arcleft" || command=="arcright" ? assert(is_num(parm),str("\"",command,"\" command requires a numeric radius value at index ",index)) let( myangle = default(parm2,state[angle]), lrsign = command=="arcleft" ? 1 : -1, radius = parm*sign(myangle), center = lastpt + lrsign*radius*line_normal([0,0],state[step]), steps = state[arcsteps]==0 ? segs(abs(radius)) : state[arcsteps], arcpath = myangle == 0 || radius == 0 ? [] : arc( steps, points = [ lastpt, rot(cp=center, p=lastpt, a=sign(parm)*lrsign*myangle/2), rot(cp=center, p=lastpt, a=sign(parm)*lrsign*myangle) ] ) ) list_set( state, [path,step], [ concat(state[path], slice(arcpath,1,-1)), rot(lrsign * myangle,p=state[step],planar=true) ] ) : command=="arcleftto" || command=="arcrightto" ? assert(is_num(parm),str("\"",command,"\" command requires a numeric radius value at index ",index)) assert(is_num(parm2),str("\"",command,"\" command requires a numeric angle value at index ",index)) let( radius = parm, lrsign = command=="arcleftto" ? 1 : -1, center = lastpt + lrsign*radius*line_normal([0,0],state[step]), steps = state[arcsteps]==0 ? segs(abs(radius)) : state[arcsteps], start_angle = posmod(atan2(state[step].y, state[step].x),360), end_angle = posmod(parm2,360), delta_angle = -start_angle + (lrsign * end_angle < lrsign*start_angle ? end_angle+lrsign*360 : end_angle), arcpath = delta_angle == 0 || radius==0 ? [] : arc( steps, points = [ lastpt, rot(cp=center, p=lastpt, a=sign(radius)*delta_angle/2), rot(cp=center, p=lastpt, a=sign(radius)*delta_angle) ] ) ) list_set( state, [path,step], [ concat(state[path], slice(arcpath,1,-1)), rot(delta_angle,p=state[step],planar=true) ] ) : assert(false,str("Unknown turtle command \"",command,"\" at index",index)) []; // Section: 2D Primitives // Function&Module: rect() // Usage: // rect(size, [center], [rounding], [chamfer], [anchor], [spin]) // Description: // When called as a module, creates a 2D rectangle of the given size, with optional rounding or chamfering. // When called as a function, returns a 2D path/list of points for a square/rectangle of the given size. // Arguments: // size = The size of the rectangle to create. If given as a scalar, both X and Y will be the same size. // rounding = The rounding radius for the corners. If given as a list of four numbers, gives individual radii for each corner, in the order [X+Y+,X-Y+,X-Y-,X+Y-]. Default: 0 (no rounding) // chamfer = The chamfer size for the corners. If given as a list of four numbers, gives individual chamfers for each corner, in the order [X+Y+,X-Y+,X-Y-,X+Y-]. Default: 0 (no chamfer) // center = If given and true, overrides `anchor` to be `CENTER`. If given and false, overrides `anchor` to be `FRONT+LEFT`. // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Example(2D): // rect(40); // Example(2D): Centered // rect([40,30], center=true); // Example(2D): Anchored // rect([40,30], anchor=FRONT); // Example(2D): Spun // rect([40,30], anchor=FRONT, spin=30); // Example(2D): Chamferred Rect // rect([40,30], chamfer=5, center=true); // Example(2D): Rounded Rect // rect([40,30], rounding=5, center=true); // Example(2D): Mixed Chamferring and Rounding // rect([40,30],center=true,rounding=[5,0,10,0],chamfer=[0,8,0,15],$fa=1,$fs=1); // Example(2D): Called as Function // path = rect([40,30], chamfer=5, anchor=FRONT, spin=30); // stroke(path, closed=true); // move_copies(path) color("blue") circle(d=2,$fn=8); module rect(size=1, center, rounding=0, chamfer=0, anchor, spin=0) { size = is_num(size)? [size,size] : point2d(size); anchor = get_anchor(anchor, center, FRONT+LEFT, FRONT+LEFT); if (rounding==0 && chamfer==0) { attachable(anchor,spin, two_d=true, size=size) { square(size, center=true); children(); } } else { pts = rect(size=size, rounding=rounding, chamfer=chamfer, center=true); attachable(anchor,spin, two_d=true, path=pts) { polygon(pts); children(); } } } function rect(size=1, center, rounding=0, chamfer=0, anchor, spin=0) = assert(is_num(size) || is_vector(size)) assert(is_num(chamfer) || len(chamfer)==4) assert(is_num(rounding) || len(rounding)==4) let( size = is_num(size)? [size,size] : point2d(size), anchor = get_anchor(anchor, center, FRONT+LEFT, FRONT+LEFT), complex = rounding!=0 || chamfer!=0 ) (rounding==0 && chamfer==0)? let( path = [ [ size.x/2, -size.y/2], [-size.x/2, -size.y/2], [-size.x/2, size.y/2], [ size.x/2, size.y/2] ] ) rot(spin, p=move(-vmul(anchor,size/2), p=path)) : let( chamfer = is_list(chamfer)? chamfer : [for (i=[0:3]) chamfer], rounding = is_list(rounding)? rounding : [for (i=[0:3]) rounding], quadorder = [3,2,1,0], quadpos = [[1,1],[-1,1],[-1,-1],[1,-1]], insets = [for (i=[0:3]) chamfer[i]>0? chamfer[i] : rounding[i]>0? rounding[i] : 0], insets_x = max(insets[0]+insets[1],insets[2]+insets[3]), insets_y = max(insets[0]+insets[3],insets[1]+insets[2]) ) assert(insets_x <= size.x, "Requested roundings and/or chamfers exceed the rect width.") assert(insets_y <= size.y, "Requested roundings and/or chamfers exceed the rect height.") let( path = [ for(i = [0:3]) let( quad = quadorder[i], inset = insets[quad], cverts = quant(segs(inset),4)/4, cp = vmul(size/2-[inset,inset], quadpos[quad]), step = 90/cverts, angs = chamfer[quad] > 0? [0,-90]-90*[i,i] : rounding[quad] > 0? [for (j=[0:1:cverts]) 360-j*step-i*90] : [0] ) each [for (a = angs) cp + inset*[cos(a),sin(a)]] ] ) complex? reorient(anchor,spin, two_d=true, path=path, p=path) : reorient(anchor,spin, two_d=true, size=size, p=path); // Function&Module: oval() // Usage: // oval(r|d, [realign], [circum]) // Description: // When called as a module, creates a 2D polygon that approximates a circle of the given size. // When called as a function, returns a 2D list of points (path) for a polygon that approximates a circle of the given size. // Arguments: // r = Radius of the circle/oval to create. Can be a scalar, or a list of sizes per axis. // d = Diameter of the circle/oval to create. Can be a scalar, or a list of sizes per axis. // realign = If true, rotates the polygon that approximates the circle/oval by half of one size. // circum = If true, the polygon that approximates the circle will be upsized slightly to circumscribe the theoretical circle. If false, it inscribes the theoretical circle. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Example(2D): By Radius // oval(r=25); // Example(2D): By Diameter // oval(d=50); // Example(2D): Anchoring // oval(d=50, anchor=FRONT); // Example(2D): Spin // oval(d=50, anchor=FRONT, spin=45); // Example(NORENDER): Called as Function // path = oval(d=50, anchor=FRONT, spin=45); module oval(r, d, realign=false, circum=false, anchor=CENTER, spin=0) { r = get_radius(r=r, d=d, dflt=1); sides = segs(max(r)); sc = circum? (1 / cos(180/sides)) : 1; rx = default(r[0],r) * sc; ry = default(r[1],r) * sc; attachable(anchor,spin, two_d=true, r=[rx,ry]) { if (rx < ry) { xscale(rx/ry) { zrot(realign? 180/sides : 0) { circle(r=ry, $fn=sides); } } } else { yscale(ry/rx) { zrot(realign? 180/sides : 0) { circle(r=rx, $fn=sides); } } } children(); } } function oval(r, d, realign=false, circum=false, anchor=CENTER, spin=0) = let( r = get_radius(r=r, d=d, dflt=1), sides = segs(max(r)), offset = realign? 180/sides : 0, sc = circum? (1 / cos(180/sides)) : 1, rx = default(r[0],r) * sc, ry = default(r[1],r) * sc, pts = [for (i=[0:1:sides-1]) let(a=360-offset-i*360/sides) [rx*cos(a), ry*sin(a)]] ) reorient(anchor,spin, two_d=true, r=[rx,ry], p=pts); // Section: 2D N-Gons // Function&Module: regular_ngon() // Usage: // regular_ngon(n, r|d|or|od, [realign]); // regular_ngon(n, ir|id, [realign]); // regular_ngon(n, side, [realign]); // Description: // When called as a function, returns a 2D path for a regular N-sided polygon. // When called as a module, creates a 2D regular N-sided polygon. // Arguments: // n = The number of sides. // or = Outside radius, at points. // r = Same as or // od = Outside diameter, at points. // d = Same as od // ir = Inside radius, at center of sides. // id = Inside diameter, at center of sides. // side = Length of each side. // rounding = Radius of rounding for the tips of the polygon. Default: 0 (no rounding) // realign = If false, a tip is aligned with the Y+ axis. If true, the midpoint of a side is aligned with the Y+ axis. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Extra Anchors: // "tip0", "tip1", etc. = Each tip has an anchor, pointing outwards. // "side0", "side1", etc. = The center of each side has an anchor, pointing outwards. // Example(2D): by Outer Size // regular_ngon(n=5, or=30); // regular_ngon(n=5, od=60); // Example(2D): by Inner Size // regular_ngon(n=5, ir=30); // regular_ngon(n=5, id=60); // Example(2D): by Side Length // regular_ngon(n=8, side=20); // Example(2D): Realigned // regular_ngon(n=8, side=20, realign=true); // Example(2D): Rounded // regular_ngon(n=5, od=100, rounding=20, $fn=20); // Example(2D): Called as Function // stroke(closed=true, regular_ngon(n=6, or=30)); function regular_ngon(n=6, r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) = let( sc = 1/cos(180/n), r = get_radius(r1=ir*sc, r2=or, r=r, d1=id*sc, d2=od, d=d, dflt=side/2/sin(180/n)) ) assert(!is_undef(r), "regular_ngon(): need to specify one of r, d, or, od, ir, id, side.") let( inset = opp_ang_to_hyp(rounding, (180-360/n)/2), path = rounding==0? oval(r=r, realign=realign, $fn=n) : ( let( steps = floor(segs(r)/n), step = 360/n/steps, path2 = [ for (i = [0:1:n-1]) let( a = 360 - i*360/n - (realign? 180/n : 0), p = polar_to_xy(r-inset, a) ) each arc(N=steps, cp=p, r=rounding, start=a+180/n, angle=-360/n) ], maxx_idx = max_index(subindex(path2,0)), path3 = polygon_shift(path2,maxx_idx) ) path3 ), anchors = !is_string(anchor)? [] : [ for (i = [0:1:n-1]) let( a1 = 360 - i*360/n - (realign? 180/n : 0), a2 = a1 - 360/n, p1 = polar_to_xy(r,a1), p2 = polar_to_xy(r,a2), tipp = polar_to_xy(r-inset+rounding,a1), pos = (p1+p2)/2 ) each [ anchorpt(str("tip",i), tipp, unit(tipp,BACK), 0), anchorpt(str("side",i), pos, unit(pos,BACK), 0), ] ] ) reorient(anchor,spin, two_d=true, path=path, extent=false, p=path, anchors=anchors); module regular_ngon(n=6, r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) { sc = 1/cos(180/n); r = get_radius(r1=ir*sc, r2=or, r=r, d1=id*sc, d2=od, d=d, dflt=side/2/sin(180/n)); assert(!is_undef(r), "regular_ngon(): need to specify one of r, d, or, od, ir, id, side."); path = regular_ngon(n=n, r=r, rounding=rounding, realign=realign); inset = opp_ang_to_hyp(rounding, (180-360/n)/2); anchors = [ for (i = [0:1:n-1]) let( a1 = 360 - i*360/n - (realign? 180/n : 0), a2 = a1 - 360/n, p1 = polar_to_xy(r,a1), p2 = polar_to_xy(r,a2), tipp = polar_to_xy(r-inset+rounding,a1), pos = (p1+p2)/2 ) each [ anchorpt(str("tip",i), tipp, unit(tipp,BACK), 0), anchorpt(str("side",i), pos, unit(pos,BACK), 0), ] ]; attachable(anchor,spin, two_d=true, path=path, extent=false, anchors=anchors) { polygon(path); children(); } } // Function&Module: pentagon() // Usage: // pentagon(or|od, [realign]); // pentagon(ir|id, [realign]); // pentagon(side, [realign]); // Description: // When called as a function, returns a 2D path for a regular pentagon. // When called as a module, creates a 2D regular pentagon. // Arguments: // or = Outside radius, at points. // r = Same as or. // od = Outside diameter, at points. // d = Same as od. // ir = Inside radius, at center of sides. // id = Inside diameter, at center of sides. // side = Length of each side. // rounding = Radius of rounding for the tips of the polygon. Default: 0 (no rounding) // realign = If false, a tip is aligned with the Y+ axis. If true, the midpoint of a side is aligned with the Y+ axis. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Extra Anchors: // "tip0" ... "tip4" = Each tip has an anchor, pointing outwards. // "side0" ... "side4" = The center of each side has an anchor, pointing outwards. // Example(2D): by Outer Size // pentagon(or=30); // pentagon(od=60); // Example(2D): by Inner Size // pentagon(ir=30); // pentagon(id=60); // Example(2D): by Side Length // pentagon(side=20); // Example(2D): Realigned // pentagon(side=20, realign=true); // Example(2D): Rounded // pentagon(od=100, rounding=20, $fn=20); // Example(2D): Called as Function // stroke(closed=true, pentagon(or=30)); function pentagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) = regular_ngon(n=5, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin); module pentagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) regular_ngon(n=5, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin) children(); // Function&Module: hexagon() // Usage: // hexagon(or, od, ir, id, side); // Description: // When called as a function, returns a 2D path for a regular hexagon. // When called as a module, creates a 2D regular hexagon. // Arguments: // or = Outside radius, at points. // r = Same as or // od = Outside diameter, at points. // d = Same as od // ir = Inside radius, at center of sides. // id = Inside diameter, at center of sides. // side = Length of each side. // rounding = Radius of rounding for the tips of the polygon. Default: 0 (no rounding) // realign = If false, a tip is aligned with the Y+ axis. If true, the midpoint of a side is aligned with the Y+ axis. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Extra Anchors: // "tip0" ... "tip5" = Each tip has an anchor, pointing outwards. // "side0" ... "side5" = The center of each side has an anchor, pointing outwards. // Example(2D): by Outer Size // hexagon(or=30); // hexagon(od=60); // Example(2D): by Inner Size // hexagon(ir=30); // hexagon(id=60); // Example(2D): by Side Length // hexagon(side=20); // Example(2D): Realigned // hexagon(side=20, realign=true); // Example(2D): Rounded // hexagon(od=100, rounding=20, $fn=20); // Example(2D): Called as Function // stroke(closed=true, hexagon(or=30)); function hexagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) = regular_ngon(n=6, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin); module hexagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) regular_ngon(n=6, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin) children(); // Function&Module: octagon() // Usage: // octagon(or, od, ir, id, side); // Description: // When called as a function, returns a 2D path for a regular octagon. // When called as a module, creates a 2D regular octagon. // Arguments: // or = Outside radius, at points. // r = Same as or // od = Outside diameter, at points. // d = Same as od // ir = Inside radius, at center of sides. // id = Inside diameter, at center of sides. // side = Length of each side. // rounding = Radius of rounding for the tips of the polygon. Default: 0 (no rounding) // realign = If false, a tip is aligned with the Y+ axis. If true, the midpoint of a side is aligned with the Y+ axis. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Extra Anchors: // "tip0" ... "tip7" = Each tip has an anchor, pointing outwards. // "side0" ... "side7" = The center of each side has an anchor, pointing outwards. // Example(2D): by Outer Size // octagon(or=30); // octagon(od=60); // Example(2D): by Inner Size // octagon(ir=30); // octagon(id=60); // Example(2D): by Side Length // octagon(side=20); // Example(2D): Realigned // octagon(side=20, realign=true); // Example(2D): Rounded // octagon(od=100, rounding=20, $fn=20); // Example(2D): Called as Function // stroke(closed=true, octagon(or=30)); function octagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) = regular_ngon(n=8, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin); module octagon(r, d, or, od, ir, id, side, rounding=0, realign=false, anchor=CENTER, spin=0) regular_ngon(n=8, r=r, d=d, or=or, od=od, ir=ir, id=id, side=side, rounding=rounding, realign=realign, anchor=anchor, spin=spin) children(); // Section: Other 2D Shapes // Function&Module: trapezoid() // Usage: // trapezoid(h, w1, w2); // Description: // When called as a function, returns a 2D path for a trapezoid with parallel front and back sides. // When called as a module, creates a 2D trapezoid with parallel front and back sides. // Arguments: // h = The Y axis height of the trapezoid. // w1 = The X axis width of the front end of the trapezoid. // w2 = The X axis width of the back end of the trapezoid. // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Examples(2D): // trapezoid(h=30, w1=40, w2=20); // trapezoid(h=25, w1=20, w2=35); // trapezoid(h=20, w1=40, w2=0); // Example(2D): Called as Function // stroke(closed=true, trapezoid(h=30, w1=40, w2=20)); function trapezoid(h, w1, w2, anchor=CENTER, spin=0) = let( path = [[w1/2,-h/2], [-w1/2,-h/2], [-w2/2,h/2], [w2/2,h/2]] ) reorient(anchor,spin, two_d=true, size=[w1,h], size2=w2, p=path); module trapezoid(h, w1, w2, anchor=CENTER, spin=0) { path = [[w1/2,-h/2], [-w1/2,-h/2], [-w2/2,h/2], [w2/2,h/2]]; attachable(anchor,spin, two_d=true, size=[w1,h], size2=w2) { polygon(path); children(); } } // Function&Module: teardrop2d() // // Description: // Makes a 2D teardrop shape. Useful for extruding into 3D printable holes. // // Usage: // teardrop2d(r|d, [ang], [cap_h]); // // Arguments: // r = radius of circular part of teardrop. (Default: 1) // d = diameter of spherical portion of bottom. (Use instead of r) // ang = angle of hat walls from the Y axis. (Default: 45 degrees) // cap_h = if given, height above center where the shape will be truncated. // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // // Example(2D): Typical Shape // teardrop2d(r=30, ang=30); // Example(2D): Crop Cap // teardrop2d(r=30, ang=30, cap_h=40); // Example(2D): Close Crop // teardrop2d(r=30, ang=30, cap_h=20); module teardrop2d(r, d, ang=45, cap_h, anchor=CENTER, spin=0) { path = teardrop2d(r=r, d=d, ang=ang, cap_h=cap_h); attachable(anchor,spin, two_d=true, path=path) { polygon(path); children(); } } function teardrop2d(r, d, ang=45, cap_h, anchor=CENTER, spin=0) = let( r = get_radius(r=r, d=d, dflt=1), cord = 2 * r * cos(ang), cord_h = r * sin(ang), tip_y = (cord/2)/tan(ang), cap_h = min((!is_undef(cap_h)? cap_h : tip_y+cord_h), tip_y+cord_h), cap_w = cord * (1 - (cap_h - cord_h)/tip_y), ang = min(ang,asin(cap_h/r)), sa = 180 - ang, ea = 360 + ang, steps = segs(r)*(ea-sa)/360, step = (ea-sa)/steps, path = deduplicate( [ [ cap_w/2,cap_h], for (i=[0:1:steps]) let(a=ea-i*step) r*[cos(a),sin(a)], [-cap_w/2,cap_h] ], closed=true ), maxx_idx = max_index(subindex(path,0)), path2 = polygon_shift(path,maxx_idx) ) reorient(anchor,spin, two_d=true, path=path2, p=path2); // Function&Module: glued_circles() // Usage: // glued_circles(r|d, spread, tangent); // Description: // When called as a function, returns a 2D path forming a shape of two circles joined by curved waist. // When called as a module, creates a 2D shape of two circles joined by curved waist. // Arguments: // r = The radius of the end circles. // d = The diameter of the end circles. // spread = The distance between the centers of the end circles. // tangent = The angle in degrees of the tangent point for the joining arcs, measured away from the Y axis. // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Examples(2D): // glued_circles(r=15, spread=40, tangent=45); // glued_circles(d=30, spread=30, tangent=30); // glued_circles(d=30, spread=30, tangent=15); // glued_circles(d=30, spread=30, tangent=-30); // Example(2D): Called as Function // stroke(closed=true, glued_circles(r=15, spread=40, tangent=45)); function glued_circles(r, d, spread=10, tangent=30, anchor=CENTER, spin=0) = let( r = get_radius(r=r, d=d, dflt=10), r2 = (spread/2 / sin(tangent)) - r, cp1 = [spread/2, 0], cp2 = [0, (r+r2)*cos(tangent)], sa1 = 90-tangent, ea1 = 270+tangent, lobearc = ea1-sa1, lobesegs = floor(segs(r)*lobearc/360), lobestep = lobearc / lobesegs, sa2 = 270-tangent, ea2 = 270+tangent, subarc = ea2-sa2, arcsegs = ceil(segs(r2)*abs(subarc)/360), arcstep = subarc / arcsegs, path = concat( [for (i=[0:1:lobesegs]) let(a=sa1+i*lobestep) r * [cos(a),sin(a)] - cp1], tangent==0? [] : [for (i=[0:1:arcsegs]) let(a=ea2-i*arcstep+180) r2 * [cos(a),sin(a)] - cp2], [for (i=[0:1:lobesegs]) let(a=sa1+i*lobestep+180) r * [cos(a),sin(a)] + cp1], tangent==0? [] : [for (i=[0:1:arcsegs]) let(a=ea2-i*arcstep) r2 * [cos(a),sin(a)] + cp2] ), maxx_idx = max_index(subindex(path,0)), path2 = reverse_polygon(polygon_shift(path,maxx_idx)) ) reorient(anchor,spin, two_d=true, path=path2, extent=true, p=path2); module glued_circles(r, d, spread=10, tangent=30, anchor=CENTER, spin=0) { path = glued_circles(r=r, d=d, spread=spread, tangent=tangent); attachable(anchor,spin, two_d=true, path=path, extent=true) { polygon(path); children(); } } // Function&Module: star() // Usage: // star(n, r|d|or|od, ir|id|step, [realign]); // Description: // When called as a function, returns the path needed to create a star polygon with N points. // When called as a module, creates a star polygon with N points. // Arguments: // n = The number of stellate tips on the star. // r = The radius to the tips of the star. // or = Same as r // d = The diameter to the tips of the star. // od = Same as d // ir = The radius to the inner corners of the star. // id = The diameter to the inner corners of the star. // step = Calculates the radius of the inner star corners by virtually drawing a straight line `step` tips around the star. 2 <= step < n/2 // realign = If false, a tip is aligned with the Y+ axis. If true, an inner corner is aligned with the Y+ axis. Default: false // anchor = Translate so anchor point is at origin (0,0,0). See [anchor](attachments.scad#anchor). Default: `CENTER` // spin = Rotate this many degrees around the Z axis after anchor. See [spin](attachments.scad#spin). Default: `0` // Extra Anchors: // "tip0" ... "tip4" = Each tip has an anchor, pointing outwards. // "corner0" ... "corner4" = The inside corner between each tip has an anchor, pointing outwards. // "midpt0" ... "midpt4" = The center-point between each pair or tips has an anchor, pointing outwards. // Examples(2D): // star(n=5, r=50, ir=25); // star(n=5, r=50, step=2); // star(n=7, r=50, step=2); // star(n=7, r=50, step=3); // Example(2D): Realigned // star(n=7, r=50, step=3, realign=true); // Example(2D): Called as Function // stroke(closed=true, star(n=5, r=50, ir=25)); function star(n, r, d, or, od, ir, id, step, realign=false, anchor=CENTER, spin=0) = let( r = get_radius(r1=or, d1=od, r=r, d=d), count = num_defined([ir,id,step]), stepOK = is_undef(step) || (step>1 && step0 && angle<90) assert(is_num(excess)) let( r = get_radius(r=r, d=d, dflt=1), n = ceil(segs(r) * angle/360), cp = [r,r], tp = cp + polar_to_xy(r,180+angle), bp = [tp.x+adj_ang_to_opp(tp.y,angle), 0], step = angle/n, path = [ bp, bp-[0,excess], [-excess,-excess], [-excess,r], for (i=[0:1:n]) cp+polar_to_xy(r,180+i*step) ] ) reorient(anchor,spin, two_d=true, path=path, p=path); module mask2d_teardrop(r,d,angle=45,excess=0.1,anchor=CENTER,spin=0) { path = mask2d_teardrop(r=r, d=d, angle=angle, excess=excess); attachable(anchor,spin, two_d=true, path=path) { polygon(path); children(); } } // Function&Module: mask2d_ogee() // Usage: // mask2d_ogee(pattern, [excess]); // // Description: // Creates a 2D Ogee mask shape that is useful for extruding into a 3D mask for a 90º edge. // This 2D mask is designed to be `difference()`d away from the edge of a shape that is in the first (X+Y+) quadrant. // Since there are a number of shapes that fall under the name ogee, the shape of this mask is given as a pattern. // Patterns are given as TYPE, VALUE pairs. ie: `["fillet",10, "xstep",2, "step",[5,5], ...]`. See Patterns below. // If called as a function, this just returns a 2D path of the outline of the mask shape. // // ### Patterns // // Type | Argument | Description // -------- | --------- | ---------------- // "step" | [x,y] | Makes a line to a point `x` right and `y` down. // "xstep" | dist | Makes a `dist` length line towards X+. // "ystep" | dist | Makes a `dist` length line towards Y-. // "round" | radius | Makes an arc that will mask a roundover. // "fillet" | radius | Makes an arc that will mask a fillet. // // Arguments: // pattern = A list of pattern pieces to describe the Ogee. // excess = Extra amount of mask shape to creates on the X- and Y- sides of the shape. // // Example(2D): 2D Ogee Mask // mask2d_ogee([ // "xstep",1, "ystep",1, // Starting shoulder. // "fillet",5, "round",5, // S-curve. // "ystep",1, "xstep",1 // Ending shoulder. // ]); // Example: Masking by Edge Attachment // diff("mask") // cube([50,60,70],center=true) // edge_profile(TOP) // mask2d_ogee([ // "xstep",1, "ystep",1, // Starting shoulder. // "fillet",5, "round",5, // S-curve. // "ystep",1, "xstep",1 // Ending shoulder. // ]); module mask2d_ogee(pattern, excess, anchor=CENTER,spin=0) { path = mask2d_ogee(pattern, excess=excess); attachable(anchor,spin, two_d=true, path=path) { polygon(path); children(); } } function mask2d_ogee(pattern, excess, anchor=CENTER, spin=0) = assert(is_list(pattern)) assert(len(pattern)>0) assert(len(pattern)%2==0,"pattern must be a list of TYPE, VAL pairs.") assert(all([for (i = idx(pattern,step=2)) in_list(pattern[i],["step","xstep","ystep","round","fillet"])])) let( excess = default(excess,$overlap), x = concat([0], cumsum([ for (i=idx(pattern,step=2)) let( type = pattern[i], val = pattern[i+1] ) ( type=="step"? val.x : type=="xstep"? val : type=="round"? val : type=="fillet"? val : 0 ) ])), y = concat([0], cumsum([ for (i=idx(pattern,step=2)) let( type = pattern[i], val = pattern[i+1] ) ( type=="step"? val.y : type=="ystep"? val : type=="round"? val : type=="fillet"? val : 0 ) ])), tot_x = select(x,-1), tot_y = select(y,-1), data = [ for (i=idx(pattern,step=2)) let( type = pattern[i], val = pattern[i+1], pt = [x[i/2], tot_y-y[i/2]] + ( type=="step"? [val.x,-val.y] : type=="xstep"? [val,0] : type=="ystep"? [0,-val] : type=="round"? [val,0] : type=="fillet"? [0,-val] : [0,0] ) ) [type, val, pt] ], path = [ [tot_x,-excess], [-excess,-excess], [-excess,tot_y], for (pat = data) each pat[0]=="step"? [pat[2]] : pat[0]=="xstep"? [pat[2]] : pat[0]=="ystep"? [pat[2]] : let( r = pat[1], steps = segs(abs(r)), step = 90/steps ) [ for (i=[0:1:steps]) let( a = pat[0]=="round"? (180+i*step) : (90-i*step) ) pat[2] + abs(r)*[cos(a),sin(a)] ] ], path2 = deduplicate(path) ) reorient(anchor,spin, two_d=true, path=path2, p=path2); // vim: expandtab tabstop=4 shiftwidth=4 softtabstop=4 nowrap