genoverse 3.2.0

package/js/Track/library/File/BAM.js

@@ -0,0 +1,30 @@
+Genoverse.Track.File.BAM = Genoverse.Track.File.extend({
+  name      : 'BAM',
+  indexExt  : '.bai',
+  threshold : 100000,
+  largeFile : true,
+  model     : Genoverse.Track.Model.File.BAM,
+  view      : Genoverse.Track.View.Sequence.extend({
+    bump       : true,
+    autoHeight : true
+  }),
+
+  click: function () {
+    var menu = this.base.apply(this, arguments);
+
+    if (menu) {
+      menu.addClass('gv-wrap-values');
+    }
+
+    return menu;
+  },
+
+  populateMenu: function (feature) {
+    var f = $.extend({ title: feature.readName }, feature);
+
+    delete f.sequence;
+    delete f.id;
+
+    return this.base(f);
+  }
+});

package/js/Track/library/File/BED.js

@@ -0,0 +1,24 @@
+Genoverse.Track.File.BED = Genoverse.Track.File.extend({
+  name                : 'BED',
+  model               : Genoverse.Track.Model.File.BED,
+  bump                : true,
+  featureHeight       : 10,
+  thickHeight         : 10,
+  thinHeight          : 7,
+  subFeatureJoinStyle : 'curve',
+
+  populateMenu: function (feature) {
+    var fields = [ false, false, false, 'name', 'score', 'strand', 'thickStart', 'thickEnd', 'itemRgb', 'blockCount', 'blockSizes', 'blockStarts' ]; // First three fields are chr, start, end which are covered by Location
+
+    return feature.originalFeature.reduce(function (menu, val, i) {
+      if (fields[i]) {
+        menu[fields[i]] = val;
+      }
+
+      return menu;
+    }, {
+      title    : '<a target="_blank" href="https://genome.ucsc.edu/FAQ/FAQformat.html#format1">BED feature details</a>',
+      Location : feature.chr + ':' + feature.start + '-' + feature.end
+    });
+  }
+});

package/js/Track/library/File/BIGBED.js

@@ -0,0 +1,47 @@
+Genoverse.Track.File.BIGBED = Genoverse.Track.File.BED.extend({
+  name  : 'bigbed',
+  model : Genoverse.Track.Model.File.BED.extend({
+    getData: function (chr, start, end) {
+      var model    = this;
+      var deferred = $.Deferred();
+
+      if (!this.bigbedFile) {
+        this.bigbedFile = this.bigbedFile || (this.url ? new dallianceLib.URLFetchable(this.url) : new dallianceLib.BlobFetchable(this.track.dataFile));
+      }
+
+      var d = $.Deferred().done(function () {
+        model.bwReader.getValues(chr, start, end, function (features, error) {
+          if (!error) {
+            features.sort(function (a, b) { return a.start - b.start; });
+
+            if (features.length) {
+              model.receiveData(features, chr, features[0].start, features[features.length - 1].end);
+            } else {
+              model.receiveData(features, chr, start, end);
+            }
+          }
+
+          deferred.resolveWith(model);
+        });
+      });
+
+      if (this.bwReader) {
+        d.resolve();
+      } else {
+        new BWReader(this.bigbedFile, function (bwReader) {
+          if (bwReader) {
+            model.bwReader = bwReader;
+            d.resolve();
+          } else {
+            model.receiveData([], chr, start, end);
+            return deferred.resolveWith(model);
+          }
+        });
+      }
+
+      return deferred;
+    }
+  })
+});
+
+Genoverse.Track.File.BB = Genoverse.Track.File.BIGBED;

package/js/Track/library/File/BIGWIG.js

