genoverse 3.2.0

package/js/Track/Model.js

@@ -0,0 +1,303 @@
+Genoverse.Track.Model = Base.extend({
+  dataType           : 'json',
+  allData            : false,
+  dataBuffer         : undefined, // e.g. { start: 0, end: 0 } - basepairs to extend data region for, when getting data from the origin
+  xhrFields          : undefined,
+  url                : undefined,
+  urlParams          : undefined, // hash of URL params
+  urlParamsGenerator : function () { return {}; }, // function to return URL params (only used if urlParams property is falsy)
+  data               : undefined, // if defined, will be used instead of fetching data from a source
+  dataRequestLimit   : undefined, // if defined, multiple requests will be made by getData if the region size exceeds its value
+  showServerErrors   : false,     // if true, error messages return from the server by getData requests will be shown on the track
+
+  constructor: function (properties) {
+    $.extend(this, properties);
+    Genoverse.wrapFunctions(this);
+    this.init();
+  },
+
+  init: function (reset) {
+    this.setDefaults(reset);
+
+    if (reset) {
+      for (var i in this.featuresById) {
+        delete this.featuresById[i].position;
+      }
+    }
+
+    if (!reset || this.data) {
+      delete this.dataRangesByChr;
+      delete this.featuresByChr;
+      this.featuresById = {};
+      this.setChrProps();
+    }
+
+    this.dataLoading = []; // tracks incomplete requests for data
+  },
+
+  setDefaults: function (reset) {
+    this.dataBuffer = this.dataBuffer || { start: 0, end: 0 };      // basepairs to extend data region for, when getting data from the origin
+    this.urlParams  = this.urlParams  || this.urlParamsGenerator(); // hash of URL params
+    this.xhrFields  = this.xhrFields  || {};
+
+    this.dataBufferStart = this.dataBuffer.start; // Remember original dataBuffer.start, since dataBuffer.start is updated based on browser scale, in setLabelBuffer
+
+    if (!this._url) {
+      this._url = this.url; // Remember original url
+    }
+
+    if (reset && !this.url && this._url) {
+      this.url = this._url;
+    }
+  },
+
+  setChrProps: function () {
+    var chr = this.browser.chr;
+
+    this.dataRangesByChr = this.dataRangesByChr || {};
+    this.featuresByChr   = this.featuresByChr   || {};
+
+    this.dataRangesByChr[chr] = this.dataRangesByChr[chr] || new RTree();
+    this.featuresByChr[chr]   = this.featuresByChr[chr]   || new RTree();
+  },
+
+  features   : function (chr) { return this.featuresByChr[chr];   },
+  dataRanges : function (chr) { return this.dataRangesByChr[chr]; },
+
+  parseURL: function (chr, start, end, url) {
+    if (this.allData) {
+      start = 1;
+      end   = this.browser.getChromosomeSize(chr);
+    }
+
+    return (url || this.url).replace(/__ASSEMBLY__/, this.browser.assembly).replace(/__CHR__/, chr).replace(/__START__/, start).replace(/__END__/, end);
+  },
+
+  setLabelBuffer: function (buffer) {
+    this.dataBuffer.start = Math.max(this.dataBufferStart, buffer);
+  },
+
+  getData: function (chr, start, end, done) {
+    start = Math.max(1, start);
+    end   = Math.min(this.browser.getChromosomeSize(chr), end);
+
+    var deferred = $.Deferred();
+
+    if (typeof this.data !== 'undefined') {
+      this.receiveData(typeof this.data.sort === 'function' ? this.data.sort(function (a, b) { return a.start - b.start; }) : this.data, chr, start, end);
+      return deferred.resolveWith(this);
+    }
+
+    var model  = this;
+    var bins   = [];
+    var length = end - start + 1;
+
+    if (!this.url) {
+      return deferred.resolveWith(this);
+    }
+
+    if (this.dataRequestLimit && length > this.dataRequestLimit) {
+      var i = Math.ceil(length / this.dataRequestLimit);
+
+      while (i--) {
+        bins.push([ start, i ? start += this.dataRequestLimit - 1 : end ]);
+        start++;
+      }
+    } else {
+      bins.push([ start, end ]);
+    }
+
+    $.when.apply($, $.map(bins, function (bin) {
+      var request = $.ajax({
+        url       : model.parseURL(chr, bin[0], bin[1]),
+        data      : model.urlParams,
+        dataType  : model.dataType,
+        context   : model,
+        xhrFields : model.xhrFields,
+        success   : function (data) {
+          this.receiveData(data, chr, bin[0], bin[1]);
+        },
+        error: function (xhr, statusText) {
+          this.track.controller.showError(
+            this.showServerErrors && (xhr.responseJSON || {}).message
+              ? xhr.responseJSON.message
+              : statusText + ' while getting the data, see console for more details',
+            arguments
+          );
+        },
+        complete: function (xhr) {
+          this.dataLoading = $.grep(this.dataLoading, function (t) { return xhr !== t; });
+        }
+      });
+
+      request.coords = [ chr, bin[0], bin[1] ]; // store actual chr, start and end on the request, in case they are needed
+
+      if (typeof done === 'function') {
+        request.done(done);
+      }
+
+      model.dataLoading.push(request);
+
+      return request;
+    })).done(function () { deferred.resolveWith(model); });
+
+    return deferred;
+  },
+
+  receiveData: function (data, chr, start, end) {
+    start = Math.max(start, 1);
+    end   = Math.min(end, this.browser.getChromosomeSize(chr));
+
+    this.setDataRange(chr, start, end);
+    this.parseData(data, chr, start, end);
+
+    if (this.allData) {
+      this.url = false;
+    }
+  },
+
+  /**
+  * parseData(data, chr, start, end) - parse raw data from the data source (e.g. online web service)
+  * extract features and insert it into the internal features storage (RTree)
+  *
+  * >> data  - raw data from the data source (e.g. ajax response)
+  * >> chr   - chromosome of the data
+  * >> start - start location of the data
+  * >> end   - end   location of the data
+  * << nothing
+  *
+  * every feature extracted this routine must construct a hash with at least 3 values:
+  *  {
+  *    id    : [unique feature id, string],
+  *    start : [chromosomal start position, integer],
+  *    end   : [chromosomal end position, integer],
+  *    [other optional key/value pairs]
+  *  }
+  *
+  * and call this.insertFeature(feature)
+  */
+  parseData: function (data, chr, start) { // end is also passed in, but not used in this case
+    var feature;
+
+    // Example of parseData function when data is an array of hashes like { start: ..., end: ... }
+    for (var i = 0; i < data.length; i++) {
+      feature = data[i];
+
+      feature.chr  = feature.chr || chr;
+      feature.sort = start + i;
+
+      this.insertFeature(feature);
+    }
+  },
+
+  updateData: function (data) {
+    this.data = data;
+    this.track.reset();
+  },
+
+  setDataRange: function (chr, start, end) {
+    if (this.allData) {
+      start = 1;
+      end   = this.browser.getChromosomeSize(chr);
+    }
+
+    this.dataRanges(chr).insert({ x: start, w: end - start + 1, y: 0, h: 1 }, [ start, end ]);
+  },
+
+  checkDataRange: function (chr, start, end) {
+    start = Math.max(1, start);
+    end   = Math.min(this.browser.getChromosomeSize(chr), end);
+
+    var ranges = this.dataRanges(chr).search({ x: start, w: end - start + 1, y: 0, h: 1 }).sort(function (a, b) { return a[0] - b[0]; });
+
+    if (!ranges.length) {
+      return false;
+    }
+
+    var s = ranges.length === 1 ? ranges[0][0] : 9e99;
+    var e = ranges.length === 1 ? ranges[0][1] : -9e99;
+
+    for (var i = 0; i < ranges.length - 1; i++) {
+      // s0 <= s1 && ((e0 >= e1) || (e0 + 1 >= s1))
+      if (ranges[i][0] <= ranges[i + 1][0] && ((ranges[i][1] >= ranges[i + 1][1]) || (ranges[i][1] + 1 >= ranges[i + 1][0]))) {
+        s = Math.min(s, ranges[i][0]);
+        e = Math.max(e, ranges[i][1], ranges[i + 1][1]);
+      } else {
+        return false;
+      }
+    }
+
+    return start >= s && end <= e;
+  },
+
+  insertFeature: function (feature) {
+    if (!feature.chr) {
+      return;
+    }
+
+    // Make sure we have a unique ID, this method is not efficient, so better supply your own id
+    if (!feature.id) {
+      feature.id = feature.ID || this.hashCode(JSON.stringify($.extend({}, feature, { sort: '' }))); // sort is dependant on the browser's region, so will change on zoom
+    }
+
+    var features = this.features(feature.chr);
+
+    if (features && !this.featuresById[feature.id]) {
+      if (feature.subFeatures) {
+        feature.subFeatures.sort(function (a, b) { return a.start - b.start; });
+
+        for (var i = 0; i < feature.subFeatures.length; i++) {
+          feature.subFeatures[i].start = Math.min(Math.max(feature.subFeatures[i].start, feature.start), feature.end);
+          feature.subFeatures[i].end   = Math.max(Math.min(feature.subFeatures[i].end,   feature.end),   feature.start);
+        }
+
+        // Add "fake" sub-features at the start and end of the feature - this will allow joins to be drawn when there are no sub-features in the current region.
+        feature.subFeatures.unshift({ start: feature.start, end: feature.start, fake: true });
+        feature.subFeatures.push({    start: feature.end,   end: feature.end,   fake: true });
+      }
+
+      features.insert({ x: feature.start, y: 0, w: feature.end - feature.start + 1, h: 1 }, feature);
+      this.featuresById[feature.id] = feature;
+    }
+  },
+
+  findFeatures: function (chr, start, end) {
+    var features = this.features(chr).search({ x: start - this.dataBuffer.start, y: 0, w: end - start + this.dataBuffer.start + this.dataBuffer.end + 1, h: 1 });
+    var filters  = this.prop('featureFilters') || [];
+
+    for (var i = 0; i < filters.length; i++) {
+      features = $.grep(features, $.proxy(filters[i], this));
+    }
+
+    return this.sortFeatures(features);
+  },
+
+  sortFeatures: function (features) {
+    return features.sort(function (a, b) { return a.sort - b.sort; });
+  },
+
+  abort: function () {
+    for (var i = 0; i < this.dataLoading.length; i++) {
+      this.dataLoading[i].abort();
+    }
+
+    this.dataLoading = [];
+  },
+
+  hashCode: function (string) {
+    var hash = 0;
+    var c;
+
+    if (!string.length) {
+      return hash;
+    }
+
+    for (var i = 0; i < string.length; i++) {
+      c     = string.charCodeAt(i);
+      hash  = ((hash << 5) - hash) + c;
+      hash &= hash; // Convert to 32bit integer
+    }
+
+    return '' + hash;
+  }
+});

