update GCoverage from BED

genomkit/__init__.py

@@ -8,4 +8,4 @@
 from .variants.gvariant import GVariant
 from .variants.gvariants import GVariants
 
-__version__ = "0.2.5"
+__version__ = "0.2.6"

genomkit/coverages/gcoverages.py

@@ -71,22 +71,25 @@ def calculate_coverage_GRegions(self, regions, scores,
         :type regions: GRegions
         :param scores: Provide the scores for calculating the coverage
         :type scores: GRegions
-        :param strandness: Make this operation strandness specific, defaults to False
+        :param strandness: Make this operation strandness specific, defaults
+                           to False
         :type strandness: bool, optional
         """
         from genomkit import GRegions
         assert isinstance(regions, GRegions)
         assert isinstance(scores, GRegions)
         filtered_scores = scores.intersect(target=regions,
-                                           mode="ORIGIN")
+                                           mode="ORIGINAL")
         for region in tqdm(regions, desc="Calculating coverage",
                            total=len(regions)):
             self.coverage[region] = np.zeros(shape=len(region) //
                                              self.bin_size)
             for target in filtered_scores:
                 if region.overlap(target, strandness=strandness):
-                    start_ind = (target.start - region.start) // self.bin_size
-                    end_ind = (target.end - region.end) // self.bin_size
+                    start_ind = (max(0, target.start - region.start))
+                    start_ind = start_ind // self.bin_size
+                    end_ind = (min(len(region), target.end - region.start))
+                    end_ind = end_ind // self.bin_size
                     for i in range(start_ind, end_ind):
                         self.coverage[region][i] += target.score
 

genomkit/regions/io.py

@@ -5,6 +5,12 @@
 # IO functions
 ###########################################################################
 def load_BED(filename: str):
+    def get_score(score):
+        if score == ".":
+            score = 0
+        else:
+            score = float(score)
+        return score
     from genomkit import GRegion, GRegions
     if not os.path.exists(filename):
         raise FileNotFoundError(f"The file '{filename}' does not exist.")
@@ -28,20 +34,20 @@ def load_BED(filename: str):
                                         start=int(infos[1]),
                                         end=int(infos[2]),
                                         name=infos[3],
-                                        score=infos[4]))
+                                        score=get_score(infos[4])))
                     elif len(infos) == 6:
                         res.add(GRegion(sequence=infos[0],
                                         start=int(infos[1]),
                                         end=int(infos[2]),
                                         name=infos[3],
-                                        score=infos[4],
+                                        score=get_score(infos[4]),
                                         orientation=infos[5]))
                     elif len(infos) > 6:
                         res.add(GRegion(sequence=infos[0],
                                         start=int(infos[1]),
                                         end=int(infos[2]),
                                         name=infos[3],
-                                        score=infos[4],
+                                        score=get_score(infos[4]),
                                         orientation=infos[5],
                                         data=infos[6:]))
         return res

tests/local_test/examples_bed.ipynb

@@ -132,15 +132,35 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Calculating coverage: 100%|██████████| 500/500 [00:00<00:00, 250226.94it/s]\n"
+      "Calculating coverage: 100%|██████████| 48709/48709 [00:49<00:00, 977.10it/s] \n"
      ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: >"
+      ]
+     },
+     "execution_count": 2,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
     }
    ],
    "source": [
@@ -149,16 +169,60 @@
     "# Generate a heatmap from two BED files: one BED file is used as windows and the other used as the signal\n",
     "DMLs = GRegions(name=\"DMLs\", load=\"DML.bed\")\n",
     "DMLs.sort()\n",
+    "DMLs.extend(upstream=5, downstream=5, inplace=True)\n",
     "TSSs = GRegions(name=\"genes\", load=\"/Users/ckuo/rgtdata/mm10/genes_Gencode_mm10.bed\")\n",
-    "TSSs.resize(extend_upstream=500, extend_downstream=500,\n",
+    "TSSs.resize(extend_upstream=1000, extend_downstream=1000,\n",
     "                    center=\"5prime\", inplace=True)\n",
+    "TSSs.sampling(size=10000)\n",
+    "# TSSs.filter_by_names(names=, inplace=True)\n",
     "cov = GCoverages(bin_size=1)\n",
-    "cov.calculate_coverage_GRegions(regions=promoters, scores=DMLs)\n",
+    "cov.calculate_coverage_GRegions(regions=TSSs, scores=DMLs)\n",
+    "cov.flip_negative_regions()\n",
     "df = cov.get_dataframe()\n",
-    "\n",
+    "sns.heatmap(df, xticklabels=False, yticklabels=False, cmap=\"PiYG\")\n",
     "# sns.heatmap(df, annot=True)"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "-0.661197579563083"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "DMLs.elements[1].score"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.338802420436917"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "float('-0.661197579563083') + 1"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 5,
@@ -185,8 +249,26 @@
      "output_type": "display_data"
     }
    ],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.0"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "sns.heatmap(df, xticklabels=False, yticklabels=False, cmap=\"PiYG\")"
+    "df.sum().sum()"
    ]
   }
  ],

tests/test_files/bed/example2.bed

@@ -1,4 +1,4 @@
-chr1    500   1500   Feature1  0      +
-chr1    3500   4500   Feature2  0      +
-chr2    4500   5500   Feature3  0      +
-chr2    7500   8500   Feature4  0      +
+chr1    500   1500   Feature1  10      +
+chr1    3500   4500   Feature2  20      +
+chr2    4500   5500   Feature3  30      +
+chr2    7500   8500   Feature4  40      +

tests/test_gcoverages.py

@@ -36,6 +36,18 @@ def test_calculate_coverage_from_bam(self):
         # ['1']
         self.assertEqual(len(cov.coverage.keys()), 1)
 
+    def test_calculate_coverage_GRegions(self):
+        regions = GRegions(name="test",
+                           load=os.path.join(script_path,
+                                             "test_files/bed/example2.bed"))
+        cov = GCoverages()
+        cov.calculate_coverage_GRegions(regions=regions, scores=regions)
+        self.assertEqual(len(cov.coverage.keys()), 4)
+        self.assertEqual(cov.coverage[regions[0]][0], 10)
+        self.assertEqual(cov.coverage[regions[1]][0], 20)
+        self.assertEqual(cov.coverage[regions[2]][0], 30)
+        self.assertEqual(cov.coverage[regions[3]][0], 40)
+
     def test_get_coverage(self):
         cov = GCoverages()
         cov.load_coverage_from_bigwig(