Beyond Trees: Exploring Abstract Geometry with L-Systems in p5.js

 let distance = 20;
 let angle = radians(90);

 let distance = 20;
 let angle = radians(120);

/** 
 * L-system tester.
 * ref. https://gin-graphic.hatenablog.com/entry/2022/12/20/000000
 * 
 * @author @deconbatch
 * @version 0.1
 * @license GPL3
 * p5.js 1.5.0
 * created 2022.12.31
 */

const initProduction = '+F[+F]F';
const maxRepeat = 10;
const maxAngle = 180;
const w = 800;
const h = w;

let repeatNum = 2;
let rotateAngle = 15;

/** 
 * keyPressed : change parameters then re-draw.
 */
function keyPressed() {
  if (keyCode == UP_ARROW) {
    repeatNum++;
  } else if (keyCode == DOWN_ARROW) {
    repeatNum--;
  } else if (keyCode == RIGHT_ARROW) {
    rotateAngle += 15;
  } else if (keyCode == LEFT_ARROW) {
    rotateAngle -= 15;
  }
  repeatNum = constrain(repeatNum, 1, maxRepeat);
  rotateAngle = constrain(rotateAngle, -maxAngle, maxAngle);

  redraw();
}

/** 
 * setup : world famous setup function.
 */
function setup() {
  createCanvas(w, h)
  angleMode(DEGREES);
  noLoop();
  noFill();
  stroke(0);
}

/** 
 * draw : generate the production then draw it.
 */
function draw() {
  // generate the production
  const production = genProduction(initProduction, repeatNum);
  // fit size and position with canvas
  const fit = fitting(production, rotateAngle);
  // draw
  background(240);
  push();
  translate(fit.x, fit.y);
  strokeWeight(3 / repeatNum);
  drawShape(production, rotateAngle, fit.z);
  pop();
  drawParams(initProduction, repeatNum, rotateAngle, fit.z);
}

/** 
 * genProduction : generate the production
 */
function genProduction(_baseP, _num) {
  let word = 'F';
  for (let i = 0; i < _num; i++) {
    let replaced = word.replace(/F/g, _baseP);
    word = replaced;
  }
  return word;
}

/** 
 * fitting : calculate the size and position to fit to the canvas
 */
function fitting(_prd, _angle) {
  let len = 10; // size
  let cX = 0;   // center x
  let cY = 0;   // center y

  let minX = width;
  let minY = height;
  let maxX = 0;
  let maxY = 0;
  let x = 0;
  let y = 0;
  let a = 0;
  const saveX = [];
  const saveY = [];
  const saveA = [];
  for (let c of _prd) {
    switch (c) {
    case "F":
      x += len * sin(a);
      y += len * cos(a);
      break;
    case "+":
      a += _angle;
      break;
    case "-":
      a -= _angle;
      break;
    case "[":
      saveX.push(x);
      saveY.push(y);
      saveA.push(a);
      break;
    case "]":
      x = saveX.pop();
      y = saveY.pop();
      a = saveA.pop();
      break;
    default:
      break;
    }
    minX = min(minX, x);
    minY = min(minY, y);
    maxX = max(maxX, x);
    maxY = max(maxY, y);
  }

  const rate = max((maxX - minX) / width, (maxY - minY) / height) * 1.5;
  if (rate != 0) {
    len /= rate;
    const rminX = minX / rate;
    const rminY = minY / rate;
    const rmaxX = maxX / rate;
    const rmaxY = maxY / rate;
    cX = width * 0.5 - (rminX + (rmaxX - rminX) * 0.5);
    cY = height * 0.5 - (rminY + (rmaxY - rminY) * 0.5);
  }

  return createVector(cX, cY, len);
}

/** 
 * drawShape : draw the shape
 */
function drawShape(_prd, _angle, _len) {
  for (let c of _prd) {
    switch (c) {
    case "F":
      line(0, 0, 0, _len);
      translate(0, _len);
      break;
    case "+":
      rotate(-_angle);
      break;
    case "-":
      rotate(+_angle);
      break;
    case "[":
      push();
      break;
    case "]":
      pop();
      break;
    default:
      break;
    }
  }
}

/** 
 * drawParams : draw parameters
 */
function drawParams(_f, _n, _a, _l) {
  const siz = 12;
  push();
  noStroke();
  fill(0);
  textSize(siz);
  textAlign(LEFT, CENTER);
  textFont('monospace');
  text('PRODUCTION:' + _f, 10, siz);
  text('    REPEAT:' + _n, 10, siz * 2);
  text('     ANGLE:' + _a, 10, siz * 3);
  text('    LENGTH:' + _l, 10, siz * 4);
  pop();
}

/*
Copyright (C) 2022- deconbatch

This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>
*/