Merge branch 'blockViz' into chains

chain/impl/halBlockViz.cpp

@@ -182,7 +182,8 @@ extern "C" void halFreeBlocks(struct hal_block_t* head)
   while (head != NULL)
   {
     hal_block_t* next = head->next;
-    free(head->sequence);
+    free(head->qSequence);
+    free(head->tSequence);
     free(head->qChrom);
     free(head);
     head = next;
@@ -707,7 +708,8 @@ void readBlock(AlignmentConstPtr seqAlignment,
   cur->next = NULL;
 
   string seqBuffer = qSequence->getName();
-  string dnaBuffer;
+  string qDnaBuffer;
+  string tDnaBuffer;
   size_t prefix = 
      seqBuffer.find(genomeName + '.') != 0 ? 0 : genomeName.length() + 1;
   cur->qChrom = (char*)malloc(seqBuffer.length() + 1 - prefix);
@@ -737,7 +739,8 @@ void readBlock(AlignmentConstPtr seqAlignment,
   assert(firstRefSeg->getLength() == firstQuerySeg->getLength());
   cur->size = 1 + tEnd - cur->tStart;
   cur->strand = firstQuerySeg->getReversed() ? '-' : '+';
-  cur->sequence = NULL;
+  cur->tSequence = NULL;
+  cur->qSequence = NULL;
   if (getSequenceString != 0)
   {
     const Genome* qSeqGenome = 
@@ -757,14 +760,36 @@ void readBlock(AlignmentConstPtr seqAlignment,
          << " for DNA sequence extraction";
       throw hal_exception(ss.str());
     }
+
+    const Genome* tSeqGenome = 
+       seqAlignment->openGenome(tSequence->getGenome()->getName());
+    if (tSeqGenome == NULL)
+    {
+      stringstream ss;
+      ss << "Unable to open genome " << tSequence->getGenome()->getName() 
+         << " for DNA sequence extraction";
+      throw hal_exception(ss.str());
+    }
+
+    const Sequence* tSeqSequence = tSeqGenome->getSequence(tSequence->getName());
+    if (tSeqSequence == NULL)
+    {
+      stringstream ss;
+      ss << "Unable to open sequence " << tSequence->getName() 
+         << " for DNA sequence extraction";
+      throw hal_exception(ss.str());
+    }
 
-    qSeqSequence->getSubString(dnaBuffer, cur->qStart, cur->size);
+    qSeqSequence->getSubString(qDnaBuffer, cur->qStart, cur->size);
+    tSeqSequence->getSubString(tDnaBuffer, cur->tStart, cur->size);
     if (cur->strand == '-')
     {
-      reverseComplement(dnaBuffer);
+      reverseComplement(qDnaBuffer);
     }
-    cur->sequence = (char*)malloc(dnaBuffer.length() * sizeof(char) + 1);
-    strcpy(cur->sequence, dnaBuffer.c_str());
+    cur->qSequence = (char*)malloc(qDnaBuffer.length() * sizeof(char) + 1);
+    cur->tSequence = (char*)malloc(tDnaBuffer.length() * sizeof(char) + 1);
+    strcpy(cur->qSequence, qDnaBuffer.c_str());
+    strcpy(cur->tSequence, tDnaBuffer.c_str());
   }
 }
 

chain/inc/halBlockViz.h

@@ -57,7 +57,8 @@ struct hal_block_t
    hal_int_t qStart;
    hal_int_t size;
    char strand;
-   char *sequence;
+   char *qSequence; // query DNA, if requested
+   char *tSequence; // target DNA, if requested
 };
 
 /** Some information about a genome */

chain/test/blockVizTest.c

@@ -70,8 +70,8 @@ static int parseArgs(int argc, char** argv, bv_args_t* args)
 
 static void printBlock(FILE* file, struct hal_block_t* b)
 {
-  fprintf(file, "chr:%s, tSt:%ld, qSt:%ld, size:%ld, strand:%c: %s\n", 
-          b->qChrom, b->tStart, b->qStart, b->size, b->strand, b->sequence);
+  fprintf(file, "chr:%s, tSt:%ld, qSt:%ld, size:%ld, strand:%c: tgt : %s query: %s\n", 
+          b->qChrom, b->tStart, b->qStart, b->size, b->strand, b->tSequence, b->qSequence);
 }
 
 static void printDupeList(FILE* file, struct hal_target_dupe_list_t* d)

include.mk

@@ -26,6 +26,11 @@ HDF5_CCLINKER = ${cxx}
 cpp = h5c++ ${h5prefix}
 cxx = h5cc ${h5prefix}
 
+ifeq (${SYS},Darwin) #This is to deal with the Mavericks replacing gcc with clang fully and changing libraries
+  cppflags += -stdlib=libstdc++
+  cflags += -stdlib=libstdc++
+endif
+
 # add compiler flag and kent paths if udc is enabled
 # relies on KENTSRC containing path to top level kent/ dir
 # and MACHTYPE being specified

liftover/impl/halBedLine.cpp

@@ -30,6 +30,7 @@ istream& BedLine::read(istream& is, int version, string& lineBuffer)
   _version = version;
   std::getline(is, lineBuffer);
   stringstream ss(lineBuffer);
+  ss.imbue(is.getloc());
   ss >> _chrName;
   if (ss.bad() || ss.fail()) 
   {

liftover/impl/halBedScanner.cpp

@@ -25,10 +25,15 @@ BedScanner::~BedScanner()
 
 }
 
-void BedScanner::scan(const string& bedPath, int bedVersion)
+void BedScanner::scan(const string& bedPath, int bedVersion,
+                      const locale* inLocale)
 {
   assert(_bedStream == NULL);
   _bedStream = new ifstream(bedPath.c_str());
+  if (inLocale != NULL)
+  {
+    _bedStream->imbue(*inLocale);
+  }
 
   try {
     scan(_bedStream, bedVersion);
@@ -46,11 +51,15 @@ void BedScanner::scan(const string& bedPath, int bedVersion)
   _bedStream = NULL;
 }
 
-void BedScanner::scan(istream* is, int bedVersion)
+void BedScanner::scan(istream* is, int bedVersion, const locale* inLocale)
 {
   visitBegin();
   _bedStream = is;
   _bedVersion = bedVersion;
+  if (inLocale != NULL)
+  {
+    _bedStream->imbue(*inLocale);
+  }
 
   if (_bedVersion == -1)
   {
@@ -65,13 +74,13 @@ void BedScanner::scan(istream* is, int bedVersion)
   _lineNumber = 0;
   try
   {
-    skipWhiteSpaces(_bedStream);
+    skipWhiteSpaces(_bedStream, inLocale);
     while (_bedStream->good())
     {
       ++_lineNumber;
       _bedLine.read(*_bedStream, _bedVersion, lineBuffer);
       visitLine();
-      skipWhiteSpaces(_bedStream);
+      skipWhiteSpaces(_bedStream, inLocale);
     }
   }
   catch(hal_exception e)
@@ -84,13 +93,18 @@ void BedScanner::scan(istream* is, int bedVersion)
   _bedStream = NULL;
 }
 
-int BedScanner::getBedVersion(istream* bedStream)
+int BedScanner::getBedVersion(istream* bedStream, const locale* inLocale)
 {
   assert(bedStream != &cin);
   if (bedStream->bad())
   {
     throw hal_exception("Error reading bed input stream");
   }
+  if (inLocale != NULL)
+  {
+    bedStream->imbue(*inLocale);
+  }
+
   string lineBuffer;
   BedLine bedLine;
   int version = 12;
@@ -101,7 +115,7 @@ int BedScanner::getBedVersion(istream* bedStream)
     {
       bedStream->clear();
       bedStream->seekg(pos);
-      skipWhiteSpaces(bedStream);
+      skipWhiteSpaces(bedStream, inLocale);
       *bedStream >> std::skipws;
       bedLine.read(*bedStream, version, lineBuffer);
       break;
@@ -120,9 +134,14 @@ int BedScanner::getBedVersion(istream* bedStream)
   return version;
 }
 
-size_t BedScanner::getNumColumns(const string& bedLine)
+size_t BedScanner::getNumColumns(const string& bedLine,
+                                 const locale* inLocale)
 {
   stringstream ss(bedLine);
+  if (inLocale != NULL)
+  {
+    ss.imbue(*inLocale);
+  }
   size_t c = 0;
   string buffer;
   while (ss.good())
@@ -148,9 +167,12 @@ void BedScanner::visitEOF()
 {
 }
 
-void BedScanner::skipWhiteSpaces(istream* bedStream)
+void BedScanner::skipWhiteSpaces(istream* bedStream,
+                                 const locale* inLocale)
 {
-  while (bedStream->good() && std::isspace(bedStream->peek()))
+  locale defaultLocale;
+  const locale& myLocale = inLocale == NULL ? defaultLocale : *inLocale;
+  while (bedStream->good() && std::isspace((char)bedStream->peek(), myLocale))
   {
     bedStream->get();
   }

liftover/impl/halLiftover.cpp

@@ -33,7 +33,8 @@ void Liftover::convert(AlignmentConstPtr alignment,
                        int outBedVersion,
                        bool addExtraColumns,
                        bool traverseDupes,
-                       bool outPSL)
+                       bool outPSL,
+                       const locale* inLocale)
 {
   _srcGenome = srcGenome;
   _tgtGenome = tgtGenome;
@@ -43,6 +44,7 @@ void Liftover::convert(AlignmentConstPtr alignment,
   _outBedVersion = outBedVersion;
   _traverseDupes = traverseDupes;
   _outPSL = outPSL;
+  _inLocale = inLocale;
   _missedSet.clear();
   _tgtSet.clear();
   assert(_srcGenome && inBedStream && tgtGenome && outBedStream);
@@ -56,12 +58,12 @@ void Liftover::convert(AlignmentConstPtr alignment,
   stringstream* firstLineStream = NULL;
   if (_inBedVersion <= 0)
   {
-    skipWhiteSpaces(inBedStream);
+    skipWhiteSpaces(inBedStream, _inLocale);
     std::getline(*inBedStream, firstLineBuffer);
     firstLineStream = new stringstream(firstLineBuffer);
-    _inBedVersion = BedScanner::getBedVersion(firstLineStream);
+    _inBedVersion = BedScanner::getBedVersion(firstLineStream, inLocale);
     assert(inBedStream->eof() || _inBedVersion >= 3);
-    size_t numCols = BedScanner::getNumColumns(firstLineBuffer);
+    size_t numCols = BedScanner::getNumColumns(firstLineBuffer, inLocale);
     if ((int)numCols > _inBedVersion)
     {
       cerr << "Warning: auto-detecting input BED version " << _inBedVersion
@@ -75,10 +77,10 @@ void Liftover::convert(AlignmentConstPtr alignment,
 
   if (firstLineStream != NULL)
   {
-    scan(firstLineStream, _inBedVersion);
+    scan(firstLineStream, _inBedVersion, inLocale);
     delete firstLineStream;
   }
-  scan(inBedStream, _inBedVersion);
+  scan(inBedStream, _inBedVersion, inLocale);
 }
 
 void Liftover::visitBegin()

liftover/impl/halLiftoverMain.cpp

@@ -9,6 +9,7 @@
 #include <fstream>
 #include "halColumnLiftover.h"
 #include "halBlockLiftover.h"
+#include "halTabFacet.h"
 
 using namespace std;
 using namespace hal;
@@ -43,7 +44,10 @@ static CLParserPtr initParser()
                                "columns in the input beyond the specified or "
                                "detected bed version, and which are cut by "
                                "default.", false);
-
+  optionsParser->addOptionFlag("tab", "input is tab-separated. this allows"
+                               " column entries to contain spaces.  if this"
+                               " flag is not set, both spaces and tabs are"
+                               " used to separate input columns.", false);
   optionsParser->setDescription("Map BED genome interval coordinates between "
                                 "two genomes.");
   return optionsParser;
@@ -64,6 +68,7 @@ int main(int argc, char** argv)
   int outBedVersion;
   bool keepExtra;
   bool outPSL;
+  bool tab;
   try
   {
     optionsParser->parseOptions(argc, argv);
@@ -78,6 +83,7 @@ int main(int argc, char** argv)
     outBedVersion = optionsParser->getOption<int>("outBedVersion");
     keepExtra = optionsParser->getFlag("keepExtra");
     outPSL = optionsParser->getFlag("outPSL");
+    tab = optionsParser->getFlag("tab");
   }
   catch(exception& e)
   {
@@ -145,11 +151,21 @@ int main(int argc, char** argv)
         throw hal_exception("Error opening tgtBed, " + tgtBedPath);
       }
     }
+
+    locale* inLocale = NULL;
+    if (tab == true)
+    {
+      inLocale = new locale(cin.getloc(), new TabSepFacet(cin.getloc()));
+      assert(std::isspace('\t', *inLocale) == true);
+      assert(std::isspace(' ', *inLocale) == false);
+    }
 
     BlockLiftover liftover;
     liftover.convert(alignment, srcGenome, srcBedPtr, tgtGenome, tgtBedPtr,
                      inBedVersion, outBedVersion, keepExtra, !noDupes,
-                     outPSL);
+                     outPSL, inLocale);
+
+    delete inLocale;
 
   }
   catch(hal_exception& e)