//----------------------------------------------------------------
void GraphView::delEdge(const edge e, bool deleteInAllGraphs) {
if (deleteInAllGraphs) {
getRootImpl()->delEdge(e, true);
} else {
assert(isElement(e));
// propagate to subgraphs
for (Graph *subGraph : subGraphs()) {
if (subGraph->isElement(e))
subGraph->delEdge(e);
}
removeEdge(e);
}
}
void VenmoGraph::processEdge(long time, edge newEdge)
{
// Insert this item only if newEdge's timestamp is within sliding window of known max time in graph.
// Since graph is sorted based on timestamps, the last entry in current graph has max time
if (graph.empty()){
insertEdge(std::pair<long, edge>(time, newEdge));
}
else if ((graph.rbegin())->first < time + slidingWindowTimeVal){
// Check if there's already an edge with same nodes in graph. Remove old edge to update with new one
// Removal and insertion will have complexity of O(logN) as sorted map is implemented using BST.
for (auto it = graph.begin(); it != graph.end(); it++){
if (AreEdgesEqual(newEdge, it->second)){
removeEdge(it);
break;
}
}
insertEdge(std::pair<long, edge>(time, newEdge));
// Delete edges with older timestamps which fall out of sliding window after insertion of new edge
long minTimeAllowed = (graph.rbegin())->first - slidingWindowTimeVal;
for (auto it = graph.begin(); it != graph.end(); ) {
// Sliding Window is exclusive and hence the use of <= below as deletion criteria
if (it->first <= minTimeAllowed){
auto deleteEdgeItr = it;
it++;
removeEdge(deleteEdgeItr);
}
else{
break;
}
}
}
}
edge_descriptor addEdge( const vertex_descriptor& v1, const vertex_descriptor& v2, const Edge& prop )
{
//TUTTLE_TCOUT_VAR2( v1, instance(v1) );
//TUTTLE_TCOUT_VAR2( v2, instance(v2) );
const edge_descriptor addedEdge = boost::add_edge( v1, v2, prop, _graph ).first;
if( hasCycle() )
{
removeEdge( addedEdge );
BOOST_THROW_EXCEPTION( exception::Logic()
<< exception::user() + "Connection error: the graph becomes cyclic while connecting \"" + instance(v1) + "\" to \"" + instance(v2) + "\"" );
}
return addedEdge;
}
Vertex<T, C, W> * const Graph<T, C, W>::removeVertex(Vertex<T, C, W> const &v) {
if(&v!=NULL) {
typename vector<Vertex<T,C,W>* >::iterator iter = find_if(_vertexList.begin(),_vertexList.end(),
bind2nd(PtrPredicate<Vertex<T,C,W> >(), &v));
if(iter != _vertexList.end()) {
vector<Edge<T,C,W>* > vtmp = (*iter)->getAdjEdges();
for(auto edge: vtmp) {
removeEdge(*edge);
}
_vertexList.erase(iter);
return *iter;
}
}
return NULL;
}
/**
* Removes a given vertex from the graph.
* @param v - the vertex to remove
*/
void Graph::removeVertex(Vertex v)
{
assertExists(v, __func__);
// first, remove all references to the vertex in every other edge list
// luckily, we can call getAdjacent and work backwards
// instead of traversing the whole hash table
vector<Vertex> adjacent = getAdjacent(v);
vector<Vertex>::iterator it;
for (it = adjacent.begin(); it != adjacent.end(); ++it)
removeEdge(*it, v);
// now that all references are gone, we can delete the vertex
graph.erase(v);
vertexLabels.erase(v);
}
/**
* Destroy the graph
*
* @param graph Graph object to destroy
*/
void destroy_graph(graph_t* graph)
{
int i = 0;
int j = 0;
if(graph == NULL)
return;
for(i = 0 ; i < graph->nodecount ; ++i) {
for(j = 0 ; j < graph->nodes[i]->edgecount ; ++j)
removeEdge(graph->nodes[i]->edges[j]);
free(graph->nodes[i]->edges);
free(graph->nodes[i]);
}
free(graph->nodes);
}
void Mesh::collapse(Vertex* v1, Vertex* v2)
{
std::vector<Face*>::iterator i;
for (i = v1->adjacentFaces().begin(); i != v1->adjacentFaces().end(); ++i){
Face* f = *i;
if (f->hasVertex(v2)) {
removeFace(f);
// delete f;
}
}
Vector3 position1 = v1->position();
int weight1 = v1->weight();
Vector3 position2 = v2->position();
int weight2 = v2->weight();
Vector3 newPosition = (position1 * weight1 + position2 * weight2) / (weight1 + weight2);
v2->setPosition(newPosition);
v2->setWeight(v1->weight() + v2->weight());
for (i = v1->adjacentFaces().begin(); i != v1->adjacentFaces().end(); ++i){
Face* f = *i;
f->changeVertex(v1, v2);
f->calculateNormal();
}
std::vector<Vertex*>::iterator j;
for (j = v1->adjacentVertices().begin(); j != v1->adjacentVertices().end(); ++j){
Vertex* v = *j;
v->removeAdjacentVertex(v1);
v->addAdjacentVertex(v2);
Edge* e = getEdge(v1, v);
if (e) {
if (e->hasVertex(v2)) {
removeEdge(e);
//delete e; // FIXME: pointer being freed was not allocated
} else {
e->changeVertex(v1, v2);
}
} else {
std::cerr << "missing edge" << v1->index() << "/" << v->index() << "\n";
}
}
}
void ClosureBuffer::removeVertex(OptimizableGraph::Vertex *v){
OptimizableGraph::VertexIDMap::iterator it=_vmap.find(v->id());
if (it != _vmap.end()){
_vmap.erase(it);
OptimizableGraph::EdgeSet tmp = _eset;
for (OptimizableGraph::EdgeSet::iterator it=tmp.begin(); it!=tmp.end(); ++it){
OptimizableGraph::Edge *e=(OptimizableGraph::Edge*)(*it);
for (size_t i=0; i<e->vertices().size(); i++){
OptimizableGraph::Vertex* vedge=(OptimizableGraph::Vertex*)e->vertices()[i];
if (vedge->id() == v->id())
removeEdge(e);
}
}
_vertexList.remove_if(VertexTimeComparator(v));
}
}
// Removes a vertex from the graph (and its edges)
void removeVertex(Graph *g, Vertex *vp)
{
// while it has edges, remove them
while(vp->head){
removeEdge(g, vp->head->adjacentEdge);
}
vp->label = 0;
// swap vert out to end of array, fix pointers
int lastVertIndex = --g->numVertices;
if(g->vertices+lastVertIndex != vp){
swap(vp, g->vertices+lastVertIndex, sizeof(Vertex));
ConnectorElement *curElement = vp->head;
while(curElement != NULL){
curElement->sourceVertex = vp;
curElement = curElement->next;
}
}
}
void graph::removeEdge(vertex *v1, vertex *v2)
{
if (isNodeExist(v1) || isNodeExist(v2))
{
vector<edge*> toRemove;
for (set<edge*>::iterator itr = edges.begin(); itr != edges.end(); ++itr)
{
if ((*itr)->start == v1 && (*itr)->end == v2)
{
toRemove.push_back(*itr);
}
}
for (unsigned int i = 0; i < toRemove.size(); i++)
{
removeEdge(toRemove[i]);
}
}
}
void GenGraph< Config >::removeEdge( WeakNode source, WeakNode destination )
{
if ( source.expired() ||
destination.expired() )
throw gtpo::bad_topology_error( "gtpo::GenGraph<>::removeEdge(): Topology error." );
// Find the edge associed with source / destination
if ( _edges.size() == 0 )
return; // Fast exit
auto edgeIter = std::find_if( _edges.begin(), _edges.end(),
[=](const SharedEdge& e ){
return ( compare_weak_ptr<>( e->getSrc(), source ) &&
compare_weak_ptr<>( e->getDst(), destination ) );
}
); // std::find_if
if ( edgeIter != _edges.end() )
removeEdge( *edgeIter );
}
edge_descriptor addEdge( const vertex_descriptor& v1, const vertex_descriptor& v2, const Edge& prop )
{
if( hasEdge( v1, v2, prop.getInAttrName() ) )
{
BOOST_THROW_EXCEPTION( exception::Logic()
<< exception::dev() + "Can't add Edge. There is already a connection from \"" + instance(v1) + "\" to \"" + instance(v2) + "/" + prop.getInAttrName() + "\"" );
}
//TUTTLE_LOG_VAR2( TUTTLE_TRACE, v1, instance(v1) );
//TUTTLE_LOG_VAR2( TUTTLE_TRACE, v2, instance(v2) );
const edge_descriptor addedEdge = boost::add_edge( v1, v2, prop, _graph ).first;
if( hasCycle() )
{
removeEdge( addedEdge );
BOOST_THROW_EXCEPTION( exception::Logic()
<< exception::user() + "Connection error: the graph becomes cyclic while connecting \"" + instance(v1) + "\" to \"" + instance(v2) + "\"" );
}
return addedEdge;
}
bool NavigationGraph::removeNode(NavigationNode* node)
{
auto index = nodes_.find(node);
if (index == -1)
return false;
// Delete all edges to this node
for (auto edge : node->edges_)
removeEdge(edge);
assert(node->edges_.empty() && "Node's edges have not been fully removed");
delete node;
nodes_.erase(index);
// Update the NavigationNode::index_ value on the nodes affected by this node removal
for (auto i = uint(index); i < nodes_.size(); i++)
nodes_[i]->index_ = i;
return true;
}
void blockDfs (int v)
{
int stop = 1;
stack[0] = v;
result[0] = 0;
while (stop > 0)
{
v = stack[stop - 1];
// printf ("enter %d\n", v);
if (v == T)
{
stop--;
result[stop - 1] = 1;
}
else if (result[stop - 1])
{
scur[stop - 1]->f = scur[stop - 1]->p;
removeEdge (scur[stop - 1]);
result[stop - 1] = 0;
if (v != S)
{
stop--;
result[stop - 1] = 1;
}
}
else if (mpe[v])
{
edge* cur = mpe[v];
mpe[v] = cur->next;
scur[stop - 1] = cur;
result[stop] = 0;
stack[stop++] = cur->b;
}
else
{
stop--;
// printf ("leave %d\n", v);
}
}
}
int SpecnetsGraph::remove_low_scoring_edges(vector<Edge*> edge_list, float minimum_threshold){
int number_removed_edges = 0;
for(int i = 0; i < edge_list.size(); i++){
//cout<<"edge ptr "<<edge_list[i]<<endl;
//cout<<"graph edge index "<<edge_list[i]->getIndex()<<endl;
//cout<<"specnets index "<<graph_to_specnets_edge_map[edge_list[i]->getIndex()]<<endl;
float score1 = graph_pairs_set[graph_to_specnets_edge_map[edge_list[i]->getIndex()]].score1;
if (score1 < minimum_threshold) {
//Mark this index to be deleted from pairs
specnets_pairs_deleted.push_back(graph_to_specnets_edge_map[edge_list[i]->getIndex()]);
//Delete Edge From Graph
removeEdge(edge_list[i]->getIndex());
number_removed_edges++;
}
}
return number_removed_edges;
}
void graph::removeEdge(const int v1, const int v2)
{
if (isNodeExist(v1) && isNodeExist(v2))
{
map<int, vertex*>::iterator itr1 = nodeMap.find(v1);
map<int, vertex*>::iterator itr2 = nodeMap.find(v2);
vector<edge*> toRemove;
for (set<edge*>::iterator itr = edges.begin(); itr != edges.end(); ++itr)
{
if ((*itr)->start == itr1->second && (*itr)->end == itr2->second)
{
toRemove.push_back(*itr);
}
}
for (unsigned int i = 0; i < toRemove.size(); i++)
{
removeEdge(toRemove[i]);
}
}
}
bool
CRDFNode::removeEdge(const CRDFPredicate & predicate, CRDFNode * pObject)
{
bool deletedSomething = false;
// Determine whether the predicate points to a bag node
std::set< CRDFTriplet > Triplets = mGraph.getTriplets(this, predicate);
// Debugging
assert(Triplets.size() > 0);
CRDFNode * pTarget = Triplets.begin()->pObject;
if (pTarget->isBagNode() && pTarget != pObject)
{
deletedSomething |= pTarget->removeEdge(CRDFPredicate::rdf_li, pObject);
Triplets = mGraph.getTriplets(pTarget, CRDFPredicate::rdf_li);
switch (Triplets.size())
{
case 0:
// If pTarget is an empty bag node we remove it.
// Note, this will destroy pTarget, i.e., no need to unbag
deletedSomething |= removeEdge(predicate, pTarget);
break;
default:
// We have more than 1 rdf_li element left.
break;
}
return deletedSomething;
}
deletedSomething |= removeTripletFromGraph(CRDFTriplet(this, predicate, pObject));
return deletedSomething;
}
void graph::removeVertex(vertex* v)
{
if (isNodeExist(v))
{
vector<edge*> toRemove;
for (set<edge*>::iterator itr = edges.begin(); itr != edges.end(); ++itr)
{
if ((*itr)->start == v || (*itr)->end == v)
{
toRemove.push_back(*itr);
}
}
for (unsigned int i = 0; i < toRemove.size(); i++)
{
removeEdge(toRemove[i]);
}
nodes.erase(v);
}
else
{
cout << "\n Node doesn't exist \n";
}
}
bool HyperGraph::removeVertex(Vertex* v, bool detach)
{
if (detach){
bool result = detachVertex(v);
if (! result) {
assert (0 && "inconsistency in detaching vertex, ");
}
}
VertexIDMap::iterator it=_vertices.find(v->id());
if (it==_vertices.end())
return false;
assert(it->second==v);
//remove all edges which are entering or leaving v;
EdgeSet tmp(v->edges());
for (EdgeSet::iterator it=tmp.begin(); it!=tmp.end(); ++it){
if (!removeEdge(*it)){
assert(0 && "error in erasing vertex");
}
}
_vertices.erase(it);
delete v;
return true;
}
int runKarger(Graph *g)
{
while(g->numVertices > 2){
// pick edge at random
Edge *ep = g->edges+(rand()%g->numEdges);
//grab the edges 2 vertices
Vertex *v1 = ep->endpoint1->sourceVertex;
Vertex *v2 = ep->endpoint2->sourceVertex;
// printf("Conracting edge (%d,%d)\n", v1->label, v2->label);
// add v2's list onto the end of v1
v1->tail->next = v2->head;
v2->head->prev = v1->tail;
v1->tail = v2->tail;
v2->head = NULL;
v2->tail = NULL;
// loop through linked list, point them all to v1, delete self loops
ConnectorElement *curElement = v1->head;
while(curElement){
curElement->sourceVertex = v1;
Edge *edgeToCheck = curElement->adjacentEdge;
curElement = curElement->next;
// if I got really unlucky and switched to a connector element that shares
// the same edge as the prev element, I need to switch again
if(curElement && curElement->adjacentEdge==edgeToCheck){
curElement->sourceVertex = v1;
curElement = curElement->next;
}
// if its a self loop, remove edge
if(edgeToCheck->endpoint1->sourceVertex==v1 && edgeToCheck->endpoint2->sourceVertex==v1){
removeEdge(g, edgeToCheck);
}
}
removeVertex(g, v2);
}
return g->numEdges;
}
int main(int argc, char *argv[]) {
List *graph = initGraph(5);
insertEdge(&graph[0], 3, 5);
insertEdge(&graph[0], 4, 10);
insertEdge(&graph[1], 2, 3);
insertEdge(&graph[1], 4, 5);
insertEdge(&graph[2], 1, 3);
insertEdge(&graph[2], 3, 7);
insertEdge(&graph[3], 0, 15);
insertEdge(&graph[3], 1, 35);
insertEdge(&graph[3], 2, 1);
insertEdge(&graph[3], 4, 17);
insertEdge(&graph[4], 2, 100);
for(int i = 0; i < 5; i++) {
printList(&graph[i]);
printf("\n");
}
printf("\n\n");
removeEdge(&graph[0], 4);
removeEdge(&graph[2], 3);
removeEdge(&graph[3], 0);
removeEdge(&graph[3], 1);
removeEdge(&graph[3], 2);
removeEdge(&graph[3], 4);
for(int i = 0; i < 5; i++) {
printList(&graph[i]);
printf("\n");
}
return 0;
}
void GVSkeletonGraph::removeEdge(const QString &source, const QString &target) {
setlocale(LC_NUMERIC,"en_US.UTF-8");
removeEdge(QPair<QString, QString>(source, target));
}
/*************************************************
Function:
clipTipFromNode
Description:
Removes tips from an end node.
Input:
1. ht: the graph hashtable
2. K_size: the kmer size
3. node: the tips starting node
4. cut_len_tip: the threadhold of tips' length
Output:
None.
Return:
1 if clips a tip successfully.
*************************************************/
static int clipTipFromNode ( hashtable2 * ht, int K_size, bucket2 * node, int cut_len_tip ) //only for remove minor tips
{
//linear return 0
if ( node->kmer_info.linear || node->kmer_info.deleted )
{
return 0;
}
// for not linear
int in_num, out_num;
int sum_edge_len = 0;
int smaller;
bool is_left;
bool pre_is_left;
edge_node * edge0;
in_num = count_left_edge_num ( node );
out_num = count_right_edge_num ( node );
if ( in_num == 0 && out_num == 1 ) { is_left = 0; }
else if ( in_num == 1 && out_num == 0 ) { is_left = 1; }
else { return 0; }
if ( is_left ) { edge0 = node->kmer_info.left; }
else { edge0 = node->kmer_info.right; }
bucket2 * next, *pre_node;
pre_node = node;
next = lastKmer ( ht, K_size, node, edge0, is_left, smaller );
while ( next->kmer_info.linear )
{
if ( sum_edge_len > cut_len_tip ) { return 0; }
is_left = ! ( is_left ^ smaller );
if ( is_left ) { edge0 = next->kmer_info.left; }
else { edge0 = next->kmer_info.right; }
sum_edge_len += edge0->len + 1;
pre_node = next;
next = lastKmer ( ht, K_size, next, edge0, is_left, smaller );
if ( !next )
{
fprintf ( stderr, "ERROR: linear edge not found error !\n" );
exit ( -1 );
}
}
pre_is_left = is_left;
is_left = ( is_left ^ smaller ); //back check orientation...
in_num = count_left_edge_num ( next );
out_num = count_right_edge_num ( next );
if ( is_left ) //check the last node left branch or not
{
if ( in_num == 1 )
{
return 0;
}
else if ( in_num > 1 )
{
edge_node * edge1 = NULL, * temp_edge = NULL;
bucket2 * temp_bucket = NULL;
int max_cvg = 0, single_cvg = 0, temp_smaller;
temp_edge = next->kmer_info.left;
while ( temp_edge )
{
single_cvg = temp_edge->edge_cov;
if ( single_cvg > max_cvg ) { max_cvg = single_cvg; }
if ( !edge1 )
{
temp_bucket = lastKmer ( ht, K_size, next, temp_edge, 1, temp_smaller );
if ( !temp_bucket )
{
fprintf ( stderr, "ERROR: edge to NULL found error ! a\n" );
exit ( 1 );
}
if ( pre_node == temp_bucket ) { edge1 = temp_edge; }
}
temp_edge = temp_edge->nxt_edge;
}
if ( !edge1 )
{
fprintf ( stderr, "ERROR: edge to node not found error ! b\n" );
exit ( 1 );
}
if ( edge1->edge_cov < max_cvg )
{
removeEdge ( next, edge1, 1 );
removeEdge ( pre_node, edge0, pre_is_left );
node->kmer_info.deleted = 1;
pre_node->kmer_info.deleted = 1;
return 1;
}
else
{
return 0;
}
}
else
{
fprintf ( stderr, "ERROR: left tips oritation error or edge not found error ! a\n" );
exit ( -1 );
}
}
else
{
if ( out_num == 1 )
{
return 0;
}
else if ( out_num > 1 )
{
edge_node * edge1 = NULL, * temp_edge = NULL;
bucket2 * temp_bucket = NULL;
int max_cvg = 0, single_cvg = 0, temp_smaller;
//ok change it to a edge_remove thred_hold locally later
//or only if it is the least cvg ->remove it
temp_edge = next->kmer_info.right;
while ( temp_edge )
{
single_cvg = temp_edge->edge_cov;
if ( single_cvg > max_cvg ) { max_cvg = single_cvg; }
if ( !edge1 )
{
temp_bucket = lastKmer ( ht, K_size, next, temp_edge, 0, temp_smaller );
if ( !temp_bucket )
{
fprintf ( stderr, "ERROR: edge to NULL found, error ! b\n" );
exit ( -1 );
}
if ( pre_node == temp_bucket ) { edge1 = temp_edge; }
}
temp_edge = temp_edge->nxt_edge;
}
if ( !edge1 )
{
fprintf ( stderr, "ERROR: edge to node not found error ! e\n" );
exit ( 1 );
}
if ( edge1->edge_cov < max_cvg )
{
removeEdge ( next, edge1, 0 );
removeEdge ( pre_node, edge0, pre_is_left );
node->kmer_info.deleted = 1;
pre_node->kmer_info.deleted = 1;
return 1;
}
else
{
return 0;
}
}
else
{
fprintf ( stderr, "ERROR: right tips oritation error or edge not found error! b\n" );
exit ( -1 );
}
}
}
//---------------------------------------------------------
// actual call (called by all variations of call)
// crossing of generalizations is forbidden if forbidCrossingGens = true
// edge costs are obeyed if costOrig != 0
//
Module::ReturnType FixedEmbeddingInserter::doCall(
PlanRep &PG,
const List<edge> &origEdges,
bool forbidCrossingGens,
const EdgeArray<int> *costOrig,
const EdgeArray<bool> *forbiddenEdgeOrig,
const EdgeArray<unsigned int> *edgeSubGraph)
{
double T;
usedTime(T);
ReturnType retValue = retFeasible;
m_runsPostprocessing = 0;
PG.embed();
OGDF_ASSERT(PG.representsCombEmbedding() == true);
if (origEdges.size() == 0)
return retOptimal; // nothing to do
// initialization
CombinatorialEmbedding E(PG); // embedding of PG
m_dual.clear();
m_primalAdj.init(m_dual);
m_nodeOf.init(E);
// construct dual graph
m_primalIsGen.init(m_dual,false);
OGDF_ASSERT(forbidCrossingGens == false || forbiddenEdgeOrig == 0);
if(forbidCrossingGens)
constructDualForbidCrossingGens((const PlanRepUML&)PG,E);
else
constructDual(PG,E,forbiddenEdgeOrig);
// m_delFaces and m_newFaces are used by removeEdge()
// if we can't allocate memory for them, we throw an exception
if (removeReinsert() != rrNone) {
m_delFaces = new FaceSetSimple(E);
if (m_delFaces == 0)
OGDF_THROW(InsufficientMemoryException);
m_newFaces = new FaceSetPure(E);
if (m_newFaces == 0) {
delete m_delFaces;
OGDF_THROW(InsufficientMemoryException);
}
// no postprocessing -> no removeEdge()
} else {
m_delFaces = 0;
m_newFaces = 0;
}
SListPure<edge> currentOrigEdges;
if(removeReinsert() == rrIncremental) {
edge e;
forall_edges(e,PG)
currentOrigEdges.pushBack(PG.original(e));
}
// insertion of edges
ListConstIterator<edge> it;
for(it = origEdges.begin(); it.valid(); ++it)
{
edge eOrig = *it;
int eSubGraph = 0; // edgeSubGraph-data of eOrig
if(edgeSubGraph!=0) eSubGraph = (*edgeSubGraph)[eOrig];
SList<adjEntry> crossed;
if(costOrig != 0) {
findShortestPath(PG, E, *costOrig,
PG.copy(eOrig->source()),PG.copy(eOrig->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrig) : Graph::association,
crossed, edgeSubGraph, eSubGraph);
} else {
findShortestPath(E,
PG.copy(eOrig->source()),PG.copy(eOrig->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrig) : Graph::association,
crossed);
}
insertEdge(PG,E,eOrig,crossed,forbidCrossingGens,forbiddenEdgeOrig);
if(removeReinsert() == rrIncremental) {
currentOrigEdges.pushBack(eOrig);
bool improved;
do {
++m_runsPostprocessing;
improved = false;
SListConstIterator<edge> itRR;
for(itRR = currentOrigEdges.begin(); itRR.valid(); ++itRR)
{
edge eOrigRR = *itRR;
int pathLength;
if(costOrig != 0)
pathLength = costCrossed(eOrigRR,PG,*costOrig,edgeSubGraph);
else
pathLength = PG.chain(eOrigRR).size() - 1;
if (pathLength == 0) continue; // cannot improve
removeEdge(PG,E,eOrigRR,forbidCrossingGens,forbiddenEdgeOrig);
// try to find a better insertion path
SList<adjEntry> crossed;
if(costOrig != 0) {
int eSubGraph = 0; // edgeSubGraph-data of eOrig
if(edgeSubGraph!=0) eSubGraph = (*edgeSubGraph)[eOrigRR];
findShortestPath(PG, E, *costOrig,
PG.copy(eOrigRR->source()),PG.copy(eOrigRR->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrigRR) : Graph::association,
crossed, edgeSubGraph, eSubGraph);
} else {
findShortestPath(E,
PG.copy(eOrigRR->source()),PG.copy(eOrigRR->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrigRR) : Graph::association,
crossed);
}
// re-insert edge (insertion path cannot be longer)
insertEdge(PG,E,eOrigRR,crossed,forbidCrossingGens,forbiddenEdgeOrig);
int newPathLength = (costOrig != 0) ? costCrossed(eOrigRR,PG,*costOrig,edgeSubGraph) : (PG.chain(eOrigRR).size() - 1);
OGDF_ASSERT(newPathLength <= pathLength);
if(newPathLength < pathLength)
improved = true;
}
} while (improved);
}
}
const Graph &G = PG.original();
if(removeReinsert() != rrIncremental) {
// postprocessing (remove-reinsert heuristc)
SListPure<edge> rrEdges;
switch(removeReinsert())
{
case rrAll:
case rrMostCrossed: {
const List<node> &origInCC = PG.nodesInCC();
ListConstIterator<node> itV;
for(itV = origInCC.begin(); itV.valid(); ++itV) {
node vG = *itV;
adjEntry adj;
forall_adj(adj,vG) {
if ((adj->index() & 1) == 0) continue;
edge eG = adj->theEdge();
rrEdges.pushBack(eG);
}
}
}
break;
case rrInserted:
for(ListConstIterator<edge> it = origEdges.begin(); it.valid(); ++it)
rrEdges.pushBack(*it);
break;
case rrNone:
case rrIncremental:
break;
}
// marks the end of the interval of rrEdges over which we iterate
// initially set to invalid iterator which means all edges
SListConstIterator<edge> itStop;
bool improved;
do {
// abort postprocessing if time limit reached
if (m_timeLimit >= 0 && m_timeLimit <= usedTime(T)) {
retValue = retTimeoutFeasible;
break;
}
++m_runsPostprocessing;
improved = false;
if(removeReinsert() == rrMostCrossed)
{
FEICrossingsBucket bucket(&PG);
rrEdges.bucketSort(bucket);
const int num = int(0.01 * percentMostCrossed() * G.numberOfEdges());
itStop = rrEdges.get(num);
}
SListConstIterator<edge> it;
for(it = rrEdges.begin(); it != itStop; ++it)
{
edge eOrig = *it;
// remove only if crossings on edge;
// in especially: forbidden edges are never handled by postprocessing
// since there are no crossings on such edges
int pathLength;
if(costOrig != 0)
pathLength = costCrossed(eOrig,PG,*costOrig,edgeSubGraph);
else
pathLength = PG.chain(eOrig).size() - 1;
if (pathLength == 0) continue; // cannot improve
removeEdge(PG,E,eOrig,forbidCrossingGens,forbiddenEdgeOrig);
// try to find a better insertion path
SList<adjEntry> crossed;
if(costOrig != 0) {
int eSubGraph = 0; // edgeSubGraph-data of eOrig
if(edgeSubGraph!=0) eSubGraph = (*edgeSubGraph)[eOrig];
findShortestPath(PG, E, *costOrig,
PG.copy(eOrig->source()),PG.copy(eOrig->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrig) : Graph::association,
crossed, edgeSubGraph, eSubGraph);
} else {
findShortestPath(E,
PG.copy(eOrig->source()),PG.copy(eOrig->target()),
forbidCrossingGens ? ((const PlanRepUML&)PG).typeOrig(eOrig) : Graph::association,
crossed);
}
// re-insert edge (insertion path cannot be longer)
insertEdge(PG,E,eOrig,crossed,forbidCrossingGens,forbiddenEdgeOrig);
int newPathLength = (costOrig != 0) ? costCrossed(eOrig,PG,*costOrig,edgeSubGraph) : (PG.chain(eOrig).size() - 1);
OGDF_ASSERT(newPathLength <= pathLength);
if(newPathLength < pathLength)
improved = true;
}
} while(improved); // iterate as long as we improve
}
bool Surface::collapse(Edge& e)
{
timespec t0,t1,t;
clock_gettime(CLOCK_REALTIME,&t0);
Point* p1 = e.p1;
Point* p2 = e.p2;
assert(p1);
assert(p2);
if(p1->faces.size() ==0 || p2->faces.size()==0) //Do not simplify boundary corners
{
//cerr << "*ERROR: EMPTY VERTEX.\n";
failed_collapses++;
//cout << redtty << "failed.\n" << deftty;
return false;
}
//Iterating faces
vector<Face*> for_removal;
//clock_gettime(CLOCK_REALTIME,&t0);
for(vector<Face*>::iterator fit = p1->faces.begin(); fit!=p1->faces.end(); ++fit)
{
bool removeface = false;
vector<Point*>::iterator auxp1;
for(vector<Point*>::iterator pit = (*fit)->points.begin(); pit != (*fit)->points.end() ; ++pit)
{
if((*pit) == p2)
{
removeface = true;
break;
}
else if ((*pit) == p1)
{
auxp1 = pit;
}
}
if(removeface) //p1 and p2 share face, remove it.
{
for_removal.push_back((*fit));
}
else //Swap p1 for p2 for this face
{
//Face is about to be modified. Checking intersection.
Point3 p30((*fit)->points[0]->x,(*fit)->points[0]->y,(*fit)->points[0]->z);
Point3 p31((*fit)->points[1]->x,(*fit)->points[1]->y,(*fit)->points[1]->z);
Point3 p32((*fit)->points[2]->x,(*fit)->points[2]->y,(*fit)->points[2]->z);
Triangle3 face(p30,p31,p32);
for(face_vec_it fit2 = m_faces.begin(); fit2 != m_faces.end(); ++fit2)
{
Face* f = (*fit2);
Point3 pf0(f->points[0]->x,f->points[0]->y,f->points[0]->z);
Point3 pf1(f->points[1]->x,f->points[1]->y,f->points[1]->z);
Point3 pf2(f->points[2]->x,f->points[2]->y,f->points[2]->z);
Triangle3 face2(pf0,pf1,pf2);
if(CGAL::do_intersect(face,face2))
{
cerr << "***Faces " << (*fit)->id << " X " << f->id << endl;
}
}
(*auxp1) = p2;
p2->faces.push_back((*fit));
}
}
//cerr << "Removing faces: ";
for(vector<Face*>::iterator it = for_removal.begin(); it != for_removal.end(); ++it)
{
//cerr << (*it)->id << " ";
removeFace(*it);
(*it)->removed = true;
//delete (*it);
}
//Set position of p2 as midpoint between p1-p2
p2->x = e.placement->x;
p2->y = e.placement->y;
p2->z = e.placement->z;
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_faces+= getNanoseconds(t);
//TODO: more efficient to use std::remove_if
clock_gettime(CLOCK_REALTIME,&t0);
removeEdge(m_edges[e.id]);
vector<Edge*> edges_to_remove;
edge_vec_it eit = p1->to.begin();
//Remove double edges to
while(eit != p1->to.end())
{
Edge* e = (*eit);
bool found = false;
edge_vec_it it = p2->to.begin();
while(it != p2->to.end())
{
Edge* e2 = (*it);
if(e->p1->id == e2->p1->id)
{
//cerr << "Found " << e->id << " " << e->p1->id << " " << e->p2->id << endl;
edges_to_remove.push_back(e);
found = true;
break;
}
it++;
}
if(!found)
{
e->p2 = p2;
if(e->p1->id == e->p2->id)
edges_to_remove.push_back(e);
}
eit++;
}
//Remove double edges from
eit = p1->from.begin();
while(eit!=p1->from.end())
{
Edge* e = (*eit);
bool found = false;
edge_vec_it it = p2->from.begin();
while(it != p2->from.end())
{
Edge* e2 = (*it);
if(e->p2->id == e2->p2->id)
{
//cerr << "Found from " << e->id << " " << e->p1->id << " " <<e->p2->id << endl;
edges_to_remove.push_back(e);
found =true;
break;
}
it++;
}
if(!found)
{
e->p1=p2;
if(e->p1->id == e->p2->id)
edges_to_remove.push_back(e);
}
eit++;
}
eit = edges_to_remove.begin();
while(eit != edges_to_remove.end())
{
removeEdge(*eit);
eit++;
}
//Append p1 edges to p2
p2->to.insert(p2->to.end(), p1->to.begin(), p1->to.end());
p2->from.insert(p2->from.end(),p1->from.begin(), p1->from.end());
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_edges += getNanoseconds(t);
//Can remove point p1
clock_gettime(CLOCK_REALTIME,&t0);
removePoint(p1);
clock_gettime(CLOCK_REALTIME,&t1);
t = diff(t0,t1);
time_point+=getNanoseconds(t);
return true;
}
static void
addPEdges (channel* cp, maze* mp)
{
int i,j;
/* dir[1,2] are used to figure out whether we should use prev
* pointers or next pointers -- 0 : decrease, 1 : increase
*/
int dir;
/* number of hops along the route to get to the deciding points */
pair hops;
/* precedences of the deciding points : same convention as
* seg_cmp function
*/
int prec1, prec2;
pair p;
rawgraph* G = cp->G;
segment** segs = cp->seg_list;
for(i=0;i+1<cp->cnt;i++) {
for(j=i+1;j<cp->cnt;j++) {
if (!edge_exists(G,i,j) && !edge_exists(G,j,i)) {
if (is_parallel(segs[i], segs[j])) {
/* get_directions */
if(segs[i]->prev==0) {
if(segs[j]->prev==0)
dir = 0;
else
dir = 1;
}
else if(segs[j]->prev==0) {
dir = 1;
}
else {
if(segs[i]->prev->comm_coord==segs[j]->prev->comm_coord)
dir = 0;
else
dir = 1;
}
p = decide_point(segs[i], segs[j], 0, dir);
hops.a = p.a;
prec1 = p.b;
p = decide_point(segs[i], segs[j], 1, 1-dir);
hops.b = p.a;
prec2 = p.b;
switch(prec1) {
case -1 :
set_parallel_edges (segs[j], segs[i], dir, 0, hops.a, mp);
set_parallel_edges (segs[j], segs[i], 1-dir, 1, hops.b, mp);
if(prec2==1)
removeEdge (segs[i], segs[j], 1-dir, mp);
break;
case 0 :
switch(prec2) {
case -1:
set_parallel_edges (segs[j], segs[i], dir, 0, hops.a, mp);
set_parallel_edges (segs[j], segs[i], 1-dir, 1, hops.b, mp);
break;
case 0 :
set_parallel_edges (segs[i], segs[j], 0, dir, hops.a, mp);
set_parallel_edges (segs[i], segs[j], 1, 1-dir, hops.b, mp);
break;
case 1:
set_parallel_edges (segs[i], segs[j], 0, dir, hops.a, mp);
set_parallel_edges (segs[i], segs[j], 1, 1-dir, hops.b, mp);
break;
}
break;
case 1 :
set_parallel_edges (segs[i], segs[j], 0, dir, hops.a, mp);
set_parallel_edges (segs[i], segs[j], 1, 1-dir, hops.b, mp);
if(prec2==-1)
removeEdge (segs[i], segs[j], 1-dir, mp);
break;
}
}
}
}
}
}
/* =============================================================================
* reverseEdge
* =============================================================================
*/
static void
reverseEdge (net_t* netPtr, long fromId, long toId)
{
removeEdge(netPtr, fromId, toId);
insertEdge(netPtr, toId, fromId);
}
/*************************************************
Function:
RemovingWeakNodesAndEdges2
Description:
1. Removes the nodes whose frequencies are not greater than threadhold NodeCovTh.
2. Removes the kmer-edges (the connections between nodes) whose frequencies
are not greater than threadhold EdgeCovTh.
Some statistics function here temporarily added.
Input:
1. ht: the graph hash table
2. K_size: kmer size
3. NodeCovTh: the threadhold for removing low coverage nodes
4. EdgeCovTh: the threadhold for removing low coverage kmer-edges
5. bucket_cnt: the current bucket number
6. edge_cnt: the current kmer-edge number
Output:
1. bucket_cnt: the bucket number after removing weak nodes and kmer-edges
2. edge_cnt: the kmer-edge number after removing weak nodes and kmer-edges
Return:
None.
*************************************************/
void RemovingWeakNodesAndEdges2 ( hashtable2 * ht, int K_size, int NodeCovTh, int EdgeCovTh, size_t * bucket_cnt, size_t * edge_cnt )
{
stat_edge_num ( ht );
stat_edge_cvg_len ( ht );
int Removed_Nodes_cnt = 0, Removed_Edges_cnt = 0;
bucket2 * bktptr = NULL, *bktptr_tmp = NULL;
bucket2 ** bktp2p = NULL;
edge_node * edge_ptr = NULL, *next_edge = NULL, *edge_tmp = NULL;
int smaller;
fprintf ( stderr, "Start to remove weak nodes and kmer-edges.\n" );
/*
for(size_t i=0;i<ht->ht_sz;++i)
{
bktptr=ht->store_pos[i];
while(bktptr!=NULL)
{
if(bktptr->kmer_info.cov1==0)printf("zero\n");
bktptr=bktptr->nxt_bucket;
}
}*/
//removing weak nodes
for ( size_t i = 0; i < ht->ht_sz; ++i )
{
bktptr = ht->store_pos[i];
while ( bktptr != NULL )
{
if ( bktptr->kmer_info.cov1 <= NodeCovTh )
{
bktptr->kmer_info.deleted = 1;
Removed_Nodes_cnt++;
edge_ptr = bktptr->kmer_info.right;
while ( edge_ptr )
{
edge_ptr->used = 1;
edge_ptr = edge_ptr->nxt_edge;
Removed_Edges_cnt++;
}
edge_ptr = bktptr->kmer_info.left;
while ( edge_ptr )
{
edge_ptr->used = 1;
edge_ptr = edge_ptr->nxt_edge;
Removed_Edges_cnt++;
}
}
bktptr = bktptr->nxt_bucket;
}
}
//removing dead edges
for ( size_t i = 0; i < ht->ht_sz; ++i )
{
bktptr = ht->store_pos[i];
while ( bktptr != NULL )
{
edge_ptr = bktptr->kmer_info.right;
while ( edge_ptr )
{
if ( edge_ptr->edge_cov <= EdgeCovTh )
{
edge_ptr->used = 1; //becasuse the cvg of edges is symmetrial, so it's ok
Removed_Edges_cnt++;
}
else
{
bktptr_tmp = lastKmer ( ht, K_size, bktptr, edge_ptr, 0, smaller );
if ( !bktptr_tmp )
{
fprintf ( stderr, "ERROR: to node not found error!\n" );
exit ( -1 );
}
if ( bktptr_tmp ->kmer_info.deleted )
{
edge_ptr->used = 1;
Removed_Edges_cnt++;
}
}
edge_ptr = edge_ptr->nxt_edge;
}
edge_ptr = bktptr->kmer_info.left;
while ( edge_ptr )
{
if ( edge_ptr->edge_cov <= EdgeCovTh )
{
edge_ptr->used = 1; //becasuse the cvg of edges is symmetrial, so it's ok
Removed_Edges_cnt++;
}
else
{
bktptr_tmp = lastKmer ( ht, K_size, bktptr, edge_ptr, 1, smaller );
if ( !bktptr_tmp )
{
fprintf ( stderr, "ERROR: to node not found error! \n" );
exit ( -1 );
}
if ( bktptr_tmp ->kmer_info.deleted )
{
edge_ptr->used = 1;
Removed_Edges_cnt++;
}
}
edge_ptr = edge_ptr->nxt_edge;
}
bktptr = bktptr->nxt_bucket;
}
}
for ( size_t i = 0; i < ht->ht_sz; ++i )
{
bktptr = ht->store_pos[i];
bktp2p = & ( ht->store_pos[i] );
while ( bktptr != NULL )
{
edge_ptr = bktptr->kmer_info.right;
while ( edge_ptr )
{
next_edge = edge_ptr->nxt_edge;
if ( edge_ptr->used )
{
removeEdge ( bktptr, edge_ptr, 0 );
//Removed_Edges_cnt2++;
}
edge_ptr = next_edge;
}
edge_ptr = bktptr->kmer_info.left;
while ( edge_ptr )
{
next_edge = edge_ptr->nxt_edge;
if ( edge_ptr->used )
{
removeEdge ( bktptr, edge_ptr, 1 );
//Removed_Edges_cnt2++;
}
edge_ptr = next_edge;
}
bktptr_tmp = bktptr->nxt_bucket;
if ( bktptr->kmer_info.deleted )
{
free ( bktptr );
( *bktp2p ) = bktptr_tmp;
//Removed_Nodes_cnt2++;
}
else
{
bktp2p = & ( bktptr->nxt_bucket );
}
bktptr = bktptr_tmp;
}
}
fprintf ( stderr, "%llu nodes removed.\n", Removed_Nodes_cnt );
fprintf ( stderr, "%llu edges removed.\n", Removed_Edges_cnt );
fprintf ( stderr, "\n" );
( *bucket_cnt ) -= Removed_Nodes_cnt;
( *edge_cnt ) -= Removed_Edges_cnt;
}
void Graph::removeEdge(int id){
removeEdge(m_getEdgeById[id]);
}
void Graph<T, C, W>::removeEdge(vector<Edge<T, C, W>* > const &edgeList) {
for(auto edge : edgeList) {
removeEdge(*edge);
}
}
