genoverse 3.2.0

package/js/Track/Model/File/BED.js

@@ -0,0 +1,116 @@
+Genoverse.Track.Model.File.BED = Genoverse.Track.Model.File.extend({
+  parseData: function (data, chr) {
+    var lines       = typeof data === 'string' ? data.split('\n') : data;
+    var thinHeight  = this.prop('thinHeight');
+    var thickHeight = this.prop('thickHeight');
+    var fields, len, feature, subfeatures, subfeature, blockSizes, blockStarts, j, thinFeature, thinFeature1, thinFeature2, thickFeature;
+
+    function filterNumber(n) {
+      return !isNaN(n);
+    }
+
+    for (var i = 0; i < lines.length; i++) {
+      fields = lines[i].split('\t').filter(function (f) { return f; });
+
+      if (fields.length < 3 || fields[0] === 'track' || fields[0] === 'browser') {
+        continue;
+      }
+
+      len = fields.length;
+
+      if (fields[0] === String(chr) || fields[0].toLowerCase() === 'chr' + chr || fields[0].match('[^1-9]' + chr + '$')) {
+        feature = {
+          chr             : chr,
+          start           : parseInt(fields[1], 10) + 1,
+          end             : parseInt(fields[2], 10),
+          name            : fields[3],
+          color           : '#000000',
+          originalFeature : fields
+        };
+
+        if (len > 3) { feature.score  = parseFloat(fields[4], 10); }
+        if (len > 5) { feature.strand = fields[5];                 }
+
+        if (len > 7) {
+          feature.thickStart = parseInt(fields[6], 10) + 1;
+          feature.thickEnd   = parseInt(fields[7], 10);
+          feature.drawThick  = fields[6] !== fields[7];
+        }
+
+        if (fields[8]) {
+          feature.color = 'rgb(' + fields[8] + ')';
+        } else {
+          feature.color = this.scoreColor(isNaN(feature.score) ? 1000 : feature.score);
+        }
+
+        if (len === 12) { // subfeatures present
+          feature.blockCount = parseInt(fields[9], 10);
+
+          subfeatures = [];
+          blockSizes  = fields[10].split(',').filter(filterNumber);
+          blockStarts = fields[11].split(',').filter(filterNumber);
+
+          for (j = 0; j < blockSizes.length; j++) {
+            subfeature = {
+              start  : feature.start + parseInt(blockStarts[j], 10),
+              height : thinHeight // if subfeature lies entirely left / right to [ thickStart, thickEnd ]
+            };
+
+            subfeature.end = subfeature.start + parseInt(blockSizes[j], 10) - 1;
+
+            if (feature.drawThick && subfeature.start <= feature.thickEnd && subfeature.end >= feature.thickStart) {
+              // some kind of an overlap for sure
+              if (subfeature.start >= feature.thickStart && subfeature.end <= feature.thickEnd) {
+                // subfeature within thickBlock, draw thick
+                subfeature.height = thickHeight;
+                subfeatures.push(subfeature);
+              } else if (subfeature.start < feature.thickStart && subfeature.end <= feature.thickEnd) {
+                // left overlap, split subfeature into 2 - thin | thick
+                thinFeature  = $.extend({}, subfeature, { end: feature.thickStart });
+                thickFeature = $.extend({}, subfeature, { start: feature.thickStart, height: thickHeight });
+
+                subfeatures = subfeatures.concat([ thinFeature, thickFeature ]);
+              } else if (subfeature.start >= feature.thickStart && subfeature.end > feature.thickEnd) {
+                // right overlap, split subfeature into 2 - thick | thin
+                thinFeature  = $.extend({}, subfeature, { start: feature.thickEnd });
+                thickFeature = $.extend({}, subfeature, { end: feature.thickEnd, height: thickHeight });
+
+                subfeatures = subfeatures.concat([ thickFeature, thinFeature ]);
+              } else {
+                // thickBlock lies within subfeature, split into 3 - thin | thick | thin
+                // the least possible case but lets be prepared for the outliers
+                thinFeature1 = $.extend({}, subfeature, { end: feature.thickStart });
+                thinFeature2 = $.extend({}, subfeature, { start: feature.thickEnd });
+                thickFeature = { start: feature.thickStart, end: feature.thickEnd, height: thickHeight };
+
+                subfeatures = subfeatures.concat([ thinFeature1, thickFeature, thinFeature2 ]);
+              }
+            } else {
+              // no thick block
+              subfeatures.push(subfeature);
+            }
+          }
+
+          if (subfeatures.length) {
+            feature.subFeatures = subfeatures;
+          }
+        }
+
+        this.insertFeature(feature);
+      }
+    }
+  },
+
+  // As per https://genome.ucsc.edu/FAQ/FAQformat.html#format1 specification
+  scoreColor: function (score) {
+    if (score <= 166) { return 'rgb(219,219,219)'; }
+    if (score <= 277) { return 'rgb(186,186,186)'; }
+    if (score <= 388) { return 'rgb(154,154,154)'; }
+    if (score <= 499) { return 'rgb(122,122,122)'; }
+    if (score <= 611) { return 'rgb(94,94,94)';    }
+    if (score <= 722) { return 'rgb(67,67,67)';    }
+    if (score <= 833) { return 'rgb(42,42,42)';    }
+    if (score <= 944) { return 'rgb(21,21,21)';    }
+    return '#000000';
+  }
+});

