blib/lib/Bio/Graphics/Wiggle.pm untested

filter: Statementstmt 0.0% 0 / 453 Branchbran 0.0% 0 / 140 Conditioncond 0.0% 0 / 130 MC/DCmcdc n/a Subroutinesub 0.0% 0 / 65 Podpod 0.0% 0 / 55 totaltotal 0.0% 0 / 843 CC 71 SCAR 29.6
CC
71
Cov
0%
_retrieve_values
90.0
value
56.0
scale
42.0
CRAP 19.3
1 package Bio::Graphics::Wiggle;
2  
3 =head1 NAME
4  
5 Bio::Graphics::Wiggle -- Binary storage for dense genomic features
6  
7 =head1 SYNOPSIS
8  
9 # all positions are 1-based
10  
11 my $wig = Bio::Graphics::Wiggle->new('./test.wig',
12 $writeable,
13 { seqid => $seqid,
14 start => $start,
15 step => $step,
16 min => $min,
17 max => $max });
18  
19 $wig->erase;
20  
21 my $seqid = $wig->seqid('new_id');
22 my $max = $wig->max($new_max);
23 my $min = $wig->min($new_min);
24 my $step = $wig->step($new_step); # data stored at modulus step == 0; all else is blank
25  
26 $wig->set_value($position => $value); # store $value at position
27 $wig->set_values($position => \@values); # store array of values at position
28 $wig->set_range($start=>$end,$value); # store the same $value from $start to $end
29  
30 my $value = $wig->value($position); # fetch value from position
31 my $values = $wig->values($start,$end); # fetch range of data from $start to $end
32  
33 $wig->window(100); # sample window size
34 $wig->smoothing('mean'); # when sampling, compute the mean value across sample window
35 my $values = $wig->values($start,$end,$samples); # fetch $samples data points from $start to $end
36  
37  
38 =head1 DESCRIPTION
39  
40 IMPORTANT NOTE: This implementation is still not right. See
41 http://genomewiki.ucsc.edu/index.php/Wiggle for a more space-efficient
42 implementation.
43  
44 This module stores "wiggle" style quantitative genome data for display
45 in a genome browser application. The data for each chromosome (or
46 contig, or other reference sequence) is stored in a single file in the
47 following format:
48  
49 256 byte header
50 50 bytes seqid, zero-terminated C string
51 4 byte long integer, value of "step" (explained later)
52 4 byte perl native float, the "min" value
53 4 byte perl native float, the "max" value
54 4 byte long integer, value of "span"
55 4 byte perl native float, the mean
56 4 byte perl native float, the standard deviation
57 2 byte unsigned short, the version number (currently version 0)
58 4 byte long integer, sequence start position (in 0-based coordinates)
59 null padding to 256 bytes for future use
60  
61 The remainder of the file consists of 8-bit unsigned scaled integer
62 values. This means that all quantitative data will be scaled to 8-bit
63 precision!
64  
65 For a convenient method of creating Wiggle files from UCSC-type WIG
66 input and creating GFF3 output, please see
67 L<Bio::Graphics::Wiggle::Loader>.
68  
69 =head1 METHODS
70  
71 =head2 Constructor and Accessors
72  
73 =over 4
74  
75 =item $wig = Bio::Graphics::Wiggle->new($filename,$writeable,{options})
76  
77 Open/create a wiggle-format data file:
78  
79 $filename -- path to the file to open/create
80 $writeable -- boolean value indicating whether file is
81 writeable. Missing files will only be created
82 if $writeable set to a true value. If path is
83 empty (undef or empty string) and writeable is true,
84 new() will create a temporary file that will be
85 deleted when the object goes out of scope.
86 {options} -- hash ref of the following named options, only valid
87 when creating a new wig file with $writeable true.
88  
89 option name description default
90 ----------- ----- -------
91 seqid name/id of sequence empty name
92 min minimum value of data points 0
93 max maximum value of data points 255
94 step interval between data points 1
95 span width of data points value of "step"
96  
97 The "step" can be used to create sparse files to save space. By
98 default, step is set to 1, in which case a data value will be stored
99 at each base of the sequence. By setting step to 10, then each value
100 is taken to correspond to 10 bp, and the file will be 10x smaller.
101 For example, consider this step 5 data set:
102  
103 1 2 3 4 5 6 7 8 9 10 11 12 13 14
104 20 . . . . 60 . . . . 80 . . .
105  
106 We have stored the values "20" "60" and "80" at positions 1, 6 and 11,
107 respectively. When retrieving this data, it will appear as if
108 positions 1 through 5 have a value of 20, positions 6-10 have a value
109 of 60, and positions 11-14 have a value of 80. In the data file, we
110 store, positions 1,6,and 11 in adjacent bytes.
111  
112 Note that no locking is performed by this module. If you wish to allow
113 multi-user write access to the databases files, you will need to
114 flock() the files yourself.
115  
116 =item $seqid = $wig->seqid(['new_id'])
117  
118 =item $max = $wig->max([$new_max])
119  
120 =item $min = $wig->min([$new_min])
121  
122 =item $step = $wig->step([$new_step])
123  
124 =item $span = $wig->span([$new_span])
125  
126 =item $mean = $wig->mean([$new_mean]);
127  
128 =item $stdev = $wig->stdev([$new_stdev]);
129  
130 These accessors get or set the corresponding values. Setting is only
131 allowed if the file was opened for writing. Note that changing the
132 min, max and step after writing data to the file under another
133 parameter set will produce unexpected (and invalid) results, as the
134 existing data is not automatically updated to be consistent.
135  
136 =item $trim = $wig->trim([$new_trim]);
137  
138 The trim method sets the trimming method, which can be used to trim
139 out extreme values. Three methods are currently supported:
140  
141 none No trimming
142 stdev Trim 1 standard deviation above and below mean
143 stdevN Trim N standard deviations above and below the mean
144  
145 In "stdevN", any can be any positive integer.
146  
147 =back
148  
149 =head2 Setting Data
150  
151 =over 4
152  
153 =item $wig->set_value($position => $value)
154  
155 This method sets the value at $position to $value. If a step>1 is in
156 force, then $position will be rounded down to the nearest multiple of
157 step.
158  
159 =item $wig->set_range($start=>$end, $value)
160  
161 This method sets the value of all bases between $start and $end to
162 $value, honoring step.
163  
164 =item $sig->set_values($position => \@values)
165  
166 This method writes an array of values into the datababase beginning at
167 $position (or the nearest lower multiple of step). If step>1, then
168 values will be written at step intervals.
169  
170 =back
171  
172 =head2 Retrieving Data
173  
174 =over 4
175  
176 =item $value = $wig->value($position)
177  
178 Retrieve the single data item at position $position, or the nearest
179 lower multiple of $step if step>1.
180  
181 =item $values = $wig->values($start=>$end)
182  
183 Retrieve the values in the range $start to $end and return them as an
184 array ref. Note that you will always get an array of size
185 ($end-$start+1) even if step>1; the data in between the step intervals
186 will be filled in.
187  
188 =item $values = $wig->values($start=>$end,$samples)
189  
190 Retrieve a sampling of the values between $start and $end. Nothing
191 very sophisticated is done here; the code simply returns the number of
192 values indicated in $samples, smoothed according to the smoothing
193 method selected (default to "mean"), then selected at even intervals
194 from the range $start to $end. The return value is an arrayref of
195 exactly $samples values.
196  
197 =item $string = $wig->export_to_wif($start,$end)
198  
199 =item $string = $wig->export_to_wif64($start,$end)
200  
201 Export the region from start to end in the "wif" format. This data can
202 later be imported into another Bio::Graphics::Wiggle object. The first
203 version returns a binary string. The second version returns a base64
204 encoded version that is safe for ascii-oriented formata such as GFF3
205 and XML.
206  
207 =item $wig->import_from_wif($string)
208  
209 =item $wig->import_from_wif64($string)
210  
211 Import a wif format data string into the Bio::Graphics::Wiggle
212 object. The first version expects a binary string. The second version
213 expects a base64 encoded version that is safe for ascii-oriented
214 formata such as GFF3 and XML.
215  
216 =back
217  
218  
219 =cut
220  
221 # read/write genome tiling data, to be compatible with Jim Kent's WIG format
222 use strict;
223 use warnings;
224 use IO::File;
225 use Carp 'croak','carp','confess';
226  
227 use constant HEADER_LEN => 256;
228 # seqid, step, min, max, span, mean, stdev, version, start
229 use constant HEADER => '(Z50LFFLFFSL)@'.HEADER_LEN;
230 use constant BODY => 'C';
231 use constant DEBUG => 0;
232 use constant DEFAULT_SMOOTHING => 'mean';
233 use constant VERSION => 0;
234 our $VERSION = '1.0';
235  
236 sub new {
237 my $class = shift;
238 my ($path,$write,$options) = @_;
239 $path ||= ''; # to avoid uninit warning
240 my $mode = $write ? -e $path # if file already exists...
241 ? '+<' # ...open for read/write
242 : '+>' # ...else clobber and open a new one
243 : '<'; # read only
244 my $fh = $class->new_fh($path,$mode);
245 $fh or die (($path||'temporary file').": $!");
246  
247 $options ||= {};
248  
249 my $self = bless {fh => $fh,
250 write => $write,
251 dirty => scalar keys %$options
252 }, ref $class || $class;
253  
254 my $stored_options = eval {$self->_readoptions} || {};
255 $options->{start}-- if defined $options->{start}; # 1-based ==> 0-based coordinates
256 my %merged_options = (%$stored_options,%$options);
257 # warn "merged options = ",join ' ',%merged_options;
258 $merged_options{version}||= 0;
259 $merged_options{seqid} ||= 'chrUnknown';
260 $merged_options{min} ||= 0;
261 $merged_options{max} ||= 255;
262 $merged_options{mean} ||= 128;
263 $merged_options{stdev} ||= 255;
264 $merged_options{trim} ||= 'none';
265 $merged_options{step} ||= 1;
266 $merged_options{start} ||= 0;
267 $merged_options{span} ||= $merged_options{step};
268 $self->{options} = \%merged_options;
269 $self->_do_trim unless $self->trim eq 'none';
270 return $self;
271 }
272  
273 sub new_fh {
274 my $self = shift;
275 my ($path,$mode) = @_;
276 return $path ? IO::File->new($path,$mode)
277 : IO::File->new_tmpfile;
278 }
279  
280 sub end {
281 my $self = shift;
282 unless (defined $self->{end}) {
283 my $size = (stat($self->fh))[7];
284 my $data_len = $size - HEADER_LEN();
285 return unless $data_len>0; # undef end
286 $self->{end} = ($self->start-1) + $data_len * $self->step;
287 }
288 return $self->{end};
289 }
290  
291 sub DESTROY { shift->write }
292  
293 sub erase {
294 my $self = shift;
295 $self->fh->truncate(HEADER_LEN);
296 }
297  
298 sub fh { shift->{fh} }
299 sub seek { shift->fh->seek(shift,0) }
300 sub tell { shift->fh->tell() }
301  
302 sub _option {
303 my $self = shift;
304 my $option = shift;
305 my $d = $self->{options}{$option};
306 if (@_) {
307 $self->{dirty}++;
308 $self->{options}{$option} = shift;
309 delete $self->{scale} if $option eq 'min' or $option eq 'max';
310 }
311 return $d;
312 }
313  
314 sub version { shift->_option('version',@_) }
315 sub seqid { shift->_option('seqid',@_) }
316 sub min { shift->_option('min',@_) }
317 sub max { shift->_option('max',@_) }
318 sub step { shift->_option('step',@_) }
319 sub span { shift->_option('span',@_) }
320 sub mean { shift->_option('mean',@_) }
321 sub stdev { shift->_option('stdev',@_) }
322 sub trim { shift->_option('trim',@_) }
323  
324 sub start { # slightly different because we have to deal with 1 vs 0-based coordinates
325 my $self = shift;
326 my $start = $self->_option('start');
327 $start++; # convert into 1-based coordinates
328 if (@_) {
329 my $newstart = shift;
330 $self->_option('start',$newstart-1); # store in zero-based coordinates
331 }
332 return $start;
333 }
334  
335 sub smoothing {
336 my $self = shift;
337 my $d = $self->{smoothing} || DEFAULT_SMOOTHING;
338 $self->{smoothing} = shift if @_;
339 $d;
340 }
341  
342 sub write {
343 my $self = shift;
344 if ($self->{dirty} && $self->{write}) {
345 $self->_writeoptions($self->{options});
346 undef $self->{dirty};
347 $self->fh->flush;
348 }
349 }
350  
351 sub _readoptions {
352 my $self = shift;
353 my $fh = $self->fh;
354 my $header;
355 $fh->seek(0,0);
356 return unless $fh->read($header,HEADER_LEN) == HEADER_LEN;
357 return $self->_parse_header($header);
358 }
359  
360 sub _parse_header {
361 my $self = shift;
362 my $header = shift;
363 my ($seqid,$step,$min,$max,$span,
364 $mean,$stdev,$version,$start) = unpack(HEADER,$header);
365 return { seqid => $seqid,
366 step => $step,
367 span => $span,
368 min => $min,
369 max => $max,
370 mean => $mean,
371 stdev => $stdev,
372 version => $version,
373 start => $start,
374 };
375 }
376  
377 sub _generate_header {
378 my $self = shift;
379 my $options = shift;
380 return pack(HEADER,@{$options}{qw(seqid step min max span mean stdev version start)});
381 }
382  
383 sub _writeoptions {
384 my $self = shift;
385 my $options = shift;
386 my $fh = $self->fh;
387 my $header = $self->_generate_header($options);
388 $fh->seek(0,0);
389 $fh->print($header) or die "write failed: $!";
390 }
391  
392 sub _do_trim {
393 my $self = shift;
394  
395 # don't trim if there is no score range
396 ($self->max - $self->min) or return;
397
398 my $trim = lc $self->trim;
399 my ($method,$arg);
400 if ($trim =~ /([a-z]+)(\d+)/) {
401 $method = "_trim_${1}";
402 $arg = $2;
403 }
404 else {
405 $method = "_trim_${trim}";
406 }
407 unless ($self->can($method)) {
408 carp "invalid trim method $trim";
409 return;
410 }
411
412 $self->$method($arg);
413 }
414  
415 # trim n standard deviations from the mean
416 sub _trim_stdev {
417 my $self = shift;
418 my $factor = shift || 1;
419 my $mean = $self->mean;
420 my $stdev = $self->stdev * $factor;
421 my $min = $self->min > $mean - $stdev ? $self->min : $mean - $stdev;
422 my $max = $self->max < $mean + $stdev ? $self->max : $mean + $stdev;
423 warn "_trim_stdev (* $factor) : setting min to $min, max to $max (was ",$self->min,',',$self->max,')'
424 if DEBUG;
425 $self->min($min);
426 $self->max($max);
427 }
428  
429 sub set_value {
430 my $self = shift;
431 croak "usage: \$wig->set_value(\$position => \$value)"
432 unless @_ == 2;
433 $self->value(@_);
434 }
435  
436 sub set_range {
437 my $self = shift;
438 croak "usage: \$wig->set_range(\$start_position => \$end_position, \$value)"
439 unless @_ == 3;
440 $self->value(@_);
441 }
442  
443 sub value {
444 my $self = shift;
445 my $position = shift;
446  
447 my $offset = $self->_calculate_offset($position);
448 $offset >= HEADER_LEN or die "Tried to retrieve data from before start position";
449 $self->seek($offset) or die "Seek failed: $!";
450  
451 if (@_ == 2) {
452 my $end = shift;
453 my $new_value = shift;
454 my $step = $self->step;
455 my $scaled_value = $self->scale($new_value);
456 $self->fh->print(pack('C*',($scaled_value)x(($end-$position+1)/$step))) or die "Write failed: $!";
457 $self->{end} = $end if !exists $self->{end} || $self->{end} < $end;
458 }
459  
460 elsif (@_==1) {
461 my $new_value = shift;
462 my $scaled_value = $self->scale($new_value);
463 $self->fh->print(pack('C*',$scaled_value)) or die "Write failed: $!";
464 $self->{end} = $position if !exists $self->{end} || $self->{end} < $position;
465 return $new_value;
466 }
467  
468 else { # retrieving data
469 my $buffer;
470 $self->fh->read($buffer,1) or die "Read failed: $!";
471 my $scaled_value = unpack('C*',$buffer);
472  
473 # missing data, so look back at most span values to get it
474 if ($scaled_value == 0 && (my $span = $self->span) > 1) {
475 $offset = $self->_calculate_offset($position-$span+1);
476 $offset >= HEADER_LEN or die "Tried to retrieve data from before start position";
477 $self->seek($offset) or die "Seek failed: $!";
478  
479 $self->fh->read($buffer,$span/$self->step);
480 for (my $i=length($buffer)-2;$i>=0;$i--) {
481 my $val = substr($buffer,$i,1);
482 next if $val eq "\0";
483 $scaled_value = unpack('C*',$val);
484 last;
485 }
486  
487 }
488 return $self->unscale($scaled_value);
489 }
490 }
491  
492 sub _calculate_offset {
493 my $self = shift;
494 my $position = shift;
495 my $step = $self->step;
496 my $start = $self->start;
497 return HEADER_LEN + int(($position-$start)/$step);
498 }
499  
500 sub set_values {
501 my $self = shift;
502 croak "usage: \$wig->set_values(\$position => \@values)"
503 unless @_ == 2 and ref $_[1] eq 'ARRAY';
504 $self->values(@_);
505 }
506  
507 # read or write a series of values
508 sub values {
509 my $self = shift;
510 my $start = shift;
511 if (ref $_[0] && ref $_[0] eq 'ARRAY') {
512 $self->_store_values($start,@_);
513 } else {
514 $self->_retrieve_values($start,@_);
515 }
516 }
517  
518 sub export_to_wif64 {
519 my $self = shift;
520 my $data = $self->export_to_wif(@_);
521 eval "require MIME::Base64"
522 unless MIME::Base64->can('encode_base64');
523 return MIME::Base64::encode_base64($data);
524 }
525 sub import_from_wif64 {
526 my $self = shift;
527 my $data = shift;
528  
529 eval "require MIME::Base64"
530 unless MIME::Base64->can('decode_base64');
531 return $self->import_from_wif(MIME::Base64::decode_base64($data));
532 }
533  
534 # subregion in "wiggle interchange format" (wif)
535 sub export_to_wif {
536 my $self = shift;
537 my ($start,$end) = @_;
538  
539 # get the 256 byte header
540 my $data = $self->_generate_header($self->{options});
541  
542 # add the range to the data (8 bytes overhead)
543 $data .= pack("L",$start);
544 $data .= pack("L",$end);
545  
546 # add the packed data for this range
547 $data .= $self->_retrieve_packed_range($start,$end-$start+1,$self->step);
548 return $data;
549 }
550  
551 sub export_to_bedgraph {
552 my $self = shift;
553 my ($start,$end,$fh) = @_;
554 my $max_range = 100_000;
555  
556 $start ||= 1;
557 $end ||= $self->end;
558  
559 my $lines;
560 for (my $s=$start;$s<$end;$s+=$max_range) {
561 my $e = $s + $max_range - 1;
562 $e = $end if $e > $end;
563 my $b = $self->values($s,$e);
564 $lines .= $self->_bedgraph_lines($s,$b,$fh);
565 }
566  
567 return $lines;
568 }
569  
570 sub _bedgraph_lines {
571 my $self = shift;
572 my ($start,$values,$fh) = @_;
573 my $seqid = $self->seqid;
574 my $result;
575  
576 my ($last_val,$last_start,$end);
577 $last_start = $start-1; # 0 based indexing
578 for (my $i=0;$i<@$values;$i++) {
579 my $v = $values->[$i];
580  
581 if (!defined $v) {
582 if (defined $last_val) {
583 $result .= $self->_append_or_print_bedgraph($fh,$seqid,$last_start,$start+$i-1,$last_val);
584 undef $last_val;
585 }
586 $last_start = $start+$i;
587 next;
588 }
589  
590 if (defined $last_val && $last_val != $v) {
591 $result .= $self->_append_or_print_bedgraph($fh,$seqid,$last_start,$start+$i-1,$last_val);
592 $last_start = $start+$i-1;
593 }
594  
595 $last_val = $v;
596 $end = $start+$i-1;
597 }
598 $result .= $self->_append_or_print_bedgraph($fh,$seqid,$last_start,$end+1,$last_val) if $last_val;
599 return $result;
600 }
601  
602 sub _append_or_print_bedgraph {
603 my $self = shift;
604 my ($fh,$seqid,$start,$end,$val) = @_;
605 my $data = join("\t",$seqid,$start,$end,sprintf("%.2f",$val))."\n";
606 if ($fh) {
607 print $fh $data;
608 return '';
609 } else {
610 return $data;
611 }
612 }
613  
614 sub import_from_wif {
615 my $self = shift;
616 my $wifdata = shift;
617  
618 # BUG: should check that header is compatible
619 my $header = substr($wifdata,0,HEADER_LEN);
620 my $start = unpack('L',substr($wifdata,HEADER_LEN, 4));
621 my $end = unpack('L',substr($wifdata,HEADER_LEN+4,4));
622  
623 my $options = $self->_parse_header($header);
624 my $stored_options = eval {$self->_readoptions} || {};
625 my %merged_options = (%$stored_options,%$options);
626 $self->{options} = \%merged_options;
627 $self->{dirty}++;
628  
629 # write the data
630 $self->seek($self->_calculate_offset($start));
631 $self->fh->print(substr($wifdata,HEADER_LEN+8)) or die "write failed: $!";
632 $self->{end} = $end if !defined $self->{end} or $self->{end} < $end;
633 }
634  
635 sub _retrieve_values {
636 my $self = shift;
637 my ($start,$end,$samples) = @_;
638  
639 my $data_start = $self->start;
640 my $step = $self->step;
641 my $span = $self->span;
642  
643 croak "Value of start position ($start) is less than data start of $data_start"
644 unless $start >= $data_start;
645 croak "Value of end position ($end) is greater than data end of ",$self->end+$span,
646 unless $end <= $self->end + $span;
647  
648 # generate list of positions to sample from
649 my $length = $end-$start+1;
650 $samples ||= $length;
651  
652 # warn "samples = $samples, length=$length, span=$span, step=$step";
653  
654 # if the length is grossly greater than the samples, then we won't even
655 # bother fetching all the data, but just sample into the disk file
656 if ($length/$samples > 100 && $step == 1) {
657 my @result;
658 # my $window = 20*($span/$step);
659 my $interval = $length/$samples;
660 # my $window = 100*$interval/$span;
661 my $window = $interval/2;
662 # warn "window = $window, interval = $interval";
663 for (my $i=0;$i<$samples;$i++) {
664 my $packed_data = $self->_retrieve_packed_range(int($start+$i*$interval-$window),
665 int($window),
666 $step);
667 my @bases= grep {$_} unpack('C*',$packed_data);
668 if (@bases) {
669 local $^W = 0;
670 my $arry = $self->unscale(\@bases);
671 my $n = @$arry;
672 my $total = 0;
673 $total += $_ foreach @$arry;
674 my $mean = $total/$n;
675 my $max;
676 for (@$arry) { $max = $_ if !defined $max || $max < $_ }
677 # warn $start+$i*$interval,': ',join(',',map {int($_)} @$arry),
678 # " mean = $mean, max = $max";
679 # push @result,$mean;
680 push @result,$max;
681 } else {
682 push @result,0;
683 }
684 }
685 return \@result;
686 }
687  
688 my $packed_data = $self->_retrieve_packed_range($start,$length,$step);
689  
690 my @bases;
691 $#bases = $length-1;
692  
693 if ($step == $span) {
694 # in this case, we do not have any partially-empty
695 # steps, so can operate on the step-length data structure
696 # directly
697 @bases = unpack('C*',$packed_data);
698 }
699  
700 else {
701 # In this case some regions may have partially missing data,
702 # so we create an array equal to the length of the requested region,
703 # fill it in, and then sample it
704 for (my $i=0; $i<length $packed_data; $i++) {
705 my $index = $i * $step;
706 my $value = unpack('C',substr($packed_data,$i,1));
707 next unless $value; # ignore 0 values
708 @bases[$index..$index+$span-1] = ($value) x $span;
709 }
710 $#bases = $length-1;
711 }
712  
713 my $r = $self->unscale(\@bases);
714 $r = $self->sample($r,$samples);
715 $r = $self->smooth($r,$self->window * $samples/@bases)
716 if defined $self->window && $self->window>1;
717 return $r;
718 }
719  
720 sub _retrieve_packed_range {
721 my $self = shift;
722 my ($start,$length,$step) = @_;
723 my $span = $self->span;
724  
725 my $offset = $self->_calculate_offset($start);
726  
727 $self->seek($offset);
728 my $packed_data;
729 $self->fh->read($packed_data,$length/$step);
730  
731 # pad data up to required amount
732 $packed_data .= "\0" x ($length/$step-length($packed_data))
733 if length $packed_data < $length/$step;
734 return $packed_data;
735 }
736  
737  
738 sub sample {
739 my $self = shift;
740 my ($values,$samples) = @_;
741 my $length = @$values;
742 my $window_size = $length/$samples;
743  
744 my @samples;
745 $#samples = $samples-1;
746  
747 if ($window_size < 2) { # no data smoothing needed
748 @samples = map { $values->[$_*$window_size] } (0..$samples-1);
749 }
750 else {
751 my $smoothsub = $self->smoothsub;
752 for (my $i=0; $i<$samples; $i++) {
753 my $start = $i * $window_size;
754 my $end = $start + $window_size - 1;
755 my @window = @{$values}[$start..$end];
756  
757 my $value = $smoothsub->(\@window);
758 $samples[$i] = $value;
759 }
760 }
761  
762 return \@samples;
763 }
764  
765 sub smoothsub {
766 my $self = shift;
767
768 my $smoothing = $self->smoothing;
769 my $smoothsub = $smoothing eq 'mean' ? \&sample_mean
770 :$smoothing eq 'max' ? \&sample_max
771 :$smoothing eq 'min' ? \&sample_min
772 :$smoothing eq 'none' ? \&sample_center
773 :croak("invalid smoothing type '$smoothing'");
774 return $smoothsub;
775 }
776  
777 sub smooth {
778 my ($self,$data,$window) = @_;
779  
780 my $smoothing = $self->smoothing;
781 $window ||= $self->window;
782  
783 return $data if $smoothing eq 'none' || $window < 2;
784  
785 my @data = @$data;
786 my $smoother = $self->smoothsub;
787 $window++ unless $window % 2;
788 my $offset = int($window/2);
789  
790 for (my $i=$offset; $i<@$data-$offset; $i++) {
791 my $start = $i - $offset;
792 my $end = $i + $offset;
793 my @subset = @data[$start..$end];
794 $data->[$i] = $smoother->(\@subset);
795 }
796  
797 return $data;
798 }
799  
800 sub window {
801 my $self = shift;
802 my $d = $self->{window};
803 $self->{window} = shift if @_;
804 $d;
805 }
806  
807 sub sample_mean {
808 my $values = shift;
809 my ($total,$items);
810 for my $v (@$values) {
811 next unless defined $v;
812 $items++;
813 $total+=$v;
814 }
815 return $items ? $total/$items : undef;
816 }
817  
818 sub sample_max {
819 my $values = shift;
820 my $max;
821 for my $v (@$values) {
822 next unless defined $v;
823 $max = $v if !defined $max or $max < $v;
824 }
825 return $max;
826 }
827  
828 sub sample_min {
829 my $values = shift;
830 my $min;
831 for my $v (@$values) {
832 next unless defined $v;
833 $min = $v if !defined $min or $min > $v;
834 }
835 return $min;
836 }
837  
838 sub sample_center {
839 my $values = shift;
840 return $values->[@$values/2];
841 }
842  
843 sub _store_values {
844 my $self = shift;
845 my ($position,$data) = @_;
846  
847 # where does data start
848 my $offset = $self->_calculate_offset($position);
849 my $fh = $self->fh;
850 my $step = $self->step;
851  
852 my $scaled = $self->scale($data);
853  
854 $self->seek($offset);
855 my $packed_data = pack('C*',@$scaled);
856 $fh->print($packed_data) or die "Write failed: $!";
857  
858 my $new_end = $position+@$data-1;
859 $self->{end} = $new_end if !exists $self->{end} || $self->{end} < $new_end;
860 }
861  
862 # zero means "no data"
863 # everything else is scaled from 1-255
864 sub scale {
865 my $self = shift;
866 my $values = shift;
867 my $scale = $self->_get_scale;
868 my $min = $self->{options}{min};
869 if (ref $values && ref $values eq 'ARRAY') {
870 my @return = map {
871 my $i = ($_ - $min)/$scale;
872 my $v = 1 + int($i+0.5*($i<=>0)); # avoid call to round()
873 $v = 1 if $v < 1;
874 $v = 255 if $v > 255;
875 $v;
876 } @$values;
877 return \@return;
878 } else {
879 my $v = 1 + round (($values - $min)/$scale);
880 $v = 1 if $v < 1;
881 $v = 255 if $v > 255;
882 return $v;
883 }
884 }
885  
886 sub unscale {
887 my $self = shift;
888 my $values = shift;
889 my $scale = $self->_get_scale;
890 my $min = $self->{options}{min};
891  
892 if (ref $values && ref $values eq 'ARRAY') {
893 my @return = map {$_ ? (($_-1) * $scale + $min) : undef} @$values;
894 return \@return;
895 } else {
896 return $values ? ($values-1) * $scale + $min : undef;
897 }
898 }
899  
900 sub _get_scale {
901 my $self = shift;
902 unless ($self->{scale}) {
903 my $min = $self->{options}{min};
904 my $max = $self->{options}{max};
905 my $range = $max - $min || 0.001; # can't be zero!
906 $self->{scale} = $range/254;
907 }
908 return $self->{scale};
909 }
910  
911 sub round {
912 return int($_[0]+0.5*($_[0]<=>0));
913 }
914  
915  
916 1;
917  
918 __END__