Mondrian Art Programm Python

Question

Ich versuche ein Mondrian Art Programm zu erstellen .... Ich habe den Code, der die Quadrate nach dem Zufallsprinzip erzeugt..aber ich habe Probleme, die Quadrate mit Primärfarben zufällig zu füllen? Kann jemand das reparieren? Das ist mein Code:

import turtle 
import random 


turtle.screensize(1000,1000) 
turtle.setworldcoordinates(-500,-500,500,500) 

piet = turtle.Turtle() 
piet.speed(300) 

#primary colors, red, blue, yellow 
#piet.color(red,blue,yellow) 

rectangles = int(input('How many rectangles should be drawn? ')) 
rectangle_w = int(input('What should be the max width of the rectangles? ')) 
rectangle_h = int(input('What should be the max height of the rectangles? ')) 

def mondrian(t,random_w,random_h): 
    piet.begin_fill() 
    for number_r in range(1): 
     for box in range(2): 
      t.left(90) 
      t.forward(random_w) 
      t.left(90) 
      t.forward(random_h) 
    piet.end_fill() 



mondrian(piet,random.randint(10,rectangle_w),random.randint(10,rectangle_h)) 

def repeat_mondrian(): 
    for i in range(rectangles - 1): 
     mondrian(piet, random.randint(10, rectangle_w), random.randint(10, rectangle_h)) 

repeat_mondrian() 

Vielen Dank! :)

Answer 1

Ich benutze nicht viel Schildkröte, aber nach der Untersuchung sieht aus wie Sie möglicherweise verpasst, Stift vor begin_fill setzen und danach piet.color setzen.

** Update ** Sieht aus wie fillcolor ist Weg zu gehen, da Sie nicht brauchen, pendown oder penup. Hier ist der aktualisierte Code für mondarian Funktion.

def mondrian(t,random_w,random_h):  
    piet.begin_fill()  
    for number_r in range(1): 
     for box in range(2): 
      piet.fillcolor(random.choice(('red','blue','yellow')))    
      t.left(90) 
      t.forward(random_w) 
      t.left(90) 
      t.forward(random_h)   
    piet.end_fill() 

Answer 2

