alignseg.h

Go to the documentation of this file.

#ifndef ALIGNSEG_H
#define ALIGNSEG_H

#include <iostream>
#include <matrix.h>

using namespace std;

class Alignseg {
   public:
      Alignseg() : x(0), y(0), len(0), score(0) {}
      Alignseg(const int xx, const int yy, const int ll)
         : x(xx), y(yy), len(ll), score(0) { }
      Alignseg(const int xx, const int yy, const int ll, const int sc)
         : x(xx), y(yy), len(ll), score(sc) { }
      Alignseg(const Alignseg& as) 
         : x(as.getX()), y(as.getY()), len(as.getLength()),
           score(as.getScore()) { }
      int distanceX(const Alignseg& as) { return as.x-x-len; }
      int distanceY(const Alignseg& as) { return as.y-y-len; }
      bool before(const Alignseg& as) { return getEndX() < as.getX() && getEndY() < as.getY(); }
      bool before(const Alignseg* as) { return getEndX() < as->getX() && getEndY() < as->getY(); }
      int diagonal() const { return y-x; }
      bool sameDiagonal(const Alignseg& as) { return y-x == as.y-as.x; }
      bool contain(const Alignseg& as) const;
      void merge(const Alignseg& as);
      friend ostream& operator<<(ostream& ous, const Alignseg& as);
      bool operator==(const Alignseg& as) const {
              return x==as.x && y==as.y && len==as.len; }
      int getLength() const { return len; }
      int getScore() const { return score; }
      void setScore(const int sc) { score=sc; }
      int getX() const { return x; }
      int getEndX() const { return x+len-1; }
      int getY() const { return y; }
      int getEndY() const { return y+len-1; }
      void setX(const int xx) { x=xx; }
      void setY(const int yy) { y=yy; }
      void setLength(const int l) { len=l; }
      void addLength(const int l) { len += l; }
      void addScore(const int sc) { score += sc; }
      int YOverlap(const Alignseg& as) const { return as.y-getEndY()+1; }
      int XOverlap(const Alignseg& as) const { return as.x-getEndX()+1; }
      void shrink(int sz, const int* xsc, const int* ysc, const Matrix* mt);

   protected:
      int x, y, len; // len is the length in X axis
      int score;
};

class Alignsegex : public Alignseg {
   public:
      Alignsegex() : Alignseg(), prev(0), maxsc(0) { }
      Alignsegex(const int xx, const int yy, const int ll)
         : Alignseg(xx,yy,ll), prev(0), maxsc(0) { }

      Alignsegex(const Alignseg& as) 
         : Alignseg(as), prev(0), maxsc(as.getScore()) { }

      void setPreviousNode(Alignsegex* as) { prev=as; }
      void setPrevious(Alignsegex* as) { prev=as; }
      Alignsegex* previous() { return prev; }
      bool attachTo(Alignsegex* as, const int* xsc, const int* ysc, const Matrix* mtx);
      //void attachTo(const Alignsegex& as) { attachTo(&as); }
      void setDefault() { maxsc=score; prev=0; } 
      void shrink(int sz, const int* xsc, const int* ysc, const Matrix* mt);
      int getMaxScore() const { return maxsc; }
      void setMaxScore(const int sc) { maxsc=sc; }
      // this object should not know too much about other objects
      //void grow(int sz, const int* xsc, const int* ysc, const Matrix* mt);
      friend ostream& operator<<(ostream& ous, const Alignsegex& as);
      void print(ostream& ous) const;
      void addMaxScore(const int sc) { Alignseg::addScore(sc); maxsc += sc; }
      void setConnectPath(const int p) { connectpath=p; }
      int getConnectPath() const { return connectpath; }

      static void setParameters(int go, int ge, int gd) {
         gapopen=go; gapextend=ge; gapaligndropoff=gd; }

   protected:
      Alignsegex *prev; // build the chain
      int maxsc;        // maximum score so far on the chain
      int connectpath;  // 1, 2, 3 methods to connect to the previous node

      // class wide parameter, copy from blast parameters
      static int gapopen; // negative number
      static int gapextend; // negative number
      static int gapaligndropoff; // default 12
};

class ltAlignsegYXlen {
   public:
      bool operator()(const Alignseg& as1, const Alignseg& as2) const {
         if (as1.getY() < as2.getY()) return true;
         else if (as1.getY() == as2.getY()) {
            if (as1.getX() < as2.getX()) return true;
            else if (as1.getX() == as2.getX()) {
               if (as1.getLength() < as2.getLength()) return true;
               else return false;
            }
            return false;
         }
         else return false;
      }
};

#endif