dnpsort.cc

Go to the documentation of this file.

#include "dnpsort.h"
#include <qinputdialog.h>
#include <cassert>

using namespace std;

void DnpSortAlgo::start()
{
  if ( selectedReads.empty() ) {
    return;
  }

  bool ok;
  int res = QInputDialog::getInteger(
                                     "DNP sort", "Enter start row for selected reads:", 0, 1, numeric_limits<int>::max(), 1,
                                     &ok, 0 );
  
  size_t row(1);
  if ( ok ) {
    // user entered something and pressed OK
    row = res;
  } else {
    // user pressed Cancel
    return;
  }
  

  //Fill structures for bookkeeping
  init();

  if ( dnpID_to_readID.empty() ) {
    return;
  }

  vector<vector<size_t> > groups;
  
  while ( !dnpID_to_readID.empty() ) {
    
    //Pick dnp with ID dnp_id
    MapSet::iterator firstIt = dnpID_to_readID.begin();
    
    int dnp_id = firstIt->first;

    //Put into working set
    set<int> working_set;
    working_set.insert( dnp_id );
    
    //create new group
    groups.push_back( vector<size_t>() );

    while ( !working_set.empty() ) {
      
      int curr_dnp_id = *(working_set.begin());
      working_set.erase( working_set.begin() );
      assert( !dnpDone( curr_dnp_id ) );

      //Pull out all reads with dnp curr_dnp_id and add to current group and register new dnps
      for( set<size_t>::iterator it = dnpID_to_readID[ curr_dnp_id ].begin(); 
           it != dnpID_to_readID[ curr_dnp_id ].end(); ++it ) {
        
        if ( readID_to_dnpID[ *it ].empty() ) continue;
        
        assert( used_reads[ *it ] );
        groups[ groups.size() - 1 ].push_back( *it );
        
        for( set<int>::iterator it2 = readID_to_dnpID[ *it ].begin(); 
             it2 != readID_to_dnpID[ *it ].end(); ++it2 ) {
          if ( *it2 != curr_dnp_id ) {
            working_set.insert( *it2 );
          }
          
        }
        readID_to_dnpID[ *it ].clear();
      } 
      
      dnpID_to_readID.erase( curr_dnp_id );
      assert( dnpDone( curr_dnp_id ) );

    }

  }
  
  //Assign new rows to groups
//   size_t row(1);
  for( size_t i = 0; i < groups.size(); i++ ) {
    
    for( size_t j = 0; j < groups[ i ].size(); j++ ) {
      assert( used_reads[ groups[i][j] ] );
      getMAl()->set_seq_row( groups[i][j], row );
      row++;
    }
    row += 5;
  }
  
  //put remaining reads at the bottom
  for( size_t i = 0; i < used_reads.size(); i++ ) {
    if ( !used_reads[ i ] ) {
      getMAl()->set_seq_row( i, row );
      row++;
      
    }
    
  }
  
}

void DnpSortAlgo::init()
{
  for( size_t i = 0; i < getMAl()->get_num_seq(); i++ ) {
    set<int> tmpset;
    readID_to_dnpID.push_back(tmpset);
    used_reads.push_back(false);
    
    for( size_t j = 0; j < getMAl()->get_seq_end( i ); j++ ) {

      if ( getMAl()->is_DNP(i, j) ) {
        dnpID_to_readID[ getMAl()->get_DNP_ID(i, j) ].insert( i );
        readID_to_dnpID[ i ].insert( getMAl()->get_DNP_ID(i, j) );
        used_reads[i] = true;
      }
      
    }
  }
}

bool DnpSortAlgo::dnpDone( int dnp_id )
{
  return dnpID_to_readID.find( dnp_id ) == dnpID_to_readID.end();
}

---