X-Git-Url: http://woldlab.caltech.edu/gitweb/?a=blobdiff_plain;f=alg%2Fmussa.cpp;h=9a5935e19947cbd68e28e7c7a3f88b267816030f;hb=6d25d4d945af696134bdf788b111f38b197b1a15;hp=ccba221f61ca45a8007906046ccd2a07209eb510;hpb=3814f060a887355f15c923d3b3d1a9b322779832;p=mussa.git

diff --git a/alg/mussa.cpp b/alg/mussa.cpp
index ccba221..9a5935e 100644
--- a/alg/mussa.cpp
+++ b/alg/mussa.cpp
@@ -12,22 +12,20 @@
 //                          ---------- mussa_class.cc -----------
 //                        ----------------------------------------
 
+#include <boost/filesystem/path.hpp>
 #include <boost/filesystem/operations.hpp>
 #include <boost/filesystem/fstream.hpp>
 namespace fs = boost::filesystem;
 
-#include <boost/spirit/core.hpp>
-#include <boost/spirit/actor/push_back_actor.hpp>
-#include <boost/spirit/iterator/file_iterator.hpp>
-#include <boost/spirit/utility/chset.hpp>
-namespace spirit = boost::spirit;
-
 #include <iostream>
 #include <sstream>
 
 #include "mussa_exceptions.hpp"
-#include "alg/mussa.hpp"
-#include "alg/flp.hpp"
+
+#include "flp.hpp"
+#include "io.hpp"
+#include "mussa.hpp"
+#include "motif_parser.hpp"
 
 using namespace std;
 
@@ -36,8 +34,8 @@ Mussa::Mussa()
   : color_mapper(new AnnotationColors)
 {
   clear();
-  connect(&the_paths, SIGNAL(progress(const std::string&, int, int)), 
-          this, SIGNAL(progress(const std::string&, int, int)));
+  connect(&the_paths, SIGNAL(progress(const QString&, int, int)), 
+          this, SIGNAL(progress(const QString&, int, int)));
 }
 
 Mussa::Mussa(const Mussa& m)
@@ -53,8 +51,14 @@ Mussa::Mussa(const Mussa& m)
     analysis_path(m.analysis_path),
     dirty(m.dirty)
 {
-  connect(&the_paths, SIGNAL(progress(const std::string&, int, int)), 
-          this, SIGNAL(progress(const std::string&, int, int)));
+  connect(&the_paths, SIGNAL(progress(const QString&, int, int)), 
+          this, SIGNAL(progress(const QString&, int, int)));
+}
+
+MussaRef Mussa::init() 
+{
+  boost::shared_ptr<Mussa> m(new Mussa());
+  return m;
 }
 
 boost::filesystem::path Mussa::get_analysis_path() const
@@ -62,6 +66,11 @@ boost::filesystem::path Mussa::get_analysis_path() const
   return analysis_path;
 }
 
+void Mussa::set_analysis_path(boost::filesystem::path pathname)
+{
+  analysis_path = pathname;
+}
+
 // set all parameters to null state
 void
 Mussa::clear()
@@ -78,7 +87,15 @@ Mussa::clear()
   the_seqs.clear();
   the_paths.clear();
   analysis_path = fs::path();
-  dirty = false;
+  set_dirty(false);
+}
+
+void Mussa::set_dirty(bool new_state)
+{
+  if (dirty != new_state) {
+    dirty = new_state;
+    emit isModified(dirty);
+  }
 }
 
 bool Mussa::is_dirty() const
@@ -99,14 +116,26 @@ void
 Mussa::set_name(string a_name)
 {
   analysis_name = a_name;
-  dirty = true;
+  set_dirty(true);
 }
 
-string Mussa::get_name()
+string Mussa::get_name() const
 {
   return analysis_name;
 }
 
