genoverse 3.2.0

package/js/Track/library/Scalebar.js

@@ -0,0 +1,227 @@
+Genoverse.Track.Scalebar = Genoverse.Track.extend({
+  unsortable     : true,
+  fixedOrder     : true,
+  order          : 0,
+  orderReverse   : 1e5,
+  featureStrand  : 1,
+  controls       : 'off',
+  height         : 20,
+  featureHeight  : 3,
+  featureMargin  : { top: 0, right: 0, bottom: 2, left: 0 },
+  margin         : 0,
+  minPixPerMajor : 100, // Least number of pixels per written number
+  color          : '#000000',
+  autoHeight     : false,
+  labels         : true,
+  bump           : false,
+  resizable      : false,
+  click          : $.noop,
+  colors         : {
+    majorGuideLine : '#CCCCCC',
+    minorGuideLine : '#E5E5E5'
+  },
+
+  setEvents: function () {
+    var browser = this.browser;
+
+    function resize() {
+      $('.gv-bg.gv-full-height', browser.container).height(function () {
+        return browser.wrapper.outerHeight(true) - $(this).parents('.gv-track-container').position().top;
+      });
+    }
+
+    browser.on('afterAddTracks', resize);
+    browser.on('afterResize', this, resize);
+  },
+
+  setScale: function () {
+    var max       = this.prop('width') / this.prop('minPixPerMajor');
+    var divisor   = 5;
+    var majorUnit = -1;
+    var fromDigit = ('' + this.browser.start).split(''); // Split into array of digits
+    var toDigit   = ('' + this.browser.end).split('');
+    var features  = {};
+    var divisions, i;
+
+    for (i = fromDigit.length; i < toDigit.length; i++) {
+      fromDigit.unshift('0');
+    }
+
+    for (i = toDigit.length; i < fromDigit.length; i++) {
+      toDigit.unshift('0');
+    }
+
+    // How many divisions would there be if we only kept i digits?
+    for (i = 0; i < fromDigit.length; i++) {
+      divisions = parseInt(toDigit.slice(0, fromDigit.length - i).join(''), 10) - parseInt(fromDigit.slice(0, fromDigit.length - i).join(''), 10);
+
+      if (divisions && divisions <= max) {
+        majorUnit = parseInt('1' + $.map(new Array(i), function () { return '0'; }).join(''), 10);
+        break;
+      }
+    }
+
+    if (majorUnit === -1) {
+      majorUnit = this.browser.length === 1 ? 1 : parseInt('1' + $.map(new Array(fromDigit.length), function () { return '0'; }).join(''), 10);
+      divisor   = 1;
+    } else if (divisions * 5 <= max) { // Improve things by trying simple multiples of 1<n zeroes>. (eg if 100 will fit will 200, 400, 500).
+      majorUnit /= 5;
+      divisor    = 2;
+    } else if (divisions * 4 <= max) {
+      majorUnit /= 4;
+      divisor    = 1;
+    } else if (divisions * 2 <= max) {
+      majorUnit /= 2;
+    }
+
+    majorUnit = Math.max(majorUnit, 1);
+
+    features[this.browser.chr] = new RTree();
+
+    this.prop('minorUnit',     Math.max(majorUnit / divisor, 1));
+    this.prop('majorUnit',     majorUnit);
+    this.prop('featuresByChr', features);
+    this.prop('featuresById',  {});
+    this.prop('seen',          {});
+
+    this.base();
+  },
+
+  setFeatures: function (chr, start, end) {
+    var minorUnit = this.prop('minorUnit');
+    var majorUnit = this.prop('majorUnit');
+    var seen      = this.prop('seen');
+
+    start = Math.max(start - (start % minorUnit) - majorUnit, 0);
+
+    var flip = (start / minorUnit) % 2 ? 1 : -1;
+    var feature, major, label;
+
+    for (var x = start; x < end + minorUnit; x += minorUnit) {
+      flip *= -1;
+
+      if (seen[x]) {
+        continue;
+      }
+
+      seen[x] = 1;
+
+      feature = { id: chr + ':' + x, chr: chr, strand: 1, sort: x };
+      major   = x && x % majorUnit === 0;
+
+      if (flip === 1) {
+        feature.start = x;
+        feature.end   = x + minorUnit - 1;
+      }
+
+      if (major) {
+        label = this.view.formatLabel(x);
+
+        if (label !== this.lastLabel) {
+          feature.label = label;
+
+          if (!feature.end) {
+            feature.start = x;
+            feature.end   = x - 1;
+          }
+        }
+
+        this.lastLabel = label;
+      }
+
+      if (feature.end) {
+        this.model.insertFeature(feature);
+      }
+    }
+  },
+
+  makeFirstImage: function (moveTo) {
+    if (this.prop('strand') === -1) {
+      moveTo = this.track.forwardTrack.prop('scrollStart');
+    }
+
+    return this.base(moveTo);
+  },
+
+  makeImage: function (params) {
+    params.background    = 'gv-guidelines gv-full-height';
+    params.featureHeight = this.prop('height');
+
+    this.track.setFeatures(params.chr, params.start, params.end);
+
+    var rtn = this.base(params);
+
+    params.container.addClass('gv-full-height');
+
+    return rtn;
+  },
+
+  makeReverseImage: function (params) {
+    this.imgContainers.push(params.container.clone().html(params.container.children('.gv-data').clone(true).css({ opacity: 1, background: this.browser.wrapper.css('backgroundColor') }))[0]);
+    this.scrollContainer.append(this.imgContainers);
+  },
+
+  renderBackground: function (f, bgImage) {
+    this.base(f, bgImage);
+    bgImage.height(this.browser.wrapper.outerHeight(true));
+  },
+
+  draw: function (features, featureContext, labelContext, scale) {
+    var i         = features.length;
+    var minorUnit = this.prop('minorUnit');
+    var width     = Math.ceil(minorUnit * scale);
+    var feature, start, end;
+
+    featureContext.textBaseline = 'top';
+    featureContext.fillStyle    = this.color;
+
+    this.guideLines = { major: {} }; // FIXME: pass params to draw, rather than scale. set guideLines on params
+
+    while (i--) {
+      feature = features[i];
+      start   = Math.round(feature.position[scale].X);
+      end     = start + width - 1;
+
+      this.drawFeature($.extend({}, feature, {
+        x      : start,
+        y      : 0,
+        width  : Math.ceil(feature.position[scale].width),
+        height : this.featureHeight
+      }), featureContext, labelContext, scale);
+
+      if (feature.label) {
+        if (start > -1) {
+          featureContext.fillRect(start, this.featureHeight, 1, this.featureHeight);
+        }
+
+        this.guideLines.major[feature.start] = true;
+      }
+
+      // Fiddle the location so that these [additional major] lines overlap with normal lines
+      if (feature.end < feature.start) {
+        start--;
+        end++;
+      }
+
+      this.guideLines[feature.start]             = start;
+      this.guideLines[feature.start + minorUnit] = end;
+    }
+
+    featureContext.fillRect(0, 0, featureContext.canvas.width, 1);
+    featureContext.fillRect(0, this.featureHeight, featureContext.canvas.width, 1);
+  },
+
+  // Draw guidelines
+  drawBackground: function (f, context) {
+    for (var i in this.guideLines) {
+      if (this.guideLines[i] >= 0 && this.guideLines[i] <= this.width) {
+        context.fillStyle = this.track.colors[this.guideLines.major[i] ? 'majorGuideLine' : 'minorGuideLine'];
+        context.fillRect(this.guideLines[i], 0, 1, context.canvas.height);
+      }
+    }
+  },
+
+  formatLabel: function (label) {
+    return this.prop('minorUnit') < 1000 ? label.toString().replace(/(\d)(?=(\d\d\d)+(?!\d))/g, '$1,') : this.base(label);
+  }
+});

