def _test_create_control(self):
        intervals = [obg.DirectedInterval(0, 20, [3]),
                     obg.DirectedInterval(0, 10, [5]),
                     obg.DirectedInterval(0, 21, [13])]
        mapped_intervals = self.snarl_map.map_interval_collection(
            intervals)
        linear_pileup = LinearPileup.create_from_starts_and_ends(
            mapped_intervals.starts,
            mapped_intervals.ends)
        graph_pileup = linear_pileup.to_sparse_pileup(self.snarl_map)

        true_sparse_pileup = OldSparsePileup(graph)
        true_data = {3: ValuedIndexes([], [], 2, 20),
                       12: ValuedIndexes([], [], 2, 20),
                       13: ValuedIndexes([], [], 2, 21),
                       5: ValuedIndexes([], [], 2, 10)}
        true_sparse_pileup.data = OldSparsePileupData([(key, val) for key, val in true_data.items()], graph=graph)
        #print(true_sparse_pileup.data)

        print("Graph pileup")
        print(graph_pileup)
        print("True")
        print(true_sparse_pileup)

        self.assertTrue(graph_pileup.equals_old_sparse_pileup(true_sparse_pileup))
Beispiel #2
0
 def setUp(self):
     self._graph = sorted_wierd_graph(2, 100)
     self._pileup = DensePileup(self._graph)
     self._intervals = [
         obg.DirectedInterval(0, 10, [1]),
         obg.DirectedInterval(90, 10, [1, 2]),
         obg.DirectedInterval(90, 10, [-3, -1])
     ]
def get_differential(motif_location, sub_graphs, node_ids_list):
    peak_id = motif_location._id
    motif_rps = motif_location.location.region_paths
    graph = sub_graphs[peak_id][()]
    node_ids = list(node_ids_list[peak_id])
    motif_idxs = [node_ids.index(rp) for rp in motif_rps]
    node_scores = np.asarray(np.min(graph, axis=1).todense())
    node_scores = node_scores.flatten()
    valid_nodes = node_scores != 0
    dists, predecessors = shortest_path(graph, return_predecessors=True,
                                        method="BF")
    alt, altD = find_alt(dists, motif_idxs, valid_nodes)
    if alt is None:
        return None
    mainD = dists[motif_idxs[0], motif_idxs[-1]]
    dist_diff = altD-mainD
    alt_node_score = abs(np.min(graph[alt]))
    start_path = backtrace(predecessors, motif_idxs[0], alt)
    end_path = backtrace(predecessors, alt, motif_idxs[-1])
    path = start_path[:-1] + end_path
    node_idxs = node_ids_list[peak_id][path]
    alt_interval = obg.DirectedInterval(
        motif_location.location.start_position.offset,
        motif_location.location.end_position.offset,
        list(node_idxs))
    obg_graph = motif_location.location.graph
    alt_interval.graph = obg_graph
    length_diff = motif_location.location.length()-alt_interval.length()
    alt_length = obg_graph.node_size(node_ids[alt])
    base_score = alt_node_score/alt_length
    main_score = base_score + dist_diff
    return DiffExpression(peak_id, motif_location.location,
                          alt_interval,
                          main_score, base_score)
Beispiel #4
0
 def test_internal_filled_interval(self):
     interval = obg.DirectedInterval(2, 8, [3])
     areas = BinaryContinousAreas(graph)
     areas.filled_interval(interval)
     areas.sanitize()
     true_areas = BinaryContinousAreas(graph)
     true_areas.internal_intervals = {3: [2, 8]}
     self.assertEqual(areas, true_areas)
Beispiel #5
0
 def test_filled_interval(self):
     interval = obg.DirectedInterval(4, 4, [2, 3, 4])
     areas = BinaryContinousAreas(graph)
     areas.filled_interval(interval)
     areas.sanitize()
     true_areas = BinaryContinousAreas(graph)
     true_areas.full_areas = {3: 1}
     true_areas.starts = {-2: 6, 4: 4}
     self.assertEqual(areas, true_areas)
    def setUp(self):
        self.snarl_map = LinearSnarlMap.from_snarl_graph(snarl_graph2, graph)
        self.graph_positions = [obg.Position(5, 4),
                                obg.Position(3, 4),
                                obg.Position(12, 4),
                                obg.Position(13, 4)]

        self.linear_positions = [4, 31/20*4, 10+21/20*4, 14]
        self.linear_positions = [p for p in self.linear_positions]
        self.graph_interval = obg.DirectedInterval(self.graph_positions[0],
                                                   self.graph_positions[2])