package/js/Track/Model/File/GFF.js

@@ -0,0 +1,40 @@
+Genoverse.Track.Model.File.GFF = Genoverse.Track.Model.File.extend({
+  parseData: function (text, chr) {
+    var lines = text.split('\n');
+
+    for (var i = 0; i < lines.length; i++) {
+      if (!lines[i].length || lines[i].indexOf('#') === 0) {
+        continue;
+      }
+
+      var fields = lines[i].split('\t');
+
+      if (fields.length < 5) {
+        continue;
+      }
+
+      var seqId = fields[0].toLowerCase();
+
+      if (
+        seqId === String(chr)             ||
+        seqId === 'chr' + chr             ||
+        seqId.match('[^1-9]' + chr + '$') ||
+        seqId.match('^' + chr + '\\b')
+      ) {
+        this.insertFeature({
+          id     : fields.slice(0, 5).join('|'),
+          chr    : chr,
+          start  : parseInt(fields[3], 10),
+          end    : parseInt(fields[4], 10),
+          source : fields[1],
+          type   : fields[2],
+          score  : fields[5],
+          strand : fields[6] === '-' ? -1 : 1,
+          label  : fields[1] + ' ' + fields[2] + ' ' + fields[3] + '-' + fields[4]
+        });
+      }
+    }
+  }
+});
+
+Genoverse.Track.Model.File.GTF = Genoverse.Track.Model.File.GFF;

package/js/Track/Model/File/VCF.js

@@ -0,0 +1,101 @@
+Genoverse.Track.Model.File.VCF = Genoverse.Track.Model.File.extend({
+  getData: function (chr, start, end) {
+    var deferred = $.Deferred();
+    var model    = this;
+
+    if (!this.prop('gz')) {
+      return this.base.apply(this, arguments);
+    }
+
+    if (!this.vcfFile) {
+      if (this.url) {
+        this.vcfFile = new dallianceLib.URLFetchable(this.url);
+        this.tbiFile = new dallianceLib.URLFetchable(this.url + this.prop('indexExt'));
+      } else if (this.dataFile && this.indexFile) {
+        this.vcfFile = new dallianceLib.BlobFetchable(this.dataFile);
+        this.tbiFile = new dallianceLib.BlobFetchable(this.indexFile);
+      } else {
+        return deferred.rejectWith(model, [ 'GZipped VCF files must be accompanied by a .tbi index file' ]);
+      }
+    }
+
+    this.makeVCF(this.vcfFile, this.tbiFile).then(function (vcf) {
+      model.cachedVCF = vcf;
+
+      vcf.getRecords(chr, start, end, function (records) {
+        model.receiveData(records, chr, start, end);
+        deferred.resolveWith(model);
+      });
+    });
+
+    return deferred;
+  },
+
+  makeVCF: function (vcfFile, tbiFile) {
+    var deferred = $.Deferred();
+
+    if (this.cachedVCF) {
+      deferred.resolve(this.cachedVCF);
+    } else {
+      var vcf = new VCFReader(vcfFile, tbiFile);
+
+      vcf.readTabix(function (tabix) {
+        vcf.tabix = tabix;
+        deferred.resolve(vcf);
+      });
+    }
+
+    return deferred;
+  },
+
+  parseData: function (text, chr) {
+    var lines   = text.split('\n');
+    var maxQual = this.allData ? this.prop('maxQual') || 0 : false;
+
+    for (var i = 0; i < lines.length; i++) {
+      if (!lines[i].length || lines[i].indexOf('#') === 0) {
+        continue;
+      }
+
+      var fields = lines[i].split('\t');
+
+      if (fields.length < 5) {
+        continue;
+      }
+
+      if (fields[0] === String(chr) || fields[0] === 'chr' + chr) {
+        var id      = fields.slice(0, 3).join('|');
+        var start   = parseInt(fields[1], 10);
+        var alleles = fields[4].split(',');
+
+        alleles.unshift(fields[3]);
+
+        for (var j = 0; j < alleles.length; j++) {
+          var end = start + alleles[j].length - 1;
+
+          this.insertFeature({
+            id              : id + '|' + alleles[j],
+            sort            : j,
+            chr             : chr,
+            start           : start,
+            end             : end,
+            width           : end - start,
+            allele          : j === 0 ? 'REF' : 'ALT',
+            sequence        : alleles[j],
+            label           : alleles[j],
+            labelColor      : '#FFFFFF',
+            originalFeature : fields
+          });
+        }
+
+        if (maxQual !== false) {
+          maxQual = Math.max(maxQual, fields[5]);
+        }
+      }
+    }
+
+    if (maxQual) {
+      this.prop('maxQual', maxQual);
+    }
+  }
+});

