def primsAlg(segments, numNodes, firstNodeID, nodeDict):
'Prim\'s Algorithm for finding a minimum spanning tree'
tree = network.Network()
segHeap = []
# Find the shortest segment emanating from the node with the firstNodeID
try:
segs = nodeDict[firstNodeID]
except KeyError:
return tree
leastWeight = None
for seg in segs:
if (seg.getWeight() < leastWeight) or (leastWeight == None):
leastWeight = seg.getWeight()
firstSeg = seg
tree.addSeg(firstSeg)
# Starter to algorithm
# Add the segs emanating from the first two endpoints to the heap
for endNode in [firstSeg.getNode1(), firstSeg.getNode2()]:
addToHeap(segHeap, nodeDict[endNode.getID()])
# Pick best from heap and repeat
while tree.numNodes() < numNodes:
try:
# Get best segment from heap
seg = heappop(segHeap)
except:
# Tree is finished (not all nodes contained).
break
node1, node2 = seg.getNodes()
node1InNet = tree.inNet(node1)
node2InNet = tree.inNet(node2)
# Add the seg if it's terminal node isn't already in the cluster.
if (not node1InNet) or (not node2InNet):
if not node1InNet:
endNode = node1
else:
endNode = node2
tree.addSeg(seg)
# Add all emanating segs to the heap:
# nodeDict returns all segments coming out from the endNode
# endNode is the node that is outside of the tree
addToHeap(segHeap, nodeDict[endNode.getID()])
# And we are sure that everything in the heap is adjacent to the tree because
# we only add the adjacent segments in the first place using nodeDict
return tree
def primsAlg(segments, numNodes, firstNodeID, nodeDict):
'Prim\'s Algorithm for finding a minimum spanning tree'
tree = network.Network()
segHeap = []
# Find the shortest segment emanating from the node with the firstNodeID
try:
segs = nodeDict[firstNodeID]
except KeyError:
#When the tree is only this node... no emanating segs
return tree
leastWeight = None
for seg in segs:
if (seg.getWeight() < leastWeight) or (leastWeight == None):
leastWeight = seg.getWeight()
firstSeg = seg
tree.addSeg(firstSeg)
# Add the segs emanating from the first two endpoints to the heap
for endNode in [firstSeg.getNode1(), firstSeg.getNode2()]:
newSegs = nodeDict[endNode.getID()]
addToHeap(segHeap,newSegs)
while tree.numNodes() < numNodes:
try:
seg = heappop(segHeap)
except:
# Tree is finished (not all nodes contained).
break
node1 = seg.getNode1()
node2 = seg.getNode2()
node1InNet = tree.inNet(node1)
node2InNet = tree.inNet(node2)
# Add the seg if it's terminal node isn't already in the cluster.
if (node1InNet != node2InNet):
if not node1InNet:
endNode = node1
else:
endNode = node2
tree.addSeg(seg)
# Add all emanating segs to the heap:
newSegs = nodeDict[endNode.getID()]
addToHeap(segHeap,newSegs)
return tree
def main(argv=None):
if argv is None:
argv = sys.argv
try:
try:
opts, args = getopt.getopt(argv[1:], "h", ["help"])
except getopt.GetoptError, msg:
raise Usage(msg)
#if len(args) == 0:
#raise Usage("No arguments specified.")
try:
#inputShapeFile = argv[1]
#inputShapeFile=r"C:\Documents and Settings\Selin\Desktop\Mbola\MbolaPts.shp"
inputShapeFile = r"C:\Documents and Settings\Selin\Desktop\MicroGrid_5march\MbolaN.shp"
#inputShapeFile=r"C:\Documents and Settings\Selin\Desktop\sampleDir\Pampaida\PampaidaPts.shp"
#outputDir = argv[2]
outputDir = r"C:\Documents and Settings\Selin\Desktop\MicroGrid_5march\MbolaN"
#algorithm = argv[3]
searchRadius = "300 meters"
except IndexError:
raise Error("Not enough arguments provided to script.")
startTime = time.time()
nodesByClusterID, clusterByNode, nodes, centers, LVCostDict = generateDictsFromShp(
inputShapeFile, outputDir)
totalCost, tree, centers, nodesByClusterID = run(
centers, nodesByClusterID, clusterByNode, searchRadius)
statsFile1 = outputDir + os.sep + "ClusterSize.txt"
statsFile2 = outputDir + os.sep + "Centers.txt"
writeCentersToText(statsFile1, statsFile2, centers)
TreeLV = network.Network()
TreeWithLV = addLVSeg(TreeLV, centers, nodesByClusterID)
fileRW.genShapefile(TreeWithLV, outputDir + ".prj",
outputDir + os.sep + "LV.shp")
finishTime = time.time()
print "Running Time:", finishTime - startTime
def kruskalsAlg(segments, nodes):
'Kruskal\'s algorithm for finding a minimum spanning tree'
segments.sort(key=lambda obj: obj.getWeight())
tree = network.Network()
numNodes = len(nodes)
for segment in segments:
node1 = segment.getNode1()
node2 = segment.getNode2()
node1InNet = tree.inNet(node1)
node2InNet = tree.inNet(node2)
if (not node1InNet and not node2InNet) or (node1InNet != node2InNet):
tree.addSeg(segment)
else:
if node1InNet and node2InNet and \
(tree.getNetID(node1) != tree.getNetID(node2)):
tree.addSeg(segment)
if tree.numNodes() > numNodes:
break
return tree, segments
def kruskalForCluster(segments, numNodes,centerNumber, maxSegWeight=None):
"Kruskal\'s algorithm for finding clusters"
segments.sort(key=lambda obj:obj.getWeight())
tree = network.Network()
for segment in segments:
node1 = segment.getNode1()
node2 = segment.getNode2()
node1InNet = tree.inNet(node1)
node2InNet = tree.inNet(node2)
if (not node1InNet and not node2InNet) or (node1InNet != node2InNet):
tree.addSeg(segment)
else:
if node1InNet and node2InNet and \
(tree.getNetID(node1) != tree.getNetID(node2)):
tree.addSeg(segment)
if tree.numNodes() > numNodes-centerNumber+1:
break
if (maxSegWeight is not None) and (segment.getWeight() > maxSegWeight):
break
return tree
s=0.5).test_transform)
dataset = data.ConcatDataset([train_dataset, test_dataset])
class_num = 10
else:
raise NotImplementedError
data_loader = torch.utils.data.DataLoader(
dataset,
batch_size=500,
shuffle=False,
drop_last=False,
num_workers=args.workers,
)
res = resnet.get_resnet(args.resnet)
model = network.Network(res, args.feature_dim, class_num)
model_fp = os.path.join(args.model_path,
"checkpoint_{}.tar".format(args.start_epoch))
model.load_state_dict(
torch.load(model_fp, map_location=device.type)['net'])
model.to(device)
print("### Creating features from model ###")
X, Y, extracted_features = inference(data_loader, model, device)
print("extracted Features shape: ", extracted_features.shape)
if args.dataset == "CIFAR-100": # super-class
super_label = [
[72, 4, 95, 30, 55],
[73, 32, 67, 91, 1],
[92, 70, 82, 54, 62],
[16, 61, 9, 10, 28],
def main(argv=None):
if argv is None:
argv = sys.argv
try:
try:
opts, args = getopt.getopt(argv[1:], "h", ["help"])
except getopt.GetoptError, msg:
raise Usage(msg)
try:
#inputShapeFile = argv[1]
inputShapeFile = r"C:\Users\Selin\Desktop\DATA\real\Bonsaaso\BonsaasoRandPts.shp"
#outputDir = argv[2]
outputDir = r"C:\Users\Selin\Desktop\DATA\real"
#outputDir=r"/home/selin/Desktop/rsSep17/200"
searchRadius = 50000
distFromT = 100
except IndexError:
raise Error("Not enough arguments provided to script.")
startTime = time.time()
print "Generating Dictionaries"
nodesByClusterID, clusterByNode, nodes, centers = generateDictsFromShp(
inputShapeFile, outputDir)
print "Run function starts..."
timeBeforeRun = time.time()
#totalCost,tree,centers,nodesByClusterID,LVCostDict=run(centers,nodesByClusterID,clusterByNode,LVCostDict,searchRadius,MV,LV,TCost,distFromT,outputDir)
centers, nodesByClusterID = run(centers, nodesByClusterID,
clusterByNode, searchRadius, distFromT,
outputDir)
print "Time for RUN:", time.time() - timeBeforeRun
statsFile = outputDir + os.sep + "Center_StarConfig_100.csv"
csvWriter = csv.writer(open(statsFile, 'wb'))
outFile = open(statsFile, "w")
TreeLV = network.Network()
TreeWithLV, meanSeg = addLVSeg(TreeLV, centers, nodesByClusterID)
fileRW.genShapefile(TreeWithLV, outputDir + ".prj",
outputDir + os.sep + "StarConfig_100.shp")
for center in centers.values():
#print nodesByClusterID[center.getID()]
centersDict = defaultdict(list)
for node in nodesByClusterID[center.getID()]:
centersDict[node.getID()] = node
segments = generateSegments(centersDict, searchRadius)
MID = kruskalsAlgForMID(
segments, centersDict
) # buraya iyice bir bak tam istedigimi HALA yapmior olabilir.
x = center.getX()
y = center.getY()
size = center.getWeight()
del centersDict
MeanSegment = meanSeg[center.getID()]
csvWriter.writerow([x, y, size, MID, MeanSegment])
#outFile.write("%(x)f \n" %vars())
#outFile.write("%(y)f \n" %vars())
#outFile.write("%(size)i \n" %vars())
#outFile.write("%(MID)f \n" %vars())
outFile.close()
numTransformer = len(centers)
afterrun = time.clock()
print "Num Transformers", numTransformer
print "Total Running Time:", time.time() - startTime
def handle_buttons(self):
if self.buttons['p1_tank_type'].click:
self.p1_tank_type = switch(self.p1_tank_type, self.tank_type_list)
self.buttons['p1_tank_type'].txt_label.text = f'P1:{self.p1_tank_type}'
elif self.buttons['p2_tank_type'].click:
self.p2_tank_type = switch(self.p2_tank_type, self.tank_type_list)
self.buttons['p2_tank_type'].txt_label.text = f'P2:{self.p2_tank_type}'
elif self.buttons['set_ip'].click:
self.ip = input('Give me new ip:')
self.buttons['set_ip'].txt_label.text = f'IP:{self.ip}'
elif self.buttons['gamemode'].click:
self.game_mode = 'OFFLINE' if self.game_mode == 'ONLINE' else 'ONLINE'
self.buttons['gamemode'].txt_label.text = self.game_mode
self.buttons['set_ip'].active = not self.buttons['set_ip'].active
self.buttons['set_ip'].visible = not self.buttons['set_ip'].visible
if self.game_mode == 'ONLINE':
self.buttons['p1_tank_type'].x = self.width/2
self.buttons['p2_tank_type'].active = False
self.buttons['p2_tank_type'].visible = False
else:
self.buttons['p1_tank_type'].x = self.width/2-200
self.buttons['p2_tank_type'].active = True
self.buttons['p2_tank_type'].visible = True
elif self.buttons['play'].click:
if self.game_mode == 'OFFLINE':
self.player1 = player.Player(self.tank_image.anchor_x, self.height-self.tank_image.anchor_y,
self.p1_tank_type, 0, self.game_mode, self.height, img=self.tank_image)
self.player2 = player.Player(self.width-self.tank_image.anchor_x, self.tank_image.anchor_y,
self.p2_tank_type, 1, self.game_mode, self.height, img=self.tank_image)
self.current_screen = 1
else:
if self.ip is not None:
# Connecting with server
self.n = network.Network(self.ip)
self.this_client_id = int(self.n.getId())
print(self.this_client_id)
if self.this_client_id == 0:
self.player1 = player.Player(self.tank_image.anchor_x, self.height-self.tank_image.anchor_y,
self.p1_tank_type, 0, self.game_mode, self.height,
in_online_main_player=True, img=self.tank_image)
else:
self.player1 = player.Player(self.width-self.tank_image.anchor_x, self.tank_image.anchor_y,
self.p1_tank_type, 1, self.game_mode, self.height,
in_online_main_player=True, img=self.tank_image)
self.n.send_player(self.player1)
self.n.p2(self)
self.current_screen = 1
threading.Thread(target=self.trade_info).start()
else:
self.display_message('Set your ip first!', 3)
elif self.buttons['stats'].click:
self.current_screen = 2
elif self.back_from_stats_button.click:
self.current_screen = 0
for btn in self.buttons.values():
if btn.long_press:
continue
btn.click = False
def primsAlg(nodes, numNodes, firstNodeID=0):
'Prim\'s Algorithm for finding a minimum spanning tree'
def addToHeap(heap, newSegs):
'Adds new segments to the segHeap.'
for seg in newSegs:
heappush(heap, seg)
return heap
def calcSegs(startNode, nodes):
"""Calculates distance from startNode to each node in nodes, and returns a
list of network.Seg instances"""
segs = []
for node in nodes:
if node.getID() == startNode.getID():
continue
dist = ((startNode.getX() - node.getX())**2 +
(startNode.getY() - node.getY())**2)**(.5)
segs.append(network.Seg(None, startNode, node, dist))
return segs
tree = network.Network()
segHeap = []
# Find the shortest segment emanating from the node with the firstNodeID
try:
segs = calcSegs(nodes[firstNodeID], nodes.values())
except KeyError:
# If there are no segs from this node, there can be no tree.
return tree
leastWeight = None
for seg in segs:
if (seg.getWeight() < leastWeight) or (leastWeight == None):
leastWeight = seg.getWeight()
firstSeg = seg
tree.addSeg(firstSeg)
# Add the segs emanating from the first two endpoints to the heap
for endNode in [firstSeg.getNode1(), firstSeg.getNode2()]:
addToHeap(segHeap, calcSegs(endNode, nodes.values()))
while tree.numNodes() < numNodes:
try:
seg = heappop(segHeap)
except:
# Tree is finished (not all nodes contained).
break
node1, node2 = seg.getNodes()
node1InNet = tree.inNet(node1)
node2InNet = tree.inNet(node2)
# Add the seg if it's terminal node isn't already in the cluster.
if (not node1InNet) or (not node2InNet):
if not node1InNet:
endNode = node1
else:
endNode = node2
tree.addSeg(seg)
# Add all emanating segs to the heap:
addToHeap(segHeap, calcSegs(endNode, nodes.values()))
return tree
def main(argv=None):
if argv is None:
argv = sys.argv
try:
try:
opts, args = getopt.getopt(argv[1:], "h", ["help"])
except getopt.GetoptError, msg:
raise Usage(msg)
try:
#inputShapeFile = argv[1]
inputShapeFile = r"/home/selin/Desktop/windows-desktop/real/Ikaram/IkaramPts.shp"
#outputDir = argv[2]
outputDir = r"/home/selin/Desktop/windows-desktop/real/Ikaram/IkaramPts"
SR = 100000000
coverDist = 500
maxLVLenghtInCluster = 600
except IndexError:
raise Error("Not enough arguments provided to script.")
startTime = time.time()
clusters = collections.defaultdict(list)
print "Generating Dictionaries"
nodes = generateNodeDictFromShp(inputShapeFile, outputDir)
nodesByClusterID, clustersByNodeID = generateClusterDicts(
nodes, coverDist)
statsFile = outputDir + os.sep + "Centers_SetCover.csv"
csvWriter = csv.writer(open(statsFile, 'wb'))
outFile = open(statsFile, "w")
centers = {}
while nodesByClusterID:
maxID = findTheBiggestCluster(nodesByClusterID)
centers[maxID] = nodes[maxID]
#centers[maxID]=generateRootNode(nodesByClusterID, maxID,nodes) #eger center of mass istersem
size = len(nodesByClusterID[maxID])
nodesByClusterID, clusters = updateDicts(nodesByClusterID, maxID,
clusters, nodes)
x = nodes[maxID].getX()
y = nodes[maxID].getY()
csvWriter.writerow([x, y, size])
outFile.close()
print "Num Clusters", len(clusters)
print "Total Running Time:", time.time() - startTime
'''
try:
netID=tree.getNetID(centers.values()[0])
except:
netID=0
tree._nodesByNetID[0]=[]
tree._network[netID]=[]
'''
#roots={}
#roots=generateRootNode(nodesByClusterID)
tree = network.Network()
print "Generating LV network"
netID = 0
tree._nodesByNetID[0] = []
tree._network[netID] = []
for ID in clusters.keys():
nodesByNodeID = {}
segments, lvCost = CMST_dfs.CMST(clusters[ID],
maxLVLenghtInCluster, centers[ID])
for segment in segments.values():
node1 = segment.getNode1()
node2 = segment.getNode2()
if not nodesByNodeID.has_key(node1.getID()):
nodesByNodeID[node1.getID()] = node1
if not nodesByNodeID.has_key(node2.getID()):
nodesByNodeID[node2.getID()] = node2
for node in nodesByNodeID.values():
tree._netIDByNode[node] = netID
tree._nodesByNetID[netID].append(node)
for segment in segments.values():
tree._network[netID].append(segment)
print "Generating MV network"
LVLen = tree.getTotalEdgeWeight()
print "LVLen", LVLen
segments = generateSegments(centers, SR)
MVtree, segments = kruskalsAlg(segments, centers)
MVLen = MVtree.getTotalEdgeWeight()
print "MVLen", MVLen
fileRW.genShapefile(MVtree, outputDir + ".prj",
outputDir + os.sep + "MV.shp")
fileRW.genShapefile(tree, outputDir + ".prj",
outputDir + os.sep + "LV.shp")