Since I got the whole L-system thing in my head again and I have always had it at the back of my mind for chain content to drive something, I decided to finally implement it.
Well, it is far from implemented but I have a foundation so that is good.
For a rundown on what a L-system can do this is a good post that covers it all - https://jsantell.com/l-systems/
Biologist Aristid Lindenmayer created Lindenmayer systems, or L-systems, in 1968 as a way of formalizing patterns of bacteria growth. L-systems are a recursive, string-rewriting framework, commonly used today in computer graphics to visualize and simulate organic growth, with applications in plant development, procedural content generation, and fractal-like art.
For the TLDR in my opinion:
An L-system is just a set of instructions to produce an arbitrary image. These can be as simple as "draw line forward, turn left, draw line forward again, turn left and then draw line forward again." That should give you a square.
The L-system is the instructions as stated above and the drawing is known as Turtle Graphics or LOGO
The above instructions of drawing a square for the sake of having a program follow them might look like this:
"F" = Draw line forward
"+" = Turn Right
"-" = Turn Left
Then we say any turn = 90 degrees and we say all lines are fixed to 100 pixels.
So to draw our square we just write "F-F-F-F" and we will get a square that has 100pixel length sides drawn to the left. Now if I say "F+FF+F+FF"
Then I get a rectangle instead.
Obviously, there are many predefined outputs already, and if you get the rules right you can recreate them like the Koch Snowflake
Don't mind the red line, it was driving me nuts to find where this thing started at. So I slapped a red line in.
The First 3 iterations of the above curve looks like this in the L-system notation I guess it would be called:
F-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-FF-FF-F-F-FF-F-F-FF-F-F-FF-FF-FF-F-F-F++F-F
Since these things usually get generated incrementally, as in the program first does a small segment like "Draw Forward, turn right, draw forward." Then it goes and does it again but with a rule that says every time you "draw forward" replace that with this new sequence.
The more times you loop and the more rules you add to replace aspects the more complex these things get to the point people can draw trees, mazes and pretty complex but deterministic shapes.
The thing is though that people get to write these rules quite with a given structure in mind.
At the very least they know what to expect as an input I think. So you don't get too many things going haywire. Although during testing it probably does and I guess it helps to know what you want to achieve.
So just string replacing random letters with instructions might not be the best way to go about it if I have a specific idea of what I expect.
I don't, so it is fine.
It is not all a big hullabaloo though because the rules that decide the instructions for the most part can have a pattern and this should come through in the overall look.
For the image below I kept the simple "F+-" instructions and just changed the angle to 90 degrees instead of the 60 degrees used to create the Koch snowflake.
So the string replace then would swap say all letters: "aeiPpV" for example with "F" (draw line) and all "uDw" for example with "+" (turn right). Do this for all letters and numbers in a piece of text and you have transformed the content into drawing instructions for the Turtle Program.
That means with random swap the text below:
I would not say I have a specific way to find my center. I don't think I know I am off kilter until I am off kilter. The main indicator for me is mainly noise.The world is full of noise and mostly a person can keep it outside, I can drown out irritating voices from downstairs by playing some calming music.
Then would be output like this:
Since the original method does iterations based on rules of replacement that creates a final output string for the drawing part to then use and draw the instructions. A post would skip the iteration step.
A post is technically a completed list of instructions the text replacement part will need to group bits and pieces to add some variety but that will come with different versions of the interpreter.
So the biggest work I think would be to figure out good frequencies of letters for the replacement of instructions and being able to generate random but interesting images based on different rulesets as different styles.
Images are screenshots of my own outputs and of the test replacement tool used - https://www.joydeepdeb.com/tools/find-replace.html