package/js/Track/Model/File/WIG.js

@@ -0,0 +1,67 @@
+Genoverse.Track.Model.File.WIG = Genoverse.Track.Model.Graph.Bar.extend({
+  dataType: 'text',
+
+  getData: function () {
+    if (!this.url) {
+      this.isLocal  = true;
+      this.dataFile = this.track.dataFile;
+
+      return Genoverse.Track.Model.File.prototype.getData.apply(this, arguments);
+    }
+
+    return this.base.apply(this, arguments);
+  },
+
+  parseData: function (text, chr, s, e) {
+    var lines    = text.split('\n');
+    var features = [];
+    var fields, chrom, start, step, span, line, feature, i;
+
+    while (lines.length && (line = lines.shift())) {
+      if (line.indexOf('#') !== -1 || line.indexOf('browser') !== -1 || line.indexOf('track') !== -1) {
+        continue;
+      } else {
+        break;
+      }
+    }
+
+    if (line) {
+      fields = line.split(/\s+/);
+      chrom  = parseInt(fields[1].split('=')[1].replace('chr', ''), 10);
+
+      if (fields[0] === 'fixedStep') {
+        start = parseInt(fields[2].split('=')[1], 10);
+        step  = parseInt(fields[3].split('=')[1], 10);
+        span  = fields[4] ? parseInt(fields[4].split('=')[1], 10) : 1;
+
+        for (i = 0; i < lines.length; i++) {
+          features.push({
+            chr    : chrom,
+            start  : start,
+            end    : start + span,
+            height : parseFloat(lines[i])
+          });
+
+          start += step;
+        }
+      } else if (fields[0] === 'variableStep') {
+        span = fields[2] ? parseInt(fields[2].split('=')[1], 10) : 1;
+
+        for (i = 0; i < lines.length; i++) {
+          fields  = lines[i].split(/\s+/);
+          feature = {
+            chr    : chrom,
+            start  : parseInt(fields[0], 10),
+            height : parseFloat(fields[1])
+          };
+
+          feature.end = feature.start + span;
+
+          features.push(feature);
+        }
+      }
+    }
+
+    return this.base.call(this, features, chr, s, e);
+  }
+});

package/js/Track/Model/File.js