package/js/Track/View/Gene/Ensembl.js

@@ -0,0 +1,46 @@
+Genoverse.Track.View.Gene.Ensembl = Genoverse.Track.View.Gene.extend({
+  setFeatureColor: function (feature) {
+    var processedTranscript = {
+      'sense_intronic'           : 1,
+      'sense_overlapping'        : 1,
+      'processed_transcript'     : 1,
+      'nonsense_mediated_decay'  : 1,
+      'non_stop_decay'           : 1,
+      'antisense'                : 1,
+      'retained_intron'          : 1,
+      'tec'                      : 1,
+      'non_coding'               : 1,
+      'ambiguous_orf'            : 1,
+      'disrupted_domain'         : 1,
+      '3prime_overlapping_ncrna' : 1
+    };
+
+    feature.color = '#000000';
+
+    if (feature.logic_name.indexOf('ensembl_havana') === 0) {
+      feature.color      = '#CD9B1D';
+      feature.labelColor = '#B78000';
+      feature.legend     = 'Merged Ensembl/Havana';
+    } else if (processedTranscript[feature.biotype.toLowerCase()]) {
+      feature.color  = '#0000FF';
+      feature.legend = 'Processed transcript';
+    } else if (feature.biotype === 'protein_coding') {
+      feature.color  = '#A00000';
+      feature.legend = 'Protein coding';
+    } else if (feature.biotype.indexOf('pseudogene') > -1) {
+      feature.color  = '#666666';
+      feature.legend = 'Pseudogene';
+    } else if (/rna/i.test(feature.biotype) || feature.biotype === 'ribozyme') {
+      feature.color  = '#8B668B';
+      feature.legend = 'RNA gene';
+    } else if (/^tr_.+_gene$/i.test(feature.biotype)) {
+      feature.color  = '#CD6600';
+      feature.legend = 'TR gene';
+    } else if (/^ig_.+_gene$/i.test(feature.biotype)) {
+      feature.color  = '#8B4500';
+      feature.legend = 'IG gene';
+    }
+
+    feature.labelColor = feature.labelColor || feature.color;
+  }
+});

