Class: Bio::Ucsc::BigWig

Inherits:
Object
  • Object
show all
Defined in:
lib/bio/ucsc/big_wig.rb

Overview

The BigWig class interacts with bigWig files

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(f = nil, opts = {}) ⇒ BigWig

Returns a new BigWig.



26
27
28
29
 
# File 'lib/bio/ucsc/big_wig.rb', line 26

def initialize(f=nil, opts={})
  @filename = f
  return self
end

Instance Attribute Details

#bbi_file ⇒ Object

pointer to bbiFile



20
21
22
 
# File 'lib/bio/ucsc/big_wig.rb', line 20

def bbi_file
  @bbi_file
end

#filename ⇒ Object

bigWig file name



18
19
20
 
# File 'lib/bio/ucsc/big_wig.rb', line 18

def filename
  @filename
end

Class Method Details

.open(*args) ⇒ Object

convenience method to create a new BigWig and open it.



22
23
24
 
# File 'lib/bio/ucsc/big_wig.rb', line 22

def self.open(*args)
  self.new(*args).open
end

Instance Method Details

#bases_covered(opts = {}) ⇒ Object

Total bases containing actual data



93
94
95
96
 
# File 'lib/bio/ucsc/big_wig.rb', line 93

def bases_covered(opts={})
  bwf,bbi_sum = prepare_bwf(opts)
  return bbi_sum[:validCount]
end

#chrom_length(chrom = nil) ⇒ Object

Returns size of given chromosome or the sum of all chromosomes



98
99
100
 
# File 'lib/bio/ucsc/big_wig.rb', line 98

def chrom_length(chrom=nil)
  chrom.nil? ? chrom_list.inject(0){|sum,chrom|sum+=chrom[:size]} : Binding::bbiChromSize(bbi_file,chrom)
end

#close ⇒ Object

closes the file



39
40
41
42
43
44
45
46
 
# File 'lib/bio/ucsc/big_wig.rb', line 39

def close
  if bbi_file
    bbi_ptr= FFI::MemoryPointer.new(:pointer)
    bbi_ptr.write_pointer(bbi_file)
    Binding::bbiFileClose(bbi_ptr)
  end
  @bbi_file = nil
end

#coverage(chrom = nil, opts = {}) ⇒ Object

Percent of bases in region containing actual data



57
58
59
60
61
62
63
64
 
# File 'lib/bio/ucsc/big_wig.rb', line 57

def coverage(chrom=nil,opts={})
  if(chrom)
    self.summary(chrom,0,self.chrom_length(chrom),1,{type:'coverage'}).first
  else
    bwf,bbi_sum = prepare_bwf(opts)          
    return bbi_sum[:validCount] / chrom_length.to_f
  end
end

#info(opts = {}) ⇒ Object

prints details about the file:

  • minMax/m => Only output the minimum and maximum values

  • zooms/z => Display zoom level details

  • chroms/c => Display chrom details

  • udcDir/u => /dir/to/cache - place to put cache for remote bigBed/bigWigs



106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
 
# File 'lib/bio/ucsc/big_wig.rb', line 106

def info(opts={})
  min_max =opts[:m] ||= opts[:minMax]
  zooms =opts[:z] ||= opts[:zooms]
  chroms =opts[:c] ||= opts[:chroms]
  bwf,bbi_sum = prepare_bwf(opts)
  # print min/max
  if(min_max)
    printf "%f %f\n", bbi_sum[:minVal], bbi_sum[:maxVal]
    return
  end
  # start summary        
  printf "version: %d\n", bwf[:version]
  printf "isCompressed: %s\n", (bwf[:uncompressBufSize] > 0 ? "yes" : "no")
  printf "isSwapped: %i\n", bwf[:isSwapped] ? 1 : 0
  printf "primaryDataSize: %i\n",bwf[:unzoomedIndexOffset] - bwf[:unzoomedDataOffset]
  unless(bwf[:levelList].null?)
    list = Binding::BbiZoomLevel.new(bwf[:levelList])
    printf "primaryIndexSize: %i\n", list[:dataOffset] - bwf[:unzoomedIndexOffset]
  end
  # print zoom level details
  printf "zoomLevels: %d\n", bwf[:zoomLevels]
  if(zooms)
    zoom = Binding::BbiZoomLevel.new(bwf[:levelList])
    while !zoom.null?
      printf "\t%d\t%d\n", zoom[:reductionLevel], zoom[:indexOffset] - zoom[:dataOffset]
      zoom = zoom[:next]
    end
  end
  # print chrom details
  
  printf "chromCount: %d\n", chrom_list.size
  if(chroms)
    chrom_list.each do |chrom|
      printf "\t%s %d %d\n", chrom[:name], chrom[:id], chrom[:size]
    end
  end
  # finish summary
  printf "basesCovered: %i\n", bbi_sum[:validCount]
  printf "mean: %f\n", bbi_sum[:sumData]/bbi_sum[:validCount]
  printf "min: %f\n", bbi_sum[:minVal]
  printf "max: %f\n", bbi_sum[:maxVal]
  printf "std: %f\n", Binding::calcStdFromSums(bbi_sum[:sumData], bbi_sum[:sumSquares], bbi_sum[:validCount])
  return 
end

#max(chrom = nil, opts = {}) ⇒ Object

Returns the maximum value of items