@@ -0,0 +1,36 @@
+Genoverse.Track.Model.File = Genoverse.Track.Model.extend({
+  dataType: 'text',
+
+  init: function () {
+    if (this.isLocal) {
+      this.url = false;
+    }
+
+    if (!(this.largeFile || this.indexFile)) {
+      this.allData = true;
+    }
+
+    this.base.apply(this, arguments);
+  },
+
+  getData: function (chr) {
+    var model = this;
+
+    if (this.isLocal && this.dataFile) {
+      var reader   = new FileReader();
+      var deferred = $.Deferred();
+
+      reader.onload = function (e) {
+        deferred.done(function () {
+          this.receiveData(e.target.result, chr, 1, this.browser.getChromosomeSize(chr));
+        }).resolveWith(model);
+      };
+
+      reader.readAsText(this.dataFile);
+
+      return deferred;
+    }
+
+    return this.base.apply(this, arguments);
+  }
+});

package/js/Track/Model/Gene/Ensembl.js

@@ -0,0 +1,22 @@
+// Ensembl REST API Gene model
+Genoverse.Track.Model.Gene.Ensembl = Genoverse.Track.Model.Gene.extend({
+  url              : '//rest.ensembl.org/overlap/region/human/__CHR__:__START__-__END__?feature=gene;content-type=application/json',
+  dataRequestLimit : 5000000, // As per e! REST API restrictions
+
+  // The url above responds in json format, data is an array
+  // We assume that parents always preceed children in data array, gene -> transcript -> exon
+  // See rest.ensembl.org/documentation/info/feature_region for more details
+  parseData: function (data, chr) {
+    for (var i = 0; i < data.length; i++) {
+      var feature = data[i];
+
+      if (feature.feature_type === 'gene' && !this.featuresById[feature.id]) {
+        feature.chr         = feature.chr || chr;
+        feature.label       = parseInt(feature.strand, 10) === 1 ? (feature.external_name || feature.id) + ' >' : '< ' + (feature.external_name || feature.id);
+        feature.transcripts = [];
+
+        this.insertFeature(feature);
+      }
+    }
+  }
+});

package/js/Track/Model/Gene.js

@@ -0,0 +1,5 @@
+// Abstract Gene model
+// see sub-models for more specific examples
+Genoverse.Track.Model.Gene = Genoverse.Track.Model.extend({
+
+});

package/js/Track/Model/Sequence/Ensembl.js

@@ -0,0 +1,4 @@
+Genoverse.Track.Model.Sequence.Ensembl = Genoverse.Track.Model.Sequence.extend({
+  url              : '//rest.ensembl.org/sequence/region/human/__CHR__:__START__-__END__?content-type=text/plain', // Example url
+  dataRequestLimit : 10000000 // As per e! REST API restrictions
+});

package/js/Track/Model/Sequence/Fasta.js

@@ -0,0 +1,60 @@
+Genoverse.Track.Model.Sequence.Fasta = Genoverse.Track.Model.Sequence.extend({
+  url: 'https://wtsi-web.github.io/Genoverse/data/Homo_sapiens.GRCh37.72.dna.chromosome.1.fa', // Example url
+
+  // Following settings could be left undefined and will be detected automatically via .getStartByte()
+  startByte  : undefined, // Byte in the file where the sequence actually starts
+  lineLength : undefined, // Length of the sequence line in the file
+
+  // TODO: Check if URL provided
+
+  getData: function (chr, start, end) {
+    var deferred = $.Deferred();
+
+    $.when(this.getStartByte()).done(function () {
+      start = start - (start % this.chunkSize) + 1;
+      end   = end + this.chunkSize - (end % this.chunkSize);
+
+      var startByte = start - 1 + Math.floor((start - 1) / this.lineLength) + this.startByte;
+      var endByte   = end   - 1 + Math.floor((end   - 1) / this.lineLength) + this.startByte;
+
+      $.ajax({
+        url       : this.parseURL(),
+        dataType  : this.dataType,
+        context   : this,
+        headers   : { Range: 'bytes=' + startByte + '-' + endByte },
+        xhrFields : this.xhrFields,
+        success   : function (data) { this.receiveData(data, chr, start, end); },
+        error     : this.track.controller.showError
+      }).done(function () { deferred.resolveWith(this); }).fail(function () { deferred.rejectWith(this); });
+    }).fail(function () { deferred.rejectWith(this); });
+
+    return deferred;
+  },
+
+  getStartByte: function () {
+    if (this.startByteRequest) {
+      return this.startByteRequest;
+    }
+
+    if (this.startByte === undefined || this.lineLength === undefined) {
+      this.startByteRequest = $.ajax({
+        url       : this.parseURL(),
+        dataType  : 'text',
+        context   : this,
+        headers   : { 'Range': 'bytes=0-300' },
+        xhrFields : this.xhrFields,
+        success   : function (data) {
+          if (data.indexOf('>') === 0) {
+            this.startByte = data.indexOf('\n') + 1;
+          } else {
+            this.startByte = 0;
+          }
+
+          this.lineLength = data.indexOf('\n', this.startByte) - this.startByte;
+        }
+      });
+
+      return this.startByteRequest;
+    }
+  }
+});

