@sjcrh/proteinpaint-rust 2.191.1 → 2.192.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (3) hide show
  1. package/Cargo.toml +0 -4
  2. package/package.json +1 -1
  3. package/src/bigwig.rs +0 -676
package/Cargo.toml CHANGED
@@ -25,7 +25,6 @@ statrs = "^0.16.0"
25
25
  libc = "0.2"
26
26
  fishers_exact="^1.0.1"
27
27
  bio = "1.5.0"
28
- bigtools = "^0.1.11"
29
28
  libmath = "^0.2.1"
30
29
  json = "^0.12.4"
31
30
  serde = {version = "^1.0.147", features = ["derive"]}
@@ -67,9 +66,6 @@ path="src/indel.rs"
67
66
  name="fisher"
68
67
  path="src/fisher.rs"
69
68
 
70
- [[bin]]
71
- name="bigwig"
72
- path="src/bigwig.rs"
73
69
 
74
70
  [[bin]]
75
71
  name="sv"
package/package.json CHANGED
@@ -1,5 +1,5 @@
1
1
  {
2
- "version": "2.191.1",
2
+ "version": "2.192.0",
3
3
  "name": "@sjcrh/proteinpaint-rust",
4
4
  "type": "module",
5
5
  "description": "Rust-based utilities for proteinpaint",
package/src/bigwig.rs DELETED
@@ -1,676 +0,0 @@
1
- /*
2
- Syntax:
3
- bigWigSummary syntax:~/proteinpaint/server/utils/bigWigSummary ~/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw chr17 7568451 7591984 940
4
-
5
- local: cd .. && cargo build --release && time echo ~/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw,chr17,7568451,7591984,940 | target/release/bigwig
6
-
7
- bigWigSummary syntax:~/proteinpaint/server/utils/bigWigSummary ~/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw chr17 7575510 7578450 2000
8
-
9
- ~/proteinpaint/server/utils/bigWigInfo -zooms ~/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw
10
- local: cd .. && cargo build --release && time echo ~/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw,chr17,7575510,7578450,2000 | target/release/bigwig
11
-
12
- local: cd .. && cargo build --release && time echo /Users/rpaul1/proteinpaint/hg19/TARGET/DNA/cov-wes/SJALL015634_D1.bw,chr1,47682689,47700849,10 | target/release/bigwig
13
-
14
- url: cd .. && cargo build --release && time echo http://hgdownload.soe.ucsc.edu/goldenPath/hg19/encodeDCC/wgEncodeMapability/wgEncodeCrgMapabilityAlign100mer.bigWig,chr17,7584491,7585468,100 | target/release/bigwig
15
- time ~/proteinpaint/server/utils/bigWigSummary http://hgdownload.soe.ucsc.edu/goldenPath/hg19/encodeDCC/wgEncodeMapability/wgEncodeCrgMapabilityAlign100mer.bigWig chr17 7584491 7585468 100
16
-
17
- url: cd .. && cargo build --release && time echo https://proteinpaint.stjude.org/ppdemo/hg19/bigwig/file.bw,chr17,0,81195210,1140 | target/release/bigwig
18
- cd .. && cargo build --release && time echo /Users/rpaul1/proteinpaint/proteinpaint_demo/hg19/bigwig/file.bw,chr17,7579863,7579920,1140 | target/release/bigwig
19
- cd .. && cargo build --release && time echo /Users/rpaul1/proteinpaint/hg19/PCGP/DNA/cov-wgs/SJOS016_D.bw,chr17,0,81195210,1140 | target/release/bigwig
20
- cd .. && cargo build --release && time echo https://proteinpaint.stjude.org/ppdemo/hg19/bigwig/temp.bw,chr17,0,81195210,1140 | target/release/bigwig
21
- ~/proteinpaint/server/utils/bigWigSummary /Users/rpaul1/proteinpaint/hg19/PCGP/DNA/cov-wgs/SJOS016_D.bw chr17 0 81195210 1140
22
-
23
- cd .. && cargo build --release && time echo http://hgdownload.soe.ucsc.edu/goldenPath/hg19/encodeDCC/wgEncodeMapability/wgEncodeCrgMapabilityAlign100mer.bigWig,chr17,0,81195210,1140 | target/release/bigwig (not working)
24
- ~/proteinpaint/server/utils/bigWigSummary http://hgdownload.soe.ucsc.edu/goldenPath/hg19/encodeDCC/wgEncodeMapability/wgEncodeCrgMapabilityAlign100mer.bigWig chr17 6074169 9086266 1140
25
-
26
- */
27
-
28
- /*
29
- Notes:
30
- The script accepts piped input in this format: {Bigwig_file_path/URL},{chr},{start_region},{stop_region}. See syntax above.
31
-
32
- In case path to file is not correct, the script gives a message "File not found". If the file is found, the aggregated data points are separated by tab character.
33
-
34
- Function cascade:
35
-
36
- main() - Checks if the web url/local file path is correct. If not, it will display "File not found" message and exit. if true, it will collect zoom headers.
37
- calculate_datapoints() - Calculates range for each region for the number of points required by the user.
38
- calculate_appropriate_zoom_level() - Calculates approporiate zoom level (or query raw data) depending upon the range being viewed.
39
-
40
- if web_url {
41
- Some(zoom_level) => use get_zoom_interval()
42
- None => use get_interval()
43
- } else local file {
44
- Some(zoom_level) => use get_zoom_interval()
45
- None => use get_interval()
46
- }
47
- */
48
-
49
- use bigtools::bigwig::ZoomHeader;
50
- use bigtools::bigwigread::BigWigRead;
51
- use bigtools::utils::file::remote_file::RemoteFile;
52
- use std::env;
53
- use std::io;
54
-
55
- fn main() {
56
- let mut input = String::new();
57
- env::set_var("RUST_BACKTRACE", "full");
58
- match io::stdin().read_line(&mut input) {
59
- // Accepting the piped input from nodejs (or command line from testing)
60
- #[allow(unused_variables)]
61
- Ok(n) => {
62
- //println!("{} bytes read", n);
63
- //println!("{}", input);
64
- }
65
- Err(error) => println!("Piping error: {}", error),
66
- }
67
- let args: Vec<&str> = input.split(",").collect(); // Various input from nodejs is separated by "_" character
68
-
69
- //println!("args:{:?}", args);
70
-
71
- let bigwig_file_url: String = args[0].parse::<String>().unwrap(); // Bigwig file name
72
- let chrom: String = args[1].parse::<String>().unwrap(); // Chromosome name
73
- let start_pos: f64 = args[2].parse::<f64>().unwrap(); // Start position
74
- let stop_pos: f64 = args[3].parse::<f64>().unwrap(); // Stop position
75
-
76
- let difference = stop_pos - start_pos;
77
- let datapoints: u32 = args[4].replace("\n", "").parse::<u32>().unwrap(); // Number of intervals
78
-
79
- //println!("start_pos:{}", start_pos);
80
- //println!("stop_pos:{}", stop_pos);
81
- //println!("difference:{}", difference);
82
- //println!("datapoints:{}", datapoints);
83
-
84
- //println!("datapoints_list length:{:?}", datapoints_list);
85
-
86
- let mut is_weburl: bool = false;
87
- if bigwig_file_url.starts_with("http://") == true
88
- || bigwig_file_url.starts_with("https://") == true
89
- || bigwig_file_url.starts_with("www.") == true
90
- {
91
- // Its a web URL
92
- let remote_file = RemoteFile::new(&bigwig_file_url);
93
- let reader = BigWigRead::from(remote_file);
94
- match reader {
95
- Ok(reader) => {
96
- is_weburl = true;
97
- let zoom_headers = reader.info.zoom_headers.clone();
98
- calculate_datapoints(
99
- zoom_headers,
100
- reader,
101
- &bigwig_file_url,
102
- is_weburl,
103
- datapoints,
104
- difference,
105
- chrom,
106
- start_pos as f64,
107
- stop_pos as f64,
108
- );
109
- }
110
- Err(_) => {
111
- println!("Cannot read bigWig file");
112
- }
113
- }
114
- } else {
115
- // Its a local file
116
- let reader = BigWigRead::from_file_and_attach(&bigwig_file_url);
117
- //let a = &reader.info.zoom_headers;
118
- match reader {
119
- Ok(_) => {
120
- let reader = BigWigRead::from_file_and_attach(&bigwig_file_url).unwrap();
121
- let zoom_headers = reader.info.zoom_headers.clone();
122
- calculate_datapoints(
123
- zoom_headers,
124
- reader,
125
- &bigwig_file_url,
126
- is_weburl,
127
- datapoints,
128
- difference,
129
- chrom,
130
- start_pos as f64,
131
- stop_pos as f64,
132
- );
133
- }
134
- Err(_) => {
135
- println!("Cannot read bigWig file");
136
- }
137
- }
138
- }
139
- /*
140
- //println!("zoom_headers:{:?}", zoom_headers);
141
-
142
- if file_found == true {
143
- //println!("datapoints_sum:{:?}", datapoints_sum);
144
- //println!("datapoints_num:{:?}", datapoints_num);
145
-
146
- calculate_datapoints(
147
- zoom_headers,
148
- &bigwig_file_url,
149
- is_weburl,
150
- datapoints,
151
- difference,
152
- chrom,
153
- start_pos as f64,
154
- stop_pos as f64,
155
- );
156
- }
157
- */
158
- }
159
-
160
- fn determine_max(n1: f64, n2: f64) -> f64 {
161
- if n1 >= n2 { n1 } else { n2 }
162
- }
163
-
164
- fn determine_min(n1: f64, n2: f64) -> f64 {
165
- if n1 < n2 { n1 } else { n2 }
166
- }
167
-
168
- #[allow(dead_code)]
169
- fn calculate_appropriate_zoom_level(zoom_headers: Vec<ZoomHeader>, difference: f64) -> Option<u32> {
170
- let mut reduction_levels = Vec::<u32>::new();
171
- let mut closest_level = Option::<u32>::None; // Zoom level will be none at base-pair resolution
172
- let mut unity_added = false;
173
- let max_entries_parsed_limit = 100000; // Maximum number of entries that should be parsed from bigwig file. A very high number will lead to better accuracy as this will lead to selection of a lower zoom level. In contrast, a lower value will decrease run time at the cost of accuracy.
174
- // Parsing out various zoom levels from bigwig file
175
- for reduction_level in zoom_headers.into_iter().map(|entry| entry.reduction_level).rev() {
176
- reduction_levels.push(reduction_level as u32);
177
- }
178
- if reduction_levels.contains(&1) == false {
179
- reduction_levels.push(1); // 1 represents single base-pair level
180
- unity_added = true;
181
- }
182
- reduction_levels.reverse();
183
- //println!("reduction_levels:{:?}", reduction_levels);
184
- for level in reduction_levels {
185
- closest_level = Some(level);
186
- if (difference as f64 / level as f64).floor() < max_entries_parsed_limit as f64 {
187
- break;
188
- }
189
- }
190
- if closest_level == Some(1) && unity_added == true {
191
- closest_level = None;
192
- }
193
- //println!("closest_level:{:?}", closest_level);
194
- closest_level
195
- }
196
-
197
- fn calculate_appropriate_zoom_level_ucsc(zoom_headers: Vec<ZoomHeader>, exact_offset: f64) -> Option<u32> {
198
- let mut reduction_levels = Vec::<u32>::new();
199
- let mut closest_level = Option::<u32>::None; // Zoom level will be none at base-pair resolution
200
- let desired_reduction: u32 = ((exact_offset as f64) / 2.0).floor() as u32;
201
- let mut unity_added = false;
202
- if desired_reduction > 1 {
203
- // Parsing out various zoom levels from bigwig file
204
- for reduction_level in zoom_headers.into_iter().map(|entry| entry.reduction_level).rev() {
205
- reduction_levels.push(reduction_level as u32);
206
- }
207
- if reduction_levels.contains(&1) == false {
208
- reduction_levels.push(1); // 1 represents single base-pair level
209
- unity_added = true;
210
- }
211
- reduction_levels.reverse();
212
- //println!("reduction_levels:{:?}", reduction_levels);
213
- let mut closest_diff: u64 = 18446744073709551615; // Highest number allowed by u64 type
214
- for level in reduction_levels {
215
- let diff: u64 = (desired_reduction as i64 - level as i64).abs() as u64;
216
- //println!("level:{}", level);
217
- //println!("diff:{}", diff);
218
- if diff > 0 && diff < closest_diff {
219
- closest_diff = diff;
220
- closest_level = Some(level);
221
- //println!("closest_diff:{}", closest_diff);
222
- }
223
- }
224
- }
225
- if closest_level == Some(1) && unity_added == true {
226
- closest_level = None;
227
- }
228
- //println!("closest_level:{:?}", closest_level);
229
- closest_level
230
- }
231
-
232
- fn calculate_datapoints<
233
- R: bigtools::utils::file::seekableread::Reopen<S>,
234
- S: bigtools::utils::file::seekableread::SeekableRead,
235
- >(
236
- zoom_headers: Vec<ZoomHeader>,
237
- mut reader: BigWigRead<R, S>,
238
- bigwig_file_url: &String,
239
- is_weburl: bool,
240
- datapoints: u32,
241
- difference: f64,
242
- chrom: String,
243
- start_pos: f64,
244
- stop_pos: f64,
245
- ) {
246
- let exact_offset: f64 = difference as f64 / datapoints as f64;
247
- //println!("exact_offset:{}", exact_offset);
248
- let mut datapoints_list = Vec::<f64>::new(); // Vector for storing datapoints
249
- let mut datapoints_sum = vec![0.0 as f64; datapoints as usize]; // Sum of all values within a region
250
- let mut datapoints_num = vec![0 as f64; datapoints as usize]; // Number of all values within a region
251
-
252
- //let zoom_level = calculate_appropriate_zoom_level(zoom_headers, difference);
253
- let zoom_level = calculate_appropriate_zoom_level_ucsc(zoom_headers, exact_offset);
254
-
255
- let mut current_pos: f64 = start_pos as f64; // Initializing current_pos to start position
256
- for _i in 0..datapoints {
257
- datapoints_list.push(current_pos);
258
- current_pos = current_pos as f64 + exact_offset as f64;
259
- }
260
- datapoints_list.push(stop_pos as f64);
261
- //println!("datapoints_list:{:?}", datapoints_list);
262
-
263
- if is_weburl == true {
264
- // Read from a web URL
265
- match zoom_level {
266
- Some(level) => {
267
- // Using some zoom level
268
- //let pre = std::time::Instant::now();
269
- let bigwig_output = reader
270
- .get_zoom_interval(&chrom, start_pos as u32, stop_pos as u32, level)
271
- .unwrap();
272
- //dbg!(pre.elapsed());
273
- let mut i = 0;
274
- let mut start_region = datapoints_list[i];
275
- let mut end_region = datapoints_list[i + 1];
276
- for entry in bigwig_output {
277
- match entry {
278
- Ok(v) => {
279
- //println!(
280
- // "start,end,sum,bases_covered:{},{},{},{}",
281
- // v.start, v.end, v.summary.sum, v.summary.bases_covered
282
- //);
283
-
284
- if v.start == v.end {
285
- continue;
286
- } else {
287
- if (v.start as f64 <= start_region && end_region < v.end as f64)
288
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
289
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
290
- || (start_region >= v.start as f64 && (v.end as f64) < end_region)
291
- {
292
- // Calculate sum and number for this region
293
- //println!("i:{}", i);
294
- //println!("v.start:{}", v.start);
295
- //println!("v.end:{}", v.end);
296
- //println!("start_region:{}", start_region);
297
- //println!("end_region:{}", end_region);
298
- let start_entry_within_region = determine_max(v.start as f64, start_region);
299
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
300
- datapoints_num[i] += (stop_entry_within_region - start_entry_within_region) as f64;
301
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region) as f64
302
- * ((v.summary.sum as f64) / v.summary.bases_covered as f64);
303
- //println!(
304
- // "start_entry_within_region:{}",
305
- // start_entry_within_region
306
- //);
307
- //println!(
308
- // "stop_entry_within_region:{}",
309
- // stop_entry_within_region
310
- //);
311
- //println!("datapoints_num[i]:{}", datapoints_num[i]);
312
- //println!("datapoints_sum[i]:{}", datapoints_sum[i]);
313
- }
314
- let mut iter = 1;
315
- while end_region < v.end as f64 && end_region != stop_pos {
316
- //println!("iter:{}", iter);
317
- //println!("i:{}", i);
318
- //println!("v.start:{}", v.start);
319
- //println!("v.end:{}", v.end);
320
- //println!("start_region:{}", start_region);
321
- //println!("end_region:{}", end_region);
322
- if ((v.start as f64 <= start_region && end_region < v.end as f64)
323
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
324
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
325
- || (start_region >= v.start as f64 && (v.end as f64) < end_region))
326
- && iter > 1
327
- {
328
- // Calculate sum and number for this region
329
- //println!("Hello");
330
- let start_entry_within_region = determine_max(v.start as f64, start_region);
331
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
332
- datapoints_num[i] +=
333
- (stop_entry_within_region - start_entry_within_region) as f64;
334
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region)
335
- as f64
336
- * ((v.summary.sum as f64) / v.summary.bases_covered as f64);
337
- //println!(
338
- // "start_entry_within_region inside:{}",
339
- // start_entry_within_region
340
- //);
341
- //println!(
342
- // "stop_entry_within_region inside:{}",
343
- // stop_entry_within_region
344
- //);
345
- //println!("datapoints_num inside[i]:{}", datapoints_num[i]);
346
- //println!("datapoints_sum inside[i]:{}", datapoints_sum[i]);
347
- }
348
- if end_region <= v.end as f64 {
349
- // Entry spans into next region, need to increment iterator
350
- if i + 2 < datapoints_list.len() {
351
- i += 1;
352
- start_region = datapoints_list[i];
353
- end_region = datapoints_list[i + 1];
354
- }
355
- }
356
- iter += 1;
357
- }
358
- }
359
- }
360
- Err(_) => {
361
- println!("Possible error:{:?}", entry);
362
- }
363
- }
364
- }
365
- }
366
- None => {
367
- // To be used in nucleotide resolution
368
- let bigwig_output = reader.get_interval(&chrom, start_pos as u32, stop_pos as u32).unwrap();
369
- let mut i = 0;
370
- let mut start_region = datapoints_list[i];
371
- let mut end_region = datapoints_list[i + 1];
372
- for entry in bigwig_output {
373
- match entry {
374
- Ok(v) => {
375
- //println!("start,end,value:{},{},{}", v.start, v.end, v.value);
376
- if v.start == v.end {
377
- continue;
378
- } else {
379
- if (v.start as f64 <= start_region && end_region < v.end as f64)
380
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
381
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
382
- || (start_region >= v.start as f64 && (v.end as f64) < end_region)
383
- {
384
- // Calculate sum and number for this region
385
- //println!("i:{}", i);
386
- //println!("v.start:{}", v.start);
387
- //println!("v.end:{}", v.end);
388
- //println!("start_region:{}", start_region);
389
- //println!("end_region:{}", end_region);
390
- let start_entry_within_region = determine_max(v.start as f64, start_region);
391
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
392
- datapoints_num[i] += (stop_entry_within_region - start_entry_within_region) as f64;
393
- datapoints_sum[i] +=
394
- (stop_entry_within_region - start_entry_within_region) as f64 * v.value as f64;
395
- //println!(
396
- // "start_entry_within_region:{}",
397
- // start_entry_within_region
398
- //);
399
- //println!(
400
- // "stop_entry_within_region:{}",
401
- // stop_entry_within_region
402
- //);
403
- //println!("datapoints_num[i]:{}", datapoints_num[i]);
404
- //println!("datapoints_sum[i]:{}", datapoints_sum[i]);
405
- }
406
- let mut iter = 1;
407
- while end_region < v.end as f64 && end_region != stop_pos {
408
- //println!("iter:{}", iter);
409
- //println!("i:{}", i);
410
- //println!("v.start:{}", v.start);
411
- //println!("v.end:{}", v.end);
412
- //println!("start_region:{}", start_region);
413
- //println!("end_region:{}", end_region);
414
- if ((v.start as f64 <= start_region && end_region < v.end as f64)
415
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
416
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
417
- || (start_region >= v.start as f64 && (v.end as f64) < end_region))
418
- && iter > 1
419
- {
420
- // Calculate sum and number for this region
421
- //println!("Hello");
422
- let start_entry_within_region = determine_max(v.start as f64, start_region);
423
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
424
- datapoints_num[i] +=
425
- (stop_entry_within_region - start_entry_within_region) as f64;
426
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region)
427
- as f64
428
- * v.value as f64;
429
- //println!(
430
- // "start_entry_within_region inside:{}",
431
- // start_entry_within_region
432
- //);
433
- //println!(
434
- // "stop_entry_within_region inside:{}",
435
- // stop_entry_within_region
436
- //);
437
- //println!("datapoints_num inside[i]:{}", datapoints_num[i]);
438
- //println!("datapoints_sum inside[i]:{}", datapoints_sum[i]);
439
- }
440
- if end_region <= v.end as f64 {
441
- // Entry spans into next region, need to increment iterator
442
- if i + 2 < datapoints_list.len() {
443
- i += 1;
444
- start_region = datapoints_list[i];
445
- end_region = datapoints_list[i + 1];
446
- } else {
447
- break;
448
- }
449
- }
450
- iter += 1;
451
- }
452
- }
453
- }
454
- Err(_) => {
455
- println!("Possible error:{:?}", entry);
456
- }
457
- }
458
- }
459
- }
460
- }
461
- } else {
462
- // Read from a local file
463
- let mut reader = BigWigRead::from_file_and_attach(&bigwig_file_url).unwrap();
464
- match zoom_level {
465
- Some(level) => {
466
- // Using some zoom level
467
- let bigwig_output = reader
468
- .get_zoom_interval(&chrom, start_pos as u32, stop_pos as u32, level)
469
- .unwrap();
470
- let mut i = 0;
471
- let mut start_region = datapoints_list[i];
472
- let mut end_region = datapoints_list[i + 1];
473
- for entry in bigwig_output {
474
- match entry {
475
- Ok(v) => {
476
- //println!(
477
- // "start,end,sum,bases_covered:{},{},{},{}",
478
- // v.start, v.end, v.summary.sum, v.summary.bases_covered
479
- //);
480
-
481
- if v.start == v.end {
482
- continue;
483
- } else {
484
- if (v.start as f64 <= start_region && end_region < v.end as f64)
485
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
486
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
487
- || (start_region >= v.start as f64 && (v.end as f64) < end_region)
488
- {
489
- // Calculate sum and number for this region
490
- //println!("i:{}", i);
491
- //println!("v.start:{}", v.start);
492
- //println!("v.end:{}", v.end);
493
- //println!("start_region:{}", start_region);
494
- //println!("end_region:{}", end_region);
495
- let start_entry_within_region = determine_max(v.start as f64, start_region);
496
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
497
- datapoints_num[i] += (stop_entry_within_region - start_entry_within_region) as f64;
498
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region) as f64
499
- * ((v.summary.sum as f64) / v.summary.bases_covered as f64);
500
- //println!(
501
- // "start_entry_within_region:{}",
502
- // start_entry_within_region
503
- //);
504
- //println!(
505
- // "stop_entry_within_region:{}",
506
- // stop_entry_within_region
507
- //);
508
- //println!("datapoints_num[i]:{}", datapoints_num[i]);
509
- //println!("datapoints_sum[i]:{}", datapoints_sum[i]);
510
- }
511
- let mut iter = 1;
512
- while end_region < v.end as f64 && end_region != stop_pos {
513
- //println!("iter:{}", iter);
514
- //println!("i:{}", i);
515
- //println!("v.start:{}", v.start);
516
- //println!("v.end:{}", v.end);
517
- //println!("start_region:{}", start_region);
518
- //println!("end_region:{}", end_region);
519
- if ((v.start as f64 <= start_region && end_region < v.end as f64)
520
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
521
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
522
- || (start_region >= v.start as f64 && (v.end as f64) < end_region))
523
- && iter > 1
524
- {
525
- // Calculate sum and number for this region
526
- let start_entry_within_region = determine_max(v.start as f64, start_region);
527
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
528
- datapoints_num[i] +=
529
- (stop_entry_within_region - start_entry_within_region) as f64;
530
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region)
531
- as f64
532
- * ((v.summary.sum as f64) / v.summary.bases_covered as f64);
533
- //println!(
534
- // "start_entry_within_region inside:{}",
535
- // start_entry_within_region
536
- //);
537
- //println!(
538
- // "stop_entry_within_region inside:{}",
539
- // stop_entry_within_region
540
- //);
541
- //println!("datapoints_num inside[i]:{}", datapoints_num[i]);
542
- //println!("datapoints_sum inside[i]:{}", datapoints_sum[i]);
543
- }
544
- if end_region <= v.end as f64 {
545
- // Entry spans into next region, need to increment iterator
546
- if i + 2 < datapoints_list.len() {
547
- i += 1;
548
- start_region = datapoints_list[i];
549
- end_region = datapoints_list[i + 1];
550
- } else {
551
- break;
552
- }
553
- }
554
- iter += 1;
555
- }
556
- }
557
- }
558
- Err(_) => {
559
- println!("Possible error:{:?}", entry);
560
- }
561
- }
562
- }
563
- }
564
- None => {
565
- // To be used in nucleotide resolution
566
- let bigwig_output = reader.get_interval(&chrom, start_pos as u32, stop_pos as u32).unwrap();
567
- let mut i = 0;
568
- let mut start_region = datapoints_list[i];
569
- let mut end_region = datapoints_list[i + 1];
570
- for entry in bigwig_output {
571
- match entry {
572
- Ok(v) => {
573
- //println!("start,end,value:{},{},{}", v.start, v.end, v.value);
574
- if v.start == v.end {
575
- continue;
576
- } else {
577
- if (v.start as f64 <= start_region && end_region < v.end as f64)
578
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
579
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
580
- || (start_region >= v.start as f64 && (v.end as f64) < end_region)
581
- {
582
- // Calculate sum and number for this region
583
- //println!("i:{}", i);
584
- //println!("v.start:{}", v.start);
585
- //println!("v.end:{}", v.end);
586
- //println!("start_region:{}", start_region);
587
- //println!("end_region:{}", end_region);
588
- let start_entry_within_region = determine_max(v.start as f64, start_region);
589
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
590
- datapoints_num[i] += (stop_entry_within_region - start_entry_within_region) as f64;
591
- datapoints_sum[i] +=
592
- (stop_entry_within_region - start_entry_within_region) as f64 * v.value as f64;
593
- //println!(
594
- // "start_entry_within_region:{}",
595
- // start_entry_within_region
596
- //);
597
- //println!(
598
- // "stop_entry_within_region:{}",
599
- // stop_entry_within_region
600
- //);
601
- //println!("datapoints_num[i]:{}", datapoints_num[i]);
602
- //println!("datapoints_sum[i]:{}", datapoints_sum[i]);
603
- }
604
- let mut iter = 1;
605
- while end_region < v.end as f64 && end_region != stop_pos {
606
- //println!("iter:{}", iter);
607
- //println!("i:{}", i);
608
- //println!("v.start:{}", v.start);
609
- //println!("v.end:{}", v.end);
610
- //println!("start_region:{}", start_region);
611
- //println!("end_region:{}", end_region);
612
- if ((v.start as f64 <= start_region && end_region < v.end as f64)
613
- || (v.start as f64 >= start_region && (v.start as f64) < end_region)
614
- || (v.end as f64 >= start_region && (v.end as f64) < end_region)
615
- || (start_region >= v.start as f64 && (v.end as f64) < end_region))
616
- && iter > 1
617
- {
618
- // Calculate sum and number for this region
619
- //println!("Hello");
620
- let start_entry_within_region = determine_max(v.start as f64, start_region);
621
- let stop_entry_within_region = determine_min(v.end as f64, end_region);
622
- datapoints_num[i] +=
623
- (stop_entry_within_region - start_entry_within_region) as f64;
624
- datapoints_sum[i] += (stop_entry_within_region - start_entry_within_region)
625
- as f64
626
- * v.value as f64;
627
- //println!(
628
- // "start_entry_within_region inside:{}",
629
- // start_entry_within_region
630
- //);
631
- //println!(
632
- // "stop_entry_within_region inside:{}",
633
- // stop_entry_within_region
634
- //);
635
- //println!("datapoints_num inside[i]:{}", datapoints_num[i]);
636
- //println!("datapoints_sum inside[i]:{}", datapoints_sum[i]);
637
- }
638
- if end_region <= v.end as f64 {
639
- // Entry spans into next region, need to increment iterator
640
- if i + 2 < datapoints_list.len() {
641
- i += 1;
642
- start_region = datapoints_list[i];
643
- end_region = datapoints_list[i + 1];
644
- } else {
645
- break;
646
- }
647
- }
648
- iter += 1;
649
- }
650
- }
651
- }
652
- Err(_) => {
653
- println!("Possible error:{:?}", entry);
654
- }
655
- }
656
- }
657
- }
658
- }
659
- }
660
-
661
- //calculate_datapoints(bigwig_output, chrom, start_pos, stop_pos, data_points);
662
-
663
- let mut output_vec: String = "".to_string();
664
- for i in 0..datapoints_num.len() {
665
- let mean;
666
- if datapoints_num[i] == 0.0 {
667
- mean = 0.0;
668
- } else {
669
- mean = datapoints_sum[i] / datapoints_num[i] as f64;
670
- }
671
- output_vec.push_str(&mean.to_string());
672
- output_vec.push_str(&"\t".to_string());
673
- }
674
- output_vec.pop();
675
- println!("{}", output_vec);
676
- }