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