package/js/Track/View/Gene.js

@@ -0,0 +1,6 @@
+Genoverse.Track.View.Gene = Genoverse.Track.View.extend({
+  featureHeight : 5,
+  labels        : true,
+  repeatLabels  : true,
+  bump          : true
+});

package/js/Track/View/Sequence/Variation.js

@@ -0,0 +1,115 @@
+Genoverse.Track.View.SequenceVariation = Genoverse.Track.View.Sequence.extend({
+  featureHeight : 15,
+  featureMargin : { top: 0, right: 0, bottom: 4, left: 0 },
+  bump          : true,
+  showLegend    : false,
+
+  positionFeature: function (feature, params) {
+    var position = feature.position[params.scale];
+
+    if (feature.alt_allele) {
+      if (!position.positioned) {
+        position.reference = { end: position.start + feature.ref_allele.length * params.scale };
+      }
+
+      position.reference.x = position.reference.end - params.scaledStart;
+    }
+
+    this.base(feature, params);
+  },
+
+  bumpFeature: function (bounds, feature) {
+    if (feature.alt_allele) {
+      this.base.apply(this, arguments);
+    }
+  },
+
+  draw: function (features, featureContext, labelContext, scale) {
+    var drawing = { seq: [], snv: [] };
+
+    for (var i = 0; i < features.length; i++) {
+      drawing[features[i].alt_allele ? 'snv' : 'seq'].push(features[i]);
+    }
+
+    this.base(drawing.seq, featureContext, labelContext, scale);
+    this.highlightSNVs(drawing.snv, featureContext, scale);
+    this.base(drawing.snv, featureContext, labelContext, scale);
+    this.outlineSNVs(drawing.snv, featureContext, scale); // Redraw the outline for SNVs, since the feature will have been drawn on top of some of the outline created by highlightSNVs
+  },
+
+  highlightSNVs: function (features, context, scale) {
+    var position, positionX, positionY;
+
+    for (var i = 0; i < features.length; i++) {
+      position  = features[i].position[scale];
+      positionX = [ position.X, position.reference.x, position.X + position.width ];
+
+      if (positionX[2] < 0 || positionX[0] > this.width) {
+        continue;
+      }
+
+      if (positionX[0] < 0 || positionX[2] > this.width) {
+        this.truncateForDrawing(positionX);
+      }
+
+      positionY = [ 0, position.Y - this.featureMargin.bottom / 2, position.Y, position.Y + this.featureHeight ];
+
+      if (!features[i].highlightColor) {
+        this.setHighlightColor(features[i]);
+      }
+
+      context.strokeStyle = context.fillStyle = features[i].highlightColor;
+      context.lineWidth   = 2;
+
+      context.beginPath();
+      context.moveTo(positionX[0], positionY[0]);
+      context.lineTo(positionX[1], positionY[0]);
+      context.lineTo(positionX[1], positionY[1]);
+      context.lineTo(positionX[2], positionY[2]);
+      context.lineTo(positionX[2], positionY[3]);
+      context.lineTo(positionX[0], positionY[3]);
+      context.closePath();
+      context.stroke();
+
+      context.lineWidth   = 1;
+      context.globalAlpha = 0.5;
+
+      context.fill();
+
+      context.globalAlpha = 1;
+    }
+  },
+
+  outlineSNVs: function (features, context, scale) {
+    var position, positionX, positionY;
+
+    for (var i = 0; i < features.length; i++) {
+      position  = features[i].position[scale];
+      positionX = [ position.X, position.X + position.width ];
+      positionY = [ position.Y, position.Y + this.featureHeight ];
+
+      context.strokeStyle = features[i].highlightColor;
+
+      context.lineWidth = 2;
+
+      context.beginPath();
+      context.moveTo(positionX[1], positionY[0]);
+      context.lineTo(positionX[1], positionY[1]);
+      context.lineTo(positionX[0], positionY[1]);
+      context.lineTo(positionX[0], positionY[0]);
+      context.stroke();
+
+      context.lineWidth = 1;
+    }
+  },
+
+  truncateForDrawing: function (positionX) {
+    for (var i in positionX) {
+      positionX[i] = Math.min(Math.max(positionX[i], -1), this.width + 1);
+    }
+  },
+
+  setHighlightColor: function (feature) {
+    feature.highlightColor = feature.alt_allele === '-' || feature.alt_allele.length < feature.ref_allele.length ? '#D31D00' : '#1DD300';
+  }
+});