@@ -0,0 +1,52 @@
+Genoverse.Track.File.BIGWIG = Genoverse.Track.Graph.Bar.extend({
+  name   : 'bigwig',
+  height : 100,
+
+  setDefaults: function () {
+    this.bwReader = null; // Not part of model since it needs to be shared between bar and line graphs
+    this.base.apply(this, arguments);
+  },
+
+  getData: function (chr, start, end) {
+    var model    = this;
+    var deferred = $.Deferred();
+
+    if (!this.bigwigFile) {
+      this.bigwigFile = this.bigwigFile || (this.url ? new dallianceLib.URLFetchable(this.url) : new dallianceLib.BlobFetchable(this.track.dataFile));
+    }
+
+    var d = $.Deferred().done(function () {
+      model.prop('bwReader').getValues(chr, start, end, function (features, error) {
+        if (!error) {
+          features.sort(function (a, b) { return a.start - b.start; });
+
+          if (features.length) {
+            model.receiveData(features, chr, features[0].start, features[features.length - 1].end);
+          } else {
+            model.receiveData(features, chr, start, end);
+          }
+        }
+
+        deferred.resolveWith(model);
+      });
+    });
+
+    if (this.prop('bwReader')) {
+      d.resolve();
+    } else {
+      new BWReader(this.bigwigFile, function (bwReader) {
+        if (bwReader) {
+          model.prop('bwReader', bwReader);
+          d.resolve();
+        } else {
+          model.receiveData([], chr, start, end);
+          return deferred.resolveWith(model);
+        }
+      });
+    }
+
+    return deferred;
+  }
+});
+
+Genoverse.Track.File.BW = Genoverse.Track.File.BIGWIG;

package/js/Track/library/File/GFF.js

@@ -0,0 +1,9 @@
+Genoverse.Track.File.GFF = Genoverse.Track.File.extend({
+  name          : 'GFF',
+  model         : Genoverse.Track.Model.File.GFF,
+  bump          : true,
+  height        : 100,
+  featureHeight : 5
+});
+
+Genoverse.Track.File.GTF = Genoverse.Track.File.GFF;

package/js/Track/library/File/VCF.js

@@ -0,0 +1,71 @@
+Genoverse.Track.File.VCF = Genoverse.Track.File.extend({
+  name       : 'VCF',
+  indexExt   : '.tbi',
+  model      : Genoverse.Track.Model.File.VCF,
+  autoHeight : false,
+  maxQual    : undefined, // Set this to the maximum value of the QUAL field in the file in order to color features by QUAL. Only required for large (tabix indexed) files - small ones can calculate this value automatically
+
+  afterSetMVC: function () {
+    if (this.prop('gz')) {
+      this.prop('threshold', 1e5);
+    }
+  },
+
+  populateMenu: function (feature) {
+    return {
+      title  : '<a target="_blank" href="https://www.internationalgenome.org/wiki/Analysis/vcf4.0">VCF feature details</a>',
+      CHROM  : feature.originalFeature[0],
+      POS    : feature.originalFeature[1],
+      ID     : feature.originalFeature[2],
+      REF    : feature.originalFeature[3],
+      ALT    : feature.originalFeature[4],
+      QUAL   : feature.originalFeature[5],
+      FILTER : feature.originalFeature[6],
+      INFO   : feature.originalFeature[7].split(';').join('<br />')
+    };
+  },
+
+  1: {
+    view: Genoverse.Track.View.Sequence.extend({
+      bump          : true,
+      labels        : false,
+      featureMargin : { top: 0, right: 0, bottom: 0, left: 0 },
+
+      draw: function (features, featureContext, labelContext, scale) {
+        this.base.apply(this, arguments);
+        this.highlightRef(features, featureContext, scale);
+      },
+
+      highlightRef: function (features, context, scale) {
+        context.strokeStyle = 'black';
+
+        for (var i = 0; i < features.length; i++) {
+          if (features[i].allele === 'REF') {
+            context.strokeRect(features[i].position[scale].X, features[i].position[scale].Y, features[i].position[scale].width, features[i].position[scale].height);
+          }
+        }
+      }
+    })
+  },
+
+  1000: {
+    view: Genoverse.Track.View.extend({
+      bump   : false,
+      labels : false,
+
+      drawFeature: function (feature) {
+        var maxQual = this.prop('maxQual');
+
+        if (maxQual && !feature.color) {
+          var heat  = Math.min(255, Math.floor((255 * (feature.originalFeature[5] || 0)) / maxQual)) - 127;
+          var red   = heat > 0 ? 255 : 127 + heat;
+          var green = heat < 0 ? 255 : 127 - heat;
+
+          feature.color = 'rgb(' + red + ',' + green + ',0)';
+        }
+
+        this.base.apply(this, arguments);
+      }
+    })
+  }
+});

