This function is intended to be an interactive technique for constructing transcripts, probably to be released
        in a future version of msbwt
        @param bwtFN - the filename of the BWT to load
        @param seedKmer - the seed sequence to use for construction
        @param threshold - minimum number for a path to be considered a path
        @param direction - True is forward, False is backward
        @param logger - the logger
        @param

def extendSeed(self, seedKmer, endSeeds):
        '''
        This function is intended to be an interactive technique for constructing transcripts, probably to be released
        in a future version of msbwt
        @param bwtFN - the filename of the BWT to load
        @param seedKmer - the seed sequence to use for construction
        @param threshold - minimum number for a path to be considered a path
        @param direction - True is forward, False is backward
        @param logger - the logger
        @param 
        '''
        
        if self.foundKmers.has_key(seedKmer):
            return
        
        pathK = self.settingsDict.get('kmerSize', len(seedKmer))
        countK = self.settingsDict.get('countK', pathK)
        isMerged = self.settingsDict.get('isMerged', False)
        trackPairs = self.settingsDict.get('trackPairs', False)
        trackReads = self.settingsDict.get('trackReads', False)
        useMemmap = self.settingsDict.get('useMemmap', True)
        maxDistance = self.settingsDict.get('maxDistance', 0xFFFFFFFF)
        
        if len(seedKmer) != pathK:
            raise Exception('Seed k-mer incorrect length')
        
        numNodes = self.settingsDict['numNodes']
        validChars = ['$', 'A', 'C', 'G', 'N', 'T']
        
        if self.logger != None:
            self.logger.info('Loading '+self.bwtDir+'...')
        msbwt = MultiStringBWT.loadBWT(self.bwtDir, useMemmap, self.logger)
        if os.path.exists(self.bwtDir+'/origins.npy'):
            raise Exception("You haven\'t reimplemented the handling of origin files")
            origins = np.load(self.bwtDir+'/origins.npy', 'r')
        else:
            origins = None
        
        self.settingsDict['interleaveFN'] = self.bwtDir+'/inter0.npy'
        
        kmer = seedKmer
        
        firstID = len(self.nodes)
        self.nodes.append(PathNode(firstID, kmer, msbwt, 0, self.settingsDict))
        self.foundKmers[kmer] = firstID
        
        for i, endSeed in enumerate(endSeeds):
            if len(endSeed) != pathK:
                raise Exception(endSeed+': NOT CORRECT LENGTH')
            else:
                endID = len(self.nodes)
                self.nodes.append(PathNode(endID, endSeed, msbwt, 0, self.settingsDict))
                self.nodes[endID].termCondition = 'END_SEED_'+str(i)
                self.foundKmers[endSeed] = endID
        
        if self.logger != None:
            self.logger.info('Beginning with seed \''+seedKmer+'\', pathK='+str(pathK)+', countK='+str(countK))
        
        unexploredPaths = [self.nodes[firstID]]
        
        #init the kmer dictionary
        execID = firstID
        
        while len(unexploredPaths) > 0:
            #uncomment to make this smallest first
            unexploredPaths.sort(key = lambda node: node.minDistToSeed)
            #print 'UP: '+'['+','.join([str((node.minDistToSeed, node.nodeID)) for node in unexploredPaths])+']'
            nextNode = unexploredPaths.pop(0)
            
            if nextNode.nodeID >= numNodes:
                nextNode.termCondition = 'UNEXPLORED_NODE'
            elif nextNode.minDistToSeed >= maxDistance:
                nextNode.termCondition = 'UNEXPLORED_DIST'
            else:
                nextNode.execOrder = execID
                execID += 1
                
                if self.logger != None:
                    self.logger.info('Exploring new node')
                nextNode.firstTimeExtension(self.foundKmers, unexploredPaths, self.nodes, self.edges)
            
        if isMerged and trackReads:
            interleaveFN = self.bwtDir+'/inter0.npy'
            interleave = np.load(interleaveFN, 'r')
            
            #we only need to do this for newly processed nodes
            for node in self.nodes[firstID:]:
                dIDs = node.readSet
                for dID in dIDs:
                    sourceID = interleave[dID[0]]
                    node.sourceCounts[sourceID] = node.sourceCounts.get(sourceID, 0)+1
                
        if trackPairs:
            abtFN = self.bwtDir+'/abt.npy'
            abt = np.load(abtFN, 'r')
                    
            #abtDict = {}
            
            #only need to process new nodes
            for node in self.nodes[firstID:]:
                dIDs = node.readSet
                
                for dID, direction in dIDs:
                    (fID, rID) = abt[dID]
                    if fID % 2 == 0:
                        oFID = fID+1
                    else:
                        oFID = fID-1
                    
                    if self.abtDict.has_key((oFID, rID, 1-direction)):
                        otherNIDs = self.abtDict[(oFID, rID, 1-direction)][1]
                        for n in otherNIDs:
                            self.nodes[n].pairedNodes[node.nodeID] = self.nodes[n].pairedNodes.get(node.nodeID, 0)+1
                            node.pairedNodes[n] = node.pairedNodes.get(n, 0)+1
                    
                    if not self.abtDict.has_key((fID, rID, direction)):
                        self.abtDict[(fID, rID, direction)] = (dID, set([]))
                    self.abtDict[(fID, rID, direction)][1].add(node.nodeID)