X-Git-Url: http://woldlab.caltech.edu/gitweb/?a=blobdiff_plain;f=alg%2Fglseqbrowser.cpp;h=04cc792ec441e3eeb375fb2ac47bf842d509b3c0;hb=a4ad0c27cefe62ecb4610706fae5aa34479cc9a7;hp=470c7c437cf1cdac1adc6c4900857e36f63dfac1;hpb=f83153e9925aee1b167fae0235865d97ba6b7f04;p=mussa.git

diff --git a/alg/glseqbrowser.cpp b/alg/glseqbrowser.cpp
index 470c7c4..04cc792 100644
--- a/alg/glseqbrowser.cpp
+++ b/alg/glseqbrowser.cpp
@@ -1,6 +1,7 @@
 #include "alg/glseqbrowser.hpp"
 #include "mussa_exceptions.hpp"
 
+#include <math.h>
 #include <iostream>
 #include <sstream>
 #include <stdexcept>
@@ -25,7 +26,8 @@ GlSeqBrowser::GlSeqBrowser(const GlSeqBrowser& gt)
     viewport_center(gt.viewport_center),
     zoom_level(gt.zoom_level),
     color_mapper(gt.color_mapper),
-    track_container(gt.track_container)
+    track_container(gt.track_container),
+    path_segments(gt.path_segments)
 {
 }
 