package/js/Track/library/File/WIG.js

@@ -0,0 +1,5 @@
+Genoverse.Track.File.WIG = Genoverse.Track.Graph.Bar.extend({
+  model  : Genoverse.Track.Model.File.WIG,
+  name   : 'wig',
+  height : 100
+});

package/js/Track/library/File.js

@@ -0,0 +1,10 @@
+Genoverse.Track.File = Genoverse.Track.extend({
+  setInterface: function () {
+    this.base();
+
+    this._interface.isLocal   = 'model';
+    this._interface.dataFile  = 'model';
+    this._interface.indexFile = 'model';
+    this._interface.largeFile = 'model';
+  }
+});

package/js/Track/library/Gene.js

@@ -0,0 +1,37 @@
+Genoverse.Track.Gene = Genoverse.Track.extend({
+  id     : 'genes',
+  name   : 'Genes',
+  height : 200,
+  legend : true,
+
+  populateMenu: function (feature) {
+    var url  = 'https://www.ensembl.org/Homo_sapiens/' + (feature.feature_type === 'transcript' ? 'Transcript' : 'Gene') + '/Summary?' + (feature.feature_type === 'transcript' ? 't' : 'g') + '=' + feature.id;
+    var menu = {
+      title    : '<a target="_blank" href="' + url + '">' + (feature.external_name ? feature.external_name + ' (' + feature.id + ')' : feature.id) + '</a>',
+      Location : feature.chr + ':' + feature.start + '-' + feature.end,
+      Source   : feature.source,
+      Biotype  : feature.biotype
+    };
+
+    if (feature.feature_type === 'transcript') {
+      menu.Gene = '<a target="_blank" href="https://www.ensembl.org/Homo_sapiens/Gene/Summary?g=' + feature.Parent + '">' + feature.Parent + '</a>';
+    }
+
+    return menu;
+  },
+
+  // Different settings for different zoom level
+  2000000: { // This one applies when > 2M base-pairs per screen
+    labels: false
+  },
+  100000: { // more than 100K but less then 2M
+    labels : true,
+    model  : Genoverse.Track.Model.Gene.Ensembl,
+    view   : Genoverse.Track.View.Gene.Ensembl
+  },
+  1: { // > 1 base-pair, but less then 100K
+    labels : true,
+    model  : Genoverse.Track.Model.Transcript.Ensembl,
+    view   : Genoverse.Track.View.Transcript.Ensembl
+  }
+});

package/js/Track/library/Graph/Bar.js

