ngs_server 0.1

data/ext/bamtools/src/toolkit/bamtools_convert.h

@@ -0,0 +1,37 @@
+// ***************************************************************************
+// bamtools_convert.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 9 July 2010
+// ---------------------------------------------------------------------------
+// Converts between BAM and a number of other formats
+// ***************************************************************************
+
+#ifndef BAMTOOLS_CONVERT_H
+#define BAMTOOLS_CONVERT_H
+
+#include "bamtools_tool.h"
+
+namespace BamTools { 
+  
+class ConvertTool : public AbstractTool {
+  
+    public:
+        ConvertTool(void);
+        ~ConvertTool(void);
+
+    public:
+        int Help(void);
+        int Run(int argc, char* argv[]); 
+        
+    private: 
+        struct ConvertSettings;
+        ConvertSettings* m_settings;
+        
+        struct ConvertToolPrivate;
+        ConvertToolPrivate* m_impl;
+};
+  
+} // namespace BamTools
+
+#endif // BAMTOOLS_CONVERT_H

data/ext/bamtools/src/toolkit/bamtools_count.cpp

@@ -0,0 +1,187 @@
+// ***************************************************************************
+// bamtools_count.cpp (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 7 April 2011
+// ---------------------------------------------------------------------------
+// Prints alignment count for BAM file(s)
+// ***************************************************************************
+
+#include "bamtools_count.h"
+
+#include <api/BamMultiReader.h>
+#include <utils/bamtools_options.h>
+#include <utils/bamtools_utilities.h>
+using namespace BamTools;
+
+#include <iostream>
+#include <string>
+#include <vector>
+using namespace std;
+
+// ---------------------------------------------  
+// CountSettings implementation
+
+struct CountTool::CountSettings {
+
+    // flags
+    bool HasInput;
+    bool HasRegion;
+
+    // filenames
+    vector<string> InputFiles;
+    string Region;
+    
+    // constructor
+    CountSettings(void)
+        : HasInput(false)
+        , HasRegion(false)
+    { }  
+}; 
+  
+// ---------------------------------------------
+// CountToolPrivate implementation
+
+struct CountTool::CountToolPrivate {
+
+    // ctor & dtro
+    public:
+        CountToolPrivate(CountTool::CountSettings* settings)
+            : m_settings(settings)
+        { }
+
+        ~CountToolPrivate(void) { }
+
+    // interface
+    public:
+        bool Run(void);
+
+    // data members
+    private:
+        CountTool::CountSettings* m_settings;
+};
+
+bool CountTool::CountToolPrivate::Run(void) {
+
+    // if no '-in' args supplied, default to stdin
+    if ( !m_settings->HasInput )
+        m_settings->InputFiles.push_back(Options::StandardIn());
+
+    // open reader without index
+    BamMultiReader reader;
+    if ( !reader.Open(m_settings->InputFiles) ) {
+        cerr << "bamtools count ERROR: could not open input BAM file(s)... Aborting." << endl;
+        return false;
+    }
+
+    // alignment counter
+    BamAlignment al;
+    int alignmentCount(0);
+
+    // if no region specified, count entire file
+    if ( !m_settings->HasRegion ) {
+        while ( reader.GetNextAlignmentCore(al) )
+            ++alignmentCount;
+    }
+
+    // otherwise attempt to use region as constraint
+    else {
+
+        // if region string parses OK
+        BamRegion region;
+        if ( Utilities::ParseRegionString(m_settings->Region, reader, region) ) {
+
+            // attempt to find index files
+            reader.LocateIndexes();
+
+            // if index data available for all BAM files, we can use SetRegion
+            if ( reader.IsIndexLoaded() ) {
+
+                // attempt to set region on reader
+                if ( !reader.SetRegion(region.LeftRefID, region.LeftPosition, region.RightRefID, region.RightPosition) ) {
+                    cerr << "bamtools count ERROR: set region failed. Check that REGION describes a valid range" << endl;
+                    reader.Close();
+                    return false;
+                }
+
+                // everything checks out, just iterate through specified region, counting alignments
+                while ( reader.GetNextAlignmentCore(al) )
+                    ++alignmentCount;
+            }
+
+            // no index data available, we have to iterate through until we
+            // find overlapping alignments
+            else {
+                while ( reader.GetNextAlignmentCore(al) ) {
+                    if ( (al.RefID >= region.LeftRefID)  && ( (al.Position + al.Length) >= region.LeftPosition ) &&
+                          (al.RefID <= region.RightRefID) && ( al.Position <= region.RightPosition) )
+                    {
+                        ++alignmentCount;
+                    }
+                }
+            }
+        }
+
+        // error parsing REGION string
+        else {
+            cerr << "bamtools count ERROR: could not parse REGION - " << m_settings->Region << endl;
+            cerr << "Check that REGION is in valid format (see documentation) and that the coordinates are valid"
+                 << endl;
+            reader.Close();
+            return false;
+        }
+    }
+
+    // print results
+    cout << alignmentCount << endl;
+
+    // clean up & exit
+    reader.Close();
+    return true;
+}
+
+// ---------------------------------------------
+// CountTool implementation
+
+CountTool::CountTool(void) 
+    : AbstractTool()
+    , m_settings(new CountSettings)
+    , m_impl(0)
+{ 
+    // set program details
+    Options::SetProgramInfo("bamtools count", "prints number of alignments in BAM file(s)", "[-in <filename> -in <filename> ...] [-region <REGION>]");
+    
+    // set up options 
+    OptionGroup* IO_Opts = Options::CreateOptionGroup("Input & Output");
+    Options::AddValueOption("-in",     "BAM filename", "the input BAM file(s)", "", m_settings->HasInput,  m_settings->InputFiles, IO_Opts, Options::StandardIn());
+    Options::AddValueOption("-region", "REGION",       "genomic region. Index file is recommended for better performance, and is used automatically if it exists. See \'bamtools help index\' for more details on creating one", "", m_settings->HasRegion, m_settings->Region, IO_Opts);
+}
+
+CountTool::~CountTool(void) { 
+
+    delete m_settings;
+    m_settings = 0;
+
+    delete m_impl;
+    m_impl = 0;
+}
+
+int CountTool::Help(void) { 
+    Options::DisplayHelp();
+    return 0;
+} 
+
+int CountTool::Run(int argc, char* argv[]) { 
+
+    // parse command line arguments
+    Options::Parse(argc, argv, 1);
+
+    // initialize CountTool with settings
+    m_impl = new CountToolPrivate(m_settings);
+
+    // run CountTool, return success/fail
+    if ( m_impl->Run() )
+        return 0;
+    else
+        return 1;
+}

