Ejemplo n.º 1
0
    def _calculate(self, region, tv):
        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()
        strands = tv.strandsAsNumpyArray()

        if self._useStrands and strands is not None:
            assert strands is not None
        else:
            self._useStrands = False
            strands = None

        # Get genome size.
        regionSize = len(region)

        ret = complement(starts, ends, strands, regionSize,
                         useStrands=self._useStrands,
                         treatMissingAsNegative=self._treatMissingAsNegative)

        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 3
            # We do not care about info from the base track..
            # the new track will only contain the starts and ends

            starts = ret[0]
            ends = ret[1]
            strands = ret[2]
            tv = createRawResultTrackView(None, region, None,
                                          self._resultAllowOverlaps,
                                          newStarts=starts, newEnds=ends,
                                          newStrands=strands)
            return tv
        else:
            return None
Ejemplo n.º 2
0
    def _calculate(self, region, tv):
        raise NotImplementedError
        logging.debug("Start call! region:{0}".format(region))
        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()
        values = tv.valsAsNumpyArray()

        ids = tv.idsAsNumpyArray()
        edges = tv.edgesAsNumpyArray()

        print("*******")
        print(edges)
        print("*******")

        ret = uniquifyLinks(ids, edges, self._trackIdentifier,
                            self._allowOverlap, self._debug)

        if ret is not None and len(ret) != 0:
            assert len(ret) == 3

            tv = createRawResultTrackView(ret[2], region, tv,
                                          self._allowOverlap, newIds=ret[0],
                                          newEdges=ret[1])
            return tv
        else:
            return None
Ejemplo n.º 3
0
    def _calculate(self, region, tv):

        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()

        if self._useStrands:
            strands = tv.strandsAsNumpyArray()
        else:
            strands = None

        regionSize = len(region)

        ret = shift(starts, ends, regionSize, strands=strands,
                    shiftLength=self._shiftLength,
                    useFraction=self._useFraction,
                    useStrands=self._useStrands,
                    treatMissingAsNegative=self._treatMissingAsNegative)

        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 4

            starts = ret[0]
            ends = ret[1]
            index = ret[2]
            strands = ret[3]

            tv = createRawResultTrackView(index, region, tv,
                                          self._resultAllowOverlap,
                                          newStarts=starts, newEnds=ends,
                                          newStrands=strands,
                                          trackFormat=self._resultTrackFormat)
            return tv
        else:
            return None
Ejemplo n.º 4
0
    def _calculate(self, region, tv1, tv2):
        t1Starts = tv1.startsAsNumpyArray()
        t1Ends = tv1.endsAsNumpyArray()

        t2Starts = tv2.startsAsNumpyArray()
        t2Ends = tv2.endsAsNumpyArray()
        ret = intersect(t1Starts, t1Ends, t2Starts, t2Ends, debug=self._debug)

        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 4

            starts = ret[0]
            ends = ret[1]
            index = ret[2]
            encoding = ret[3]

            return createRawResultTrackView(
                index,
                region,
                [tv1, tv2],
                self._resultAllowOverlap,
                newStarts=starts,
                newEnds=ends,
                encoding=encoding,
                trackFormat=self._resultTrackFormat,
            )
        else:
            return None
Ejemplo n.º 5
0
    def _calculate(self, region, tv):
        logging.debug("Start call! region:{0}".format(region))

        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()

        if self._removeStrands:
            strands = None
        else:
            strands = tv.strandsAsNumpyArray()

        if self._removeValues:
            vals = None
        else:
            vals = tv.valsAsNumpyArray()

        if self._removeLinks:
            # As edges needs its, we need to remove them,
            # and as weights needs edges, we need to remove them as well.
            ids = None
            edges = None
            weights = None
        else:
            ids = tv.idsAsNumpyArray()
            edges = tv.edgesAsNumpyArray()

            if self._removeWeights:
                weights = None
            else:
                weights = tv.weightsAsNumpyArray()

        if self._removeExtras:
            extras = None
        else:
            extras = tv.allExtrasAsDictOfNumpyArrays()

        tv = createRawResultTrackView(None, region, None,
                                      self._resultAllowOverlap,
                                      newStarts=starts, newEnds=ends,
                                      newValues=vals, newStrands=strands,
                                      newIds=ids, newEdges=edges,
                                      newWeights=weights, newExtras=extras,
                                      trackFormat=self._resultTrackFormat)

        return tv