Beispiel #7
0
    def _generate_interval_from_start_pos(self, start_pos):
        cur_node = start_pos.region_path_id
        start_offset = start_pos.offset
        l = self._interval_length - (
            self._graph.node_size(cur_node)-start_offset)
        rps = [cur_node]
        while l > 0:
            cur_node = random.choice(self._graph.adj_list[cur_node])
            rps.append(cur_node)
            l -= self._graph.node_size(cur_node)

        end_offset = self._graph.node_size(cur_node) + l
        return obg.DirectedInterval(start_pos.offset, end_offset, rps)
Beispiel #8
0
    def test_long_fragments(self):
        intervals = [
            obg.DirectedInterval(80, 90, [1]),
            obg.DirectedInterval(90, 10, [1, 2]),
            obg.DirectedInterval(90, 10, [-4, -2]),
            obg.DirectedInterval(90, 10, [-3, -1])
        ]
        pileup = main(intervals, self._graph, 30)
        pileup = pileup.data._values
        true_array = np.zeros_like(pileup)
        true_array[60:80] = 1
        true_array[80:90] = 2
        true_array[90:100] = 3

        true_array[100:120] = 2
        true_array[120:140] = 1
        true_array[160:200] = 1

        true_array[200:210] = 2
        true_array[210:220] = 1

        true_array[300:310] = 1
        self.assertTrue(np.all(pileup == true_array))
Beispiel #9
0
 def get_interval(self, start, end):
     is_reversed = start > end
     if is_reversed:
         start, end = end, start
     assert end <= self.length
     first_idx = np.where(self._distances > start)[0][0]-1
     last_idx = np.where(self._distances < end)[0][-1]
     rps = [self._nodes[i] for i in range(first_idx, last_idx+1)]
     if is_reversed:
         rps = [-rp for rp in rps[::-1]]
         start_offset = self._distances[last_idx+1]-end
         end_offset = self._distances[first_idx+1]-start
     else:
         start_offset = start-self._distances[first_idx]
         end_offset = end-self._distances[last_idx]
     return obg.DirectedInterval(start_offset, end_offset, rps)
Beispiel #10
0
    def to_obg_with_reversals(self, ob_graph=False):
        if len(self.mappings) == 0:
            return False

        start_offset = self.mappings[0].get_start_offset()
        end_offset = self.mappings[-1].get_end_offset()
        obg_blocks = [m.node_id() for m in self.mappings]

        interval = offsetbasedgraph.DirectedInterval(start_offset, end_offset,
                                                     obg_blocks, ob_graph
                                                     or None)

        if ob_graph:
            if not interval.length() == self.length():
                raise IntervalNotInGraphException(
                    "Interval %s is not valid interval in graph" % interval)

        return interval
    def expand_hole_sides_to_right(self, positions):

        logging.info("Number of holes to expand: %d" % len(positions))
        extender = Extender(self._graph, self.hole_size)

        i = 0
        for position in positions:
            if i % 500 == 0:
                logging.info("Expanding hole %d/%d" % (i, len(positions)))
            i += 1

            node = position[0]
            offset = position[1]
            interval = obg.DirectedInterval(int(offset),
                                            int(offset) + 1, [node])
            areas = extender.extend_interval(interval)
            self.pileup.set_area_to_value(areas, True)

        self.pileup.threshold(0.5)
Beispiel #12
0
        self.assertTrue(np.all(pileup == true_array))


if False or __name__ == "__main__":
    node_size = 32
    n_nodes = 100000
    graph = swierd(n_nodes, node_size)
    intervals = []
    for node in graph.get_sorted_node_ids():
        if node % 20 == 0:
            next_nodes = graph.adj_list[node]
            if not next_nodes:
                continue
            next_node = next_nodes[0]
            for i in range(10):
                intervals.append(
                    obg.DirectedInterval(i, i + 4, [node, next_node]))

    for node in graph.get_sorted_node_ids(reverse=True):
        node = -node
        if node % 20 == 0:
            next_nodes = graph.reverse_adj_list[node]
            if not next_nodes:
                continue
            next_node = next_nodes[0]
            for i in range(10):
                intervals.append(
                    obg.DirectedInterval(i, i + 4, [node, next_node]))

    main(intervals, graph, 110)
Beispiel #13
0
paths = [Path("path1", mappings[:1])]
intervals = [offsetbasedgraph.Interval(10, 15, [0])]

nodes = [
    Node("_", 0, 10),
    Node("_", 1, 20),
    Node("_", 2, 30),
    Node("_", 3, 40)
]

edges = [Edge(0, 1), Edge(0, 2), Edge(1, 3), Edge(2, 3)]

