def closest_node_on_segment_to_node(node, segment) -> Node.Node:
A_start, B_start, C_start = perpendicular(segment.start, segment)
A_end, B_end, C_end = perpendicular(segment.end, segment)
if line_value(A_start, B_start, C_start, node) * line_value(
A_end, B_end, C_end, node) < 0:
node_A, node_B, node_C = perpendicular(node, segment)
x = 10000
y = (-node_A * x - node_C) / node_B
end = Node.Node(x, y)
node_segment = Edge.Edge(node, end)
if geometry.intersect(segment, node_segment):
closest_node = geometry.intersection(segment, node_segment)
else:
x = -10000
y = (-node_A * x - node_C) / node_B
end = Node.Node(x, y)
node_segment = Edge.Edge(node, end)
closest_node = geometry.intersection(segment, node_segment)
else:
closest_node = segment.start
distance_to_start = dist(node, segment.start)
distance_to_end = dist(node, segment.end)
if distance_to_start > distance_to_end:
closest_node = segment.end
return closest_node
def add_edge(self, v, w, wt):
if v == w:
return
self.g[v].append(Edge(v, w, wt))
if not self.is_directed:
self.g[w].append(Edge(w, v, wt))
self.edges += 1
def test_constructor_if_assign_edge_properly(self):
state1 = State(name='A')
edge1 = Edge(label='a', destination=State('B'))
self.assertListEqual(state1.state_edges, [])
state1.add_edge(edge1)
self.assertEqual(state1.state_edges,
[Edge(label='a', destination=State('B'))])
def addEdge(self, nod1, l1, nod2, l2, col):
l1 = self.LayerPerm[l1]
l2 = self.LayerPerm[l2]
if col == 1 or col == 15:
return self.addEdge_util(Edge.Edge(nod1, l1, nod2, l2, col))
return max(self.addEdge_util(Edge.Edge(nod1, l1, nod2, l2, col)),
self.addEdge_util(Edge.Edge(nod2, l2, nod1, l1, col)))
def collideWithCircle(self, b):
axis = Edge(self.center, b.center, "#000000")
axis2 = Edge(self.center, b.center, "#000000")
aPerp = self.velocity.getPerpVec(axis)
bPerp = b.velocity.getPerpVec(axis)
aVi = self.velocity.projOnto(axis)
bVi = b.velocity.projOnto(axis)
aVf = (2.0*b.mass*bVi + aVi*(self.mass - b.mass))/(self.mass + b.mass)
bVf = (2.0*self.mass*aVi + bVi*(b.mass - self.mass))/(self.mass + b.mass)
axis.setM(aVf)
aPerp.add(axis)
aPerp.setOrigin(self.center)
self.velocity = aPerp
self.center = self.velocity.p0
axis2.setM(bVf)
bPerp.add(axis2)
bPerp.setOrigin(b.center)
b.velocity = bPerp
b.center = b.velocity.p0
def getConvertedEdges(graph : networkx.Graph):
convertedEdges = [[] * (graph.number_of_nodes()) for i in range(graph.number_of_nodes())] #--> Desta forma para evitar que as linhas sejam todas a msm referencia --> https://stackoverflow.com/questions/240178/list-of-lists-changes-reflected-across-sublists-unexpectedly
counter = 0
counter2 = 0
for i in range(len(graph.nodes)):
counter = 0
for u, v, data in graph.edges(data=True):
if u > i: #SE CHEGOU AO FIM DA LISTAGEM DAS EDGES
break
elif i == u:
if i == v:
itemArgs = {Utils.INITIALPOINT: putAsciiValues(u, graph.number_of_nodes()),
Utils.FINALPOINT: putAsciiValues(v, graph.number_of_nodes()),
Utils.DISTANCE: data['weight']}
convertedEdges[i].append(Edge.Edge(**itemArgs))
counter = counter + 1
if i != v:
itemArgs = {Utils.INITIALPOINT: putAsciiValues(u, graph.number_of_nodes()),
Utils.FINALPOINT: putAsciiValues(v, graph.number_of_nodes()),
Utils.DISTANCE: data['weight']}
convertedEdges[i].append(Edge.Edge(**itemArgs))
itemArgs = {Utils.INITIALPOINT: putAsciiValues(v, graph.number_of_nodes()),
Utils.FINALPOINT: putAsciiValues(u, graph.number_of_nodes()),
Utils.DISTANCE: data['weight']}
convertedEdges[v].append(Edge.Edge(**itemArgs))
else:
continue
return convertedEdges
def add_edge(self, v1, v2, weight):
if v1 == v2:
return
self.g[v1].append(Edge(v1, v2, weight))
if not self._is_directed:
self.g[v2].append(Edge(v2, v1, weight))
def _add_route_info(self, firewall, data, interface, edge):
"""Add informations about gateways and destinations network, and link them with the corresponding
firewall and network.
"""
self.graph.add_node(data, object=Node(data))
self.graph.add_edge(firewall, data, object=Edge(data, firewall))
self.graph.add_edge(data,
interface.network,
object=Edge(data, interface))
def add_edge(v1, v2, w): edge = Edge.Edge(v1,v2,w) resEdge = Edge.Edge(v2,v1,0) edge.res = resEdge resEdge.res = edge adjacency_list[v1].append(edge) adjacency_list[v2].append(resEdge) optFlow[edge] = 0 optFlow[resEdge] = 0
def Roadmap_construction(self):
while len(self.vertices) < self.number_of_node:
q_random = self.sampling()
if self.check_collision(q_random):
self.vertices.append(q_random)
for vertex in self.vertices:
k_nearest_neighbor = self.get_k_nearest_neighbor(vertex, self.number_of_neighbors)
for neighbor in k_nearest_neighbor:
if Edge.Edge(neighbor[0], vertex) not in self.edges and self.connect(neighbor[0], vertex):
self.edges.append(Edge.Edge(neighbor[0], vertex))
def createGraph(lines):
verts = []
edges = []
for line in lines:
lineverts = line.split(' ')
if not lineverts[0] in verts:
verts.append(lineverts[0])
if not lineverts[1] in verts:
verts.append(lineverts[1])
if len(lineverts) == 2:
edges.append(Edge.Edge(lineverts[0],lineverts[1]))
else:
edges.append(Edge.Edge(lineverts[0],lineverts[1],lineverts[2]))
return Graph.Graph(verts,edges)
def main(playerX: int, playerY: int, pipeInfo: list, stillAlive: bool):
test1 = Edge(0, 3, 100, 100)
test2 = Edge(1, 3, 100, 100)
test3 = Edge(2, 3, 100, 100)
supertest = (test1, test2, test3)
NNTest = NeuralNetwork(supertest, 4, (3))
if pipeInfo[0]['x'] >= 0:
print("Pipe Info = ", pipeInfo[0]['x'])
else:
print("Pipe Info = ", pipeInfo[1]['x'])
return
def init(self, width, height):
size = width*height
nedges = 2*size - width - height
print ('nedges: ', nedges)
self.edges = array([Edge() for i in range(nedges)])
self.dsf = DSF(size)
self.thresholds = self.TH*ones(size)
def __init__(self, center, radius, color):
self.center = center
self.radius = radius
self.color = color
self.filled = True
self.velocity = Edge(self.center, Point(self.center.x, self.center.y), '#00ff00')
self.mass = 1.0
def addEdge(self,
edge=None,
From=None,
to=None,
label=None,
type=None,
renderType=None,
fromToken=None,
toToken=None):
if edge is not None:
self._edges.append(edge)
else:
if fromToken is not None and toToken is not None:
From = fromToken.index
to = toToken.index
if From is not None and to is not None:
#if self.isInvalidEdge(From, to):
# return
From = self._map[From]
to = self._map[to]
label = label
type = type
renderType = renderType
else:
From = self._map[From]
to = self._map[to]
self._edges.append(
Edge(From=From,
To=to,
label=label,
Type=type,
renderType=renderType))
def readEdgeFromTxt(self):
edge_list = []
if self.txtpath:
try:
file = open(self.txtpath, "r")
line = file.readline()
print(line)
s_list = line.split(",")
for s in s_list:
print(s)
# print(len(s))
if s:
# print(s[0])
s = s.strip()
v_s = Vertex(-1, s[0])
v_e = Vertex(-1, s[1])
d = int(s[2])
edge = Edge(v_s, v_e, d)
edge_list.append(edge)
except IOError:
return None
else:
# print(edge_list)
return edge_list
def run(parameters):
file_name = parameters['file_name']
stdOut = parameters['output']
ns = {'xmlns' : 'http://graphml.graphdrawing.org/xmlns', 'graphml' : 'http://www.yworks.com/xml/graphml'}
try:
graph = xml.etree.ElementTree.parse(file_name)
except IOError as e:
stdOut.print_error("Could not open specified file\nDetails:" + str(e))
graphRoot = graph.getroot()
g = graphRoot.find('xmlns:graph', ns)
nodes = g.findall('xmlns:node', ns)
edges = g.findall('xmlns:edge', ns)
for node in nodes:
data = node.findall('xmlns:data', ns)
node_recognized = False
for dataElement in data:
nodeType = None
for type_string in supported_node_types:
if nodeType is None:
nodeType = dataElement.find(type_string, ns)
id = int(node.attrib['id'].strip('n'))
if nodeType is not None:
label = nodeType.find('graphml:NodeLabel', ns).text
if label is None:
label = ''
nodeList.append(Node.Node(id, [], label))
node_recognized = True
if not node_recognized:
stdOut.print_error('Unrecognized node type on graph! Node id: %s' % id)
for edge in edges:
data = edge.findall('xmlns:data', ns)
for dataElement in data:
edgeType = dataElement.find('graphml:PolyLineEdge', ns)
if edgeType is not None:
id = int(edge.attrib['id'].strip('e'))
source = int(edge.attrib['source'].strip('n'))
target = int(edge.attrib['target'].strip('n'))
label = edgeType.find('graphml:EdgeLabel', ns)
if label is not None:
label_text = label.text
else:
label_text = ''
edgeList.append(Edge.Edge(source, target, label_text))
nodeList[source].related_edges.append(edgeList[-1])
else:
stdOut.print_debug("EDGE NOT KNOWN: \n[%s, %s, %s, %s, %s]" % (edgeType, id, source, target, label))
return edgeList, nodeList
def get_edges(self):
id = 0
node_len = len(self.adjacent_node_matrix)
start_from_node = {}
end_with_node = {}
self.edges = {}
self.node_to_edge = {}
for i in range(node_len):
start_from_node[i] = []
end_with_node[i] = []
for i in range(node_len):
for j in range(node_len):
if self.adjacent_node_matrix[i][j] == 0 or i == j:
continue
self.edges[id] = Edge(id, self.nodes[i], self.nodes[j])
self.node_to_edge[(i, j)] = id
start_from_node[i].append(id)
end_with_node[j].append(id)
id += 1
print("edge number: ", id)
# 初始化边邻接矩阵
self.adjacent_edge_matrix = np.zeros([id, id])
for i in range(id):
for j in start_from_node[self.edges[i].end_node.id]:
self.adjacent_edge_matrix[i][j] = 1
def add_edge(self, source, destination, weight):
edge = Edge.Edge(source, destination, weight)
if source not in self.graph_dict:
self.graph_dict[source] = [edge]
else:
self.graph_dict[source].append(edge)
def __init__(self, graph, s):
self.s = s
self.graph = graph
n = graph.vertexs
self.marked = [False for _ in xrange(n)]
self.dist_to = [0 for _ in xrange(n)]
self._from = [None for _ in xrange(n)]
self.mh = IndexMinHeap(n)
self._from[s] = Edge(s, s, 0)
self.marked[s] = True
self.mh.insert(s, self.dist_to[s])
while not self.mh.is_empty():
v = self.mh.extract_min_index()
self.marked[v] = True
for e in self.graph.g[v]:
w = e.other(v)
if not self.marked[w]:
if not self.dist_to[w] or self.dist_to[v] + e.weight < self.dist_to[w]:
self.dist_to[w] = self.dist_to[v] + e.weight
self._from[w] = e
if not self.mh.contain(w):
self.mh.insert(w, self.dist_to[w])
else:
self.mh.change(w, self.dist_to[w])
def addPairProgrammingEdgesToList(self, pairs):
for IDs, info in pairs.items():
edge = Edge.Edge(self.getNodeByID(IDs[0]),
self.getNodeByID(IDs[1]))
edge.setPairProgrammingWeight(info['weight'])
edge.setPairProgCommitList(info['commits'])
self.addEdgeToList(edge)
def freqGraphMining(self):
startTime = datetime.datetime.now()
self.sortAndReLabel()
self.resultGraphs = []
self.totalGraphs = []
for gd in self.totalGraphDatas:
g = Graph()
g = g.constructGraph(gd)
self.totalGraphs.append(g)
self.ef = EdgeFrequency(self.newNodeLabelNum, self.newEdgeLabelNum)
len1 = self.newNodeLabelNum
len2 = self.newEdgeLabelNum
for i in range(len1):
for j in range(len2):
for k in range(len1):
for tempG in self.totalGraphs:
if tempG.hasEdge(i, j, k):
self.ef.edgeFreqCount[i][j][
k] = self.ef.edgeFreqCount[i][j][k] + 1
for i in range(self.newNodeLabelNum):
for j in range(self.newEdgeLabelNum):
for k in range(self.newNodeLabelNum):
if self.ef.edgeFreqCount[i][j][k] >= self.minSupportCount:
gc = GraphCode()
edge = Edge(0, 1, i, j, k)
gc.edgeSeq.append(edge)
for y in range(len(self.totalGraphs)):
if self.totalGraphs[y].hasEdge(i, j, k):
gc.gs.append(y)
self.subMining(gc, 2)
endTime = datetime.datetime.now()
print "Execution time:", (endTime - startTime).seconds, "s"
self.printResultGraphInfo()
def insert_edge(self, id_origin, id_destiny, weight, data):
origin_aux = self.search_vertex_by_data(id_origin)
destiny_aux = self.search_vertex_by_data(id_destiny)
if (origin_aux is not None) and (destiny_aux is not None):
self.list_edges.append(Edge(origin_aux, destiny_aux, weight, data))
else:
print("Um dos Vértices ou ambos são inválidos")
def getInAndOut(A,B, InsAndOuts):
for arestaA in A.Arestas:
count = 0
pontoMedio = getPontoMedioAresta(arestaA)
#pontoMedio[0] = x , pontoMedio[1] = y
newAresta = (Point(-1,pontoMedio.y,0),pontoMedio)
edge = Edge(arestaA[0],arestaA[1])
helper = 0
for arestaB in B.Arestas:
if(hasRetaIntersection(newAresta[0], newAresta[1], arestaB[0], arestaB[1])):
point = getIntersection(newAresta[0], newAresta[1], arestaB[0], arestaB[1])
count += 1
if point in B.Vertices and not findMaxOrMin(point,B.Vertices):
helper += 1
if helper > 0:
count += 1
if(count%2 != 0):
if edge not in InsAndOuts['in']:
InsAndOuts['in'].append(edge)
else:
if edge not in InsAndOuts['out']:
InsAndOuts['out'].append(edge)
return InsAndOuts
def set_node_relations(self, relation_input, other_node, new_relation,
reason, incoming):
cause = reason + self._name
if incoming:
edges = self._incoming_edges
else:
edges = self._outgoing_edges
to_add = []
#Update all the edges
for edge in edges:
attribute = edge.get_name()
#If the other player liked or loved this character
# they should hate the murderer
if attribute.keys()[0] in relation_input:
if incoming:
from_node = edge.get_from_node()
else:
from_node = edge.get_to_node()
if not (from_node == other_node):
new_edge = Edge({new_relation: cause}, from_node,
other_node)
from_node.add_outgoing_edge(new_edge)
other_node.add_incoming_edge(new_edge)
to_add.append(new_edge)
return to_add
def loadGraphFromFile(self, infile):
with open(infile) as f:
lines = f.readlines()
cleanlines = [x.strip() for x in lines
] #strip off any weird leading or trailing spaces.
for line in cleanlines:
line = line.replace('\'', '').replace('[',
'').replace(']', '').replace(
' ', '').strip('()')
rawEdge = line.split(
','
) # now just have nice clean comma-separated values. Make it a list
[l1, l2, label, x1, y1, x2,
y2] = rawEdge # grab all the components of the edge
if l1 not in self.nodeIndex:
self.nodeIndex[l1] = (int(x1), int(y1))
self.nodes.append(Node(int(x1), int(y1), l1))
if l2 not in self.nodeIndex:
self.nodeIndex[l2] = (int(x2), int(y2))
self.nodes.append(Node(int(x2), int(y2), l2))
# Now build and Edge object for it
newEdge = Edge((int(x1), int(y1)), (int(x2), int(y2)), int(label))
newEdge.setLabels(l1, l2)
self.edges.append(newEdge)
f.close()
def deflectFromEdge(self, e):
mSquared = e.x() * e.x() + e.y() * e.y()
p0 = Point(0, 0)
pf = Point((-2 * e.y() * self.velocity.det(e)) / mSquared,
2 * e.x() * self.velocity.det(e) / mSquared)
x = Edge(p0, pf, generateHTMLColor(255, 255, 0))
self.velocity.add(x)
def add_edge(self, v, w, element):
if not v in self._structure or not w in self._structure:
return None
e = Edge(v, w, element)
self._structure[v][w] = e
self._structure[w][v] = e
return e
def toggle_edge(self):
is_present = False
selected_edge = None
for edge in self.edges:
if ((edge.left_vertex == self.left_vertex) and
(edge.right_vertex == self.right_vertex)):
is_present = True
edge.destroy()
selected_edge = edge
break
if (is_present):
self.edges.remove(selected_edge)
# update adjacency lists
self.left_neighbors[self.left_vertex].remove(self.right_vertex)
self.right_neighbors[self.right_vertex].remove(self.left_vertex)
else:
new_edge = ED.Edge(self, self.left_vertex, self.right_vertex,
self.left_size, self.right_size)
games.screen.add(new_edge)
self.edges.append(new_edge)
# update adjacency lists
self.left_neighbors[self.left_vertex].append(self.right_vertex)
self.right_neighbors[self.right_vertex].append(self.left_vertex)
# re-sort lists
self.left_neighbors[self.left_vertex].sort()
self.right_neighbors[self.right_vertex].sort()
# unselect current left and right vertices and set to -1
self.left_branch[self.left_vertex].unselect()
self.right_branch[self.right_vertex].unselect()
self.left_vertex = -1
self.right_vertex = -1
def dfsSearch(self,stack,currentPosition,next):
if currentPosition>=len(self.edgeSeqs):
stack.pop()
return
while not stack.isEmpty():
x = stack.pop()
for i in range(len(self.graph.edgeNexts[x])):
y = self.graph.edgeNexts[x][i]
if self.f[x][y] or self.f[y][x]:
continue
if self.g2s[y]<0:
edge = Edge(self.g2s[x],next,self.graph.nodeLabels[x],
self.graph.edgeLabels[x][i],self.graph.nodeLabels[y])
compareResult = edge.compareWith(self.edgeSeqs[currentPosition])
if compareResult==Edge.edge_smaller:
self.isMin = False
return
elif compareResult==Edge.edge_larger:
continue
self.g2s[y] = next
self.f[x][y] = True
self.f[y][x] = True
stack.push(y)
self.dfsSearch(stack,currentPosition+1,next+1)
if self.isMin!=True:
return
self.f[x][y] = False
self.f[y][x] = False
self.g2s[y] = -1
else:
edge = Edge(self.g2s[x],self.g2s[y],self.graph.nodeLabels[x],
self.graph.edgeLabels[x][i],self.graph.nodeLabels[y])
compareResult = edge.compareWith(self.edgeSeqs[currentPosition])
if compareResult==Edge.edge_smaller:
self.isMin = False;
return
elif compareResult==Edge.edge_larger:
continue
self.g2s[y] = next
self.f[x][y] = True
self.f[y][x] = True
stack.push(y)
self.dfsSearch(stack,currentPosition+1,next)
if self.isMin!=True:
return
self.f[x][y] = False
self.f[x][y] = False
