igv 2.15.0 → 2.15.2

package/dist/igv.esm.js

@@ -18656,6 +18656,8 @@ class IGVXhr {
 
     async _loadURL(url, options) {
 
+        const self = this;
+
         //console.log(`${Date.now()}   ${url}`)
         url = mapUrl$1(url);
 
@@ -18745,7 +18747,7 @@ class IGVXhr {
                         // For small files a range starting at 0 can return the whole file => 200
                         // Provide just the slice we asked for, throw out the rest quietly
                         // If file is large warn user
-                        if (xhr.response.length > 100000 && !this.RANGE_WARNING_GIVEN) {
+                        if (xhr.response.length > 100000 && !self.RANGE_WARNING_GIVEN) {
                             alert(`Warning: Range header ignored for URL: ${url}.  This can have severe performance impacts.`);
                         }
                         resolve(xhr.response.slice(range.start, range.start + range.size));
@@ -18774,8 +18776,9 @@ class IGVXhr {
             xhr.onerror = function (event) {
                 if (isGoogleURL(url) && !options.retries) {
                     tryGoogleAuth();
+                } else {
+                    handleError("Error accessing resource: " + url + " Status: " + xhr.status);
                 }
-                handleError("Error accessing resource: " + url + " Status: " + xhr.status);
             };
 
             xhr.ontimeout = function (event) {
@@ -18790,7 +18793,11 @@ class IGVXhr {
             try {
                 xhr.send(sendData);
             } catch (e) {
-                reject(e);
+                if (isGoogleURL(url) && !options.retries) {
+                    tryGoogleAuth();
+                } else {
+                    handleError(e);
+                }
             }
 
 
@@ -18807,7 +18814,7 @@ class IGVXhr {
                     const accessToken = await fetchGoogleAccessToken(url);
                     options.retries = 1;
                     options.oauthToken = accessToken;
-                    const response = await this._load(url, options);
+                    const response = await self.load(url, options);
                     resolve(response);
                 } catch (e) {
                     if (e.error) {
@@ -18953,14 +18960,16 @@ function addTeamDrive(url) {
  */
 function mapUrl$1(url) {
 
-    if (url.includes("//www.dropbox.com")) {
+    if (url.startsWith("https://www.dropbox.com")) {
         return url.replace("//www.dropbox.com", "//dl.dropboxusercontent.com")
-    } else if (url.includes("//drive.google.com")) {
+    } else if (url.startsWith("https://drive.google.com")) {
         return getDriveDownloadURL(url)
     } else if (url.includes("//www.broadinstitute.org/igvdata")) {
         return url.replace("//www.broadinstitute.org/igvdata", "//data.broadinstitute.org/igvdata")
     } else if (url.includes("//igvdata.broadinstitute.org")) {
-        return url.replace("//igvdata.broadinstitute.org", "https://dn7ywbm9isq8j.cloudfront.net")
+        return url.replace("//igvdata.broadinstitute.org", "//s3.amazonaws.com/igv.broadinstitute.org")
+    } else if (url.includes("//igv.genepattern.org")) {
+        return url.replace("//igv.genepattern.org", "//igv-genepattern-org.s3.amazonaws.com")
     } else if (url.startsWith("ftp://ftp.ncbi.nlm.nih.gov/geo")) {
         return url.replace("ftp://", "https://")
     } else {
@@ -23922,7 +23931,7 @@ const Cytoband = function (start, end, name, typestain) {
     }
 };
 
-const _version = "2.15.0";
+const _version = "2.15.2";
 function version() {
     return _version
 }
@@ -25759,15 +25768,15 @@ function decodeGTF(tokens, header) {
  * @param keyValueDelim
  * @returns {[]}
  */
-function parseAttributeString(attributeString, keyValueDelim) {
+function parseAttributeString(attributeString, keyValueDelim, relaxed = false) {
     // parse 'attributes' string (see column 9 docs in https://github.com/The-Sequence-Ontology/Specifications/blob/master/gff3.md)
     var attributes = [];
     for (let kv of attributeString.split(';')) {
         kv = kv.trim();
         const idx = kv.indexOf(keyValueDelim);
         if (idx > 0 && idx < kv.length - 1) {
-            const key = kv.substring(0, idx);
-            let value = stripQuotes(decodeGFFAttribute(kv.substring(idx + 1).trim()));
+            const key = stripQuotes(decodeGFFAttribute(kv.substring(0, idx).trim(), relaxed));
+            let value = stripQuotes(decodeGFFAttribute(kv.substring(idx + 1).trim(), relaxed));
             attributes.push([key, value]);
         }
     }
@@ -25806,11 +25815,14 @@ const encodings = new Map([
     ["%2C", ","]
 ]);
 
-function decodeGFFAttribute(str) {
+function decodeGFFAttribute(str, relaxed = false) {
 
     if (!str.includes("%")) {
         return str
     }
+    if (relaxed) {
+        return decodeURIComponent(str);
+    }
     let decoded = "";
     for (let i = 0; i < str.length; i++) {
 
@@ -25868,7 +25880,7 @@ function decodeBed(tokens, header) {
 
             // Potentially parse name field as GFF column 9 style streng.
             if (tokens[3].indexOf(';') > 0 && tokens[3].indexOf('=') > 0) {
-                const attributeKVs = parseAttributeString(tokens[3], '=');
+                const attributeKVs = parseAttributeString(tokens[3], '=', true);
                 feature.attributes = {};
                 for (let kv of attributeKVs) {
                     feature.attributes[kv[0]] = kv[1];
@@ -25916,7 +25928,25 @@ function decodeBed(tokens, header) {
         }
 
         if (tokens.length > 11) {
-            const exons = decodeExons(tokens[9], tokens[10], tokens[11]);
+            const exonCount = parseInt(tokens[9]);
+            // Some basic validation
+            if (exonCount > 1000) {
+                // unlikely
+                return feature
+            }
+
+            const exonSizes = tokens[10].replace(/,$/, '').split(',');
+            const exonStarts = tokens[11].replace(/,$/, '').split(',');
+            if (!(exonSizes.length === exonStarts.length && exonCount === exonSizes.length)) {
+                return feature
+            }
+
+            const exons = [];
+            for (let i = 0; i < exonCount; i++) {
+                const eStart = start + parseInt(exonStarts[i]);
+                const eEnd = eStart + parseInt(exonSizes[i]);
+                exons.push({start: eStart, end: eEnd});
+            }
             if (exons.length > 0) {
                 findUTRs$1(exons, feature.cdStart, feature.cdEnd);
                 feature.exons = exons;
@@ -25940,7 +25970,6 @@ function decodeBed(tokens, header) {
     }
 
     return feature
-
 }
 
 /**
@@ -27252,6 +27281,8 @@ class TrackBase {
                         }
                         tracklineConfg.autoscale = false;
                         tracklineConfg.dataRange = {min, max};
+                        this.viewLimitMin = min;
+                        this.viewLimitMax = max;
                     }
                 case "name":
                     tracklineConfg[key] = properties[key];
@@ -29150,9 +29181,9 @@ function optimizeChunks(chunks, lowest) {
  * @returns {boolean|boolean}
  */
 function canMerge(chunk1, chunk2) {
-    const gap = chunk2.minv.block - chunk1.maxv.block;
+    chunk2.minv.block - chunk1.maxv.block;
     const sizeEstimate = chunk1.maxv.block - chunk1.minv.block;
-    return gap < 65000 && sizeEstimate < 5000000
+    return sizeEstimate < 5000000
 }
 
 // Represents a CSI Bam or Tabix index
@@ -40775,8 +40806,8 @@ class FeatureTrack extends TrackBase {
             color = IGVColor.addAlpha(color, feature.alpha);
         } else if (this.useScore && feature.score && !Number.isNaN(feature.score)) {
             // UCSC useScore option, for scores between 0-1000.  See https://genome.ucsc.edu/goldenPath/help/customTrack.html#TRACK
-            const min = this.config.min ? this.config.min : 0; //getViewLimitMin(track);
-            const max = this.config.max ? this.config.max : 1000; //getViewLimitMax(track);
+            const min = this.config.min ? this.config.min : this.viewLimitMin ? this.viewLimitMin : 0;
+            const max = this.config.max ? this.config.max : this.viewLimitMax ? this.viewLimitMax : 1000;
             const alpha = getAlpha(min, max, feature.score);
             feature.alpha = alpha;    // Avoid computing again
             color = IGVColor.addAlpha(color, alpha);
@@ -54145,11 +54176,13 @@ class HDF5Reader {
 
         // console.log(h5_obj_keys)
         let signal_bin = new ParseSignals(h5_obj_keys);
-        this.rd_bins = signal_bin.get_rd_bins();
+        let rd_bins = signal_bin.get_rd_bins();
+        let snp_bins = signal_bin.get_snp_bins();
+        this.available_bins = [...new Set(rd_bins, snp_bins)];
 
         // let bin_size = this.bin_size
-        if(! this.rd_bins.includes(bin_size)){
-            bin_size = this.rd_bins[rd_bins.length-1];    
+        if(! this.available_bins.includes(bin_size)){
+            bin_size = this.available_bins.at(-1);    
         }
 
         const chr_ds = await h5_obj.get("rd_chromosomes");
@@ -54193,6 +54226,9 @@ class HDF5Reader {
             let signal_baf_1 = `snp_likelihood_${chrom}_${bin_size}_mask`;
             let chr_wig_bafs = await this.get_baf_signals(h5_obj, h5_obj_keys, chrom, bin_size, signal_baf_1);
 
+            // let signal_baf_1 = `snp_i1_${chrom}_${bin_size}_mask`
+            // let chr_wig_bafs = await this.get_baf_signals_v2(h5_obj, h5_obj_keys, chrom, bin_size, signal_baf_1)
+
             wigFeatures_baf1 = wigFeatures_baf1.concat(chr_wig_bafs[0]);
             wigFeatures_baf2 = wigFeatures_baf2.concat(chr_wig_bafs[1]);
             // this.rd_call_combined(h5_obj, h5_obj_keys, chrom, bin_size, rd_stat)
@@ -54317,6 +54353,28 @@ class HDF5Reader {
         }
         return [chr_wig_1, chr_wig_2]
     }
+
+    async get_baf_signals_v2(h5_obj, h5_obj_keys, chrom, bin_size, signal_name){
+        
+        /* return two list of dictionary*/
+        let chr_wig_1 = [];
+        let chr_wig_2 = [];
+        if (h5_obj_keys.includes(signal_name)){
+            let chrom_dataset = await h5_obj.get(signal_name);
+            let chrom_data = await chrom_dataset.to_array(); //create_nested_array(value, shape)
+            chrom_data.forEach((lh, bin_idx) => {
+                if (!isNaN(lh)){
+                    chr_wig_1.push({chr:chrom, start: bin_idx*bin_size, end: (bin_idx+1) * bin_size, value: -2 * ( 0.5 - lh )});
+                    if(lh != 0.5){
+                        chr_wig_2.push({chr:chrom, start: bin_idx*bin_size, end: (bin_idx+1) * bin_size, value: -2 * ( 0.5 + lh )});
+                    }
+                }
+            });
+        }
+        console.log(chrom, chr_wig_1, chr_wig_2);
+        return [chr_wig_1, chr_wig_2]
+
+    }
 }
 
 class ParseSignals{
@@ -54357,6 +54415,53 @@ class ParseSignals{
     }
 }
 
+class GetFit {
+  constructor(allBins) {
+      this.allBins = allBins;
+  }
+  getValues() {
+      const bins = Object.values(this.allBins).reduce(
+          (binResult, bin) => { return binResult.concat(bin.filter(a => a.binScore > 0).map(a => a.binScore)) }, []);
+      return bins
+  }
+  getMean(data) {
+      return (data.reduce(function (a, b) { return a + b; }) / data.length);
+  }
+  fit_data() {
+      let rd_list = this.getValues();
+      let distParmas = getDistParams(rd_list);
+      return distParmas
+  }
+
+  histogram(data, bins) {
+      const step = bins[1] - bins[0];
+      const hist_bins = [];
+
+      data.forEach((value, index) => {
+          bins.forEach((bin_value, bin_index) => {
+              if (!hist_bins[bin_value]) {
+                  hist_bins[bin_value] = { count: 0 };
+              }
+              if (bin_value <= value && value < bin_value + step) {
+                  hist_bins[bin_value].count++;
+                  return false;
+              }
+          });
+      });
+      const dist_p = [];
+      hist_bins.forEach((bin, index) => { dist_p.push(bin.count); });
+      return dist_p
+  }
+
+}
+
+function range_function(start, stop, step) {
+  const data_array = Array(Math.ceil((stop - start) / step))
+    .fill(start)
+    .map((x, y) => x + y * step);
+  return data_array;
+}
+
 function filterOutliers(someArray) {
 
   if (someArray.length < 4)
@@ -54389,6 +54494,21 @@ function getDistParams(bins) {
   return [mean, std]
 }
 
+function linspace(a, b, n) {
+  if (typeof n === "undefined") n = Math.max(Math.round(b - a) + 1, 1);
+  if (n < 2) {
+      return n === 1 ? [a] : [];
+  }
+  var ret = Array(n);
+  n--;
+  for (let i = n; i >= 0; i--) {
+      ret[i] = (i * b + (n - i) * a) / n;
+  }
+  return ret;
+}
+
+var g_utils = { range_function, getDistParams, linspace, GetFit};
+
 /** 
 * Evaluates the cumulative distribution function (CDF) for a Student's t distribution with degrees of freedom `v` at a value `t`.
 *
@@ -54533,48 +54653,507 @@ function lgamma(xg){
     return Math.log(gamma(xg))
 }
 
-var t_dist = {TdistributionCDF, gamma};
+function t_test_1_sample$1(mean, m, s, n) {
+    if (s == 0) s = 1;
+    var t = ((mean - m) / s) * Math.sqrt(n);
+    var p = 1.0 - TdistributionCDF(Math.abs(t), (n - 1));
+    return p
+}
 
-class GetFit {
-    constructor(allBins) {
-        this.allBins = allBins;
-    }
-    getValues() {
-        const bins = Object.values(this.allBins).reduce(
-            (binResult, bin) => { return binResult.concat(bin.filter(a => a.binScore > 0).map(a => a.binScore)) }, []);
-        return bins
+function t_test_2_samples$1(m1, s1, n1, m2, s2, n2) {
+    if (s1 == 0) s1 = 1;
+    if (s2 == 0) s2 = 1;
+    var t = (m1 - m2) / Math.sqrt(s1 ** 2 / n1 + s2 ** 2 / n2);
+    var df = ((s1 ** 2 / n1 + s2 ** 2 / n2) ** 2 * (n1 - 1) * (n2 - 1)) /
+        ((s1 ** 4 * (n2 - 1)) / n1 ** 2 + (s2 ** 4 * (n1 - 1)) / n2 ** 2);
+
+    var p = 1.0 - TdistributionCDF(Math.abs(t), parseInt(df + 0.5));
+
+    return p
+}
+
+var t_dist = {TdistributionCDF, gamma, t_test_1_sample: t_test_1_sample$1, t_test_2_samples: t_test_2_samples$1};
+
+class CombinedCaller{
+    constructor(wigFeatures, binSize) {
+        this.wigFeatures = wigFeatures;
+        this.binSize = binSize;
+        // let fit_obj = this.get_fit()
+        // this.globalMean = fit_obj.globalMean
+        // this.globalStd = fit_obj.globalStd
     }
-    getMean(data) {
-        return (data.reduce(function (a, b) { return a + b; }) / data.length);
+    get_fit(){
+        var fit_info = new g_utils.GetFit(this.wigFeatures);
+        var [globalMean, globalStd] = fit_info.fit_data();
+
+        return {globalMean:globalMean, globalStd:globalStd}
+       
     }
-    fit_data() {
-        let rd_list = this.getValues();
-        let distParmas = getDistParams(rd_list);
-        return distParmas
+    async call_2d(omin=null, mcount=null, event_type="both", max_distance=0.1, baf_threshold=0, max_copy_number=10, min_cell_fraction=0.0){
+        
+        let fit_obj = this.get_fit();
+        this.globalMean = fit_obj.globalMean;
+        this.globalStd = fit_obj.globalStd;
+        
+        let overlap_min = omin==null ?  0.05 * this.binSize / 3e9: omin ;
+        let min_count = mcount == null ? parseInt(this.binSize / 10000) : mcount ;
+
+        let gstat_rd0 = [];
+        let gstat_rd_all = [];
+        let gstat_rd = [];
+        let gstat_error = [];
+        let gstat_lh = [];
+        let gstat_n = [];
+        
+        for (const [chr, wig] of Object.entries(this.wigFeatures)) {
+            let segments = [];
+            let levels = [];
+            let likelihoods = [];
+            
+            wig.forEach((bin, bin_idx) => {
+                if (bin.hets_count > 4 ){
+                    
+                    if( bin.dp_count > min_count ){
+                        segments.push([bin_idx]);
+                        levels.push(bin.binScore);
+                        likelihoods.push(bin.likelihood_score);
+                        delete bin.likelihood_score;
+                        
+                    }
+                }
+            });
+
+            let diff_level = [];
+            for(let i=1; i<levels.length; i++){
+                diff_level.push(Math.abs(levels[i] - levels[i-1]));
+            }
+            let min_flank = [0];
+            for(let i=1; i<diff_level.length; i++){
+                min_flank.push(Math.min(diff_level[i-1], diff_level[i]));    
+            }
+            min_flank.push(0);
+
+            let error  = levels.map((x, x_idx) => {return Math.sqrt(Math.sqrt(x) ** 2 + this.globalStd ** 2 + Math.pow(min_flank[x_idx]/2, 2));});
+            
+            let overlaps = [];
+            
+            for(let i=0; i< segments.length-1; i++){
+                
+                let lh_overlap = 0;
+                try{
+                    lh_overlap = likelihood_overlap(likelihoods[i], likelihoods[i+1]);
+                }catch{
+                    console.log("Overlap failed: ", i, likelihoods[i], segments[i+1], likelihoods[i+1]);
+                }
+                
+                let rd_overlap = normal_overlap_approx(levels[i], error[i], levels[i+1], error[i+1]);
+                overlaps.push(rd_overlap * lh_overlap);
+                
+            }
+            
+            while(overlaps.length >0) {
+                overlaps = overlaps.filter(num => typeof num === "number");
+                
+                let max_overlap = arrayMax(overlaps);
+                if(isNaN(max_overlap)){
+                    console.log('NaN value', overlaps);
+                }
+                if(max_overlap < overlap_min){
+                    // console.log("maxoverlap ",max_overlap,  "is smaller than overlap min")
+                    break
+                }
+                let i = overlaps.indexOf(max_overlap);
+                
+                let merge_level = normal_merge(levels[i], error[i], levels[i + 1], error[i + 1]);
+                
+                let nlh;
+                let nlh_sum;
+                try{
+                    nlh = likelihoods[i].map((l_value, l_idx) => { return l_value * likelihoods[i+1][l_idx]});
+                
+                    nlh_sum = nlh.reduce((a, c_value) => {return a + c_value});
+                    
+                }catch{
+                    console.log(likelihoods);
+                    console.log('max_overlap:', max_overlap, i, overlaps.length);
+                    console.log('likelihood: ', i ,likelihoods[i], likelihoods[i+1]);
+                    console.log('nlh: ', nlh_sum);
+                }
+                // nlh_sum = nlh.reduce((a, c_value) => {return a + c_value});
+
+                levels[i] = merge_level.nl;
+                error[i] = merge_level.ne;
+                
+                likelihoods[i] = nlh.map(function(item) { return item/nlh_sum } );
+                
+                segments[i].push(...segments[i+1]);
+
+                levels.splice(i + 1, 1);
+                error.splice(i + 1, 1);
+                segments.splice(i + 1, 1);
+                likelihoods.splice(i + 1, 1);
+                overlaps.splice(i, 1);
+                
+                if(i < overlaps.length){
+                    
+                    let rd_overlap = normal_overlap_approx(levels[i], error[i], levels[i+1], error[i+1]);
+                    let new_overlap = rd_overlap * likelihood_overlap(likelihoods[i], likelihoods[i + 1]);
+                    
+                    overlaps[i] = new_overlap;
+                }
+                if(i > 0){
+                    let new_overlap = normal_overlap_approx(levels[i - 1], error[i - 1], levels[i], error[i]) 
+                    * likelihood_overlap(likelihoods[i - 1], likelihoods[i]);
+                    overlaps[i - 1] = new_overlap;
+                }
+
+            }
+            let ons = -1;
+            while(true){
+                overlaps = [];
+                for(let i=0; i< levels.length; i++){
+                    for(let j=i; j<levels.length; j++){
+                        if(segments[j][0] - segments[i].at(-1) < max_distance * (segments[i].length + segments[j].length)){
+                            overlaps.push(normal_overlap_approx(levels[i], error[i], levels[j], error[j]) * likelihood_overlap(likelihoods[i], likelihoods[j]));
+                        }
+                    }
+                }
+                
+                if(overlaps.length == 0){
+                    break
+                }
+                let max_overlap = arrayMax(overlaps);
+                if(max_overlap < overlap_min){
+                    break
+                }
+                let i = 0; 
+                let j = 1;
+                while (i < segments.length - 1){
+                    let overlap_value = normal_overlap_approx(levels[i], error[i], levels[j], error[j]) * likelihood_overlap(likelihoods[i], likelihoods[j]);
+
+                    if((segments[j][0] - segments[i].at(-1)) < max_distance * (segments[i].length + segments[j].length) && overlap_value == max_overlap){
+                        let merge_level = normal_merge(levels[i], error[i], levels[i + 1], error[i + 1]);
+
+                        levels[i] = merge_level.nl;
+                        error[i] = merge_level.ne;
+                        let nlh = likelihoods[i].map((l_value, l_idx) => { return l_value * likelihoods[i+1][l_idx]});
+                        let nlh_sum = nlh.reduce((a, c_value) => {return a + c_value});
+                        likelihoods[i] = nlh.map(function(item) { return item/nlh_sum } );
+
+                        
+                        segments[i].push(...segments[i+1]);
+                        segments[i] = segments[i].sort((a,b) => a-b);
+
+                        levels.splice(j, 1);
+                        error.splice(j, 1);
+                        segments.splice(j, 1);
+                        likelihoods.splice(j, 1);
+                        
+                        if(j >= segments.length){
+                            i += 1;
+                            j = i + 1;
+                        }
+
+                    }else {
+                        j += 1;
+                        if(j >= segments.length){
+                            i += 1;
+                            j = i + 1;
+                        }
+                    }
+                }
+                if(ons == segments.length){
+                    break
+                }
+                ons = segments.length;
+            }
+            // console.log('final segments', segments)
+            
+            segments.forEach((seg_value, seg_idx) => {
+                let baf_info = likelihood_baf_pval(likelihoods[seg_idx]);
+                if(seg_value.length > 1){
+
+                    seg_value.forEach((bin, bin_idx) =>{
+                        gstat_rd_all.push(wig[bin]);
+                        if(baf_info.mean <= baf_threshold){
+                            gstat_rd0.push(wig[bin]);
+                        }
+                        wig[bin].segment_score = levels[seg_idx];
+                    });
+                    gstat_rd.push(levels[seg_idx]);
+                    gstat_error.push(error[seg_idx]);
+                    gstat_lh.push(likelihoods[seg_idx]);
+
+                }
+
+            });
+
+            continue
+        }
+        
+        // Third stage for call
+        
+        // let data = gstat_rd0.lengthn == 0 ?  gstat_rd_all: gstat_rd0 ;
+        
+        let points = parseInt(1000 * (1 - min_cell_fraction));
+        if(points == 0){
+            points = 1;
+        }
+        let x = g_utils.linspace(min_cell_fraction, 1, points);
+        let master_lh = {};
+        let germline_lh = {};
+        for(let cn=10; cn > -1; cn--){
+            for(let h1=0; h1 < (cn/2+1); h1++){
+                let h2 = cn - h1;
+                let mrd = x.map((v, idx) => {return 1-v +v*cn/2});
+                let g_mrd = cn / 2;
+                let g_mbaf;
+                let mbaf;
+                if(cn > 0){
+                    g_mbaf = 0.5 - (h1 / (h1 + h2));
+                    mbaf = x.map((v, idx) => {return 0.5 - (1 - v + v * h1) / (2 - 2 * v + (h1 + h2) * v)});
+                   
+                }else {
+                    g_mbaf = 0;
+                    mbaf =  x.map((v, idx) => {return 0*v});
+                }
+                
+                for( let ei=0; ei < gstat_rd.length; ei++){
+                        
+                    let g_lh = normal(g_mrd * this.globalMean, 1, gstat_rd[ei], gstat_error[ei]) * likelihood_of_baf(gstat_lh[ei], 0.5 + g_mbaf);
+                    if(ei in germline_lh){
+                        germline_lh[ei].push([cn, h1, h2, g_lh, 1.0]);
+                    }else {
+                        germline_lh[ei] = [cn, h1, h2, g_lh, 1.0];
+                    }
+                    let slh = 0;
+                    let max_lh = 0;
+                    let max_x = 0;
+                    mrd.forEach((mi, idx) => {
+                        if(!isNaN(mbaf[idx])){
+                            let tmpl = normal(mi * this.globalMean, 1, gstat_rd[ei], gstat_error[ei]) * likelihood_of_baf(gstat_lh[ei], 0.5 + mbaf[idx]);
+                            slh += tmpl;
+                            if(tmpl > max_lh){
+                                max_lh = tmpl;
+                                max_x = x[idx];
+                            }
+                        }
+                    });
+                    if(ei in master_lh){
+                        master_lh[ei].push([cn, h1, h2, slh / x.length, max_x]);
+                    }else {
+                        master_lh[ei] = [cn, h1, h2, slh / x.length, max_x];
+                    }
+                }
+                
+                for( let ei=0; ei < gstat_rd.length; ei++){
+                    if(event_type == "germline"){
+                        master_lh[ei].sort((a, b) => a[3] - b[3]);
+                    }
+                    else {
+                        master_lh[ei].sort((a, b) => a[3] - b[3]);
+                        if(event_type == "both"){
+                            
+                            germline_lh[ei].sort((a, b) => a[3] - b[3]);
+                            if(germline_lh[ei][0][3] > master_lh[ei][0][3]){
+                                //let tmp_list = list(filter( lambda x: x[0] != germline_lh[ei][0][0] and x[1] != germline_lh[ei][0][1], master_lh[ei]))
+                                let tmp_list = master_lh[ei].filter((x) => (x[0] != germline_lh[ei][0][0]) && (x[1] <= germline_lh[ei][0][1]));
+                                // console.log('tmp_list', tmp_list)
+                                // master_lh[ei] = [germline_lh[ei][0]] + tmp_list
+                                master_lh[ei] = [germline_lh[ei][0]].push(...tmp_list);
+                            }
+                        }
+                    }
+                }
+                for( let ei=0; ei < gstat_rd.length; ei++){
+                    if(master_lh[ei][0][0] > 2);
+                    if(master_lh[ei][0][0] < 2);
+                    gstat_rd[ei] / this.globalMean;
+                    t_dist.t_test_1_sample(this.globalMean, gstat_rd[ei], gstat_error[ei], gstat_n[ei]);
+                    // console.log(etype)
+
+                }
+                
+
+                // break
+            }
+            
+        }
+        
+        var rawbinScore = this.formatDataStructure(this.wigFeatures, 'binScore', this.globalMean);
+        var callScore = this.formatDataStructure(this.wigFeatures, 'segment_score', this.globalMean);
+        
+        return {binScore: rawbinScore, segment_score: callScore}
+        
     }
 
-    histogram(data, bins) {
-        const step = bins[1] - bins[0];
-        const hist_bins = [];
+    formatDataStructure(wigFeatures, feature_column, scaling_factor = 1) {
+        const results = [];
+        for (const [chr, wig] of Object.entries(wigFeatures)) {
 
-        data.forEach((value, index) => {
-            bins.forEach((bin_value, bin_index) => {
-                if (!hist_bins[bin_value]) {
-                    hist_bins[bin_value] = { count: 0 };
+            wig.forEach(sample => {
+                var new_sample = { ...sample };
+                if (scaling_factor != 1) {
+                    new_sample.value = sample[feature_column] / scaling_factor * 2;
                 }
-                if (bin_value <= value && value < bin_value + step) {
-                    hist_bins[bin_value].count++;
-                    return false;
+                results.push(new_sample);
+            });
+        }
+
+        return results
+    }
+
+    formatDataStructure_BAF(feature_column, scaling_factor = 2) {
+        const baf1 = [];
+        const baf2 = [];
+        for (const [chr, wig] of Object.entries(this.wigFeatures)) {
+
+            wig.forEach(sample => {
+                
+                var baf1_value = { ...sample };
+                var baf2_value = { ...sample };
+                
+                let value = sample[feature_column];
+                if (value != 0.5){
+                    baf2_value.value = -2 * (1 - value);
+                    baf2.push(baf2_value);
                 }
+                baf1_value.value = -2 * value;
+                baf1.push(baf1_value);
+                    
             });
-        });
-        const dist_p = [];
-        hist_bins.forEach((bin, index) => { dist_p.push(bin.count); });
-        return dist_p
+        }
+        
+
+        return [baf1, baf2]
     }
+}
 
+function arrayMax(arr) {
+    return arr.reduce(function (p, v) {
+      return ( p > v ? p : v );
+    });
+  }
+
+/**
+ * Normal distribution.
+ * 
+ * @param {float} x - Variable.
+ * @param {float} a - area
+ * @param {float} x0 -  Mean value
+ * @param {float} sigma - Sigma
+ * @returns {float} - Value of distribution in x.
+ */
+function normal(x, a, x0, sigma){
+  
+  return a * Math.exp(-1* (x - x0) ** 2 / (2 * sigma ** 2)) / Math.sqrt(2 * Math.PI) / sigma
+
+}
+
+/**
+ *  Calculates two normal distributions overlap area.
+ * 
+ * @param {float} m1 - Mean value of the first distribution
+ * @param {float} s1 - Sigma of the first distribution
+ * @param {float} m2 - Mean value for second distribution
+ * @param {float} s2 - Sigma of the second distribution
+ * 
+ * @returns {float} area - Area of overlap
+ */
+function normal_overlap_approx(m1, s1, m2, s2){
+   
+    return Math.exp(-1* (m1-m2)**2/ (s1**2+s2**2))
+}
+
+
+/**
+ * Returns overlap area of two likelihood functions.
+ * 
+ * @param {*} lk1 - First likelihood function.
+ * @param {*} lk2 - Second likelihood function.
+ * 
+ * @returns {float}  - Overlap area.
+ */
+function likelihood_overlap(likelihood_1, likelihood_2){
+    let sum;
+    try{
+        sum = likelihood_1.reduce((accumulator, currentValue, currentIndex) => {return accumulator + Math.min(currentValue, likelihood_2[currentIndex])});
+    }catch{
+        console.log("Failed to find likelihood overlap: ", likelihood_1, likelihood_2);
+        return 0
+    }
+
+    return sum
 }
 
+/**
+ * Calculates normal distribution that is product of two given normal distributions.
+ * 
+ * @param {float} m1 - Mean value of the first distribution
+ * @param {float} s1 - Sigma of the first distribution
+ * @param {float} m2 - Mean value for second distribution
+ * @param {float} s2 - Sigma of the second distribution
+ * @returns {Object} An object representing the first distribution
+ * @property {float} nl - Mean value of the first distribution
+ * @property {float} ne - Sigma of the first distribution
+ */
+function normal_merge(m1, s1, m2, s2){
+   
+    if((s1 == 0) && (s2 == 0)){
+        return {nl: 0.5 * (m1 + m2), ne: 0}
+    }
+    else {
+        return {nl: (m1 * s2 * s2 + m2 * s1 * s1) / (s1 * s1 + s2 * s2), ne: Math.sqrt(s1 * s1 * s2 * s2 / (s1 * s1 + s2 * s2))}
+    }
+}
+
+/**
+ * Calculates likelihood for given baf
+ * @param {*} likelihood 
+ * @param {*} baf 
+ * @returns {float}  likelihood value
+ */
+function likelihood_of_baf(likelihood, baf){
+   
+    let bin = parseInt(baf * (likelihood.length - 1));
+    let fr = baf * (likelihood.length - 1) - bin;
+    if(bin < likelihood.length - 1){
+        return likelihood[bin] * (1 - fr) + likelihood[bin + 1] * fr
+    }
+    else {
+        return likelihood[bin]
+    }
+}
+
+/**
+ * 
+ * Calculates baf level and p-value for given likelihood function.
+ * 
+ * @param {*} likelihood 
+ * @returns {Object} An object representing BAF
+ * @property {float} mean  BAF level (difference from 1/2)
+ * @property {float} p  p-value for event different than 1/2
+ */
+function likelihood_baf_pval(likelihood) {
+    const res = likelihood.length;
+    const max_lh = Math.max(...likelihood);
+    let ix = likelihood.indexOf(max_lh);
+    if (ix > Math.floor(res / 2)) {
+      ix = res - 1 - ix;
+    }
+    const b = (res / 2 - ix) / (res + 1);
+  
+    const ix1 = Math.floor((res / 2 + ix) / 2);
+    const ix2 = res - 1 - ix1;
+    let p = likelihood.slice(ix1, ix2 + 1).reduce((acc, val) => acc + val, 0) / likelihood.reduce((acc, val) => acc + val, 0);
+    if (ix === Math.floor(res / 2)) {
+      p = 1.0;
+    }
+    return {mean:b, p:p};
+  }
+
+  var combined_caller = {CombinedCaller};
+
 function erf(x) {
     var m = 1.0, s = 1.0, sum = x * 1.0;
     for (var i = 1; i < 50; i++) {
@@ -55222,6 +55801,10 @@ class Partition {
     }
 }
 
+
+
+var read_depth_caller = { Partition };
+
 class CNVpytorVCF {
     constructor(allVariants, binSize) {
         this.allVariants = allVariants;
@@ -55349,13 +55932,11 @@ class CNVpytorVCF {
     readDepthMeanshift(wigFeatures) {
 
         // Get global mean and standrad deviation
-        var fit_info = new GetFit(wigFeatures);
+        var fit_info = new g_utils.GetFit(wigFeatures);
         var [globamMean, globalStd] = fit_info.fit_data();
-        // console.log('Fitter', globamMean, globalStd)
-
 
         // Apply partition method
-        var partition = new Partition(wigFeatures, globamMean, globalStd);
+        var partition = new read_depth_caller.Partition(wigFeatures, globamMean, globalStd);
         var partition_array = partition.meanShiftCaller();
         var caller_array = partition.cnv_calling();
 
@@ -55386,86 +55967,10 @@ class CNVpytorVCF {
                 results.push(new_sample);
             });
         }
-        // console.log(feature_column, results)
 
         return results
     }
 
-    // function for baf likelihood calculations
-    async computeBAF() {
-        const chromosomes = Object.keys(this.allVariants);
-        const wigFeatures = {};
-        const results = [];
-
-        for (let chr of chromosomes) {
-            const variants = this.allVariants[chr];
-            if (variants.length === 0) continue
-            var featureBin;
-            for (let snp of variants) {
-                featureBin = Math.max(Math.floor(snp.start / this.binSize), 0);
-
-                if (!wigFeatures[chr]) {
-                    wigFeatures[chr] = [];
-                }
-                if (!wigFeatures[chr][featureBin]) {
-                    if (featureBin > 0) {
-                        // calculating the BAF likelihood for previous bin
-                        let previous_featureBin = featureBin - 1;
-                        if (wigFeatures[chr][previous_featureBin]) {
-
-                            const updated_bin = this.get_max_min_score(wigFeatures[chr][previous_featureBin]);
-                            wigFeatures[chr][previous_featureBin] = updated_bin;
-                            results.push(wigFeatures[chr][previous_featureBin]);
-                        }
-                    }
-                    wigFeatures[chr][featureBin] = {
-                        chr,
-                        start: featureBin * this.binSize,
-                        end: (featureBin + 1) * this.binSize,
-                        value: 0,
-                        count: 0,
-                        likelihood_score: [],
-                        min_score: 0,
-                    };
-                }
-                const calls = snp.calls[9];
-                let genotype = calls.genotype;
-                let ad_score = calls.info["AD"].split(',');
-                let ad_a = ad_score[0], ad_b = ad_score[1];
-
-                if ((genotype[0] == 0 && genotype[1] == 1) || (genotype[0] == 1 && genotype[1] == 0)) {
-                    //apply the beta function
-                    if (wigFeatures[chr][featureBin].likelihood_score.length == 0) {
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 200).map((value, index) => {
-                            return beta(ad_a, ad_b, value);
-                        });
-                    } else {
-                        var sum = 0;
-
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 200).map((value, index) => {
-                            var likelihood_value = wigFeatures[chr][featureBin].likelihood_score[index] * beta(ad_a, ad_b, value);
-                            sum = sum + likelihood_value;
-                            return likelihood_value;
-                        });
-
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 200).map((value, index) => {
-                            return wigFeatures[chr][featureBin].likelihood_score[index] / sum;
-                        });
-                    }
-                    wigFeatures[chr][featureBin].count++;
-                }
-            }
-
-            // last feature bin
-            const updated_bin = this.get_max_min_score(wigFeatures[chr][featureBin]);
-            wigFeatures[chr][featureBin] = updated_bin;
-            results.push(wigFeatures[chr][featureBin]);
-        }
-
-        const baf2_result = this.format_BAF_likelihood(wigFeatures);
-        return [results, baf2_result]
-
-    }
     async computeBAF_v2() {
 
         const chromosomes = Object.keys(this.allVariants);
@@ -55520,19 +56025,19 @@ class CNVpytorVCF {
                 if ((genotype[0] == 0 && genotype[1] == 1) || (genotype[0] == 1 && genotype[1] == 0)) {
                     //apply the beta function
                     if (wigFeatures[chr][featureBin].likelihood_score.length == 0) {
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                        wigFeatures[chr][featureBin].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                             return beta(ad_a, ad_b, value);
                         });
                     } else {
                         var sum = 0;
 
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                        wigFeatures[chr][featureBin].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                             var likelihood_value = wigFeatures[chr][featureBin].likelihood_score[index] * beta(ad_a, ad_b, value);
                             sum = sum + likelihood_value;
                             return likelihood_value;
                         });
 
-                        wigFeatures[chr][featureBin].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                        wigFeatures[chr][featureBin].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                             return wigFeatures[chr][featureBin].likelihood_score[index] / sum;
                         });
                     }
@@ -55578,7 +56083,6 @@ class CNVpytorVCF {
         if (sample.likelihood_score.length > 0) {
             const max = Math.max(...sample.likelihood_score);
             const res = sample.likelihood_score.indexOf(max);
-            sample.likelihood_score = [];
             sample.value = Math.max(res / 100, 1 - res / 100);
             sample.min_score = Math.min(res / 100, 1 - res / 100);
 
@@ -55594,7 +56098,7 @@ class CNVpytorVCF {
 
         //console.log('getAllbins', bins["value"])
 
-        const fitter = new GetFit(bins);
+        const fitter = new g_utils.GetFit(bins);
 
         fitter.fit_data();
         //  dconsole.log('rd list', distParams)
@@ -55602,7 +56106,7 @@ class CNVpytorVCF {
         return bins
     }
 
-    async read_rd_baf(){
+    async read_rd_baf(caller='ReadDepth'){
         
         const chromosomes = Object.keys(this.allVariants);
         var wigFeatures = {};
@@ -55648,13 +56152,22 @@ class CNVpytorVCF {
             }
         
         }
-        
+    
         var avgbin = this.adjust_bin_size(wigFeatures);
+        var finalFeatureSet;
+        if(caller == 'ReadDepth'){
+            finalFeatureSet = this.readDepthMeanshift(avgbin);
+            var baf = this.formatDataStructure_BAF(avgbin, 'max_likelihood');
+        }else if(caller=='2D'){
+            
+            let caller_obj = new combined_caller.CombinedCaller(avgbin,  this.binSize);        
+            let processed_bins = await caller_obj.call_2d();
+            
+            finalFeatureSet = [processed_bins.binScore, [], processed_bins.segment_score];
+    
+            var baf = caller_obj.formatDataStructure_BAF('max_likelihood');
+        }
         
-        let finalFeatureSet = this.readDepthMeanshift(avgbin);
-        
-        //var rawbinScore = this.formatDataStructure(avgbin, 'binScore', globamMean)
-        var baf = this.formatDataStructure_BAF(avgbin, 'max_likelihood');
 
         return [finalFeatureSet, baf]
     }
@@ -55717,19 +56230,19 @@ class CNVpytorVCF {
                             
                             wigFeatures[chr][j].hets.forEach((hets, hets_idx) => {
                                 if(avgbin[chr][k].likelihood_score.length == 0){
-                                    avgbin[chr][k].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                                    avgbin[chr][k].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                                         return beta(hets.ref, hets.alt, value);
                                     });
                                 }
                                 else {
                                     var likelihood_sum = 0;
-                                    avgbin[chr][k].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                                    avgbin[chr][k].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                                         var likelihood_value = avgbin[chr][k].likelihood_score[index] * beta(hets.ref, hets.alt, value);
                                         likelihood_sum += likelihood_value;
                                         return likelihood_value;
                                     });
 
-                                    avgbin[chr][k].likelihood_score = linspace(0, 1, 100).map((value, index) => {
+                                    avgbin[chr][k].likelihood_score = g_utils.linspace(0, 1, 100).map((value, index) => {
                                         return avgbin[chr][k].likelihood_score[index] / likelihood_sum;
                                     });
                        
@@ -55754,19 +56267,6 @@ function beta(a, b, p, phased = true) {
     return p ** a * (1 - p) ** b + p ** b * (1 - p) ** a;
 }
 
-function linspace(a, b, n) {
-    if (typeof n === "undefined") n = Math.max(Math.round(b - a) + 1, 1);
-    if (n < 2) {
-        return n === 1 ? [a] : [];
-    }
-    var ret = Array(n);
-    n--;
-    for (let i = n; i >= 0; i--) {
-        ret[i] = (i * b + (n - i) * a) / n;
-    }
-    return ret;
-}
-
 /*
 * The MIT License (MIT)
 *
@@ -55877,29 +56377,43 @@ class CNVPytorTrack extends TrackBase {
             }, Object.create(null));
 
             const cnvpytor_obj = new CNVpytorVCF(allVariants, this.bin_size);
-            //const wigFeatures = await cnvpytor_obj.computeReadDepth()
-            //const bafFeatures = await cnvpytor_obj.computeBAF_v2()
-            const dataWigs = await cnvpytor_obj.read_rd_baf();
-            const wigFeatures = dataWigs[0];
-            const bafFeatures = dataWigs[1];
             
+            let wigFeatures;
+            let bafFeatures;
             this.wigFeatures_obj = {};
-            this.wigFeatures_obj[this.bin_size] = {
-                "RD_Raw": wigFeatures[0],
-                "RD_Raw_gc_coor": wigFeatures[1],
-                "ReadDepth": wigFeatures[2],
-                "2D": [],
-                "BAF1": bafFeatures[0],
-                "BAF2": bafFeatures[1]
-            };
-            this.rd_bins = [this.bin_size];
-            this.available_callers = ["ReadDepth"];
+            this.wigFeatures_obj[this.bin_size] = {};
+
+            let dataWigs;
+            if(this.config.cnv_caller == '2D'){
+                
+                dataWigs = await cnvpytor_obj.read_rd_baf('2D');
+
+                wigFeatures = dataWigs[0];
+                bafFeatures = dataWigs[1];
+                this.wigFeatures_obj[this.bin_size]['2D'] = wigFeatures[2];
+
+                this.available_callers = ['2D'];
+            }else {
+                dataWigs = await cnvpytor_obj.read_rd_baf();
+                wigFeatures = dataWigs[0];
+                bafFeatures = dataWigs[1];
+                this.wigFeatures_obj[this.bin_size]['ReadDepth'] = wigFeatures[2];
+                this.available_callers = ['ReadDepth'];
+            }
+            
+            this.wigFeatures_obj[this.bin_size]['RD_Raw'] = wigFeatures[0];
+            this.wigFeatures_obj[this.bin_size]['RD_Raw_gc_coor'] = wigFeatures[1];
+            this.wigFeatures_obj[this.bin_size]['BAF1'] = bafFeatures[0];
+            this.wigFeatures_obj[this.bin_size]['BAF2'] = bafFeatures[1];
+            
+            this.available_bins = [this.bin_size];
+            
             this.set_available_callers();
 
         } else {
             this.cnvpytor_obj =   new HDF5Reader(this.config.url, this.bin_size);
             this.wigFeatures_obj = await this.cnvpytor_obj.get_rd_signal(this.bin_size);
-            this.rd_bins = this.cnvpytor_obj.rd_bins;
+            this.available_bins = this.cnvpytor_obj.available_bins;
             this.available_callers = this.cnvpytor_obj.callers;
             this.set_available_callers();
         }
@@ -56012,7 +56526,7 @@ class CNVPytorTrack extends TrackBase {
 
         items.push('<hr/>');
         items.push("Bin Sizes");
-        for (let rd_bin of this.rd_bins) {
+        for (let rd_bin of this.available_bins) {
             const checkBox = createCheckbox(rd_bin, rd_bin === this.bin_size);
             items.push({
                 object: $$1(checkBox),