vg_graphs = [Graph(nodes, edges, [])]
ob_graphs = [graph.get_offset_based_graph() for graph in vg_graphs]

pileup_intervals = [
    offsetbasedgraph.Interval(5, 5, [0, 1]),
    offsetbasedgraph.Interval(0, 10, [1]),
    offsetbasedgraph.Interval(10, 15, [1])
]

directed_pileup_intervals = [
    offsetbasedgraph.DirectedInterval(5, 5, [0, 1]),
    offsetbasedgraph.DirectedInterval(10, 20, [-1], -1),
    offsetbasedgraph.DirectedInterval(10, 15, [1])
]

for interval in pileup_intervals + directed_pileup_intervals:
    interval.graph = ob_graphs[0]
    def setUp(self):
        nodes = {i + 1: obg.Block(10) for i in range(5)}
        edges = {1: [2, 3], 2: [4], 3: [-4], 4: [5], -4: [5]}
        self.graph = obg.GraphWithReversals(nodes, edges)

        data = {
            node_id: ValuedIndexes(
                np.array([2 * i for i in range(1, 5)]),
                np.array([2 * i + 10 * node_id for i in range(1, 5)]),
                node_id * 10, 10)
            for node_id in nodes
        }

        self.pileup = SparsePileup(self.graph)
        self.pileup.data = data

        self.pileup = DensePileup.create_from_old_sparsepileup(self.pileup)

        flat_data = {
            node_id: ValuedIndexes(np.array([], dtype="int"), np.array([]),
                                   node_id * 10, 10)
            for node_id in nodes
        }

        self.flat_pileup = SparsePileup(self.graph)
        self.flat_pileup.data = flat_data
        self.flat_pileup = DensePileup.create_from_old_sparsepileup(
            self.flat_pileup)

        self.peak = BinaryContinousAreas(self.graph)
        self.peak.add_full(2)
        self.peak.add_full(4)
        self.peak.add_full(3)
        self.peak.add_start(5, 5)
        self.peak.add_start(-1, 5)

        indexes = np.array([2, 4, 6, 8])
        values = np.array([2, 4, 6, 8])
        self.scores = {
            2: ValuedIndexes(indexes, values + 20, 20, 10),
            -2: ValuedIndexes(indexes, values + 20, 20, 10),
            3: ValuedIndexes(indexes, values + 30, 30, 10),
            -3: ValuedIndexes(indexes, values + 30, 30, 10),
            4: ValuedIndexes(indexes, values + 40, 40, 10),
            -4: ValuedIndexes(indexes, values + 40, 40, 10),
            5: ValuedIndexes(np.array([2, 4]), np.array([52, 54]), 50, 5),
            -1: ValuedIndexes(np.array([1, 3]), np.array([16, 18]), 14, 5)
        }

        self.flat_scores = {
            2: ValuedIndexes(np.array([], dtype="int"), np.array([]), 20, 10),
            3: ValuedIndexes(np.array([], dtype="int"), np.array([]), 30, 10),
            4: ValuedIndexes(np.array([], dtype="int"), np.array([]), 40, 10),
            -2: ValuedIndexes(np.array([], dtype="int"), np.array([]), 20, 10),
            -3: ValuedIndexes(np.array([], dtype="int"), np.array([]), 30, 10),
            -4: ValuedIndexes(np.array([], dtype="int"), np.array([]), 40, 10),
            5: ValuedIndexes(np.array([], dtype="int"), np.array([]), 50, 5),
            -1: ValuedIndexes(np.array([], dtype="int"), np.array([]), 10, 5)
        }

        self.peak2 = BinaryContinousAreas(self.graph)
        self.peak2.add_full(2)
        self.peak2.add_start(-3, 7)
        self.peak2.add_full(4)
        self.peak2.add_start(5, 5)

        self.scores2 = {
            2: ValuedIndexes(indexes, values + 20, 20, 10),
            -3: ValuedIndexes(np.array([1, 3, 5]), np.array([34, 36, 38]), 32,
                              7),
            4: ValuedIndexes(indexes, values + 40, 40, 10),
            5: ValuedIndexes(np.array([2, 4]), np.array([52, 54]), 50, 5),
        }

        self.scored_peak = ScoredPeak(self.peak, self.scores)
        self.flat_scored_peak = ScoredPeak(self.peak, self.flat_scores)
        self.scored_peak2 = ScoredPeak(self.peak2, self.scores2)
        self.max_path = obg.DirectedInterval(5,
                                             5, [1, 3, -4, 5],
                                             graph=self.graph)
        self.max_path2 = obg.DirectedInterval(3,
                                              5, [3, -4, 5],
                                              graph=self.graph)