Game of life

from copy import deepcopy

from MyImage_class import MyImage

class Cell:

    def __init__(self, x, y, value):
        self.x = x
        self.y = y
        self.value = value

    def __str__(self):
        return "(" + str(self.x) + " " + str(self.y) +") "+str(self.value)


class Table:


    def __init__(self, size_x, size_y):

        self.size_x = size_x
        self.size_y = size_y


        self.table = []

        self.pixel_threshold = 0.5

        for x in range(size_x):
            for y in range(size_y):
                self.table.append(Cell(x, y, 0))

    def __str__(self):
        s = ""
        for x in range(self.size_x):
            for y in range(self.size_y):
                s += "|" + str(self.getCell(x, y).value) + "|"
            s += "\n"
        return s


    def getNeighbors(self, x, y):

        neighbors = []
        for i in (-1, 0, 1):
            for j in (-1, 0, 1):
                nx = x + i
                ny = y + j



                if nx >= 0 and nx < self.size_x and ny >= 0 and ny < self.size_y:
                    if nx == x and ny == y:
                        pass
                    else:
                        neighbors.append(self.getCell(nx, ny))
        return neighbors


    def setCell(self, x, y, value):
        self.table[self.size_x*x + y].value = value

    def getCell(self, x, y):
        return self.table[self.size_x*x + y]

    def saveFile(self, filename = "./text.txt"):
        s = ""
        for x in range(self.size_x):
            for y in range(self.size_y):
                s += str(self.getCell(x, y).value) + " "
            s += "\n"

        with open(filename, "w") as f:
            f.write(s)

    def loadFile(self, filename = "./text.txt"):
        self.table = []

        with open(filename, "r") as f:
            lines = f.readlines()
        x = 0

        for line in lines:
            values = line.strip().split(" ")
            for y, value in enumerate(values):
                self.table.append(Cell(x, y, int(value)))
            x += 1


        self.size_x = x
        self.size_y = y + 1

    def readFromImage(self, filename = "test_picture.png"):
        img = MyImage()

        img.read_from_file(filename)
        img.convert2grayscale()

        img.transpose()

        img.normalize()
        img.limit(1)

        table_x = img.data.shape[0]
        table_y = img.data.shape[1]

        # binarize the image
        self.size_x = table_x
        self.size_y = table_y

        self.table = []

        for x in range(table_y):
            for y in range(table_x):
                if img.data[y][x] < self.pixel_threshold:
                    self.table.append(Cell(x, y, 1))

                else:
                    self.table.append(Cell(x, y, 0))

    def saveToImage(self, filename = "turn_test_picture.png"):
        img = MyImage((self.size_x, self.size_y))

        for cell in self.table:
            if cell.value > self.pixel_threshold:
                img.data[cell.y][cell.x] = 1
            else:
                img.data[cell.y][cell.x] = 0

        img.save(filename)


class GameLife:

    def __init__(self):

        table_x = 10
        table_y = 10

        self.game_board = Table(table_x, table_y)

    def nextTurn(self):

        # copy the table

        delete = deepcopy(self.game_board)

        for cell in delete.table:
            neighbors = self.game_board.getNeighbors(cell.x, cell.y)

            count = sum(n.value for n in neighbors)

            if count < 2:
                cell.value = 0
            elif count > 3:

                cell.value = 0
            elif count == 3:

                cell.value = 1

        for dele, cell in zip(delete.table, self.game_board.table):
            cell.value = dele.value

gl = GameLife()
print("read from file")
gl.game_board.readFromImage()
#gl.game_board.loadFile()

print("save file")
gl.game_board.saveToImage("turn_0.png")

#print(gl.game_board)

total_turn = 200
counter = 1

while counter <= total_turn:
    print("calculating turn...", counter)

    gl.nextTurn()
    gl.game_board.saveToImage("turn_" + str(counter)+ ".png")

    #print(gl.game_board)

    counter += 1