package/js/Track/View/Sequence.js

@@ -0,0 +1,63 @@
+Genoverse.Track.View.Sequence = Genoverse.Track.View.extend({
+  featureMargin : { top: 0, right: 0, bottom: 0, left: 0 },
+  colors        : { 'default': '#CCCCCC', A: '#73E973', T: '#DE4C61', G: '#FFFF77', C: '#688EC0' },
+  labelColors   : { 'default': '#000000', T: '#FFFFFF', C: '#FFFFFF' },
+  labels        : 'overlay',
+
+  setDefaults: function () {
+    this.base.apply(this, arguments);
+
+    var lowerCase = this.prop('lowerCase');
+    var key;
+
+    this.labelYOffset = typeof this.labelYOffset === 'number' ? this.labelYOffset : (this.featureHeight + 1) / 2;
+    this.widestLabel  = typeof this.widestLabel  === 'string' ? this.widestLabel : lowerCase ? 'g' : 'G';
+    this.labelWidth   = {};
+
+    this.labelWidth[this.widestLabel] = Math.ceil(this.context.measureText(this.widestLabel).width) + 1;
+
+    if (lowerCase) {
+      for (key in this.colors) {
+        this.colors[key.toLowerCase()] = this.colors[key];
+      }
+
+      for (key in this.labelColors) {
+        this.labelColors[key.toLowerCase()] = this.labelColors[key];
+      }
+    }
+  },
+
+  draw: function (features, featureContext, labelContext, scale) {
+    featureContext.textBaseline = 'middle';
+    featureContext.textAlign    = 'center';
+
+    var width = Math.max(scale, this.minScaledWidth);
+
+    for (var i = 0; i < features.length; i++) {
+      this.drawSequence(features[i], featureContext, scale, width);
+    }
+  },
+
+  drawSequence: function (feature, context, scale, width) {
+    var drawLabels = this.labelWidth[this.widestLabel] < width - 1;
+    var start, bp;
+
+    for (var i = 0; i < feature.sequence.length; i++) {
+      start = feature.position[scale].X + i * scale;
+
+      if (start < -scale || start > context.canvas.width) {
+        continue;
+      }
+
+      bp = feature.sequence.charAt(i);
+
+      context.fillStyle = this.colors[bp] || this.colors.default;
+      context.fillRect(start, feature.position[scale].Y, width, this.featureHeight);
+
+      if (drawLabels) {
+        context.fillStyle = this.labelColors[bp] || this.labelColors.default;
+        context.fillText(bp, start + (width / 2), feature.position[scale].Y + this.labelYOffset);
+      }
+    }
+  }
+});

