Пример #1
0
//
// High level merge function that does not specify an edge
//
void Bigraph::mergeVertices(VertexID id1, VertexID id2)
{
    Vertex* pVert1 = getVertex(id1);

    // Get the edges from vertex1 to vertex2
    EdgePtrVec edgesTo = pVert1->findEdgesTo(id2);

    if(edgesTo.empty())
    {
        std::cerr << "mergeVertices: vertices are not connected\n";
        return;
    }

    if(edgesTo.size() > 1)
    {
        std::cerr << "mergeVertces: cannot merge because of ambigious edges\n";
        return;
    }

    // There is a single unique edge between the vertices
    Edge* mergeEdge = *edgesTo.begin();

    // Call the real merging function
    merge(pVert1, mergeEdge);
}
Пример #2
0
bool SGMaximalOverlapVisitor::visit(StringGraph* /*pGraph*/, Vertex* pVertex)
{
    bool modified = false;

    typedef bool(*PredicateEdge)(const Edge*);
    PredicateEdge predicateEdgeArray[ED_COUNT] = {SGMaximalOverlapVisitor::isSenseEdge, SGMaximalOverlapVisitor::isAntiSenseEdge};
    for(size_t idx = 0; idx < ED_COUNT; idx++)
    {
        EdgeDir dir = EDGE_DIRECTIONS[idx];
        EdgePtrVec edges = pVertex->getEdges(dir); // These edges are already sorted by overlap length
        if(edges.empty())
            continue;
            //return false;

        for(size_t i = 1; i < edges.size(); ++i)
        {
            if (edges[i]->getMatchLength() == edges[0]->getMatchLength())
                continue;

            bool valid = false;

            //EdgePtrVec redges = edges[i]->getEnd()->getEdges(EDGE_DIRECTIONS[ED_COUNT - idx - 1]);
            EdgePtrVec redges = edges[i]->getEnd()->getEdges();
            EdgePtrVec::iterator last = std::remove_if(redges.begin(), redges.end(), predicateEdgeArray[idx]);
            redges.resize(std::distance(redges.begin(), last));
            assert(!redges.empty());
            for(size_t j = 0; j < redges.size(); ++j)
            {
                if (redges[j]->getEndID() == pVertex->getID() && edges[0]->getMatchLength() - edges[i]->getMatchLength() <= _delta)
                {
                    valid = true;
                }
            }

            if (!valid)
            {
                edges[i]->setColor(GC_BLACK);
                edges[i]->getTwin()->setColor(GC_BLACK);
                modified = true;
            }
        }
    }

    return modified;
}
Пример #3
0
// Construct the walk structure from a vector of edges
SGWalk::SGWalk(const EdgePtrVec& edgeVec, bool bIndexWalk) : m_extensionDistance(0), m_extensionFinished(false)

{
    assert(!edgeVec.empty());

    if(bIndexWalk)
        m_pWalkIndex = new WalkIndex;
    else
        m_pWalkIndex = NULL;

    // The start vector is the start vertex of the first edge
    Edge* first = edgeVec.front();
    m_pStartVertex = first->getStart();

    for(EdgePtrVec::const_iterator iter = edgeVec.begin();
                                   iter != edgeVec.end();
                                   ++iter)
    {
        addEdge(*iter);
    }
}