alg/glsequence.hpp

   1 #ifndef _GL_SEQUENCE_H_
   2 #define _GL_SEQUENCE_H_
   3
   4 #include <boost/shared_ptr.hpp>
   5
   6 #include "alg/annotation_colors.hpp"
   7 #include "alg/sequence.hpp"
   8 #include "alg/color.hpp"
   9 // isn't it lovely how the header file can live in different places?
  10 #ifdef __APPLE__
  11 #include <OpenGL/gl.h>
  12 #else
  13 #include <GL/gl.h>
  14 #endif
  15
  16 class GlSequence;
  17 typedef boost::shared_ptr<GlSequence> GlSequenceRef;
  18
  19 //! Manage rendering a mussa sequence track
  20 /*! The idea is this will keep track of the location of where the sequence
  21  *  is being rendered, and handle displaying annotations on that track
  22  */
  23 class GlSequence : public Sequence
  24 {
  25 public:
  26   GlSequence(const Sequence & s,
  27              boost::shared_ptr<AnnotationColors> cm);
  28   GlSequence(const GlSequence & s);
  29   GlSequence(const GlSequence *);
  30   //! Make a new GlSequence, using a copy of SeqSpan
  31   GlSequence(const GlSequenceRef);
  32
  33   GlSequence &operator=(const GlSequence &s);
  34
  35   static DrawableRef default_drawable();
  36   static DrawableRef copy_drawable(DrawableRef s);
  37
  38   //! search through sequence and add an annotation highlighting all the non AGCT characters
  39   void add_annotations_for_defined_sequence(Drawable::draw_func_ptr draw=0);
  40   //! set our starting x (horizontal) coordinate
  41   void setX(float x);
  42   //! get our starting x (horizontal) coordinate
  43   float x() const;
  44   //! set our current y (vertical) position
  45   void setY(float y);
  46   //! get our current y (vertical) position
  47   float y() const;
  48   //! get our current z (depth) position
  49   float z() const;
  50   //! how thick (high) the track we're drawing is
  51   float height() const;
  52
  53   //! set our default draw color
  54   void setColor(ColorRef &c );
  55   //! return our draw color
  56   const ColorRef color() const;
  57   //! return our draw color
  58   ColorRef color();
  59   //! return our annotation color mapper
  60   AnnotationColorsRef colorMapper() { return color_mapper; }
  61
  62   //! draw a from left to right +/- height/2
  63   static
  64   void draw_box(GLfloat world_left, GLfloat world_right,
  65                 GLfloat left, GLfloat right, GLfloat height,
  66                 GLfloat y, GLfloat z,
  67                 GLint primitive=GL_QUADS);
  68   //! draw a track
  69   /*! left and right are the edges of the current viewport
  70    */
  71   void draw(GLfloat left, GLfloat right) const;
  72
  73   //! get our right (horizontal) coordinate (size-x)
  74   float right() const;
  75   //! how long is our sequence track? (computed from the sequence)
  76   GLfloat size() const;
  77
  78   //! return the left (lowest) base index that is fully visible
  79   Sequence::size_type leftbase(GLfloat left) const;
  80   //! return one past rightmost (highest ) base index that is fully visible
  81   //! done mostly so all the iterator logic continues to work correctly.
  82   Sequence::size_type rightbase(GLfloat right) const;
  83
  84   //! provide an iterator to the sequence starting at world coordinate left
  85   Sequence::const_iterator region_begin(GLfloat left, GLfloat right) const;
  86   //! provide an iterator to the sequence ending at world coordinate right
  87   Sequence::const_iterator region_end(GLfloat left, GLfloat right) const;
  88
  89   //! return a subsequence as a GlSequence (instead of a Sequence subsequence)
  90   GlSequence subseq(size_type start, size_type count) const;
  91
  92   //! Return the pixel width of the opengl viewport.
  93   static int get_viewport_width_in_pixels();
  94   //! how big is a pixel in world coordinats
  95   static GLfloat pixelWidth(GLfloat, GLfloat);
  96   //! how big is a pixel in world coordinats (specifying viewport size)
  97   static GLfloat pixelWidth(GLfloat, GLfloat, int);
  98
  99   //! are we close enough that it would make sense to view the base pairs?
 100   bool is_sequence_renderable(GLfloat left, GLfloat right) const;
 101   //! are we close enough that it would make sense to view the base pairs?
 102   /*! though we don't actually check to see if there's sequence in our
 103    *  view, just that there's enough pixels to render something if
 104    *  there were.
 105    *  \param[in] left the left edge of the viewable region in world coordinates
 106    *  \param[in] right the right edge of the viewable region in world
 107    *             coordinates
 108    *  \param[in] pixel_width allow setting the current viewport pixel width
 109    */
 110   bool is_sequence_renderable(GLfloat, GLfloat, int) const;
 111
 112   friend bool operator==(const GlSequence &left, const GlSequence &right);
 113
 114 protected:
 115   AnnotationColorsRef color_mapper;
 116   const GLfloat char_pix_per_world_unit;
 117
 118   //! initalize a SeqSpanRef covering start, count
 119   SeqSpanRef make_undefined_sequence_annotation(
 120     Drawable::draw_func_ptr draw,
 121     size_type start,
 122     size_type count);
 123
 124   //! draw sequence as a bar
 125   void draw_track(GLfloat, GLfloat) const;
 126   void draw_annotations(GLfloat, GLfloat) const;
 127   //! render a sequence as ATGC
 128   /*! left and right are the current edges of the viewable world
 129    */
 130   void draw_sequence(GLfloat, GLfloat) const;
 131 };
 132
 133 void draw_track(SeqSpanRef ref, float left, float right);
 134 void draw_narrow_track(SeqSpanRef ref, float left, float right);
 135 #endif