def __init__(self, data, iterations):
"""
Constructor
:param dict data: JSON data describing the fractal's
L-System
:param int iterations: iteration to generate
"""
if iterations < 0:
raise ValueError("Iterations cannot be negative")
try:
initiator = data['start']
rules = data['rules']
self.system = LSystem(initiator, rules)
self.angle = data['angle']
self.scale = 1.0 / data['divisor']
self.initial_size = data['length']
self.iterations = iterations
except KeyError as e:
raise ValueError("Data JSON missing key {0}".format(e))
pass
elif event.type == sdl2.SDL_MOUSEBUTTONDOWN:
pass
elif event.type == sdl2.SDL_MOUSEBUTTONUP:
pass
#self.draw(renderer,frame_time)
last_frame = current_frame
if len(sys.argv) < 2:
print 'Usage: python %s <input file>'%sys.argv[0]
sys.exit(0)
filename = sys.argv[1]
try:
L = LSystem(filename)
except LSystemParseException:
print 'Error parsing %s'%filename
sys.exit(0)
sdl2.ext.init()
window = sdl2.ext.Window("CSC 205 A3", size=(A3Canvas.CANVAS_SIZE_X, A3Canvas.CANVAS_SIZE_Y))
window.show()
renderer = sdl2.SDL_CreateRenderer(window.window, -1,0, sdl2.SDL_RENDERER_PRESENTVSYNC | sdl2.SDL_RENDERER_ACCELERATED);
sdl2.SDL_SetRenderDrawColor(renderer, 0, 255, 0, 255)
sdl2.SDL_RenderClear(renderer)
sdl2.SDL_RenderPresent(renderer)
from LSystem import LSystem
rule1 = {"a": 'F', "b": 'FF'}
rule2 = {"a": 'L', "b": 'F[L]L'}
system = LSystem(axiom='L',
rules=[rule1, rule2],
angle=45,
start_pos=(500, 0),
start_ang=90,
iterations=7,
line_len=10,
screen_size=1000)
system.generate()
from LSystem import LSystem
rule1 = {"a": 'F', "b": 'F-G+F+G-F'}
rule2 = {"a": 'G', "b": 'GG'}
sierpinski_triangle = LSystem(axiom='F-G-G',
rules=[rule1, rule2],
angle=120,
start_pos=(0, 0),
start_ang=0,
iterations=5,
line_len=50,
screen_size=1000)
sierpinski_triangle.generate()
from LSystem import LSystem
rule1 = {"a": 'F', "b": 'FF'}
rule2 = {"a": 'X', "b": '+F+F[+Y]-F[+X+F+X]-F-FF[-Y][+X]FF'}
rule3 = {"a": 'Y', "b": 'X'}
system = LSystem(axiom='X',
rules=[rule1, rule2, rule3],
angle=15,
start_pos=(750, 0),
start_ang=130,
iterations=12,
line_len=2,
screen_size=2500)
system.generate()
import sys
sys.path.insert(0, './LindenmayerSystem')
sys.path.insert(1, '.')
from LSystem import LSystem
if __name__ == '__main__':
rules_dict = {'F': 'F-F++F-F'}
start_string = 'F'
measures_dict = {'length': 2, 'angle': 60}
fn_dict = {
'F': lambda turtle1: turtle1.forward(measures_dict['length']),
'B': lambda turtle1: turtle1.backward(measures_dict['length']),
'-': lambda turtle1: turtle1.left(measures_dict['angle']),
'+': lambda turtle1: turtle1.right(measures_dict['angle']),
}
ls = LSystem(start_string=start_string,
rules_dict=rules_dict,
iterations=4,
fn_dict=fn_dict)
ls.display()
ls.end_this()
from LSystem import LSystem
rule1 = {"a": 'F', "b": '+F--F+'}
system = LSystem(axiom='F+F+F+F+F+F+F+F',
rules=[rule1],
angle=45,
start_pos=(750, 1800),
start_ang=0,
iterations=13,
line_len=8,
screen_size=2000)
system.generate()
from LSystem import LSystem
rule1 = {"a": 'X', "b": 'X+YF+'}
rule2 = {"a": 'Y', "b": '-FX-Y'}
dragon_curve = LSystem(axiom='FX',
rules=[rule1, rule2],
angle=90,
start_pos=(500, 500),
start_ang=90,
iterations=15,
line_len=5,
screen_size=1000)
dragon_curve.generate()
class TurtleCommands(object):
"""
Generate Turtle commands for any TurtleMachine
from an LSystem.
"""
def __init__(self, data, iterations):
"""
Constructor
:param dict data: JSON data describing the fractal's
L-System
:param int iterations: iteration to generate
"""
if iterations < 0:
raise ValueError("Iterations cannot be negative")
try:
initiator = data['start']
rules = data['rules']
self.system = LSystem(initiator, rules)
self.angle = data['angle']
self.scale = 1.0 / data['divisor']
self.initial_size = data['length']
self.iterations = iterations
except KeyError as e:
raise ValueError("Data JSON missing key {0}".format(e))
def __iter__(self):
"""
Generate turtle commands from the underlying
L-System.
:rtype: generator of str
:returns: generator of turtle command strings
in the form:
OPCODE param1 param2 ...
"""
size = self.initial_size * self.scale ** self.iterations
steps = self.system.nth(self.iterations)
for command in self.generate_commands(steps, self.angle, size):
yield command
def generate_commands(self, steps, angle, size):
"""
Take an iteration of an LSystem and generate
corresponding turtle commands
:param str steps: Iteration string from the L-System.
:param float angle: Angle for every turn left/right command.
:param float size: Length of path for forward commands.
:rtype: generator of str
:returns: generator of turtle command strings
in the form:
OPCODE param1 param2 ...
"""
for step in steps:
if step in ["F", "A", "B"]:
yield "FORWARD {0}".format(size)
elif step == "+":
yield "RIGHT {0}".format(angle)
elif step == "-":
yield "LEFT {0}".format(angle)
else:
pass
from LSystem import LSystem
Algae = LSystem(variables = "A B".split(), constants =[], axiom="A", rules={"A": "AB", "B":"A"})
FractalTree = LSystem(variables = "0 1".split(), constants ="[ ]".split(), axiom="0", rules={"1": "11", "0":"1[0]0"})
CantorSet = LSystem(variables="A B".split(), constants=[], axiom = "A", rules={"A":"ABA", "B":"BBB"})
KochCurve = LSystem(variables="F".split(), constants="+ -".split(), axiom = "F", rules={"F":"F+F−F−F+F"})
with open('Lsystems.txt') as text:
for line in text:
stringList = re.split(',|\n', line)
axiom = stringList[1]
angle = math.radians(int(stringList[2]))
length = int(stringList[3])
x, y = int(stringList[4]), int(stringList[5])
rulesList = stringList[6].split()
rules = []
for rule in rulesList:
rules.append({
'in': rule.split('->')[0],
'out': rule.split('->')[1]
})
systems.append(LSystem(axiom, rules, x, y, length, angle))
curr = systems[4]
pygame.init()
screen = pygame.display.set_mode([500, 500])
first = True
running = True
while running:
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
if event.type == pygame.MOUSEBUTTONDOWN:
screen.fill((255, 255, 255))
curr.draw(screen)
