How to add colours to different areas

Question

So I created a recurring pattern using two different designs. The problem now is making the colours, so I have to ask the user to pick 3 different colours and use them to make certain areas of the designs that colour. For example what I mean is, if I were to choose the 5x5 patch layout then the first 2 boxes of patterns across and below should be one colour (so that's four boxes) and so on.

EDIT: to clear up the confusion.

1. So if you look at the 500x500 one. type '5' when it asks for what patch size you want.

2. you should see two different pattern designs.

3. all I want is the x = 0 to x = 200 and y = 0 to y = 200 to be blue colour. Meaning that everything in that area (by area, I mean all the pattern designs that are in there) should be a blue colour. The same colour should be used for x = 300 to x = 500 and y = 300 to y = 500.

4. the x = 300 to x = 500 and y = 0 to y = 200 should be red colour and the x = 0 to x = 200 and y = 300 to y = 500 should also be red.

5. and all that is left is the '+' part in the middle which should have the third colour, green.

6. https://prntscr.com/m48xxd this is what I mean by the colours. so the top left and bottom right are the same colours. the top right and bottom left are te same colours and the '+' is another colour.

7.https://prntscr.com/m48xzm here is the 7x7 version

I just put colours, for now, to make it easier to look at.

I have already tried doing the 'getX' and 'getY' but I can't seem to get it right.

from graphics import *

def main():
    global patchWorkSize
    patchWorkSize = int(input("What patchwork size would you like?"))

    if patchWorkSize == 5:
        patchWork5()
    elif patchWorkSize == 7:
        patchWork7()
    elif patchWorkSize == 9:
        patchWork9()
    else:
        print('Only patchwork sizes 5, 7 and 9 are avaliable')




def patchWork5():
    layout()

    for y in range(0,500,100):

        for x in range(0,500,200):

            for l1 in range(0,100,20):
                line = Line(Point(l1+x,0+y), Point(100+x,100-l1+y))
                line.draw(win)
            for l2 in range(100,0,-20):
                line3 = Line(Point(l2+x,100+y), Point(0+x,100-l2+y))
                line3.draw(win)

            for l3 in range(100,0,-20):
                line2 = Line(Point(100+x,0+l3+y), Point(0+l3+x,100+y))
                line2.setFill('red')
                line2.draw(win)
            for l4 in range(0,100,20):
                line4 = Line(Point(0+x,100-l4+y), Point(100-l4+x,0+y))
                line4.setFill('red')
                line4.draw(win)

    for e in range(0,500,100):
        for t in range(100,500,200):
            for o in range(0,500,10):
                for c in range(5,100,10):
                    circle1 = Circle(Point(c+t,5+o+e), 5)
                    circle1.setFill('blue')
                    circle1.draw(win)


def patchWork7():
    layout()

    for y in range(0,700,100):

        for x in range(0,700,200):

            for l1 in range(0,100,20):
                line = Line(Point(l1+x,0+y), Point(100+x,100-l1+y))
                line.draw(win)
            for l2 in range(100,0,-20):
                line3 = Line(Point(l2+x,100+y), Point(0+x,100-l2+y))
                line3.draw(win)

            for l3 in range(100,0,-20):
                line2 = Line(Point(100+x,0+l3+y), Point(0+l3+x,100+y))
                line2.setFill('red')
                line2.draw(win)
            for l4 in range(0,100,20):
                line4 = Line(Point(0+x,100-l4+y), Point(100-l4+x,0+y))
                line4.setFill('red')
                line4.draw(win)

    for e in range(0,700,100):
        for t in range(100,700,200):
            for o in range(0,700,10):
                for c in range(5,100,10):
                    circle1 = Circle(Point(c+t,5+o+e), 5)
                    circle1.setFill('blue')
                    circle1.draw(win)

def patchWork9():
    layout()

    for y in range(0,900,100):

        for x in range(0,900,200):

            for l1 in range(0,100,20):
                line = Line(Point(l1+x,0+y), Point(100+x,100-l1+y))
                line.draw(win)
            for l2 in range(100,0,-20):
                line3 = Line(Point(l2+x,100+y), Point(0+x,100-l2+y))
                line3.draw(win)

            for l3 in range(100,0,-20):
                line2 = Line(Point(100+x,0+l3+y), Point(0+l3+x,100+y))
                line2.setFill('red')
                line2.draw(win)
            for l4 in range(0,100,20):
                line4 = Line(Point(0+x,100-l4+y), Point(100-l4+x,0+y))
                line4.setFill('red')
                line4.draw(win)

    for e in range(0,900,100):
        for t in range(100,900,200):
            for o in range(0,900,10):
                for c in range(5,100,10):
                    circle1 = Circle(Point(c+t,5+o+e), 5)
                    circle1.setFill('blue')
                    circle1.draw(win)

def layout():
    global win

    win = GraphWin('Patchwork',patchWorkSize*100, patchWorkSize*100)
    for i in range(0, patchWorkSize*100,100):
        line = Line(Point(i,0), Point(i, patchWorkSize*100))
        line2 = Line(Point(0,i), Point(patchWorkSize*100, i))


        line.draw(win)
        line2.draw(win)

main()

Answer 1

I'm not going to write everything for you, but the code below shows how to choose the color for each area based on its position within the patchwork grid (i and j). The color is determined in color_func().

Hopefully this will be enough for you to figure out how to apply the relatively simple coding pattern shown to draw the desired graphics.

Hint: Compute the coordinates of each graphics element based on (or relative to) these same position values (i.e. don't write a separate function for every possible patchwork size).

This code still seems overly repetitive to me, and could probably be made more concise, but I'll leave that to you, too... ;¬)

def main():
#    size = int(input("What patchwork size would you like?"))
#    Hardcoded for testing.
#
#    if size % 2 == 0:
#        raise RuntimeError('patchwork size must be odd')

    patch_work(5)
    print()
    patch_work(7)

def patch_work(n):
    colors = '0', '1', '2'
    mid = n // 2

    # Call color_func() for every possible position in patchwork and
    # prints the results in rows.
    for i in range(n):
        row = []
        for j in range(n):
            row.append(color_func(n, i, j, colors))
        print(''.join(row))

def color_func(n, i, j, colors):
    mid = n // 2

    if i == mid:
        index = 2

    elif i < mid:
        if j < mid:
            index = 0
        elif j == mid:
            index = 2
        elif j > mid:
            index = 1

    elif i > mid:
        if j < mid:
            index = 1
        elif j == mid:
            index = 2
        elif j > mid:
            index = 0

    return colors[index]


if __name__ == '__main__':

    main()

Output:

00211
00211
22222
11200
11200

0002111
0002111
0002111
2222222
1112000
1112000
1112000

Answer 2

The key is to paramertize everything into cubes of a convenient size, and then turn the filling code into subroutines that can be called to fill those cubes. Below is a rework of your code along these lines that can handle any odd number 3 or greater as an input:

from graphics import *

UNIT = 100

def patchWork(win, size):
    blocks = size // 2

    def hatch_box(x, y):
        for n in range(0, UNIT, UNIT//5):
            line = Line(Point(n + x * UNIT, y * UNIT), Point((x + 1) * UNIT, UNIT - n + y * UNIT))
            line.draw(win)

        for n in range(UNIT, 0, -UNIT//5):
            line = Line(Point(n + x * UNIT, (y + 1) * UNIT), Point(x * UNIT, UNIT - n + y * UNIT))
            line.draw(win)

        for n in range(UNIT, 0, -UNIT//5):
            line = Line(Point((x + 1) * UNIT, n + y * UNIT), Point(n + x * UNIT, (y + 1) * UNIT))
            line.setFill('red')
            line.draw(win)

        for n in range(0, UNIT, UNIT//5):
            line = Line(Point(x * UNIT, UNIT - n + y * UNIT), Point(UNIT - n + x * UNIT, y * UNIT))
            line.setFill('red')
            line.draw(win)

    for y in range(blocks):
        for x in range(blocks):
            hatch_box(x, y)

    for y in range(blocks + 1, 2 * blocks + 1):
        for x in range(blocks + 1, 2 * blocks + 1):
            hatch_box(x, y)

    def draw_circles(x, y):
        for o in range(0, UNIT, UNIT // 10):
            for c in range(0, UNIT, UNIT // 10):
                circle = Circle(Point(c + UNIT // 20 + x * UNIT, o + UNIT // 20 + y * UNIT), UNIT // 20)
                circle.setFill('blue')
                circle.draw(win)

    for y in range(blocks):
        for x in range(blocks + 1, 2 * blocks + 1):
            draw_circles(x, y)
            draw_circles(y, x)

    def draw_cube(x, y):
        cube = Rectangle(Point(x * UNIT, y * UNIT), Point((x + 1) * UNIT, (y + 1) * UNIT))
        cube.setFill('yellow')
        cube.draw(win)

    x = blocks
    for y in range(0, 2 * blocks + 1):
        draw_cube(x, y)
        draw_cube(y, x)

def layout(size):
    win = GraphWin('Patchwork', size * UNIT, size * UNIT)

    for i in range(0, size * UNIT, UNIT):
        Line(Point(i, 0), Point(i, size * UNIT)).draw(win)
        Line(Point(0, i), Point(size * UNIT, i)).draw(win)

    return win

def main():
    patchWorkSize = int(input("What patchwork size would you like? "))

    if patchWorkSize % 2 == 1 and patchWorkSize > 2:
        win = layout(patchWorkSize)

        patchWork(win, patchWorkSize)

        win.getMouse() # pause for click in window
        win.close()
    else:
        print('Only odd sizes 3 or greater are available')

main()

You should be able to change UNIT, within reason.