Java FastqReader.iterator方法代码示例

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * Checks a fastq file to verify that all the reads can be parsed into a
 * FastqRecord. Errors should be thrown if any of the reads are not
 * formatted correctly.
 *
 * @param fastq the fastq file to verify
 */
public void veryfiyReads(File fastq)
{
    System.out.println("I should exit with a read count. If not check the error message");
    FastqReader fq = new FastqReader(fastq);
    Iterator it = fq.iterator();

    int itCounter = 0;
    while (it.hasNext())
    {
        FastqRecord seqRecord = (FastqRecord) it.next();
        itCounter++;
    }

    System.out.println("Counted " + itCounter + " reads");
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
public void compressFastq(File fastqFile, File fastqOut) throws FileNotFoundException, IOException, ClassNotFoundException
{
    FastqReader fqr = new FastqReader(fastqFile);
    FastqWriterFactory writer = new FastqWriterFactory();
    FastqWriter goodReads = writer.newWriter(fastqOut);

    Iterator<FastqRecord> it = fqr.iterator();

    //loop thru the interlaced file
    while (it.hasNext())
    {
        FastqRecord fastqRecord = it.next();
        if (!fastqRecord.getReadString().equalsIgnoreCase(""))
        {
            goodReads.write(fastqRecord);
        }
    }
    goodReads.close();
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
@Test(dataProvider = "readsToWrite")
public void testWritingReading(final List<GATKRead> readsToWrite) throws Exception {
    final File tempFile = IOUtils.createTempFile("testWriting", "fastq");
    final FastqGATKWriter writer = new FastqGATKWriter(
            new FastqWriterFactory().newWriter(tempFile));
    readsToWrite.forEach(writer::addRead);
    writer.close();
    // now check if reading is the same
    final FastqReader reader = new FastqReader(tempFile);
    final Iterator<GATKRead> iterator = new RecordToReadIterator<>(reader.iterator(), FastqGATKRead::new);
    readsToWrite.forEach(r -> Assert.assertEquals(iterator.next().convertToSAMRecord(null),
            r.convertToSAMRecord(null)));
    Assert.assertFalse(iterator.hasNext());
    reader.close();
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * A helper method to print out the sequence ids in a fastq file
 * @param fastqFile the fastq file for which the sequence ids should be printed
 */
public void printFastq(File fastqFile)
{
    FastqReader fq = new FastqReader(fastqFile);
    Iterator it = fq.iterator();
    //loop thru the left hand reads 
    while (it.hasNext())
    {
        FastqRecord seqRecord = (FastqRecord) it.next();
        System.out.println(seqRecord.getReadHeader());
    }
    fq.close();
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * Verifies that two files of left/right paired-end reads are in order and
 * contain no fastq format errors
 *
 * @param fastqLeft the left-handed fastq file to verify
 * @param fastqRight the right-handed fastq file to verify
 */
public void veryfiyPairedReads(File fastqLeft, File fastqRight)
{
    //System.out.println("I should exit with a read count. If not check the error message");
    FastqReader fql = new FastqReader(fastqLeft);
    Iterator itl = fql.iterator();
    FastqReader fqr = new FastqReader(fastqRight);
    Iterator itr = fqr.iterator();

    int itCounter = 0;
    while (itl.hasNext())
    {
        FastqRecord seqRecordLeft = (FastqRecord) itl.next();
        FastqRecord seqRecordRight = (FastqRecord) itr.next();

        String[] leftNameArray = seqRecordLeft.getReadHeader().split(" ");
        String[] rightNameArray = seqRecordRight.getReadHeader().split(" ");
        String leftName = leftNameArray[0];
        String rightName = rightNameArray[0];
        //System.out.println(leftName + " : "+rightName);
        if (!leftName.equalsIgnoreCase(rightName))
        {
            System.out.println("Found an error at read " + itCounter);
            System.err.println(leftName + " is not the same as " + rightName);
            System.exit(0);
        }
        itCounter++;
    }

    System.out.println("Counted " + itCounter + " reads which were all in order");
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
@Override
protected Iterator<GATKRead> getReaderIterator(final FastqReader reader) {
    return new RecordToReadIterator<>(reader.iterator(), FastqGATKRead::new);
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * Interlaces fastq sequences, where it is known that each sequence has a corresponding mate in the same order
 * @param leftReads the left-handed fastq reads
 * @param rightReads the right-handed fastq reads
 * @param fastqInterlacedFile the interlaced paired fastq files
 * @throws IOException 
 */
public void interlaceKnownPairs(File leftReads, File rightReads, File fastqInterlacedFile) throws IOException
{

    FastqReader lfq = new FastqReader(leftReads);
    FastqReader rfq = new FastqReader(rightReads);

    FastqWriterFactory writer = new FastqWriterFactory();
    //for the matching paired-end reads
    FastqWriter interlacedSeqs = writer.newWriter(fastqInterlacedFile);
    int peCounter = 0;
    Iterator lit = lfq.iterator();
    Iterator rit = rfq.iterator();
    //loop thru the left hand reads
    while (lit.hasNext())
    {
        FastqRecord leftSeqRecord = (FastqRecord) lit.next();
        if (!rit.hasNext())
        {
            System.err.println("More reads in left file than right");
            System.exit(1);
        }
        else
        {
            FastqRecord rightSeqRecord = (FastqRecord) rit.next();
            //and write the paired reads to their file
            interlacedSeqs.write(leftSeqRecord);
            interlacedSeqs.write(rightSeqRecord);
            peCounter++;
        }
    }
    if (rit.hasNext())
    {
        System.err.println("More reads in right file than left");
        System.exit(1);
    }
    rfq.close();
    lfq.close();
    interlacedSeqs.close();
    System.out.println("Interlaced " + peCounter + " paired-end reads");
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * Takes a fastq file and calculates the number of reads which have a 'N'
 * and the distribution of read lengths
 *
 * @param fastq the fastq file to analyse
 * @return the number of reads found with 'N' in the read sequence
 */
public int countLengthsAndNs(File fastq)
{
    FastqReader fq = new FastqReader(fastq);
    int readsWithNs = 0;
    TreeMap<Integer, Integer> lengthDists = new TreeMap<>();

    //create an interator for each file
    Iterator it = fq.iterator();

    int itCounter = 0;
    while (it.hasNext())
    {
        //get the corresponding reads
        FastqRecord seqRecord = (FastqRecord) it.next();

        //get the length of them
        int seqLength = seqRecord.getReadString().length();
        if (lengthDists.containsKey(seqLength))
        {
            Integer count = lengthDists.get(seqLength);
            count++;
            lengthDists.put(seqLength, count);
        } else
        {
            lengthDists.put(seqLength, 1);
        }

        //check for N's
        String readString = seqRecord.getReadString();

        boolean containsN = readString.toLowerCase().contains("n");

        if (containsN == true)
        {
            readsWithNs++;
        }
        itCounter++;

    }
    System.out.println("Completed reading " + itCounter + " reads");
    for (Map.Entry<Integer, Integer> entry : lengthDists.entrySet())
    {
        Integer key = entry.getKey();
        Integer value = entry.getValue();

        System.out.println("length: " + key + " count: " + value);
    }
    System.out.println("Found " + readsWithNs + " read with at least one 'N'");
    return readsWithNs;

}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * Removes pairs of reads where at least one of the pair contains short/long
 * reads or a read that contain an 'N', from paired-end fastq files.
 * Optionally writes bad reads to a file.
 *
 * @param leftFastqFileIn the left-handed reads
 * @param rightFastqFileIn the right-handed reads
 * @param leftReadsOut the QCd left-handed reads
 * @param rightReadsOut the QCd right-handed reads

 */
public void removeNsFromPairedReads(File leftFastqFileIn, File rightFastqFileIn, File leftReadsOut, File rightReadsOut)
{
    FastqReader fql = new FastqReader(leftFastqFileIn);
    FastqReader fqr = new FastqReader(rightFastqFileIn);

    FastqWriterFactory writer = new FastqWriterFactory();
    FastqWriter goodLeftSeqs = writer.newWriter(leftReadsOut);
    FastqWriter goodRightSeqs = writer.newWriter(rightReadsOut);

    int itCounterAll = 0;
    int itCounterGood = 0;

    //create an interator for each file
    Iterator itl = fql.iterator();
    Iterator itr = fqr.iterator();

    while (itl.hasNext())
    {
        itCounterAll++;
        //get the corresponding reads
        FastqRecord leftSeqRecord = (FastqRecord) itl.next();
        FastqRecord rightSeqRecord = (FastqRecord) itr.next();
        String leftReadString = leftSeqRecord.getReadString();
        String rightReadString = rightSeqRecord.getReadString();
        boolean leftContainsN = leftReadString.toLowerCase().contains("n");
        boolean rightContainsN = rightReadString.toLowerCase().contains("n");


        if (!leftContainsN && !rightContainsN)
        {
            goodLeftSeqs.write(leftSeqRecord);
            goodRightSeqs.write(rightSeqRecord);
            itCounterGood++;
        } 
    }

    goodLeftSeqs.close();
    goodRightSeqs.close();

    System.out.println("Wrote " + itCounterGood + " of " +  itCounterAll +" reads");
}
 

import htsjdk.samtools.fastq.FastqReader; //导入方法依赖的package包/类
/**
 * 
 * @param fastqFile a fastq file of joined left-handed and right-handed reads
 * @param leftPairdReads the split left-handed reads
 * @param rightPairedReads the split right-handed reads
 */
public void split(File fastqFile, File leftPairdReads, File rightPairedReads)
{
    FastqReader fqr = new FastqReader(fastqFile);
    FastqWriterFactory writer = new FastqWriterFactory();
    FastqWriter leftPairedSeqs = writer.newWriter(leftPairdReads);
    FastqWriter rightPairedSeqs = writer.newWriter(rightPairedReads);
    Iterator<FastqRecord> it = fqr.iterator();
    int peCounter = 0;

    //loop thru the interlaced file
    while (it.hasNext())
    {
        FastqRecord fastqRecord = it.next();
        //get the read name
        String readHeader = fastqRecord.getReadHeader();
        //get Sequence
        String seq = fastqRecord.getReadString();
        
        String qualString = fastqRecord.getBaseQualityString();
        int readlength = seq.length();
        int midpoint = readlength/2;

        String leftHeader = readHeader.concat(" 1:N:0:");
        String rightHeader = readHeader.concat(" 2:N:0:");

        String leftRead = seq.substring(0, midpoint);
        String rightRead = seq.substring(midpoint, readlength);

        String leftQual = qualString.substring(0, midpoint);
        String rightQual = qualString.substring(midpoint, readlength);

        FastqRecord leftSeq = new FastqRecord(leftHeader, leftRead, "", leftQual);
        FastqRecord rightSeq = new FastqRecord(rightHeader, rightRead, "", rightQual);
        leftPairedSeqs.write(leftSeq);
        rightPairedSeqs.write(rightSeq);
        peCounter++;

    }
    leftPairedSeqs.close();
    rightPairedSeqs.close();
    System.out.println("Completed spliting " + peCounter + " paired-reads");
}