@@ -117,13 +119,15 @@ void GlSeqBrowser::processSelection(GLuint hits, GLuint buffer[], GLuint bufsize
         {
           objid = *ptr++; ++consumed_names;
 
-          int left = track_container[objid].leftbase(r.left);
-          int right = track_container[objid].rightbase(r.right);
+          int left = track_container[objid]->leftbase(r.left);
+          int right = track_container[objid]->rightbase(r.right);
           // the static_cast should be ok, since basepairs line up on 
           // integral values
           //TrackRegion track(objid, left, right); 
           track.set(objid, left, right);
           selected_tracks.push_back(track);
+          //clog << "selected track " << objid
+          //     << "(" << left << ", " << right << ")" << endl;
         }
         break;
         default:
@@ -193,12 +197,12 @@ float GlSeqBrowser::left() const
   {
     return cur_ortho.left;
   } else {
-    vector<GlSequence>::const_iterator track_i = track_container.begin();    
-    left = track_i->x();
+    vector<boost::shared_ptr<GlSequence> >::const_iterator track_i = track_container.begin();    
+    left = (*track_i)->x();
     for( ; track_i != track_container.end(); ++track_i)
     {
-      if (track_i->x() < left) {
-        left = track_i->x();
+      if ((*track_i)->x() < left) {
+        left = (*track_i)->x();
       }
     }
     return left-border_width;
@@ -211,16 +215,25 @@ float GlSeqBrowser::right() const
   if (track_container.size() == 0) {
     return cur_ortho.right;
   } else {
-    vector<GlSequence>::const_iterator track_i = track_container.begin();
-    right = track_i->right();
+    vector<boost::shared_ptr<GlSequence> >::const_iterator track_i = track_container.begin();
+    right = (*track_i)->right();
     for( ; track_i != track_container.end(); ++track_i) {
-      if (track_i->right() > right)
-        right = track_i->right();
+      if ((*track_i)->right() > right)
+        right = (*track_i)->right();
     }
     return right+border_width;
   }
 }
 
+float GlSeqBrowser::get_pixel_width() const
+{
+  GLint viewport[4];
+  glGetIntegerv(GL_VIEWPORT, viewport);
+  GLint vp_width = viewport[3]; // grab the viewport width
+  
+  return round((cur_ortho.right-cur_ortho.left)/vp_width);
+}  
+
 void GlSeqBrowser::setViewportCenter(float x)
 {
   update_viewport(x, zoom_level);
@@ -252,6 +265,16 @@ float GlSeqBrowser::viewportWidth() const
   return cur_ortho.right - cur_ortho.left;
 }
 
+int GlSeqBrowser::viewportPixelHeight() const
+{
+  return viewport_size.y;
+}
+
+int GlSeqBrowser::viewportPixelWidth() const
+{
+  return viewport_size.x;
+}
+
 double GlSeqBrowser::zoomOut()
 {
 
@@ -321,11 +344,17 @@ void GlSeqBrowser::push_sequence(const Sequence& s)
 
 void GlSeqBrowser::push_sequence(boost::shared_ptr<Sequence> s)
 {
-  GlSequence gs(s, color_mapper);
+  boost::shared_ptr<GlSequence> gs(new GlSequence(s, color_mapper));
   push_sequence(gs);
 }
 
 void GlSeqBrowser::push_sequence(GlSequence gs)
+{
+  boost::shared_ptr<GlSequence> new_gs(new GlSequence(gs));
+  push_sequence(new_gs);
+}
+
+void GlSeqBrowser::push_sequence(boost::shared_ptr<GlSequence> gs)
 {
   clear_links();
   track_container.push_back(gs);
@@ -334,7 +363,7 @@ void GlSeqBrowser::push_sequence(GlSequence gs)
     path_segments.push_back(pair_segment_map());
 }
 
-const std::vector<GlSequence>& GlSeqBrowser::sequences() const
+const std::vector<boost::shared_ptr<GlSequence> >& GlSeqBrowser::sequences() const
 {
   return track_container;
 }
@@ -350,7 +379,7 @@ void GlSeqBrowser::clear_links()
 }
 
 void 
-GlSeqBrowser::link(const vector<int>& path, const vector<bool>& rc, int )
+GlSeqBrowser::link(const vector<int>& path, const vector<bool>& rc, int length)
 {
   if (path.size() < 2) {
     // should i throw an error instead?
@@ -376,18 +405,23 @@ GlSeqBrowser::link(const vector<int>& path, const vector<bool>& rc, int )
     pair_segment_map::iterator found_segment = path_segments[track_i].find(p);
     if (found_segment == path_segments[track_i].end()) {
       // not already found
-      float y1 = track_container[track_i].y();
-            y1 -= track_container[track_i].height()/2;
-      float y2 = track_container[track_i+1].y();
-            y2 += track_container[track_i+1].height()/2;
+      float y1 = track_container[track_i]->y();
+            y1 -= track_container[track_i]->height()/2;
+      float y2 = track_container[track_i+1]->y();
+            y2 += track_container[track_i+1]->height()/2;
       
       bool rcFlag = (prev_rc or *rc_i) and !(prev_rc and *rc_i);
-      Segment s(prev_x, y1, *path_i, y2, rcFlag);
+      Segment s(prev_x, y1, *path_i, y2, rcFlag, length);
       s.path_ids.insert(pathid);
       path_segments[track_i][p] = s;
     } else {
       //found
       found_segment->second.path_ids.insert(pathid);
+      // make each segment the size of the largest of any link between these 
+      // two bases
+      if (found_segment->second.length < length) {
+        found_segment->second.length = length;
+      }
     }
     prev_x = *path_i;
     prev_rc = *rc_i;
@@ -427,9 +461,12 @@ list<TrackRegion> GlSeqBrowser::selectedTracks() const
 
 //! copy sequence from selected track using formating function
 template<class Item>
-void GlSeqBrowser::copySelectedTracks(std::list<Item>& result, 
-             Item (*formatter)(const Sequence& s, int left, int right))
+size_t GlSeqBrowser::copySelectedTracks(std::list<Item>& result, 
+             Item (*formatter)(boost::shared_ptr<Sequence> s, 
+                               int left, 
+                               int right))
 {
+  size_t base_pairs_copied = 0;
   result.clear();
 
   for(selected_track_iterator track_i = selected_tracks.begin();
@@ -443,28 +480,32 @@ void GlSeqBrowser::copySelectedTracks(std::list<Item>& result,
            << endl;
     } else {
       // we should be safe
-      const Sequence& seq = track_container[track_index].sequence();
+      boost::shared_ptr<Sequence> seq = track_container[track_index]->sequence();
       result.push_back(formatter(seq, track_i->left, track_i->right));
+      base_pairs_copied += max(track_i->right-track_i->left, 0);
     }
   }
+  return base_pairs_copied;
 }
 
 //! copy sequence from selected tracks as FASTA sequences
-void GlSeqBrowser::copySelectedTracksAsFasta(std::string& copy_buffer)
+size_t GlSeqBrowser::copySelectedTracksAsFasta(std::string& copy_buffer)
 {
   std::list<std::string> result;
   struct AsFasta {
-    static string formatter(const Sequence& seq, int left, int right)
+    static string formatter(boost::shared_ptr<Sequence> seq, 
+                            int left, 
+                            int right)
     {
       stringstream s;
-      s << ">" << seq.get_fasta_header() 
+      s << ">" << seq->get_fasta_header() 
         << "|" << "subregion=" << left << "-" << right+1
         << std::endl
-        << seq.subseq(left, right-left+1) << std::endl;
+        << seq->subseq(left, right-left+1) << std::endl;
       return s.str();
     }
   };
-  copySelectedTracks(result, AsFasta::formatter);
+  size_t base_pairs_copied = copySelectedTracks(result, AsFasta::formatter);
   // I wish there was some way to use for_each and bind here
   for (list<string>::iterator result_i = result.begin();
        result_i != result.end();
@@ -472,46 +513,53 @@ void GlSeqBrowser::copySelectedTracksAsFasta(std::string& copy_buffer)
   {
     copy_buffer.append(*result_i);
   }
+  return base_pairs_copied;
 }
 
 //! copy sequence from selected tracks as new sequences
-void GlSeqBrowser::copySelectedTracksAsSequences(std::list<Sequence>& result)
+size_t GlSeqBrowser::copySelectedTracksAsSequences(std::list<Sequence>& result)
 {
   struct AsSequence {
-    static Sequence formatter(const Sequence& seq, int left, int right)
+    static Sequence formatter(boost::shared_ptr<Sequence> seq, 
+                              int left, 
+                              int right)
     {
-      return seq.subseq(left, right-left+1);
+      return seq->subseq(left, right-left+1);
     }
   };
-  copySelectedTracks(result, AsSequence::formatter);
+  return copySelectedTracks(result, AsSequence::formatter);
 }
 
-void GlSeqBrowser::copySelectedTracksAsSeqLocation(
+size_t GlSeqBrowser::copySelectedTracksAsSeqLocation(
     std::list<SequenceLocation>& result)
 {
   struct AsSeqLocation {
-    static SequenceLocation formatter(const Sequence& seq, int left, int right)
+    static SequenceLocation formatter(boost::shared_ptr<Sequence> seq, 
+                                      int left, 
+                                      int right)
     {
       return SequenceLocation(seq, left, right);
     }
   };
-  copySelectedTracks(result, AsSeqLocation::formatter);
+  return copySelectedTracks(result, AsSeqLocation::formatter);
 }
 
 //! copy sequence from selected tracks as plain sequences
-void GlSeqBrowser::copySelectedTracksAsString(std::string& copy_buffer)
+size_t GlSeqBrowser::copySelectedTracksAsString(std::string& copy_buffer)
 {
   std::list<string> result;
   struct AsString {
-    static string formatter(const Sequence& seq, int left, int right)
+    static string formatter(boost::shared_ptr<Sequence> seq, 
+                            int left, 
+                            int right)
     {
       stringstream s;
-      s << seq.subseq(left, right-left+1) << std::endl;
+      s << seq->subseq(left, right-left+1);
       return s.str();
     }
   };
 
-  copySelectedTracks(result, AsString::formatter);
+  size_t base_pairs_copied = copySelectedTracks(result, AsString::formatter);
   // I wish there was some way to use for_each and bind here
   for (list<string>::iterator result_i = result.begin();
        result_i != result.end();
@@ -519,7 +567,7 @@ void GlSeqBrowser::copySelectedTracksAsString(std::string& copy_buffer)
   {
     copy_buffer.append(*result_i);
   }
-
+  return base_pairs_copied;
 }
 
 void GlSeqBrowser::centerOnPath(const vector<int>& paths)
@@ -531,7 +579,7 @@ void GlSeqBrowser::centerOnPath(const vector<int>& paths)
   for(size_t track_i = 0; track_i != track_container.size(); ++track_i)
   {
     // -15 = shift more to the left
-    track_container[track_i].setX((viewport_center-15) - paths[track_i]);
+    track_container[track_i]->setX((viewport_center-15) - paths[track_i]);
   }
 }
 
@@ -548,7 +596,7 @@ void GlSeqBrowser::update_viewport(float center, double new_zoom)
 
 void GlSeqBrowser::update_layout()
 {
-  typedef std::vector<GlSequence>::iterator glseq_itor_type;
+  typedef std::vector<boost::shared_ptr<GlSequence> >::iterator glseq_itor_type;
   float available_height = (float)cur_ortho.top - 2 * (float)border_width;
   float max_base_pairs = 0;
   size_t track_count = track_container.size();
@@ -561,17 +609,17 @@ void GlSeqBrowser::update_layout()
         seq_i != track_container.end();
         ++seq_i, y-=track_spacing)
     {
-      seq_i->setX(0);
-      seq_i->setY(y);
-      if (seq_i->size() > max_base_pairs)
-        max_base_pairs = seq_i->size();
+      (*seq_i)->setX(0);
+      (*seq_i)->setY(y);
+      if ((*seq_i)->size() > max_base_pairs)
+        max_base_pairs = (*seq_i)->size();
     }
   } else if (track_count == 1) {
     // center the single track
     glseq_itor_type seq_i = track_container.begin();
-    seq_i->setX(0);
-    seq_i->setY(viewport_size.x /2);
-    max_base_pairs = seq_i->size();
+    (*seq_i)->setX(0);
+    (*seq_i)->setY(viewport_size.x /2);
+    max_base_pairs = (*seq_i)->size();
   } else {
     // nothing to do as we're empty
     return;
@@ -616,7 +664,7 @@ void GlSeqBrowser::draw_tracks() const
   for(size_t track_i = 0; track_i != track_container.size(); ++track_i)
   {
     glPushName(track_i);
-    track_container[track_i].draw(cur_ortho.left, cur_ortho.right);
+    track_container[track_i]->draw(cur_ortho.left, cur_ortho.right);
     glPopName();
   }
 }
@@ -626,6 +674,9 @@ void GlSeqBrowser::draw_segments() const
   glLineWidth(1);
   glEnable(GL_BLEND);
   glDepthMask(GL_FALSE);
+  const float zdepth = -1.0;
+  const float min_segment_width = max((float)(1.0), get_pixel_width());
+  
   // each vector contains path_segment_maps of all the connections
   // between this track and the next
   path_segment_map_vector::const_iterator psmv_i;
@@ -653,33 +704,50 @@ void GlSeqBrowser::draw_segments() const
                        back_inserter(selected));
 
       if (not s.reversed) {
+        // forward
         if (selected_paths.size() == 0 or selected.size() > 0) {
           glColor4f(1.0, 0.0, 0.0, 1.0);
         } else {
           glColor4f(1.0, 0.7, 0.7, 0.4);
         }
       } else { 
+        // reverse
         if (selected_paths.size() == 0 or selected.size() > 0) {
           glColor4f(0.0, 0.0, 1.0, 1.0);
         } else {
           glColor4f(0.7, 0.7, 1.0, 0.4);
         }
-        /*
-        if (selected_paths.size() == 0 or selected.size() > 0) {
-          glColor3f(0.0, 0.0, 1.0);
-        } else {
-          glColor3f(0.8, 0.8, 1.0);
-        }
-        */
       }
       // save the multipart name for our segment
       glPushName(path_index); glPushName(key.first); glPushName(key.second);
-      glBegin(GL_LINES);
-      float seq_start_x = track_container[path_index].x();
-      float seq_end_x = track_container[path_index+1].x();
-      glVertex3f(s.start.x + seq_start_x, s.start.y, -1);
-      glVertex3f(s.end.x   + seq_end_x  , s.end.y, -1);
-      glEnd();
+      float seq_start_x = s.start.x 
+                        + track_container[path_index]->x();
+      float seq_end_x = s.end.x
+                      + track_container[path_index+1]->x();
+      if (s.length <= min_segment_width) {
+        // use lines for elements of length <=1 or < 1 pixel.
+        // and try to center the line
+        const float offset = s.length * 0.5;
+        glBegin(GL_LINES);
+          glVertex3f(seq_start_x+offset, s.start.y, -1);
+          glVertex3f(seq_end_x  +offset, s.end.y, -1);
+        glEnd();
+      } else {
+        // otherwise use quads
+        // compute length
+        float seq_start_x_length = s.start.x 
+                                 + s.length
+                                 + track_container[path_index]->x();
+        float seq_end_x_length = s.end.x
+                               + s.length
+                               + track_container[path_index+1]->x();
+        glBegin(GL_QUADS);
+          glVertex3f(seq_start_x, s.start.y, zdepth);
+          glVertex3f(seq_end_x, s.end.y, zdepth);
+          glVertex3f(seq_end_x_length, s.end.y, zdepth);
+          glVertex3f(seq_start_x_length, s.start.y, zdepth);
+        glEnd();
+      }      
       // clear the names
       glPopName(); glPopName(); glPopName();
     }