Python LSysObj Examples

Example #1

 def kochCurve3(self):
     a = 90
     s = "F-F-F-F"
     i = 4
     r = {'F': "FF-F-F-F-FF"}
     rs = {'F': ["FF-F-F-F-FF", "FF-F-F", "F-F-FF"]}
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #2

 def TwoDTree2(self):
     a = 20
     s = "F"
     i = 5
     r = {'F': "F[+F]F[-F][F]"}
     rs = {'F': ["F[+F]F[-F][F]", "F[+F]F", "F[-F][F]"]}
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #3

 def createCustomRule(self, angle, sentence, num, dict):
     a = angle
     s = sentence
     i = num
     r = dict
     rs = {}
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #4

 def TwoDTree5(self):
     a = 25.7
     s = "X"
     i = 7
     r = {'X': "F[+X][-X]FX", 'F': "FF"}
     rs = {'X': ["F[+X][-X]FX", "F[+X][-X]", "[+X][-X]FX"], 'F': ["FF"]}
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #5

 def pinetree3D(self):
     c = "green"
     a = 37
     s = "ffffA"
     i = 15
     r = {
         "A": "ff[(90)&TP++P++P++P++P]fAB",
         "P": "[(10)^fZ]",
         "Z": "fBZ",
         "B": "[(80)^[f][(70)+[f](100)+[>f]] [(80)-f]]",
         "T": "(20)+T"
     }
     rs = {
         "A": [
             "ff[(90)&TP++P++P++P++P]fAB", "f[(90)&TP++P++P++P++P]fAB",
             "f[(90)&TP++P++P++P++P]fA"
         ],
         "P": ["[(10)^fZ]"],
         "Z": ["fBZ"],
         "B": [
             "[(80)^[f][(70)+[f](100)+[>f]] [(80)-f]]",
             "[[(70)+[f](100)+[>f]] [(80)-f]]", "[[(70)+[f](100)+]]"
         ],
         "T": ["(20)+T"]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs, color=c)

Example #6

 def TwoDTree1(self):
     a = 25.7
     s = "F"
     i = 5
     r = {'F': "F[+F]F[-F]F"}
     rs = {'F': ["F[+F]F[-F]F", "F[+F]F", "F[-F]F"]}
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #7

    def TwoDTree3(self):
        a = 25.7
        s = "F"
        i = 4
        r = {'F': "FF-[-F+F+F]+[+F-F-F]"}
        rs = {'F': ["FF-[-F+F+F]+[+F-F-F]", "FF-[-F+F+F]", "F+[+F-F-F]"]}

        return lSystemObj.LSysObj(a, s, i, r, rs)

Example #8

File: tree.py Project: FlaviaR/Procedural-Trees

