int UltimateTicTacToeMontecarloAI::expand(int leafIndex, Nodes& nodes, int const player) const
{
Node& node = nodes[leafIndex];
node.children.reserve(maxChildren);
Moves options = movementOptions(node.board, node.previousMove);
int turn = node.previousMove > 0 ? otherPlayer(node.board.grids.at(node.previousMove)) : player;
int mostPromisingChildIndex = -1;
int mostPromisingChildScore = 0;
while(node.children.size() < maxChildren && !options.empty())
{
Move move = options.takeAt(qrand() % options.size());
int childIndex = nodes.size();
node.children.append(childIndex);
Board newBoard(node.board);
nodes.append( Node {0, 1, playMove(newBoard, move, turn), move, leafIndex, Node::Children()});
int score = scoreBoard(nodes.last().board, player);
if(score > mostPromisingChildScore || mostPromisingChildIndex < 0)
{
mostPromisingChildIndex = childIndex;
mostPromisingChildScore = score;
}
}
return mostPromisingChildIndex;
}
//----------------------------------------------------------------------
// Connecting a node
//----------------------------------------------------------------------
NodePtr LocalNode::connect( const NodeID& nodeID )
{
EQASSERT( nodeID != NodeID::ZERO );
EQASSERT( _state == STATE_LISTENING );
Nodes nodes;
getNodes( nodes );
for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i )
{
NodePtr peer = *i;
if( peer->getNodeID() == nodeID && peer->isConnected( )) // early out
return peer;
}
for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i )
{
NodePtr peer = *i;
NodePtr node = _connect( nodeID, peer );
if( node.isValid( ))
return node;
}
EQWARN << "Node " << nodeID << " connection failed" << std::endl;
return 0;
}
void VirtualMachinesAssigner::getAvailableNodeAssignments(Element* element, std::map<Node*, std::vector<Node*> >& VMsOnNode, std::map<Node*, Assignment* >& vmAssignment, Assignment* assignment)
{
Nodes::iterator nodesIt = network->getNodes().begin();
Nodes::iterator nodesItEnd = network->getNodes().end();
for ( ; nodesIt != nodesItEnd; ++nodesIt )
{
// inserting only vms with capacity less then the element's one
VMsOnNode[*nodesIt] = std::vector<Node *>();
// going through all other assigned requests
RequestAssignment::iterator it = requestAssignment.begin();
RequestAssignment::iterator itEnd = requestAssignment.end();
for ( ; it != itEnd; ++it )
{
Nodes vms = it->second->GetAssigned(*nodesIt);
Nodes::iterator vmIt = vms.begin();
Nodes::iterator vmItEnd = vms.end();
for ( ; vmIt != vmItEnd; ++vmIt )
{
VMsOnNode[*nodesIt].push_back(*vmIt);
vmAssignment[*vmIt] = it->second;
}
}
}
}
Elements Region::buildElements(Nodes& Base)
{
Elements Result;
if(typ==1)
{
if(numofrows<=numofcols)
{
for(int i=0;i<numofcols;i++)
for(int j=0;j<numofrows;j++)
{
Result.push_back(Triangle(Base,i*(numofrows+1)+j,i*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j),Element(i*(numofrows+1)+j,i*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j));
Result.push_back(Triangle(Base,i*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j),Element(i*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j));
if(i==0&&CONDLEFT) Result.addcondition(Border(true,j,j+1,Base.node(j),Base.node(j+1),ENV_TEMPLEFT));
if(i==numofcols-1&&CONDRIGHT) Result.addcondition(Border(true,(numofcols)*(numofrows+1)+j,(numofcols)*(numofrows+1)+j+1,Base.node((numofcols)*(numofrows+1)+j),Base.node((numofcols)*(numofrows+1)+j+1),ENV_TEMPRIGHT));
if(j==0&&CONDDOWN) Result.addcondition(Border(true,(i)*(numofrows+1)+j,(i+1)*(numofrows+1)+j,Base.node((i)*(numofrows+1)+j),Base.node((i+1)*(numofrows+1)+j),ENV_TEMPDOWN));
if(j==numofrows-1&&CONDUP) Result.addcondition(Border(true,(i)*(numofrows+1)+j+1,(i+1)*(numofrows+1)+j+1,Base.node((i)*(numofrows+1)+j+1),Base.node((i+1)*(numofrows+1)+j+1),ENV_TEMPUP));
}
}
else
{
for(int j=0;j<numofrows;j++)
for(int i=0;i<numofcols;i++)
{
Result.push_back(Triangle(Base,j*(numofcols+1)+i,j*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i),Element(j*(numofcols+1)+i,j*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i));
Result.push_back(Triangle(Base,j*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i),Element(j*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i));
if(j==0&&CONDDOWN) Result.addcondition(Border(true,i,i+1,Base.node(i),Base.node(i+1),ENV_TEMPDOWN));
if(j==numofrows-1&&CONDUP) Result.addcondition(Border(true,(numofrows)*(numofcols+1)+i,(numofrows)*(numofcols+1)+i+1,Base.node((numofrows)*(numofcols+1)+i),Base.node((numofrows)*(numofcols+1)+i+1),ENV_TEMPUP));
if(i==0&&CONDLEFT) Result.addcondition(Border(true,(j)*(numofcols+1)+i,(j+1)*(numofcols+1)+i,Base.node((j)*(numofcols+1)+i),Base.node((j+1)*(numofcols+1)+i),ENV_TEMPLEFT));
if(i==numofcols-1&&CONDRIGHT) Result.addcondition(Border(true,(j)*(numofcols+1)+i+1,(j+1)*(numofcols+1)+i+1,Base.node((j)*(numofcols+1)+i+1),Base.node((j+1)*(numofcols+1)+i+1),ENV_TEMPRIGHT));
}
}
}
return Result;
}
void
LineMerger::buildEdgeStringsForUnprocessedNodes()
{
#if GEOS_DEBUG
cerr<<__FUNCTION__<<endl;
#endif
typedef std::vector<Node*> Nodes;
Nodes nodes;
graph.getNodes(nodes);
for (Nodes::size_type i=0, in=nodes.size(); i<in; ++i) {
Node *node=nodes[i];
#if GEOS_DEBUG
cerr<<"Node "<<i<<": "<<*node<<endl;
#endif
if (!node->isMarked()) {
assert(node->getDegree()==2);
buildEdgeStringsStartingAt(node);
node->setMarked(true);
#if GEOS_DEBUG
cerr<<" setMarked(true) : "<<*node<<endl;
#endif
}
}
}
static void Compute(Nodes &nodes, AccSubAlgorithm accSubAlgorithm, AccTest *accTest)
{
#ifdef ACCSUB_TRACE
Timer::TimeStamp("ComputationsParallelOMP start");
Timer::Time start = Timer::Now();
if (accSubAlgorithm == AccSubAlgorithm::AccSubIG)
{
std::cout<<"using AccSubIG"<<std::endl;
}
else
{
std::cout<<"using AccSubST"<<std::endl;
}
#endif
#pragma omp parallel for
for (typename Nodes::iterator i = nodes.begin(); i != nodes.end(); i++)
{
ComputationsLocal<PartitionGraph>::CreateIncidenceGraph(*i, accSubAlgorithm, accTest);
#ifdef ACCSUB_TRACE
Timer::TimeStamp("incidence graph calculated");
#endif
}
#ifdef ACCSUB_TRACE
Timer::TimeStamp("ComputationsParallelOMP end");
Timer::TimeFrom(start, "total distributed computations");
#endif
}
bool OSR::isNoArrayInLoop(LoopNode* lnode, SsaOpnd* iv) {
Nodes nodes = lnode->getNodesInLoop();
StlVector < Node* >::iterator iter = nodes.begin(), end = nodes.end();
for (; iter != end; iter++) {
Node* node = *iter;
Inst* last_inst = (Inst*) node->getLastInst();
for (Inst* iter1 = (Inst*) node->getFirstInst();
iter1 != last_inst; iter1 = iter1->getNextInst()) {
Inst inst = *iter1;
if (inst.getOpcode() == Op_AddScaledIndex) {
Opnd* opnd = inst.getSrc(1);
findLeadingOpnd(&inst, (SsaOpnd*) opnd);
SsaOpnd* lop = getLeadingOperand((SsaOpnd*) opnd);
if (lop != 0) {
SsaOpnd* ivlop = getLeadingOperand(iv);
if (lop == ivlop) {
return false;
}
}
}
}
}
return true;
}
Nodes Region::buildnodes()
{
Nodes Result;
srand(unsigned(time(0)));
if(typ==1)
{
double steph=double(PIXELSH)/numofrows,stepw=double(PIXELSW)/numofcols;
if(numofrows<=numofcols)
{
for(int i=0;i<=numofcols;i++)
for(int j=0;j<=numofrows;j++)
//Result.push_back(Point(stepw*i,steph*j),sqrt(stepw*i*stepw*i+steph*j*steph*j)/PIXELSH*50-50);
//Result.push_back(Point(stepw*i,steph*j),double(rand())/RAND_MAX*200-100);
Result.push_back(Point(stepw*i,steph*j),0);
}
else
{
for(int j=0;j<=numofrows;j++)
for(int i=0;i<=numofcols;i++)
//Result.push_back(Point(stepw*i,steph*j),sqrt(stepw*i*stepw*i+steph*j*steph*j)/PIXELSH*50-50);
//Result.push_back(Point(stepw*i,steph*j),double(rand())/RAND_MAX*200-100);
Result.push_back(Point(stepw*i,steph*j),0);
}
}
return Result;
}
//---------------------------------------------------------------------------
// identifier master node mapping
//---------------------------------------------------------------------------
NodeID ObjectStore::_findMasterNodeID( const base::UUID& identifier )
{
EQ_TS_NOT_THREAD( _commandThread );
// OPT: look up locally first?
Nodes nodes;
_localNode->getNodes( nodes );
// OPT: send to multiple nodes at once?
for( Nodes::iterator i = nodes.begin(); i != nodes.end(); i++ )
{
NodePtr node = *i;
EQLOG( LOG_OBJECTS ) << "Finding " << identifier << " on " << node
<< std::endl;
NodeFindMasterNodeIDPacket packet;
packet.requestID = _localNode->registerRequest();
packet.identifier = identifier;
node->send( packet );
NodeID masterNodeID = base::UUID::ZERO;
_localNode->waitRequest( packet.requestID, masterNodeID );
if( masterNodeID != base::UUID::ZERO )
{
EQLOG( LOG_OBJECTS ) << "Found " << identifier << " on "
<< masterNodeID << std::endl;
return masterNodeID;
}
}
return base::UUID::ZERO;
}
void Apta::generateData()
{
Q nodeIds;
Fp acceptedNodes;
Fm rejectedNodes;
Nodes allNodes;
allNodes.insert(this->_redNodes.begin(), this->_redNodes.end());
allNodes.insert(this->_blueNodes.begin(), this->_blueNodes.end());
allNodes.insert(this->_whiteNodes.begin(), this->_whiteNodes.end());
for (pair<string, string> node : allNodes) {
if (node.second == Apta::ACCEPTED) {
acceptedNodes.insert(node.first);
} else if (node.second == Apta::REJECTED) {
rejectedNodes.insert(node.first);
}
nodeIds.insert(node.first);
}
this->_data.Q = nodeIds;
this->_data.Z = this->_alphabet;
this->_data.s = this->_rootId;
this->_data.Fp = acceptedNodes;
this->_data.Fm = rejectedNodes;
}
QObjectList loadAll(NodeObjectMap &map) {
Nodes nodes;
Triples candidates = m_s->match(Triple(Node(), Uri("a"), Node()));
foreach (Triple t, candidates) {
if (t.c.type != Node::URI) continue;
nodes.push_back(t.a);
}
LoadState state;
state.requested = nodes;
state.map = map;
state.loadFlags = LoadState::IgnoreUnknownTypes;
collect(state);
load(state);
map = state.map;
QObjectList objects;
foreach (Node n, nodes) {
QObject *o = map.value(n);
if (o) objects.push_back(o);
}
static bool checkDesired(vpsc::Dim dim, const Nodes& nodes,
const Rectangles& targets, const ResizeMap& resizeMap)
{
for (Nodes::const_iterator i=nodes.begin();i!=nodes.end();++i) {
const Node* v=*i;
const unsigned id=v->id;
const Rectangle* t=targets[id];
ResizeMap::const_iterator j=resizeMap.find(id);
if(j==resizeMap.end()) {
COLA_ASSERT(approx_equals(v->var->desiredPosition,
t->getCentreD(dim)));
}
}
for(ResizeMap::const_iterator j=resizeMap.begin();j!=resizeMap.end();++j) {
const unsigned id=j->first;
const ResizeInfo& ri=j->second;
COLA_ASSERT(ri.orig->id==id);
const Node *ln=ri.lhsNode, *cn=nodes[id], *rn=ri.rhsNode;
COLA_ASSERT(ln->id==id);
COLA_ASSERT(cn->id==id);
COLA_ASSERT(rn->id==id);
const Rectangle* t=targets[id];
const double lp = t->getMinD(dim) + DW2,
cp = t->getCentreD(dim),
rp = t->getMaxD(dim) - DW2;
COLA_ASSERT(approx_equals(lp,ln->var->desiredPosition));
COLA_ASSERT(approx_equals(cp,cn->var->desiredPosition));
COLA_ASSERT(approx_equals(rp,rn->var->desiredPosition));
}
return true;
}
static void PrintNodes(std::ostream &str, const Nodes &nodes)
{
for (typename Nodes::const_iterator i = nodes.begin(); i != nodes.end(); i++)
{
PrintSimplex(str, (*i)->simplex);
}
}
bool TypeHierarchy::closure(Graph & gr,GI & gi,Nodes & vs,GI & gs,const TypeRef * t)
{
if(gi == gr.end())
{
return false;
};
if(*(gi->first) == *t)
{
for(Nodes::const_iterator i = vs.begin();i != vs.end();++i)
{
gs->second.insert(*i);
//insert(vs.begin(),vs.end());
};
//gs->second.insert(vs.begin(),vs.end());
return true;
};
for(Nodes::iterator n = gi->second.begin();n != gi->second.end();++n)
{
if(vs.find(*n) == vs.end())
{
vs.insert(*n);
GI tmp = gr.find(*n);
if(closure(gr,tmp,vs,gs,t)) return true;
};
};
return false;
};
void Config::_stopNodes()
{
// wait for the nodes to stop, destroy entities, disconnect
Nodes stoppingNodes;
const Nodes& nodes = getNodes();
for( Nodes::const_iterator i = nodes.begin(); i != nodes.end(); ++i )
{
Node* node = *i;
const State state = node->getState();
if( state != STATE_STOPPED && state != STATE_FAILED )
continue;
LBASSERT( !node->isActive() || state == STATE_FAILED );
if( node->isApplicationNode( ))
continue;
co::NodePtr netNode = node->getNode();
if( !netNode ) // already disconnected
continue;
LBLOG( LOG_INIT ) << "Exiting node" << std::endl;
if( state == STATE_FAILED )
node->setState( STATE_STOPPED );
stoppingNodes.push_back( node );
LBASSERT( netNode.isValid( ));
netNode->send( fabric::CMD_SERVER_DESTROY_CONFIG )
<< getID() << LB_UNDEFINED_UINT32;
netNode->send( fabric::CMD_CLIENT_EXIT );
}
// now wait that the render clients disconnect
uint32_t nSleeps = 50; // max 5 seconds for all clients
for( Nodes::const_iterator i = stoppingNodes.begin();
i != stoppingNodes.end(); ++i )
{
Node* node = *i;
co::NodePtr netNode = node->getNode();
node->setNode( 0 );
if( nSleeps )
while( netNode->isConnected() && --nSleeps )
lunchbox::sleep( 100 ); // ms
if( netNode->isConnected( ))
{
co::LocalNodePtr localNode = getLocalNode();
LBASSERT( localNode.isValid( ));
LBWARN << "Forcefully disconnecting exited render client node"
<< std::endl;
localNode->disconnect( netNode );
}
LBLOG( LOG_INIT ) << "Disconnected node" << std::endl;
}
}
int Test::count_per_qid(const Nodes& nodes, const Qid& qid) const
{
int count = 0;
for (Nodes::const_iterator ni = nodes.begin(); ni != nodes.end(); ++ni) {
if (ni->qid == qid) ++count;
}
return count;
}
void
PolygonizeGraph::computeNextCWEdges()
{
typedef std::vector<Node*> Nodes;
Nodes pns; getNodes(pns);
// set the next pointers for the edges around each node
for(Nodes::size_type i=0, in=pns.size(); i<in; ++i) {
Node *node=pns[i];
computeNextCWEdges(node);
}
}
static void PrintAccSub(std::ostream &str, const Nodes &nodes)
{
for (typename Nodes::const_iterator i = nodes.begin(); i != nodes.end(); i++)
{
if ((*i)->IsInAccSub())
{
PrintSimplex(str, *((*i)->simplex));
}
}
str<<std::endl;
}
void split() {
Nodes nodes;
Edges es;
printf("test: bend2()\n");
addNode(nodes,100,100,40,20);
addNode(nodes,100,130,40,20);
addNode(nodes,70,160,40,20);
addNode(nodes,180,190,40,20);
EdgePoints p1;
addToPath(p1,nodes[0],EdgePoint::CENTRE);
addToPath(p1,nodes[1],EdgePoint::BL);
addToPath(p1,nodes[1],EdgePoint::TL);
addToPath(p1,nodes[3],EdgePoint::CENTRE);
es.push_back(new Edge(100,p1));
EdgePoints p2;
addToPath(p2,nodes[2],EdgePoint::CENTRE);
addToPath(p2,nodes[3],EdgePoint::CENTRE);
es.push_back(new Edge(50,p2));
const size_t V = nodes.size();
vpsc::Constraints cs;
vpsc::Variables vs;
getVariables(nodes,vs);
{ // scope for t, so that t gets destroyed before es
TopologyConstraints t(vpsc::HORIZONTAL,nodes,es,vs,cs);
writeFile(nodes,es,"split-0.svg");
// test computeStress
double stress=t.computeStress();
printf("Stress=%f\n",stress);
//assert(fabs(expectedStress-stress)<1e-4);
valarray<double> g(V);
cola::SparseMap h(V);
for(unsigned i=1;i<5;i++) {
g=0;
h.clear();
t.gradientProjection(g,h);
stringstream ss;
ss << "split-" << i << ".svg";
writeFile(nodes,es,ss.str().c_str());
}
}
for_each(nodes.begin(),nodes.end(),delete_node());
for_each(es.begin(),es.end(),delete_object());
for_each(cs.begin(),cs.end(),delete_object());
for_each(vs.begin(),vs.end(),delete_object());
}
Nodes *av_to_nodes(pTHX_ SV *from_)
{
Nodes *ret = new Nodes();
AV *from = (AV *)((SvROK(from_)) ? SvRV(from_) : from_);
int size = av_len(from);
for (int i = 0; i <= size; i++) {
SV *arg = (SV *)*av_fetch(from, i, FALSE);
ret->push_back(hv_to_node(aTHX_ arg));
}
return ret;
}
Channel* Config::getChannel( const ChannelPath& path )
{
Nodes nodes = getNodes();
LBASSERTINFO( nodes.size() > path.nodeIndex,
nodes.size() << " <= " << path.nodeIndex );
if( nodes.size() <= path.nodeIndex )
return 0;
return nodes[ path.nodeIndex ]->getChannel( path );
}
//Directory
string Directory::path() const
{
ostringstream oss;
Nodes nodes = pathFromRoot();
for (auto node = nodes.begin(); node != nodes.end(); ++node)
{
if (node != nodes.begin())
oss << "/";
oss << (*node)->name;
}
return oss.str();
}
string filename()
{
ostringstream oss;
Nodes nodes = pathFromRoot();
for (auto node = nodes.begin(); node != nodes.end(); ++node)
{
if (node != nodes.begin())
oss << "/";
oss << (*node)->name;
}
return oss.str();
}
Nodes Test::parse_nodes(const char *nodes_str) const
{
Nodes nodes;
std::vector<int> array = parse_int_array(nodes_str);
assert(array.size() % 2 == 0);
for (int i = 0; i < array.size(); i += 2) {
int qid(array[i]);
int kid(array[i+1]);
nodes.push_back(Node(qid, kid));
}
return nodes;
}
static void neighbors(Node *n, Nodes &r, NodePool &p, const Grid &g) {
Tile v[16];
size_t s = g.adjacent(n->tile, v, COUNTOF(v));
r.clear();
for (Tile *t = v; t < v + s; ++t) {
float c = g.get(*t);
if (c > 0.1f) {
Node *a = new (p) Node(*t, c);
r.push_back(a);
}
}
}
void write_vertices(Nodes const& nodes, string vertex_filename)
{
ofstream of(vertex_filename.c_str());
give_wide_permissions(vertex_filename.c_str());
for (Nodes::const_iterator it = nodes.begin(), end = nodes.end();
it != end; ++it) {
of << (*it)->pos()[0] << " "
<< (*it)->pos()[1] << " "
<< (*it)->pos()[2] << endl;
}
}
void NetworkManager::setSearchSpace(const Nodes & nodes)
{
rejectedNodes.clear();
rejectedStores.clear();
Elements elements;
for (Nodes::iterator i = nodes.begin(); i != nodes.end(); i++)
{
elements.insert(*i);
}
depthSearcher = new DepthSearcher(network, elements);
}
int Test::count_overlap_kid(const Nodes& nodes) const
{
std::map<Kid,int> counter;
for (Nodes::const_iterator ni = nodes.begin(); ni != nodes.end(); ++ni) {
counter[ni->kid]++;
}
int count = 0;
for (std::map<Kid,int>::const_iterator ki = counter.begin(); ki != counter.end(); ++ki) {
if (ki->second > 1) ++count;
}
return count;
}
/**
* Applies the required resizes to nodes in the specified axis, rerouting edges
* around the resized nodes.
* @param dim axis
* @param targets the target rectangles (in both axes)
* @param nodes to be moved and/or resized
* @param edges to be rerouted around nodes
* @param resizes ResizeInfo for specific nodes
* @param vs canonical list of variables passed into solver. Note that
* the first nodes.size() variables are used for each corresponding node.
* Note also that new variables for the dummy nodes will be appended to this
* list and will need to be cleaned up later.
* @param cs canonical list of constraints over variables. Note that new
* non-overlap constraints may be appended to the end of this list.
*/
static void resizeAxis(vpsc::Dim dim, const Rectangles& targets,
Nodes& nodes, Edges& edges, RootCluster *clusters, ResizeMap& resizes,
Variables& vs, Constraints& cs)
{
COLA_ASSERT(vs.size()>=nodes.size());
// - create copy tn of topologyNodes with resize rects replaced with
// three nodes: one for the lhs of rect, one for centre and one for rhs.
// lhs node goes at position of replaced node, the others are appended
// to end of tn.
// - set desired positions of each lhs node to be the left side
// of resized rect and symmetric for rhs node, centre node's desired
// pos it at the centre
Nodes tn(nodes.size());
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges));
transform(nodes.begin(),nodes.end(),tn.begin(),
TransformNode(dim, targets,resizes,vs));
feach(resizes, CreateLeftRightDummyNodes(dim,targets,tn,vs));
COLA_ASSERT(tn.size()==nodes.size()+2*resizes.size());
COLA_ASSERT(vs.size()>=tn.size());
// update topologyRoutes with references to resized nodes replaced with
// correct references to lhs/rhs nodes
feach(edges,SubstituteNodes(dim,resizes,tn));
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(tn,edges));
// move nodes and reroute
topology::TopologyConstraints t(dim, tn, edges, clusters, vs, cs);
COLA_ASSERT(checkDesired(dim,tn,targets,resizes));
#ifndef NDEBUG
unsigned loopCtr=0;
#endif
while(t.solve()) { COLA_ASSERT(++loopCtr<1000); }
//COLA_ASSERT(checkFinal(tn,targets,resizes));
// reposition and resize original nodes
feach(nodes,CopyPositions(dim,tn,resizes));
// revert topologyRoutes back to original nodes
feach(edges,RevertNodes(nodes));
COLA_ASSERT(assertConvexBends(edges));
COLA_ASSERT(assertNoSegmentRectIntersection(nodes,edges));
// clean up
feach(tn,DeleteTempNode());
}
void GraphProtoInterface::build_from_proto(graph::Graph *graph) {
vector <Graphnode *> nodes;
vector <Graphedge *> edges;
int edge_count = 0;
for (int i = 0; i < graph->node_size(); i++) {
const graph::Graph_Node & node = graph->node(i);
for (int j=0; j < node.edge_size(); j++) {
const graph::Graph_Edge& edge = node.edge(j);
edge_count++;
}
}
set_up(*graph, graph->node_size(), edge_count);
for (int i = 0; i < graph->node_size(); i++) {
const graph::Graph_Node & node = graph->node(i);
Graphnode * my_node = new Graphnode(node.id());
my_node->set_label(node.label());
process_node(node, my_node);
nodes.push_back(my_node);
}
uint edge_id = 0;
for (int i = 0; i < graph->node_size(); i++) {
const graph::Graph_Node& node = graph->node(i);
for (int j=0; j < node.edge_size(); j++) {
const graph::Graph_Edge& edge = node.edge(j);
int to_node = edge.to_node();
Graphedge * my_edge = new Graphedge(edge_id, *nodes[node.id()], *nodes[to_node]);
process_edge(edge, my_edge);
//((HypernodeImpl*)_nodes[to_node])->add_edge(forest_edge);
nodes[node.id()]->add_edge(my_edge);
nodes[my_edge->to_node()->id()]->add_in_edge(my_edge);
edge_id++;
edges.push_back(my_edge);
}
}
Nodes * ns = new Nodes ();
Edges * es = new Edges ();
foreach (Graphnode * n, nodes) {
ns->push_back((Node) n);
}