Ejemplo n.º 6
0
    def _calculate(self, region, tv):
        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()
        strands = tv.strandsAsNumpyArray()
        values = tv.valsAsNumpyArray()
        ids = tv.idsAsNumpyArray()
        edges = tv.edgesAsNumpyArray()
        weights = tv.weightsAsNumpyArray()

        if self._useStrands:
            if strands is None:
                self._useStrands = False

        ret = merge(starts, ends, strands=strands, values=values, ids=ids,
                    edges=edges, weights=weights, useStrands=self._useStrands,
                    treatMissingAsNegative=self._treatMissingAsNegative,
                    mergeValuesFunction=self._mergeValuesFunction,
                    debug=self._debug)

        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 7
            # We do not care about info from the base track..
            # the new track will only contain starts, ends and (strands if
            # present.

            #starts, ends, values, strands, ids, edges, weights
            starts = ret[0]
            ends = ret[1]
            values = ret[2]
            strands = ret[3]
            ids = ret[4]
            edges = ret[5]
            weights = ret[6]

            tv = createRawResultTrackView(None, region, None,
                                          self._resultAllowOverlap,
                                          newStarts=starts, newEnds=ends,
                                          newValues=values, newStrands=strands,
                                          newIds=ids, newEdges=edges,
                                          newWeights=weights,
                                          trackFormat=self._resultTrackFormat)
            return tv
        else:
            return None
Ejemplo n.º 7
0
    def _calculate(self, region, tv):

        ids = tv.idsAsNumpyArray()
        edges = tv.edgesAsNumpyArray()

        ret = uniquifyLinks(ids, edges, self._identifier, self._debug)

        if ret is not None and len(ret) != 0:
            assert len(ret) == 3
            newIds = ret[0]
            newEdges = ret[1]
            index = ret[2]

            tv = createRawResultTrackView(
                index, region, tv, True, newIds=newIds, newEdges=newEdges, trackFormat=self._resultTrackFormat
            )
            return tv
        else:
            return None
Ejemplo n.º 8
0
    def _calculate(self, region, tv):
        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()
        values = tv.valsAsNumpyArray()

        ret = valueSelect(starts, ends, values=values, limit=self._limit,
                          compareFunction=self._compareFunction,
                          allowOverlap=self._allowOverlap, debug=self._debug)

        if ret is not None and len(ret) != 0:
            assert len(ret) == 3
            # We do not care about info from the base track..
            # the new track will only contain starts, ends and (strands if
            # present

            t = createRawResultTrackView(ret[2], region, tv,True,
                                         newStarts=ret[0], newEnds=ret[1])
            return t
        else:
            return None
Ejemplo n.º 9
0
    def _calculate(self, region, tv1, tv2):

        t1Starts = tv1.startsAsNumpyArray()
        t1Ends = tv1.endsAsNumpyArray()

        t2Starts = tv2.startsAsNumpyArray()
        t2Ends = tv2.endsAsNumpyArray()

        ret = union(t1Starts, t1Ends, t2Starts, t2Ends,
                    self._resultAllowOverlap)

        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 4

            tv = createRawResultTrackView(ret[2], region, [tv1,tv2],
                                            self._resultAllowOverlap,
                                            newStarts=ret[0], newEnds=ret[1],
                                            encoding=ret[3],
                                            trackFormat=self._resultTrackFormat)
            return tv
        else:
            return None
Ejemplo n.º 10
0
    def _calculate(self, region, tv):

        # Remove RawOperationsContent
        starts = tv.startsAsNumpyArray()
        ends = tv.endsAsNumpyArray()
        strands = None

        if self._useStrands:
            strands = tv.strandsAsNumpyArray()
            if strands is None or strands.size == 0:
                # Track has no strand information, ignoring strands.
                strands = None
                self._useStrand = False

        # Get genome size.
        regionSize = len(region)

        ret = expand(regionSize, starts=starts, ends=ends, strands=strands,
                     downstream=self._downstream, upstream=self._upstream,
                     both=self._both, useFraction=self._useFraction,
                     useStrands=self._useStrands,
                     treatMissingAsNegative=self._treatMissingAsNegative,
                     debug=self._debug)

        # Returns start, ends, strands, index
        if ret is not None and len(ret[0]) != 0:
            assert len(ret) == 3
            starts = ret[0]
            ends = ret[1]
            index = ret[2]
            return createRawResultTrackView(index, region, tv,
                                            self._resultAllowOverlap,
                                            newStarts=starts, newEnds=ends,
                                            trackFormat=self._resultTrackFormat)
        else:
            return None