# Create a Python spatial grid.
 
from math import sqrt
import csv
 
class Grid(object):
    markcnt = 0
    """Grid class with a width, height, length"""
    def __init__(self, width, height):
        self.grid = []
        self.width = width
        self.height = height
        self.length = width * height
        for x in range(self.width):
            col = []
            for y in range(self.height):
                col.append(Cell(x, y, self.grid))
            self.grid.append(col)
 
    class Area(object):
        area = 0
 
    def getWidth(self):
        return self.width
 
    def getHeight(self):
        return self.height
 
    def getLength(self):
        return self.length
 
    def __len__(self):
        return self.length
 
    def setCellValue(self, x, y, i):
        self.grid[x][y].value = i
 
    def getCellValue(self, x, y):
        return self.grid[x][y].value
 
    def getCell(self, x, y):
        return self.grid[x][y]
 
    def __getitem__(self, (x, y)):
        return self.grid[x][y]
 
    def index(self, value):
        return self.grid.index(value)
 
    def fillBlock(self, left, right, top, bottom, value):
        # You can choose if you want to iterate over a range of left - exclusive right
        # or over a range of left - inclusive right. Same goes for top - exclusive bottom
        # or top - inclusive bottom
        # For now it's exclusive
        for x in range(left, right):
            for y in range(top, bottom):
                self[x, y].value = value
 
    """
    def floodFill(self, x, y, landUse):
        visited = set()
        self.rec_floodFill(x, y, landUse, visited)
 
    def rec_floodFill(self, x, y, landUse, visited):
        if (x < 0 or y < 0 or x >= self.width or y >= self.height):
            return
 
        cell = self.grid[x][y]
        if (x, y) in visited:
            return
        visited.add((x,y))
 
        if (cell.value != landUse):
            return
 
        print visited 
        self.rec_floodFill(x-1, y, landUse, visited)
        self.rec_floodFill(x+1, y, landUse, visited)
        self.rec_floodFill(x, y-1, landUse, visited)
        self.rec_floodFill(x, y+1, landUse, visited)
    """
 
    def firstFreeCell(self):
        for y in range(self.height):
            for x in range(self.width):
                if self.grid[x][y].clusterId == -1:
                    return self.grid[x][y]
        return None
 
    def reset(self):
        for y in range(self.height):
            for x in range(self.width):
                self.grid[x][y].clusterId == -1
 
    def floodFill(self, x, y, clusterId, landUse):
        if (x < 0 or y < 0 or x >= self.width or y >= self.height):
            return
 
        cell = self.grid[x][y]
        area = 0
        if (cell.clusterId != -1 or cell.value != landUse):
            return
 
        cell.setClusterId(clusterId)
        area += 1
 
        self.floodFill(x-1, y, clusterId, landUse)
        self.floodFill(x+1, y, clusterId, landUse)
        self.floodFill(x, y-1, clusterId, landUse)
        self.floodFill(x, y+1, clusterId, landUse)
 
    def analyze(self):
        freeCell = self.firstFreeCell()
        clusterId = 0
        while freeCell != None:
            self.floodFill(freeCell.x, freeCell.y, clusterId, freeCell.value)
 
            freeCell = self.firstFreeCell()
            clusterId += 1
 
    def printClusterId(self, clusterId):
        for y in range(self.height):
            for x in range(self.width):
                if self.grid[x][y].clusterId == clusterId:
                    print 'clusterId:',clusterId,'Cell-coordinates:','(',self.grid[x][y].x,',',self.grid[x][y].y,')'
 
 
    """
    def printVisited(self, visited):
        for y in range(self.height):
            for x in range(self.width):
                if self.grid[x][y].visited == True:
                    print self.grid[x][y].value,
            print
    """
 
    def printVisited(self, visited):
        for y in range(self.height):
            for x in range(self.width):
                if self[x, y].visited:
                    print self[x, y].value,
                else:
                    print "x",
            print
 
    def printGrid(self):
        for y in range(self.height):
            for x in range(self.width):
                print self[x, y].value,
            print
 
    def load(cls, filename):
        print "Loaded csv file"
        loadGrid = []
        reader = csv.reader(open(filename), delimiter=';')
        for line in reader:
            loadGrid.append(line)
        width = len(loadGrid[0])
        height = len(loadGrid)
        grid = Grid(width, height)
        for x in range(width):
            for y in range(height):
                grid.getCell(x, y).value = loadGrid[x][y]
        return grid
    load = classmethod(load)
 
class Cell(object):
    def __init__(self, x, y, grid):
        self.x = x
        self.y = y
        self.grid = grid
        self.value = 0
        #self.visited = False
        self.clusterId = -1
 
    def inspect(self):
        "#<Cell: value = #(value), x = #(x), y = #(y)>"
 
    def getClusterId(self):
        return self.clusterId
 
    def setClusterId(self, clusterId):
        self.clusterId = clusterId
 
 
""" 
class ParcelClusterAnalyzer(object):
    def __init__(self, prevLandUseCount, landUseCount, parcel, prevAreaList, areaList, prevLandUseClusters, landUseClusters, prevClusterBoundingBox, clusterBoundingBox):
        self.prevLandUseCount = {}
        self.landUseCount= {}
        self.parcel = parcel
        self.prevAreaList = {}
        self.areaList = {}
        self.prevLandUseClusters = {}
        self.landUseClusters = {}
        self.prevClusterBoundingBox = {}
        self.clusterBoundingBox = {}
 
    class Area(object):
        area = 0
 
    def ParcelClusterAnalyzer(self):
        pass
 
    def ParcelClusterAnalyzer(self, parcel):
        self.parcel = parcel
"""
 
my_grid = Grid(7, 7)
my_grid.printGrid()
print '-'*20
 
my_grid[1, 1].value = 1
my_grid[2, 0].value = 1
my_grid[2, 1].value = 1
my_grid[2, 2].value = 1
 
my_grid[3, 4].value = 2
my_grid[3, 5].value = 2
my_grid[4, 4].value = 2
my_grid[4, 5].value = 2
my_grid[5, 4].value = 2
my_grid[5, 5].value = 2
 
my_grid.printGrid()
print '-'*20
 
my_grid.firstFreeCell()
 
#my_grid.floodFill(x, y, landUse, area, boundingBox)
print my_grid[1, 1].clusterId
print '-'*20
 
my_grid.analyze()
print my_grid[0, 0].clusterId
print my_grid[1, 1].clusterId
print my_grid[2, 0].clusterId
print my_grid[2, 1].clusterId
print my_grid[2, 2].clusterId
 
print my_grid[3, 4].clusterId
print my_grid[3, 5].clusterId
print my_grid[4, 4].clusterId
print my_grid[4, 5].clusterId
print my_grid[5, 4].clusterId
print my_grid[5, 5].clusterId
 
my_grid.printClusterId(1)
my_grid.printClusterId(2)
 
 
"""
Uitkomst met beholp van floodFill moet volgende soort informatie geven:
 
class Cluster:
    pass
 
cluster = Cluster()
cluster.cells = []
cluster.cells.append(mygrid[2, 0])
cluster.left = 1
cluster.right = 2
cluster.top = 0
cluster.bottom = 2
cluster.area = 4
 
cluster_list = [
  cluster    
]
"""