data/ext/bamtools/src/toolkit/bamtools_count.h

@@ -0,0 +1,37 @@
+// ***************************************************************************
+// bamtools_count.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 7 April 2011
+// ---------------------------------------------------------------------------
+// Prints alignment count for BAM file(s)
+// ***************************************************************************
+
+#ifndef BAMTOOLS_COUNT_H
+#define BAMTOOLS_COUNT_H
+
+#include "bamtools_tool.h"
+
+namespace BamTools { 
+  
+class CountTool : public AbstractTool {
+  
+    public:
+        CountTool(void);
+        ~CountTool(void);
+
+    public:
+        int Help(void);
+        int Run(int argc, char* argv[]); 
+        
+    private: 
+        struct CountSettings;
+        CountSettings* m_settings;
+
+        struct CountToolPrivate;
+        CountToolPrivate* m_impl;
+};
+  
+} // namespace BamTools
+
+#endif // BAMTOOLS_COUNT_H

data/ext/bamtools/src/toolkit/bamtools_coverage.cpp

@@ -0,0 +1,196 @@
+// ***************************************************************************
+// bamtools_coverage.cpp (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 7 April 2011
+// ---------------------------------------------------------------------------
+// Prints coverage data for a single BAM file 
+// ***************************************************************************
+
+#include "bamtools_coverage.h"
+
+#include <api/BamReader.h>
+#include <utils/bamtools_options.h>
+#include <utils/bamtools_pileup_engine.h>
+using namespace BamTools;
+
+#include <iostream>
+#include <fstream>
+#include <string>
+#include <vector>
+using namespace std;
+  
+namespace BamTools {
+ 
+// ---------------------------------------------  
+// CoverageVisitor implementation 
+  
+class CoverageVisitor : public PileupVisitor {
+  
+    public:
+        CoverageVisitor(const RefVector& references, ostream* out)
+            : PileupVisitor()
+            , m_references(references)
+            , m_out(out)
+        { }
+        ~CoverageVisitor(void) { }
+  
+    // PileupVisitor interface implementation
+    public:
+	// prints coverage results ( tab-delimited )
+        void Visit(const PileupPosition& pileupData) {
+            *m_out << m_references[pileupData.RefId].RefName << "\t" 
+                   << pileupData.Position << "\t" 
+                   << pileupData.PileupAlignments.size() << endl;
+        }
+        
+    private:
+        RefVector m_references;
+        ostream*  m_out;
+};
+
+} // namespace BamTools
+
+// ---------------------------------------------  
+// CoverageSettings implementation
+
+struct CoverageTool::CoverageSettings {
+
+    // flags
+    bool HasInputFile;
+    bool HasOutputFile;
+
+    // filenames
+    string InputBamFilename;
+    string OutputFilename;
+    
+    // constructor
+    CoverageSettings(void)
+        : HasInputFile(false)
+        , HasOutputFile(false)
+        , InputBamFilename(Options::StandardIn())
+        , OutputFilename(Options::StandardOut())
+    { } 
+};  
+
+// ---------------------------------------------
+// CoverageToolPrivate implementation
+
+struct CoverageTool::CoverageToolPrivate {
+  
+    // ctor & dtor
+    public:
+        CoverageToolPrivate(CoverageTool::CoverageSettings* settings)
+            : m_settings(settings)
+            , m_out(cout.rdbuf())
+        { }
+
+        ~CoverageToolPrivate(void) { }
+    
+    // interface
+    public:
+        bool Run(void);
+        
+    // data members
+    private: 
+        CoverageTool::CoverageSettings* m_settings;
+        ostream m_out;
+        RefVector m_references;
+};  
+
+bool CoverageTool::CoverageToolPrivate::Run(void) {  
+  
+    // if output filename given
+    ofstream outFile;
+    if ( m_settings->HasOutputFile ) {
+      
+        // open output file stream
+        outFile.open(m_settings->OutputFilename.c_str());
+        if ( !outFile ) {
+            cerr << "bamtools coverage ERROR: could not open " << m_settings->OutputFilename
+                 << " for output" << endl;
+            return false; 
+        }
+        
+        // set m_out to file's streambuf
+        m_out.rdbuf(outFile.rdbuf()); 
+    } 
+    
+    //open our BAM reader
+    BamReader reader;
+    if ( !reader.Open(m_settings->InputBamFilename) ) {
+        cerr << "bamtools coverage ERROR: could not open input BAM file: " << m_settings->InputBamFilename << endl;
+        return false;
+    }
+
+    // retrieve references
+    m_references = reader.GetReferenceData();
+    
+    // set up our output 'visitor'
+    CoverageVisitor* cv = new CoverageVisitor(m_references, &m_out);
+    
+    // set up pileup engine with 'visitor'
+    PileupEngine pileup;
+    pileup.AddVisitor(cv);
+    
+    // process input data
+    BamAlignment al;    
+    while ( reader.GetNextAlignment(al) ) 
+        pileup.AddAlignment(al);
+    
+    // clean up 
+    reader.Close();
+    if ( m_settings->HasOutputFile )
+        outFile.close();
+    delete cv;
+    cv = 0;
+    
+    // return success
+    return true;
+}
+
+// ---------------------------------------------
+// CoverageTool implementation
+
+CoverageTool::CoverageTool(void) 
+    : AbstractTool()
+    , m_settings(new CoverageSettings)
+    , m_impl(0)
+{ 
+    // set program details
+    Options::SetProgramInfo("bamtools coverage", "prints coverage data for a single BAM file", "[-in <filename>] [-out <filename>]");
+    
+    // set up options 
+    OptionGroup* IO_Opts = Options::CreateOptionGroup("Input & Output");
+    Options::AddValueOption("-in",  "BAM filename", "the input BAM file", "", m_settings->HasInputFile,  m_settings->InputBamFilename, IO_Opts, Options::StandardIn());
+    Options::AddValueOption("-out", "filename",     "the output file",    "", m_settings->HasOutputFile, m_settings->OutputFilename,   IO_Opts, Options::StandardOut());
+}
+
+CoverageTool::~CoverageTool(void) { 
+
+    delete m_settings;
+    m_settings = 0;
+    
+    delete m_impl;
+    m_impl = 0;
+}
+
+int CoverageTool::Help(void) { 
+    Options::DisplayHelp();
+    return 0;
+} 
+
+int CoverageTool::Run(int argc, char* argv[]) { 
+
+    // parse command line arguments
+    Options::Parse(argc, argv, 1);
+    
+    // initialize CoverageTool with settings
+    m_impl = new CoverageToolPrivate(m_settings);
+    
+    // run CoverageTool, return success/fail
+    if ( m_impl->Run() ) 
+        return 0;
+    else 
+        return 1;
+}  

data/ext/bamtools/src/toolkit/bamtools_coverage.h

@@ -0,0 +1,37 @@
+// ***************************************************************************
+// bamtools_coverage.h (c) 2010 Derek Barnett, Erik Garrison
+// Marth Lab, Department of Biology, Boston College
+// ---------------------------------------------------------------------------
+// Last modified: 1 August 2010
+// ---------------------------------------------------------------------------
+// Prints coverage data for a single BAM file 
+// ***************************************************************************
+
+#ifndef BAMTOOLS_COVERAGE_H
+#define BAMTOOLS_COVERAGE_H
+
+#include "bamtools_tool.h"
+
+namespace BamTools {
+  
+class CoverageTool : public AbstractTool {
+  
+    public:
+        CoverageTool(void);
+        ~CoverageTool(void);
+  
+    public:
+        int Help(void);
+        int Run(int argc, char* argv[]); 
+        
+    private:  
+        struct CoverageSettings;
+        CoverageSettings* m_settings;
+        
+        struct CoverageToolPrivate;
+        CoverageToolPrivate* m_impl;
+};
+  
+} // namespace BamTools
+
+#endif // BAMTOOLS_COVERAGE_H