def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.randomize_atts('p', 'Bus-UV')
self.N.randomize_atts('s', (60, 120))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.constructgraph()
self.F.drawgraph(self.figname)
#########################
self.VC = VertexCover(self.N, self.S, self.F,
len(self.F.filterednodes))
self.VC.dummygraph = self.F.graph.copy()
def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.randomize_atts('p', 'Bus-UV')
self.N.randomize_atts('s', (60, 120))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.drawnodes(self.figname)
self.nodes_list = copy.copy(list(self.F.graph.nodes))
def initialize_test(self):
self.OD = ODPair(self.N, 0, self.N.size**2 - 1)
self.OD.create_pair()
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
if self.draw_mode == 'draw_output':
self.N.drawnetwork(self.figname)
self.OD.draw_pair(self.figname)
self.S.drawnetwork(self.figname)
def create_ellipse_slanted(self, i):
plt.clf()
z = i + 1
o = (z - 1) * (self.size + 1)
d = (self.size - z) * (self.size + 1)
self.N = Network(self.size, self.scale)
self.N.creategrid()
self.N.drawnetwork(self.figname)
self.OD = ODPair(self.N, o, d)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.drawnetwork(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
def create_ellipse(self, i):
plt.clf()
node = i + self.start
if node != self.pivot and node <= self.end:
plt.clf()
self.N = Network(self.size, self.scale)
self.N.creategrid()
self.N.drawnetwork(self.figname)
self.OD = ODPair(self.N, self.pivot, node)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.drawnetwork(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.same_atts('p', 'None')
self.N.same_atts('s', (0, 6))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.constructgraph()
self.F.drawnodes(self.figname)
#########################
self.VC = VertexCover(self.N, self.S, self.F, len(self.F.filterednodes))
self.VC.find_best_vc()
self.VC.constructgraph()
#########################
self.H = HillClimb(0.5, self.N, self.S, self.VC.cover, 1, self.figname)
self.H.init_hill_climb()
class Graph_Const_Test(QDialog):
def __init__(self, size, scale, parent):
super(Graph_Const_Test, self).__init__(parent)
self.size = size
self.scale = scale
self.N = Network(self.size, self.scale)
self.OD = None
self.S = None
self.F = None
self.nodes_list = []
self.figname = 'Graph_Construction'
self.folder = 'graph_construction_test'
######################
self.layout = QGridLayout(self)
self.setGeometry(900, 100, 500, 60)
self.setWindowTitle('Running Graph Construction Test: ' +
str(self.size) + '-' + str(self.scale))
self.progress = QProgressBar(self)
self.layout.addWidget(self.progress, 0, 0)
def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.randomize_atts('p', 'Bus-UV')
self.N.randomize_atts('s', (60, 120))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.drawnodes(self.figname)
self.nodes_list = copy.copy(list(self.F.graph.nodes))
def node_graph(self, i):
node = self.nodes_list[i]
self.F.connect_node(node)
self.F.drawgraph(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
def test(self):
self.filter()
frames = len(self.nodes_list)
self.progress.setMaximum(frames)
self.show()
fig = plt.figure(self.figname, figsize=(12, 12))
video = anim.FuncAnimation(fig,
self.node_graph,
frames=frames,
interval=500,
blit=False)
if not os.path.exists(self.folder):
os.mkdir(self.folder)
video.save(self.folder + '/' + str(self.size) + '_' + str(self.scale) +
'km' + '.mp4',
writer='ffmpeg')
plt.clf()
self.close()
def test(self):
self.show()
plt.figure(self.figname, figsize=(12, 12))
scale_list = truncatelist(self.truncation,
self.attribute_dict[self.attribute])
size = int(2**(len(scale_list) - 1)) + 1
scale = 1
############################
N = Network(size, scale)
N.creategrid()
corridors = fractalize(scale_list)
N.fractal_atts(self.attribute, corridors)
for att in self.attribute_list:
if att != self.attribute:
N.same_atts(att, random.choice(self.attribute_dict[att]))
N.drawnetwork(self.figname)
self.progress.setValue(1)
QApplication.processEvents()
############################
OD = ODPair(N, 0, size**2 - 1)
OD.create_pair()
OD.draw_pair(self.figname)
self.progress.setValue(2)
QApplication.processEvents()
############################
S = Subnetwork(N, OD)
S.reducenetwork()
S.compute_affinities()
S.drawnetwork(self.figname)
self.progress.setValue(3)
QApplication.processEvents()
############################
F = FilteredNetwork(N, S)
F.filter()
F.clear_edges()
F.constructgraph()
F.drawnodes(self.figname)
self.progress.setValue(4)
QApplication.processEvents()
label = str(self.attribute_dict[self.attribute].index(self.truncation))
if self.attribute != 's':
save_image(self.folder,
self.attribute + label + "_" + str(self.truncation))
else:
save_image(
self.folder, self.attribute + label + "_" +
str(self.truncation[0]) + "-" + str(self.truncation[1]))
plt.clf()
self.close()
class Hill_Climb_Test(QDialog):
def __init__(self, size, scale, frames, mode, parent):
super(Hill_Climb_Test, self).__init__(parent)
self.size = size
self.scale = scale
self.N = Network(self.size, self.scale)
self.OD = None
self.S = None
self.F = None
self.VC = None
self.H = None
self.mode = mode
self.frames = frames
self.figname = 'Hill_Climb_Test'
self.folder = 'hill_climb_test'
#########################
self.layout = QGridLayout(self)
self.setGeometry(900, 100, 500, 60)
self.setWindowTitle('Running Hill Climbing Test: ' + str(self.size) + '-' + str(self.scale))
self.progress = QProgressBar(self)
self.layout.addWidget(self.progress, 0, 0)
def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.same_atts('p', 'None')
self.N.same_atts('s', (0, 6))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.constructgraph()
self.F.drawnodes(self.figname)
#########################
self.VC = VertexCover(self.N, self.S, self.F, len(self.F.filterednodes))
self.VC.find_best_vc()
self.VC.constructgraph()
#########################
self.H = HillClimb(0.5, self.N, self.S, self.VC.cover, 1, self.figname)
self.H.init_hill_climb()
def climb(self, i):
plt.clf()
self.N.drawnetwork(self.figname)
self.OD.draw_pair(self.figname)
self.S.drawnetwork(self.figname)
self.F.drawnodes(self.figname)
self.VC.drawgraph(self.figname)
self.H.climb_trial(i)
self.H.optimalpath = self.H.iterations['guess'][0]
self.H.optimaltv = self.H.iterations['guess'][1]
if self.mode == 'simple':
self.H.determine_simplified_optimal_path()
else:
self.H.determine_optimal_path()
self.H.draw_optimal_path(self.figname)
self.progress.setValue(i+1)
QApplication.processEvents()
def test(self):
self.filter()
frames = self.frames
self.progress.setMaximum(frames)
self.show()
fig = plt.figure(self.figname, figsize=(12, 12))
video = anim.FuncAnimation(fig, self.climb, frames=frames, interval=100, blit=False)
if not os.path.exists(self.folder):
os.mkdir(self.folder)
video.save(self.folder + '/' + str(self.size) + '_' + str(self.scale) + 'km' + '.mp4', writer='ffmpeg')
plt.clf()
self.close()
class Vertex_Cover_Test(QDialog):
def __init__(self, size, scale, parent):
super(Vertex_Cover_Test, self).__init__(parent)
self.size = size
self.scale = scale
self.N = Network(self.size, self.scale)
self.OD = None
self.S = None
self.F = None
self.VC = None
self.figname = 'Vertex_Cover_Test'
self.folder = 'vertex_cover_test'
#########################
self.layout = QGridLayout(self)
self.setGeometry(900, 100, 500, 60)
self.setWindowTitle('Running Vertex Cover Test: ' + str(self.size) +
'-' + str(self.scale))
self.progress = QProgressBar(self)
self.layout.addWidget(self.progress, 0, 0)
def filter(self):
self.N.creategrid()
self.N.randomize_atts('h', 'Motorway')
self.N.randomize_atts('p', 'Bus-UV')
self.N.randomize_atts('s', (60, 120))
self.N.drawnetwork(self.figname)
#########################
self.OD = ODPair(self.N, 0, self.size**2 - 1)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
#########################
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
self.S.drawnetwork(self.figname)
#########################
self.F = FilteredNetwork(self.N, self.S)
self.F.filter()
self.F.clear_edges()
self.F.constructgraph()
self.F.drawgraph(self.figname)
#########################
self.VC = VertexCover(self.N, self.S, self.F,
len(self.F.filterednodes))
self.VC.dummygraph = self.F.graph.copy()
def vc_approximation(self, i):
if len(list(self.VC.dummygraph.edges)) != 0 and i < int(
math.ceil(len(list(self.F.graph.nodes)) / 2)) and i > 0:
edge = random.choice(list(self.VC.dummygraph.edges))
plt.clf()
self.N.drawnetwork(self.figname)
self.OD.draw_pair(self.figname)
self.S.drawnetwork(self.figname)
self.F.drawnodes(self.figname)
self.VC.cover += self.VC.remove_neighbors(edge)
self.VC.constructgraph()
self.VC.drawgraph(self.figname)
self.VC.draw_dummy_graph(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
else:
self.progress.setValue(i + 1)
QApplication.processEvents()
pass
def test(self):
self.filter()
frames = int(math.ceil(len(list(self.F.graph.nodes)) / 2))
self.progress.setMaximum(frames)
self.show()
fig = plt.figure(self.figname, figsize=(12, 12))
video = anim.FuncAnimation(fig,
self.vc_approximation,
frames=frames,
interval=2000,
blit=False)
if not os.path.exists(self.folder):
os.mkdir(self.folder)
video.save(self.folder + '/' + str(self.size) + '_' + str(self.scale) +
'km' + '.mp4',
writer='ffmpeg')
plt.clf()
self.close()
class PaperA_Test(QDialog):
def __init__(self, alpha, network, parent, **kwargs):
super(PaperA_Test, self).__init__(parent)
self.N = network
self.OD = None
self.S = None
self.F = None
self.x = []
self.y = []
self.alpha = alpha
if len(kwargs) != 0:
self.draw_mode = kwargs['draw_mode']
self.output_mode = kwargs['output_mode']
else:
self.draw_mode = None
self.output_mode = None
self.figname = 'PaperA_Test'
############################
self.layout = QGridLayout(self)
self.setGeometry(900, 100, 500, 60)
self.setWindowTitle('Running Paper A Test: ' + str(self.alpha))
self.progress = QProgressBar(self)
self.layout.addWidget(self.progress, 0, 0)
def initialize_test(self):
self.OD = ODPair(self.N, 0, self.N.size**2 - 1)
self.OD.create_pair()
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.compute_affinities()
if self.draw_mode == 'draw_output':
self.N.drawnetwork(self.figname)
self.OD.draw_pair(self.figname)
self.S.drawnetwork(self.figname)
def filter_nlargest(self, n):
self.F = FilteredNetwork(self.N, self.S)
self.F.filter(n)
self.F.clear_edges()
if self.draw_mode == 'draw_output':
self.F.drawnodes(self.figname)
H = HillClimb(self.alpha, self.N, self.S, self.F.filterednodes, 1,
self.figname)
if self.draw_mode == 'draw_output':
H.multiple_trials(self.draw_mode, self.output_mode)
else:
H.multiple_trials()
self.x.append(n)
self.y.append(H.optimaltv)
def test(self, runs, interval):
self.progress.setMaximum(runs)
self.show()
for i in range(runs + 1):
self.initialize_test()
if i == 0:
self.filter_nlargest(1)
else:
self.filter_nlargest(i * interval)
if self.draw_mode == 'draw_output':
save_image(str(self.alpha), str(i) + '_' + interval + '_nodes')
self.progress.setValue(i + 1)
QApplication.processEvents()
plt.clf()
plt.plot(self.x, self.y, '-o')
axes = plt.gca()
axes.set_xlim(0, runs * interval)
axes.set_ylim(0, 2 * self.N.size)
if self.draw_mode == 'draw_output':
save_image(str(self.alpha), 'node-obj plot')
else:
save_image('paperA_test/no_drawing',
str(self.alpha) + 'node-obj plot')
plt.clf()
self.close()
return min(self.y)
class EllipseTest(QDialog):
def __init__(self, size, scale, mode, parent):
super(EllipseTest, self).__init__(parent)
self.size = size
self.scale = scale
######################
self.N = None
self.OD = None
self.S = None
######################
self.end = int(math.floor((self.size**2 - 1) / 2))
self.pivot = int(self.end - math.floor(self.size / 2) + 1)
self.start = int(self.end - math.floor(self.size) + 1)
######################
self.folder = 'ellipse_test'
self.figname = "Ellipse_Test"
self.mode = mode
######################
self.layout = QGridLayout(self)
self.setGeometry(900, 100, 500, 60)
self.setWindowTitle('Running Ellipse Test: ' + str(self.size) + '-' +
str(self.scale))
self.progress = QProgressBar(self)
self.layout.addWidget(self.progress, 0, 0)
self.progress.setMaximum(self.size)
def create_ellipse(self, i):
plt.clf()
node = i + self.start
if node != self.pivot and node <= self.end:
plt.clf()
self.N = Network(self.size, self.scale)
self.N.creategrid()
self.N.drawnetwork(self.figname)
self.OD = ODPair(self.N, self.pivot, node)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.drawnetwork(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
def create_ellipse_slanted(self, i):
plt.clf()
z = i + 1
o = (z - 1) * (self.size + 1)
d = (self.size - z) * (self.size + 1)
self.N = Network(self.size, self.scale)
self.N.creategrid()
self.N.drawnetwork(self.figname)
self.OD = ODPair(self.N, o, d)
self.OD.create_pair()
self.OD.draw_pair(self.figname)
self.S = Subnetwork(self.N, self.OD)
self.S.reducenetwork()
self.S.drawnetwork(self.figname)
self.progress.setValue(i + 1)
QApplication.processEvents()
def test(self):
self.show()
fig = plt.figure(self.figname, figsize=(12, 12))
if self.mode == "straight":
video = anim.FuncAnimation(fig,
self.create_ellipse,
frames=self.size,
interval=100,
blit=False)
elif self.mode == "slanted":
video = anim.FuncAnimation(fig,
self.create_ellipse_slanted,
frames=self.size,
interval=100,
blit=False)
if not os.path.exists(self.folder):
os.mkdir(self.folder)
video.save(self.folder + '/' + str(self.size) + '_' + str(self.scale) +
'km' + '.mp4',
writer='ffmpeg')
plt.clf()
self.close()
def test(self):
self.show()
N = Network(self.size, self.scale)
N.creategrid()
for i in self.random:
N.randomize_atts(i, self.input[i])
for i in self.same:
N.same_atts(i, self.input[i])
for i in self.random_c:
N.randomize_atts_corridors(i, self.input[i])
N.create_corridor('h', ['Motorway'], 'row', [int(self.size / 2)])
N.create_corridor('p', ['None'], 'row', [int(self.size / 2)])
N.create_corridor('s', [(0, 6)], 'row', [int(self.size / 2)])
N.create_corridor('h', ['Motorway'], 'column', [int(0)])
N.create_corridor('p', ['None'], 'column', [int(0)])
N.create_corridor('s', [(0, 6)], 'column', [int(0)])
N.create_corridor('h', ['Motorway'], 'column', [int(self.size - 1)])
N.create_corridor('p', ['None'], 'column', [int(self.size - 1)])
N.create_corridor('s', [(0, 6)], 'column', [int(self.size - 1)])
N.drawnetwork(self.figname)
self.progress.setValue(1)
QApplication.processEvents()
#################################
OD = ODPair(N, self.origin, self.destination)
OD.create_pair()
OD.draw_pair(self.figname)
self.progress.setValue(2)
QApplication.processEvents()
#################################
S = Subnetwork(N, OD)
S.reducenetwork()
S.compute_affinities()
S.drawnetwork(self.figname)
self.progress.setValue(3)
QApplication.processEvents()
#################################
F = FilteredNetwork(N, S)
F.filter()
F.clear_edges()
F.constructgraph()
F.drawnodes(self.figname)
self.progress.setValue(4)
QApplication.processEvents()
#################################
VC = VertexCover(N, S, F, len(F.filterednodes))
VC.find_best_vc()
VC.constructgraph()
VC.drawgraph(self.figname)
self.progress.setValue(5)
QApplication.processEvents()
#################################
HC = HillClimb(0.5, N, S, VC.cover, self.hctrials, self.figname)
HC.multiple_trials('draw_output', self.mode)
self.progress.setValue(6)
QApplication.processEvents()
#################################
randomtags = str()
sametags = str()
for i in self.random:
randomtags += i
for j in self.random_c:
randomtags += (j + '-')
for k in self.same:
sametags += k
taglist = {
'Motorway': 1,
'Trunk': 2,
'Primary': 3,
'Secondary': 4,
'Tertiary': 5,
'Residential': 6,
'Service': 7
}
htag = str(taglist[self.input['h']]) + '-' + str(self.input['h'])
ptag = str(self.input['p'])
stag = str(self.input['s'][0]) + '-' + str(self.input['s'][1])
if not os.path.exists('standard_test/' + self.folder):
os.mkdir('standard_test/' + self.folder)
save_image(
'standard_test/' + self.folder + '/' + 'R' + randomtags + '_' +
'S' + sametags, '_' + htag + ptag + stag)
self.progress.setValue(7)
QApplication.processEvents()
plt.clf()
self.close()