package/js/Track/View/Transcript/Ensembl.js

@@ -0,0 +1,12 @@
+Genoverse.Track.View.Transcript.Ensembl = Genoverse.Track.View.Transcript.extend({
+  setFeatureColor: function (feature) {
+    Genoverse.Track.View.Gene.Ensembl.prototype.setFeatureColor(feature);
+
+    for (var i = 0; i < (feature.subFeatures || []).length; i++) {
+      if (feature.subFeatures[i].utr) {
+        feature.subFeatures[i].color       = false;
+        feature.subFeatures[i].borderColor = feature.color;
+      }
+    }
+  }
+});

package/js/Track/View/Transcript.js

@@ -0,0 +1,28 @@
+Genoverse.Track.View.Transcript = Genoverse.Track.View.extend({
+  featureHeight       : 12,
+  utrHeight           : 7,
+  labels              : true,
+  repeatLabels        : true,
+  bump                : true,
+  subFeatureJoinStyle : 'curve',
+
+  scaleFeatures: function (features, scale) {
+    var subFeatures, j;
+
+    for (var i = 0; i < features.length; i++) {
+      subFeatures = features[i].subFeatures || [];
+
+      if (subFeatures.length) {
+        for (j = 0; j < subFeatures.length; j++) {
+          if (subFeatures[j].utr) {
+            subFeatures[j].height = this.utrHeight;
+          }
+        }
+
+        features[i].height = Math.max.apply(Math, subFeatures.map(function (c) { return c.fake ? 0 : c.height || 0; }).concat(this.featureHeight));
+      }
+    }
+
+    return this.base(features, scale);
+  }
+});