package/js/Track/library/Scaleline.js

@@ -0,0 +1,91 @@
+Genoverse.Track.Scaleline = Genoverse.Track.Static.extend({
+  strand     : 1,
+  color      : '#000000',
+  height     : 12,
+  labels     : 'overlay',
+  unsortable : true,
+  fixedOrder : true,
+  arrowWidth : 7,
+
+  resize: $.noop,
+
+  makeFirstImage: function () {
+    this.prop('scaleline', false);
+    this.base.apply(this, arguments);
+  },
+
+  render: function (f, img) {
+    this.base(f, img);
+    this.prop('drawnScale', img.data('scale'));
+  },
+
+  positionFeatures: function (features, params) {
+    var scaleline = this.prop('scaleline');
+
+    if (params.scale === this.drawnScale) {
+      return false;
+    }
+
+    if (scaleline) {
+      return scaleline;
+    }
+
+    var strand     = this.prop('strand');
+    var height     = this.prop('height');
+    var text       = this.formatLabel(this.browser.length);
+    var width      = this.context.measureText(text).width;
+    var textMargin = 10; // 5px each side
+    var y          = height / 2;
+    var x1         = 0;
+    var x2         = (this.width - width - textMargin) / 2;
+
+    if (strand) {
+      var strandText  = strand === 1 ? 'Forward strand' : 'Reverse strand';
+      var strandWidth = this.context.measureText(strandText).width;
+      var x3          = (
+        strand === 1
+          ? this.width - this.prop('arrowWidth') - strandWidth - (1.5 * textMargin)
+          : this.prop('arrowWidth') + (0.5 * textMargin)
+      );
+
+      scaleline = [
+        { x: x1, y: y, width: this.width,               height: 1, decorations: true },
+        { x: x2, y: 0, width: width       + textMargin, height: height, clear: true, color: false, labelColor: this.color, labelWidth: width,       label: text       },
+        { x: x3, y: 0, width: strandWidth + textMargin, height: height, clear: true, color: false, labelColor: this.color, labelWidth: strandWidth, label: strandText }
+      ];
+    } else {
+      scaleline = [
+        { x: x1, y: y, width: this.width,         height: 1, decorations: true },
+        { x: x2, y: 0, width: width + textMargin, height: height, clear: true, color: false, labelColor: this.color, labelWidth: width, label: text }
+      ];
+    }
+
+    return this.base(this.prop('scaleline', scaleline), params);
+  },
+
+  decorateFeature: function (feature, context) {
+    var strand     = this.prop('strand');
+    var height     = this.prop('height');
+    var arrowWidth = this.prop('arrowWidth');
+    var width      = this.width;
+
+    context.strokeStyle = this.color;
+
+    [ -1, 1 ].filter(
+      function (dir) { return strand ? dir === strand : true; }
+    ).forEach(
+      function (dir) {
+        var x1 = dir === 1 ? width - arrowWidth : arrowWidth;
+        var x2 = x1 + (dir * arrowWidth);
+
+        context.beginPath();
+        context.moveTo(x1, height * 0.25);
+        context.lineTo(x2, height * 0.5);
+        context.lineTo(x1, height * 0.75);
+        context.closePath();
+        context.stroke();
+        context.fill();
+      }
+    );
+  }
+});

