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 #include <iostream>
  13 using namespace std;
  14
  15 MussaAlignedWindow::MussaAlignedWindow(Mussa& m,
  16                                        const set<int>& sel_paths,
  17                                        QWidget *parent)
  18   : QMainWindow(parent),
  19     analysis(m),
  20     pick_align_menu(tr("Choose Alignment")),
  21     view_align_menu(tr("View Alignment"))
  22 {
  23   browser.setSequences(analysis.sequences(), analysis.colorMapper());
  24   setSelectedPaths(m, sel_paths);
  25   setAlignment(0);
  26   double zoom_level = browser.zoomToSequence();
  27   zoom.setValue(zoom_level);
  28   computeMatchLines();
  29   setupMenus();
  30
  31   setCentralWidget(&browser);
  32
  33   addToolBar(&alignTB);
  34   alignTB.addWidget(&zoom);
  35
  36   connect(&zoom, SIGNAL(valueChanged(double)),
  37           &browser, SLOT(setZoom(double)));
  38
  39
  40   //Save pixel map action
  41   saveBrowserPixmapAction = new QAction(tr("Save to image..."), this);
  42   connect(saveBrowserPixmapAction, (SIGNAL(triggered())),
  43           &browser, SLOT(promptSaveBrowserPixmap()));
  44   saveBrowserPixmapAction->setIcon(QIcon(":/icons/image2.png"));
  45   QMenu *newMenu = menuBar()->addMenu(tr("&File"));
  46   newMenu->addAction(saveBrowserPixmapAction);
  47   menuBar()->addMenu(&pick_align_menu);
  48   menuBar()->addMenu(&view_align_menu);
  49
  50   ostringstream message;
  51   message << "Selected " << selected_paths.size() << " paths";
  52   statusBar()->showMessage(message.str().c_str(), 5000);
  53   browser.updatePosition();
  54 }
  55
  56
  57 void MussaAlignedWindow::setSelectedPaths(Mussa &m, const set<int>& sel_paths)
  58 {
  59   // sets are sorted
  60   set<int>::iterator sel_i = sel_paths.begin();
  61   list<ConservedPath>::const_iterator path_i = m.paths().refined_pathz.begin();
  62   list<ConservedPath>::const_iterator path_end = m.paths().refined_pathz.end();
  63   size_t path_size = m.paths().refined_pathz.size();
  64   size_t pathid=0;
  65
  66   selected_paths.reserve(sel_paths.size());
  67   view_paths.reserve(sel_paths.size());
  68   while (pathid != path_size and sel_i != sel_paths.end())
  69   {
  70     assert (*sel_i >= 0);
  71     size_t sel_pathid = (size_t)(*sel_i);
  72     if (pathid == sel_pathid) {
  73       selected_paths.push_back(*path_i);
  74       view_paths.push_back(true);
  75       ++pathid;
  76       ++path_i;
  77       ++sel_i;
  78     } else if (pathid < sel_pathid) {
  79       ++pathid;
  80       ++path_i;
  81     } else if (pathid > sel_pathid) {
  82       ++sel_i;
  83     }
  84   }
  85 }
  86
  87 void MussaAlignedWindow::setupMenus()
  88 {
  89   pick_align_menu.clear();
  90   view_align_menu.clear();
  91   pick_actions.clear();
  92   view_actions.clear();
  93
  94   for(vector<ConservedPath >::iterator pathz_i=selected_paths.begin();
  95       pathz_i != selected_paths.end();
  96       ++pathz_i)
  97   {
  98     ConservedPath::path_type normalized_path = pathz_i->normalizedIndexes();
  99     ostringstream menu_text;
 100     menu_text << pathz_i->window_size << ":";
 101     ConservedPath::iterator element_i = normalized_path.begin();
 102     menu_text << *element_i++;
 103     for (;
 104          element_i != normalized_path.end();
 105          ++element_i)
 106     {
 107       menu_text << ", ";
 108       menu_text << *element_i;
 109     }
 110     int index = pathz_i - selected_paths.begin();
 111     IntAction *pick = new IntAction(QString(menu_text.str().c_str()), index, this);
 112     connect(pick, SIGNAL(triggered(int)), this, SLOT(setAlignment(int)));
 113     pick_actions.push_back(pick);
 114     pick_align_menu.addAction(pick);
 115     IntAction *view = new IntAction(QString(menu_text.str().c_str()), index, this);
 116     connect(view, SIGNAL(triggered(int)), this, SLOT(toggleViewAlignment(int)));
 117     view->setCheckable(true);
 118     view->setChecked(true);
 119     view_actions.push_back(view);
 120     view_align_menu.addAction(view);
 121   }
 122 }
 123
 124 void MussaAlignedWindow::setAlignment(int alignment_index)
 125 {
 126   if (selected_paths.size() > 0) {
 127     browser.centerOnPath(selected_paths[alignment_index].normalizedIndexes());
 128   }
 129 }
 130
 131 void MussaAlignedWindow::toggleViewAlignment(int alignment_index)
 132 {
 133   view_paths[alignment_index]= not view_paths[alignment_index];
 134   // perhaps it'd be better if we could erase specific sets
 135   // of matches instead of erasing them all and recomputing them all
 136   // but this is easier
 137   computeMatchLines();
 138 }
 139
 140 void MussaAlignedWindow::update()
 141 {
 142   browser.update();
 143 }
 144
 145 void MussaAlignedWindow::computeMatchLines()
 146 {
 147   browser.clear_links();
 148
 149   // filter out conserved paths
 150   list<ConservedPath> filtered_paths;
 151   vector<ConservedPath>::iterator path_i = selected_paths.begin();
 152   list<ConservedPath::path_type> result;
 153   list<vector<bool> > reversed;
 154
 155   for(vector<ConservedPath>::size_type count = 0;
 156       count != selected_paths.size();
 157       ++count, ++path_i)
 158   {
 159     if (view_paths[count])
 160       filtered_paths.push_back(*path_i);
 161   }
 162   analysis.createLocalAlignment(filtered_paths.begin(),
 163                                 filtered_paths.end(),
 164                                 result,
 165                                 reversed);
 166
 167   list<ConservedPath::path_type>::const_iterator result_i = result.begin();
 168   list<vector<bool> >::const_iterator reversed_i = reversed.begin();
 169   for(int i = 0; i != result.size(); ++i, ++result_i, ++reversed_i)
 170   {
 171     // make 1 base long links
 172     browser.link(*result_i, *reversed_i, 1);
 173   }
 174 }