def hilbert3D():
    a = 90
    s = "A"
    i = 2
    r = {'A':"B-F+CFC+F-D&F∧D-F+&&CFC+F+B//",\
     'B':"A&F∧CFB∧F∧D∧∧-F-D∧|F∧B|FC∧F∧A//",\
      'C':"|D∧|F∧B-F+C∧F∧A&&FA&F∧C+F+B∧F∧D//",\
       'D':"|CFB-F+B|FA&F∧A&&FB-F+B|FC//"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #9

 def TwoDTree6(self):
     a = 22.5
     s = "X"
     i = 5
     r = {'X': "F-[[X]+X]+F[+FX]-X", 'F': "FF"}
     rs = {
         'X': ["F-[[X]+X]+F[+FX]-X", "F-[[X]+X]", "[[X]+X]+F[+FX]-X"],
         'F': ["FF"]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #10

 def ugly3DTree(self):
     a = 25
     s = "FA"
     i = 8
     r = {'A': "&FFB\\B\\\\\B", 'B': "[&&FF\\\\\\A]"}
     rs = {
         'A': ["&FFB\\B\\\\\B", "&FFB\\", "B\\\\\B"],
         'B': ["[&&FF\\\\\\A]"]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs)

Example #11

 def skeletalTree3D(self):
     c = "brown"
     a = 20
     s = "A"
     i = 10
     r = {"A": "[B]////[B]////[B]", "B": "FF&>FFFAL"}
     rs = {
         "A": ["[B]////[B]////[B]", "[B]///[B]////[B]", "/[B]////[B]"],
         "B": ["FF&>>FFFAL", "FF&>FFFA", "F&>FFFAL"]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs, color=c)

Example #12

    def hilbert3D(self):
        a = 90
        s = "X"
        i = 5
        r = {'X': "-F^//XFX&F+//XFX-F/X-/"}
        rs = {}

        #r = {'A':"B-F+CFC+F-D&F∧D-F+&&CFC+F+B//",\
        #'B':"A&F∧CFB∧F∧D∧∧-F-D∧|F∧B|FC∧F∧A//",\
        #'C':"|D∧|F∧B-F+C∧F∧A&&FA&F∧C+F+B∧F∧D//",\
        #'D':"|CFB-F+B|FA&F∧A&&FB-F+B|FC//"}
        return lSystemObj.LSysObj(a, s, i, r, rs)

Example #13

 def coral3D(self):
     c = "orange red"
     a = 22
     s = "F"
     i = 4
     r = {"F": "FF-[&F^F^F]+[^F&F&F][>^F^F&F]"}
     rs = {
         'F': [
             "FF-[&F^F^F]+[^F&F&F][>^F^F&F]", "FF-[&F^F^F]+",
             "F-[&F^F^F]+[^F&F&F][>^F^F&F]"
         ]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs, color=c)

Example #14

 def birdNest3D(self):
     c = "brown"
     a = 15
     s = "F"
     i = 3
     r = {
         "F": "[-&>G][>++&G]||F[--&<G][+&G]FF-[-F+F+F]-[^>F-F-F&<]",
         "G": "F[+G][-G]F[+G][-G]FG"
     }
     rs = {
         "F": [
             "[-&>G][>++&G]||F[--&<G][+&G]FF-[-F+F+F]-[^>F-F-F&<]",
             "[-&>G][>++&G]||F[--&<G][+&G]FF-[-F+F+F]-",
             "[-&>G]||F[--&<G][+&G]FF-[-F][^>F-F-F&<]"
         ],
         "G": [
             "F[+G][-G]F[+G][-G]FG", "F[-G]F[+G][-G]FG",
             "F[+G][-G]F[+G][-G]G"
         ]
     }
     return lSystemObj.LSysObj(a, s, i, r, rs, color=c)

Example #15

File: tree.py Project: FlaviaR/Procedural-Trees

def fractalPlant2():
    a = 25.7
    s = "X"
    i = 7
    r = {'X': "F[+X][-X]FX", 'F': "FF"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #16

File: tree.py Project: FlaviaR/Procedural-Trees

def fractalPlant1():
    a = 20
    s = "X"
    i = 7
    r = {'X': "F[+X]F[-X]+X", 'F': "FF"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #17

File: tree.py Project: FlaviaR/Procedural-Trees

def TwoDTree3():
    a = 25.7
    s = "F"
    i = 4
    r = {'F': "FF-[-F+F+F]+[+F-F-F]"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #18

File: tree.py Project: FlaviaR/Procedural-Trees

def TwoDTree2():
    a = 20
    s = "F"
    i = 5
    r = {'F': "F[+F]F[-F][F]"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #19

File: tree.py Project: FlaviaR/Procedural-Trees

def TwoDTree1():
    a = 25.7
    s = "F"
    i = 5
    r = {'F': "F[+F]F[-F]F"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #20

File: tree.py Project: FlaviaR/Procedural-Trees

def kochCurve3():
    a = 90
    s = "F-F-F-F"
    i = 4
    r = {'F': "FF-F-F-F-FF"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #21

File: tree.py Project: FlaviaR/Procedural-Trees

def kochCurve1():
    a = 90
    s = "F-F-F-F"
    i = 2
    r = {'F': "F+FF-FF-F-F+F+FF-F-F+F+FF+FF-F"}
    return lSystemObj.LSysObj(a, s, i, r)

Example #22

File: tree.py Project: FlaviaR/Procedural-Trees

def fractalPlant3():
    a = 22.5
    s = "X"
    i = 5
    r = {'X': "F-[[X]+X]+F[+FX]-X", 'F': "FF"}
    return lSystemObj.LSysObj(a, s, i, r)