Example #1
0
def calculate_region_stranded(self, dual_reader, region_file):
    temp_region_file = open(self.sorted_region_path, 'wb')
    region_plus = Region()
    region_minus = Region()
    regions = []
    numreads_plus = 1
    numreads_minus = 1
    dual_reader = utils.DualSortedReader(self.current_experiment_path, self.current_control_path, self.experiment_format, self.logger)
    for line in dual_reader:
        new_region = _region_from_dual(self, line)
        new_region.end += self.proximity
        if not (region_plus and new_region.strand == PLUS_STRAND):
            region_plus = _region_from_dual(self, line)
           
        elif not (region_plus and new_region.strand == PLUS_STRAND):
            region_minus = _region_from_dual(self, line)

        else:
            if region_plus.overlap(new_region) and region_plus.strand == new_region.strand:
                region_plus.join(new_region)
                numreads_plus += 1
            elif region_minus.overlap(new_region) and region_minus.strand == new_region.strand:
                region_minus.join(new_region)
                numreads_minus += 1
            else:
                if new_region.strand == region_plus.strand:
                    region_plus.end -= self.proximity
                    self.__calc_reg_write(region_file, numreads_plus, region_plus)                      
                    region_plus = new_region.copy()  
                    numreads_plus = 1    
                else:
                    region_minus.end -= self.proximity
                    self.__calc_reg_write(region_file, numreads_minus, region_minus)         
                    region_minus = new_region.copy()  
                    numreads_minus = 1    

    if region_plus:
        region_plus.end -= self.proximity
        regions.append(region_plus)

    if region_minus:
        region_minus.end -= self.proximity
        regions.append(region_minus)

    regions.sort(key=lambda x:(x.name, x.start, x.end, x.strand))
    for region in regions:
        region_file.write(region.write())  
Example #2
0
def calculate_region_notstranded(self, dual_reader, region_file):
    calculated_region = Region()        
    readcount = 1
    for line in dual_reader:
        if not calculated_region: #first region only
            calculated_region = _region_from_dual(self, line)
            calculated_region.end += self.proximity
        else:
            new_region = _region_from_dual(self, line)
            new_region.end += self.proximity
            if calculated_region.overlap(new_region):
                calculated_region.join(new_region)
                readcount += 1
            else:
                calculated_region.end -= self.proximity
                __calc_reg_write(self, region_file, readcount, calculated_region)                 
                calculated_region = new_region.copy()
                readcount = 1

    if calculated_region:
        calculated_region.end -= self.proximity
        __calc_reg_write(self, region_file, readcount, calculated_region)