75
76
77
78
79
80
81
82
 
# File 'lib/bio/ucsc/big_wig.rb', line 75

def max(chrom=nil,opts={})
  if(chrom)
    self.summary(chrom,0,self.chrom_length(chrom),1,{type:'max'}).first
  else
    bwf,bbi_sum = prepare_bwf(opts)
    return bbi_sum[:maxVal]
  end
end

#mean(chrom = nil, opts = {}) ⇒ Object

Returns the mean value of items



84
85
86
87
88
89
90
91
 
# File 'lib/bio/ucsc/big_wig.rb', line 84

def mean(chrom=nil,opts={})
  if(chrom)
    self.summary(chrom,0,self.chrom_length(chrom),1,{type:'mean'}).first
  else
    bwf,bbi_sum = prepare_bwf(opts)
    return bbi_sum[:sumData]/bbi_sum[:validCount].to_f
  end
end

#min(chrom = nil, opts = {}) ⇒ Object

Returns the minimum value of items



66
67
68
69
70
71
72
73
 
# File 'lib/bio/ucsc/big_wig.rb', line 66

def min(chrom=nil,opts={})
  if(chrom)
    self.summary(chrom,0,self.chrom_length(chrom),1,{type:'min'}).first
  else
    bwf,bbi_sum = prepare_bwf(opts)
    return bbi_sum[:minVal]
  end
end

#open ⇒ Object

opens the file

Raises:

  • (ArgumentError) 


31
32
33
34
35
36
37
 
# File 'lib/bio/ucsc/big_wig.rb', line 31

def open
  raise ArgumentError, "filename undefined" unless filename
  raise NameError, "#{filename} not found" unless File.exist?(filename)
  raise LoadError, "#{filename} bad format" unless Binding::isBigWig(filename)
  @bbi_file = Binding::bigWigFileOpen(filename)
  return self
end

#smooth(out_file, opts = {}) ⇒ Object

creates a new smoothed bigWig file at the supplied location. Smoothing options:

  • chrom => restrict smoothing to a given chromosome

  • cutoff => probe count cutoff

  • window => rolling window size

  • type => smoothing algorithm [avg]

    • ‘avg’ - average depth in window

    • ‘probe’ - count of regions (probes) crossing ‘cutoff’ in window

Big Wig options:

  • :blockSize => Number of items to bundle in r-tree [256]

  • :itemsPerSlot => Number of data points bundled at lowest level [1024]

  • :unc => If set, do not use compression

  • :udcDir => /dir/to/cache - place to put cache for remote bigBed/bigWigs



187
188
189
190
191
192
193
194
195
196
197
198
199
 
# File 'lib/bio/ucsc/big_wig.rb', line 187

def smooth(out_file,opts={})
  verb = opts[:v] || 0
  window = opts[:window] || 250
  cutoff = opts[:cutoff] || self.mean
  block_size = opts[:block_size]||256
  chrom = opts[:chrom]||nil
  items_per_slot = opts[:items_per_slot]||1024
  unc = opts[:unc]||false
  do_compress = !unc
  type = opts[:type]||'avg'
  udc_dir = opts[:u] ||= opts[:udcDir] ||= Binding::udcDefaultDir()
  Binding::bigWigFileSmooth(filename, chrom, block_size, items_per_slot, do_compress, window, verb, out_file, type, cutoff)
end

#std_dev(chrom = nil, opts = {}) ⇒ Object

returns the caclulated standard deviation



48
49
50
51
52
53
54
55
 
# File 'lib/bio/ucsc/big_wig.rb', line 48

def std_dev(chrom=nil,opts={})
  if(chrom)
    self.summary(chrom,0,self.chrom_length(chrom),1,{type:'std'}).first
  else
    bwf,bbi_sum = prepare_bwf(opts)
    return Binding::calcStdFromSums(bbi_sum[:sumData], bbi_sum[:sumSquares], bbi_sum[:validCount])
  end
end

#summary(chrom, start, stop, count, opts = {}) ⇒ Object

retrieves summary information from the bigWig for the given range.

  • chrom => Sequence name for summary

  • start => Start of range (0 based)

  • stop => End of range

  • count => Number of datapoints to compute (1 for simple summary)

hash Options:

  • :udcDir - /dir/to/cache - place to put cache for remote bigBed/bigWigs

  • :type => Summary type string

    • mean - average value in region (default)

    • min - minimum value in region

    • max - maximum value in region

    • std - standard deviation in region

    • coverage - %% of region that is covered



163
164
165
166
167
168
169
170
171
172
173
174
 
# File 'lib/bio/ucsc/big_wig.rb', line 163

def summary(chrom, start, stop, count, opts={})
  type = opts[:type] || opts[:t] || 'mean'
  udc_dir = opts[:u] ||= opts[:udcDir] ||= Binding::udcDefaultDir()
  Binding::udcSetDefaultDir(udc_dir)
  # allocate the array
  summaryValues = FFI::MemoryPointer.new(:double,count)
  # initialize to all 'NaN'
  summaryValues.write_array_of_type(:double,:write_string,["NaN"]*count)
  # fill in with Summary Data
  Binding::bigWigSummaryArray(bbi_file, chrom, start, stop, Binding::bbiSummaryTypeFromString(type),count,summaryValues)
  return summaryValues.read_array_of_double(count)
end