def test():
#~ #define the grids
bd=grid.grid()
struktur=grid.grid()
nahr=grid.grid()
# load the grids
bd.read_hdf('../../hdf/schreiadler_all.h5','bd_all')
struktur.read_hdf('../../hdf/schreiadler_all.h5','struktur')
nahr.read_hdf('../../hdf/schreiadler_all.h5','nahr_schreiadler')
#~ # draw a sample of a size of 2000
X,Y=grid.sample(g1=bd,g2=struktur,g4=nahr,n=2000,filename='s_nahr.csv')
X=np.array(X)
Y=np.array(Y)
print X.shape, Y.shape
# define the model
t0=time.time()
model=svm('bd','struktur')
model.def_model()
# train the model
model.train(X,Y)
# test model
bias,rsme,r2=model.test(X,Y)
print 'Bias=', bias, 'RSME=', rsme, 'R^2=', r2
# write the model
model.write_model('bd_struk.svm')
print 'after read:', model.get_names()
# gen the output
out=model.calc(bd,struktur)
print 'time=',time.time()-t0
out.show()
def test():
#~ #define the grids
bd = grid.grid()
struktur = grid.grid()
nahr = grid.grid()
# load the grids
bd.read_hdf('../../hdf/schreiadler_all.h5', 'bd_all')
struktur.read_hdf('../../hdf/schreiadler_all.h5', 'struktur')
nahr.read_hdf('../../hdf/schreiadler_all.h5', 'nahr_schreiadler')
#~ # draw a sample of a size of 2000
X, Y = grid.sample(g1=bd,
g2=struktur,
g4=nahr,
n=2000,
filename='s_nahr.csv')
X = np.array(X)
Y = np.array(Y)
print X.shape, Y.shape
# define the model
t0 = time.time()
model = svm('bd', 'struktur')
model.def_model()
# train the model
model.train(X, Y)
# test model
bias, rsme, r2 = model.test(X, Y)
print 'Bias=', bias, 'RSME=', rsme, 'R^2=', r2
# write the model
model.write_model('bd_struk.svm')
print 'after read:', model.get_names()
# gen the output
out = model.calc(bd, struktur)
print 'time=', time.time() - t0
out.show()
def test_counts(self):
a = grid(2, 4)
a.set(0, 0, OPEN)
a.set(0, 1, OPEN)
a.set(0, 2, OPEN)
a.set(1, 0, OPEN)
self.assertEqual(count_placements(a), 1)
b = grid(2, 4, list(OPEN * 8))
self.assertEqual(count_placements(b), 2)
c = grid(3, 3, list(OPEN * 9))
c.set(1, 1, BLOCKED)
self.assertEqual(count_placements(c), 4)
def Run(n):
Ngl1 = 70 + 4 * n
#Ngl2 = 10 + 2 * n
mygrid = grid(xmin, xmax, ymin, ymax, Ngl1, 18)
mygrid.train(df1, 6, 7)
print
print "Run(n), Ngl1 = %d" % Ngl1
#print "Run(n), Ngl2 = %d" % Ngl2
#print "Run(n), n = %d" % n
with open('out.csv','wb') as f_handle:
csvw = csv.writer(f_handle, delimiter=',', quoting=csv.QUOTE_MINIMAL)
csvw.writerow(s1)
i = 0
#for i in range(nc):
for idx, row in df2.iterrows():
s2 = '%d,' % i
f_handle.write(s2)
pr = mygrid.predict(df2.Address[idx], df2.X[idx], df2.Y[idx], df2.PdDistrict[idx])
crm = df2.Category[idx]
j = iccl[crm]
if pr[j] > 1.0E-15: s[i] = -math.log(pr[j])
else: s[i] = -math.log(1.0E-15)
se2[i] = Entropy(pr)
csvw.writerow(pr)
if i % 5000 == 0:
print "i = %d, s = %f, se2 = %f" % (i, s[:i+1].mean(), se2[:i+1].mean())
i += 1
#print "n = %d, S = %f, Se2 = %f" % (n, s.mean(), se2.mean())
print "Ngl1 = %d, S = %f, Se2 = %f" % (Ngl1, s.mean(), se2.mean())
#print "Ngl2 = %d, S = %f, Se2 = %f" % (Ngl2, s.mean(), se2.mean())
print "\n\n"
def repeatedAStar(origMap,start,goal):
"""
Implementation of Repeated Forward A* algorithm
"""
agentMap = grid.grid(origMap.size,origMap.width,origMap.height,origMap.margin)
agentPos = start
path = []
expandedCells = 0
while not (agentPos.row == goal.row and agentPos.column == goal.column):
#Update map
for neighbor in origMap.neighbors(agentPos):
if(neighbor.isBlocked()):
agentMap.getCell(neighbor.row, neighbor.column).setBlocked(True)
#Calculate best path as per available input
bestPath,aStarExpandedCells = aStarPath.aStar(agentMap, agentPos, goal)
expandedCells = expandedCells + aStarExpandedCells
#If no path is available
if(not bestPath):
return None,expandedCells
#Traverse 1 step in the direction
l = len(bestPath)-2
(pathStepX,pathStepY) = bestPath[l]
agentPos = origMap.getCell(pathStepX,pathStepY)
#recordPath
path.append(bestPath[l])
return path,expandedCells
def ID_DFTS(state, goal, spawnList, gridSize):
frontier = queue.LifoQueue() # Stack implementation
root = grid(state, '', 0, spawnList, gridSize)
bound = 0 # Initializing max depth to zero.
natural_failure = False # Setting it to false, so that we toggle only we run out of any more nodes to explore.
while not natural_failure:
frontier.put(root)
while True:
if frontier.empty():
break
curNode = frontier.get()
if isGoal(curNode.STATE,
goal): # Checks if the goal state is reached.
return curNode.PATH, curNode
children = curNode.CHILDREN(spawnList, bound, gridSize)
if len(curNode.PATH
) < bound: # As long as it is within the depth limit.
if not children: # Sets natural failure to True only when we run out of states to explore.
natural_failure = True
else:
for child in children:
natural_failure = False # Sets it to false to keep the loop running as along as there are
# more children nodes to explore.
frontier.put(child)
bound += 1
def __init__(self, ships):
'''Initializes player object. Add ships to fleet, grid object
and defines valid initial player move options.'''
self.ships = self.addShips(ships)
self.board = grid()
self.sonarRemaining = 2
self.validAttack = {'c': 'coordinate attack', 'm': 'move fleet'}
def grid_calc3(self, g1,g2,g3):
cdef int i,j
cdef np.ndarray[DTYPE_t,ndim=2] mat1=g1.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] mat2=g2.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] mat3=g3.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] matx=g1.get_matc()
cdef int ii1,jj1, ii2,jj2,ii3,jj3
(ii1,jj1)=g1.size()
(ii2,jj2)=g2.size()
(ii3,jj3)=g3.size()
if(ii1!=ii2 or jj1!=jj2 or ii1!=ii3 or jj1!=jj3):
return None
for i in range(ii1):
for j in range(jj1):
if(int(mat1[i,j])==g1.get_nodata() or
int(mat2[i,j])==g2.get_nodata() or
int(mat3[i,j])==g3.get_nodata()):
matx[i,j]=g1.get_nodata()
else:
matx[i,j]=self.calc3(mat1[i,j],mat2[i,j],mat3[i,j])
gx=samt2.grid()
(nrows,ncols,x,y,csize,nodata)=g1.get_header()
gx.set_header(nrows,ncols,x,y,csize,nodata)
gx.set_mat(matx)
return gx
def __init__(self):
self.grid = grid()
self.__vis = visualization(self.grid.grid)
self.changedcounter = 0
self.iteration_counter = 0
self.reward_in = 0
self.filled_before = np.count_nonzero(self.grid.grid)
def repeatedAStar(origMap,start,goal):
agentMap = grid.grid(origMap.size,origMap.width,origMap.height,origMap.margin)
agentPos = start
path = []
expandedCells = 0
while not (agentPos.row == goal.row and agentPos.column == goal.column):
#Update map
for neighbor in origMap.neighbors(agentPos):
if(neighbor.isBlocked()):
agentMap.getCell(neighbor.row, neighbor.column).setBlocked(True)
#Calculate best path as per available input
bestPath,aStarExpandedCells = aStarPath.aStar(agentMap, agentPos, goal)
expandedCells = expandedCells + aStarExpandedCells
#If no path is available
if(not bestPath):
return None,expandedCells
#Traverse 1 step in the direction
l = len(bestPath)-2
(pathStepX,pathStepY) = bestPath[l]
agentPos = origMap.getCell(pathStepX,pathStepY)
#recordPath
path.append(bestPath[l])
return path,expandedCells
def grid_calc3(self, g1,g2,g3):
cdef int i,j
cdef np.ndarray[DTYPE_t,ndim=2] mat1=g1.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] mat2=g2.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] mat3=g3.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] matx=g1.get_matc()
cdef int ii1,jj1, ii2,jj2,ii3,jj3
(ii1,jj1)=g1.size()
(ii2,jj2)=g2.size()
(ii3,jj3)=g3.size()
if(ii1!=ii2 or jj1!=jj2 or ii1!=ii3 or jj1!=jj3):
return None
for i in range(ii1):
for j in range(jj1):
if(int(mat1[i,j])==g1.get_nodata() or
int(mat2[i,j])==g2.get_nodata() or
int(mat3[i,j])==g3.get_nodata()):
matx[i,j]=g1.get_nodata()
else:
matx[i,j]=self.calc3(mat1[i,j],mat2[i,j],mat3[i,j])
gx=samt2.grid()
(nrows,ncols,x,y,csize,nodata)=g1.get_header()
gx.set_header(nrows,ncols,x,y,csize,nodata)
gx.set_mat(matx)
return gx
def initializeNewGrid():
dataKeywords = ['gridHeight', 'gridWidth', 'cellSize']
gridDatas = {}
# creates a dictionary, with the key originating from dataKeywords
# this dictionary will then be used as a keyword argument
for i in dataKeywords:
dataEntered = False
while not dataEntered:
clear()
print("Enter 0 for default value")
# checks for invalid input
try:
gridData = int(
input("Enter " + i[:4] + " " + i[4:].lower() + " : "))
if (gridData != 0):
gridDatas[i] = gridData
dataEntered = True
else:
dataEntered = True
except:
continue
# creates a grid object, with the information provided by the dictionary
grids.append(g.grid(**gridDatas))
def play_game():
game = grid(4, 3, actions, (0, 0))
# initialise random start
idx = np.random.randint(0, 10)
start = game.all_states[idx]
game.set_state(start)
# play game
game_over = False
states_visited = []
n = 0
for i in range(1000):
n += 1
if game.current_state not in states_visited:
states_visited.append(game.current_state)
idx = np.random.randint(0, len(actions[game.current_state]))
action = actions[game.current_state][idx]
game.take_move(actions[game.current_state][idx])
if game.current_state == (1, 3):
game_over = True
break
if game.current_state == (0, 3):
game_over = True
break
return states_visited
def __init__(self):
g = grid.grid(120,160,4,4,1)
g.generate()
#f = open('120x160Map', 'w+')
#pickle.dump(g,f)
#f.close()
g.printGrid()
def main():
#we define our non-constant parameters
generations = 20
width = 5
height = 5
#we randomize the seed of the game
seed = np.empty([width, height], dtype=bool)
for i in range(width):
for j in range(height):
seed[i][j] = random.choice([True, False])
#we define our grid
gridMap = grid.grid(seed, height, width)
#we print out the seed generation
print("(Seed) Generation #0:")
gridMap.printGrid()
print("*************")
print("*************")
#we loop through our grid, each time updating
for i in range(generations):
print("Generation #", (i + 1), ":")
gridMap.updateGrid()
gridMap.printGrid()
print("*************")
print("*************")
def Run(n):
Ngl1 = 70 + 4 * n
#Ngl2 = 10 + 2 * n
mygrid = grid(xmin, xmax, ymin, ymax, Ngl1, 18)
mygrid.train(df1, 6, 7)
print
print "Run(n), Ngl1 = %d" % Ngl1
#print "Run(n), Ngl2 = %d" % Ngl2
#print "Run(n), n = %d" % n
with open('out.csv', 'wb') as f_handle:
csvw = csv.writer(f_handle, delimiter=',', quoting=csv.QUOTE_MINIMAL)
csvw.writerow(s1)
i = 0
#for i in range(nc):
for idx, row in df2.iterrows():
s2 = '%d,' % i
f_handle.write(s2)
pr = mygrid.predict(df2.Address[idx], df2.X[idx], df2.Y[idx],
df2.PdDistrict[idx])
crm = df2.Category[idx]
j = iccl[crm]
if pr[j] > 1.0E-15: s[i] = -math.log(pr[j])
else: s[i] = -math.log(1.0E-15)
se2[i] = Entropy(pr)
csvw.writerow(pr)
if i % 5000 == 0:
print "i = %d, s = %f, se2 = %f" % (i, s[:i + 1].mean(),
se2[:i + 1].mean())
i += 1
#print "n = %d, S = %f, Se2 = %f" % (n, s.mean(), se2.mean())
print "Ngl1 = %d, S = %f, Se2 = %f" % (Ngl1, s.mean(), se2.mean())
#print "Ngl2 = %d, S = %f, Se2 = %f" % (Ngl2, s.mean(), se2.mean())
print "\n\n"
def Main(in_board):
board = grid.grid(constants.empty, len(in_board))
board.massSet(in_board) #Need to set the grid object to the starting board
while master(
board
): #Loop function until it doesn't change anything in the grid
pass
return board.getGrid()
def main():
g = grid.grid(40,120)
ml = Model(g)
vw=view.View(ml,g)
main_loop = urwid.MainLoop(vw.fill, vw.palette,unhandled_input=vw.unhandled_input)
main_loop.set_alarm_in(1, vw.callback,user_data={"mod":ml,"vw":vw})
main_loop.run()
def get_list_grids(self, hdf_name): """ in: hdf str out: list of all grids in hdf call from slotHDF_Open_All """ gx = grid.grid() return gx.list_hdf(hdf_name)
def CHILDREN(self, sl): # Function to try out all the moves and add it to the childList.
childList = []
curLayout = self.STATE
curGrid = grid(current_grid=curLayout, spawn_list=sl)
currState = self
if grid.move(curGrid, 'Up', self.SPAWN):
# Generate the state for the child
childState = []
for line in curGrid.get_current_grid():
childState.append(line)
child = Node(childState, self, 'U', self.PATHCOST + 1, self.SPAWN + 1)
childList.append(child)
curLayout = self.STATE
curGrid = grid(current_grid=curLayout, spawn_list=sl)
if grid.move(curGrid, 'Down', self.SPAWN):
childState = []
for line in curGrid.get_current_grid():
childState.append(line)
child = Node(childState, self, 'D', self.PATHCOST + 1, self.SPAWN + 1)
childList.append(child)
curLayout = self.STATE
curGrid = grid(current_grid=curLayout, spawn_list=sl)
if grid.move(curGrid, 'Left', self.SPAWN):
childState = []
for line in curGrid.get_current_grid():
childState.append(line)
child = Node(childState, self, 'L', self.PATHCOST + 1, self.SPAWN + 1)
childList.append(child)
curLayout = self.STATE
curGrid = grid(current_grid=curLayout, spawn_list=sl)
if grid.move(curGrid, 'Right', self.SPAWN):
childState = []
for line in curGrid.get_current_grid():
childState.append(line)
child = Node(childState, self, 'R', self.PATHCOST + 1, self.SPAWN + 1)
childList.append(child)
curLayout = self.STATE
curGrid = grid(current_grid=curLayout, spawn_list=sl)
return childList
def __init__(gridsize,xcount,ycount,zcount):
self.xcount = xcount
self.ycount = ycount
self.zcount = zcount
self.grids = np.array((self.xcount,self.ycount,self.zcount))
for i in range(xcount):
for j in range(ycount):
for k in range(zcount):
self.grids[i][j][k] = grid(i,j,k,gridsize)
def __init__(self, nodes_in_layer=[18, 16, 8, 4]):
self.grid = grid()
self.layers = 4
self.nodes_in_layer = nodes_in_layer
self.weights_layer_2 = np.array([[0.] * (18 + 1)] * 16)
self.weights_layer_3 = np.array([[0.] * (16 + 1)] * 16)
self.weights_layer_4 = np.array([[0.] * (16 + 1)] * 4)
self.moves_done = []
self.food_pos = []
def test_write(self):
""" tests the read write of ASCII files """
self.gx.write_ascii('xxx.asc')
g1=samt2.grid()
g1.read_ascii('xxx.asc')
os.system('rm xxx.asc')
sx,sy=g1.size()
print sx,sy
assert sx==500 and sy==500
def Main(in_board):
board = grid.grid(constants.empty, len(in_board))
board.massSet(in_board) #Need to set the grid object to the starting board
keep_going = True
while keep_going: #Loop functions until it doesn't change anything in the grid
keep_going = solve_rules(board)
keep_going = keep_going or fill_master(board)
keep_going = keep_going or logic(board)
return board.getGrid()
def grid_create(self, gname, nrows, ncols): gx = grid.grid(nrows,ncols) # add grid gname_new = self.add_grid(gname, gx) # fill with random retu = self.get_grid_rand_float(gname_new) if retu is None: return False return gname_new
def init(width, height, square_size, map_generator, height_generator, name,
h_border, v_border):
global window
#create the screen
window = pygame.display.set_mode(
(width * square_size, height * square_size))
pygame.init()
return grid.grid(width, height, square_size, map_generator,
height_generator, name, h_border, v_border)
def constructBoard(_board, _temp_board):
row = 0
for i in _board:
_temp_board.append([])
for idx, j in enumerate(i):
tempgrid = grid(row, idx)
tempgrid.value = j.value
tempgrid.occupied = j.occupied
_temp_board[row].append(tempgrid)
row = row + 1
def create_routing_grid(self):
"""
Create a routing grid that spans given area. Wires cannot exist outside region.
"""
# We will add a halo around the boundary
# of this many tracks
size = self.ur - self.ll
debug.info(1, "Size: {0} x {1}".format(size.x, size.y))
self.rg = grid.grid()
def test_grid(self):
""" A test for training sample data and apply it to the
grid
"""
# define the grids
gwd=samt2.grid()
rise=samt2.grid()
ufc=samt2.grid()
relyield=samt2.grid()
# load the grids
gwd.read_hdf('../data/training.h5','gwd')
rise.read_hdf('../data/training.h5','rise')
ufc.read_hdf('../data/training.h5','ufc')
relyield.read_hdf('../data/training.h5','relyield')
# normalize the inputs
gwd.norm()
rise.norm()
ufc.norm()
# generate the training sample
size=500
inp=[]
y=np.zeros(size) # outputs 1
nrows,ncols=gwd.size()
k=0 # counter for the sample
while(k<size):
i=np.random.randint(nrows)
j=np.random.randint(ncols)
if(gwd.get(i,j)==gwd.get_nodata() or
rise.get(i,j)==rise.get_nodata() or
ufc.get(i,j)==ufc.get_nodata() or
relyield.get(i,j)==relyield.get_nodata()):
continue
inp.append([gwd.get(i,j),rise.get(i,j),ufc.get(i,j)])
y[k]=np.sign(relyield.get(i,j)-1.0)
k+=1
# start training
m=lm.svm()
m.set_names('gwd','rise','ufc')
m.train(inp,y)
res=m.calc(gwd,rise,ufc)
m.write_model("test3.svm")
assert np.fabs(res.corr(relyield))>0.6
def __init__(self):
self.startingBoard = [[" ", "w", " ", "w", " ", "w", " ", "w"],
["w", " ", "w", " ", "w", " ", "w", " "],
[" ", "w", " ", "w", " ", "w", " ", "w"],
[" ", " ", " ", " ", " ", " ", " ", " "],
[" ", " ", " ", " ", " ", " ", " ", " "],
["b", " ", "b", " ", "b", " ", "b", " "],
[" ", "b", " ", "b", " ", "b", " ", "b"],
["b", " ", "b", " ", "b", " ", "b", " "]]
self.realBoard = grid.grid(" ")
self.realBoard.massSet(self.startingBoard) #init board
def move(self):
from grid import grid
self.direction = movement(self.exits)
if self.direction == 'n':
grid([self.coord[0], self.coord[1] - 1]).enter()
elif self.direction == 's':
grid([self.coord[0], self.coord[1] + 1]).enter()
elif self.direction == 'e':
grid([self.coord[0] + 1, self.coord[1]]).enter()
elif self.direction == 'w':
grid([self.coord[0] - 1, self.coord[1]]).enter()
else:
print("Error: Room.move() was passed an invalid argument.")
exit(0)
def batch_grid():
parser = argparse.ArgumentParser(description="multi grid works")
parser.add_argument('-s', '--src', help='data folder', required=True)
parser.add_argument('-i', '--id', help='case id', required=True)
args = vars(parser.parse_args())
if args['src'][-1] != '/': args['src'] = args['src'] + "/"
for fn in glob.glob(args['src']+"*.avi"):
name = args['src'] + os.path.basename(fn).split('.')[0] + "_%s"%args['id']
if not os.path.exists(name): os.makedirs(name)
params = {'src' : fn,
"dst" : "%s/init.csv"%name,
"grid" : "%s/grid"%name}
#print params
if not os.path.isfile(params['dst']): #init already existed
mapping(params)
for fn in glob.glob(args['src']+"*.avi"):
name = args['src'] + os.path.basename(fn).split('.')[0] + "_%s"%args['id']
params = {'src' : fn,
"dst" : "%s/init.csv"%name,
"grid" : "%s/grid"%name}
grid(params)
def __init__(self):
logging.debug("client init")
#pygame.init();
pygame.font.init()
self.running = True
self.m = grid.grid()
self.start_frame()
self.start_renderer()
self.clgame = clgame.clgame(self.m)
self.clgame.frame = self
self.si = server_interface(self, self.r, self.clgame)
self.ih = input_handler.input_handler(self.si, self.clgame, self.r)
def grid_calc1(self, g1):
cdef int i,j
cdef np.ndarray[DTYPE_t,ndim=2] mat1=g1.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] matx=g1.get_matc()
cdef int ii,jj
(ii,jj)=g1.size()
for i in range(ii):
for j in range(jj):
if(int(mat1[i,j])!=g1.get_nodata()):
matx[i,j]=self.calc1(mat1[i,j])
gx=samt2.grid()
(nrows,ncols,x,y,csize,nodata)=g1.get_header()
gx.set_header(nrows,ncols,x,y,csize,nodata)
gx.set_mat(matx)
return gx
def grid_calc1(self, g1):
cdef int i,j
cdef np.ndarray[DTYPE_t,ndim=2] mat1=g1.get_matp()
cdef np.ndarray[DTYPE_t,ndim=2] matx=g1.get_matc()
cdef int ii,jj
(ii,jj)=g1.size()
for i in range(ii):
for j in range(jj):
if(int(mat1[i,j])!=g1.get_nodata()):
matx[i,j]=self.calc1(mat1[i,j])
gx=samt2.grid()
(nrows,ncols,x,y,csize,nodata)=g1.get_header()
gx.set_header(nrows,ncols,x,y,csize,nodata)
gx.set_mat(matx)
return gx
def __init__(self):
self.scanData = [[0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1], [0, 0, 0, 0, 0, 0, 0, 0],
[0, 0, 0, 0, 0, 0, 0, 0], [1, 0, 1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1, 0, 1], [1, 0, 1, 0, 1, 0, 1, 0]]
self.startingBoard = [[" ", "w", " ", "w", " ", "w", " ", "w"],
["w", " ", "w", " ", "w", " ", "w", " "],
[" ", "w", " ", "w", " ", "w", " ", "w"],
[" ", " ", " ", " ", " ", " ", " ", " "],
[" ", " ", " ", " ", " ", " ", " ", " "],
["b", " ", "b", " ", "b", " ", "b", " "],
[" ", "b", " ", "b", " ", "b", " ", "b"],
["b", " ", "b", " ", "b", " ", "b", " "]]
self.board = grid.grid(" ")
self.board.massSet(self.startingBoard) #init board
self.turnM = t.turnManager(['w', 'b'])
def gbfs(state, goal, spawnList, gridSize):
frontier = queue.PriorityQueue() # Priority Queue Implementation
root = grid(state, '', 0, spawnList, gridSize)
frontier.put(root)
explored = set() # A python set to store explored states. Using a set as it has O(1) look up time.
while not frontier.empty(): # Exits when the frontier is out of states to explore.
curNode = frontier.get()
if isGoal(curNode.STATE, goal):
return curNode.PATH, curNode
else:
for child in curNode.CHILDREN(spawnList, gridSize):
visited = child in explored # Checks if the child node is in explored set.
if not visited:
frontier.put(child)
explored.add(child) # Adds child node to visited set if it has just been explored.
def initalizeGrid(self):
""" Initialize the grid and the human and mosquito classes """
config = self.config
# Numpy array with the size of the grid
self.grid = np.ndarray(shape=(config["grid-x"], config["grid-y"]), dtype=object)
self.plotX = []
self.plotY = []
self.plotType = []
self.plotSize = []
# Add a grid instance to the array
for x in xrange(0, config["grid-y"]):
for y in xrange(0, config["grid-x"]):
self.grid[x][y] = g.grid(x, y, config)
self.addHumans()
self.addMosquitos()
def updateBoardfromScan(self, board, scanData, currentPlayer):
#Compares board to scan
#finds differences and updates board
#returns false if two pieces different
pieceToSet = p.location(
-1,
-1) #Stores the location of the piece to be set to currentPlayer
oldPieces = list(
) #Stores the locations of the piece to that need to be removed
scan = grid.grid(0)
scan.massSet(scanData)
pieceTypeToSet = currentPlayer #this gets changed if their is a missing king, therefore piece moved was a king kindof hacky
for i in range(8):
for j in range(8):
currentPos = p.location(i, j)
if scan.get(
currentPos) == 1 and not board.get(currentPos) == " ":
continue
elif scan.get(currentPos) == 1 and board.get(
currentPos) == " ":
pieceToSet = currentPos
elif scan.get(
currentPos) == 0 and not board.get(currentPos) == " ":
if board.get(currentPos)[0] == currentPlayer:
pieceTypeToSet = board.get(
currentPos
) #if the piece removed was of the current player, set that type to be set
oldPieces.append(currentPos)
elif scan.get(currentPos) == 0 and board.get(
currentPos) == " ":
continue
else:
print("ERROR IN SETTING BOARD")
return False
done = board.set(pieceToSet, pieceTypeToSet)
if done == None:
print("no move done")
return False
for l in oldPieces:
board.set(l, " ")
self.updateToKings(board)
return None
def add_hdf(self, hdf_name, dataset_name):
"""a
adds a new grid from a hdf filesystem with:
in: hdf_name
dataset_name
out: name of the new grid or False
dataset_new str
if dataset_name is already in the dict self.d_grids then:
add a 1 to the name to make it unique
result: add the grid in self.d_grids
"""
dataset_new = dataset_name
while(dataset_new in self.d_grids):
dataset_new += "1"
gx = grid.grid()
if gx.read_hdf(hdf_name, dataset_name) == True:
self.d_grids[dataset_new] = gx
return dataset_new
else:
return None
def start_game():
"""Function that starts the game"""
# Screen is the native surface to which we blit other surfaces
screen = pygame.display.set_mode((const.grid_size, const.grid_size), pygame.SRCALPHA, 32)
pygame.display.set_caption('Pseudoku')
# Graphic canvas is the surface that displays the background color and dividing borders
graphic_canvas = pygame.Surface(screen.get_size())
# Number canvas is the surface that displays the numbers in their boxes in Alpha
number_canvas = pygame.Surface(screen.get_size(), pygame.SRCALPHA, 32)
graphic_canvas.fill(const.plain)
draw_vertical(graphic_canvas)
draw_horizontal(graphic_canvas)
# Game over canvas is the canvas that displays the end game message.
game_over_canvas = pygame.Surface(screen.get_size())
game_over_canvas.set_alpha(215)
game_over_canvas.fill(const.white)
grid_model = grid("")
grid_model.init_grid()
grid_model.remove_boxes()
clock = pygame.time.Clock()
gameloop(clock, screen, graphic_canvas, number_canvas, grid_model, game_over_canvas)
def add_ascii(self, filename, ascii_name):
"""
adds a new grid from filesystem (.asc) with:
in: filename incl. path str
ascii_name str
out: name of the new grid or None
dataset_new str
if dataset_name is already in the dict self.d_grids then:
add a 1 to the name to make it unique
result: add the grid in self.d_grids
"""
dataset_new = ascii_name
while(dataset_new in self.d_grids):
dataset_new += "1"
gx = grid.grid()
if gx.read_ascii(filename) == True:
self.d_grids[dataset_new] = gx
return dataset_new
else:
print "error: ascii-filename not found"
return None
def main():
pygame.init()
screen = display.set_mode((640, 480))
display.set_caption('shard gui')
screen.fill(colours['white'])
pygame.display.update()
t = toolbar(things=[box('label.png'), box('label.png')])
c = cancel('label.png')
cl = clear('label.png')
f = forward('label.png')
b = back('label.png')
t.add([c, cl, b, f])
g = grid(screen, 0, t.height, screen.get_width(),
screen.get_height() - t.height)
con = container(t, g, screen)
done = False
while not done:
rs = con.draw(screen)
display.update(rs)
events = pygame.event.get()
for e in events:
if (e.type == QUIT):
done = True
break
elif (e.type == KEYDOWN):
if (e.key == K_ESCAPE):
done = True
break
else:
con.handleEvent(e)
return
def __init__(self,
rows=10,
cols=10,
start=(0, 0),
end=None,
obstructions=None,
obstruction_density=30,
block_size=20) -> None:
self.__rows = rows
self.__cols = cols
self.__start = start
self.__end = end if end else (self.__rows, self.__cols)
self.__grid = grid(rows=self.__rows,
cols=self.__cols,
start=self.__start,
end=self.__end,
obstructions=obstructions,
obstruction_density=obstruction_density,
block_size=block_size)
self.__obstructions = self.__grid.get_obstructions()
print(len(self.__obstructions))
self.__visited = {}
self.__steps = {}
def main():
pygame.init()
screen = display.set_mode((640, 480))
display.set_caption('shard gui')
screen.fill(colours['white'])
pygame.display.update()
t = toolbar(things = [box('label.png'), box('label.png')])
c = cancel('label.png')
cl = clear('label.png')
f = forward('label.png')
b = back('label.png')
t.add([c, cl, b, f])
g = grid(screen, 0, t.height, screen.get_width(), screen.get_height()-t.height)
con = container(t, g, screen)
done = False
while not done:
rs = con.draw(screen)
display.update(rs)
events = pygame.event.get()
for e in events:
if(e.type == QUIT):
done = True
break
elif(e.type == KEYDOWN):
if(e.key == K_ESCAPE):
done = True
break
else:
con.handleEvent(e)
return
#!/usr/bin/env python3
import numpy as np
import time
import sys
import os
sys.path.append(os.environ['SAMT2MASTER']+"/src")
import grid as samt2
# test the poisson solver using random distributed values
nsamples=50 # number of random samples
xsize=100 # size of the grid, can be slow if xsize>100
ysize=100
maxiter=100000 # maximum number of iterations
# define the grid and the random inputs
gx=samt2.grid(ysize,xsize)
x=np.random.randint(0,xsize,nsamples)
y=np.random.randint(0,ysize,nsamples)
z=np.ones(nsamples)
# activate the poisson solver
t0=time.time()
gx.poisson(y,x,z,0.001*nsamples,maxiter)
print("t=",time.time()-t0)
gx.show_contour()
'''
Created on 07-Feb-2016
@author: Shreepad Patil
@Ruid: 169005770
'''
"""
Program to generate 50 101x101 Maps.
"""
import grid
import pickle
for i in range(1,51):
g = grid.grid(101,5,5,1)
g.generate()
f = open('Map' + str(i), 'wb+')
pickle.dump(g,f)
f.close()
info.num_factions = 4
info.faction_colors = [ vector3(255,0,0), vector3(0,0,255),
vector3(255,255,0), vector3(0,255,255) ]
info.faction_names = [ "orcs", "humans", "elves", "fairies" ]
grid.global_info = info
area.global_info = info
#initialize pygame
pygame.init()
screen = pygame.display.set_mode( (800,600), 0, 24 )
screen.fill( (0,0,0) )
#create information display structures
out = output.output( screen, 14 )
world = grid.grid( out, screen, (64,64), random_generator(10000, 15000) )
#create the factions
factions = []
for ident in range( info.num_factions ):
area = world.get_random_unclaimed_area()
area.faction_control[ ident ] = 100
citypos = world.get_city_location( area )
newcity = world.cities[ citypos ]
newcity.faction_ident = ident
newcity.population = 100
fac = faction.faction( ident, out,
name = info.faction_names[ ident ],
import blob as bl
#opening video file
cap = cv2.VideoCapture("/home/erik/videos/videoplayback.mp4")
#creating named fixed windows
cv2.namedWindow("video",cv2.WINDOW_AUTOSIZE)
cv2.namedWindow("possessed",cv2.WINDOW_AUTOSIZE)
#lower and upper hsv values for thresholding the pigs in the video
lower = (26,74,3)
upper = (125,225,254)
#creating grid
ret, frame = cap.read()
dirg = grid.grid(frame)
#vector of times
timevec = []
while True:
#start counting time
benchInit = time.clock()
#process frames 5 times
for i in range(5):
#reading from video file
ret, frame = cap.read()
#checking if video is over
if frame is None:
break
#loads image in grayscale
img = cv2.imread(sys.argv[1],0)
#error while reading image
if img is None:
print "ERROR: file could not be opened!"
exit()
#displaying image
cv2.namedWindow("img",cv2.WINDOW_AUTOSIZE)
cv2.imshow("img",img)
cv2.waitKey(0)
#creating grid and finding objects
dirg = gr.grid(img,32)
for i in range(1):
blobs = dirg.locate(img)
for blob in blobs:
print "pt, area: ",blob.pt,blob.area()
blobs = bl.ordered(blobs)
print " "
for blob in blobs:
print "pt, area: ",blob.pt,blob.area()
for blob in blobs:
blob.mark(img)
info = global_info.global_info()
info.num_factions = 2
info.faction_colors = [ vector3(255,0,0), vector3(0,0,255) ]
info.faction_names = [ "orcs", "humans" ]
grid.global_info = info
area.global_info = info
#initialize pygame
pygame.init()
screen = pygame.display.set_mode( (800,600), 0, 24 )
screen.fill( (0,0,0) )
#create information display structures
out = output.output( screen, 14 )
world = grid.grid( out, screen, (64,64), random_generator(36, 64) )
#create the factions
area = world.get_area_at( 0, 0 )
area.faction_control[0] = 100
Thragg = world.cities[0] = city.city(area.pos,
out,
faction_ident=0,
population=100,
name="Thragg",
area=area)
orcs = faction.faction( 0, out, name = "orcs",
cities = [ Thragg ],
areas = world.linearize() )
def main():
argparser = argparse.ArgumentParser(description="text file")
argparser.add_argument("file", type=str, help="file to produce frequency distribution for")
argparser.add_argument("-m", "--pLen", type=int, default=4, help="length of the patterns to look for")
argparser.add_argument("-n", "--nRes", type=int, default=5, help="number of results to show")
argparser.add_argument("-k", "--findKey", help="find patterns from repeating key", action="store_true")
argparser.add_argument(
"-p",
"--plotByAlpha",
help="-p N: split cipher text by N alphabets and save plots. specify dir to save with -d. default is the current directory",
type=int,
default=0,
)
argparser.add_argument("-l", "--cipherLen", help="display the length of the cipher text", action="store_true")
argparser.add_argument("-d", "--outDir", type=str, default=".", help="directory to save files to")
argparser.add_argument("-a", "--ascii", help="text is ascii", action="store_true")
argparser.add_argument(
"-s",
"--shiftByAlpha",
help="-s N: split cipher text by N alphabets and shift on the basis of frequency analysis",
type=int,
default=0,
)
argparser.add_argument("-r", "--reverseShift", help="shift charcters backwards", action="store_true")
argparser.add_argument(
"-x",
"--xorByAlpha",
help="-x N: split cipher text by N alphabets and xor on the basis of frequency analysis",
type=int,
default=0,
)
argparser.add_argument("-c", "--common", help="most common letter in plain text alphabet", default="e")
argparser.add_argument(
"-g", "--grid", help="-g N: output the cipher text in a grid N chars wide", type=int, default=0
)
argparser.add_argument(
"-t",
"--transpose",
help="-t N: output the cipher text in a grid N chars wide",
metavar="N",
nargs="+",
type=int,
default=0,
)
argparser.add_argument(
"-i", "--perpGrid", help="-g N: output the cipher text in a grid N chars wide", type=int, default=0
)
args = argparser.parse_args()
toker = WhitespaceTokenizer()
f = open(args.file)
if args.ascii:
text = f.read().split()
arry = []
for e in text:
arry.append(chr(int(e, 16)))
# ascString = string.join(arry)
ascString = arry
else:
ascString = f.read()
tmp = ""
for c in ascString:
if ord(c) < 128:
tmp = tmp + c
ascString = tmp
if args.cipherLen:
print("cipher text length: " + str(len(ascString)))
if args.findKey:
print(findKey.getNgramsDispersion(string.join(ascString), args.pLen, args.nRes))
if args.plotByAlpha > 0:
alphas = split.splitByAlpha(args.plotByAlpha, ascString)
g = 0
for group in alphas:
g += 1
myFreqDist.MyFreqDist(group).createPlot(args.outDir + "s" + str(args.plotByAlpha) + "g" + str(g), 10)
if args.shiftByAlpha > 0:
alphas = split.splitByAlpha(args.shiftByAlpha, ascString)
candidate = shift.shiftByAlpha(alphas, ascString, args.common, args.reverseShift)
file = open(args.outDir + "candidate.pln", "w")
print(candidate)
if args.xorByAlpha > 0:
alphas = split.splitByAlpha(args.xorByAlpha, ascString)
candidate = xor.xorByAlpha(alphas, ascString, args.common)
file = open(args.outDir + "candidate.pln", "w")
print(candidate)
if args.grid > 0:
grid.grid(ascString, args.grid)
if args.perpGrid > 0:
perpGrid.grid(ascString, args.perpGrid)
if len(args.transpose) > 0:
transpose.transpose(ascString, args.transpose)
import numpy as np
import sys
import os
# sys.path.append('/home/ralf/master/samt2')
sys.path.append(os.environ['SAMT2MASTER']+"/src")
import grid as samt2
inch = 2.54 # cm
width = 14.8 # cm postcard
height = 10.5 # cm postcard
res = 300 # dots/inch
nrows = int(height/inch*res)
ncols = int(width/inch*res)
print('nrows:', nrows, 'ncols:', ncols)
size=25 # random points
# define the grid
gx=samt2.grid(nrows,ncols)
# generate random points x,y,z
x=np.random.randint(ncols,size=size)
y=np.random.randint(nrows,size=size)
z=np.random.rand(size)
# interpolation
intmeth=['linear','cubic','thin_plate']
for method in intmeth:
print(method)
gx.interpolate(x,y,z,method=method)
gx.show_contour()
def test_placements_from_head(self):
a = grid(4, 4, list(OPEN * 16))
rotations = placements_from_head(a, 0, 0)
self.assertEqual(rotations,
[[(0, 0), (1, 0), (2, 0), (2, 1)], [(0, 0), (0, 1), (0, 2), (1, 2)]])
'''
Created on 10-Feb-2016
@author: Shreepad Patil
'''
"""
Program to generate 5x5 Maps.
"""
import grid
import pickle
g = grid.grid(5,20,20,5)
g.generate()
f = open('10x10Map', 'wb+')
pickle.dump(g,f)
f.close()
g.printGrid()
min_speed = 5
speed = min_speed
done = False
pause = False
pygame.init()
pygame.display.set_caption("Game of Life")
clock = pygame.time.Clock()
main = grid()
if len(sys.argv) > 1:
main.load_map(sys.argv[1])
else:
main.load_random(ROW, COL)
window_size = [WIDTH * len(main.grid[0]) + MARGIN * len(main.grid[0]) + MARGIN, HEIGHT * len(main.grid)+ MARGIN * len(main.grid) + MARGIN]
screen = pygame.display.set_mode(window_size)
screen.fill(gray)
def draw_grid():
for row in range(len(main.grid)):
for col in range(len(main.grid[row])):
if main.grid[row][col] == 0:
color = white
def __init__(self):
self.__grid = grid.grid()
self.loadSolver()
#!/usr/bin/env python3
# simple test for different interpolation methods
import numpy as np
import sys
import os
# sys.path.append('/home/ralf/master/samt2')
sys.path.append(os.environ['SAMT2MASTER']+"/src")
import grid as samt2
gx=samt2.grid()
gx.read_hdf(os.environ['SAMT2MASTER']+'/data/ziethen.hdf','zie_dgm')
for i in xrange(5,51):
print gx.complexity(i)
import sys
import os
import grid
# test data
px=50 # pixel size
nx=6
ny=10
ll_x=-800 # lower left x
ll_y=-800
tl_x=-800 # top left x
tl_y=-250
# create grid object instances
ll=grid.grid(ll_x,ll_y,nx,ny,px,corner='lower_left')
tl=grid.grid(tl_x, tl_y, nx, ny, px, corner='top_left')
def test_tl_corner_mesh():
tl_corner=tl.cell_corner_mesh()
#tl_corner[0] = the x coordiante mesh
#tl_corner[1] = the x coordiante mesh
try:
assert tl_corner[0].min() == ll_x
except AssertionError:
sys.exit("Corner mesh output incorrect")
try:
se2[i] = Entropy(pr)
csvw.writerow(pr)
if i % 5000 == 0:
print "i = %d, s = %f, se2 = %f" % (i, s[:i + 1].mean(),
se2[:i + 1].mean())
i += 1
#print "n = %d, S = %f, Se2 = %f" % (n, s.mean(), se2.mean())
print "Ngl1 = %d, S = %f, Se2 = %f" % (Ngl1, s.mean(), se2.mean())
#print "Ngl2 = %d, S = %f, Se2 = %f" % (Ngl2, s.mean(), se2.mean())
print "\n\n"
#for i in range(0, 40):
# Run(i)
with open('out.csv', 'wb') as f_handle:
csvw = csv.writer(f_handle, delimiter=',', quoting=csv.QUOTE_MINIMAL)
csvw.writerow(s1)
mygrid = grid(xmin, xmax, ymin, ymax, 80, 18)
mygrid.train(df1, 6, 7)
i = 0
for idx, row in df2.iterrows():
s2 = '%d,' % i
f_handle.write(s2)
pr = mygrid.predict(df2.Address[idx], df2.X[idx], df2.Y[idx],
df2.PdDistrict[idx])
csvw.writerow(pr)
if i % 5000 == 0:
print "i = %d" % i
i += 1
