Updated coverageBed and bedFile.cpp

	1. Revised usage to 80 chars
	2. GPL headers
	3. Added new stdin logic
	4. Changes logo.
	5. Updated bedFile.cpp's loadBedIntoMapBin to support stdin.

src/coverageBed/a.bed

+chr1	10	20
+chr1	20	30
+chr1	30	40
+

src/coverageBed/b.bed

+chr1	0	100
+chr2	0	100

src/coverageBed/coverageBed.cpp

-// 
-//  coverageBed.cpp
-//  BEDTools
-//  
-//  Created by Aaron Quinlan Spring 2009.
-//  Copyright 2009 Aaron Quinlan. All rights reserved.
-//
-//
+/*****************************************************************************
+  coverageBed.cpp
+
+  (c) 2009 - Aaron Quinlan
+  Hall Laboratory
+  Department of Biochemistry and Molecular Genetics
+  University of Virginia
+  aaronquinlan@gmail.com
+
+  Licenced under the GNU General Public License 2.0+ license.
+******************************************************************************/
 #include "lineFileUtilities.h"
 #include "coverageBed.h"
 
 
-BedGraph::BedGraph(string &bedAFile, string &bedBFile, bool &forceStrand) {
+BedCoverage::BedCoverage(string &bedAFile, string &bedBFile, bool &forceStrand) {
 
 	this->bedAFile = bedAFile;
 	this->bedBFile = bedBFile;
@@ -23,75 +26,43 @@ BedGraph::BedGraph(string &bedAFile, string &bedBFile, bool &forceStrand) {
 
 
 
-BedGraph::~BedGraph(void) {
+BedCoverage::~BedCoverage(void) {
 }
 
 
  
-void BedGraph::GraphBed() {
-
+void BedCoverage::GetCoverage(istream &bedInput) {
+	
 	// load the "B" bed file into a map so
 	// that we can easily compare "A" to it for overlaps
 	bedB->loadBedFileIntoMap();
 
-
-	string bedLine;
-	BED bedEntry;                                                                                                                        
-	int lineNum = 0;
-
-	// are we dealing with a file?
-	if (bedA->bedFile != "stdin") {
-		
-		ifstream bed(bedA->bedFile.c_str(), ios::in);
-		if ( !bed ) {
-			cerr << "Error: The requested bed file (" <<bedA->bedFile << ") could not be opened. Exiting!" << endl;
-			exit (1);
-		}
+	string bedLine;                                                                                                                    
+	int lineNum = 0;					// current input line number
+	vector<string> bedFields;			// vector for a BED entry
 	
-		BED a;
-		while (getline(bed, bedLine)) {
+	bedFields.reserve(12);	
 		
-			if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
-				continue;
-			}
-			else {
-				vector<string> bedFields;
-				Tokenize(bedLine,bedFields);
-				lineNum++;
-				// process the feature in A IFF it's valid.
-				if (bedA->parseBedLine(a, bedFields, lineNum)) {
-			
-					// increment the count of overlaps for each feature in B that
-					// overlaps the current A interval
-					bedB->countHits(bedB->bedMap[a.chrom], a, this->forceStrand);
-				}
-			}
-		}
-	}
-	// A is being passed via stdin.
-	else {
+	BED a;
+	// process each entry in A
+	while (getline(bedInput, bedLine)) {
+
+		lineNum++;
+		Tokenize(bedLine,bedFields);
 	
-		BED a;
-		while (getline(cin, bedLine)) {
-		
-			if ((bedLine.find("track") != string::npos) || (bedLine.find("browser") != string::npos)) {
-				continue;
-			}
-			else {
-				vector<string> bedFields;
-				Tokenize(bedLine,bedFields);
-				lineNum++;
-				// process the feature in A IFF it's valid.
-				if (bedA->parseBedLine(a, bedFields, lineNum)) {
-			
-					// increment the count of overlaps for each feature in B that
-					// overlaps the current A interval
-					bedB->countHits(bedB->bedMap[a.chrom], a, this->forceStrand);
-				}
-			}
-		}
+		// find the overlaps with B if it's a valid BED entry. 
+		if (bedA->parseLine(a, bedFields, lineNum)) {
+	
+			// increment the count of overlaps for each feature in B that
+			// overlaps the current A interval
+			bedB->countHits(bedB->bedMap[a.chrom], a, this->forceStrand);
+		}	
+		// reset for the next input line
+		bedFields.clear();
 	}
 	
+	
+	
 	// now, report the count of hist for each feature in B.
 	for (masterBedMap::iterator c = bedB->bedMap.begin(); c != bedB->bedMap.end(); ++c) {
 		map<int, vector<BED> > bin2Beds = c->second;
@@ -135,3 +106,18 @@ void BedGraph::GraphBed() {
 }
 
 
+void BedCoverage::DetermineBedInput() {
+	if (bedA->bedFile != "stdin") {   // process a file
+		ifstream beds(bedA->bedFile.c_str(), ios::in);
+		if ( !beds ) {
+			cerr << "Error: The requested bed file (" << bedA->bedFile << ") could not be opened. Exiting!" << endl;
+			exit (1);
+		}
+		GetCoverage(beds);
+	}
+	else {   						// process stdin
+		GetCoverage(cin);		
+	}
+}
+
+

src/coverageBed/coverageBed.h

+/*****************************************************************************
+  coverageBed.h
+
+  (c) 2009 - Aaron Quinlan
+  Hall Laboratory
+  Department of Biochemistry and Molecular Genetics
+  University of Virginia
+  aaronquinlan@gmail.com
+
+  Licenced under the GNU General Public License 2.0+ license.
+******************************************************************************/
 #ifndef	COVERAGEBED_H
 #define COVERAGEBED_H
 
@@ -12,18 +23,19 @@ using namespace std;
 //************************************************
 // Class methods and elements
 //************************************************
-class BedGraph {
+class BedCoverage {
 
 public:
 
 	// constructor 
-	BedGraph(string &, string &, bool &);
+	BedCoverage(string &, string &, bool &);
 
 	// destructor
-	~BedGraph(void);
+	~BedCoverage(void);
 	
-	void GraphBed();
+	void GetCoverage(istream &bedInput);
 	
+	void DetermineBedInput();
 	
 private:
 

src/coverageBed/coverageMain.cpp

+/*****************************************************************************
+  coverageMain.cpp
+
+  (c) 2009 - Aaron Quinlan
+  Hall Laboratory
+  Department of Biochemistry and Molecular Genetics
+  University of Virginia
+  aaronquinlan@gmail.com
+
+  Licenced under the GNU General Public License 2.0+ license.
+******************************************************************************/
 #include "coverageBed.h"
 #include "version.h"
 
@@ -72,8 +83,8 @@ int main(int argc, char* argv[]) {
 
 	if (!showHelp) {
 
-		BedGraph *bg = new BedGraph(bedAFile, bedBFile, forceStrand);
-		bg->GraphBed();
+		BedCoverage *bg = new BedCoverage(bedAFile, bedBFile, forceStrand);
+		bg->DetermineBedInput();
 		return 0;
 	}
 	else {
@@ -85,22 +96,17 @@ void ShowHelp(void) {
 	
 	//cout << "\t" << beds[i].count << "\t" << (length-zeroDepthCount) << "\t" << length << "\t" << (float) (length-zeroDepthCount)/length << endl;
 
-	cerr << "===============================================" << endl;
-	cerr << " " <<PROGRAM_NAME << " v" << VERSION << endl ;
-	cerr << " Aaron Quinlan, Ph.D. (aaronquinlan@gmail.com)  " << endl ;
-	cerr << " Hall Laboratory, University of Virginia" << endl;
-	cerr << "===============================================" << endl << endl;
-	cerr << "Description: Returns the depth and breadth of coverage of features from A" << endl;
-	cerr << "on the intervals in B." << endl << endl;
+	cerr << endl << "PROGRAM: " << PROGRAM_NAME << " (v" << VERSION << ")" << endl << endl;
 	
-	cerr << "Usage: " << PROGRAM_NAME << " [OPTIONS] -a <a.bed> -b <b.bed>" << endl << endl;
-
-	cerr << "NOTES: " << endl;
-	cerr << "\t" << "-i stdin\t\t"	<< "Allows BED file A to be read from stdin.  E.g.: cat a.bed | coverageBed -a stdin -b B.bed" << endl << endl;
-	cerr << "\t***Only tab-delimited BED3 - BED6 formats allowed.***"<< endl << endl;
+	cerr << "AUTHOR:  Aaron Quinlan (aaronquinlan@gmail.com)" << endl << endl ;
+	
+	cerr << "SUMMARY: Returns the depth and breadth of coverage of features from A" << endl;
+	cerr << "\t on the intervals in B." << endl << endl;
+	
+	cerr << "USAGE:   " << PROGRAM_NAME << " [OPTIONS] -a <a.bed> -b <b.bed>" << endl << endl;
 
-	cerr << "OUTPUT: " << endl;
-	cerr << "\t" << "After each entry in B, reports: " << endl; 
+	cerr << "OUTPUT:  " << endl;
+	cerr << "\t" << " After each entry in B, reports: " << endl; 
 	cerr << "\t  1) The number of overlapping entries in A." << endl;
 	cerr << "\t  2) The number of bases in B that had non-zero coverage." << endl;
 	cerr << "\t  3) The length of the entry in B." << endl;

src/mergeBed/a.bed

-chr1	10	20	a
-chr1	15	25	b
+chr1	100	200	A1
+chr1	150	300	A2
+chr1	250	500	A3

src/mergeBed/b.bed

+chr1	100	200
+chr1	501	1000
+

src/mergeBed/mergeBed.cpp

@@ -233,7 +233,7 @@ void BedMerge::MergeBedStranded() {
 				}
 				else {
 
-					// was there an overlap befor the current entry broke it?
+					// was there an overlap before the current entry broke it?
 					if (OIP) {
 						if (this->numEntries) {
 							cout << bedList[prev].chrom << "\t" << minStart << "\t" << maxEnd << "\t" << mergeCount << "\t" << strands[s] << endl;

src/mergeBed/mergeMain.cpp

@@ -122,7 +122,7 @@ void ShowHelp(void) {
 	cerr						<< "\t- By default, merging is done without respect to strand." << endl << endl;
 
 	cerr << "  " << "-n\t"		<< "Report the number of BED entries that were merged." << endl;
-	cerr						<< "\t- Note: \"1\" is reported if no merging occured." << endl << endl;
+	cerr						<< "\t- Note: \"1\" is reported if no merging occurred." << endl << endl;
 
 
 	cerr << "  " << "-d\t"  	<< "Maximum distance between features allowed for features to be merged." << endl;

src/utils/bedFile/bedFile.cpp

@@ -475,33 +475,52 @@ bool BedFile::parseGffLine (BED &bed, const vector<string> &lineVector, int line
 
 void BedFile::loadBedFileIntoMap() {
 
-	// open the BED file for reading                                                                                                                                      
-	ifstream bed(bedFile.c_str(), ios::in);
-	if ( !bed ) {
-		cerr << "Error: The requested bed file (" <<bedFile << ") could not be opened. Exiting!" << endl;
-		exit (1);
-	}
-
-	string bedLine;                                                                                                                       
+	string bedLine;
+	BED bedEntry;                                                                                                                        
 	int lineNum = 0;
 
 	vector<string> bedFields;	// vector of strings for each column in BED file.
-	bedFields.reserve(12);		// reserve space for worst case (BED 6)
+	bedFields.reserve(12);		// reserve space for worst case (BED 12)
+
+
+	// Case 1: Proper BED File.
+	if ( (this->bedFile != "") && (this->bedFile != "stdin") ) {
+		
+		// open the BED file for reading                                                                                                                                      
+		ifstream bed(bedFile.c_str(), ios::in);
+		if ( !bed ) {
+			cerr << "Error: The requested bed file (" <<bedFile << ") could not be opened. Exiting!" << endl;
+			exit (1);
+		}
+
+		while (getline(bed, bedLine)) {
+			lineNum++;
+		
+			Tokenize(bedLine,bedFields);
 
-	while (getline(bed, bedLine)) {
-		lineNum++;
-		BED bedEntry; 
+			if (parseLine(bedEntry, bedFields, lineNum)) {
+				int bin = getBin(bedEntry.start, bedEntry.end);
+				bedEntry.count = 0;
+				bedEntry.minOverlapStart = INT_MAX;
+				this->bedMap[bedEntry.chrom][bin].push_back(bedEntry);	
+			}
+			bedFields.clear();
+		}
+	}
+	else {
+		while (getline(cin, bedLine)) {
+			lineNum++;
 		
-		Tokenize(bedLine,bedFields);
+			Tokenize(bedLine,bedFields);
 
-		if (parseLine(bedEntry, bedFields, lineNum)) {
-			//this->reportBedNewLine(bedEntry);
-			int bin = getBin(bedEntry.start, bedEntry.end);
-			bedEntry.count = 0;
-			bedEntry.minOverlapStart = INT_MAX;
-			this->bedMap[bedEntry.chrom][bin].push_back(bedEntry);	
+			if (parseLine(bedEntry, bedFields, lineNum)) {
+				int bin = getBin(bedEntry.start, bedEntry.end);
+				bedEntry.count = 0;
+				bedEntry.minOverlapStart = INT_MAX;
+				this->bedMap[bedEntry.chrom][bin].push_back(bedEntry);	
+			}
+			bedFields.clear();
 		}
-		bedFields.clear();
 	}
 }
 
@@ -513,7 +532,7 @@ void BedFile::loadBedFileIntoMapNoBin() {
 	int lineNum = 0;
 
 	vector<string> bedFields;	// vector of strings for each column in BED file.
-	bedFields.reserve(12);		// reserve space for worst case (BED 6)
+	bedFields.reserve(12);		// reserve space for worst case (BED 12)
 
 	// Case 1: Proper BED File.
 	if ( (this->bedFile != "") && (this->bedFile != "stdin") ) {