if len(argv) == 1:

cmd = 'python ' + argv[0] + ' -h'

os.system(cmd)

sys.exit(1)

desc = ""

usages = "%prog -i bed -w wig -o operator -s True"

parser = OP(usage=usages)

parser.add_option("-i", "--bed", dest="bed",

metavar="BED_REGION", help="Regions in bed file format, \

Bed will be read in memory wholely. - can be used as STDIN.\

When -m is TRUE, no duplicate names allowed in bed. Otherwise \

neighbor lines \

with same name in the forth column will be taken as one regions.***")

parser.add_option("-w", "--wig", dest="wig",

metavar="WIG", help="Regions in wig file format. Each position \

of same chromsome in wig must be sorted numerically. All legal wig \

obeys this rule. Tested for variable step and fixed step wig. \

All positions of one chromosome must under one header line when using \

variable step wig. For fixed step wig, all separated regions of one \

chromosome must near each other and should not be interrupted by \

regions in other chromosomes.***")

parser.add_option("-o", "--op", dest="op",

metavar="OPERATOR", help="Several choice, sum,mean,median,max,min.\

Multiple ones can be given in ',' connected in formats like \

<mean, max>. This parameter is exclusive with -m.")

parser.add_option("-m", "--maximum-pos", dest="mp",

metavar="1/0", default=0, help="Get the position with the largest \

value. If multiple maximum positions are found, the one nearest the \

middle will be chosed. This parameter is exclusive with -o. Default 0 \

means do not get max value.")

parser.add_option("-s", "--strand", dest="strand",

metavar="1/0", default=0, help="When 1 is given, compute \

strand specific coverage for bed regions. This assumes, the seond \

column in wig is positive strand while the third column in wig is \

nagative strand. Default 0, means unstranded." )

parser.add_option("-n", "--name", dest="name", default=1,

metavar="All column/Name column", help="Default the \

column output before coverage data is the forth column of bed file. If\

position information or all columns are also required, please give <0>.")

parser.add_option("-v", "--verbose", dest="verbose",

default=0, help="Show process information")

parser.add_option("-d", "--debug", dest="debug",

default=False, help="Debug the program")

(options, args) = parser.parse_args(argv[1:])

assert options.bed != None, "Region file in bed format is needed -i"

assert options.wig != None, "Coverage file in wig format is needed -i"

'''

Read bed into a dicat indexed by chromosome name.

additional = [0, 0, 0] length of additional is the same as length for

opL.

bedDict = {chr:[[chr, int_start, int_end, name, other, additional], \

[], []]}

'''

bedDict = {}

for line in bed_fh:

lineL = line.strip().split('\t')

#lineL[1] = int(lineL[1])

#lineL[2] = int(lineL[2])

chr = lineL[0]

#lineL.extend(additional)

if chr not in bedDict:

bedDict[chr] = []

bedDict[chr].append(lineL)

#-------------------------------

chrRegion= {} # chrRegion = {chr:(start, end)}

for chr, valueL in bedDict.items():

start = [int(i[1]) for i in valueL]

end = [int(i[2]) for i in valueL]

chrRegion[chr] = (min(start), max(end))

#array_i = array

chr = ''

span = 0

step = 0

#wigDict = collections.defaultdict(dict)

#wigDict = {} #unstrand wigDict = {pos:value}

#strand wigDicr = {pos:[pos value, neg value]}

bedDictChr = []

valDict = {}

pos_fixed = 0

overlappedChr = []

for i in open(wig):

if i.startswith('track'):

continue

elif i.startswith('#'):

continue

elif i.startswith('browse'):

continue

elif i.startswith('variableStep'):

saveWig = 1

if chr and chr in bedDict:

outputCoverage(wigChrDict,bedDict[chr],opL,name_mode,\

strand, mp)

bedDict.pop(chr)

wigChrDict = {}

pos_fixed = 0

chromi = i.rfind('chrom=')

assert chromi != -1, "Wrong format no chr %s" % i

chr = i[chromi+6:].strip().split()[0]

overlappedChr.append(chr)

if chr not in bedDict:

saveWig = 0

else:

spani = i.rfind("span=")

span = 1 if spani == -1 else \

int(i[spani+5:].strip().split()[0])

pos = 1

neg = 2

min_start = chrRegion[chr][0]

max_end = chrRegion[chr][1]

#-unckecked for less of data-------------

elif i.startswith("fixedStep"):

saveWig = 1

#if chr and chr in bedDict and wigChrDict:

chromi = i.rfind('chrom=')

assert chromi != -1, "Wrong format no chr %s" % i

newchr = i[chromi+6:].strip().split()[0]

if chr and chr != newchr and chr in bedDict:

outputCoverage(wigChrDict,bedDict[chr],opL,\

name_mode,strand,mp)

bedDict.pop(chr)

wigChrDict = {}

overlappedChr.append(chr)

if not chr:

wigChrDict = {}

chr = newchr

if chr not in bedDict:

saveWig = 0

else:

starti = i.rfind('start=')

assert starti != -1, "Must have start %s" % i

pos_fixed = int(i[starti+6:].strip().split()[0])

assert pos_fixed > 0, \

"fixedStep must have start bigger than 0 %s" % i

stepi = i.rfind('step=')

assert stepi != -1, "Must have step %s" % i

step = int(i[stepi+5:].strip().split()[0])

start = pos_fixed - step - 1 #feasible add <step> each

spani = i.rfind('span=')

span = 1 if spani == -1 else \

int(i[spani+5:].strip().split()[0])

pos = 0

neg = 1

min_start = chrRegion[chr][0]

max_end = chrRegion[chr][1]

#--------------------------------------------------

else:

if not saveWig:

continue

lineL = i.strip().split()

if pos_fixed: #fixedStep each position is the last

#position plus step.

start += step

end = start + span

else:

start = int(lineL[0])-1

end = start + span

#-------------------------------------------

#skip coverage for regions not located in bed

if end <= min_start:

continue

if start > max_end:

continue

#---------------------------------------------

if strand:

for position in xrange(start,end):

wigChrDict[position] = \

[float(lineL[pos]),float(lineL[neg])]

else:

for position in xrange(start,end):

wigChrDict[position] = float(lineL[pos])

#-------------------------------------------------

#--------end processing one line ----------------------

#----------------END reading whole file-------------------

if chr and chr in bedDict:

outputCoverage(wigChrDict,bedDict[chr],opL,\

name_mode,strand,mp)

bedDict.pop(chr)

label = ''

valueL = np_array([])

other = ''

for lineL in bedLineL:

if label and label != lineL[3]:

#---------------get the position with maximum value-------

if mp:

sort_indexL = argsort(valueL)

#print valueL

#print sort_indexL

maxP = sort_indexL[-1]

#print 'ORiginal maxP:', maxP

diff = abs(sort_indexL[-1]-mid)

maxV = valueL[maxP]

#print 'Total length:', length

for i in xrange(-2,length,-1):

if valueL[sort_indexL[i]] == maxV:

if diff > abs(sort_indexL[i]-mid):

diff = abs(sort_indexL[i]-mid)

maxP = sort_indexL[i]

maxV = valueL[maxP]

#print 'Iterated maxP:', maxP

else:

break

#----------------------------

if other:

print '%s\t%s\t%s\t%s\t%s\t%s' % (chr, str(maxP+start),

str(maxP+start+1), name, str(maxV),

'\t'.join(other))

other = ''

else:

print '%s\t%s\t%s\t%s\t%s' % (chr, str(maxP+start),

str(maxP+start+1), name, str(maxV))

#---------------get the position with maximum value-------

else:

print "%s\t%s" % (name, \

'\t'.join([str(op(valueL)) for op in opL]))

valueL = np_array([])

#----------output ----------------------------------

#---------------begin process--------------------

chr = lineL[0]

start = int(lineL[1])

end = int(lineL[2])

length = start - end - 1 #used for xrange, -1 means include

#start-end

mid = (end-start)/2.0

label = lineL[3]

if len(lineL) >= 6:

other = '\t'.join(lineL[5:])

if strand:

strand_in = lineL[5]

strand_num = 0 if strand_in == '+' else 1

if name_mode:

name = ''.join(label, '@', strand_in)

else:

name = '\t'.join(lineL)

valueL = np_append(valueL, \

[wigChrDict.get(i,[0,0])[strand_num] for i in xrange(start, end)])

else:

if name_mode:

name = label

else:

name = '\t'.join(lineL)

valueL = np_append(valueL, \

[wigChrDict.get(i,0) for i in xrange(start, end)])

#---------------------------------------------------------------------

if label:

#---------------get the position with maximum value-------

if mp:

sort_indexL = argsort(valueL)

#print valueL

#print sort_indexL

maxP = sort_indexL[-1]

#print 'ORiginal maxP:', maxP

diff = abs(sort_indexL[-1]-mid)

maxV = valueL[maxP]

#print 'Total length:', length

for i in xrange(-2,length,-1):

if valueL[sort_indexL[i]] == maxV:

if diff > abs(sort_indexL[i]-mid):

diff = abs(sort_indexL[i]-mid)

maxP = sort_indexL[i]

#print maxP

else:

break

#----------------------------

if other:

print '%s\t%s\t%s\t%s\t%s\t%s' % (chr, str(maxP+start),

str(maxP+start+1), name, str(maxV),

'\t'.join(other))

else:

print '%s\t%s\t%s\t%s\t%s' % (chr, str(maxP+start),

str(maxP+start+1), name, str(maxV))

#print "%s\t%s" % (name, str(maxP+start))

#---------------get the position with maximum value-------

else:

print "%s\t%s" % (name, \

'\t'.join([str(op(valueL)) for op in opL]))

options, args = cmdparameter(sys.argv)

#-----------------------------------

bed = options.bed

wig = options.wig

strand = options.strand

verbose = options.verbose

debug = options.debug

mp = options.mp

#wigDict = readWig(wig, strand)

#addL = [0 for i in opL]

name_mode = int(options.name)

#-----------------------------------

opDict = {'mean':mean, 'median':median, \

'max':max, 'min':min, 'sum':sum}

if options.op:

opL = [opDict[i] for i in options.op.split(',')]

else:

opL = []

assert options.mp

if bed == '-':

fh = sys.stdin

else:

fh = open(bed)

#--------------------------------

if options.op:

if name_mode:

print "#name\t%s" % '\t'.join([i for i in options.op.split(',')])

else:

print "#%s" % '\t'.join([i for i in options.op.split(',')])

bedDict, chrRegion = readBed(fh)

overlappedChr = computeCoverage(bedDict, wig, opL, name_mode,

strand, chrRegion, mp)

#-------output regions which do not exist in wig---

if options.op:

valuL = '\t'.join(['0' for i in opL])

for key in bedDict.keys():

if key not in overlappedChr:

for lineL in bedDict[key]:

label = lineL[3]

if name_mode:

if strand:

strand_in = lineL[5]

name = ''.join(label, '@', strand_in)

else:

name = label

else:

name = '\t'.join(lineL)

print '%s\t%s' % (name, valuL)

#--------------------------------------

#----------------------------------------

#-----------------------------------------------

#----close file handle for files-----

if bed != '-':

fh.close()

#-----------end close fh-----------

if verbose:

print >>sys.stderr,\