#ifndef _GLTRACKS_H_
#define _GLTRACKS_H_
+#include <boost/shared_ptr.hpp>
#include <map>
#include <set>
#include "alg/annotation_colors.hpp"
#include "alg/sequence.hpp"
#include "alg/glsequence.hpp"
+#include "alg/sequence_location.hpp"
+#include "alg/track_region.hpp"
//! Manage rendering a collection of glSequences
class GlSeqBrowser
//! select a region (using canvas coordinates)
void selectRegion(int top, int left, int bottom, int right);
+ //! turn off selection
+ void clearSelection();
//! border size
float border() const;
float left() const;
//! max world right coordinate
float right() const;
+ // return how wide is a pixel in world coordinates?
+ float get_pixel_width() const;
void setViewportCenter(float x);
//! return world coordinate of the left side of the viewport
float viewportHeight() const;
//! return width of the viewport in world coordinates
float viewportWidth() const;
+
+ //! return viewport height in pixels
+ int viewportPixelHeight() const;
+ //! return viewport width in pixels
+ int viewportPixelWidth() const;
+
+ //! convert x axis from display to world coordinates
+ float viewportXtoWorldX(int x);
+ //! convert y axis from display to world coordinates
+ float viewportYtoWorldY(int y);
//! zoom out far enough to show the full size of the sequence
double zoomOut();
//! center the provided path in the current viewport
void centerOnPath(const std::vector<int>&);
- void setColorMapper(AnnotationColors& cm);
- AnnotationColors& colorMapper();
+ void setColorMapper(boost::shared_ptr<AnnotationColors> cm);
+ const AnnotationColorsRef colorMapper();
//! clear our tracks and connections
void clear();
//! clear everything related to a selection
void clear_selection();
+ //! add a sequence to the back of our track container (makes copy of s)
+ void push_sequence(const Sequence& s);
//! add a sequence to the back of our track container
- void push_sequence(const Sequence &s);
+ void push_sequence(boost::shared_ptr<Sequence> s);
+ //! add a glsequence to the back of our track container
+ void push_sequence(GlSequence s);
//! add a glsequence to the back of our track container
- void push_sequence(GlSequence &s);
+ void push_sequence(boost::shared_ptr<GlSequence> gs);
//! return our track container
- const std::vector<GlSequence>& sequences() const;
+ const std::vector<boost::shared_ptr<GlSequence> >& sequences() const;
//! clear all the line segments between all the sequences
void clear_links();
//! define a path
void link(const std::vector<int>& path, const std::vector<bool>& isRC, int length);
+ //! set selected paths (it'd be nice if this could be a templated function)
+ void setSelectedPaths(std::vector<int> c);
//! returns the index of pathids based on order added by link
const std::set<int>& selectedPaths() const;
+
+ //! set selected tracks (it'd be nice if this could be a templated function)
+ void appendSelectedTrack(GLuint track_index, int left, int right);
+
+ //! return list of selected tracks
+ std::list<TrackRegion> selectedTracks() const;
+
//! copy sequence from selected track using formating function
template<class Item>
- void copySelectedTracks(std::list<Item>& result,
+ size_t copySelectedTracks(std::list<Item>& result,
Item (*format_track)(const Sequence& s, int left, int right));
//! copy sequence from selected tracks as FASTA sequences
- void copySelectedTracksAsFasta(std::string& copy_buffer);
+ /*! \return number of base pairs copied
+ */
+ size_t copySelectedTracksAsFasta(std::string& copy_buffer);
//! copy sequence from selected tracks as a list of sequences
- void copySelectedTracksAsSequences(std::list<Sequence>& result);
+ /*! \return number of base pairs copied
+ */
+ size_t copySelectedTracksAsSequences(std::list<Sequence>& result);
//! copy sequence from selected tracks as plain sequences
- void copySelectedTracksAsString(std::string& copy_buffer);
-
- //! convenience structure for holding selected track segments
- struct SequenceLocation {
- const Sequence& sequence;
- int left;
- int count;
- SequenceLocation(const Sequence& s, int l, int c);
- };
+ /*! \return number of base pairs copied
+ */
+ size_t copySelectedTracksAsString(std::string& copy_buffer);
+
//! copy tracks as a sequence and its coordinates
- void copySelectedTracksAsSeqLocation(std::list<SequenceLocation>& result);
+ size_t copySelectedTracksAsSeqLocation(std::list<SequenceLocation>& result);
//! Provide a logical name for a type discriminator for our glName stack
point<float> start;
point<float> end;
bool reversed;
+ int length;
+ // each integer represents an index into our list of paths
std::set<int> path_ids;
- Segment() : start(0.0, 0.0), end(0.0, 0.0) {}
- Segment(float x1, float y1, float x2, float y2, bool isRC)
- : start(x1, y1), end(x2, y2), reversed(isRC) {}
+ Segment() : start(0.0, 0.0), end(0.0, 0.0), reversed(false), length(0) {}
+ Segment(float x1, float y1, float x2, float y2, bool isRC, int length_)
+ : start(x1, y1), end(x2, y2), reversed(isRC), length(length_) {}
};
//! data structure holding our line segments
* it's indexed by the pair x1, x2 (the two x coordinates between
* the two tracks
*/
- typedef std::pair<int, int> segment_key;
+ typedef std::pair<int, int> segment_key;
typedef std::map<segment_key, Segment> pair_segment_map;
typedef std::vector<pair_segment_map> path_segment_map_vector;
path_segment_map_vector path_segments;
- struct TrackRegion
- {
- GLuint track_id;
- int left;
- int right;
-
- TrackRegion():track_id(0), left(0), right(0) {};
- TrackRegion(const TrackRegion& o)
- : track_id(o.track_id), left(o.left), right(o.right) {}
- TrackRegion(GLuint id, int l, int r)
- : track_id(id), left(l), right(r) {}
- void set(GLuint id, int l, int r) { track_id = id; left=l; right=r; };
- };
-
private:
//! recalculate the viewable world
/*! depending on the size of our canvas, our zoom level and
//! the center of our current viewport (world coord) (used for scrollbar)
float viewport_center;
double zoom_level;
- AnnotationColors color_mapper;
- //! container of all the GlSequences loaded into our scene
- std::vector<GlSequence> track_container;
+ AnnotationColorsRef color_mapper;
//! counter for each path added to us via connect
int pathid;
protected:
+ //! container of all the GlSequences loaded into our scene
+ std::vector<GlSequenceRef > track_container;
//! where to draw our box (world coordinates)
rect<float> selectedRegion;
//! true if we have a selection
std::list<TrackRegion> selected_tracks;
typedef std::list<TrackRegion>::iterator selected_track_iterator;
};
+
+inline float GlSeqBrowser::viewportXtoWorldX(int x) {
+ GLfloat x_scale = cur_ortho.width()/((float)viewport_size.x);
+ return (cur_ortho.left + (x * x_scale));
+}
+
+inline float GlSeqBrowser::viewportYtoWorldY(int y) {
+ GLfloat y_scale = cur_ortho.height()/((float)viewport_size.y);
+ return cur_ortho.top-(y * y_scale);
+}
+
#endif
projects / mussa.git / blobdiff