igv 2.15.0 → 2.15.2

package/dist/igv.js

@@ -18662,6 +18662,8 @@
 
         async _loadURL(url, options) {
 
+            const self = this;
+
             //console.log(`${Date.now()}   ${url}`)
             url = mapUrl$1(url);
 
@@ -18751,7 +18753,7 @@
                             // 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));
@@ -18780,8 +18782,9 @@
                 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) {
@@ -18796,7 +18799,11 @@
                 try {
                     xhr.send(sendData);
                 } catch (e) {
-                    reject(e);
+                    if (isGoogleURL(url) && !options.retries) {
+                        tryGoogleAuth();
+                    } else {
+                        handleError(e);
+                    }
                 }
 
 
@@ -18813,7 +18820,7 @@
                         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) {
@@ -18959,14 +18966,16 @@
      */
     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 {
@@ -23928,7 +23937,7 @@
         }
     };
 
-    const _version = "2.15.0";
+    const _version = "2.15.2";
     function version() {
         return _version
     }
@@ -25765,15 +25774,15 @@
      * @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]);
             }
         }
@@ -25812,11 +25821,14 @@
         ["%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++) {
 
@@ -25874,7 +25886,7 @@
 
                 // 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];
@@ -25922,7 +25934,25 @@
             }
 
             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;
@@ -25946,7 +25976,6 @@
         }
 
         return feature
-
     }
 
     /**
@@ -27258,6 +27287,8 @@
                             }
                             tracklineConfg.autoscale = false;
                             tracklineConfg.dataRange = {min, max};
+                            this.viewLimitMin = min;
+                            this.viewLimitMax = max;
                         }
                     case "name":
                         tracklineConfg[key] = properties[key];
@@ -29156,9 +29187,9 @@
      * @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
@@ -40781,8 +40812,8 @@
                 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);
@@ -54151,11 +54182,13 @@
 
             // 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");
@@ -54199,6 +54232,9 @@
                 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)
@@ -54323,6 +54359,28 @@
             }
             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{
@@ -54363,6 +54421,53 @@
         }
     }
 
+    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)
@@ -54395,6 +54500,21 @@
       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`.
     *
@@ -54539,48 +54659,507 @@
         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++) {
@@ -55228,6 +55807,10 @@
         }
     }
 
+
+
+    var read_depth_caller = { Partition };
+
     class CNVpytorVCF {
         constructor(allVariants, binSize) {
             this.allVariants = allVariants;
@@ -55355,13 +55938,11 @@
         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();
 
@@ -55392,86 +55973,10 @@
                     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);
@@ -55526,19 +56031,19 @@
                     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;
                             });
                         }
@@ -55584,7 +56089,6 @@
             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);
 
@@ -55600,7 +56104,7 @@
 
             //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)
@@ -55608,7 +56112,7 @@
             return bins
         }
 
-        async read_rd_baf(){
+        async read_rd_baf(caller='ReadDepth'){
             
             const chromosomes = Object.keys(this.allVariants);
             var wigFeatures = {};
@@ -55654,13 +56158,22 @@
                 }
             
             }
-            
+        
             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]
         }
@@ -55723,19 +56236,19 @@
                                 
                                 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;
                                         });
                            
@@ -55760,19 +56273,6 @@
         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)
     *
@@ -55883,29 +56383,43 @@
                 }, 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();
             }
@@ -56018,7 +56532,7 @@
 
             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),