2.4 preview

examples/lsystem2_collection.scad

@@ -0,0 +1,320 @@
+use <turtle/lsystem2.scad>;
+use <line2d.scad>;
+
+for(line = fern()) {
+    line2d(
+        line[0],
+        line[1],
+        .2,
+        p1Style = "CAP_ROUND", 
+        p2Style =  "CAP_ROUND"
+    );
+}
+
+function fern(n = 8, angle = 4, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "EEEA",
+        rules = [
+            ["A", "[++++++++++++++EC]B+B[--------------ED]B+BA"],
+            ["C", "[---------EE][+++++++++EE]B+C"],
+            ["D", "[---------EE][+++++++++EE]B-D"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, forward_chars = "ABCDE");  
+
+function tree(n = 2, angle = 36, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F[+FF][-FF]F[-F][+F]F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function plant(n = 4, angle = 25, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "X",
+        rules = [
+            ["X", "F+[[X]-X]-F[-FX]+X"],
+            ["F", "FF"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_curve(n = 4, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F-F++F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_curve_3(n = 3, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-F-F-F",
+        rules = [
+            ["F", "FF-F+F-F-FF"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_snowflake(n = 4, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F++F++F",
+        rules = [
+            ["F", "F-F++F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_quadratic(n = 3, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-F-F-F",
+        rules = [
+            ["F", "FF-F-F-F-F-F+F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_quadratic_type1(n = 4, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F-F+F+F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_quadratic_type2(n = 4, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F-F+F+FF-F-F+F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function koch_star(n = 4, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F++F++F",
+        rules = [
+            ["F", "F+F--F+F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, "6789");   
+
+function dragon_curve(n = 10, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "FX",
+        rules = [
+            ["X", "X+YF+"],
+            ["Y", "-FX-Y"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);
+
+function twin_dragon_curve(n = 8, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "FX+FX+",
+        rules = [
+            ["X", "X+YF"],
+            ["Y", "Y=FX-Y"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);    
+
+function hilbert_curve(n = 5, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "A",
+        rules = [
+            ["A", "-BF+AFA+FB-"],
+            ["B", "+AF-BFB-FA+"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);    
+
+function moore_curve(n = 4, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "LFL+F+LFL",
+        rules = [
+            ["L", "-RF+LFL+FR-"],
+            ["R", "+LF-RFR-FL+"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);      
+
+function peano_curve(n = 3, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "L",
+        rules = [
+            ["L", "LFRFL-F-RFLFR+F+LFRFL"],
+            ["R", "RFLFR+F+LFRFL-F-RFLFR"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);       
+
+function gosper_curve(n = 4, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "A",
+        rules = [
+            ["A", "A-B--B+A++AA+B-"],
+            ["B", "+A-BB--B-A++A+B"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, "AB");    
+
+function gosper_star(n = 2, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "X-X-X-X-X-X",
+        rules = [
+            ["X", "FX+YF++YF-FX--FXFX-YF+"],
+            ["Y", "-FX+YFYF++YF+FX--FX-FY"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);    
+
+function levy_c_curve(n = 8, angle = 45, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "+F--F+"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);       
+
+function island_curve(n = 2, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-F-F-F",
+        rules = [
+            ["F", "F-f+FF-F-FF-Ff-FF+f-FF+F+FF+Ff+FFF"],
+            ["f", "ffffff"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);  
+
+function sierpinski_triangle(n = 5, angle = 120, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-G-G",
+        rules = [
+            ["F", "F-G+F+G-F"],
+            ["G", "GG"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, "FG");  
+
+function sierpinski_arrowhead(n = 6, angle = 60, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "XF",
+        rules = [
+            ["X", "YF+XF+Y"],
+            ["Y", "XF-YF-X"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);     
+
+function sierpinski_square(n = 8, angle = 45, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "L--F--L--F",
+        rules = [
+            ["L", "+R-F-R+"],
+            ["R", "-L+F+L-"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);      
+
+function sierpinski_carpet(n = 4, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F+F-F-F-G+F+F+F-F"],
+            ["G", "GGG"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, forward_chars = "G");          
+
+function terdragon(n = 5, angle = 120, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F+F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);    
+
+function pentadendrite(n = 2, angle = 72, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-F-F-F-F",
+        rules = [
+            ["F", "F-F-F++F+F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);    
+
+function icy(n = 2, angle = 90, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F+F+F+F",
+        rules = [
+            ["F", "FF+F++F+F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);        
+
+function round_star(n = 3, angle = 77, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "F++F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);   
+
+function penrose_tiling(n = 2, angle = 36, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "[7]++[7]++[7]++[7]++[7]",
+        rules = [
+            ["6", "81++91----71[-81----61]++"],
+            ["7", "+81--91[---61--71]+"],
+            ["8", "-61++71[+++81++91]-"],
+            ["9", "--81++++61[+91++++71]--71"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start, "6789");       
+
+function bush(n = 3, angle = 16, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "++++F",
+        rules = [
+            ["F", "FF-[-F+F+F]+[+F-F-F]"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);       
+
+function pentigree(n = 3, angle = 72, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F-F-F-F-F",
+        rules = [
+            ["F", "F-F++F+F-F-F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);         
+
+function penrose_snowflake(n = 3, angle = 18, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F----F----F----F----F",
+        rules = [
+            ["F", "F----F----F----------F++F----F"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);         
+
+function weed(n = 6, angle = 22.5, leng = 1, heading = 0, start = [0, 0]) = 
+    let(
+        axiom = "F",
+        rules = [
+            ["F", "FF-[XY]+[XY]"],
+            ["X", "+FY"],
+            ["Y", "-FX"]
+        ]
+    )
+    lsystem2(axiom, rules, n, angle, leng, heading, start);

examples/lsystem3_collection.scad

@@ -1,4 +1,4 @@
-use <experimental/lsystem3.scad>;
+use <turtle/lsystem3.scad>;
 use <hull_polyline3d.scad>;
 
 for(line = hilbert_curve()) {

src/experimental/note.md

@@ -6,4 +6,6 @@ to_do:
 2.4 preview:
 - intersection_p
 - util/sum
-- matrix/m_determinant
+- matrix/m_determinant
+- turtle/lsystem2
+- turtle/lsystem3

src/turtle/_impl/_lsystem2_impl.scad

@@ -1,5 +1,5 @@
-use <experimental/_impl/_lsystem_comm.scad>;
+use <_lsystem_comm.scad>;
-use <turtle/turtle2d.scad>;
+use <../turtle2d.scad>;
 
 function _lsystem2_join(str_lt) = _join(str_lt);
 

src/turtle/_impl/_lsystem3_impl.scad

@@ -1,5 +1,5 @@
-use <experimental/_impl/_lsystem_comm.scad>;
+use <_lsystem_comm.scad>;
-use <turtle/turtle3d.scad>;
+use <../turtle3d.scad>;
 
 function _lsystem3_join(str_lt) = _join(str_lt);
 

src/turtle/_impl/_lsystem_comm.scad

@@ -1,5 +1,8 @@
-use <experimental/assoc_lookup.scad>;
+use <../../util/rand.scad>;
-use <util/rand.scad>;
+
+function assoc_lookup(array, key) = 
+    let(idx = search([key], array)[0])
+    array[idx][1];
 
 // It doesn't use recursion to avoid recursion error. 
 function _join(str_lt) = 

src/turtle/lsystem2.scad

@@ -1,5 +1,5 @@
-use <experimental/_impl/_lsystem2_impl.scad>;
+use <_impl/_lsystem2_impl.scad>;
-use <turtle/turtle2d.scad>;
+use <turtle2d.scad>;
 
 /*
 

src/turtle/lsystem3.scad

@@ -1,5 +1,5 @@
-use <experimental/_impl/_lsystem3_impl.scad>;
+use <_impl/_lsystem3_impl.scad>;
-use <turtle/turtle3d.scad>;
+use <turtle3d.scad>;
 
 /*