+string Mussa::get_title() const
+{
+  fs::path analysis_path = get_analysis_path();
+  if (not analysis_path.empty()) {
+    return analysis_path.native_file_string();
+  } else if (get_name().size() > 0) {
+    return get_name();
+  } else {
+    return std::string("Unnamed");
+  }
+}
+
 int 
 Mussa::size() const
 {
@@ -120,7 +149,7 @@ void
 Mussa::set_window(int a_window)
 {
   window = a_window;
-  dirty = true;
+  set_dirty(true);
 }
 
 int Mussa::get_window() const
@@ -132,7 +161,7 @@ void
 Mussa::set_threshold(int a_threshold)
 {
   threshold = a_threshold;
-  dirty = true;
+  set_dirty(true);
   if (a_threshold > soft_thres) {
     soft_thres = a_threshold;
   }
@@ -164,7 +193,7 @@ void
 Mussa::set_analysis_mode(enum analysis_modes new_ana_mode)
 {
   ana_mode = new_ana_mode;
-  dirty = true;
+  set_dirty(true);
 }
 
 enum Mussa::analysis_modes Mussa::get_analysis_mode() const
@@ -291,17 +320,17 @@ void Mussa::append_sequence(const Sequence& a_seq)
 {
   boost::shared_ptr<Sequence> seq_copy(new Sequence(a_seq));
   the_seqs.push_back(seq_copy);
-  dirty = true;
+  set_dirty(true);
 }
 
 void Mussa::append_sequence(boost::shared_ptr<Sequence> a_seq)
 {
   the_seqs.push_back(a_seq);
-  dirty = true;
+  set_dirty(true);
 }
 
 
-const vector<boost::shared_ptr<Sequence> >& 
+const vector<SequenceRef>& 
 Mussa::sequences() const
 {
   return the_seqs;
@@ -320,13 +349,38 @@ void Mussa::load_sequence(fs::path seq_file, fs::path annot_file,
     aseq->set_species(*name);
   }
   the_seqs.push_back(aseq);
-  dirty = true;
+  set_dirty(true);
+}
+
+void Mussa::load_mupa_file(std::string para_file_path) {
+  load_mupa_file(boost::filesystem::path(para_file_path));
 }
 
 void
 Mussa::load_mupa_file(fs::path para_file_path)
 {
-  fs::ifstream para_file;
+  if (not fs::exists(para_file_path))
+  {
+    throw mussa_load_error("Config File: " + para_file_path.string() + " not found");
+  } else if (fs::is_directory(para_file_path)) {
+    throw mussa_load_error("Config File: " + para_file_path.string() + " is a directory.");
+  } else if (fs::is_empty(para_file_path)) {
+    throw mussa_load_error("Config File: " + para_file_path.string() + " is empty");
+  } else  {
+    // what directory is the mupa file in?
+    fs::path file_path_base( para_file_path.branch_path()) ;
+
+    fs::ifstream para_file;
+    para_file.open(para_file_path, ios::in);
+    
+    load_mupa_stream(para_file, file_path_base);
+    para_file.close();   
+  }
+}
+
+void
+Mussa::load_mupa_stream(std::istream& para_file, fs::path& file_path_base)
+{
   string file_data_line;
   string param, value; 
   fs::path annot_file;
@@ -340,103 +394,86 @@ Mussa::load_mupa_file(fs::path para_file_path)
   // initialize values
   clear();
 
-  // if file was opened, read the parameter values
-  if (not fs::exists(para_file_path))
+  // setup loop by getting file's first line
+  getline(para_file, file_data_line);
+  split_index = file_data_line.find(" ");
+  param = file_data_line.substr(0,split_index);
+  value = file_data_line.substr(split_index+1);
+  
+  while (para_file)
   {
-    throw mussa_load_error("Config File: " + para_file_path.string() + " not found");
-  } else if (fs::is_directory(para_file_path)) {
-    throw mussa_load_error("Config File: " + para_file_path.string() + " is a directory.");
-  } else if (fs::is_empty(para_file_path)) {
-    throw mussa_load_error("Config File: " + para_file_path.string() + " is empty");
-  } else  {
-    para_file.open(para_file_path, ios::in);
-
-    // what directory is the mupa file in?
-    fs::path file_path_base = para_file_path.branch_path();
-
-    // setup loop by getting file's first line
-    getline(para_file,file_data_line);
-    split_index = file_data_line.find(" ");
-    param = file_data_line.substr(0,split_index);
-    value = file_data_line.substr(split_index+1);
-    
-    while (para_file)
+    did_seq = false;
+    if (param == "ANA_NAME")
+      analysis_name = value;
+    else if (param == "APPEND_WIN")
+      win_append = true;
+    else if (param == "APPEND_THRES")
+      thres_append = true;
+    else if (param == "SEQUENCE_NUM")
+      ; // ignore sequence_num now
+    else if (param == "WINDOW")
+      window = atoi(value.c_str());
+    else if (param == "THRESHOLD")
+      threshold = atoi(value.c_str());
+    else if (param == "SEQUENCE")
     {
-      did_seq = false;
-      if (param == "ANA_NAME")
-        analysis_name = value;
-      else if (param == "APPEND_WIN")
-        win_append = true;
-      else if (param == "APPEND_THRES")
-        thres_append = true;
-      else if (param == "SEQUENCE_NUM")
-        ; // ignore sequence_num now
-      else if (param == "WINDOW")
-        window = atoi(value.c_str());
-      else if (param == "THRESHOLD")
-        threshold = atoi(value.c_str());
-      else if (param == "SEQUENCE")
-      {
-        fs::path seq_file = file_path_base / value;
-        //cout << "seq_file_name " << seq_files.back() << endl;
-        fasta_index = 1;
-        annot_file = "";
-        sub_seq_start = 0;
-        sub_seq_end = 0;
-        seq_params = true;
-
-        while (para_file && seq_params)
-        {
-          getline(para_file,file_data_line);
-          split_index = file_data_line.find(" ");
-          param = file_data_line.substr(0,split_index);
-          value = file_data_line.substr(split_index+1);
-
-          if (param == "FASTA_INDEX")
-            fasta_index = atoi(value.c_str());
-          else if (param == "ANNOTATION")
-            annot_file = file_path_base / value;
-          else if (param == "SEQ_START")
-            sub_seq_start = atoi(value.c_str());
-          else if (param == "SEQ_END")
-          {
-            sub_seq_end = atoi(value.c_str());
-          }
-          //ignore empty lines or that start with '#'
-          else if ((param == "") || (param == "#")) {}
-          else seq_params = false;
-        }
-        load_sequence(seq_file, annot_file, fasta_index, sub_seq_start, 
-                      sub_seq_end);
-        did_seq = true;
-      }
-      //ignore empty lines or that start with '#'
-      else if ((param == "") || (param == "#")) {}
-      else
-      {
-        clog << "Illegal/misplaced mussa parameter in file\n";
-        clog << param << "\n";
-      }
-
-      if (!did_seq)
+      fs::path seq_file = file_path_base / value;
+      //cout << "seq_file_name " << seq_files.back() << endl;
+      fasta_index = 1;
+      annot_file = "";
+      sub_seq_start = 0;
+      sub_seq_end = 0;
+      seq_params = true;
+
+      while (para_file && seq_params)
       {
-        getline(para_file,file_data_line);
+        multiplatform_getline(para_file,file_data_line);
         split_index = file_data_line.find(" ");
         param = file_data_line.substr(0,split_index);
         value = file_data_line.substr(split_index+1);
-        did_seq = false;
+
+        if (param == "FASTA_INDEX")
+          fasta_index = atoi(value.c_str());
+        else if (param == "ANNOTATION")
+          annot_file = file_path_base / value;
+        else if (param == "SEQ_START")
+          sub_seq_start = atoi(value.c_str());
+        else if (param == "SEQ_END")
+        {
+          sub_seq_end = atoi(value.c_str());
+        }
+        //ignore empty lines or that start with '#'
+        else if ((param == "") || (param == "#")) {
+          // pass 
+        } else {
+          seq_params = false;
+        }
       }
+      load_sequence(seq_file, annot_file, fasta_index, sub_seq_start, 
+                    sub_seq_end);
+      did_seq = true;
+    }
+    //ignore empty lines or that start with '#'
+    else if ((param == "") || (param == "#")) {}
+    else
+    {
+      clog << "Illegal/misplaced mussa parameter in file\n";
+      clog << param << "\n";
     }
 
-    para_file.close();
-
-    soft_thres = threshold;
-    //cout << "nway mupa: analysis_name = " << analysis_name 
-    //     << " window = " << window 
-    //     << " threshold = " << threshold << endl;
+    if (!did_seq)
+    {
+      multiplatform_getline(para_file,file_data_line);
+      split_index = file_data_line.find(" ");
+      param = file_data_line.substr(0,split_index);
+      value = file_data_line.substr(split_index+1);
+      did_seq = false;
+    }
   }
+
+  soft_thres = threshold;
   // no file was loaded, signal error
-  dirty = true;
+  set_dirty(true);
 }
 
 
@@ -447,8 +484,7 @@ Mussa::analyze()
     throw mussa_analysis_error("you need to have at least 2 sequences to "
                                "do an analysis.");
   }
-  //cout << "nway ana: seq_num = " << the_seqs.size() << endl;
-
+  
   seqcomp();
   the_paths.setup(window, threshold);
   nway();
@@ -524,13 +560,14 @@ Mussa::nway()
 void
 Mussa::save(fs::path save_path)
 {
-  fs::path flp_filepath;
   fs::fstream save_file;
   ostringstream append_info;
   int dir_create_status;
 
   if (save_path.empty()) {
-    if (not analysis_name.empty()) {
+    if (not analysis_path.empty()) {
+      save_path = analysis_path;
+    } else if (not analysis_name.empty()) {
       std::string save_name = analysis_name;
        // gotta do bit with adding win & thres if to be appended
        if (win_append) {
@@ -553,8 +590,12 @@ Mussa::save(fs::path save_path)
   if (not fs::exists(save_path)) {
     fs::create_directory(save_path);
   }
+  
+  std::string basename = save_path.leaf(); 
+  fs::path museq(basename + ".museq", fs::native);
+  
   // save sequence and annots to a special mussa file
-  save_file.open(save_path / (save_path.leaf()+".museq"), ios::out);
+  save_file.open(save_path / museq, ios::out);
   save_file << "<Mussa_Sequence>" << endl;
 
   for(vector<Sequence>::size_type i = 0; i < the_seqs.size(); i++)
@@ -565,18 +606,27 @@ Mussa::save(fs::path save_path)
   save_file << "</Mussa_Sequence>" << endl;
   save_file.close();
 
+  // if we have any motifs, save them.
+  if (motif_sequences.size()) {
+    fs::path mtl(basename + ".mtl", fs::native);
+    save_motifs(save_path / mtl);
+  }
+
   // save nway paths to its mussa save file
-  the_paths.save(save_path / (save_path.leaf()+ ".muway"));
+  fs::path muway(basename + ".muway", fs::native);
+  the_paths.save(save_path / muway);
 
   for(vector<Sequence>::size_type i = 0; i < the_seqs.size(); i++) {
     for(vector<Sequence>::size_type i2 = i+1; i2 < the_seqs.size(); i2++)
     {
       append_info.str("");
       append_info <<  "_sp_" << i << "v" << i2;
-      all_comps[i][i2].save(save_path/(save_path.leaf()+append_info.str()+".flp"));
+      fs::path flp(basename+append_info.str()+".flp", fs::native);
+      all_comps[i][i2].save(save_path / flp);
     }
   }
-  dirty = false;
+
+  set_dirty(false);
   analysis_path = save_path;
 }
 
@@ -599,13 +649,14 @@ Mussa::load(fs::path ana_file)
   vector<FLPs> empty_FLP_vector;
   FLPs dummy_comp;
 
+
+  //--------------------------------------------------------
+  // Load Muway
+  //--------------------------------------------------------
   analysis_path = ana_file;
-  //clog << "ana_file name " << ana_file.string() << endl;
   analysis_name = ana_path.leaf();
-  //clog << " ana_name " << analysis_name << endl;
-  file_path_base =  ana_path.branch_path() / analysis_name;
-  a_file_path = file_path_base / (analysis_name + ".muway");
-  //clog << " loading museq: " << a_file_path.string() << endl;
+  fs::path muway(analysis_name+".muway", fs::native);
+  a_file_path = analysis_path / muway;
   the_paths.load(a_file_path);
   // perhaps this could be more elegent, but at least this'll let
   // us know what our threshold and window sizes were when we load a muway
@@ -613,19 +664,63 @@ Mussa::load(fs::path ana_file)
   threshold = the_paths.get_threshold();
   soft_thres = threshold;
 
-  int seq_num = the_paths.sequence_count();
 
-  a_file_path = file_path_base / (analysis_name + ".museq");
+  //--------------------------------------------------------
+  // Load Sequence
+  //--------------------------------------------------------
+  //int seq_num = the_paths.sequence_count();
+
+  fs::path museq(analysis_name + ".museq", fs::native);
+  a_file_path = analysis_path / museq;
 
   // this is a bit of a hack due to C++ not acting like it should with files
-  for (i = 1; i <= seq_num; i++)
+  /*for (i = 1; i <= seq_num; i++)
   {
     boost::shared_ptr<Sequence> tmp_seq(new Sequence);
-    //clog << "mussa_class: loading museq frag... " << a_file_path.string() << endl;
     tmp_seq->load_museq(a_file_path, i);
     the_seqs.push_back(tmp_seq);
+  }*/
+  
+  i = 1;
+  //int seq_num = 0;
+  boost::filesystem::fstream load_museq_fs;
+  load_museq_fs.open(a_file_path, std::ios::in);
+  boost::shared_ptr<Sequence> tmp_seq;
+  while (1)
+  {
+    tmp_seq = Sequence::load_museq(load_museq_fs);
+    
+    if (tmp_seq)
+    {
+      the_seqs.push_back(tmp_seq);
+    }
+    else
+    {
+      break;
+    }
+    
+    
+    //safe guard in case of an infinate loop.
+    //FIXME: If mussa can handle a comparison of 10000 sequences
+    // in the future, then this code should be fixed.
+    if (i == 10000)
+    {
+      throw mussa_load_error(" Run away sequence load!");
+    }
+    i++;
+  }
+  load_museq_fs.close();
+  
+  //--------------------------------------------------------
+  // Load Motifs
+  //--------------------------------------------------------
+  fs::path mtl(analysis_name + ".mtl", fs::native);
+  fs::path motif_file = analysis_path / mtl;
+  if (fs::exists(motif_file)) {
+    load_motifs(motif_file);
   }
   
+  vector<Sequence>::size_type seq_num = the_seqs.size();
   empty_FLP_vector.clear();
   for(i = 0; i < seq_num; i++)
   {
@@ -634,6 +729,7 @@ Mussa::load(fs::path ana_file)
       all_comps[i].push_back(dummy_comp);
   }
   
+  
   for(i = 0; i < seq_num; i++)
   {
     for(i2 = i+1; i2 < seq_num; i2++)
@@ -641,15 +737,13 @@ Mussa::load(fs::path ana_file)
       append_info.str("");
       append_info << analysis_name <<  "_sp_" << i << "v" << i2 << ".flp";
       //clog << append_info.str() << endl;
-      a_file_path = file_path_base / append_info.str();
-      //clog << "path " << a_file_path.string() << endl;
+      fs::path flp(append_info.str(), fs::native);
+      a_file_path = analysis_path / flp;
       all_comps[i][i2].load(a_file_path);
-      //clog << "real size = " << all_comps[i][i2].size() << endl;
     }
   }
 }
 
-
 void
 Mussa::save_old()
 {
@@ -726,6 +820,7 @@ void Mussa::add_motif(const Sequence& motif, const Color& color)
 {
   motif_sequences.insert(motif);
   color_mapper->appendInstanceColor("motif", motif.get_sequence(), color);
+  set_dirty(true);
 }
 
 void Mussa::set_motifs(const vector<Sequence>& motifs, 
@@ -743,60 +838,18 @@ void Mussa::set_motifs(const vector<Sequence>& motifs,
   update_sequences_motifs();
 }
 
-
-// Helper functor to append created motifs to our Mussa analysis
-struct push_back_motif {
-  std::set<Sequence>& motif_set;
-  boost::shared_ptr<AnnotationColors> color_mapper;
-  std::string& seq_string;
-  std::string& name;
-  float& red;
-  float& green;
-  float& blue;
-
-  push_back_motif(std::set<Sequence>& motif_set_,
-                  boost::shared_ptr<AnnotationColors> color_mapper_,
-                  std::string& seq_, 
-                  std::string& name_,
-                  float red_, float green_, float blue_)
-    : motif_set(motif_set_),
-      color_mapper(color_mapper_),
-      seq_string(seq_),
-      name(name_),
-      red(red_),
-      green(green_),
-      blue(blue_)
-  {
-  }
-
-  void operator()(std::string::const_iterator, 
-                  std::string::const_iterator) const 
-  {
-    //std::cout << "motif: " << seq_string << "/" << name << endl;
-
-    Sequence seq(seq_string);
-    // shouldn't we have a better field than "fasta header" and speices?
-    seq.set_fasta_header(name);
-    // we need to clear the name in case the next motif doesn't have one.
-    name.clear();
-    // be nice if glsequence was a subclass of sequence so we could
-    // just attach colors directly to the motif.
-    Color c(red, green, blue);
-    color_mapper->appendInstanceColor("motif", seq.c_str(), c);
-    motif_set.insert(seq);
-  };
-};
-
-// I mostly split the ifstream out so I can use a stringstream to test it.
+void Mussa::load_motifs(fs::path filename)
+{
+  fs::ifstream f;
+  f.open(filename, ifstream::in);
+  load_motifs(f);
+}
+  
 void Mussa::load_motifs(std::istream &in)
 {
   std::string data;
-  const char *alphabet = Sequence::nucleic_iupac_alphabet.c_str();
-  string seq;
-  string name;
-  float red;
-  float green;
-  float blue;
+  const char *alphabet = Alphabet::dna_cstr;
+  motif_parser::ParsedMotifs parsed_motifs(motif_sequences, color_mapper);
 
   // slurp our data into a string
   std::streamsize bytes_read = 1;
@@ -806,38 +859,37 @@ void Mussa::load_motifs(std::istream &in)
     bytes_read = in.readsome(buf, bufsiz);
     data.append(buf, buf+bytes_read);
   }
-  // parse our string
-  bool status = spirit::parse(data.begin(), data.end(),
-     *( 
-       ( 
-        (
-         (+spirit::chset<>(alphabet))[spirit::assign_a(seq)] >> 
-         +spirit::space_p
-        ) >>
-        !(
-          (spirit::alpha_p >> *spirit::alnum_p)[spirit::assign_a(name)]
-          >> +spirit::space_p
-        ) >>
-        spirit::real_p[spirit::assign_a(red)] >> +spirit::space_p >>
-        spirit::real_p[spirit::assign_a(green)] >> +spirit::space_p >>
-        spirit::real_p[spirit::assign_a(blue)] >> +spirit::space_p
-       )[push_back_motif(motif_sequences, color_mapper, seq, name, red, green, blue)]
-     )).full;
+  parsed_motifs.parse(data);
   update_sequences_motifs();
 }
 
-void Mussa::load_motifs(fs::path filename)
+void Mussa::save_motifs(fs::path filename)
 {
-  fs::ifstream f;
-  f.open(filename, ifstream::in);
-  load_motifs(f);
+  fs::ofstream out_stream;
+  out_stream.open(filename, ofstream::out);
+  save_motifs(out_stream);
+}
+
+void Mussa::save_motifs(std::ostream& out)
+{
+  for(motif_set::iterator motif_i = motif_sequences.begin();
+      motif_i != motif_sequences.end();
+      ++motif_i)
+  {
+    out << motif_i->get_sequence() << " ";
+    if (motif_i->get_name().size() > 0) {
+      out << "\"" << motif_i->get_name() << "\" ";
+    }
+    out << color_mapper->lookup("motif", motif_i->get_sequence());
+    out << std::endl;
+  }
 }
 
 void Mussa::update_sequences_motifs()
 {
   // once we've loaded all the motifs from the file, 
   // lets attach them to the sequences
-  for(vector<boost::shared_ptr<Sequence> >::iterator seq_i = the_seqs.begin();
+  for(vector<SequenceRef >::iterator seq_i = the_seqs.begin();
       seq_i != the_seqs.end();
       ++seq_i)
   {