/** Find every path that overlaps with the specified path. */ static void findOverlaps(const Graph& g, const Paths& paths, const SeedMap& seedMap, const Vertex& v, Overlaps& overlaps) { ContigPath rc; if (v.sense) { rc = paths[v.id]; reverseComplement(rc.begin(), rc.end()); } const ContigPath& path = v.sense ? rc : paths[v.id]; for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) { if (it->ambiguous()) continue; pair<SeedMap::const_iterator, SeedMap::const_iterator> range = seedMap.equal_range(*it); for (SeedMap::const_iterator seed = range.first; seed != range.second; ++seed) { if (v == seed->second) continue; int distance = 0; unsigned overlap = findOverlap(g, paths, it, path.end(), seed->second, distance); if (overlap > 0) overlaps.push_back(Overlap(v, seed->second, overlap, distance)); } } }
/** Record the trimmed contigs. */ static void recordTrimmedContigs( ContigPath::const_iterator first, ContigPath::const_iterator last) { for (ContigPath::const_iterator it = first; it != last; ++it) if (!it->ambiguous()) s_trimmedContigs.push_back(it->contigIndex()); }
static void appendToMergeQ(deque<ContigNode>& mergeQ, set<ContigNode>& seen, const ContigPath& path) { for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) if (!it->ambiguous() && seen.insert(*it).second) mergeQ.push_back(*it); }
/** Finds all contigs used in each path in paths, and * marks them as seen in the vector seen. */ static void seenContigs(vector<bool>& seen, const ContigPaths& paths) { for (ContigPaths::const_iterator it = paths.begin(); it != paths.end(); ++it) for (ContigPath::const_iterator itc = it->begin(); itc != it->end(); ++itc) if (itc->id() < seen.size()) seen[itc->id()] = true; }
/** Return a pivot suitable for aligning the two paths if one exists, * otherwise return false. */ static pair<ContigNode, bool> findPivot( const ContigPath& path1, const ContigPath& path2) { for (ContigPath::const_iterator it = path2.begin(); it != path2.end(); ++it) { if (it->ambiguous()) continue; if (count(path2.begin(), path2.end(), *it) == 1 && count(path1.begin(), path1.end(), *it) == 1) return make_pair(*it, true); } return make_pair(ContigNode(0), false); }
/** Return the set of contigs that appear more than once in a single * solution. */ static set<ContigID> findRepeats(ContigID seed, const ContigPaths& solutions) { set<ContigID> repeats; for (ContigPaths::const_iterator solIt = solutions.begin(); solIt != solutions.end(); ++solIt) { map<ContigID, unsigned> count; count[seed]++; for (ContigPath::const_iterator it = solIt->begin(); it != solIt->end(); ++it) count[it->contigIndex()]++; for (map<ContigID, unsigned>::const_iterator it = count.begin(); it != count.end(); ++it) if (it->second > 1) repeats.insert(it->first); } return repeats; }
/** Return all contigs that are tandem repeats, identified as those * contigs that appear more than once in a single path. */ static set<ContigID> findRepeats(const ContigPathMap& paths) { set<ContigID> repeats; for (ContigPathMap::const_iterator pathIt = paths.begin(); pathIt != paths.end(); ++pathIt) { const ContigPath& path = pathIt->second; map<ContigID, unsigned> count; for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) if (!it->ambiguous()) count[it->contigIndex()]++; for (map<ContigID, unsigned>::const_iterator it = count.begin(); it != count.end(); ++it) if (it->second > 1) repeats.insert(it->first); } return repeats; }
/** Merge the specified path. */ static Contig mergePath(const Graph& g, const Contigs& contigs, const ContigPath& path) { Sequence seq; unsigned coverage = 0; for (ContigPath::const_iterator it = path.begin(); it != path.end(); ++it) { if (!it->ambiguous()) coverage += g[*it].coverage; if (seq.empty()) { seq = sequence(contigs, *it); } else { assert(it != path.begin()); mergeContigs(g, contigs, *(it-1), *it, seq, path); } } ostringstream ss; ss << seq.size() << ' ' << coverage << ' '; pathToComment(ss, g, path); return Contig(ss.str(), seq); }