root/trunk/FRII/gui/BlastFeaturesContainer.hh

/*
 * This file is part of the FamilyRelations II source distribution.
 *
 * FamilyRelations II is part of the FamilyJewels package for comparative
 * sequence analysis: http://family.caltech.edu/.
 *
 * Contact author: C. Titus Brown, titus@caltech.edu.
 *
 * This program and all associated source code files are Copyright (C) 2003,
 * 2004 the California Institute of Technology, Pasadena, CA, 91125 USA.  It
 * is under the Lesser GNU Public License; please see the included
 * LICENSE.txt file for more information, or contact Titus directly.
 *
 */

// A FeaturesContainer for features with BLAST-style scores.

#ifndef BLAST_FEATURES_CONTAINER_HH
#define BLAST_FEATURES_CONTAINER_HH

#include "FeaturesContainer.hh"

#include <vector>

namespace gui {
  class BlastFeaturesContainer;

  class BlastFeature : public Feature {
  public:
    const float score;

    BlastFeature(int s, int e, int o, float sc) : Feature(s, e, o),
                                                  score(sc) { _other = NULL; }

    BlastFeature * copy_me() const {
      BlastFeature * new_f = new BlastFeature(start, end, orientation, score);
      if (_other) {
        new_f->_other = _other->copy_me();
      }
      new_f->set_alignment(top_aln, bot_aln);
      new_f->_info = _info;

      return new_f;
    }
  };

  class BlastFeatureList : public FeatureList {
    friend class BlastFeaturesContainer;
  protected:
    BlastFeatureList() { }

    BlastFeatureList* filter_at(float th) const {
      BlastFeatureList* n = new BlastFeatureList();
      BlastFeature* f;
      
      for (unsigned int i = 0; i < _list.size(); i++) {
        f = (BlastFeature*) _list[i];
        if (f->score <= th) {
          n->add_feature(f->copy_me());
        }
      }
      return n;
    }

    BlastFeatureList* copy_me() const {
      BlastFeatureList* n = new BlastFeatureList();
      BlastFeature* f;
      
      for (unsigned int i = 0; i < _list.size(); i++) {
        f = (BlastFeature*) _list[i];
        n->add_feature(f->copy_me());
      }
      return n;
    }
  };

  //
  // A FeaturesContainer for feature lists with BLAST-type scores.
  //

  class BlastFeaturesContainer : public FeaturesContainer {
  private:
    BlastFeatureList* _orig;
    BlastFeatureList* _list;

    float _threshold, _min_val;

    void _filter(float th) {
      BlastFeatureList * old = _list;
      if (th < _threshold) {    // more stringent
        _list = old->filter_at(th);
      } else {                  // less stringent
        _list = _orig->filter_at(th);
      }
      delete old;
      
      notify_changed();
    }

    BlastFeaturesContainer(BlastFeatureList * l, float th, float min_val) {
      _orig = l;                // consumes l...x
      _list = _orig->filter_at(th);
      _min_val = min_val;
      _threshold = th;
    }
  public:
    // Constructor.
    BlastFeaturesContainer(std::vector<BlastFeature*> l, float th) {
      // create the basic list.
      _orig = new BlastFeatureList();

      if (l.size()) { _min_val = l[0]->score; } // initialize _min_val
      else { _min_val = 1.0; }

      for (unsigned int i = 0; i < l.size(); i++) {
        _orig->add_feature(l[i]);
        if (l[i]->score < _min_val) { _min_val = l[i]->score; }
      }

      // initialize list to the passed-in threshold.
      _list = _orig->filter_at(th);

      _threshold = th;
    }

    // set the threshold
    void threshold(float th) {
      if (th != _threshold) { _filter(th); }
      _threshold = th;
    }

    // get the threshold
    float threshold() { return _threshold; }
    
    virtual const FeatureList* getFeatureList() const { return _list; }
    FeaturesContainer* copy_me() const {
      return new BlastFeaturesContainer(_list->copy_me(), _threshold, _min_val);
    }
    
    // delete stuff.
    ~BlastFeaturesContainer() {
      for (unsigned int i = 0; i < _orig->n_features(); i++) {
        delete _orig->get(i);
      }
      delete _list;
    }
    
    float min() { return _min_val; }
  };
}

#endif // BLAST_FEATURES_CONTAINER_HH