package/js/Track/Model/Sequence.js

@@ -0,0 +1,50 @@
+// Abstract Sequence model
+// assumes that the data source responds with raw sequence text
+// see Fasta model for more specific example
+Genoverse.Track.Model.Sequence = Genoverse.Track.Model.extend({
+  threshold : 100000,
+  chunkSize : 1000,
+  buffer    : 0,
+  dataType  : 'text',
+
+  setChrProps: function () {
+    var chr = this.browser.chr;
+
+    this.base();
+
+    this.chunksByChr      = this.chunksByChr || {};
+    this.chunksByChr[chr] = this.chunksByChr[chr] || {};
+  },
+
+  getData: function (chr, start, end) {
+    start = start - (start % this.chunkSize) + 1;
+    end   = end + this.chunkSize - (end % this.chunkSize);
+    return this.base(chr, start, end);
+  },
+
+  parseData: function (data, chr, start) {
+    data = data.replace(/\n/g, '');
+
+    if (this.prop('lowerCase')) {
+      data = data.toLowerCase();
+    }
+
+    for (var i = 0; i < data.length; i += this.chunkSize) {
+      if (this.chunksByChr[chr][start + i]) {
+        continue;
+      }
+
+      var feature = {
+        id       : chr + ':' + start + ':' + i,
+        chr      : chr,
+        start    : start + i,
+        end      : start + i + this.chunkSize - 1,
+        sequence : data.substr(i, this.chunkSize),
+        sort     : start + i
+      };
+
+      this.chunksByChr[chr][feature.start] = feature;
+      this.insertFeature(feature);
+    }
+  }
+});

package/js/Track/Model/SequenceVariation.js

@@ -0,0 +1,41 @@
+Genoverse.Track.Model.SequenceVariation = Genoverse.Track.Model.extend({
+  seqModel: Genoverse.Track.Model.Sequence.Ensembl,
+
+  getSeqModel: function () {
+    var models = this.prop('models');
+    models.seq = models.seq || this.track.newMVC(this.seqModel);
+    return models.seq;
+  },
+
+  getData: function (chr, start, end) {
+    var model    = this;
+    var deferred = $.Deferred();
+    var seqData  = this.getSeqModel().checkDataRange(chr, start, end);
+
+    this.base(chr, start, end).done(function () {
+      if (seqData) {
+        deferred.resolve();
+      } else {
+        model.getSeqModel().getData(chr, start, end).done(deferred.resolve);
+      }
+    });
+
+    return deferred;
+  },
+
+  insertFeature: function (feature) {
+    return this.base($.extend(feature, {
+      end      : feature.start + feature.alt_allele.length - 1,
+      length   : feature.alt_allele.length,
+      sequence : feature.alt_allele
+    }));
+  },
+
+  checkDataRange: function (chr, start, end) {
+    return this.base(chr, start, end) && this.getSeqModel().checkDataRange(chr, start, end);
+  },
+
+  findFeatures: function (chr, start, end) {
+    return this.getSeqModel().findFeatures(chr, start, end).concat(this.base(chr, start, end));
+  }
+});

package/js/Track/Model/Stranded.js

@@ -0,0 +1,28 @@
+Genoverse.Track.Model.Stranded = Genoverse.Track.Model.extend({
+  init: function (reset) {
+    this.base(reset);
+
+    if (!reset) {
+      var otherTrack = this.prop('forwardTrack');
+
+      if (otherTrack) {
+        this.featuresByChr = otherTrack.prop('featuresByChr');
+        this.features      = otherTrack.prop('features');
+        this.featuresById  = otherTrack.prop('featuresById');
+      }
+    }
+  },
+
+  parseURL: function () {
+    if (!this.urlParams.strand) {
+      this.urlParams.strand = this.prop('featureStrand');
+    }
+
+    return this.base.apply(this, arguments);
+  },
+
+  findFeatures: function () {
+    var strand = this.track.featureStrand;
+    return $.grep(this.base.apply(this, arguments), function (feature) { return feature.strand === strand; });
+  }
+});

