bool DeBruijnNode::isNodeConnected(DeBruijnNode * node) const
{
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
if (edge->getStartingNode() == node || edge->getEndingNode() == node)
return true;
}
return false;
}
//This function checks to see if the passed node leads away from
//this node. If so, it returns the connecting edge. If not,
//it returns a null pointer.
DeBruijnEdge * DeBruijnNode::doesNodeLeadAway(DeBruijnNode * node) const
{
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
if (edge->getStartingNode() == this && edge->getEndingNode() == node)
return edge;
}
return 0;
}
std::vector<DeBruijnEdge *> DeBruijnNode::getLeavingEdges() const
{
std::vector<DeBruijnEdge *> returnVector;
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
if (this == edge->getStartingNode())
returnVector.push_back(edge);
}
return returnVector;
}
//If the node has an edge which leads to itself (creating a loop), this function
//will return it. Otherwise, it returns 0.
DeBruijnEdge * DeBruijnNode::getSelfLoopingEdge() const
{
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
if (edge->getStartingNode() == this && edge->getEndingNode() == this)
return edge;
}
return 0;
}
//This function checks whether this node has any path leading outward that
//unambiguously leads to the given node.
//It checks a number of steps as set by the contiguitySearchSteps setting.
//If includeReverseComplement is true, then this function returns true if
//all paths lead either to the node or its reverse complement node.
bool DeBruijnNode::doesPathLeadOnlyToNode(DeBruijnNode * node, bool includeReverseComplement)
{
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
bool outgoingEdge = (this == edge->getStartingNode());
std::vector<DeBruijnNode *> pathSoFar;
pathSoFar.push_back(this);
if (edge->leadsOnlyToNode(outgoingEdge, g_settings->contiguitySearchSteps, node, pathSoFar, includeReverseComplement))
return true;
}
return false;
}
//This function determines the contiguity of nodes relative to this one.
//It has two steps:
// -First, for each edge leaving this node, all paths outward are found.
// Any nodes in any path are MAYBE_CONTIGUOUS, and nodes in all of the
// paths are CONTIGUOUS.
// -Second, it is necessary to check in the opposite direction - for each
// of the MAYBE_CONTIGUOUS nodes, do they have a path that unambiguously
// leads to this node? If so, then they are CONTIGUOUS.
void DeBruijnNode::determineContiguity()
{
upgradeContiguityStatus(STARTING);
//A set is used to store all nodes found in the paths, as the nodes
//that show up as MAYBE_CONTIGUOUS will have their paths checked
//to this node.
std::set<DeBruijnNode *> allCheckedNodes;
//For each path leaving this node, find all possible paths
//outward. Nodes in any of the paths for an edge are
//MAYBE_CONTIGUOUS. Nodes in all of the paths for an edge
//are CONTIGUOUS.
for (size_t i = 0; i < m_edges.size(); ++i)
{
DeBruijnEdge * edge = m_edges[i];
bool outgoingEdge = (this == edge->getStartingNode());
std::vector< std::vector <DeBruijnNode *> > allPaths;
edge->tracePaths(outgoingEdge, g_settings->contiguitySearchSteps, &allPaths, this);
//Set all nodes in the paths as MAYBE_CONTIGUOUS
for (size_t j = 0; j < allPaths.size(); ++j)
{
QApplication::processEvents();
for (size_t k = 0; k < allPaths[j].size(); ++k)
{
DeBruijnNode * node = allPaths[j][k];
node->upgradeContiguityStatus(MAYBE_CONTIGUOUS);
allCheckedNodes.insert(node);
}
}
//Set all common nodes as CONTIGUOUS_STRAND_SPECIFIC
std::vector<DeBruijnNode *> commonNodesStrandSpecific = getNodesCommonToAllPaths(&allPaths, false);
for (size_t j = 0; j < commonNodesStrandSpecific.size(); ++j)
(commonNodesStrandSpecific[j])->upgradeContiguityStatus(CONTIGUOUS_STRAND_SPECIFIC);
//Set all common nodes (when including reverse complement nodes)
//as CONTIGUOUS_EITHER_STRAND
std::vector<DeBruijnNode *> commonNodesEitherStrand = getNodesCommonToAllPaths(&allPaths, true);
for (size_t j = 0; j < commonNodesEitherStrand.size(); ++j)
{
DeBruijnNode * node = commonNodesEitherStrand[j];
node->upgradeContiguityStatus(CONTIGUOUS_EITHER_STRAND);
node->getReverseComplement()->upgradeContiguityStatus(CONTIGUOUS_EITHER_STRAND);
}
}
//For each node that was checked, then we check to see if any
//of its paths leads unambiuously back to the starting node (this node).
for (std::set<DeBruijnNode *>::iterator i = allCheckedNodes.begin(); i != allCheckedNodes.end(); ++i)
{
QApplication::processEvents();
DeBruijnNode * node = *i;
ContiguityStatus status = node->getContiguityStatus();
//First check without reverse complement target for
//strand-specific contiguity.
if (status != CONTIGUOUS_STRAND_SPECIFIC &&
node->doesPathLeadOnlyToNode(this, false))
node->upgradeContiguityStatus(CONTIGUOUS_STRAND_SPECIFIC);
//Now check including the reverse complement target for
//either strand contiguity.
if (status != CONTIGUOUS_STRAND_SPECIFIC &&
status != CONTIGUOUS_EITHER_STRAND &&
node->doesPathLeadOnlyToNode(this, true))
{
node->upgradeContiguityStatus(CONTIGUOUS_EITHER_STRAND);
node->getReverseComplement()->upgradeContiguityStatus(CONTIGUOUS_EITHER_STRAND);
}
}
}