Question

我使用python的乌龟图形创建了一个程序，模拟森林中的树木生长。随机选择3种树型，并随机选择它们的起始坐标和角度。我选择了一些看起来很酷的树木图案，但我遇到的问题是许多树木都是重叠的，所以不像看起来像一片树林，它看起来像一个糟糕的5岁的画。

有没有办法让这个重叠的更少更常见？当你看到一片森林时，一些树木和它们的树叶确实重叠，但它看起来肯定不是这样的：

enter image description here

由于涉及很多随机化，我不知道如何处理这个问题。

这是我的代码：

import turtle
import random

stack = []

#max_it = maximum iterations, word = starting axiom such as 'F', proc_rules are the rules that 
#change the elements of word if it's key is found in dictionary notation, x and y are the 
#coordinates, and turn is the starting angle 

def createWord(max_it, word, proc_rules, x, y, turn):

    turtle.up()
    turtle.home()
    turtle.goto(x, y)
    turtle.right(turn)
    turtle.down()

    t = 0
    while t < max_it:
        word = rewrite(word, proc_rules)
        drawit(word, 5, 20)
        t = t+1


def rewrite(word, proc_rules):

   #rewrite changes the word at each iteration depending on proc_rules

    wordList = list(word)

    for i in range(len(wordList)):
        curChar = wordList[i]
        if curChar in proc_rules:
            wordList[i] = proc_rules[curChar]

    return "".join(wordList)


def drawit(newWord, d, angle):

    #drawit 'draws' the words

    newWordLs = list(newWord)
    for i in range(len(newWordLs)):
        cur_Char = newWordLs[i]
        if cur_Char == 'F':
            turtle.forward(d)
        elif cur_Char == '+':
            turtle.right(angle)
        elif cur_Char == '-':
            turtle.left(angle)
        elif cur_Char == '[':
            state_push()
        elif cur_Char == ']':
            state_pop()


def state_push():

    global stack

    stack.append((turtle.position(), turtle.heading()))


def state_pop():

    global stack

    position, heading = stack.pop()

    turtle.up()
    turtle.goto(position)
    turtle.setheading(heading)
    turtle.down()


def randomStart():

    #x can be anywhere from -300 to 300, all across the canvas
    x = random.randint(-300, 300)

    #these are trees, so we need to constrain the 'root' of each
    # to a fairly narrow range from -320 to -280
    y = random.randint(-320, -280)

    #heading (the angle of the 'stalk') will be constrained 
    #from -80 to -100 (10 degrees either side of straight up)
    heading = random.randint(-100, -80)

    return ((x, y), heading)


def main():

    #define the list for rule sets.
    #each set is iteration range [i_range], the axiom and the rule for making a tree.  
    #the randomizer will select one of these for building.

    rule_sets = []
    rule_sets.append(((3, 5), 'F', {'F':'F[+F][-F]F'}))
    rule_sets.append(((4, 6), 'B', {'B':'F[-B][+ B]', 'F':'FF'}))
    rule_sets.append(((2, 4), 'F', {'F':'FF+[+F-F-F]-[-F+F+F]'}))

    #define the number of trees to build
    tree_count = 50

    #speed up the turtle
    turtle.tracer(10, 0)

    #for each tree...
    for x in range(tree_count):

        #pick a random number between 0 and the length
        #of the rule set -1 - this results in selecting
        #a result randomly from the list of possible rules.

        rand_i = random.randint(0, len(rule_sets) - 1)
        selected_ruleset = rule_sets[rand_i]

        #unpack the tuple stored for this ruleset
        i_range, word, rule = selected_ruleset

        #pick a random number inside the given iteration_range to be the 
        #iteration length for this command list.
        low, high = i_range
        i = random.randint(low, high)

        #get a random starting location and heading for the tree
        start_position, start_heading = randomStart()

        #unpack the x & y coordinates from the position
        start_x, start_y = start_position

        #build the current tree
        createWord(i, word, rule, start_x, start_y, start_heading)

if __name__ == '__main__': main()

Answer 1

根据我对L系统的理解，有一个完整的语法不是随机选择的。你能提供一些关于你的语法如何工作的细节吗？我想你可以通过制作一个从起始角度超过90度的有限的封闭式制作来限制树木成长的方向。

但是你不能完全随机化起始角度...你可能需要在一定范围内随机化它？当然，如果你的L系统只是随机产生一切，它就会像一堆噪音。有一个目的是限制你的初始条件;每个语法都有一个开始符号，你需要利用你的开始符号来生成有意义的东西。我想你希望你的开始符号始终指向。

但是我很长时间没有研究过L系统，所以我的答案很简单。

修改

施加这是一个有趣的限制，因为它听起来像树木自然而然地做的事情。在自然界中，我认为这是因为只有一定量的阳光可以通过一定的地面，所以如果一棵树已经在某处生长，那么其他任何事情都无法生长。

作为一个AI人，我喜欢将现实世界的解决方案变成有趣的启发式方法。我们在这里寻找什么样的启发式？那么，二维坐标系中的“地面补丁”只是一系列x坐标。如果在不断增长的叶子的任意x范围内有太多的东西，也许会有一些东西让增长失去动力？（不是python xrange，而是一系列x坐标，如果你愿意的话，还有一些“delta”值。）

Answer 2

我认为问题更多的是树木本身的特征的规律性，而不是它们本身的位置。

可能的解决方案是添加突变。对于“发育迟缓”的全球控制，您可以抑制5％的生产应用程序。这样可以使松散的树木更加松散地跟随模型。

为了更好地控制，您可以使用不同的重量来抑制每个生产。

查看The Algorithmic Beauty of Plants部分1.7随机L系统了解更多信息。他们使用概率在单一规则的几个变体中进行选择。

在L系统森林中重叠的树木

2 个答案: