Method getSimilarCoveragePath

src/rnabloom/util/GraphUtils.java:1149–1495

(BloomFilterDeBruijnGraph graph, 
                                                        ArrayList<Kmer> leftKmers, 
                                                        ArrayList<Kmer> rightKmers, 
                                                        int bound, 
                                                        int lookahead, 
                                                        float maxCovGradient,
                                                        boolean rescue,
                                                        float minKmerCov)

    }
    
    public static ArrayList<Kmer> getSimilarCoveragePath(BloomFilterDeBruijnGraph graph, 
                                                        ArrayList<Kmer> leftKmers, 
                                                        ArrayList<Kmer> rightKmers, 
                                                        int bound, 
                                                        int lookahead, 
                                                        float maxCovGradient,
                                                        boolean rescue,
                                                        float minKmerCov) {
        
        HashSet<Kmer> leftKmersSet = new HashSet<>(leftKmers);
        HashSet<Kmer> rightKmersSet = new HashSet<>(rightKmers);
        
        Kmer left = leftKmers.get(leftKmers.size()-1);
        Kmer right = rightKmers.get(0);
        
        float leftCoverageThreshold = getMinimumKmerCoverage(leftKmers) * maxCovGradient;
        float rightCoverageThreshold = getMinimumKmerCoverage(rightKmers) * maxCovGradient;
        
        int k = graph.getK();
        int numHash = graph.getMaxNumHash();
        
        HashSet<Kmer> leftPathKmers = new HashSet<>(bound);
        
        /* extend right */
        ArrayDeque<Kmer> leftPath = new ArrayDeque<>(bound);
        Kmer best;
        ArrayDeque<Kmer> neighbors = new ArrayDeque<>(4);
        
        best = left;

        for (int depth=0; depth < bound; ++depth) {
            best.getSuccessors(k, numHash, graph, neighbors, minKmerCov);

            if (neighbors.isEmpty()) {
                break;
            }
            else {
                if (neighbors.size() == 1) {
                    best = neighbors.pop();
                }
                else {
                    Iterator<Kmer> itr = neighbors.iterator();
                    while (itr.hasNext()) {
                        if (itr.next().count < leftCoverageThreshold) {
                            itr.remove();
                        }
                    }
                    
                    if (neighbors.isEmpty()) {
                        break;
                    }
                    else if (neighbors.size() == 1) {
                        best = neighbors.pop();
                        
                        float c = maxCovGradient * best.count;
                        if (c < leftCoverageThreshold) {
                            leftCoverageThreshold = c;
                        }