package/js/Track/library/Static.js

@@ -0,0 +1,78 @@
+Genoverse.Track.Controller.Static = Genoverse.Track.Controller.extend({
+  addDomElements: function () {
+    this.base();
+
+    this.image = $('<img>').appendTo(this.imgContainer);
+
+    this.container.toggleClass('gv-track-container gv-track-container-static').prepend(this.imgContainer);
+    this.scrollContainer.add(this.messageContainer).remove();
+  },
+
+  reset: function () {
+    delete this.stringified;
+    this.base.apply(this, arguments);
+  },
+
+  setWidth: function (width) {
+    this.base(width);
+    this.image.width = this.width;
+  },
+
+  makeFirstImage: function () {
+    this.base.apply(this, arguments);
+    this.container.css('left', 0);
+    this.imgContainer.show();
+  },
+
+  makeImage: function (params) {
+    if (this.prop('disabled')) {
+      return $.Deferred().resolve();
+    }
+
+    var features = this.view.positionFeatures(this.model.findFeatures(params.chr, params.start, params.end), params);
+
+    if (features) {
+      var string = JSON.stringify(features);
+
+      if (this.stringified !== string) {
+        var height = this.prop('height');
+
+        params.width         = this.width;
+        params.featureHeight = height;
+
+        this.render(features, this.image.data(params));
+        this.imgContainer.children(':last').show();
+        this.resize(height, undefined, false);
+
+        this.stringified = string;
+      }
+    }
+
+    return $.Deferred().resolve();
+  }
+});
+
+Genoverse.Track.Model.Static = Genoverse.Track.Model.extend({
+  url            : false,
+  checkDataRange : function () { return true; }
+});
+
+Genoverse.Track.View.Static = Genoverse.Track.View.extend({
+  featureMargin   : { top: 0, right: 1, bottom: 0, left: 1 },
+  positionFeature : $.noop,
+  scaleFeatures   : function (features) { return features; },
+
+  draw: function (features, featureContext, labelContext, scale) {
+    for (var i = 0; i < features.length; i++) {
+      this.drawFeature(features[i], featureContext, labelContext, scale);
+    }
+  }
+});
+
+Genoverse.Track.Static = Genoverse.Track.extend({
+  controls   : 'off',
+  resizable  : false,
+  controller : Genoverse.Track.Controller.Static,
+  model      : Genoverse.Track.Model.Static,
+  view       : Genoverse.Track.View.Static
+});