@@ -0,0 +1,235 @@
+Genoverse.Track.Controller.Graph.Bar = {
+  getClickedFeatures: function (x, y) {
+    var yZero     = this.prop('marginTop') - (this.prop('range')[0] * this.track.getYScale());
+    var scale     = this.scale;
+    var tolerance = scale > 1 ? 0 : 1;
+
+    // Bars with negative values are stored in featurePositions with h < 0.
+    // While this works to a certain degree (fillRect allows negative height, drawing upwards from y), it makes them hard to search for in the RTree - to find such a feature you need to search with y = -h and h = y - h + 1
+    // It is therefore easier to search featuresByChr (i.e. the genomic positions) for a feature overlapping the x of the click, and then filter those results for y position manually.
+    var features = this.prop('featuresByChr')[this.browser.chr].search({
+      x : (x - (tolerance / 2)) / scale,
+      y : 0,
+      w : (1 + tolerance) / scale,
+      h : 1
+    });
+
+    if (features.length) {
+      if (
+        (y <  yZero && features.filter(function (f) { return f.position[scale].bounds.y + f.position[scale].bounds.h <= y && f.position[scale].bounds.y >= y; }).length === 0) ||
+        (y >= yZero && this.featurePositions.search({ x: x, y: y, w: 1, h: 1 }).length === 0)
+      ) {
+        features = [];
+      }
+    }
+
+    return features.length ? [ this.model.sortFeatures(features) ] : [];
+  },
+
+  populateMenu: function (features) {
+    if (!features.length) {
+      return [];
+    }
+
+    var start = features[0].start;
+    var end   = features[features.length - 1].end;
+    var avg   = features[0].start !== features[features.length - 1].start;
+    var menu  = { title: features[0].chr + ':' + (start === end ? start : start + '-' + end) };
+    var values, i;
+
+    function getValues(_features) {
+      var vals = _features.map(function (f) { return f.height; }).sort(function (a, b) { return a - b; });
+
+      return {
+        avg : vals.reduce(function (n, v) { return n + v; }, 0) / vals.length,
+        min : vals[0],
+        max : vals[vals.length - 1]
+      };
+    }
+
+    if (avg) {
+      if (features.length === 1) {
+        values = getValues(features);
+
+        menu['Average value'] = values.avg;
+        menu['Min value']     = values.min;
+        menu['Max value']     = values.max;
+      } else {
+        menu = [ menu ];
+
+        var datasets = this.prop('datasets');
+        var featuresByDataset;
+
+        if (datasets.length) {
+          featuresByDataset = datasets.reduce(function (hash, d) { hash[d.name] = []; return hash; }, {});
+
+          for (i = 0; i < features.length; i++) {
+            featuresByDataset[features[i].dataset].push(features[i]);
+          }
+        } else {
+          datasets          = [{ name: '' }];
+          featuresByDataset = { '': features };
+        }
+
+        for (i = 0; i < datasets.length; i++) {
+          values = getValues(featuresByDataset[datasets[i].name]);
+
+          menu.push($.extend({
+            Average : values.avg,
+            Min     : values.min,
+            Max     : values.max
+          }, datasets[i].name ? { title: datasets[i].name } : {}));
+        }
+      }
+    } else if (features.length === 1) {
+      menu.Value = features[0].height;
+    } else {
+      for (i = 0; i < features.length; i++) {
+        menu[features[i].dataset] = features[i].height;
+      }
+    }
+
+    return menu;
+  }
+};
+
+Genoverse.Track.Model.Graph.Bar = Genoverse.Track.Model.Graph.extend({
+  insertFeature: function (feature) {
+    var datasets = this.prop('datasets');
+
+    if (datasets.length) {
+      feature.legend = feature.dataset;
+      feature.color  = (datasets.filter(function (s) { return s.name === feature.dataset; })[0] || { color: this.color }).color;
+    }
+
+    feature.id = feature.id || [ feature.chr, feature.start, feature.end, feature.dataset || '' ].join(':');
+
+    return this.base.apply(this, arguments);
+  }
+});
+
+Genoverse.Track.View.Graph.Bar = Genoverse.Track.View.Graph.extend({
+  scaleFeatures: function (features, scale) {
+    var yScale = this.track.getYScale();
+    var zeroY  = this.prop('marginTop') - this.prop('range')[0] * yScale;
+
+    features = this.base(features, scale);
+
+    for (var i = 0; i < features.length; i++) {
+      features[i].position[scale].height = features[i].height * yScale;
+      features[i].position[scale].y      = zeroY;
+    }
+
+    return features;
+  },
+
+  draw: function (features, featureContext, labelContext, scale) {
+    var datasets     = this.featureDataSets(features);
+    var marginBottom = this.prop('margin');
+    var binSize      = scale < 1 ? Math.ceil(1 / scale) : 0;
+    var conf, set, setFeatures, j, binnedFeatures, binStart, bin, f;
+
+    var defaults = {
+      color       : this.color,
+      globalAlpha : this.prop('globalAlpha')
+    };
+
+    for (var i = 0; i < datasets.list.length; i++) {
+      conf        = $.extend({}, defaults, datasets.list[i]);
+      set         = datasets.list[i].name;
+      setFeatures = $.extend(true, [], datasets.features[set] || []);
+
+      if (!setFeatures.length) {
+        continue;
+      }
+
+      if (binSize) {
+        binnedFeatures = [];
+        j              = 0;
+
+        while (j < setFeatures.length) {
+          binStart = setFeatures[j].start;
+          bin      = [];
+
+          while (setFeatures[j] && setFeatures[j].start - binStart < binSize) {
+            bin.push(setFeatures[j++]);
+          }
+
+          f = $.extend(true, {}, bin[0], {
+            height : bin.reduce(function (a, b) { return a + b.height; }, 0) / bin.length,
+            end    : bin[bin.length - 1].end
+          });
+
+          [ 'H', 'W', 'height', 'width' ].forEach(function (attr) { // eslint-disable-line no-loop-func
+            f.position[scale][attr] = bin.reduce(function (a, b) { return a + b.position[scale][attr]; }, 0) / bin.length;
+          });
+
+          binnedFeatures.push(f);
+        }
+
+        setFeatures = binnedFeatures;
+      }
+
+      for (j = 0; j < setFeatures.length; j++) {
+        setFeatures[j].color = conf.color;
+      }
+
+      featureContext.globalAlpha = conf.globalAlpha;
+
+      this.base(setFeatures, featureContext, labelContext, scale);
+    }
+
+    // Don't allow features to be drawn in the margins
+    featureContext.clearRect(0, 0,                                  this.width, this.prop('marginTop') - 1);
+    featureContext.clearRect(0, this.prop('height') - marginBottom, this.width, marginBottom);
+  }
+});
+
+Genoverse.Track.Graph.Bar = Genoverse.Track.Graph.extend({
+  type      : 'Bar',
+  model     : Genoverse.Track.Model.Graph.Bar,
+  view      : Genoverse.Track.View.Graph.Bar,
+  threshold : 500000,
+
+  10000: $.extend( // Switch to line graph at 10000bp region
+    Object.keys(Genoverse.Track.Graph.Line.prototype).reduce(function (hash, key) {
+      if (Genoverse.Track.Graph.Line.prototype.hasOwnProperty(key) && !Base.prototype[key]) {
+        hash[key] = Genoverse.Track.Graph.Line.prototype[key];
+      }
+
+      return hash;
+    }, {}), {
+      fill  : true,
+      model : Genoverse.Track.Model.Graph.Line.extend({
+        parseData: function (data, chr, start, end) {
+          var coords = [];
+          var j;
+
+          for (var i = 0; i < data.length; i++) {
+            for (j = data[i].start; j < data[i].end; j++) {
+              coords.push([ j, data[i].height ]);
+            }
+          }
+
+          return this.base([{ chr: chr, start: start, end: end, coords: coords }], chr, start, end);
+        }
+      })
+    }
+  ),
+  50000: $.extend( // Switch to sparser line graph at 50000bp region
+    Object.keys(Genoverse.Track.Graph.Line.prototype).reduce(function (hash, key) {
+      if (Genoverse.Track.Graph.Line.prototype.hasOwnProperty(key) && !Base.prototype[key]) {
+        hash[key] = Genoverse.Track.Graph.Line.prototype[key];
+      }
+
+      return hash;
+    }, {}), {
+      fill  : true,
+      model : Genoverse.Track.Model.Graph.Line.extend({
+        parseData: function (data, chr, start, end) {
+          return this.base([{ chr: chr, start: start, end: end, coords: data.map(function (d) { return [ d.start, d.height ]; }) }], chr, start, end);
+        }
+      })
+    }
+  )
+});