Sie einfach ändern müssen die turtle.color (die Sie auf Kommentar haben, nur an der falschen Stelle:

def mondrian(t, random_w, random_h): 
    piet.begin_fill() 
    piet.color(random.choice(['red', 'blue', 'yellow'])) 
    # rest of your code goes here 

Answer 3

Hier ist das Programm leicht gereinigt und mit Eingängen vorübergehend für eine einfache Fest von Entwicklung. Beachten Sie, dass untere rechte Ecke aller Rechtecke ist der Ursprung. Sie, dass auch Randomisierung sollte.

import turtle 
import random 


turtle.screensize(1000,1000) 
turtle.setworldcoordinates(-500,-500,500,500) 

piet = turtle.Turtle() 
piet.speed(300) 

rectangles = 8 #int(input('How many rectangles ')) 
rectangle_w = 500 #int(input('Max width of the rectangles? ')) 
rectangle_h = 500 #int(input('Max height of the rectangles? ')) 

def mondrian(t,random_w, random_h): 
    piet.fillcolor(random.choice(('red','blue','yellow'))) 
    piet.begin_fill() 
    for box in range(2): 
     t.left(90) 
     t.forward(random_w) 
     t.left(90) 
     t.forward(random_h) 
    piet.end_fill() 

def repeat_mondrian(): 
    for i in range(rectangles): 
     mondrian(piet, 
       random.randint(10, rectangle_w), 
       random.randint(10, rectangle_h)) 

repeat_mondrian() 

Answer 4

als Fan habe ich ein Mondrian als Wesen mor sehen e über die Teilung von Raum mit Andeutungen von Spannung und Rekursion statt zufälliger Quadrate. Mit mehr Leerraum als Farbe.

Wenn diese Leute können teach a computer to paint a Rembrandt, dann sollten wir in der Lage sein, gemeinsam zu lehren, einen Mondrian zu malen. Hier ist meine bescheidene Angebot in Richtung dieser Bemühungen:

import turtle as turtle_graphics 
import random 
import collections 

BORDER_COLOR = '#000000' # so you can add 'black' to COLORS below 

BORDER_WIDTH = 10 

MINIMUM_DIVISIBLE_PORTION = .2 # limits recursion 

COLORS = ('white', 'white', 'red', 'white', 'blue', 'yellow') # multiple 'white' to increase probability 

Bounds = collections.namedtuple('Bounds', ['x', 'y', 'width', 'height']) 

PICTURE_BOUNDS = Bounds(x=-250, y=-300, width=500, height=600) 


def fill_rectangle(turtle, bounds, color=BORDER_COLOR): 
    """ Fill a rectangle with the border color (by default) and then fill the center with a bright color """ 
    turtle.penup() 
    turtle.goto(bounds.x, bounds.y) 
    turtle.color(color) 
    turtle.pendown() 
    turtle.begin_fill() 
    for _ in range(2): 
     turtle.forward(bounds.width) 
     turtle.left(90) 
     turtle.forward(bounds.height) 
     turtle.left(90) 
    turtle.end_fill() 
    turtle.penup() 

    if color == BORDER_COLOR: 
     fill_rectangle(turtle, Bounds(bounds.x + BORDER_WIDTH, bounds.y + BORDER_WIDTH, bounds.width - BORDER_WIDTH*2, bounds.height - BORDER_WIDTH*2), random.choice(COLORS)) 


def mondrian(piet, bounds): 
    """ Divide, fill and divide & fill some more. Intuitively and recursively """ 

    if bounds.width < bounds.height: 
     dimension = 'height' 
     random_dimension = random.randint(getattr(bounds, dimension) // 5, 2 * getattr(bounds, dimension) // 3) 
     bounds_yin = Bounds(bounds.x, y=bounds.y + random_dimension, width=bounds.width, height=bounds.height - random_dimension) 
     bounds_yang = Bounds(bounds.x, bounds.y, bounds.width, random_dimension) 
    else: 
     dimension = 'width' 
     random_dimension = random.randint(getattr(bounds, dimension) // 5, 2 * getattr(bounds, dimension) // 3) 
     bounds_yin = Bounds(bounds.x, bounds.y, random_dimension, bounds.height) 
     bounds_yang = Bounds(x=bounds.x + random_dimension, y=bounds.y, width=bounds.width - random_dimension, height=bounds.height) 

    if getattr(bounds_yin, dimension) > getattr(bounds_yang, dimension): 
     bounds_paint, bounds_divide = bounds_yang, bounds_yin 
    else: 
     bounds_paint, bounds_divide = bounds_yin, bounds_yang 

    fill_rectangle(piet, bounds_paint) 

    if getattr(bounds_divide, dimension) < MINIMUM_DIVISIBLE_PORTION * getattr(PICTURE_BOUNDS, dimension): 
     fill_rectangle(piet, bounds_divide) 
    else: 
     mondrian(piet, bounds_divide) 


def paint_canvas(dummy_x=0, dummy_y=0): 
    """ Runs the program and can be used as an event handler """ 
    turtle_graphics.onscreenclick(None) 
    fill_rectangle(turtle_graphics, PICTURE_BOUNDS, 'black') 
    mondrian(turtle_graphics, PICTURE_BOUNDS) 
    turtle_graphics.onscreenclick(paint_canvas) 

turtle_graphics.screensize(PICTURE_BOUNDS.width, PICTURE_BOUNDS.height) 
turtle_graphics.speed('fastest') 
turtle_graphics.hideturtle() 

paint_canvas() 

turtle_graphics.listen() 

turtle_graphics.mainloop() 

Wenn Sie das Bild nicht gefällt Ihnen erhalten, klicken Sie auf der Leinwand, und es wird eine andere malen, hoffentlich mehr nach Ihren Wünschen:

@KaileeCollins, ich hoffe das gibt dir ein paar Ideen für dein eigenes Projekt.

Answer 5

Noch eine Implementierung. Dieses Programm kann in einem Browser ausgeführt werden, wählen Sie die 'Mondrian' Demo unter: http://www.transcrypt.org/live/turtle_site/turtle_site.html und warten Sie eine Weile, die Schmerz ändert sich alle paar Sekunden.

Sie können das Programm ändern und sehen, was der Effekt ist. Es läuft auch mit Python 3.5 von der Konsole.

# Inspired by our cat Pietje 

from turtle import * 
from random import * 

speed (0) 

colors = ('gray', 'green', 'red', 'white', 'blue', 'yellow') 
delta = 8 
threshold = 100 
color ('black', 'black') 

def maybe (bias = None): 
    return choice ([False, True, bias, bias] if bias != None else [False, True])  

def between (a, b): 
    return a + (0.2 + 0.3 * random()) * (b - a) 

recentColors = ['black', 'black'] 
def originalColor(): 
    global recentColors 
    while True: 
     result = choice (colors) 
     if not result in recentColors: 
      recentColors = [result, recentColors [0]] 
      return result 

def rect (xMin, yMin, xMax, yMax): 
    for aColor in ('black', originalColor()): 
     color (aColor, aColor) 

     up() 
     goto (xMin, yMin) 
     down() 

     begin_fill() 
     goto (xMax, yMin) 
     goto (xMax, yMax) 
     goto (xMin, yMax) 
     goto (xMin, yMin) 
     end_fill() 

     xMin += delta 
     yMin += delta 
     xMax -= delta 
     yMax -= delta 

def draw (xMin = -250, yMin = -300, xMax = 250, yMax = 300): 
    if xMax - xMin > threshold and yMax - yMin > threshold: 
     if maybe (xMax - xMin > yMax - yMin): 
      xMid = between (xMin, xMax) 
      if maybe(): 
       draw (xMin, yMin, xMid, yMax) 
       rect (xMid, yMin, xMax, yMax) 
      else: 
       rect (xMin, yMin, xMid, yMax) 
       draw (xMid, yMin, xMax, yMax) 
     else: 
      yMid = between (yMin, yMax) 
      if maybe(): 
       draw (xMin, yMin, xMax, yMid) 
       rect (xMin, yMid, xMax, yMax) 
      else: 
       rect (xMin, yMin, xMax, yMid) 
       draw (xMin, yMid, xMax, yMax) 
    else: 
     rect (xMin, yMin, xMax, yMax) 
     ontimer (lambda: (clear(), draw()), 2000) 
draw() 
done()