package/js/Track/library/dbSNP.js

@@ -0,0 +1,142 @@
+Genoverse.Track.dbSNP = Genoverse.Track.extend({
+  id               : 'dbSNP',
+  name             : 'dbSNP',
+  info             : 'All sequence variants from the database of Single Nucleotide Polymorphisms (dbSNP)',
+  url              : '//rest.ensembl.org/overlap/region/human/__CHR__:__START__-__END__?feature=variation;content-type=application/json',
+  dataRequestLimit : 5000000, // As per e! REST API restrictions
+  threshold        : 1e5,
+  labels           : false,
+  legend           : true,
+  autoHeight       : true,
+  colorMap         : {
+    transcript_ablation                : '#ff0000',
+    splice_acceptor_variant            : '#FF581A',
+    splice_donor_variant               : '#FF581A',
+    stop_gained                        : '#ff0000',
+    frameshift_variant                 : '#9400D3',
+    stop_lost                          : '#ff0000',
+    start_lost                         : '#ffd700',
+    transcript_amplification           : '#ff69b4',
+    inframe_insertion                  : '#ff69b4',
+    inframe_deletion                   : '#ff69b4',
+    missense_variant                   : '#ffd700',
+    protein_altering_variant           : '#FF0080',
+    splice_region_variant              : '#ff7f50',
+    incomplete_terminal_codon_variant  : '#ff00ff',
+    stop_retained_variant              : '#76ee00',
+    synonymous_variant                 : '#76ee00',
+    coding_sequence_variant            : '#458b00',
+    mature_miRNA_variant               : '#458b00',
+    '5_prime_UTR_variant'              : '#7ac5cd',
+    '3_prime_UTR_variant'              : '#7ac5cd',
+    non_coding_transcript_exon_variant : '#32cd32',
+    intron_variant                     : '#02599c',
+    NMD_transcript_variant             : '#ff4500',
+    non_coding_transcript_variant      : '#32cd32',
+    upstream_gene_variant              : '#a2b5cd',
+    downstream_gene_variant            : '#a2b5cd',
+    TFBS_ablation                      : '#a52a2a',
+    TFBS_amplification                 : '#a52a2a',
+    TF_binding_site_variant            : '#a52a2a',
+    regulatory_region_ablation         : '#a52a2a',
+    regulatory_region_amplification    : '#a52a2a',
+    feature_elongation                 : '#7f7f7f',
+    regulatory_region_variant          : '#a52a2a',
+    feature_truncation                 : '#7f7f7f',
+    intergenic_variant                 : '#636363'
+  },
+
+  insertFeature: function (feature) {
+    feature.color  = this.prop('colorMap')[feature.consequence_type];
+    feature.legend = feature.consequence_type;
+
+    if (feature.start > feature.end) {
+      feature.decorations = true;
+    }
+
+    this.base(feature);
+  },
+
+  decorateFeature: function (feature, context, scale) {
+    context.fillStyle = feature.color;
+    context.beginPath();
+    context.moveTo(feature.position[scale].X - 3, feature.position[scale].Y + this.featureHeight);
+    context.lineTo(feature.position[scale].X,     feature.position[scale].Y + this.featureHeight - 4);
+    context.lineTo(feature.position[scale].X + 3, feature.position[scale].Y + this.featureHeight);
+    context.fill();
+
+    if (scale > 1) {
+      context.fillRect(feature.position[scale].X - 0.5, feature.position[scale].Y, 1.5, feature.position[scale].height);
+    }
+  },
+
+  populateMenu: function (feature) {
+    var deferred = $.Deferred();
+    var menu     = [{
+      title       : '<a href="https://www.ensembl.org/Homo_sapiens/Variation/Summary?v=' + feature.id + '" target="_blank">' + feature.id + '</a>',
+      Location    : feature.chr + ':' + feature.start + '-' + feature.end,
+      Consequence : feature.consequence_type,
+      Alleles     : feature.alleles.join(', ')
+    }];
+
+    $.ajax({
+      url      : '//rest.ensembl.org/variation/human/' + feature.id + '?population_genotypes=1;content-type=application/json',
+      dataType : 'json',
+      success  : function (data) {
+        var populationGenotypes = $.grep(data.population_genotypes, function (pop) { return /1000GENOMES.+ALL/.test(pop.population); }); // Only considering 1000 Genomes: ALL population
+        var frequencies         = {};
+        var pop, i, j;
+
+        if (populationGenotypes.length) {
+          for (i = 0; i < populationGenotypes.length; i++) {
+            pop           = populationGenotypes[i];
+            pop.frequency = parseFloat(pop.frequency, 10);
+            pop.count     = parseInt(pop.count, 10);
+
+            frequencies[pop.population] = frequencies[pop.population] || [];
+            frequencies[pop.population].push(pop);
+          }
+
+          for (i in frequencies) {
+            frequencies[i].sort(function (a, b) { return a.count < b.count; });
+
+            pop = {
+              title    : i + ' population genotypes',
+              Genotype : [ 'Frequency', 'Count' ],
+              start    : false,
+              end      : false
+            };
+
+            for (j in frequencies[i]) {
+              pop[frequencies[i][j].genotype] = [ (frequencies[i][j].frequency * 100).toFixed(2) + '%', frequencies[i][j].count ];
+            }
+
+            menu.push(pop);
+          }
+
+          pop = {
+            start : false,
+            end   : false
+          };
+
+          pop['<a href="https://www.ensembl.org/Homo_sapiens/Variation/Population?v=' + feature.id + '" target="_blank">See all population genotypes</a>'] = '';
+
+          menu.push(pop);
+        }
+
+        deferred.resolve(menu);
+      }
+    });
+
+    return deferred;
+  },
+
+  // Different settings for different zoom level
+  5000: { // more than 5k
+    bump: false
+  },
+  1: { // > 1 base-pair, but less then 5k
+    bump: true
+  }
+
+});