Mercurial > repos > bjoern-gruening > bismark

comparison bismark_methylation_extractor @ 3:7eefe5d6eecd draft

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
reupload
author bjoern-gruening
date Tue, 25 Dec 2012 05:54:01 -0500
parents 36d124f44c0a
children
comparison
equal deleted inserted replaced
2:371bb57ac729 3:7eefe5d6eecd
1 #!/usr/bin/perl
2 use warnings;
3 use strict;
4 $|++;
5 use Getopt::Long;
6 use Cwd;
7 use Carp;
8
9 my @filenames; # input files
10 my %counting;
11 my $parent_dir = getcwd();
12
13 my %fhs;
14
15 my $version = 'v0.7.7';
16 my ($ignore,$genomic_fasta,$single,$paired,$full,$report,$no_overlap,$merge_non_CpG,$vanilla,$output_dir,$no_header,$bedGraph,$remove,$coverage_threshold,$counts,$cytosine_report,$genome_folder,$zero,$CpG_only,$CX_context,$split_by_chromosome) = process_commandline();
17
18
19 ### only needed for bedGraph output
20 my @sorting_files; # if files are to be written to bedGraph format, these are the methylation extractor output files
21 my @methylcalls = qw (0 0 0); # [0] = methylated, [1] = unmethylated, [2] = total
22 my @bedfiles;
23
24 ### only needed for genome-wide cytosine methylation report
25 my %chromosomes;
26
27 ##############################################################################################
28 ### Summarising Run Parameters
29 ##############################################################################################
30
31 ### METHYLATION EXTRACTOR
32
33 warn "Summarising Bismark methylation extractor parameters:\n";
34 warn '='x63,"\n";
35
36 if ($single){
37 if ($vanilla){
38 warn "Bismark single-end vanilla format specified\n";
39 }
40 else{
41 warn "Bismark single-end SAM format specified (default)\n"; # default
42 }
43 }
44 elsif ($paired){
45 if ($vanilla){
46 warn "Bismark paired-end vanilla format specified\n";
47 }
48 else{
49 warn "Bismark paired-end SAM format specified (default)\n"; # default
50 }
51 }
52
53 if ($ignore){
54 warn "First $ignore bases will be disregarded when processing the methylation call string\n";
55 }
56
57 if ($full){
58 warn "Strand-specific outputs will be skipped. Separate output files for cytosines in CpG, CHG and CHH context will be generated\n";
59 }
60 if ($merge_non_CpG){
61 warn "Merge CHG and CHH context to non-CpG context specified\n";
62 }
63 ### output directory
64 if ($output_dir eq ''){
65 warn "Output will be written to the current directory ('$parent_dir')\n";
66 }
67 else{
68 warn "Output path specified as: $output_dir\n";
69 }
70
71
72 sleep (1);
73
74 ### BEDGRAPH
75
76 if ($bedGraph){
77 warn "\n\nSummarising bedGraph parameters:\n";
78 warn '='x63,"\n";
79
80 if ($counts){
81 warn "Generating additional output in bedGraph format including methylating counts (output format: <Chromosome> <Start Position> <End Position> <Methylation Percentage> <count methylated> <count non-methylated>)\n";
82 }
83 else{
84 warn "Generating additional sorted output in bedGraph format (output format: <Chromosome> <Start Position> <End Position> <Methylation Percentage>)\n";
85 }
86
87 warn "Using a cutoff of $coverage_threshold read(s) to report cytosine positions\n";
88
89 if ($CX_context){
90 warn "Reporting and sorting methylation information for all cytosine context (sorting may take a long time, you have been warned ...)\n";
91 }
92 else{ # default
93 $CpG_only = 1;
94 warn "Reporting and sorting cytosine methylation information in CpG context only (default)\n";
95 }
96
97 if ($remove){
98 warn "White spaces in read ID names will be removed prior to sorting\n";
99 }
100
101 sleep (1);
102
103 if ($cytosine_report){
104 warn "\n\nSummarising genome-wide cytosine methylation report parameters:\n";
105 warn '='x63,"\n";
106 warn "Generating comprehensive genome-wide cytosine report (output format: <Chromosome> <Start Position> <End Position> <Methylation Percentage> )\n";
107
108
109 if ($CX_context){
110 warn "Reporting methylation for all cytosine contexts. Be aware that this will generate enormous files\n";
111 }
112 else{ # default
113 $CpG_only = 1;
114 warn "Reporting cytosine methylation in CpG context only (default)\n";
115 }
116
117 if ($split_by_chromosome){
118 warn "Splitting the cytosine report output up into individual files for each chromosome\n";
119 }
120
121 ### Zero-based coordinates
122 if ($zero){
123 warn "Using zero-based genomic coordinates (user-defined)\n";
124 }
125 else{ # default, 1-based coords
126 warn "Using 1-based genomic coordinates (default)\n";
127 }
128
129 ### GENOME folder
130 if ($genome_folder){
131 unless ($genome_folder =~/\/$/){
132 $genome_folder =~ s/$/\//;
133 }
134 warn "Genome folder was specified as $genome_folder\n";
135 }
136 else{
137 $genome_folder = '/data/public/Genomes/Mouse/NCBIM37/';
138 warn "Using the default genome folder /data/public/Genomes/Mouse/NCBIM37/\n";
139 }
140 sleep (1);
141 }
142 }
143
144 warn "\n";
145 sleep (5);
146
147 ######################################################
148 ### PROCESSING FILES
149 ######################################################
150
151 foreach my $filename (@filenames){
152 # resetting counters and filehandles
153 %fhs = ();
154 %counting =(
155 total_meCHG_count => 0,
156 total_meCHH_count => 0,
157 total_meCpG_count => 0,
158 total_unmethylated_CHG_count => 0,
159 total_unmethylated_CHH_count => 0,
160 total_unmethylated_CpG_count => 0,
161 sequences_count => 0,
162 );
163 @sorting_files = ();
164 @bedfiles = ();
165
166 process_Bismark_results_file($filename);
167
168 if ($bedGraph){
169 my $out = $filename;
170 $out =~ s/sam$//;
171 $out =~ s/txt$//;
172 $out =~ s/$/bedGraph/;
173
174 my $bedGraph_output = $out;
175 open (OUT,'>',$output_dir.$out) or die $!;
176 # warn "Writing bedGraph to file: $out\n";
177
178 process_bedGraph_output();
179 close OUT or die $!;
180
181 ### genome-wide cytosine methylation report requires bedGraph processing anyway
182 if ($cytosine_report){
183 my $cytosine_out = $out;
184 $cytosine_out =~ s/bedGraph$//;
185
186 read_genome_into_memory();
187 generate_genome_wide_cytosine_report($bedGraph_output,$cytosine_out);
188 }
189 }
190 }
191
192
193 sub process_commandline{
194 my $help;
195 my $single_end;
196 my $paired_end;
197 my $ignore;
198 my $genomic_fasta;
199 my $full;
200 my $report;
201 my $extractor_version;
202 my $no_overlap;
203 my $merge_non_CpG;
204 my $vanilla;
205 my $output_dir;
206 my $no_header;
207 my $bedGraph;
208 my $coverage_threshold = 1; # Minimum number of reads covering before calling methylation status
209 my $remove;
210 my $counts;
211 my $cytosine_report;
212 my $genome_folder;
213 my $zero;
214 my $CpG_only;
215 my $CX_context;
216 my $split_by_chromosome;
217
218
219 my $command_line = GetOptions ('help|man' => \$help,
220 'p|paired-end' => \$paired_end,
221 's|single-end' => \$single_end,
222 'fasta' => \$genomic_fasta,
223 'ignore=i' => \$ignore,
224 'comprehensive' => \$full,
225 'report' => \$report,
226 'version' => \$extractor_version,
227 'no_overlap' => \$no_overlap,
228 'merge_non_CpG' => \$merge_non_CpG,
229 'vanilla' => \$vanilla,
230 'o|output=s' => \$output_dir,
231 'no_header' => \$no_header,
232 'bedGraph' => \$bedGraph,
233 "cutoff=i" => \$coverage_threshold,
234 "remove_spaces" => \$remove,
235 "counts" => \$counts,
236 "cytosine_report" => \$cytosine_report,
237 'g|genome_folder=s' => \$genome_folder,
238 "zero_based" => \$zero,
239 "CX|CX_context" => \$CX_context,
240 "split_by_chromosome" => \$split_by_chromosome,
241 );
242
243 ### EXIT ON ERROR if there were errors with any of the supplied options
244 unless ($command_line){
245 die "Please respecify command line options\n";
246 }
247
248 ### HELPFILE
249 if ($help){
250 print_helpfile();
251 exit;
252 }
253
254 if ($extractor_version){
255 print << "VERSION";
256
257
258 Bismark Methylation Extractor
259
260 Bismark Extractor Version: $version Copyright 2010-12 Felix Krueger, Babraham Bioinformatics
261 www.bioinformatics.babraham.ac.uk/projects/bismark/
262
263
264 VERSION
265 exit;
266 }
267
268
269 ### no files provided
270 unless (@ARGV){
271 die "You need to provide one or more Bismark files to create an individual C methylation output. Please respecify!\n";
272 }
273 @filenames = @ARGV;
274
275 warn "\n *** Bismark methylation extractor version $version ***\n\n";
276
277 ### IGNORING <INT> bases at the start of the read when processing the methylation call string
278 unless ($ignore){
279 $ignore = 0;
280 }
281 ### PRINT A REPORT
282 unless ($report){
283 $report = 0;
284 }
285
286 ### OUTPUT DIR PATH
287 if ($output_dir){
288 unless ($output_dir =~ /\/$/){
289 $output_dir =~ s/$/\//;
290 }
291 }
292 else{
293 $output_dir = '';
294 }
295
296 ### NO HEADER
297 unless ($no_header){
298 $no_header = 0;
299 }
300
301 ### OLD (VANILLA) OUTPUT FORMAT
302 unless ($vanilla){
303 $vanilla = 0;
304 }
305
306 if ($single_end){
307 $paired_end = 0; ### SINGLE END ALIGNMENTS
308 }
309 elsif ($paired_end){
310 $single_end = 0; ### PAIRED-END ALIGNMENTS
311 }
312 else{
313 die "Please specify whether the supplied file(s) are in Bismark single-end or paired-end format\n\n";
314 }
315
316 ### NO OVERLAP
317 if ($no_overlap){
318 die "The option '--no_overlap' can only be specified for paired-end input!\n" unless ($paired_end);
319 }
320 else{
321 $no_overlap = 0;
322 }
323
324 ### COMPREHENSIVE OUTPUT
325 unless ($full){
326 $full = 0;
327 }
328
329 ### MERGE NON-CpG context
330 unless ($merge_non_CpG){
331 $merge_non_CpG = 0;
332 }
333
334 ### remove white spaces in read ID (needed for sorting using the sort command
335 unless ($remove){
336 $remove = 0;
337 }
338
339 ### COVERAGE THRESHOLD FOR gedGraph OUTPUT
340 unless (defined $coverage_threshold){
341 unless ($coverage_threshold > 0){
342 die "Please select a coverage greater than 0 (positive integers only)\n";
343 }
344 $coverage_threshold = 1;
345 }
346
347 if ($zero){
348 die "Option '--zero' is only available if '--cytosine_report' is specified as well. Please respecify\n" unless ($cytosine_report);
349 }
350
351 if ($CX_context){
352 die "Option '--CX_context' is only available if '--cytosine_report' or '--bedGraph' is specified as well. Please respecify\n" unless ($cytosine_report or $bedGraph);
353 }
354
355 if ($cytosine_report){
356
357 ### GENOME folder
358 if ($genome_folder){
359 unless ($genome_folder =~/\/$/){
360 $genome_folder =~ s/$/\//;
361 }
362 }
363 else{
364 die "Please specify a genome folder to proceed (full path only)\n";
365 }
366
367 unless ($bedGraph){
368 warn "Setting the option '--bedGraph' since this is required for the genome-wide cytosine report\n";
369 $bedGraph = 1;
370 }
371 unless ($counts){
372 warn "Setting the option '--counts' since this is required for the genome-wide cytosine report\n";
373 $counts = 1;
374 }
375 warn "\n";
376 }
377
378 return ($ignore,$genomic_fasta,$single_end,$paired_end,$full,$report,$no_overlap,$merge_non_CpG,$vanilla,$output_dir,$no_header,$bedGraph,$remove,$coverage_threshold,$counts,$cytosine_report,$genome_folder,$zero,$CpG_only,$CX_context,$split_by_chromosome);
379 }
380
381
382 sub process_Bismark_results_file{
383 my $filename = shift;
384
385 warn "\nNow reading in Bismark result file $filename\n\n";
386
387 if ($filename =~ /\.gz$/) {
388 open (IN,"zcat $filename |") or die "Can't open gzipped file $filename: $!\n";
389 } else {
390 open (IN,$filename) or die "Can't open file $filename: $!\n";
391 }
392
393 ### Vanilla and SAM output need to read different numbers of header lines
394 if ($vanilla) {
395 my $bismark_version = <IN>; ## discarding the Bismark version info
396 chomp $bismark_version;
397 $bismark_version =~ s/\r//; # replaces \r line feed
398 $bismark_version =~ s/Bismark version: //;
399 if ($bismark_version =~ /^\@/) {
400 warn "Detected \@ as the first character of the version information. Is it possible that the file is in SAM format?\n\n";
401 sleep (2);
402 }
403
404 unless ($version eq $bismark_version){
405 die "The methylation extractor and Bismark itself need to be of the same version!\n\nVersions used:\nmethylation extractor: '$version'\nBismark: '$bismark_version'\n";
406 }
407 } else {
408 # If the read is in SAM format (default) it can either start with @ header lines or start with alignments directly.
409 # We are reading from it further down
410 }
411
412 my $output_filename = (split (/\//,$filename))[-1];
413
414 ### OPENING OUTPUT-FILEHANDLES
415 if ($report) {
416 my $report_filename = $output_filename;
417 $report_filename =~ s/[\.sam|\.txt]$//;
418 $report_filename =~ s/$/_splitting_report.txt/;
419 $report_filename = $output_dir . $report_filename;
420 open (REPORT,'>',$report_filename) or die "Failed to write to file $report_filename $!\n";
421 }
422
423 if ($report) {
424 print REPORT "$output_filename\n\n";
425 print REPORT "Parameters used to extract methylation information:\n";
426 if ($paired) {
427 if ($vanilla) {
428 print REPORT "Bismark result file: paired-end (vanilla Bismark format)\n";
429 } else {
430 print REPORT "Bismark result file: paired-end (SAM format)\n"; # default
431 }
432 }
433
434 if ($single) {
435 if ($vanilla) {
436 print REPORT "Bismark result file: single-end (vanilla Bismark format)\n";
437 } else {
438 print REPORT "Bismark result file: single-end (SAM format)\n"; # default
439 }
440 }
441
442 if ($ignore) {
443 print REPORT "Ignoring first $ignore bases\n";
444 }
445
446 if ($full) {
447 print REPORT "Output specified: comprehensive\n";
448 } else {
449 print REPORT "Output specified: strand-specific (default)\n";
450 }
451
452 if ($no_overlap) {
453 print REPORT "No overlapping methylation calls specified\n";
454 }
455 if ($genomic_fasta) {
456 print REPORT "Genomic equivalent sequences will be printed out in FastA format\n";
457 }
458 if ($merge_non_CpG) {
459 print REPORT "Methylation in CHG and CHH context will be merged into \"non-CpG context\" output\n";
460 }
461
462 print REPORT "\n";
463 }
464
465 ### CpG-context and non-CpG context. THIS SECTION IS OPTIONAL
466 ### if --comprehensive AND --merge_non_CpG was specified we are only writing out one CpG-context and one Any-Other-context result file
467 if ($full and $merge_non_CpG) {
468 my $cpg_output = my $other_c_output = $output_filename;
469 ### C in CpG context
470 $cpg_output =~ s/^/CpG_context_/;
471 $cpg_output =~ s/sam$/txt/;
472 $cpg_output =~ s/$/.txt/ unless ($cpg_output =~ /\.txt$/);
473 $cpg_output = $output_dir . $cpg_output;
474 push @sorting_files,$cpg_output;
475 open ($fhs{CpG_context},'>',$cpg_output) or die "Failed to write to $cpg_output $! \n";
476 print "Writing result file containing methylation information for C in CpG context to $cpg_output\n";
477
478 unless ($no_header) {
479 print {$fhs{CpG_context}} "Bismark methylation extractor version $version\n";
480 }
481
482 ### C in any other context than CpG
483 $other_c_output =~ s/^/Non_CpG_context_/;
484 $other_c_output =~ s/sam$/txt/;
485 $other_c_output =~ s/$/.txt/ unless ($other_c_output =~ /\.txt$/);
486 $other_c_output = $output_dir . $other_c_output;
487 push @sorting_files,$other_c_output;
488 open ($fhs{other_context},'>',$other_c_output) or die "Failed to write to $other_c_output $!\n";
489 print "Writing result file containing methylation information for C in any other context to $other_c_output\n";
490
491 unless ($no_header) {
492 print {$fhs{other_context}} "Bismark methylation extractor version $version\n";
493 }
494 }
495
496 ### if only --merge_non_CpG was specified we will write out 8 different output files, depending on where the (first) unique best alignment has been found
497 elsif ($merge_non_CpG) {
498
499 my $cpg_ot = my $cpg_ctot = my $cpg_ctob = my $cpg_ob = $output_filename;
500
501 ### For cytosines in CpG context
502 $cpg_ot =~ s/^/CpG_OT_/;
503 $cpg_ot =~ s/sam$/txt/;
504 $cpg_ot =~ s/$/.txt/ unless ($cpg_ot =~ /\.txt$/);
505 $cpg_ot = $output_dir . $cpg_ot;
506 push @sorting_files,$cpg_ot;
507 open ($fhs{0}->{CpG},'>',$cpg_ot) or die "Failed to write to $cpg_ot $!\n";
508 print "Writing result file containing methylation information for C in CpG context from the original top strand to $cpg_ot\n";
509
510 unless($no_header){
511 print {$fhs{0}->{CpG}} "Bismark methylation extractor version $version\n";
512 }
513
514 $cpg_ctot =~ s/^/CpG_CTOT_/;
515 $cpg_ctot =~ s/sam$/txt/;
516 $cpg_ctot =~ s/$/.txt/ unless ($cpg_ctot =~ /\.txt$/);
517 $cpg_ctot = $output_dir . $cpg_ctot;
518 push @sorting_files,$cpg_ctot;
519 open ($fhs{1}->{CpG},'>',$cpg_ctot) or die "Failed to write to $cpg_ctot $!\n";
520 print "Writing result file containing methylation information for C in CpG context from the complementary to original top strand to $cpg_ctot\n";
521
522 unless($no_header){
523 print {$fhs{1}->{CpG}} "Bismark methylation extractor version $version\n";
524 }
525
526 $cpg_ctob =~ s/^/CpG_CTOB_/;
527 $cpg_ctob =~ s/sam$/txt/;
528 $cpg_ctob =~ s/$/.txt/ unless ($cpg_ctob =~ /\.txt$/);
529 $cpg_ctob = $output_dir . $cpg_ctob;
530 push @sorting_files,$cpg_ctob;
531 open ($fhs{2}->{CpG},'>',$cpg_ctob) or die "Failed to write to $cpg_ctob $!\n";
532 print "Writing result file containing methylation information for C in CpG context from the complementary to original bottom strand to $cpg_ctob\n";
533
534 unless($no_header){
535 print {$fhs{2}->{CpG}} "Bismark methylation extractor version $version\n";
536 }
537
538 $cpg_ob =~ s/^/CpG_OB_/;
539 $cpg_ob =~ s/sam$/txt/;
540 $cpg_ob =~ s/$/.txt/ unless ($cpg_ob =~ /\.txt$/);
541 $cpg_ob = $output_dir . $cpg_ob;
542 push @sorting_files,$cpg_ob;
543 open ($fhs{3}->{CpG},'>',$cpg_ob) or die "Failed to write to $cpg_ob $!\n";
544 print "Writing result file containing methylation information for C in CpG context from the original bottom strand to $cpg_ob\n\n";
545
546 unless($no_header){
547 print {$fhs{3}->{CpG}} "Bismark methylation extractor version $version\n";
548 }
549
550 ### For cytosines in Non-CpG (CC, CT or CA) context
551 my $other_c_ot = my $other_c_ctot = my $other_c_ctob = my $other_c_ob = $output_filename;
552
553 $other_c_ot =~ s/^/Non_CpG_OT_/;
554 $other_c_ot =~ s/sam$/txt/;
555 $other_c_ot =~ s/$/.txt/ unless ($other_c_ot =~ /\.txt$/);
556 $other_c_ot = $output_dir . $other_c_ot;
557 push @sorting_files,$other_c_ot;
558 open ($fhs{0}->{other_c},'>',$other_c_ot) or die "Failed to write to $other_c_ot $!\n";
559 print "Writing result file containing methylation information for C in any other context from the original top strand to $other_c_ot\n";
560
561 unless($no_header){
562 print {$fhs{0}->{other_c}} "Bismark methylation extractor version $version\n";
563 }
564
565 $other_c_ctot =~ s/^/Non_CpG_CTOT_/;
566 $other_c_ctot =~ s/sam$/txt/;
567 $other_c_ctot =~ s/$/.txt/ unless ($other_c_ctot =~ /\.txt$/);
568 $other_c_ctot = $output_dir . $other_c_ctot;
569 push @sorting_files,$other_c_ctot;
570 open ($fhs{1}->{other_c},'>',$other_c_ctot) or die "Failed to write to $other_c_ctot $!\n";
571 print "Writing result file containing methylation information for C in any other context from the complementary to original top strand to $other_c_ctot\n";
572
573 unless($no_header){
574 print {$fhs{1}->{other_c}} "Bismark methylation extractor version $version\n";
575 }
576
577 $other_c_ctob =~ s/^/Non_CpG_CTOB_/;
578 $other_c_ctob =~ s/sam$/txt/;
579 $other_c_ctob =~ s/$/.txt/ unless ($other_c_ctob =~ /\.txt$/);
580 $other_c_ctob = $output_dir . $other_c_ctob;
581 push @sorting_files,$other_c_ctob;
582 open ($fhs{2}->{other_c},'>',$other_c_ctob) or die "Failed to write to $other_c_ctob $!\n";
583 print "Writing result file containing methylation information for C in any other context from the complementary to original bottom strand to $other_c_ctob\n";
584
585 unless($no_header){
586 print {$fhs{2}->{other_c}} "Bismark methylation extractor version $version\n";
587 }
588
589 $other_c_ob =~ s/^/Non_CpG_OB_/;
590 $other_c_ob =~ s/sam$/txt/;
591 $other_c_ob =~ s/$/.txt/ unless ($other_c_ob =~ /\.txt$/);
592 $other_c_ob = $output_dir . $other_c_ob;
593 push @sorting_files,$other_c_ob;
594 open ($fhs{3}->{other_c},'>',$other_c_ob) or die "Failed to write to $other_c_ob $!\n";
595 print "Writing result file containing methylation information for C in any other context from the original bottom strand to $other_c_ob\n\n";
596
597 unless($no_header){
598 print {$fhs{3}->{other_c}} "Bismark methylation extractor version $version\n";
599 }
600 }
601 ### THIS SECTION IS THE DEFAULT (CpG, CHG and CHH context)
602
603 ### if --comprehensive was specified we are only writing one file per context
604 elsif ($full) {
605 my $cpg_output = my $chg_output = my $chh_output = $output_filename;
606 ### C in CpG context
607 $cpg_output =~ s/^/CpG_context_/;
608 $cpg_output =~ s/sam$/txt/;
609 $cpg_output =~ s/$/.txt/ unless ($cpg_output =~ /\.txt$/);
610 $cpg_output = $output_dir . $cpg_output;
611 push @sorting_files,$cpg_output;
612 open ($fhs{CpG_context},'>',$cpg_output) or die "Failed to write to $cpg_output $! \n";
613 print "Writing result file containing methylation information for C in CpG context to $cpg_output\n";
614
615 unless($no_header){
616 print {$fhs{CpG_context}} "Bismark methylation extractor version $version\n";
617 }
618
619 ### C in CHG context
620 $chg_output =~ s/^/CHG_context_/;
621 $chg_output =~ s/sam$/txt/;
622 $chg_output =~ s/$/.txt/ unless ($chg_output =~ /\.txt$/);
623 $chg_output = $output_dir . $chg_output;
624 push @sorting_files,$chg_output;
625 open ($fhs{CHG_context},'>',$chg_output) or die "Failed to write to $chg_output $!\n";
626 print "Writing result file containing methylation information for C in CHG context to $chg_output\n";
627
628 unless($no_header){
629 print {$fhs{CHG_context}} "Bismark methylation extractor version $version\n";
630 }
631
632 ### C in CHH context
633 $chh_output =~ s/^/CHH_context_/;
634 $chh_output =~ s/sam$/txt/;
635 $chh_output =~ s/$/.txt/ unless ($chh_output =~ /\.txt$/);
636 $chh_output = $output_dir . $chh_output;
637 push @sorting_files, $chh_output;
638 open ($fhs{CHH_context},'>',$chh_output) or die "Failed to write to $chh_output $!\n";
639 print "Writing result file containing methylation information for C in CHH context to $chh_output\n";
640
641 unless($no_header){
642 print {$fhs{CHH_context}} "Bismark methylation extractor version $version\n";
643 }
644 }
645 ### else we will write out 12 different output files, depending on where the (first) unique best alignment was found
646 else {
647 my $cpg_ot = my $cpg_ctot = my $cpg_ctob = my $cpg_ob = $output_filename;
648
649 ### For cytosines in CpG context
650 $cpg_ot =~ s/^/CpG_OT_/;
651 $cpg_ot =~ s/sam$/txt/;
652 $cpg_ot =~ s/$/.txt/ unless ($cpg_ot =~ /\.txt$/);
653 $cpg_ot = $output_dir . $cpg_ot;
654 push @sorting_files,$cpg_ot;
655 open ($fhs{0}->{CpG},'>',$cpg_ot) or die "Failed to write to $cpg_ot $!\n";
656 print "Writing result file containing methylation information for C in CpG context from the original top strand to $cpg_ot\n";
657
658 unless($no_header){
659 print {$fhs{0}->{CpG}} "Bismark methylation extractor version $version\n";
660 }
661
662 $cpg_ctot =~ s/^/CpG_CTOT_/;
663 $cpg_ctot =~ s/sam$/txt/;
664 $cpg_ctot =~ s/$/.txt/ unless ($cpg_ctot =~ /\.txt$/);
665 $cpg_ctot = $output_dir . $cpg_ctot;
666 push @sorting_files,$cpg_ctot;
667 open ($fhs{1}->{CpG},'>',$cpg_ctot) or die "Failed to write to $cpg_ctot $!\n";
668 print "Writing result file containing methylation information for C in CpG context from the complementary to original top strand to $cpg_ctot\n";
669
670 unless($no_header){
671 print {$fhs{1}->{CpG}} "Bismark methylation extractor version $version\n";
672 }
673
674 $cpg_ctob =~ s/^/CpG_CTOB_/;
675 $cpg_ctob =~ s/sam$/txt/;
676 $cpg_ctob =~ s/$/.txt/ unless ($cpg_ctob =~ /\.txt$/);
677 $cpg_ctob = $output_dir . $cpg_ctob;
678 push @sorting_files,$cpg_ctob;
679 open ($fhs{2}->{CpG},'>',$cpg_ctob) or die "Failed to write to $cpg_ctob $!\n";
680 print "Writing result file containing methylation information for C in CpG context from the complementary to original bottom strand to $cpg_ctob\n";
681
682 unless($no_header){
683 print {$fhs{2}->{CpG}} "Bismark methylation extractor version $version\n";
684 }
685
686 $cpg_ob =~ s/^/CpG_OB_/;
687 $cpg_ob =~ s/sam$/txt/;
688 $cpg_ob =~ s/$/.txt/ unless ($cpg_ob =~ /\.txt$/);
689 $cpg_ob = $output_dir . $cpg_ob;
690 push @sorting_files,$cpg_ob;
691 open ($fhs{3}->{CpG},'>',$cpg_ob) or die "Failed to write to $cpg_ob $!\n";
692 print "Writing result file containing methylation information for C in CpG context from the original bottom strand to $cpg_ob\n\n";
693
694 unless($no_header){
695 print {$fhs{3}->{CpG}} "Bismark methylation extractor version $version\n";
696 }
697
698 ### For cytosines in CHG context
699 my $chg_ot = my $chg_ctot = my $chg_ctob = my $chg_ob = $output_filename;
700
701 $chg_ot =~ s/^/CHG_OT_/;
702 $chg_ot =~ s/sam$/txt/;
703 $chg_ot =~ s/$/.txt/ unless ($chg_ot =~ /\.txt$/);
704 $chg_ot = $output_dir . $chg_ot;
705 push @sorting_files,$chg_ot;
706 open ($fhs{0}->{CHG},'>',$chg_ot) or die "Failed to write to $chg_ot $!\n";
707 print "Writing result file containing methylation information for C in CHG context from the original top strand to $chg_ot\n";
708
709 unless($no_header){
710 print {$fhs{0}->{CHG}} "Bismark methylation extractor version $version\n";
711 }
712
713 $chg_ctot =~ s/^/CHG_CTOT_/;
714 $chg_ctot =~ s/sam$/txt/;
715 $chg_ctot =~ s/$/.txt/ unless ($chg_ctot =~ /\.txt$/);
716 $chg_ctot = $output_dir . $chg_ctot;
717 push @sorting_files,$chg_ctot;
718 open ($fhs{1}->{CHG},'>',$chg_ctot) or die "Failed to write to $chg_ctot $!\n";
719 print "Writing result file containing methylation information for C in CHG context from the complementary to original top strand to $chg_ctot\n";
720
721 unless($no_header){
722 print {$fhs{1}->{CHG}} "Bismark methylation extractor version $version\n";
723 }
724
725 $chg_ctob =~ s/^/CHG_CTOB_/;
726 $chg_ctob =~ s/sam$/txt/;
727 $chg_ctob =~ s/$/.txt/ unless ($chg_ctob =~ /\.txt$/);
728 $chg_ctob = $output_dir . $chg_ctob;
729 push @sorting_files,$chg_ctob;
730 open ($fhs{2}->{CHG},'>',$chg_ctob) or die "Failed to write to $chg_ctob $!\n";
731 print "Writing result file containing methylation information for C in CHG context from the complementary to original bottom strand to $chg_ctob\n";
732
733 unless($no_header){
734 print {$fhs{2}->{CHG}} "Bismark methylation extractor version $version\n";
735 }
736
737 $chg_ob =~ s/^/CHG_OB_/;
738 $chg_ob =~ s/sam$/txt/;
739 $chg_ob =~ s/$/.txt/ unless ($chg_ob =~ /\.txt$/);
740 $chg_ob = $output_dir . $chg_ob;
741 push @sorting_files,$chg_ob;
742 open ($fhs{3}->{CHG},'>',$chg_ob) or die "Failed to write to $chg_ob $!\n";
743 print "Writing result file containing methylation information for C in CHG context from the original bottom strand to $chg_ob\n\n";
744
745 unless($no_header){
746 print {$fhs{3}->{CHG}} "Bismark methylation extractor version $version\n";
747 }
748
749 ### For cytosines in CHH context
750 my $chh_ot = my $chh_ctot = my $chh_ctob = my $chh_ob = $output_filename;
751
752 $chh_ot =~ s/^/CHH_OT_/;
753 $chh_ot =~ s/sam$/txt/;
754 $chh_ot =~ s/$/.txt/ unless ($chh_ot =~ /\.txt$/);
755 $chh_ot = $output_dir . $chh_ot;
756 push @sorting_files,$chh_ot;
757 open ($fhs{0}->{CHH},'>',$chh_ot) or die "Failed to write to $chh_ot $!\n";
758 print "Writing result file containing methylation information for C in CHH context from the original top strand to $chh_ot\n";
759
760 unless($no_header){
761 print {$fhs{0}->{CHH}} "Bismark methylation extractor version $version\n";
762 }
763
764 $chh_ctot =~ s/^/CHH_CTOT_/;
765 $chh_ctot =~ s/sam$/txt/;
766 $chh_ctot =~ s/$/.txt/ unless ($chh_ctot =~ /\.txt$/);
767 $chh_ctot = $output_dir . $chh_ctot;
768 push @sorting_files,$chh_ctot;
769 open ($fhs{1}->{CHH},'>',$chh_ctot) or die "Failed to write to $chh_ctot $!\n";
770 print "Writing result file containing methylation information for C in CHH context from the complementary to original top strand to $chh_ctot\n";
771
772 unless($no_header){
773 print {$fhs{1}->{CHH}} "Bismark methylation extractor version $version\n";
774 }
775
776 $chh_ctob =~ s/^/CHH_CTOB_/;
777 $chh_ctob =~ s/sam$/txt/;
778 $chh_ctob =~ s/$/.txt/ unless ($chh_ctob =~ /\.txt$/);
779 $chh_ctob = $output_dir . $chh_ctob;
780 push @sorting_files,$chh_ctob;
781 open ($fhs{2}->{CHH},'>',$chh_ctob) or die "Failed to write to $chh_ctob $!\n";
782 print "Writing result file containing methylation information for C in CHH context from the complementary to original bottom strand to $chh_ctob\n";
783
784 unless($no_header){
785 print {$fhs{2}->{CHH}} "Bismark methylation extractor version $version\n";
786 }
787
788 $chh_ob =~ s/^/CHH_OB_/;
789 $chh_ob =~ s/sam$/txt/;
790 $chh_ob =~ s/$/.txt/ unless ($chh_ob =~ /\.txt$/);
791 $chh_ob = $output_dir . $chh_ob;
792 push @sorting_files,$chh_ob;
793 open ($fhs{3}->{CHH},'>',$chh_ob) or die "Failed to write to $chh_ob $!\n";
794 print "Writing result file containing methylation information for C in CHH context from the original bottom strand to $chh_ob\n\n";
795
796 unless($no_header){
797 print {$fhs{3}->{CHH}} "Bismark methylation extractor version $version\n";
798 }
799 }
800
801 my $methylation_call_strings_processed = 0;
802 my $line_count = 0;
803
804 ### proceeding differently now for single-end or paired-end Bismark files
805
806 ### PROCESSING SINGLE-END RESULT FILES
807 if ($single) {
808
809 ### also proceeding differently now for SAM format or vanilla Bismark format files
810 if ($vanilla) { # old vanilla Bismark output format
811 while (<IN>) {
812 ++$line_count;
813 warn "Processed lines: $line_count\n" if ($line_count%500000==0);
814
815 ### $seq here is the chromosomal sequence (to use for the repeat analysis for example)
816 my ($id,$strand,$chrom,$start,$seq,$meth_call,$read_conversion,$genome_conversion) = (split("\t"))[0,1,2,3,6,7,8,9];
817
818 ### we need to remove 2 bp of the genomic sequence as we were extracting read + 2bp long fragments to make a methylation call at the first or
819 ### last position
820 chomp $genome_conversion;
821
822 my $index;
823 if ($meth_call) {
824
825 if ($read_conversion eq 'CT' and $genome_conversion eq 'CT') { ## original top strand
826 $index = 0;
827 } elsif ($read_conversion eq 'GA' and $genome_conversion eq 'CT') { ## complementary to original top strand
828 $index = 1;
829 } elsif ($read_conversion eq 'CT' and $genome_conversion eq 'GA') { ## original bottom strand
830 $index = 3;
831 } elsif ($read_conversion eq 'GA' and $genome_conversion eq 'GA') { ## complementary to original bottom strand
832 $index = 2;
833 } else {
834 die "Unexpected combination of read and genome conversion: '$read_conversion' / '$genome_conversion'\n";
835 }
836
837 ### Clipping off the first <int> number of bases from the methylation call string as specified with --ignore <int>
838 if ($ignore) {
839 $meth_call = substr($meth_call,$ignore,length($meth_call)-$ignore);
840
841 ### If we are clipping off some bases at the start we need to adjust the start position of the alignments accordingly!
842 if ($strand eq '+') {
843 $start += $ignore;
844 } elsif ($strand eq '-') {
845 $start += length($meth_call)-1; ## $meth_call is already shortened!
846 } else {
847 die "Alignment did not have proper strand information: $strand\n";
848 }
849 }
850 ### printing out the methylation state of every C in the read
851 print_individual_C_methylation_states_single_end($meth_call,$chrom,$start,$id,$strand,$index);
852
853 ++$methylation_call_strings_processed; # 1 per single-end result
854 }
855 }
856 } else { # processing single-end SAM format (default)
857 while (<IN>) {
858 ### SAM format can either start with header lines (starting with @) or start with alignments directly
859 if (/^\@/) { # skipping header lines (starting with @)
860 warn "skipping SAM header line:\t$_";
861 next;
862 }
863
864 ++$line_count;
865 warn "Processed lines: $line_count\n" if ($line_count%500000==0);
866
867 # example read in SAM format
868 # 1_R1/1 67 5 103172224 255 40M = 103172417 233 AATATTTTTTTTATTTTAAAATGTGTATTGATTTAAATTT IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII NM:i:4 XX:Z:4T1T24TT7 XM:Z:....h.h........................hh....... XR:Z:CT XG:Z:CT
869 ###
870
871 # < 0.7.6 my ($id,$chrom,$start,$meth_call,$read_conversion,$genome_conversion) = (split("\t"))[0,2,3,13,14,15];
872 # < 0.7.6 $meth_call =~ s/^XM:Z://;
873 # < 0.7.6 $read_conversion =~ s/^XR:Z://;
874 # < 0.7.6 $genome_conversion =~ s/^XG:Z://;
875
876 my ($id,$chrom,$start,$cigar) = (split("\t"))[0,2,3,5];
877
878 ### detecting the following SAM flags in case the SAM entry was shuffled by CRAM or Goby compression/decompression
879 my $meth_call; ### Thanks to Zachary Zeno for this solution
880 my $read_conversion;
881 my $genome_conversion;
882
883 while ( /(XM|XR|XG):Z:([^\t]+)/g ) {
884 my $tag = $1;
885 my $value = $2;
886
887 if ($tag eq "XM") {
888 $meth_call = $value;
889 $meth_call =~ s/\r//;
890 } elsif ($tag eq "XR") {
891 $read_conversion = $value;
892 $read_conversion =~ s/\r//;
893 } elsif ($tag eq "XG") {
894 $genome_conversion = $value;
895 $genome_conversion =~ s/\r//;
896 }
897 }
898
899 my $strand;
900 chomp $genome_conversion;
901 # print "$meth_call\n$read_conversion\n$genome_conversion\n";
902
903 my $index;
904 if ($meth_call) {
905 if ($read_conversion eq 'CT' and $genome_conversion eq 'CT') { ## original top strand
906 $index = 0;
907 $strand = '+';
908 } elsif ($read_conversion eq 'GA' and $genome_conversion eq 'CT') { ## complementary to original top strand
909 $index = 1;
910 $strand = '-';
911 } elsif ($read_conversion eq 'GA' and $genome_conversion eq 'GA') { ## complementary to original bottom strand
912 $index = 2;
913 $strand = '+';
914 } elsif ($read_conversion eq 'CT' and $genome_conversion eq 'GA') { ## original bottom strand
915 $index = 3;
916 $strand = '-';
917 } else {
918 die "Unexpected combination of read and genome conversion: '$read_conversion' / '$genome_conversion'\n";
919 }
920
921 ### If the read is in SAM format we need to reverse the methylation call if the read has been reverse-complemented for the output
922 if ($strand eq '-') {
923 $meth_call = reverse $meth_call;
924 }
925
926 ### Clipping off the first <int> number of bases from the methylation call string as specified with --ignore <int>
927 if ($ignore) {
928 # print "\n\n$meth_call\n";
929 $meth_call = substr($meth_call,$ignore,length($meth_call)-$ignore);
930 # print "$meth_call\n";
931 ### If we are ignoring a part of the sequence we also need to adjust the cigar string accordingly
932
933 my @len = split (/\D+/,$cigar); # storing the length per operation
934 my @ops = split (/\d+/,$cigar); # storing the operation
935 shift @ops; # remove the empty first element
936 die "CIGAR string contained a non-matching number of lengths and operations\n" unless (scalar @len == scalar @ops);
937
938 my @comp_cigar; # building an array with all CIGAR operations
939 foreach my $index (0..$#len) {
940 foreach (1..$len[$index]) {
941 # print "$ops[$index]";
942 push @comp_cigar, $ops[$index];
943 }
944 }
945 # print "original CIGAR: $cigar\n";
946 # print "original CIGAR: @comp_cigar\n";
947
948 ### If we are clipping off some bases at the start we need to adjust the start position of the alignments accordingly!
949 if ($strand eq '+') {
950
951 my $D_count = 0; # counting all deletions that affect the ignored genomic position, i.e. Deletions and insertions
952 my $I_count = 0;
953
954 for (1..$ignore) {
955 my $op = shift @comp_cigar; # adjusting composite CIGAR string by removing $ignore operations from the start
956 # print "$_ deleted $op\n";
957
958 while ($op eq 'D') { # repeating this for deletions (D)
959 $D_count++;
960 $op = shift @comp_cigar;
961 # print "$_ deleted $op\n";
962 }
963 if ($op eq 'I') { # adjusting the genomic position for insertions (I)
964 $I_count++;
965 }
966 }
967 $start += $ignore + $D_count - $I_count;
968 # print "start $start\t ignore: $ignore\t D count: $D_count I_count: $I_count\n";
969 } elsif ($strand eq '-') {
970
971 for (1..$ignore) {
972 my $op = pop @comp_cigar; # adjusting composite CIGAR string by removing $ignore operations, here the last value of the array
973 while ($op eq 'D') { # repeating this for deletions (D)
974 $op = pop @comp_cigar;
975 }
976 }
977
978 ### For reverse strand alignments we need to determine the number of matching bases (M) or deletions (D) in the read from the CIGAR
979 ### string to be able to work out the starting position of the read which is on the 3' end of the sequence
980 my $MD_count = 0; # counting all operations that affect the genomic position, i.e. M and D. Insertions do not affect the start position
981 foreach (@comp_cigar) {
982 ++$MD_count if ($_ eq 'M' or $_ eq 'D');
983 }
984 $start += $MD_count - 1;
985 }
986
987 ### reconstituting shortened CIGAR string
988 my $new_cigar;
989 my $count = 0;
990 my $last_op;
991 # print "ignore adjusted: @comp_cigar\n";
992 foreach my $op (@comp_cigar) {
993 unless (defined $last_op){
994 $last_op = $op;
995 ++$count;
996 next;
997 }
998 if ($last_op eq $op) {
999 ++$count;
1000 } else {
1001 $new_cigar .= "$count$last_op";
1002 $last_op = $op;
1003 $count = 1;
1004 }
1005 }
1006 $new_cigar .= "$count$last_op"; # appending the last operation and count
1007 $cigar = $new_cigar;
1008 # print "ignore adjusted scalar: $cigar\n";
1009 }
1010 }
1011 ### printing out the methylation state of every C in the read
1012 print_individual_C_methylation_states_single_end($meth_call,$chrom,$start,$id,$strand,$index,$cigar);
1013
1014 ++$methylation_call_strings_processed; # 1 per single-end result
1015 }
1016 }
1017 }
1018
1019 ### PROCESSING PAIRED-END RESULT FILES
1020 elsif ($paired) {
1021
1022 ### proceeding differently now for SAM format or vanilla Bismark format files
1023 if ($vanilla) { # old vanilla Bismark paired-end output format
1024 while (<IN>) {
1025 ++$line_count;
1026 warn "processed line: $line_count\n" if ($line_count%500000==0);
1027
1028 ### $seq here is the chromosomal sequence (to use for the repeat analysis for example)
1029 my ($id,$strand,$chrom,$start_read_1,$end_read_2,$seq_1,$meth_call_1,$seq_2,$meth_call_2,$first_read_conversion,$genome_conversion) = (split("\t"))[0,1,2,3,4,6,7,9,10,11,12,13];
1030
1031 my $index;
1032 chomp $genome_conversion;
1033
1034 if ($first_read_conversion eq 'CT' and $genome_conversion eq 'CT') {
1035 $index = 0; ## this is OT
1036 } elsif ($first_read_conversion eq 'GA' and $genome_conversion eq 'GA') {
1037 $index = 2; ## this is CTOB!!!
1038 } elsif ($first_read_conversion eq 'GA' and $genome_conversion eq 'CT') {
1039 $index = 1; ## this is CTOT!!!
1040 } elsif ($first_read_conversion eq 'CT' and $genome_conversion eq 'GA') {
1041 $index = 3; ## this is OB
1042 } else {
1043 die "Unexpected combination of read and genome conversion: $first_read_conversion / $genome_conversion\n";
1044 }
1045
1046 if ($meth_call_1 and $meth_call_2) {
1047 ### Clipping off the first <int> number of bases from the methylation call strings as specified with '--ignore <int>'
1048 if ($ignore) {
1049 $meth_call_1 = substr($meth_call_1,$ignore,length($meth_call_1)-$ignore);
1050 $meth_call_2 = substr($meth_call_2,$ignore,length($meth_call_2)-$ignore);
1051
1052 ### we also need to adjust the start and end positions of the alignments accordingly if '--ignore' was specified
1053 $start_read_1 += $ignore;
1054 $end_read_2 -= $ignore;
1055 }
1056 my $end_read_1;
1057 my $start_read_2;
1058
1059 if ($strand eq '+') {
1060
1061 $end_read_1 = $start_read_1+length($meth_call_1)-1;
1062 $start_read_2 = $end_read_2-length($meth_call_2)+1;
1063
1064 ## we first pass the first read which is in + orientation on the forward strand
1065 print_individual_C_methylation_states_paired_end_files($meth_call_1,$chrom,$start_read_1,$id,'+',$index,0,0);
1066
1067 # we next pass the second read which is in - orientation on the reverse strand
1068 ### if --no_overlap was specified we also pass the end of read 1. If read 2 starts to overlap with read 1 we can stop extracting methylation calls from read 2
1069 print_individual_C_methylation_states_paired_end_files($meth_call_2,$chrom,$end_read_2,$id,'-',$index,$no_overlap,$end_read_1);
1070 } else {
1071
1072 $end_read_1 = $start_read_1+length($meth_call_2)-1; # read 1 is the second reported read!
1073 $start_read_2 = $end_read_2-length($meth_call_1)+1; # read 2 is the first reported read!
1074
1075 ## we first pass the first read which is in - orientation on the reverse strand
1076 print_individual_C_methylation_states_paired_end_files($meth_call_1,$chrom,$end_read_2,$id,'-',$index,0,0);
1077
1078 # we next pass the second read which is in + orientation on the forward strand
1079 ### if --no_overlap was specified we also pass the end of read 2. If read 2 starts to overlap with read 1 we will stop extracting methylation calls from read 2
1080 print_individual_C_methylation_states_paired_end_files($meth_call_2,$chrom,$start_read_1,$id,'+',$index,$no_overlap,$start_read_2);
1081 }
1082
1083 $methylation_call_strings_processed += 2; # paired-end = 2 methylation calls
1084 }
1085 }
1086 } else { # Bismark paired-end SAM output format (default)
1087 while (<IN>) {
1088 ### SAM format can either start with header lines (starting with @) or start with alignments directly
1089 if (/^\@/) { # skipping header lines (starting with @)
1090 warn "skipping SAM header line:\t$_";
1091 next;
1092 }
1093
1094 ++$line_count;
1095 warn "Processed lines: $line_count\n" if ($line_count%500000==0);
1096
1097 # example paired-end reads in SAM format (2 consecutive lines)
1098 # 1_R1/1 67 5 103172224 255 40M = 103172417 233 AATATTTTTTTTATTTTAAAATGTGTATTGATTTAAATTT IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII NM:i:4 XX:Z:4T1T24TT7 XM:Z:....h.h........................hh....... XR:Z:CT XG:Z:CT
1099 # 1_R1/2 131 5 103172417 255 40M = 103172224 -233 TATTTTTTTTTAGAGTATTTTTTAATGGTTATTAGATTTT IIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII NM:i:6 XX:Z:T5T1T9T9T7T3 XM:Z:h.....h.h.........h.........h.......h... XR:Z:GA XG:Z:CT
1100
1101 # < version 0.7.6 my ($id_1,$chrom,$start_read_1,$meth_call_1,$first_read_conversion,$genome_conversion) = (split("\t"))[0,2,3,13,14,15];
1102
1103 my ($id_1,$chrom,$start_read_1,$cigar_1) = (split("\t"))[0,2,3,5]; ### detecting the following SAM flags in case the SAM entry was shuffled by CRAM or Goby compression/decompression
1104 my $meth_call_1;
1105 my $first_read_conversion;
1106 my $genome_conversion;
1107
1108 while ( /(XM|XR|XG):Z:([^\t]+)/g ) {
1109 my $tag = $1;
1110 my $value = $2;
1111
1112 if ($tag eq "XM") {
1113 $meth_call_1 = $value;
1114 $meth_call_1 =~ s/\r//;
1115 } elsif ($tag eq "XR") {
1116 $first_read_conversion = $value;
1117 $first_read_conversion =~ s/\r//;
1118 } elsif ($tag eq "XG") {
1119 $genome_conversion = $value;
1120 $genome_conversion =~ s/\r//;
1121 }
1122 }
1123
1124 $_ = <IN>; # reading in the paired read
1125
1126 # < version 0.7.6 my ($id_2,$start_read_2,$meth_call_2,$second_read_conversion) = (split("\t"))[0,3,13,14];
1127 # < version 0.7.6 $meth_call_1 =~ s/^XM:Z://;
1128 # < version 0.7.6 $meth_call_2 =~ s/^XM:Z://;
1129 # < version 0.7.6 $first_read_conversion =~ s/^XR:Z://;
1130 # < version 0.7.6 $second_read_conversion =~ s/^XR:Z://;
1131
1132 my ($id_2,$start_read_2,$cigar_2) = (split("\t"))[0,3,5]; ### detecting the following SAM flags in case the SAM entry was shuffled by CRAM or Goby compression/decompression
1133
1134 my $meth_call_2;
1135 my $second_read_conversion;
1136
1137 while ( /(XM|XR):Z:([^\t]+)/g ) {
1138 my $tag = $1;
1139 my $value = $2;
1140
1141 if ($tag eq "XM") {
1142 $meth_call_2 = $value;
1143 $meth_call_2 =~ s/\r//;
1144 } elsif ($tag eq "XR") {
1145 $second_read_conversion = $value;
1146 $second_read_conversion = s/\r//;
1147 }
1148 }
1149
1150 # < version 0.7.6 $genome_conversion =~ s/^XG:Z://;
1151 chomp $genome_conversion; # in case it captured a new line character
1152
1153 # print join ("\t",$meth_call_1,$meth_call_2,$first_read_conversion,$second_read_conversion,$genome_conversion),"\n";
1154
1155 my $index;
1156 my $strand;
1157
1158 if ($first_read_conversion eq 'CT' and $genome_conversion eq 'CT') {
1159 $index = 0; ## this is OT
1160 $strand = '+';
1161 } elsif ($first_read_conversion eq 'GA' and $genome_conversion eq 'CT') {
1162 $index = 1; ## this is CTOT
1163 $strand = '-';
1164 } elsif ($first_read_conversion eq 'GA' and $genome_conversion eq 'GA') {
1165 $index = 2; ## this is CTOB
1166 $strand = '+';
1167 } elsif ($first_read_conversion eq 'CT' and $genome_conversion eq 'GA') {
1168 $index = 3; ## this is OB
1169 $strand = '-';
1170 } else {
1171 die "Unexpected combination of read and genome conversion: $first_read_conversion / $genome_conversion\n";
1172 }
1173
1174 ### reversing the methylation call of the read that was reverse-complemented
1175 if ($strand eq '+') {
1176 $meth_call_2 = reverse $meth_call_2;
1177 } else {
1178 $meth_call_1 = reverse $meth_call_1;
1179 }
1180
1181 if ($meth_call_1 and $meth_call_2) {
1182
1183 my $end_read_1;
1184
1185 ### READ 1
1186 my @len_1 = split (/\D+/,$cigar_1); # storing the length per operation
1187 my @ops_1 = split (/\d+/,$cigar_1); # storing the operation
1188 shift @ops_1; # remove the empty first element
1189 die "CIGAR string contained a non-matching number of lengths and operations\n" unless (scalar @len_1 == scalar @ops_1);
1190
1191 my @comp_cigar_1; # building an array with all CIGAR operations
1192 foreach my $index (0..$#len_1) {
1193 foreach (1..$len_1[$index]) {
1194 # print "$ops_1[$index]";
1195 push @comp_cigar_1, $ops_1[$index];
1196 }
1197 }
1198 # print "original CIGAR read 1: $cigar_1\n";
1199 # print "original CIGAR read 1: @comp_cigar_1\n";
1200
1201 ### READ 2
1202 my @len_2 = split (/\D+/,$cigar_2); # storing the length per operation
1203 my @ops_2 = split (/\d+/,$cigar_2); # storing the operation
1204 shift @ops_2; # remove the empty first element
1205 die "CIGAR string contained a non-matching number of lengths and operations\n" unless (scalar @len_2 == scalar @ops_2);
1206 my @comp_cigar_2; # building an array with all CIGAR operations for read 2
1207 foreach my $index (0..$#len_2) {
1208 foreach (1..$len_2[$index]) {
1209 # print "$ops_2[$index]";
1210 push @comp_cigar_2, $ops_2[$index];
1211 }
1212 }
1213 # print "original CIGAR read 2: $cigar_2\n";
1214 # print "original CIGAR read 2: @comp_cigar_2\n";
1215
1216 if ($ignore) {
1217 ### Clipping off the first <int> number of bases from the methylation call strings as specified with '--ignore <int>'
1218 ### the methylation calls have already been reversed where necessary
1219 $meth_call_1 = substr($meth_call_1,$ignore,length($meth_call_1)-$ignore);
1220 $meth_call_2 = substr($meth_call_2,$ignore,length($meth_call_2)-$ignore);
1221
1222 ### If we are ignoring a part of the sequence we also need to adjust the cigar string accordingly
1223
1224 if ($strand eq '+') {
1225
1226 ### if the (read 1) strand information is '+', read 1 needs to be trimmed from the start
1227 my $D_count_1 = 0; # counting all deletions that affect the ignored genomic position for read 1, i.e. Deletions and insertions
1228 my $I_count_1 = 0;
1229
1230 for (1..$ignore) {
1231 my $op = shift @comp_cigar_1; # adjusting composite CIGAR string of read 1 by removing $ignore operations from the start
1232 # print "$_ deleted $op\n";
1233
1234 while ($op eq 'D') { # repeating this for deletions (D)
1235 $D_count_1++;
1236 $op = shift @comp_cigar_1;
1237 # print "$_ deleted $op\n";
1238 }
1239 if ($op eq 'I') { # adjusting the genomic position for insertions (I)
1240 $I_count_1++;
1241 }
1242 }
1243
1244 $start_read_1 += $ignore + $D_count_1 - $I_count_1;
1245 # print "start read 1 $start_read_1\t ignore: $ignore\t D count 1: $D_count_1\tI_count 1: $I_count_1\n";
1246
1247 ### if the (read 1) strand information is '+', read 2 needs to be trimmed from the back
1248
1249 for (1..$ignore) {
1250 my $op = pop @comp_cigar_2; # adjusting composite CIGAR string by removing $ignore operations, here the last value of the array
1251 while ($op eq 'D') { # repeating this for deletions (D)
1252 $op = pop @comp_cigar_2;
1253 }
1254 }
1255 # the start position of reads mapping to the reverse strand is being adjusted further below
1256 } elsif ($strand eq '-') {
1257
1258 ### if the (read 1) strand information is '-', read 1 needs to be trimmed from the back
1259 for (1..$ignore) {
1260 my $op = pop @comp_cigar_1; # adjusting composite CIGAR string by removing $ignore operations, here the last value of the array
1261 while ($op eq 'D') { # repeating this for deletions (D)
1262 $op = pop @comp_cigar_1;
1263 }
1264 }
1265 # the start position of reads mapping to the reverse strand is being adjusted further below
1266
1267 ### if the (read 1) strand information is '-', read 2 needs to be trimmed from the start
1268 my $D_count_2 = 0; # counting all deletions that affect the ignored genomic position for read 2, i.e. Deletions and insertions
1269 my $I_count_2 = 0;
1270
1271 for (1..$ignore) {
1272 my $op = shift @comp_cigar_2; # adjusting composite CIGAR string of read 2 by removing $ignore operations from the start
1273 # print "$_ deleted $op\n";
1274
1275 while ($op eq 'D') { # repeating this for deletions (D)
1276 $D_count_2++;
1277 $op = shift @comp_cigar_2;
1278 # print "$_ deleted $op\n";
1279 }
1280 if ($op eq 'I') { # adjusting the genomic position for insertions (I)
1281 $I_count_2++;
1282 }
1283 }
1284
1285 $start_read_2 += $ignore + $D_count_2 - $I_count_2;
1286 # print "start read 2 $start_read_2\t ignore: $ignore\t D count 2: $D_count_2\tI_count 2: $I_count_2\n";
1287
1288 }
1289
1290 ### reconstituting shortened CIGAR string 1
1291 my $new_cigar_1;
1292 my $count_1 = 0;
1293 my $last_op_1;
1294 # print "ignore adjusted CIGAR 1: @comp_cigar_1\n";
1295 foreach my $op (@comp_cigar_1) {
1296 unless (defined $last_op_1){
1297 $last_op_1 = $op;
1298 ++$count_1;
1299 next;
1300 }
1301 if ($last_op_1 eq $op) {
1302 ++$count_1;
1303 } else {
1304 $new_cigar_1 .= "$count_1$last_op_1";
1305 $last_op_1 = $op;
1306 $count_1 = 1;
1307 }
1308 }
1309 $new_cigar_1 .= "$count_1$last_op_1"; # appending the last operation and count
1310 $cigar_1 = $new_cigar_1;
1311 # print "ignore adjusted CIGAR 1 scalar: $cigar_1\n";
1312
1313 ### reconstituting shortened CIGAR string 2
1314 my $new_cigar_2;
1315 my $count_2 = 0;
1316 my $last_op_2;
1317 # print "ignore adjusted CIGAR 2: @comp_cigar_2\n";
1318 foreach my $op (@comp_cigar_2) {
1319 unless (defined $last_op_2){
1320 $last_op_2 = $op;
1321 ++$count_2;
1322 next;
1323 }
1324 if ($last_op_2 eq $op) {
1325 ++$count_2;
1326 } else {
1327 $new_cigar_2 .= "$count_2$last_op_2";
1328 $last_op_2 = $op;
1329 $count_2 = 1;
1330 }
1331 }
1332 $new_cigar_2 .= "$count_2$last_op_2"; # appending the last operation and count
1333 $cigar_2 = $new_cigar_2;
1334 # print "ignore adjusted CIGAR 2 scalar: $cigar_2\n";
1335
1336 }
1337
1338 if ($strand eq '+') {
1339 ### adjusting the start position for all reads mapping to the reverse strand, in this case read 2
1340 @comp_cigar_2 = reverse@comp_cigar_2; # the CIGAR string needs to be reversed for all reads aligning to the reverse strand, too
1341 # print "reverse: @comp_cigar_2\n";
1342
1343 my $MD_count_1 = 0;
1344 foreach (@comp_cigar_1) {
1345 ++$MD_count_1 if ($_ eq 'M' or $_ eq 'D'); # Matching bases or deletions affect the genomic position of the 3' ends of reads, insertions don't
1346 }
1347
1348 my $MD_count_2 = 0;
1349 foreach (@comp_cigar_2) {
1350 ++$MD_count_2 if ($_ eq 'M' or $_ eq 'D'); # Matching bases or deletions affect the genomic position of the 3' ends of reads, insertions don't
1351 }
1352
1353 $end_read_1 = $start_read_1 + $MD_count_1 - 1;
1354 $start_read_2 += $MD_count_2 - 1; ## Passing on the start position on the reverse strand
1355 } else {
1356 ### adjusting the start position for all reads mapping to the reverse strand, in this case read 1
1357
1358 @comp_cigar_1 = reverse@comp_cigar_1; # the CIGAR string needs to be reversed for all reads aligning to the reverse strand, too
1359 # print "reverse: @comp_cigar_1\n";
1360
1361 my $MD_count_1 = 0;
1362 foreach (@comp_cigar_1) {
1363 ++$MD_count_1 if ($_ eq 'M' or $_ eq 'D'); # Matching bases or deletions affect the genomic position of the 3' ends of reads, insertions don't
1364 }
1365
1366 $end_read_1 = $start_read_1;
1367 $start_read_1 += $MD_count_1 - 1; ### Passing on the start position on the reverse strand
1368
1369 }
1370
1371 if ($strand eq '+') {
1372 ## we first pass the first read which is in + orientation on the forward strand
1373 print_individual_C_methylation_states_paired_end_files($meth_call_1,$chrom,$start_read_1,$id_1,'+',$index,0,0,$cigar_1);
1374
1375 # we next pass the second read which is in - orientation on the reverse strand
1376 ### if --no_overlap was specified we also pass the end of read 1. If read 2 starts to overlap with read 1 we can stop extracting methylation calls from read 2
1377 print_individual_C_methylation_states_paired_end_files($meth_call_2,$chrom,$start_read_2,$id_2,'-',$index,$no_overlap,$end_read_1,$cigar_2);
1378 } else {
1379 ## we first pass the first read which is in - orientation on the reverse strand
1380 print_individual_C_methylation_states_paired_end_files($meth_call_1,$chrom,$start_read_1,$id_1,'-',$index,0,0,$cigar_1);
1381
1382 # we next pass the second read which is in + orientation on the forward strand
1383 ### if --no_overlap was specified we also pass the end of read 1. If read 2 starts to overlap with read 1 we will stop extracting methylation calls from read 2
1384 print_individual_C_methylation_states_paired_end_files($meth_call_2,$chrom,$start_read_2,$id_2,'+',$index,$no_overlap,$end_read_1,$cigar_2);
1385 }
1386
1387 $methylation_call_strings_processed += 2; # paired-end = 2 methylation calls
1388 }
1389 }
1390 }
1391 } else {
1392 die "Single-end or paired-end reads not specified properly\n";
1393 }
1394
1395 print "\n\nProcessed $line_count lines from $filename in total\n";
1396 print "Total number of methylation call strings processed: $methylation_call_strings_processed\n\n";
1397 if ($report) {
1398 print REPORT "Total number of methylation call strings processed: $methylation_call_strings_processed\n\n";
1399 }
1400 print_splitting_report ();
1401 }
1402
1403
1404
1405 sub print_splitting_report{
1406
1407 ### Calculating methylation percentages if applicable
1408
1409 my $percent_meCpG;
1410 if (($counting{total_meCpG_count}+$counting{total_unmethylated_CpG_count}) > 0){
1411 $percent_meCpG = sprintf("%.1f",100*$counting{total_meCpG_count}/($counting{total_meCpG_count}+$counting{total_unmethylated_CpG_count}));
1412 }
1413
1414 my $percent_meCHG;
1415 if (($counting{total_meCHG_count}+$counting{total_unmethylated_CHG_count}) > 0){
1416 $percent_meCHG = sprintf("%.1f",100*$counting{total_meCHG_count}/($counting{total_meCHG_count}+$counting{total_unmethylated_CHG_count}));
1417 }
1418
1419 my $percent_meCHH;
1420 if (($counting{total_meCHH_count}+$counting{total_unmethylated_CHH_count}) > 0){
1421 $percent_meCHH = sprintf("%.1f",100*$counting{total_meCHH_count}/($counting{total_meCHH_count}+$counting{total_unmethylated_CHH_count}));
1422 }
1423
1424 my $percent_non_CpG_methylation;
1425 if ($merge_non_CpG){
1426 if ( ($counting{total_meCHH_count}+$counting{total_unmethylated_CHH_count}+$counting{total_meCHG_count}+$counting{total_unmethylated_CHG_count}) > 0){
1427 $percent_non_CpG_methylation = sprintf("%.1f",100* ( $counting{total_meCHH_count}+$counting{total_meCHG_count} ) / ( $counting{total_meCHH_count}+$counting{total_unmethylated_CHH_count}+$counting{total_meCHG_count}+$counting{total_unmethylated_CHG_count} ) );
1428 }
1429 }
1430
1431 if ($report){
1432 ### detailed information about Cs analysed
1433 print REPORT "Final Cytosine Methylation Report\n",'='x33,"\n";
1434
1435 my $total_number_of_C = $counting{total_meCHG_count}+$counting{total_meCHH_count}+$counting{total_meCpG_count}+$counting{total_unmethylated_CHG_count}+$counting{total_unmethylated_CHH_count}+$counting{total_unmethylated_CpG_count};
1436 print REPORT "Total number of C's analysed:\t$total_number_of_C\n\n";
1437
1438 print REPORT "Total methylated C's in CpG context:\t$counting{total_meCpG_count}\n";
1439 print REPORT "Total methylated C's in CHG context:\t$counting{total_meCHG_count}\n";
1440 print REPORT "Total methylated C's in CHH context:\t$counting{total_meCHH_count}\n\n";
1441
1442 print REPORT "Total C to T conversions in CpG context:\t$counting{total_unmethylated_CpG_count}\n";
1443 print REPORT "Total C to T conversions in CHG context:\t$counting{total_unmethylated_CHG_count}\n";
1444 print REPORT "Total C to T conversions in CHH context:\t$counting{total_unmethylated_CHH_count}\n\n";
1445
1446 ### calculating methylated CpG percentage if applicable
1447 if ($percent_meCpG){
1448 print REPORT "C methylated in CpG context:\t${percent_meCpG}%\n";
1449 }
1450 else{
1451 print REPORT "Can't determine percentage of methylated Cs in CpG context if value was 0\n";
1452 }
1453
1454 ### 2-Context Output
1455 if ($merge_non_CpG){
1456 if ($percent_non_CpG_methylation){
1457 print REPORT "C methylated in non-CpG context:\t${percent_non_CpG_methylation}%\n\n\n";
1458 }
1459 else{
1460 print REPORT "Can't determine percentage of methylated Cs in non-CpG context if value was 0\n\n\n";
1461 }
1462 }
1463
1464 ### 3 Context Output
1465 else{
1466 ### calculating methylated CHG percentage if applicable
1467 if ($percent_meCHG){
1468 print REPORT "C methylated in CHG context:\t${percent_meCHG}%\n";
1469 }
1470 else{
1471 print REPORT "Can't determine percentage of methylated Cs in CHG context if value was 0\n";
1472 }
1473
1474 ### calculating methylated CHH percentage if applicable
1475 if ($percent_meCHH){
1476 print REPORT "C methylated in CHH context:\t${percent_meCHH}%\n\n\n";
1477 }
1478 else{
1479 print REPORT "Can't determine percentage of methylated Cs in CHH context if value was 0\n\n\n";
1480 }
1481 }
1482 }
1483
1484 ### detailed information about Cs analysed for on-screen report
1485 print "Final Cytosine Methylation Report\n",'='x33,"\n";
1486
1487 my $total_number_of_C = $counting{total_meCHG_count}+$counting{total_meCHH_count}+$counting{total_meCpG_count}+$counting{total_unmethylated_CHG_count}+$counting{total_unmethylated_CHH_count}+$counting{total_unmethylated_CpG_count};
1488 print "Total number of C's analysed:\t$total_number_of_C\n\n";
1489
1490 print "Total methylated C's in CpG context:\t$counting{total_meCpG_count}\n";
1491 print "Total methylated C's in CHG context:\t$counting{total_meCHG_count}\n";
1492 print "Total methylated C's in CHH context:\t$counting{total_meCHH_count}\n\n";
1493
1494 print "Total C to T conversions in CpG context:\t$counting{total_unmethylated_CpG_count}\n";
1495 print "Total C to T conversions in CHG context:\t$counting{total_unmethylated_CHG_count}\n";
1496 print "Total C to T conversions in CHH context:\t$counting{total_unmethylated_CHH_count}\n\n";
1497
1498 ### printing methylated CpG percentage if applicable
1499 if ($percent_meCpG){
1500 print "C methylated in CpG context:\t${percent_meCpG}%\n";
1501 }
1502 else{
1503 print "Can't determine percentage of methylated Cs in CpG context if value was 0\n";
1504 }
1505
1506 ### 2-Context Output
1507 if ($merge_non_CpG){
1508 if ($percent_non_CpG_methylation){
1509 print "C methylated in non-CpG context:\t${percent_non_CpG_methylation}%\n\n\n";
1510 }
1511 else{
1512 print "Can't determine percentage of methylated Cs in non-CpG context if value was 0\n\n\n";
1513 }
1514 }
1515
1516 ### 3-Context Output
1517 else{
1518 ### printing methylated CHG percentage if applicable
1519 if ($percent_meCHG){
1520 print "C methylated in CHG context:\t${percent_meCHG}%\n";
1521 }
1522 else{
1523 print "Can't determine percentage of methylated Cs in CHG context if value was 0\n";
1524 }
1525
1526 ### printing methylated CHH percentage if applicable
1527 if ($percent_meCHH){
1528 print "C methylated in CHH context:\t${percent_meCHH}%\n\n\n";
1529 }
1530 else{
1531 print "Can't determine percentage of methylated Cs in CHH context if value was 0\n\n\n";
1532 }
1533 }
1534 }
1535
1536
1537
1538
1539
1540 sub print_individual_C_methylation_states_paired_end_files{
1541
1542 my ($meth_call,$chrom,$start,$id,$strand,$filehandle_index,$no_overlap,$end_read_1,$cigar) = @_;
1543 my @methylation_calls = split(//,$meth_call);
1544
1545 #################################################################
1546 ### . for bases not involving cytosines ###
1547 ### X for methylated C in CHG context (was protected) ###
1548 ### x for not methylated C in CHG context (was converted) ###
1549 ### H for methylated C in CHH context (was protected) ###
1550 ### h for not methylated C in CHH context (was converted) ###
1551 ### Z for methylated C in CpG context (was protected) ###
1552 ### z for not methylated C in CpG context (was converted) ###
1553 #################################################################
1554
1555 my $methyl_CHG_count = 0;
1556 my $methyl_CHH_count = 0;
1557 my $methyl_CpG_count = 0;
1558 my $unmethylated_CHG_count = 0;
1559 my $unmethylated_CHH_count = 0;
1560 my $unmethylated_CpG_count = 0;
1561
1562 my @len;
1563 my @ops;
1564 my $pos_offset = 0; # this is only relevant for SAM reads with insertions or deletions
1565 my $cigar_offset = 0; # again, this is only relevant for SAM reads containing indels
1566 my @comp_cigar;
1567
1568 if ($cigar){ # parsing CIGAR string
1569 @len = split (/\D+/,$cigar); # storing the length per operation
1570 @ops = split (/\d+/,$cigar); # storing the operation
1571 shift @ops; # remove the empty first element
1572 die "CIGAR string contained a non-matching number of lengths and operations\n" unless (scalar @len == scalar @ops);
1573
1574 foreach my $index (0..$#len){
1575 foreach (1..$len[$index]){
1576 # print "$ops[$index]";
1577 push @comp_cigar, $ops[$index];
1578 }
1579 }
1580 # warn "\nDetected CIGAR string: $cigar\n";
1581 # warn "Length of methylation call: ",length $meth_call,"\n";
1582 # warn "number of operations: ",scalar @ops,"\n";
1583 # warn "number of length digits: ",scalar @len,"\n\n";
1584 # print @comp_cigar,"\n";
1585 # print "$meth_call\n\n";
1586 # sleep (1);
1587 }
1588
1589
1590 if ($strand eq '-') {
1591
1592 ### the CIGAR string needs to be reversed, the methylation call has already been reversed above
1593 @comp_cigar = reverse@comp_cigar; # the CIGAR string needs to be reversed for all reads aligning to the reverse strand, too
1594 # print "reverse CIGAR string: @comp_cigar\n";
1595
1596 ### the start position of paired-end files has already been corrected, see above
1597 }
1598
1599 ### THIS IS AN OPTIONAL 2-CONTEXT (CpG and non-CpG) SECTION IF --merge_non_CpG was specified
1600
1601 if ($merge_non_CpG) {
1602
1603 if ($no_overlap) {
1604
1605 ### single-file CpG and non-CpG context output
1606 if ($full) {
1607 if ($strand eq '+') {
1608 for my $index (0..$#methylation_calls) {
1609
1610 if ($cigar){ # only needed for SAM files
1611 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1612 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
1613 $cigar_offset += $cigar_mod;
1614 $pos_offset += $pos_mod;
1615 }
1616
1617 ### Returning as soon as the methylation calls start overlapping
1618 if ($start+$index+$pos_offset >= $end_read_1) {
1619 return;
1620 }
1621
1622 if ($methylation_calls[$index] eq 'X') {
1623 $counting{total_meCHG_count}++;
1624 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1625 } elsif ($methylation_calls[$index] eq 'x') {
1626 $counting{total_unmethylated_CHG_count}++;
1627 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1628 } elsif ($methylation_calls[$index] eq 'Z') {
1629 $counting{total_meCpG_count}++;
1630 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1631 } elsif ($methylation_calls[$index] eq 'z') {
1632 $counting{total_unmethylated_CpG_count}++;
1633 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1634 } elsif ($methylation_calls[$index] eq 'H') {
1635 $counting{total_meCHH_count}++;
1636 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1637 } elsif ($methylation_calls[$index] eq 'h') {
1638 $counting{total_unmethylated_CHH_count}++;
1639 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1640 }
1641 elsif ($methylation_calls[$index] eq '.'){}
1642 else{
1643 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1644 }
1645 }
1646 } elsif ($strand eq '-') {
1647 for my $index (0..$#methylation_calls) {
1648
1649 if ($cigar){ # only needed for SAM files
1650 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
1651 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1652 $cigar_offset += $cigar_mod;
1653 $pos_offset += $pos_mod;
1654 }
1655
1656 ### Returning as soon as the methylation calls start overlapping
1657 if ($start-$index+$pos_offset <= $end_read_1) {
1658 return;
1659 }
1660
1661 if ($methylation_calls[$index] eq 'X') {
1662 $counting{total_meCHG_count}++;
1663 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1664 } elsif ($methylation_calls[$index] eq 'x') {
1665 $counting{total_unmethylated_CHG_count}++;
1666 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1667 } elsif ($methylation_calls[$index] eq 'Z') {
1668 $counting{total_meCpG_count}++;
1669 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1670 } elsif ($methylation_calls[$index] eq 'z') {
1671 $counting{total_unmethylated_CpG_count}++;
1672 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1673 } elsif ($methylation_calls[$index] eq 'H') {
1674 $counting{total_meCHH_count}++;
1675 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1676 } elsif ($methylation_calls[$index] eq 'h') {
1677 $counting{total_unmethylated_CHH_count}++;
1678 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1679 }
1680 elsif ($methylation_calls[$index] eq '.') {}
1681 else{
1682 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1683 }
1684 }
1685 } else {
1686 die "The read orientation was neither + nor -: '$strand'\n";
1687 }
1688 }
1689
1690 ### strand-specific methylation output
1691 else {
1692 if ($strand eq '+') {
1693 for my $index (0..$#methylation_calls) {
1694
1695 if ($cigar){ # only needed for SAM files
1696 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1697 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
1698 $cigar_offset += $cigar_mod;
1699 $pos_offset += $pos_mod;
1700 }
1701
1702 ### Returning as soon as the methylation calls start overlapping
1703 if ($start+$index+$pos_offset >= $end_read_1) {
1704 return;
1705 }
1706
1707 if ($methylation_calls[$index] eq 'X') {
1708 $counting{total_meCHG_count}++;
1709 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1710 } elsif ($methylation_calls[$index] eq 'x') {
1711 $counting{total_unmethylated_CHG_count}++;
1712 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1713 } elsif ($methylation_calls[$index] eq 'Z') {
1714 $counting{total_meCpG_count}++;
1715 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1716 } elsif ($methylation_calls[$index] eq 'z') {
1717 $counting{total_unmethylated_CpG_count}++;
1718 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1719 } elsif ($methylation_calls[$index] eq 'H') {
1720 $counting{total_meCHH_count}++;
1721 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1722 } elsif ($methylation_calls[$index] eq 'h') {
1723 $counting{total_unmethylated_CHH_count}++;
1724 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1725 }
1726 elsif ($methylation_calls[$index] eq '.') {}
1727 else{
1728 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1729 }
1730 }
1731 } elsif ($strand eq '-') {
1732 for my $index (0..$#methylation_calls) {
1733
1734 if ($cigar){ # only needed for SAM files
1735 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
1736 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1737 $cigar_offset += $cigar_mod;
1738 $pos_offset += $pos_mod;
1739 }
1740
1741 ### Returning as soon as the methylation calls start overlapping
1742 if ($start-$index+$pos_offset <= $end_read_1) {
1743 return;
1744 }
1745
1746 if ($methylation_calls[$index] eq 'X') {
1747 $counting{total_meCHG_count}++;
1748 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1749 } elsif ($methylation_calls[$index] eq 'x') {
1750 $counting{total_unmethylated_CHG_count}++;
1751 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1752 } elsif ($methylation_calls[$index] eq 'Z') {
1753 $counting{total_meCpG_count}++;
1754 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1755 } elsif ($methylation_calls[$index] eq 'z') {
1756 $counting{total_unmethylated_CpG_count}++;
1757 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1758 } elsif ($methylation_calls[$index] eq 'H') {
1759 $counting{total_meCHH_count}++;
1760 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1761 } elsif ($methylation_calls[$index] eq 'h') {
1762 $counting{total_unmethylated_CHH_count}++;
1763 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1764 }
1765 elsif ($methylation_calls[$index] eq '.') {}
1766 else{
1767 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1768 }
1769 }
1770 } else {
1771 die "The strand orientation was neither + nor -: '$strand'/n";
1772 }
1773 }
1774 }
1775
1776 ### this is the default paired-end procedure allowing overlaps and using every single C position
1777 ### Still within the 2-CONTEXT ONLY optional section
1778 else {
1779 ### single-file CpG and non-CpG context output
1780 if ($full) {
1781 if ($strand eq '+') {
1782 for my $index (0..$#methylation_calls) {
1783
1784 if ($cigar){ # only needed for SAM files
1785 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1786 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
1787 $cigar_offset += $cigar_mod;
1788 $pos_offset += $pos_mod;
1789 }
1790
1791 if ($methylation_calls[$index] eq 'X') {
1792 $counting{total_meCHG_count}++;
1793 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1794 } elsif ($methylation_calls[$index] eq 'x') {
1795 $counting{total_unmethylated_CHG_count}++;
1796 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1797 } elsif ($methylation_calls[$index] eq 'Z') {
1798 $counting{total_meCpG_count}++;
1799 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1800 } elsif ($methylation_calls[$index] eq 'z') {
1801 $counting{total_unmethylated_CpG_count}++;
1802 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1803 } elsif ($methylation_calls[$index] eq 'H') {
1804 $counting{total_meCHH_count}++;
1805 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1806 } elsif ($methylation_calls[$index] eq 'h') {
1807 $counting{total_unmethylated_CHH_count}++;
1808 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1809 }
1810 elsif ($methylation_calls[$index] eq '.') {}
1811 else{
1812 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1813 }
1814 }
1815 } elsif ($strand eq '-') {
1816 for my $index (0..$#methylation_calls) {
1817
1818 if ($cigar){ # only needed for SAM files
1819 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
1820 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1821 $cigar_offset += $cigar_mod;
1822 $pos_offset += $pos_mod;
1823 }
1824
1825 if ($methylation_calls[$index] eq 'X') {
1826 $counting{total_meCHG_count}++;
1827 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1828 } elsif ($methylation_calls[$index] eq 'x') {
1829 $counting{total_unmethylated_CHG_count}++;
1830 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1831 } elsif ($methylation_calls[$index] eq 'Z') {
1832 $counting{total_meCpG_count}++;
1833 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1834 } elsif ($methylation_calls[$index] eq 'z') {
1835 $counting{total_unmethylated_CpG_count}++;
1836 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1837 } elsif ($methylation_calls[$index] eq 'H') {
1838 $counting{total_meCHH_count}++;
1839 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1840 } elsif ($methylation_calls[$index] eq 'h') {
1841 $counting{total_unmethylated_CHH_count}++;
1842 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1843 }
1844 elsif ($methylation_calls[$index] eq '.') {}
1845 else{
1846 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1847 }
1848 }
1849 } else {
1850 die "The strand orientation as neither + nor -: '$strand'\n";
1851 }
1852 }
1853
1854 ### strand-specific methylation output
1855 ### still within the 2-CONTEXT optional section
1856 else {
1857 if ($strand eq '+') {
1858 for my $index (0..$#methylation_calls) {
1859
1860 if ($cigar){ # only needed for SAM files
1861 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1862 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
1863 $cigar_offset += $cigar_mod;
1864 $pos_offset += $pos_mod;
1865 }
1866
1867 if ($methylation_calls[$index] eq 'X') {
1868 $counting{total_meCHG_count}++;
1869 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1870 } elsif ($methylation_calls[$index] eq 'x') {
1871 $counting{total_unmethylated_CHG_count}++;
1872 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1873 } elsif ($methylation_calls[$index] eq 'Z') {
1874 $counting{total_meCpG_count}++;
1875 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1876 } elsif ($methylation_calls[$index] eq 'z') {
1877 $counting{total_unmethylated_CpG_count}++;
1878 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1879 } elsif ($methylation_calls[$index] eq 'H') {
1880 $counting{total_meCHH_count}++;
1881 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1882 } elsif ($methylation_calls[$index] eq 'h') {
1883 $counting{total_unmethylated_CHH_count}++;
1884 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1885 }
1886 elsif ($methylation_calls[$index] eq '.') {}
1887 else{
1888 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1889 }
1890 }
1891 } elsif ($strand eq '-') {
1892 for my $index (0..$#methylation_calls) {
1893
1894 if ($cigar){ # only needed for SAM files
1895 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
1896 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1897 $cigar_offset += $cigar_mod;
1898 $pos_offset += $pos_mod;
1899 }
1900
1901 if ($methylation_calls[$index] eq 'X') {
1902 $counting{total_meCHG_count}++;
1903 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1904 } elsif ($methylation_calls[$index] eq 'x') {
1905 $counting{total_unmethylated_CHG_count}++;
1906 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1907 } elsif ($methylation_calls[$index] eq 'Z') {
1908 $counting{total_meCpG_count}++;
1909 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1910 } elsif ($methylation_calls[$index] eq 'z') {
1911 $counting{total_unmethylated_CpG_count}++;
1912 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1913 } elsif ($methylation_calls[$index] eq 'H') {
1914 $counting{total_meCHH_count}++;
1915 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1916 } elsif ($methylation_calls[$index] eq 'h') {
1917 $counting{total_unmethylated_CHH_count}++;
1918 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1919 }
1920 elsif ($methylation_calls[$index] eq '.') {}
1921 else{
1922 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1923 }
1924 }
1925 } else {
1926 die "The strand orientation as neither + nor -: '$strand'\n";
1927 }
1928 }
1929 }
1930 }
1931
1932 ############################################
1933 ### THIS IS THE DEFAULT 3-CONTEXT OUTPUT ###
1934 ############################################
1935
1936 elsif ($no_overlap) {
1937 ### single-file CpG, CHG and CHH context output
1938 if ($full) {
1939 if ($strand eq '+') {
1940 for my $index (0..$#methylation_calls) {
1941
1942 if ($cigar){ # only needed for SAM files
1943 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1944 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
1945 $cigar_offset += $cigar_mod;
1946 $pos_offset += $pos_mod;
1947 }
1948
1949 ### Returning as soon as the methylation calls start overlapping
1950 if ($start+$index+$pos_offset >= $end_read_1) {
1951 return;
1952 }
1953
1954 if ($methylation_calls[$index] eq 'X') {
1955 $counting{total_meCHG_count}++;
1956 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1957 } elsif ($methylation_calls[$index] eq 'x') {
1958 $counting{total_unmethylated_CHG_count}++;
1959 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1960 } elsif ($methylation_calls[$index] eq 'Z') {
1961 $counting{total_meCpG_count}++;
1962 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1963 } elsif ($methylation_calls[$index] eq 'z') {
1964 $counting{total_unmethylated_CpG_count}++;
1965 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1966 } elsif ($methylation_calls[$index] eq 'H') {
1967 $counting{total_meCHH_count}++;
1968 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1969 } elsif ($methylation_calls[$index] eq 'h') {
1970 $counting{total_unmethylated_CHH_count}++;
1971 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
1972 }
1973 elsif ($methylation_calls[$index] eq '.') {}
1974 else{
1975 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
1976 }
1977 }
1978 } elsif ($strand eq '-') {
1979 for my $index (0..$#methylation_calls) {
1980
1981 if ($cigar){ # only needed for SAM files
1982 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
1983 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
1984 $cigar_offset += $cigar_mod;
1985 $pos_offset += $pos_mod;
1986 }
1987
1988 ### Returning as soon as the methylation calls start overlapping
1989 if ($start-$index+$pos_offset <= $end_read_1) {
1990 return;
1991 }
1992
1993 if ($methylation_calls[$index] eq 'X') {
1994 $counting{total_meCHG_count}++;
1995 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1996 } elsif ($methylation_calls[$index] eq 'x') {
1997 $counting{total_unmethylated_CHG_count}++;
1998 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
1999 } elsif ($methylation_calls[$index] eq 'Z') {
2000 $counting{total_meCpG_count}++;
2001 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2002 } elsif ($methylation_calls[$index] eq 'z') {
2003 $counting{total_unmethylated_CpG_count}++;
2004 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2005 } elsif ($methylation_calls[$index] eq 'H') {
2006 $counting{total_meCHH_count}++;
2007 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2008 } elsif ($methylation_calls[$index] eq 'h') {
2009 $counting{total_unmethylated_CHH_count}++;
2010 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2011 }
2012 elsif ($methylation_calls[$index] eq '.') {}
2013 else{
2014 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2015 }
2016 }
2017 } else {
2018 die "The strand orientation as neither + nor -: '$strand'\n";
2019 }
2020 }
2021
2022 ### strand-specific methylation output
2023 else {
2024 if ($strand eq '+') {
2025 for my $index (0..$#methylation_calls) {
2026
2027 if ($cigar){ # only needed for SAM files
2028 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2029 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
2030 $cigar_offset += $cigar_mod;
2031 $pos_offset += $pos_mod;
2032 }
2033
2034 ### Returning as soon as the methylation calls start overlapping
2035 if ($start+$index+$pos_offset >= $end_read_1) {
2036 return;
2037 }
2038
2039 if ($methylation_calls[$index] eq 'X') {
2040 $counting{total_meCHG_count}++;
2041 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2042 } elsif ($methylation_calls[$index] eq 'x') {
2043 $counting{total_unmethylated_CHG_count}++;
2044 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2045 } elsif ($methylation_calls[$index] eq 'Z') {
2046 $counting{total_meCpG_count}++;
2047 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2048 } elsif ($methylation_calls[$index] eq 'z') {
2049 $counting{total_unmethylated_CpG_count}++;
2050 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2051 } elsif ($methylation_calls[$index] eq 'H') {
2052 $counting{total_meCHH_count}++;
2053 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2054 } elsif ($methylation_calls[$index] eq 'h') {
2055 $counting{total_unmethylated_CHH_count}++;
2056 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2057 }
2058 elsif ($methylation_calls[$index] eq '.') {}
2059 else{
2060 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2061 }
2062 }
2063 } elsif ($strand eq '-') {
2064 for my $index (0..$#methylation_calls) {
2065
2066 if ($cigar){ # only needed for SAM files
2067 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
2068 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2069 $cigar_offset += $cigar_mod;
2070 $pos_offset += $pos_mod;
2071 }
2072
2073 ### Returning as soon as the methylation calls start overlapping
2074 if ($start-$index+$pos_offset <= $end_read_1) {
2075 return;
2076 }
2077
2078 if ($methylation_calls[$index] eq 'X') {
2079 $counting{total_meCHG_count}++;
2080 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2081 } elsif ($methylation_calls[$index] eq 'x') {
2082 $counting{total_unmethylated_CHG_count}++;
2083 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2084 } elsif ($methylation_calls[$index] eq 'Z') {
2085 $counting{total_meCpG_count}++;
2086 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2087 } elsif ($methylation_calls[$index] eq 'z') {
2088 $counting{total_unmethylated_CpG_count}++;
2089 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2090 } elsif ($methylation_calls[$index] eq 'H') {
2091 $counting{total_meCHH_count}++;
2092 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2093 } elsif ($methylation_calls[$index] eq 'h') {
2094 $counting{total_unmethylated_CHH_count}++;
2095 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2096 }
2097 elsif ($methylation_calls[$index] eq '.') {}
2098 else{
2099 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2100 }
2101 }
2102 } else {
2103 die "The strand orientation as neither + nor -: '$strand'\n";
2104 }
2105 }
2106 }
2107
2108 ### this is the default paired-end procedure allowing overlaps and using every single C position
2109 else {
2110 ### single-file CpG, CHG and CHH context output
2111 if ($full) {
2112 if ($strand eq '+') {
2113 for my $index (0..$#methylation_calls) {
2114
2115 if ($cigar){ # only needed for SAM files
2116 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2117 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
2118 $cigar_offset += $cigar_mod;
2119 $pos_offset += $pos_mod;
2120 }
2121
2122 if ($methylation_calls[$index] eq 'X') {
2123 $counting{total_meCHG_count}++;
2124 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2125 } elsif ($methylation_calls[$index] eq 'x') {
2126 $counting{total_unmethylated_CHG_count}++;
2127 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2128 } elsif ($methylation_calls[$index] eq 'Z') {
2129 $counting{total_meCpG_count}++;
2130 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2131 } elsif ($methylation_calls[$index] eq 'z') {
2132 $counting{total_unmethylated_CpG_count}++;
2133 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2134 } elsif ($methylation_calls[$index] eq 'H') {
2135 $counting{total_meCHH_count}++;
2136 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2137 } elsif ($methylation_calls[$index] eq 'h') {
2138 $counting{total_unmethylated_CHH_count}++;
2139 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2140 }
2141 elsif ($methylation_calls[$index] eq '.') {}
2142 else{
2143 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2144 }
2145 }
2146 } elsif ($strand eq '-') {
2147 for my $index (0..$#methylation_calls) {
2148
2149 if ($cigar){ # only needed for SAM files
2150 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
2151 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2152 $cigar_offset += $cigar_mod;
2153 $pos_offset += $pos_mod;
2154 }
2155
2156 if ($methylation_calls[$index] eq 'X') {
2157 $counting{total_meCHG_count}++;
2158 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2159 } elsif ($methylation_calls[$index] eq 'x') {
2160 $counting{total_unmethylated_CHG_count}++;
2161 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2162 } elsif ($methylation_calls[$index] eq 'Z') {
2163 $counting{total_meCpG_count}++;
2164 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2165 } elsif ($methylation_calls[$index] eq 'z') {
2166 $counting{total_unmethylated_CpG_count}++;
2167 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2168 } elsif ($methylation_calls[$index] eq 'H') {
2169 $counting{total_meCHH_count}++;
2170 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2171 } elsif ($methylation_calls[$index] eq 'h') {
2172 $counting{total_unmethylated_CHH_count}++;
2173 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2174 }
2175 elsif ($methylation_calls[$index] eq '.') {}
2176 else{
2177 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2178 }
2179 }
2180 } else {
2181 die "The strand orientation as neither + nor -: '$strand'\n";
2182 }
2183 }
2184
2185 ### strand-specific methylation output
2186 else {
2187 if ($strand eq '+') {
2188 for my $index (0..$#methylation_calls) {
2189
2190 if ($cigar){ # only needed for SAM files
2191 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2192 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
2193 $cigar_offset += $cigar_mod;
2194 $pos_offset += $pos_mod;
2195 }
2196
2197 if ($methylation_calls[$index] eq 'X') {
2198 $counting{total_meCHG_count}++;
2199 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2200 } elsif ($methylation_calls[$index] eq 'x') {
2201 $counting{total_unmethylated_CHG_count}++;
2202 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2203 } elsif ($methylation_calls[$index] eq 'Z') {
2204 $counting{total_meCpG_count}++;
2205 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2206 } elsif ($methylation_calls[$index] eq 'z') {
2207 $counting{total_unmethylated_CpG_count}++;
2208 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2209 } elsif ($methylation_calls[$index] eq 'H') {
2210 $counting{total_meCHH_count}++;
2211 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2212 } elsif ($methylation_calls[$index] eq 'h') {
2213 $counting{total_unmethylated_CHH_count}++;
2214 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2215 }
2216 elsif ($methylation_calls[$index] eq '.') {}
2217 else{
2218 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2219 }
2220 }
2221 } elsif ($strand eq '-') {
2222 for my $index (0..$#methylation_calls) {
2223
2224 if ($cigar){ # only needed for SAM files
2225 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
2226 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2227 $cigar_offset += $cigar_mod;
2228 $pos_offset += $pos_mod;
2229 }
2230
2231 if ($methylation_calls[$index] eq 'X') {
2232 $counting{total_meCHG_count}++;
2233 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2234 } elsif ($methylation_calls[$index] eq 'x') {
2235 $counting{total_unmethylated_CHG_count}++;
2236 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2237 } elsif ($methylation_calls[$index] eq 'Z') {
2238 $counting{total_meCpG_count}++;
2239 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2240 } elsif ($methylation_calls[$index] eq 'z') {
2241 $counting{total_unmethylated_CpG_count}++;
2242 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2243 } elsif ($methylation_calls[$index] eq 'H') {
2244 $counting{total_meCHH_count}++;
2245 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2246 } elsif ($methylation_calls[$index] eq 'h') {
2247 $counting{total_unmethylated_CHH_count}++;
2248 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2249 }
2250 elsif ($methylation_calls[$index] eq '.') {}
2251 else{
2252 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2253 }
2254 }
2255 } else {
2256 die "The strand orientation as neither + nor -: '$strand'\n";
2257 }
2258 }
2259 }
2260 }
2261
2262 sub check_cigar_string {
2263 my ($index,$cigar_offset,$pos_offset,$strand,$comp_cigar) = @_;
2264 # print "$index\t$cigar_offset\t$pos_offset\t$strand\t";
2265 my ($new_cigar_offset,$new_pos_offset) = (0,0);
2266
2267 if ($strand eq '+') {
2268 # print "### $strand strand @$comp_cigar[$index + $cigar_offset]\t";
2269
2270 if (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'M'){ # sequence position matches the genomic position
2271 # warn "position needs no adjustment\n";
2272 }
2273
2274 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'I'){ # insertion in the read sequence
2275 $new_pos_offset -= 1; # we need to subtract the length of inserted bases from the genomic position
2276 # warn "adjusted genomic position by -1 bp (insertion)\n";
2277 }
2278
2279 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'D'){ # deletion in the read sequence
2280 $new_cigar_offset += 1; # the composite cigar string does no longer match the methylation call index
2281 $new_pos_offset += 1; # we need to add the length of deleted bases to get the genomic position
2282 # warn "adjusted genomic position by +1 bp (deletion). Now looping through the CIGAR string until we hit another M or I\n";
2283
2284 while ( ($index + $cigar_offset + $new_cigar_offset) < (scalar @$comp_cigar) ){
2285 if (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'M'){ # sequence position matches the genomic position
2286 # warn "position needs no adjustment\n";
2287 last;
2288 }
2289 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'I'){
2290 $new_pos_offset -= 1; # we need to subtract the length of inserted bases from the genomic position
2291 # warn "adjusted genomic position by another -1 bp (insertion)\n";
2292 last;
2293 }
2294 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'D'){ # deletion in the read sequence
2295 $new_cigar_offset += 1; # the composite cigar string does no longer match the methylation call index
2296 $new_pos_offset += 1; # we need to add the length of deleted bases to get the genomic position
2297 # warn "adjusted genomic position by another +1 bp (deletion)\n";
2298 }
2299 else{
2300 die "The CIGAR string contained undefined operations in addition to 'M', 'I' and 'D': '@$comp_cigar[$index + $cigar_offset + $new_cigar_offset]'\n";
2301 }
2302 }
2303 }
2304 else{
2305 die "The CIGAR string contained undefined operations in addition to 'M', 'I' and 'D': '@$comp_cigar[$index + $cigar_offset + $new_cigar_offset]'\n";
2306 }
2307 }
2308
2309 elsif ($strand eq '-') {
2310 # print "### $strand strand @$comp_cigar[$index + $cigar_offset]\t";
2311
2312 if (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'M'){ # sequence position matches the genomic position
2313 # warn "position needs no adjustment\n";
2314 }
2315
2316 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'I'){ # insertion in the read sequence
2317 $new_pos_offset += 1; # we need to add the length of inserted bases to the genomic position
2318 # warn "adjusted genomic position by +1 bp (insertion)\n";
2319 }
2320
2321 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'D'){ # deletion in the read sequence
2322 $new_cigar_offset += 1; # the composite cigar string does no longer match the methylation call index
2323 $new_pos_offset -= 1; # we need to subtract the length of deleted bases to get the genomic position
2324 # warn "adjusted genomic position by -1 bp (deletion). Now looping through the CIGAR string until we hit another M or I\n";
2325
2326 while ( ($index + $cigar_offset + $new_cigar_offset) < (scalar @$comp_cigar) ){
2327 if (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'M'){ # sequence position matches the genomic position
2328 # warn "Found new 'M' operation; position needs no adjustment\n";
2329 last;
2330 }
2331 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'I'){
2332 $new_pos_offset += 1; # we need to subtract the length of inserted bases from the genomic position
2333 # warn "Found new 'I' operation; adjusted genomic position by another +1 bp (insertion)\n";
2334 last;
2335 }
2336 elsif (@$comp_cigar[$index + $cigar_offset + $new_cigar_offset] eq 'D'){ # deletion in the read sequence
2337 $new_cigar_offset += 1; # the composite cigar string does no longer match the methylation call index
2338 $new_pos_offset -= 1; # we need to subtract the length of deleted bases to get the genomic position
2339 # warn "adjusted genomic position by another -1 bp (deletion)\n";
2340 }
2341 else{
2342 die "The CIGAR string contained undefined operations in addition to 'M', 'I' and 'D': '@$comp_cigar[$index + $cigar_offset + $new_cigar_offset]'\n";
2343 }
2344 }
2345 }
2346 else{
2347 die "The CIGAR string contained undefined operations in addition to 'M', 'I' and 'D': '@$comp_cigar[$index + $cigar_offset + $new_cigar_offset]'\n";
2348 }
2349 }
2350 # print "new cigar offset: $new_cigar_offset\tnew pos offset: $new_pos_offset\n";
2351 return ($new_cigar_offset,$new_pos_offset);
2352 }
2353
2354 sub print_individual_C_methylation_states_single_end{
2355
2356 my ($meth_call,$chrom,$start,$id,$strand,$filehandle_index,$cigar) = @_;
2357 my @methylation_calls = split(//,$meth_call);
2358
2359 #################################################################
2360 ### . for bases not involving cytosines ###
2361 ### X for methylated C in CHG context (was protected) ###
2362 ### x for not methylated C in CHG context (was converted) ###
2363 ### H for methylated C in CHH context (was protected) ###
2364 ### h for not methylated C in CHH context (was converted) ###
2365 ### Z for methylated C in CpG context (was protected) ###
2366 ### z for not methylated C in CpG context (was converted) ###
2367 #################################################################
2368
2369 my $methyl_CHG_count = 0;
2370 my $methyl_CHH_count = 0;
2371 my $methyl_CpG_count = 0;
2372 my $unmethylated_CHG_count = 0;
2373 my $unmethylated_CHH_count = 0;
2374 my $unmethylated_CpG_count = 0;
2375
2376 my @len;
2377 my @ops;
2378 my $pos_offset = 0; # this is only relevant for SAM reads with insertions or deletions
2379 my $cigar_offset = 0; # again, this is only relevant for SAM reads containing indels
2380
2381 my @comp_cigar;
2382
2383 if ($cigar){ # parsing CIGAR string
2384 @len = split (/\D+/,$cigar); # storing the length per operation
2385 @ops = split (/\d+/,$cigar); # storing the operation
2386 shift @ops; # remove the empty first element
2387 die "CIGAR string contained a non-matching number of lengths and operations\n" unless (scalar @len == scalar @ops);
2388
2389 foreach my $index (0..$#len){
2390 foreach (1..$len[$index]){
2391 # print "$ops[$index]";
2392 push @comp_cigar, $ops[$index];
2393 }
2394 }
2395 # warn "\nDetected CIGAR string: $cigar\n";
2396 # warn "Length of methylation call: ",length $meth_call,"\n";
2397 # warn "number of operations: ",scalar @ops,"\n";
2398 # warn "number of length digits: ",scalar @len,"\n\n";
2399 # print @comp_cigar,"\n";
2400 # print "$meth_call\n\n";
2401 # sleep (1);
2402 }
2403
2404 ### adjusting the start position for all reads mapping to the reverse strand
2405 if ($strand eq '-') {
2406
2407 @comp_cigar = reverse@comp_cigar; # the CIGAR string needs to be reversed for all reads aligning to the reverse strand, too
2408 # print @comp_cigar,"\n";
2409
2410 unless ($ignore){ ### if --ignore was specified the start position has already been corrected
2411
2412 if ($cigar){ ### SAM format
2413 my $MD_count = 0;
2414 foreach (@comp_cigar){
2415 ++$MD_count if ($_ eq 'M' or $_ eq 'D'); # Matching bases or deletions affect the genomic position of the 3' ends of reads, insertions don't
2416 }
2417 $start += $MD_count - 1;
2418 }
2419 else{ ### vanilla format
2420 $start += length($meth_call)-1;
2421 }
2422 }
2423 }
2424
2425 ### THIS IS THE CpG and Non-CpG SECTION (OPTIONAL)
2426
2427 ### single-file CpG and other-context output
2428 if ($full and $merge_non_CpG) {
2429 if ($strand eq '+') {
2430 for my $index (0..$#methylation_calls) {
2431
2432 if ($cigar){ # only needed for SAM files
2433 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2434 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition+index: ",$start+$index,"\t";
2435 $cigar_offset += $cigar_mod;
2436 $pos_offset += $pos_mod;
2437 }
2438
2439 ### methylated Cs (any context) will receive a forward (+) orientation
2440 ### not methylated Cs (any context) will receive a reverse (-) orientation
2441 if ($methylation_calls[$index] eq 'X') {
2442 $counting{total_meCHG_count}++;
2443 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2444 }
2445 elsif ($methylation_calls[$index] eq 'x') {
2446 $counting{total_unmethylated_CHG_count}++;
2447 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2448 }
2449 elsif ($methylation_calls[$index] eq 'Z') {
2450 $counting{total_meCpG_count}++;
2451 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2452 }
2453 elsif ($methylation_calls[$index] eq 'z') {
2454 $counting{total_unmethylated_CpG_count}++;
2455 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2456 }
2457 elsif ($methylation_calls[$index] eq 'H') {
2458 $counting{total_meCHH_count}++;
2459 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2460 }
2461 elsif ($methylation_calls[$index] eq 'h') {
2462 $counting{total_unmethylated_CHH_count}++;
2463 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2464 }
2465 elsif ($methylation_calls[$index] eq '.') {
2466 }
2467 else{
2468 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2469 }
2470 }
2471 }
2472 elsif ($strand eq '-') {
2473
2474 for my $index (0..$#methylation_calls) {
2475 ### methylated Cs (any context) will receive a forward (+) orientation
2476 ### not methylated Cs (any context) will receive a reverse (-) orientation
2477
2478 if ($cigar){ # only needed for SAM files
2479 # print "index: $index\tmethylation_call: $methylation_calls[$index]\tposition-index: ",$start-$index,"\t";
2480 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2481 $cigar_offset += $cigar_mod;
2482 $pos_offset += $pos_mod;
2483 }
2484
2485 if ($methylation_calls[$index] eq 'X') {
2486 $counting{total_meCHG_count}++;
2487 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2488 }
2489 elsif ($methylation_calls[$index] eq 'x') {
2490 $counting{total_unmethylated_CHG_count}++;
2491 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2492 }
2493 elsif ($methylation_calls[$index] eq 'Z') {
2494 $counting{total_meCpG_count}++;
2495 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2496 }
2497 elsif ($methylation_calls[$index] eq 'z') {
2498 $counting{total_unmethylated_CpG_count}++;
2499 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2500 }
2501 elsif ($methylation_calls[$index] eq 'H') {
2502 $counting{total_meCHH_count}++;
2503 print {$fhs{other_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2504 }
2505 elsif ($methylation_calls[$index] eq 'h') {
2506 $counting{total_unmethylated_CHH_count}++;
2507 print {$fhs{other_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2508 }
2509 elsif ($methylation_calls[$index] eq '.'){
2510 }
2511 else{
2512 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2513 }
2514 }
2515 }
2516 else {
2517 die "The strand information was neither + nor -: $strand\n";
2518 }
2519 }
2520
2521 ### strand-specific methylation output
2522 elsif ($merge_non_CpG) {
2523 if ($strand eq '+') {
2524 for my $index (0..$#methylation_calls) {
2525 ### methylated Cs (any context) will receive a forward (+) orientation
2526 ### not methylated Cs (any context) will receive a reverse (-) orientation
2527
2528 if ($cigar){ # only needed for SAM files
2529 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2530 $cigar_offset += $cigar_mod;
2531 $pos_offset += $pos_mod;
2532 }
2533
2534 if ($methylation_calls[$index] eq 'X') {
2535 $counting{total_meCHG_count}++;
2536 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2537 }
2538 elsif ($methylation_calls[$index] eq 'x') {
2539 $counting{total_unmethylated_CHG_count}++;
2540 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2541 }
2542 elsif ($methylation_calls[$index] eq 'Z') {
2543 $counting{total_meCpG_count}++;
2544 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2545 }
2546 elsif ($methylation_calls[$index] eq 'z') {
2547 $counting{total_unmethylated_CpG_count}++;
2548 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2549 }
2550 elsif ($methylation_calls[$index] eq 'H') {
2551 $counting{total_meCHH_count}++;
2552 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2553 }
2554 elsif ($methylation_calls[$index] eq 'h') {
2555 $counting{total_unmethylated_CHH_count}++;
2556 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2557 }
2558 elsif ($methylation_calls[$index] eq '.') {
2559 }
2560 else{
2561 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2562 }
2563 }
2564 }
2565 elsif ($strand eq '-') {
2566
2567 for my $index (0..$#methylation_calls) {
2568 ### methylated Cs (any context) will receive a forward (+) orientation
2569 ### not methylated Cs (any context) will receive a reverse (-) orientation
2570
2571 if ($cigar){ # only needed for SAM files
2572 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2573 $cigar_offset += $cigar_mod;
2574 $pos_offset += $pos_mod;
2575 }
2576
2577 if ($methylation_calls[$index] eq 'X') {
2578 $counting{total_meCHG_count}++;
2579 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2580 }
2581 elsif ($methylation_calls[$index] eq 'x') {
2582 $counting{total_unmethylated_CHG_count}++;
2583 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2584 }
2585 elsif ($methylation_calls[$index] eq 'Z') {
2586 $counting{total_meCpG_count}++;
2587 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2588 }
2589 elsif ($methylation_calls[$index] eq 'z') {
2590 $counting{total_unmethylated_CpG_count}++;
2591 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2592 }
2593 elsif ($methylation_calls[$index] eq 'H') {
2594 $counting{total_meCHH_count}++;
2595 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2596 }
2597 elsif ($methylation_calls[$index] eq 'h') {
2598 $counting{total_unmethylated_CHH_count}++;
2599 print {$fhs{$filehandle_index}->{other_c}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2600 }
2601 elsif ($methylation_calls[$index] eq '.') {
2602 }
2603 else{
2604 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2605 }
2606 }
2607 }
2608 else {
2609 die "The strand information was neither + nor -: $strand\n";
2610 }
2611 }
2612
2613 ### THIS IS THE 3-CONTEXT (CpG, CHG and CHH) DEFAULT SECTION
2614
2615 elsif ($full) {
2616 if ($strand eq '+') {
2617 for my $index (0..$#methylation_calls) {
2618 ### methylated Cs (any context) will receive a forward (+) orientation
2619 ### not methylated Cs (any context) will receive a reverse (-) orientation
2620
2621 if ($cigar){ # only needed for SAM files
2622 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2623 $cigar_offset += $cigar_mod;
2624 $pos_offset += $pos_mod;
2625 }
2626
2627 if ($methylation_calls[$index] eq 'X') {
2628 $counting{total_meCHG_count}++;
2629 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2630 } elsif ($methylation_calls[$index] eq 'x') {
2631 $counting{total_unmethylated_CHG_count}++;
2632 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2633 } elsif ($methylation_calls[$index] eq 'Z') {
2634 $counting{total_meCpG_count}++;
2635 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2636 } elsif ($methylation_calls[$index] eq 'z') {
2637 $counting{total_unmethylated_CpG_count}++;
2638 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2639 } elsif ($methylation_calls[$index] eq 'H') {
2640 $counting{total_meCHH_count}++;
2641 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2642 } elsif ($methylation_calls[$index] eq 'h') {
2643 $counting{total_unmethylated_CHH_count}++;
2644 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2645 }
2646 elsif ($methylation_calls[$index] eq '.') {}
2647 else{
2648 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2649 }
2650 }
2651 }
2652 elsif ($strand eq '-') {
2653
2654 for my $index (0..$#methylation_calls) {
2655 ### methylated Cs (any context) will receive a forward (+) orientation
2656 ### not methylated Cs (any context) will receive a reverse (-) orientation
2657
2658 if ($cigar){ # only needed for SAM files
2659 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2660 $cigar_offset += $cigar_mod;
2661 $pos_offset += $pos_mod;
2662 }
2663
2664 if ($methylation_calls[$index] eq 'X') {
2665 $counting{total_meCHG_count}++;
2666 print {$fhs{CHG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2667 } elsif ($methylation_calls[$index] eq 'x') {
2668 $counting{total_unmethylated_CHG_count}++;
2669 print {$fhs{CHG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2670 } elsif ($methylation_calls[$index] eq 'Z') {
2671 $counting{total_meCpG_count}++;
2672 print {$fhs{CpG_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2673 } elsif ($methylation_calls[$index] eq 'z') {
2674 $counting{total_unmethylated_CpG_count}++;
2675 print {$fhs{CpG_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2676 } elsif ($methylation_calls[$index] eq 'H') {
2677 $counting{total_meCHH_count}++;
2678 print {$fhs{CHH_context}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2679 } elsif ($methylation_calls[$index] eq 'h') {
2680 $counting{total_unmethylated_CHH_count}++;
2681 print {$fhs{CHH_context}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2682 }
2683 elsif ($methylation_calls[$index] eq '.') {}
2684 else{
2685 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2686 }
2687 }
2688 }
2689 else {
2690 die "The read had a strand orientation which was neither + nor -: $strand\n";
2691 }
2692 }
2693
2694 ### strand-specific methylation output
2695 else {
2696 if ($strand eq '+') {
2697 for my $index (0..$#methylation_calls) {
2698 ### methylated Cs (any context) will receive a forward (+) orientation
2699 ### not methylated Cs (any context) will receive a reverse (-) orientation
2700
2701 if ($cigar){ # only needed for SAM files
2702 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2703 $cigar_offset += $cigar_mod;
2704 $pos_offset += $pos_mod;
2705 }
2706
2707 if ($methylation_calls[$index] eq 'X') {
2708 $counting{total_meCHG_count}++;
2709 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2710 } elsif ($methylation_calls[$index] eq 'x') {
2711 $counting{total_unmethylated_CHG_count}++;
2712 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2713 } elsif ($methylation_calls[$index] eq 'Z') {
2714 $counting{total_meCpG_count}++;
2715 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2716 } elsif ($methylation_calls[$index] eq 'z') {
2717 $counting{total_unmethylated_CpG_count}++;
2718 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2719 } elsif ($methylation_calls[$index] eq 'H') {
2720 $counting{total_meCHH_count}++;
2721 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2722 } elsif ($methylation_calls[$index] eq 'h') {
2723 $counting{total_unmethylated_CHH_count}++;
2724 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start+$index+$pos_offset,$methylation_calls[$index]),"\n";
2725 }
2726 elsif ($methylation_calls[$index] eq '.') {}
2727 else{
2728 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2729 }
2730 }
2731 }
2732 elsif ($strand eq '-') {
2733
2734 for my $index (0..$#methylation_calls) {
2735 ### methylated Cs (any context) will receive a forward (+) orientation
2736 ### not methylated Cs (any context) will receive a reverse (-) orientation
2737
2738 if ($cigar){ # only needed for SAM files
2739 my ($cigar_mod,$pos_mod) = check_cigar_string($index,$cigar_offset,$pos_offset,$strand,\@comp_cigar);
2740 $cigar_offset += $cigar_mod;
2741 $pos_offset += $pos_mod;
2742 }
2743
2744 if ($methylation_calls[$index] eq 'X') {
2745 $counting{total_meCHG_count}++;
2746 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2747 } elsif ($methylation_calls[$index] eq 'x') {
2748 $counting{total_unmethylated_CHG_count}++;
2749 print {$fhs{$filehandle_index}->{CHG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2750 } elsif ($methylation_calls[$index] eq 'Z') {
2751 $counting{total_meCpG_count}++;
2752 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2753 } elsif ($methylation_calls[$index] eq 'z') {
2754 $counting{total_unmethylated_CpG_count}++;
2755 print {$fhs{$filehandle_index}->{CpG}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2756 } elsif ($methylation_calls[$index] eq 'H') {
2757 $counting{total_meCHH_count}++;
2758 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'+',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2759 } elsif ($methylation_calls[$index] eq 'h') {
2760 $counting{total_unmethylated_CHH_count}++;
2761 print {$fhs{$filehandle_index}->{CHH}} join ("\t",$id,'-',$chrom,$start-$index+$pos_offset,$methylation_calls[$index]),"\n";
2762 }
2763 elsif ($methylation_calls[$index] eq '.') {}
2764 else{
2765 die "The methylation call string contained the following unrecognised character: $methylation_calls[$index]\n";
2766 }
2767 }
2768 }
2769 else {
2770 die "The strand information was neither + nor -: $strand\n";
2771 }
2772 }
2773 }
2774
2775
2776
2777 #######################################################################################################################################
2778 ### bismark2bedGaph section - START
2779 #######################################################################################################################################
2780
2781 sub process_bedGraph_output{
2782 warn "="x64,"\n";
2783 warn "Methylation information will now be written into a bedGraph file\n";
2784 warn "="x64,"\n\n";
2785 sleep (2);
2786
2787 ### Closing all filehandles so that the Bismark methtylation extractor output doesn't get truncated due to buffering issues
2788 foreach my $fh (keys %fhs) {
2789 if ($fh =~ /^[1230]$/) {
2790 foreach my $context (keys %{$fhs{$fh}}) {
2791 close $fhs{$fh}->{$context} or die $!;
2792 }
2793 } else {
2794 close $fhs{$fh} or die $!;
2795 }
2796 }
2797
2798 ### deciding which files to use for bedGraph conversion
2799 foreach my $filename (@sorting_files){
2800 # warn "$filename\n";
2801 if ($filename =~ /\//){ # if files are in a different output folder we extract the filename again
2802 $filename =~ s/.*\///; # replacing everything up to the last slash in the filename
2803 # warn "$filename\n";
2804 }
2805
2806 if ($CX_context){
2807 push @bedfiles,$filename;
2808 }
2809 else{ ## CpG context only (default)
2810 if ($filename =~ /^CpG_/){
2811 push @bedfiles,$filename;
2812 }
2813 else{
2814 # skipping CHH or CHG files
2815 }
2816 }
2817 }
2818
2819 warn "Using the following files as Input:\n";
2820 print join ("\t",@bedfiles),"\n\n";
2821 sleep (2);
2822
2823 my %temp_fhs;
2824 my @temp_files; # writing all context files (default CpG only) to these files prior to sorting
2825
2826 ### changing to the output directory
2827 unless ($output_dir eq ''){ # default
2828 chdir $output_dir or die "Failed to change directory to $output_dir\n";
2829 warn "Changed directory to $output_dir\n";
2830 }
2831
2832 foreach my $infile (@bedfiles) {
2833
2834 if ($remove) {
2835 warn "Now replacing whitespaces in the sequence ID field of the Bismark methylation extractor output $infile prior to bedGraph conversion\n\n";
2836
2837 open (READ,$infile) or die $!;
2838
2839 my $removed_spaces_outfile = $infile;
2840 $removed_spaces_outfile =~ s/$/.spaces_removed.txt/;
2841
2842 open (REM,'>',$output_dir.$removed_spaces_outfile) or die "Couldn't write to file $removed_spaces_outfile: $!\n";
2843
2844 unless ($no_header){
2845 $_ = <READ>; ### Bismark version header
2846 print REM $_; ### Bismark version header
2847 }
2848
2849 while (<READ>) {
2850 chomp;
2851 my ($id,$strand,$chr,$pos,$context) = (split (/\t/));
2852 $id =~ s/\s+/_/g;
2853 print REM join ("\t",$id,$strand,$chr,$pos,$context),"\n";
2854 }
2855
2856 close READ or die $!;
2857 close REM or die $!;
2858
2859 ### changing the infile name to the new file without spaces
2860 $infile = $removed_spaces_outfile;
2861 }
2862
2863 warn "Now writing methylation information for file $infile to individual files for each chromosome\n";
2864 open (IN,$infile) or die $!;
2865
2866 ## always ignoring the version header
2867 unless ($no_header){
2868 $_ = <IN>; ### Bismark version header
2869 }
2870
2871 while (<IN>) {
2872 chomp;
2873 my ($chr) = (split (/\t/))[2];
2874
2875 unless (exists $temp_fhs{$chr}) {
2876 open ($temp_fhs{$chr},'>','chr'.$chr.'.meth_extractor.temp') or die "Failed to open filehandle: $!";
2877 }
2878 print {$temp_fhs{$chr}} "$_\n";
2879 }
2880
2881 warn "Finished writing out individual chromosome files for $infile\n";
2882 }
2883 warn "\n";
2884
2885 @temp_files = <*.meth_extractor.temp>;
2886
2887 warn "Collecting temporary chromosome file information...\n";
2888 sleep (1);
2889 warn "processing the following input file(s):\n";
2890 warn join ("\n",@temp_files),"\n\n";
2891 sleep (1);
2892
2893 foreach my $in (@temp_files) {
2894 warn "Sorting input file $in by positions\n";
2895 open my $ifh, "sort -k3,3 -k4,4n $in |" or die "Input file could not be sorted. $!";
2896 # print "Chromosome\tStart Position\tEnd Position\tMethylation Percentage\n";
2897
2898 ############################################# m.a.bentley - moved the variables out of the while loop to hold the current line data {
2899
2900 my $name;
2901 my $meth_state;
2902 my $chr = "";
2903 my $pos = 0;
2904 my $meth_state2;
2905
2906 my $last_pos;
2907 my $last_chr;
2908
2909 ############################################# }
2910
2911 while (my $line = <$ifh>) {
2912 next if $line =~ /^Bismark/;
2913 chomp $line;
2914
2915 ########################################### m.a.bentley - (1) set the last_chr and last_pos variables early in the while loop, before the line split (2) removed unnecessary setting of same variables in if statement {
2916
2917 $last_chr = $chr;
2918 $last_pos = $pos;
2919 ($name, $meth_state, $chr, $pos, $meth_state2) = split "\t", $line;
2920
2921 if (($last_pos ne $pos) || ($last_chr ne $chr)) {
2922 generate_output($last_chr,$last_pos) if $methylcalls[2] > 0;
2923 @methylcalls = qw (0 0 0);
2924 }
2925
2926 ############################################# }
2927
2928 my $validated = validate_methylation_call($meth_state, $meth_state2);
2929 unless($validated){
2930 warn "Methylation state of sequence ($name) in file ($in) on line $. is inconsistent (meth_state is $meth_state, meth_state2 = $meth_state2)\n";
2931 next;
2932 }
2933 if ($meth_state eq "+") {
2934 $methylcalls[0]++;
2935 $methylcalls[2]++;
2936 } else {
2937 $methylcalls[1]++;
2938 $methylcalls[2]++;
2939 }
2940 }
2941
2942 ############################################# m.a.bentley - set the last_chr and last_pos variables for the last line in the file (outside the while loop's scope using the method i've implemented) {
2943
2944 $last_chr = $chr;
2945 $last_pos = $pos;
2946 if ($methylcalls[2] > 0) {
2947 generate_output($last_chr,$last_pos) if $methylcalls[2] > 0;
2948 }
2949 ############################################# }
2950
2951 close $ifh or die $!;
2952
2953 @methylcalls = qw (0 0 0); # resetting @methylcalls
2954
2955 ### deleting temporary files
2956 my $delete = unlink $in;
2957 if ($delete) {
2958 warn "Successfully deleted the temporary input file $in\n\n";
2959 }
2960 else {
2961 warn "The temporary inputfile $in could not be deleted $!\n\n";
2962 }
2963 }
2964 }
2965
2966 sub generate_output{
2967 my $methcount = $methylcalls[0];
2968 my $nonmethcount = $methylcalls[1];
2969 my $totalcount = $methylcalls[2];
2970 my $last_chr = shift;
2971 my $last_pos = shift;
2972 croak "Should not be generating output if there's no reads to this region" unless $totalcount > 0;
2973 croak "Total counts ($totalcount) is not the sum of the methylated ($methcount) and unmethylated ($nonmethcount) counts" if $totalcount != ($methcount + $nonmethcount);
2974
2975 ############################################# m.a.bentley - declare a new variable 'bed_pos' to distinguish from bismark positions (-1) - previous scripts modified the last_pos variable earlier in the script leading to problems in meth % calculation {
2976
2977 my $bed_pos = $last_pos -1; ### Bismark coordinates are 1 based whereas bedGraph coordinates are 0 based.
2978 my $meth_percentage;
2979 ($totalcount >= $coverage_threshold) ? ($meth_percentage = ($methcount/$totalcount) * 100) : ($meth_percentage = undef);
2980 # $meth_percentage =~ s/(\.\d\d).+$/$1/ unless $meth_percentage =~ /^Below/;
2981 if (defined $meth_percentage){
2982 if ($counts){
2983 print OUT "$last_chr\t$bed_pos\t$bed_pos\t$meth_percentage\t$methcount\t$nonmethcount\n";
2984 }
2985 else{
2986 print OUT "$last_chr\t$bed_pos\t$bed_pos\t$meth_percentage\n";
2987 }
2988 }
2989 ############################################# }
2990 }
2991
2992 sub validate_methylation_call{
2993 my $meth_state = shift;
2994 croak "Missing (+/-) methylation call" unless defined $meth_state;
2995 my $meth_state2 = shift;
2996 croak "Missing alphabetical methylation call" unless defined $meth_state2;
2997 my $is_consistent;
2998 ($meth_state2 =~ /^z/i) ? ($is_consistent = check_CpG_methylation_call($meth_state, $meth_state2))
2999 : ($is_consistent = check_nonCpG_methylation_call($meth_state,$meth_state2));
3000 return 1 if $is_consistent;
3001 return 0;
3002 }
3003
3004 sub check_CpG_methylation_call{
3005 my $meth1 = shift;
3006 my $meth2 = shift;
3007 return 1 if($meth1 eq "+" && $meth2 eq "Z");
3008 return 1 if($meth1 eq "-" && $meth2 eq "z");
3009 return 0;
3010 }
3011
3012 sub check_nonCpG_methylation_call{
3013 my $meth1 = shift;
3014 my $meth2 = shift;
3015 return 1 if($meth1 eq "+" && $meth2 eq "C");
3016 return 1 if($meth1 eq "+" && $meth2 eq "X");
3017 return 1 if($meth1 eq "+" && $meth2 eq "H");
3018 return 1 if($meth1 eq "-" && $meth2 eq "c");
3019 return 1 if($meth1 eq "-" && $meth2 eq "x");
3020 return 1 if($meth1 eq "-" && $meth2 eq "h");
3021 return 0;
3022 }
3023
3024 #######################################################################################################################################
3025 ### bismark2bedGaph section - END
3026 #######################################################################################################################################
3027
3028
3029
3030
3031
3032
3033 #######################################################################################################################################
3034 ### genome-wide cytosine methylation report - START
3035 #######################################################################################################################################
3036
3037 sub generate_genome_wide_cytosine_report {
3038
3039 warn "="x78,"\n";
3040 warn "Methylation information will now be written into a genome-wide cytosine report\n";
3041 warn "="x78,"\n\n";
3042 sleep (2);
3043
3044 ### changing to the output directory again
3045 unless ($output_dir eq ''){ # default
3046 chdir $output_dir or die "Failed to change directory to $output_dir\n";
3047 # warn "Changed directory to $output_dir\n";
3048 }
3049
3050 my $in = shift;
3051 open (IN,$in) or die $!;
3052
3053 my $cytosine_out = shift;
3054
3055 if ($CX_context){
3056 $cytosine_out =~ s/$/genome-wide_CX_report.txt/;
3057 }
3058 else{
3059 $cytosine_out =~ s/$/genome_wide_CpG_report.txt/;
3060 }
3061
3062 ### note: we are still in the folder: $output_dir, so we do not have to include this into the open commands
3063 unless ($split_by_chromosome){ ### writing all output to a single file (default)
3064 open (CYT,'>',$cytosine_out) or die $!;
3065 warn "Writing genome-wide cytosine report to: $cytosine_out\n";
3066 sleep (3);
3067 }
3068
3069 my $last_chr;
3070 my %chr; # storing reads for one chromosome at a time
3071
3072 my $count = 0;
3073 while (<IN>){
3074 chomp;
3075 ++$count;
3076 my ($chr,$start,$end,undef,$meth,$nonmeth) = (split /\t/);
3077
3078 # defining the first chromosome
3079 unless (defined $last_chr){
3080 $last_chr = $chr;
3081 # warn "Storing all covered cytosine positions for chromosome: $chr\n";
3082 }
3083
3084 if ($chr eq $last_chr){
3085 $chr{$chr}->{$start}->{meth} = $meth;
3086 $chr{$chr}->{$start}->{nonmeth} = $nonmeth;
3087 }
3088 else{
3089 warn "Writing cytosine reports for chromosome $last_chr (stored ",scalar keys %{$chr{$last_chr}}," different covered positions)\n";
3090
3091 if ($split_by_chromosome){ ## writing output to 1 file per chromosome
3092 my $chromosome_out = $cytosine_out;
3093 $chromosome_out =~ s/txt$/chr${last_chr}.txt/;
3094 open (CYT,'>',$chromosome_out) or die $!;
3095 }
3096
3097 while ( $chromosomes{$last_chr} =~ /([CG])/g){
3098
3099 my $tri_nt = '';
3100 my $context = '';
3101 my $pos = pos$chromosomes{$last_chr};
3102
3103 my $strand;
3104 my $meth = 0;
3105 my $nonmeth = 0;
3106
3107 if ($1 eq 'C'){ # C on forward strand
3108 $tri_nt = substr ($chromosomes{$last_chr},($pos-1),3); # positions are 0-based!
3109 $strand = '+';
3110 }
3111 elsif ($1 eq 'G'){ # C on reverse strand
3112 $tri_nt = substr ($chromosomes{$last_chr},($pos-3),3); # positions are 0-based!
3113 $tri_nt = reverse $tri_nt;
3114 $tri_nt =~ tr/ACTG/TGAC/;
3115 $strand = '-';
3116 }
3117 next if (length$tri_nt < 3); # trinucleotide sequence could not be extracted
3118
3119 if (exists $chr{$last_chr}->{($pos-1)}){ # stored positions are 0-based!
3120 $meth = $chr{$last_chr}->{$pos-1}->{meth};
3121 $nonmeth = $chr{$last_chr}->{$pos-1}->{nonmeth};
3122 }
3123
3124 ### determining cytosine context
3125 if ($tri_nt =~ /^CG/){
3126 $context = 'CG';
3127 }
3128 elsif ($tri_nt =~ /^C.{1}G$/){
3129 $context = 'CHG';
3130 }
3131 elsif ($tri_nt =~ /^C.{2}$/){
3132 $context = 'CHH';
3133 }
3134 else{ # if the context can't be determined the positions will not be printed (it will equally not have been reported by Bismark)
3135 warn "The sequence context could not be determined (found: '$tri_nt'). Skipping.\n";
3136 next;
3137 }
3138
3139 if ($CpG_only){
3140 if ($tri_nt =~ /^CG/){ # CpG context is the default
3141 if ($zero){ # zero based coordinates
3142 $pos -= 1;
3143 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3144 }
3145 else{ # default
3146 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3147 }
3148 }
3149 }
3150 else{ ## all cytosines, specified with --CX
3151 if ($zero){ # zero based coordinates
3152 $pos -= 1;
3153 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3154 }
3155 else{ # default
3156 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3157 }
3158 }
3159 }
3160
3161 %chr = (); # resetting the hash
3162
3163 # new first entry
3164 $last_chr = $chr;
3165 $chr{$chr}->{$start}->{meth} = $meth;
3166 $chr{$chr}->{$start}->{nonmeth} = $nonmeth;
3167 }
3168 }
3169
3170 # Last found chromosome
3171 warn "Writing cytosine reports for chromosome $last_chr (stored ",scalar keys %{$chr{$last_chr}}," different covered positions)\n";
3172
3173 if ($split_by_chromosome){ ## writing output to 1 file per chromosome
3174 my $chromosome_out = $cytosine_out;
3175 $chromosome_out =~ s/txt$/chr${last_chr}.txt/;
3176 open (CYT,'>',$chromosome_out) or die $!;
3177 }
3178
3179 while ( $chromosomes{$last_chr} =~ /([CG])/g){
3180
3181 my $tri_nt;
3182 my $context;
3183 my $pos = pos$chromosomes{$last_chr};
3184
3185 my $strand;
3186 my $meth = 0;
3187 my $nonmeth = 0;
3188
3189 if ($1 eq 'C'){ # C on forward strand
3190 $tri_nt = substr ($chromosomes{$last_chr},($pos-1),3); # positions are 0-based!
3191 $strand = '+';
3192 }
3193 elsif ($1 eq 'G'){ # C on reverse strand
3194 $tri_nt = substr ($chromosomes{$last_chr},($pos-3),3); # positions are 0-based!
3195 $tri_nt = reverse $tri_nt;
3196 $tri_nt =~ tr/ACTG/TGAC/;
3197 $strand = '-';
3198 }
3199
3200 if (exists $chr{$last_chr}->{($pos-1)}){ # stored positions are 0-based!
3201 $meth = $chr{$last_chr}->{$pos-1}->{meth};
3202 $nonmeth = $chr{$last_chr}->{$pos-1}->{nonmeth};
3203 }
3204
3205 next if (length$tri_nt < 3); # trinucleotide sequence could not be extracted
3206
3207 ### determining cytosine context
3208 if ($tri_nt =~ /^CG/){
3209 $context = 'CG';
3210 }
3211 elsif ($tri_nt =~ /^C.{1}G$/){
3212 $context = 'CHG';
3213 }
3214 elsif ($tri_nt =~ /^C.{2}$/){
3215 $context = 'CHH';
3216 }
3217 else{ # if the context can't be determined the positions will not be printed (it will equally not have been reported by Bismark)
3218 warn "The cytosine context could not be determined (found: '$tri_nt'). Skipping.\n";
3219 next;
3220 }
3221
3222 if ($CpG_only){
3223 if ($tri_nt =~ /^CG/){ # CpG context is the default
3224 if ($zero){ # zero-based coordinates
3225 $pos -= 1;
3226 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3227 }
3228 else{ # default
3229 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3230 }
3231 }
3232 }
3233 else{ ## all cytosines, specified with --CX
3234 if ($zero){ # zero based coordinates
3235 $pos -= 1;
3236 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3237 }
3238 else{ # default
3239 print CYT join ("\t",$last_chr,$pos,$strand,$meth,$nonmeth,$context,$tri_nt),"\n";
3240 }
3241 }
3242 }
3243 close CYT or die $!;
3244 }
3245
3246
3247 sub read_genome_into_memory{
3248
3249 ## reading in and storing the specified genome in the %chromosomes hash
3250 chdir ($genome_folder) or die "Can't move to $genome_folder: $!";
3251 warn "Now reading in and storing sequence information of the genome specified in: $genome_folder\n\n";
3252
3253 my @chromosome_filenames = <*.fa>;
3254
3255 ### if there aren't any genomic files with the extension .fa we will look for files with the extension .fasta
3256 unless (@chromosome_filenames){
3257 @chromosome_filenames = <*.fasta>;
3258 }
3259 unless (@chromosome_filenames){
3260 die "The specified genome folder $genome_folder does not contain any sequence files in FastA format (with .fa or .fasta file extensions)\n";
3261 }
3262
3263 foreach my $chromosome_filename (@chromosome_filenames){
3264
3265 # skipping the tophat entire mouse genome fasta file
3266 next if ($chromosome_filename eq 'Mus_musculus.NCBIM37.fa');
3267
3268 open (CHR_IN,$chromosome_filename) or die "Failed to read from sequence file $chromosome_filename $!\n";
3269 ### first line needs to be a fastA header
3270 my $first_line = <CHR_IN>;
3271 chomp $first_line;
3272 $first_line =~ s/\r//; # removing /r carriage returns
3273
3274 ### Extracting chromosome name from the FastA header
3275 my $chromosome_name = extract_chromosome_name($first_line);
3276
3277 my $sequence;
3278 while (<CHR_IN>){
3279 chomp;
3280 $_ =~ s/\r//; # removing /r carriage returns
3281
3282 if ($_ =~ /^>/){
3283 ### storing the previous chromosome in the %chromosomes hash, only relevant for Multi-Fasta-Files (MFA)
3284 if (exists $chromosomes{$chromosome_name}){
3285 warn "chr $chromosome_name (",length $sequence ," bp)\n";
3286 die "Exiting because chromosome name already exists. Please make sure all chromosomes have a unique name!\n";
3287 }
3288 else {
3289 if (length($sequence) == 0){
3290 warn "Chromosome $chromosome_name in the multi-fasta file $chromosome_filename did not contain any sequence information!\n";
3291 }
3292 warn "chr $chromosome_name (",length $sequence ," bp)\n";
3293 $chromosomes{$chromosome_name} = $sequence;
3294 }
3295 ### resetting the sequence variable
3296 $sequence = '';
3297 ### setting new chromosome name
3298 $chromosome_name = extract_chromosome_name($_);
3299 }
3300 else{
3301 $sequence .= uc$_;
3302 }
3303 }
3304
3305 if (exists $chromosomes{$chromosome_name}){
3306 warn "chr $chromosome_name (",length $sequence ," bp)\t";
3307 die "Exiting because chromosome name already exists. Please make sure all chromosomes have a unique name.\n";
3308 }
3309 else{
3310 if (length($sequence) == 0){
3311 warn "Chromosome $chromosome_name in the file $chromosome_filename did not contain any sequence information!\n";
3312 }
3313 warn "chr $chromosome_name (",length $sequence ," bp)\n";
3314 $chromosomes{$chromosome_name} = $sequence;
3315 }
3316 }
3317 warn "\n";
3318 chdir $parent_dir or die "Failed to move to directory $parent_dir\n";
3319 }
3320
3321 sub extract_chromosome_name {
3322 ## Bowtie extracts the first string after the inition > in the FASTA file, so we are doing this as well
3323 my $fasta_header = shift;
3324 if ($fasta_header =~ s/^>//){
3325 my ($chromosome_name) = split (/\s+/,$fasta_header);
3326 return $chromosome_name;
3327 }
3328 else{
3329 die "The specified chromosome ($fasta_header) file doesn't seem to be in FASTA format as required!\n";
3330 }
3331 }
3332
3333 #######################################################################################################################################
3334 ### genome-wide cytosine methylation report - END
3335 #######################################################################################################################################
3336
3337
3338
3339
3340 sub print_helpfile{
3341
3342 print << 'HOW_TO';
3343
3344
3345 DESCRIPTION
3346
3347 The following is a brief description of all options to control the Bismark
3348 methylation extractor. The script reads in a bisulfite read alignment results file
3349 produced by the Bismark bisulfite mapper and extracts the methylation information
3350 for individual cytosines. This information is found in the methylation call field
3351 which can contain the following characters:
3352
3353 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3354 ~~~ X for methylated C in CHG context (was protected) ~~~
3355 ~~~ x for not methylated C CHG (was converted) ~~~
3356 ~~~ H for methylated C in CHH context (was protected) ~~~
3357 ~~~ h for not methylated C in CHH context (was converted) ~~~
3358 ~~~ Z for methylated C in CpG context (was protected) ~~~
3359 ~~~ z for not methylated C in CpG context (was converted) ~~~
3360 ~~~ . for any bases not involving cytosines ~~~
3361 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
3362
3363 The methylation extractor outputs result files for cytosines in CpG, CHG and CHH
3364 context (this distinction is actually already made in Bismark itself). As the methylation
3365 information for every C analysed can produce files which easily have tens or even hundreds of
3366 millions of lines, file sizes can become very large and more difficult to handle. The C
3367 methylation info additionally splits cytosine methylation calls up into one of the four possible
3368 strands a given bisulfite read aligned against:
3369
3370 OT original top strand
3371 CTOT complementary to original top strand
3372
3373 OB original bottom strand
3374 CTOB complementary to original bottom strand
3375
3376 Thus, by default twelve individual output files are being generated per input file (unless
3377 --comprehensive is specified, see below). The output files can be imported into a genome
3378 viewer, such as SeqMonk, and re-combined into a single data group if desired (in fact
3379 unless the bisulfite reads were generated preserving directionality it doesn't make any
3380 sense to look at the data in a strand-specific manner). Strand-specific output files can
3381 optionally be skipped, in which case only three output files for CpG, CHG or CHH context
3382 will be generated. For both the strand-specific and comprehensive outputs there is also
3383 the option to merge both non-CpG contexts (CHG and CHH) into one single non-CpG context.
3384
3385
3386 The output files are in the following format (tab delimited):
3387
3388 <sequence_id> <strand> <chromosome> <position> <methylation call>
3389
3390
3391 USAGE: methylation_extractor [options] <filenames>
3392
3393
3394 ARGUMENTS:
3395
3396 <filenames> A space-separated list of Bismark result files in SAM format from
3397 which methylation information is extracted for every cytosine in
3398 the reads. For alignment files in the older custom Bismark output
3399 see option '--vanilla'.
3400
3401 OPTIONS:
3402
3403 -s/--single-end Input file(s) are Bismark result file(s) generated from single-end
3404 read data. Specifying either --single-end or --paired-end is
3405 mandatory.
3406
3407 -p/--paired-end Input file(s) are Bismark result file(s) generated from paired-end
3408 read data. Specifying either --paired-end or --single-end is
3409 mandatory.
3410
3411 --vanilla The Bismark result input file(s) are in the old custom Bismark format
3412 (up to version 0.5.x) and not in SAM format which is the default as
3413 of Bismark version 0.6.x or higher. Default: OFF.
3414
3415 --no_overlap For paired-end reads it is theoretically possible that read_1 and
3416 read_2 overlap. This option avoids scoring overlapping methylation
3417 calls twice (only methylation calls of read 1 are used for in the process
3418 since read 1 has historically higher quality basecalls than read 2).
3419 Whilst this option removes a bias towards more methylation calls
3420 in the center of sequenced fragments it may de facto remove a sizable
3421 proportion of the data. This option is highly recommended for paired-end
3422 data.
3423
3424 --ignore <int> Ignore the first <int> bp at the 5' end of each read when processing the
3425 methylation call string. This can remove e.g. a restriction enzyme site
3426 at the start of each read.
3427
3428 --comprehensive Specifying this option will merge all four possible strand-specific
3429 methylation info into context-dependent output files. The default
3430 contexts are:
3431 - CpG context
3432 - CHG context
3433 - CHH context
3434
3435 --merge_non_CpG This will produce two output files (in --comprehensive mode) or eight
3436 strand-specific output files (default) for Cs in
3437 - CpG context
3438 - non-CpG context
3439
3440 --report Prints out a short methylation summary as well as the paramaters used to run
3441 this script.
3442
3443 --no_header Suppresses the Bismark version header line in all output files for more convenient
3444 batch processing.
3445
3446 -o/--output DIR Allows specification of a different output directory (absolute or relative
3447 path). If not specified explicitely, the output will be written to the current directory.
3448
3449 --version Displays version information.
3450
3451 -h/--help Displays this help file and exits.
3452
3453
3454
3455 bedGraph specific options:
3456
3457 --bedGraph After finishing the methylation extraction, the methylation output is written into a
3458 sorted bedGraph file that reports the position of a given cytosine and its methylation
3459 state (in %, seem details below). The methylation extractor output is temporarily split up into
3460 temporary files, one per chromosome (written into the current directory or folder
3461 specified with -o/--output); these temp files are then used for sorting and deleted
3462 afterwards. By default, only cytosines in CpG context will be sorted. The option
3463 '--CX_context' may be used to report all cyosines irrespective of sequence context
3464 (this will take MUCH longer!).
3465
3466
3467 --cutoff [threshold] The minimum number of times a methylation state has to be seen for that nucleotide
3468 before its methylation percentage is reported. Default: 1.
3469
3470 --remove_spaces Replaces whitespaces in the sequence ID field with underscores to allow sorting.
3471
3472
3473 --counts Adds two additional columns to the output file to enable further calculations:
3474 col 5: number of methylated calls
3475 col 6: number of unmethylated calls
3476 This option is required if '--cytosine_report' is specified (and will be set automatically if
3477 necessary).
3478
3479 --CX/--CX_context The sorted bedGraph output file contains information on every single cytosine that was covered
3480 in the experiment irrespective of its sequence context. This applies to both forward and
3481 reverse strands. Please be aware that this option may generate large temporary and output files
3482 and may take a long time to sort (up to many hours). Default: OFF.
3483 (i.e. Default = CpG context only).
3484
3485
3486
3487 Genome-wide cytosine methylation report specific options:
3488
3489 --cytosine_report After the conversion to bedGraph has completed, the option '--cytosine_report' produces a
3490 genome-wide methylation report for all cytosines in the genome. By default, the output uses 1-based
3491 chromosome coordinates (zero-based cords are optional) and reports CpG context only (all
3492 cytosine context is optional). The output considers all Cs on both forward and reverse strands and
3493 reports their position, strand, trinucleotide content and methylation state (counts are 0 if not
3494 covered).
3495
3496 --CX/--CX_context The output file contains information on every single cytosine in the genome irrespective of
3497 its context. This applies to both forward and reverse strands. Please be aware that this will
3498 generate output files with > 1.1 billion lines for a mammalian genome such as human or mouse.
3499 Default: OFF (i.e. Default = CpG context only).
3500
3501 --zero_based Uses zero-based coordinates like used in e.g. bed files instead of 1-based coordinates. Default: OFF.
3502
3503 --genome_folder <path> Enter the genome folder you wish to use to extract sequences from (full path only). Accepted
3504 formats are FastA files ending with '.fa' or '.fasta'. Specifying a genome folder path is mandatory.
3505
3506 --split_by_chromosome Writes the output into individual files for each chromosome instead of a single output file. Files
3507 will be named to include the input filename and the chromosome number.
3508
3509
3510
3511 OUTPUT:
3512
3513 The bismark_methylation_extractor output is in the form:
3514 ========================================================
3515 <seq-ID> <methylation state*> <chromosome> <start position (= end position)> <methylation call>
3516
3517 * Methylated cytosines receive a '+' orientation,
3518 * Unmethylated cytosines receive a '-' orientation.
3519
3520
3521
3522 The bedGraph output (optional) looks like this (tab-delimited):
3523 ===============================================================
3524 <chromosome> <start position> <end position> <methylation percentage>
3525
3526
3527
3528 The genome-wide cytosine methylation output file is tab-delimited in the following format:
3529 ==========================================================================================
3530 <chromosome> <position> <strand> <count methylated> <count non-methylated> <C-context> <trinucleotide context>
3531
3532
3533
3534 This script was last modified on 02 Oct 2012.
3535
3536 HOW_TO
3537 }