package/js/Track/Model/Transcript/Ensembl.js

@@ -0,0 +1,67 @@
+// Ensembl REST API Transcript model
+Genoverse.Track.Model.Transcript.Ensembl = Genoverse.Track.Model.Transcript.extend({
+  url              : '//rest.ensembl.org/overlap/region/human/__CHR__:__START__-__END__?feature=transcript;feature=exon;feature=cds;content-type=application/json',
+  dataRequestLimit : 5000000, // As per e! REST API restrictions
+
+  setDefaults: function () {
+    this.geneIds   = {};
+    this.seenGenes = 0;
+
+    this.base.apply(this, arguments);
+  },
+
+  // The url above responds in json format, data is an array
+  // See rest.ensembl.org/documentation/info/overlap_region for more details
+  parseData: function (data, chr) {
+    var model        = this;
+    var featuresById = this.featuresById;
+    var ids          = [];
+
+    data.filter(function (d) { return d.feature_type === 'transcript'; }).forEach(function (feature, i) {
+      if (!featuresById[feature.id]) {
+        model.geneIds[feature.Parent] = model.geneIds[feature.Parent] || ++model.seenGenes;
+
+        feature.chr         = feature.chr || chr;
+        feature.label       = parseInt(feature.strand, 10) === 1 ? (feature.external_name || feature.id) + ' >' : '< ' + (feature.external_name || feature.id);
+        feature.sort        = (model.geneIds[feature.Parent] * 1e10) + (feature.logic_name.indexOf('ensembl_havana') === 0 ? 0 : 2e9) + (feature.biotype === 'protein_coding' ? 0 : 1e9) + feature.start + i;
+        feature.cdsStart    = Infinity;
+        feature.cdsEnd      = -Infinity;
+        feature.exons       = {};
+        feature.subFeatures = [];
+
+        model.insertFeature(feature);
+      }
+
+      ids.push(feature.id);
+    });
+
+    data.filter(function (d) { return d.feature_type === 'cds' && featuresById[d.Parent]; }).forEach(function (cds) {
+      featuresById[cds.Parent].cdsStart = Math.min(featuresById[cds.Parent].cdsStart, cds.start);
+      featuresById[cds.Parent].cdsEnd   = Math.max(featuresById[cds.Parent].cdsEnd,   cds.end);
+    });
+
+    data.filter(function (d) { return d.feature_type === 'exon' && featuresById[d.Parent] && !featuresById[d.Parent].exons[d.id]; }).forEach(function (exon) {
+      if (exon.end < featuresById[exon.Parent].cdsStart || exon.start > featuresById[exon.Parent].cdsEnd) {
+        featuresById[exon.Parent].subFeatures.push($.extend({ utr: true }, exon));
+      } else {
+        if (exon.start < featuresById[exon.Parent].cdsStart) {
+          featuresById[exon.Parent].subFeatures.push($.extend({ utr: true }, exon, { end: featuresById[exon.Parent].cdsStart }));
+        }
+
+        featuresById[exon.Parent].subFeatures.push($.extend({}, exon, {
+          start  : Math.max(exon.start, featuresById[exon.Parent].cdsStart),
+          end    : Math.min(exon.end,   featuresById[exon.Parent].cdsEnd),
+          strand : featuresById[exon.Parent].strand
+        }));
+
+        if (exon.end > featuresById[exon.Parent].cdsEnd) {
+          featuresById[exon.Parent].subFeatures.push($.extend({ utr: true }, exon, { start: featuresById[exon.Parent].cdsEnd }));
+        }
+      }
+    });
+
+    ids.forEach(function (id) {
+      featuresById[id].subFeatures.sort(function (a, b) { return a.start - b.start; });
+    });
+  }
+});

package/js/Track/Model/Transcript.js

@@ -0,0 +1,5 @@
+// Abstract Transcript model
+// see sub-models for more specific examples
+Genoverse.Track.Model.Transcript = Genoverse.Track.Model.extend({
+
+});