void outer( Point3d pentagon[5], Point3d * output) {
for(int i=0; i<5; i++) {
Line3d edge1(pentagon[i], pentagon[(i+1)%5]);
Line3d edge4(pentagon[(i+3)%5], pentagon[(i+4)%5]);
Point3d* ppt = (Point3d*)edge1.intersection(edge4);
if (!ppt) {
std::cout << "INCORRECT!!! diagonal lines are disjoint or identical" << std::endl;
exit(0);
}
output[i] = *ppt;
}
}
void Graph::seedNodesAndEdges()
{
/* Upon construction: seed graph with nodes and edges to connect them.
* For now this happens manually. Ideally this happens by algorithm */
std::shared_ptr<Node> nodeA(new Node(0, "0", 100, 50));
std::shared_ptr<Node> nodeB(new Node(1, "1", 500, 40));
std::shared_ptr<Node> nodeC(new Node(2, "2", 200, 300));
std::shared_ptr<Node> nodeD(new Node(3, "3", 700, 100));
std::shared_ptr<Node> nodeE(new Node(4, "4", 600, 400));
std::shared_ptr<Node> nodeF(new Node(5, "5", 250, 450));
std::shared_ptr<Node> nodeG(new Node(6, "6", 750, 500));
std::shared_ptr<Node> nodeH(new Node(7, "7", 400, 150));
std::shared_ptr<Node> nodeI(new Node(8, "8", 550, 250));
std::shared_ptr<Node> nodeJ(new Node(9, "9", 100, 400));
std::list<std::shared_ptr<Edge>> edgeList; // Sequenced container of Edge pointers
nodeVector.push_back(nodeA);
std::shared_ptr<Edge> edge1(new Edge(nodeA, nodeB, calculateCost(nodeA, nodeB)));
edgeList.push_back(edge1);
std::shared_ptr<Edge> edge2(new Edge(nodeA, nodeC, calculateCost(nodeA, nodeC)));
edgeList.push_back(edge2);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeB);
std::shared_ptr<Edge> edge3(new Edge(nodeB, nodeA, calculateCost(nodeB, nodeA)));
edgeList.push_back(edge3);
std::shared_ptr<Edge> edge4(new Edge(nodeB, nodeH, calculateCost(nodeB, nodeH)));
edgeList.push_back(edge4);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeC);
std::shared_ptr<Edge> edge5(new Edge(nodeC, nodeA, calculateCost(nodeC, nodeA)));
edgeList.push_back(edge5);
std::shared_ptr<Edge> edge6(new Edge(nodeC, nodeH, calculateCost(nodeC, nodeH)));
edgeList.push_back(edge6);
std::shared_ptr<Edge> edge7(new Edge(nodeC, nodeE, calculateCost(nodeC, nodeE)));
edgeList.push_back(edge7);
std::shared_ptr<Edge> edge8(new Edge(nodeC, nodeF, calculateCost(nodeC, nodeF)));
edgeList.push_back(edge8);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeD);
std::shared_ptr<Edge> edge9(new Edge(nodeD, nodeH, calculateCost(nodeD, nodeH)));
edgeList.push_back(edge9);
std::shared_ptr<Edge> edge10(new Edge(nodeD, nodeE, calculateCost(nodeD, nodeE)));
edgeList.push_back(edge10);
std::shared_ptr<Edge> edge11(new Edge(nodeD, nodeG, calculateCost(nodeD, nodeG)));
edgeList.push_back(edge11);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeE);
std::shared_ptr<Edge> edge12(new Edge(nodeE, nodeC, calculateCost(nodeE, nodeC)));
edgeList.push_back(edge12);
std::shared_ptr<Edge> edge13(new Edge(nodeE, nodeD, calculateCost(nodeE, nodeD)));
edgeList.push_back(edge13);
std::shared_ptr<Edge> edge14(new Edge(nodeE, nodeG, calculateCost(nodeE, nodeG)));
edgeList.push_back(edge14);
std::shared_ptr<Edge> edge15(new Edge(nodeE, nodeI, calculateCost(nodeE, nodeI)));
edgeList.push_back(edge15);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeF);
std::shared_ptr<Edge> edge16(new Edge(nodeF, nodeG, calculateCost(nodeF, nodeG)));
edgeList.push_back(edge16);
std::shared_ptr<Edge> edge17(new Edge(nodeF, nodeC, calculateCost(nodeF, nodeC)));
edgeList.push_back(edge17);
std::shared_ptr<Edge> edge18(new Edge(nodeF, nodeJ, calculateCost(nodeF, nodeJ)));
edgeList.push_back(edge18);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeG);
std::shared_ptr<Edge> edge19(new Edge(nodeG, nodeF, calculateCost(nodeG, nodeF)));
edgeList.push_back(edge19);
std::shared_ptr<Edge> edge20(new Edge(nodeG, nodeD, calculateCost(nodeG, nodeD)));
edgeList.push_back(edge20);
std::shared_ptr<Edge> edge21(new Edge(nodeG, nodeE, calculateCost(nodeG, nodeE)));
edgeList.push_back(edge21);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeH);
std::shared_ptr<Edge> edge22(new Edge(nodeH, nodeD, calculateCost(nodeH, nodeD)));
edgeList.push_back(edge22);
std::shared_ptr<Edge> edge23(new Edge(nodeH, nodeC, calculateCost(nodeH, nodeC)));
edgeList.push_back(edge23);
std::shared_ptr<Edge> edge24(new Edge(nodeH, nodeB, calculateCost(nodeH, nodeB)));
edgeList.push_back(edge24);
std::shared_ptr<Edge> edge25(new Edge(nodeH, nodeI, calculateCost(nodeH, nodeI)));
edgeList.push_back(edge25);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeI);
std::shared_ptr<Edge> edge26(new Edge(nodeI, nodeH, calculateCost(nodeI, nodeH)));
edgeList.push_back(edge26);
std::shared_ptr<Edge> edge27(new Edge(nodeI, nodeE, calculateCost(nodeI, nodeE)));
edgeList.push_back(edge27);
edgeListVector.push_back(edgeList);
edgeList.clear();
nodeVector.push_back(nodeJ);
std::shared_ptr<Edge> edge28(new Edge(nodeJ, nodeF, calculateCost(nodeJ, nodeF)));
edgeList.push_back(edge28);
edgeListVector.push_back(edgeList);
edgeList.clear();
}
