qui/MussaAlignedWindow.cpp

   1 #include <list>
   2 #include <vector>
   3 #include <sstream>
   4
   5 #include <QStatusBar>
   6 #include <QString>
   7 #include <QMenuBar>
   8
   9 #include "qui/MussaAlignedWindow.hpp"
  10 #include "alg/sequence.hpp"
  11
  12 using namespace std;
  13
  14 MussaAlignedWindow::MussaAlignedWindow(Mussa& m,
  15                                        const set<int>& sel_paths,
  16                                        QWidget *parent)
  17   : QMainWindow(parent),
  18     analysis(m),
  19     pick_align_menu(tr("Choose Alignment")),
  20     view_align_menu(tr("View Alignment"))
  21 {
  22   browser.setSequences(analysis.sequences(), analysis.colorMapper());
  23   setSelectedPaths(m, sel_paths);
  24   setAlignment(0);
  25   browser.zoomToSequence();
  26   computeMatchLines();
  27   setupMenus();
  28
  29   setCentralWidget(&browser);
  30   menuBar()->addMenu(&pick_align_menu);
  31   menuBar()->addMenu(&view_align_menu);
  32
  33   ostringstream message;
  34   message << "Selected " << selected_paths.size() << " paths";
  35   statusBar()->showMessage(message.str().c_str(), 5000);
  36   browser.updatePosition();
  37 }
  38
  39
  40 void MussaAlignedWindow::setSelectedPaths(Mussa &m, const set<int>& sel_paths)
  41 {
  42   // sets are sorted
  43   set<int>::iterator sel_i = sel_paths.begin();
  44   list<ExtendedConservedPath>::const_iterator path_i = m.paths().rpbegin();
  45   list<ExtendedConservedPath>::const_iterator path_end = m.paths().rpend();
  46   size_t path_size = m.paths().refined_pathz.size();
  47   size_t pathid=0;
  48
  49   selected_paths.reserve(sel_paths.size());
  50   view_paths.reserve(sel_paths.size());
  51   while (pathid != path_size and sel_i != sel_paths.end())
  52   {
  53     assert (*sel_i >= 0);
  54     size_t sel_pathid = (size_t)(*sel_i);
  55     if (pathid == sel_pathid) {
  56       selected_paths.push_back(*path_i);
  57       view_paths.push_back(true);
  58       ++pathid;
  59       ++path_i;
  60       ++sel_i;
  61     } else if (pathid < sel_pathid) {
  62       ++pathid;
  63       ++path_i;
  64     } else if (pathid > sel_pathid) {
  65       ++sel_i;
  66     }
  67   }
  68 }
  69
  70 void MussaAlignedWindow::setupMenus()
  71 {
  72   pick_align_menu.clear();
  73   view_align_menu.clear();
  74   pick_actions.clear();
  75   view_actions.clear();
  76
  77   for(vector<ExtendedConservedPath >::iterator pathz_i=selected_paths.begin();
  78       pathz_i != selected_paths.end();
  79       ++pathz_i)
  80   {
  81     ConservedPath::path_type normalized_path = pathz_i->normalizedIndexes();
  82     ostringstream menu_text;
  83     menu_text << pathz_i->window_size << ":";
  84     ConservedPath::iterator element_i = normalized_path.begin();
  85     menu_text << *element_i++;
  86     for (;
  87          element_i != normalized_path.end();
  88          ++element_i)
  89     {
  90       menu_text << ", ";
  91       menu_text << *element_i;
  92     }
  93     int index = pathz_i - selected_paths.begin();
  94     IntAction *pick = new IntAction(QString(menu_text.str().c_str()), index, this);
  95     connect(pick, SIGNAL(triggered(int)), this, SLOT(setAlignment(size_t)));
  96     pick_actions.push_back(pick);
  97     pick_align_menu.addAction(pick);
  98     IntAction *view = new IntAction(QString(menu_text.str().c_str()), index, this);
  99     connect(view, SIGNAL(triggered(int)), this, SLOT(toggleViewAlignment(size_t)));
 100     view->setCheckable(true);
 101     view->setChecked(true);
 102     view_actions.push_back(view);
 103     view_align_menu.addAction(view);
 104   }
 105 }
 106
 107 void MussaAlignedWindow::setAlignment(size_t alignment_index)
 108 {
 109   if (selected_paths.size() > 0) {
 110     browser.centerOnPath(selected_paths[alignment_index].normalizedIndexes());
 111   }
 112 }
 113
 114 void MussaAlignedWindow::toggleViewAlignment(size_t alignment_index)
 115 {
 116   view_paths[alignment_index]= not view_paths[alignment_index];
 117   // perhaps it'd be better if we could erase specific sets
 118   // of matches instead of erasing them all and recomputing them all
 119   // but this is easier
 120   computeMatchLines();
 121 }
 122
 123 void MussaAlignedWindow::update()
 124 {
 125   browser.update();
 126 }
 127
 128 void MussaAlignedWindow::computeMatchLines()
 129 {
 130   const vector<Sequence>& raw_sequence = analysis.sequences();
 131   vector<int> aligned_path;
 132   size_t i2, i3;
 133   int x_start, x_end;
 134   int window_length, win_i;
 135   int rc_1 = 0;
 136   int rc_2 = 0;
 137   vector<bool> rc_list;
 138   bool full_match;
 139   vector<bool> matched;
 140   int align_counter;
 141
 142   browser.clear_links();
 143   align_counter = 0;
 144   for(vector<ExtendedConservedPath >::iterator pathz_i=selected_paths.begin();
 145       pathz_i != selected_paths.end();
 146       ++pathz_i)
 147   {
 148     if (view_paths[align_counter])
 149     {
 150       ExtendedConservedPath& a_path = *pathz_i;
 151       window_length = a_path.window_size;
 152       // determine which parts of the path are RC relative to first species
 153       rc_list = a_path.reverseComplimented();
 154
 155       // loop over each bp in the conserved region for all sequences
 156       for(win_i = 0; win_i < window_length; win_i++)
 157       {
 158         aligned_path.clear();
 159         // determine which exact base pairs match between the sequences
 160         full_match = true;
 161         for(i2 = 0; i2 < a_path.size()-1; i2++)
 162         {
 163           // assume not rc as most likely, adjust below
 164           rc_1 = 0;
 165           rc_2 = 0;
 166           // no matter the case, any RC node needs adjustments
 167           if (a_path[i2] < 0)
 168             rc_1 = window_length-1;
 169           if (a_path[i2+1] < 0)
 170             rc_2 = window_length-1;
 171
 172           x_start = (abs(a_path[i2]-rc_1+win_i));
 173           x_end =   (abs(a_path[i2+1]-rc_2+win_i));
 174
 175           // RC case handling
 176           // ugh, and xor...only want rc coloring if just one of the nodes is rc
 177           // if both nodes are rc, then they are 'normal' relative to each other
 178           if ( ( rc_list[i2] || rc_list[i2+1] ) &&
 179               !(rc_list[i2] && rc_list[i2+1] ) )
 180           { //the hideous rc matching logic - not complex, but annoying
 181             if ( !( ( (raw_sequence[i2][x_start] == 'A') &&
 182                     (raw_sequence[i2+1][x_end] == 'T') ) ||
 183                   ( (raw_sequence[i2][x_start] == 'T') &&
 184                     (raw_sequence[i2+1][x_end] == 'A') ) ||
 185                   ( (raw_sequence[i2][x_start] == 'G') &&
 186                     (raw_sequence[i2+1][x_end] == 'C') ) ||
 187                   ( (raw_sequence[i2][x_start] == 'C') &&
 188                     (raw_sequence[i2+1][x_end] == 'G') ) ) )
 189               full_match = false;
 190           }
 191           else
 192           {
 193             if (!( (raw_sequence[i2][x_start] == raw_sequence[i2+1][x_end]) &&
 194                   (raw_sequence[i2][x_start] != 'N') &&
 195                   (raw_sequence[i2+1][x_end] != 'N') ) )
 196               full_match = false;
 197           }
 198         }
 199
 200         // draw for matches stretching across all sequences
 201         if (full_match)
 202         {
 203           // now can draw the line for each bp in this window that matches
 204           // grrr, need to ask if anyone cares if I switch the seq
 205           // top-bot order...
 206           i3 = 0;
 207           //y_loc = y_min + 5;
 208           for(i2 = 0; i2 < a_path.size()-1; i2++)
 209           {
 210             // assume not rc as most likely, adjust below
 211             rc_1 = 0;
 212             rc_2 = 0;
 213             // no matter the case, any RC node needs adjustments
 214             if (a_path[i2] < 0)
 215             {
 216               rc_1 = window_length;
 217             }
 218             if (a_path[i2] < 0)
 219             {
 220               rc_2 = window_length;
 221             }
 222
 223             // maybe shouldn't recalc these, but store values from first loop
 224             x_start = (abs((int) (a_path[i2]-rc_1+win_i)));
 225             x_end =   (abs((int) (a_path[i2+1]-rc_2+win_i)));
 226             aligned_path.push_back(x_start);
 227             // if we're on the last time through the loop, save x_end too
 228             if (i2 == a_path.size()-2) {
 229               aligned_path.push_back(x_end);
 230             }
 231           }
 232         }
 233         if (aligned_path.size() > 0) {
 234           browser.link(aligned_path, rc_list,1);
 235         }
 236       }
 237     }
 238     align_counter++;
 239   }
 240 }
 241