#!/usr/bin/env python
'''
Copyright (C) 2005 Aaron Spike, aaron@ekips.org

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 2 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, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
'''
import inkex, simplestyle, random
from inkex import turtle as pturtle

def stripme(s):
    return s.strip()

class LSystem(inkex.GenerateExtension):
    def add_arguments(self,pars):
        pars.add_argument("--tab")
        pars.add_argument("--order", type=int, default=3, help="number of iteration")
        pars.add_argument("--langle", type=float, default=16.0, help="angle for turning left")
        pars.add_argument("--rangle", type=float, default=16.0, help="angle for turning right")
        pars.add_argument("--step", type=float, default=25.0, help="step size")
        pars.add_argument("--randomizestep", type=float, default=0.0, help="randomize step")
        pars.add_argument("--randomizeangle", type=float, default=0.0, help="randomize angle")
        pars.add_argument("--axiom", default="++F", help="initial state of system")
        pars.add_argument("--rules", default="F=FF-[-F+F+F]+[+F-F-F]", help="replacement rules")
        pars.add_argument("--factor", type=float,  help="???")
        self.stack = []
        self.turtle = pturtle.pTurtle()

    def iterate(self):
        self.rules = dict([map(stripme, i.split("=")) for i in self.options.rules.upper().split(";") if i.count("=")==1])
        string = self.__recurse(self.options.axiom.upper(),0)
        self.__compose_path(string)
        return self.turtle.getPath()
    def __compose_path(self, string):
        self.turtle.pu()
        point = self.svg.namedview.center
        self.turtle.setpos(point)
        self.turtle.pd()
        for c in string:
            if c in 'ABC':
                self.turtle.pd()
                self.turtle.fd(self.options.step * (random.normalvariate(1.0, 0.01 * self.options.randomizestep)))
            elif c in 'DEF':
                self.turtle.pd()
                self.turtle.fd(self.options.step * self.options.factor * (random.normalvariate(1.0, 0.01 * self.options.randomizestep)))
            elif c in 'GHI':
                self.turtle.pu()
                self.turtle.fd(self.options.step * (random.normalvariate(1.0,  0.01 * self.options.randomizestep)))
            elif c in 'JKL':
                self.turtle.pu()
                self.turtle.fd(self.options.step * self.options.factor * (random.normalvariate(1.0,  0.01 * self.options.randomizestep)))
            elif c == '+':
                self.turtle.lt(self.options.langle * (random.normalvariate(1.0,  0.01 * self.options.randomizeangle)))
            elif c == '-':
                self.turtle.rt(self.options.rangle * (random.normalvariate(1.0,  0.01 * self.options.randomizeangle)))
            elif c == '|':
                self.turtle.lt(180)
            elif c == '[':
                self.stack.append([self.turtle.getpos(), self.turtle.getheading()])
            elif c == ']':
                self.turtle.pu()
                pos,heading = self.stack.pop()
                self.turtle.setpos(pos)
                self.turtle.setheading(heading)

    def __recurse(self,rule,level):
        level_string = ''
        for c in rule:
            if level < self.options.order:
                try:
                    level_string = level_string + self.__recurse(self.rules[c],level+1)
                except KeyError:
                    level_string = level_string + c
            else:
                level_string = level_string + c
        return level_string

    def generate(self):
        self.options.step = self.svg.unittouu(str(self.options.step) + 'px')
        sty = {'stroke-linejoin': 'miter', 'stroke-width': str(self.svg.unittouu('1px')),
             'stroke-opacity': '1.0', 'fill-opacity': '1.0',
             'stroke': '#000000', 'stroke-linecap': 'butt',
             'fill': 'none'}
        return inkex.PathElement(style=str(inkex.Style(sty)), d=self.iterate())

if __name__ == '__main__':
    LSystem().run()

# vim: expandtab shiftwidth=4 tabstop=8 softtabstop=4 encoding=utf-8 textwidth=99