def generateTriangle(figureInfoArray, cordArray, triangleName,node_root): print("Inside generateTriangle function") write_Name_In_File(triangleName[0]) write_Name_In_File(triangleName[1]) write_Name_In_File(triangleName[2]) side1 = str(triangleName[0] + triangleName[1]) side2 = str(triangleName[1] + triangleName[2]) side3 = str(triangleName[0] + triangleName[2]) angle2 = triangleName angle3 = (side2 + triangleName[0]) angle1 = str(triangleName[1] + triangleName[0]+ triangleName[2]) point1 = triangleName[0] point2 = triangleName[1] point3 = triangleName[2] #Create root node node_triangle, = graph_db.create({"name": triangleName,"type":"triangle"}) if node_triangle : print(" node_triangle is generated") rel_triangle_root = node_root.create_relationship_to(node_triangle, "KD1") # Create three nodes node_a, node_b, node_c = graph_db.create( {"name": side1, "value":figureInfoArray[0],"type":"line"}, {"name": side2, "value":figureInfoArray[1],"type":"line"}, {"name": side3, "value":figureInfoArray[2],"type":"line"} ) # Join the nodes with a HAS relationship rel_triangle_a = node_triangle.create_relationship_to(node_a, "HAS") rel_triangle_b = node_triangle.create_relationship_to(node_b, "HAS") rel_triangle_c = node_triangle.create_relationship_to(node_c, "HAS") rel_a_b, = graph_db.get_or_create_relationships((node_a, "ANGLE",node_b, {"value": figureInfoArray[3]})) rel_b_c, = graph_db.get_or_create_relationships((node_b, "ANGLE",node_c, {"value": figureInfoArray[4]})) rel_a_c, = graph_db.get_or_create_relationships((node_a, "ANGLE",node_c, {"value": figureInfoArray[5]})) #Create input nodes node_point1, node_point2, node_point3= graph_db.create({"name":point1, "cordx":cordArray[0],"cordy":cordArray[1],"type":"point"},{"name":point2, "cordx":cordArray[2],"cordy":cordArray[3],"type":"point"},{"name":point3, "cordx":cordArray[4],"cordy":cordArray[5],"type":"point"}) # Join the nodes with a INPUT relationship rel_a_point1 = node_a.create_relationship_to(node_point1, "CONTAIN") rel_a_point2 = node_a.create_relationship_to(node_point2, "CONTAIN") rel_b_point2 = node_b.create_relationship_to(node_point2, "CONTAIN") rel_b_point3 = node_b.create_relationship_to(node_point3, "CONTAIN") rel_c_point1 = node_c.create_relationship_to(node_point1, "CONTAIN") rel_c_point3 = node_c.create_relationship_to(node_point3, "CONTAIN") # Join the point nodes with a CONNECTED relationship node_point1.create_relationship_to(node_point2, "CONNECTED") node_point2.create_relationship_to(node_point3, "CONNECTED") node_point1.create_relationship_to(node_point3, "CONNECTED") print("Exiting generate triangle function")
def check_join_Existing_three_non_collinear_non_connected_Points(): print("Pick existing set of three non collinear points which are not connected") global count_row global dict_three_point count_row = 0 dict_three_point = [] query = "START b=node(*),a=node(*),c=node(*) MATCH a-[r?:CONNECTED]-b, b-[s?:CONNECTED]-c,c-[t?:CONNECTED]-a WHERE NOT(a = b) AND NOT(b = c) AND NOT(a = c) AND b.type = {B} AND a.type = {B} AND c.type = {B} AND t IS NULL AND s IS NULL AND r IS NULL RETURN a,b,c" cypher.execute(graph_db, query, {"B":"point"}, row_handler=print_three_points_row) #global count_row if count_row == 0: print(" Not found 3 points, hence exiting from this function") return False #Join these points and add info to the triangle TODO (Please fill the values of angle and length in the below code) randomSet = check_saveObjFigure("Triangle_three_existing_points") print( "first selectedPoint is " +randomSet[0][0]) print( "second selectedPoint is " +randomSet[0][1]) print( "third selectedPoint is " +randomSet[0][2]) query = "START a=node(*) WHERE a.type = {A} AND a.name = {B} return a" data,metadata = cypher.execute(graph_db, query, {"A" :"point","B":randomSet[0][0]}) node1 = data[0][0] query = "START a=node(*) WHERE a.type = {A} AND a.name = {B} return a" data,metadata = cypher.execute(graph_db, query, {"A" :"point","B":randomSet[0][1]}) node2 = data[0][0] query = "START a=node(*) WHERE a.type = {A} AND a.name = {B} return a" data,metadata = cypher.execute(graph_db, query, {"A" :"point","B":randomSet[0][2]}) node3 = data[0][0] node1.create_relationship(node2, "CONNECTED") node2.create_relationship(node3, "CONNECTED") node3.create_relationship(node1, "CONNECTED") sideName1 = node1["name"] + node2["name"] sideName2 = node2["name"] + node3["name"] sideName3 = node1["name"] + node3["name"] node_a, node_b, node_c = graph_db.create( {"name": sideName1, "value":quesArray[0],"type":"line"}, {"name": sideName2, "value":quesArray[1],"type":"line"}, {"name": sideName3, "value":quesArray[2],"type":"line"}) node_a.create_relationship_to(node_b, "ANGLE") node_b.create_relationship_to(node_c, "ANGLE") node_c.create_relationship_to(node_a, "ANGLE") triangleName = node1["name"] + node2["name"] + node3["name"] addTriangle(triangleName) count_row = 0 print("exiting from check_join_Existing_three_non_collinear_non_connected_Points function") return True
def addPointOnLine(pointName,cordx,cordy,lineName, line1Length, line2Length,node_triangle): print("Inside addPointOnLine function and lineName is "+ lineName + " and pointName is "+pointName) #Getting the node of line for making collinear relationship query = "START z=node(*) WHERE z.name={A} AND z.type = {B} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": lineName, "B":"line"}) temp = data[0][0] print(temp["name"]) #Create two nodes for two new lines made line1Name = lineName[0]+pointName line2Name = lineName[1]+pointName node_line1new, = graph_db.create({"name": line1Name, "value":line1Length,"type":"line"}) node_line2new, = graph_db.create({"name": line2Name, "value":line2Length,"type":"line"}) #Create a new node for point node_new, = graph_db.create({"name": pointName, "cordx":cordx,"cordy":cordy,"type":"point"}) #Get othernodes of given line nodeCollection = temp.get_related_nodes(0,"CONTAIN") for node in nodeCollection: node.create_relationship_to(node_new, "COLLINEAR") node.create_relationship_to(node_new, "MIDPOINT") graph_db.get_or_create_relationships((node, "CONNECTED",node_new)) #Create new relationships between these two new lines and points node_line1new.create_relationship_to(node_new, "CONTAIN") node_line2new.create_relationship_to(node_new, "CONTAIN") for node in nodeCollection: if(node["name"] == lineName[0]): node_line1new.create_relationship_to(node, "CONTAIN") if(node["name"] == lineName[1]): node_line2new.create_relationship_to(node, "CONTAIN") #Create new relationships between these two new lines and triangle node_triangle.create_relationship_to(node_line1new, "INDIRECTLY_HAS") node_triangle.create_relationship_to(node_line2new, "INDIRECTLY_HAS") print("Exiting addPointOnLine function")
def addTriangle(triangleName): print("Inside addTriangleName function") #This function will save triangle which will help in checking changeTriangle #save_triangle.append(triangleName) node_new, = graph_db.create({"name":triangleName,"type":"triangle"}) node_root.create_relationship_to(node_new, "KD1") side1 = triangleName[0]+ triangleName[1] side4 = triangleName[1]+ triangleName[0] side5 = triangleName[2]+ triangleName[1] side6 = triangleName[0]+ triangleName[2] side2 = triangleName[1]+ triangleName[2] side3 = triangleName[2]+ triangleName[0] query = "START z=node(*) WHERE z.name={A} OR z.name={B} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": side1, "B":side4}) temp1 = data[0][0] print(temp1["name"]) query = "START z=node(*) WHERE z.name={A} OR z.name={B} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": side2, "B":side5}) temp2 = data[0][0] print(temp2["name"]) query = "START z=node(*) WHERE z.name={A} OR z.name={B} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": side3, "B":side6}) temp3 = data[0][0] print(temp3["name"]) #graph_db.get_or_create_relationships(node_new, "HAS",temp1) node_new.create_relationship_to(temp1, "HAS") node_new.create_relationship_to(temp2, "HAS") node_new.create_relationship_to(temp3, "HAS") #graph_db.get_or_create_relationships(node_new, "HAS",temp2) #graph_db.get_or_create_relationships(node_new, "HAS",temp3) print("Exiting addTriangleName function")
from __future__ import print_function # Import Neo4j modules from py2neo import neo4j, cypher from macro import graph_db, node_root # Attach to the graph db instance #graph_db = neo4j.GraphDatabaseService("http://localhost:7474/db/data/") #graph_db.clear() #Create root node #root = "Root" #node_root, = graph_db.create({"name":root,"type":"node"}) node_kd2, = graph_db.create({"name": "THEOREM1","type":"node"}) node_root.create_relationship_to(node_kd2, "KD2") node_triangle, = graph_db.create({"name": "ABC","type":"triangle"}) node_kd2.create_relationship_to(node_triangle, "Pythagorean") # Create three nodes node_a, node_b, node_c = graph_db.create( {"name": "AB","type":"line"}, {"name": "BC","type":"line"}, {"name": "CA","type":"line"} ) # Join the nodes with a HAS relationship rel_triangle_a = node_triangle.create_relationship_to(node_a, "HAS") rel_triangle_b = node_triangle.create_relationship_to(node_b, "HAS") rel_triangle_c = node_triangle.create_relationship_to(node_c, "HAS")
def addLineInTriangle(lineName, length, ang1, ang2,ang3,ang4,node_triangle): print("Inside addLineInTriangle function") node_new, = graph_db.create({"name": lineName, "value":length,"type":"line"}) node_triangle.create_relationship_to(node_new, "INDIRECTLY_HAS") query = "START z=node(*) WHERE z.name={A} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": lineName[0]}) temp = data[0][0] print(temp["name"]) query = "START z=node(*) WHERE z.name={A} RETURN z" data, metadata = cypher.execute(graph_db, query, {"A": lineName[1]}) temp1 = data[0][0] print(temp1["name"]) node_new.create_relationship_to(temp, "CONTAIN") node_new.create_relationship_to(temp1, "CONTAIN") graph_db.get_or_create_relationships((temp, "CONNECTED",temp1)) p1 = [temp["cordx"],temp["cordy"]] p2 = [temp1["cordx"],temp1["cordy"]] print("Find all possible triangles formed by adding this line TODO") query = "START z=node({B}), c=node({C}) MATCH z-[:CONNECTED]-b-[:CONNECTED]-c WHERE z.type={A} AND c.type={A} RETURN b" data, metadata = cypher.execute(graph_db, query, {"A": "point","B": temp.id,"C":temp1.id}) for row in data: print(row[0]["name"]) tempPoint = str(row[0]["name"]) if tempPoint in lineName: print("found point "+ tempPoint) else: tempSide1 = lineName + tempPoint print("calling addTriangle for " + tempSide1) addTriangle(tempSide1) #Compute angles and addAngleRelationship TODO p3 = [row[0]["cordx"],row[0]["cordy"]] print("Before calculating angle for first point") print(p1) print(p2) print(p3) ang1 = 10 #TODO angle_lines(p1, p2, p1, p3) temp.create_relationship_to(row[0], "ANGLE", {"value": ang1}) graph_db.get_or_create_relationships((temp, "CONNECTED",row[0])) ''' query = "START z=node({B}) MATCH z-[:CONNECTED]-b WHERE z.type={A} RETURN b" data, metadata = cypher.execute(graph_db, query, {"A": "point","B": temp1.id}) for row in data: print(row[0]["name"]) tempPoint = str(row[0]["name"]) if tempPoint in lineName: print("found point "+ tempPoint) else: tempSide1 = lineName + tempPoint print("calling addTriangle for " + tempSide1) addTriangle(tempSide1) #Compute angles and addAngleRelationship TODO p3 = [row[0]["cordx"],row[0]["cordy"]] print("Before calculating angle for second point") print(p1) print(p2) print(p3) ang1 = 10 #TODO angle_lines(p1, p2, p2, p3) temp.create_relationship_to(row[0], "ANGLE", {"value": ang1}) graph_db.get_or_create_relationships((temp, "CONNECTED",row[0])) #print("Add triangles via hardcoding") #addTriangle("PSR") #addTriangle("PSQ") ''' print("Exiting addLineInTriangle function")