Ejemplo n.º 1
0
	def get_next_move(self, coordstring):
		#I am Player One. Only return one coordinate
		if(coordstring[0:1]=='D'):
			move = random.choice(list(self.__moves))
			self.__moves.discard(move)		
			print move, "jjj"	
			return str(move.get_msg_repr())
		
		#I am Player two, this is my first move. 
		if(coordstring[0:1]=='L'):
			self.__moves.discard(Coord(coordstring[1:3],coordstring[3:5]))	
			self.__moves.discard(Coord(coordstring[5:7],coordstring[7:9]))	
		#Regular Case
		else:
			self.__moves.discard(Coord(coordstring[0:2],coordstring[2:4]))	
			self.__moves.discard(Coord(coordstring[4:6],coordstring[6:8]))	
		
		move1 = random.choice(list(self.__moves))
		self.__moves.discard(move1)
		move2 = random.choice(list(self.__moves))
		self.__moves.discard(move2)		
		

		returnvalue = str(move1.get_msg_repr()+move2.get_msg_repr())
		
		return returnvalue
Ejemplo n.º 2
0
def printValidMoves(g: Game, c: Coord):
    moves = g.getValidMoves(c)
    b = g.board
    print(Style.BRIGHT, end="")
    if g.turn == 1:
        print(Fore.RED + "      > Black <", g.getScore(), Fore.RESET)
    else:
        print(Fore.RED + "        Black  ", g.getScore(), Fore.RESET)
    print("    a b c d e f g h")
    print("  " + "▄" * 18)
    for y in range(len(b)):
        print(f"{8-y} █", end="")
        for x in range(len(b[y])):
            print(Back.LIGHTBLACK_EX if (x + y) % 2 == 1 else Back.BLACK,
                  end="")
            if (Coord(x, y) in moves):
                print(Back.LIGHTMAGENTA_EX, end="")
            elif (Coord(x, y) == c):
                print(Back.LIGHTCYAN_EX, end="")
            if (b[y][x].team == 1):
                print(Fore.RED, end="")
            elif (b[y][x].team == 0):
                print(Fore.BLUE, end="")
            print(chooseSprite(b[y][x]), end=" ")
            print(Back.RESET + Fore.RESET, end="")
        print("█")
    print("  " + "▀" * 18)
    if g.turn == 0:
        print(Fore.BLUE + "      > White <", g.getScore(), Fore.RESET)
    else:
        print(Fore.BLUE + "        White ", g.getScore(), Fore.RESET)
    print(Style.RESET_ALL, end="")
Ejemplo n.º 3
0
def test_gamemanager(level2):
    gm = GameManager()
    player_names = []
    for i in range(3):
        player_names.append("bruh " + str(i))
    gm.register_player_names(player_names)
    assert len(gm.players) == 3
    assert gm.players[0].name == "bruh 0"
    assert gm.players[1].name == "bruh 1"
    assert gm.players[2].name == "bruh 2"
    gm.start_game(level2)
    assert gm.gamestate.current_level
    assert len(gm.players) == 3
    assert len(gm.gamestate.players) == 3
    assert gm.players[0].name == "bruh 0"
    assert gm.players[1].name == "bruh 1"
    assert gm.players[2].name == "bruh 2"
    new_player_locs = [gm.players[0].pos, gm.players[1].pos, gm.players[2].pos]
    new_player_locs[2] = Coord(7, 18)
    gm.request_player_move(gm.players[2].name, Coord(7, 3))
    assert gm.players[2].pos == Coord(7, 3)
    item = Item(KEY, Coord(8, 17))
    gm.apply_player_item_interaction(gm.gamestate.players[2], Coord(8, 17))
    print(str(gm.gamestate.players[2]))
    assert item in gm.gamestate.players[2].inventory
Ejemplo n.º 4
0
def test_reachable_tiles_multiple(room1):
    coord = Coord(8, 7)
    tiles = room1.get_reachable_tiles(coord)
    assert len(tiles) == 3
    assert Coord(8, 6) in tiles
    assert Coord(8, 8) in tiles
    assert Coord(9, 7) in tiles
Ejemplo n.º 5
0
def test_invalid_level_dimensions(capsys, level1):
    invalid_dimensions = Room(Coord(6, 1), Coord(6, 6), tiles, doors)
    level1.rooms.append(invalid_dimensions)
    valid_level = check_level(level1)
    capture = capsys.readouterr()
    assert capture.out == 'Invalid Level: Overlapping Room(s) or Hallway(s)\n'
    assert valid_level == False
Ejemplo n.º 6
0
 def _find_coord(self, s):
     _p = s.split()
     for x in _p:
         r = re_coord1.search(x)
         if r:
             p = r.group(0).replace("-", " ").replace(":", " ").replace(
                 ",", "").replace(".", "").split()
             return (s.replace(r.group(0), "").strip(),
                     Coord(p[0].replace("x", "X").replace("y", "Y"), p[1],
                           p[2]))
     for x in _p:
         r = re_coord2.search(x)
         if r:
             p = r.group(0).replace("-", " ").replace(":", " ").replace(
                 ",", "").replace(".", "").split()
             return (s.replace(r.group(0), "").strip(),
                     Coord(p[0].replace("x", "X").replace("y", "Y"), p[1],
                           int(p[1]) + 1))
     for x in _p:
         r = re_coord3.search(x)
         if r:
             c = r.group(0).replace("x", "X").replace("y", "Y")
             return (s.replace(r.group(0), "").strip(),
                     Coord(c, 0, chrom_lengths[self.assembly][c]))
     return (s, None)
Ejemplo n.º 7
0
 def generate_pacman_and_cherries(self):
     free_cells = [
         pos for pos, cell in self.grid.cells.items()
         if pos.x != self.grid.width // 2 and cell.is_floor()
     ]
     self.random.shuffle(free_cells)
     left_cells = [
         pos for pos in free_cells if pos.x < self.grid.width // 2
     ]
     i = 0
     while i < self.pacman_per_player:
         left_cell = Coord(left_cells[i].x, left_cells[i].y)
         right_cell = Coord(self.grid.width - 1 - left_cell.x, left_cell.y)
         left_player = self.random.randint(0, 1)
         right_player = (left_player + 1) % 2
         self.players[left_player][i] = left_cell
         self.players[right_player][i] = right_cell
         i += 1
     for j in range(self.cherries // 2):
         left_cell = Coord(left_cells[i + j].x, left_cells[i + j].y)
         right_cell = Coord(self.grid.width - 1 - left_cell.x, left_cell.y)
         self.grid.get(left_cell).has_cherry = True
         self.grid.get(right_cell).has_cherry = True
     players = set()
     for player in self.players:
         for pos in player:
             players.add(pos)
     for pos, cell in self.grid.cells.items():
         if cell.is_floor() and not cell.has_cherry and pos not in players:
             cell.has_pellet = True
Ejemplo n.º 8
0
def walk(instructions):
    """
    >>> walk("R2, L3")
    (5, None)
    >>> walk("R2, R2, R2")
    (2, None)
    >>> walk("R5, L5, R5, R3")
    (12, None)
    >>> walk("R8, R4, R4, R8")
    (8, 4)
    """
    position = BlockCoord(0, 0)
    heading = Coord(0, 1)
    visited = set((position, ))
    part2 = None
    for instruction in instructions.strip().split(', '):
        if instruction[0] == 'R':
            heading = heading.rotate_right()
        elif instruction[0] == 'L':
            heading = heading.rotate_left()
        for step in range(int(instruction[1:])):
            position += heading
            if part2 is None and position in visited:
                part2 = position
            visited.add(position)
    return (position.distance_blocks(),
            part2.distance_blocks() if part2 else None)
Ejemplo n.º 9
0
 def get_reachable_tiles(self, coord):
     try:
         tiles = []
         is_horizontal = self.check_orientation()
         # If halls should be 1 tile wide any traversable coord in a horizontal hall must have the same y value as a door. The range of traversable tiles spans the x boundary while y does not change
         if is_horizontal == True:
             col_values = set()
             for room in self.rooms:
                 for door in room.doors:
                     col_values.add(door.col)
             for ii in range(self.origin.row,
                             self.origin.row + self.dimensions.row + 1):
                 if coord.col in col_values:
                     new_coord = Coord(ii, coord.col)
                     tiles.append(new_coord)
         elif is_horizontal == False:
             row_values = set()
             for room in self.rooms:
                 for door in room.doors:
                     row_values.add(door.row)
             for jj in range(self.origin.col,
                             self.origin.col + self.dimensions.col + 1):
                 if coord.row in row_values:
                     new_coord = Coord(coord.row, jj)
                     tiles.append(new_coord)
         return tiles
     except Exception as err:
         print(err)
         return None
Ejemplo n.º 10
0
    def create(cls,
               arr,
               height=None,
               width=None,
               chart_id=None,
               index=None,
               pixels=None,
               orientation=0,
               mirror=(False, False)):
        obj = cls()

        obj.arr = np.array(arr, dtype=Chart.DATA_TYPE, copy=True)
        obj.chart_id = chart_id
        if height == None:
            obj.height = obj.arr.shape[0]
        else:
            obj.height = height
        if width == None:
            obj.width = obj.arr.shape[1]
        else:
            obj.width = width
        if index != None:
            obj.index = Coord(index)
            obj.low = Coord(index[0], index[1])
            obj.high = Coord(index[0] + height, index[1] + width)
        if pixels == None:
            obj.pixels = obj._count_pixels()
        else:
            obj.pixels = pixels
        if orientation < 0 or orientation > 3:
            raise Exception('Invalid orientation in Chart.create')
        obj.orientation = orientation

        return obj
Ejemplo n.º 11
0
def next_best_point(st, bot=None):
    minX = bot.region["minX"]
    maxX = bot.region["maxX"]
    minZ = bot.region["minZ"]
    maxZ = bot.region["maxZ"]
    # print(bot.region)

    for y, x, z in np.transpose(
            np.where(
                np.transpose(st.matrix._ndarray, (1, 0,
                                                  2)) == state.Voxel.MODEL)):
        if minX <= x < maxX and minZ <= z < maxZ:
            coord = Coord(int(x), int(y), int(z))
            if st.matrix.would_be_grounded(coord):
                # print(coord)
                return coord

    for y, x, z in np.transpose(
            np.where(
                np.transpose(st.matrix._ndarray, (1, 0,
                                                  2)) == state.Voxel.MODEL)):
        if minX - (maxX -
                   minX) / 2 <= x < maxX + (maxX - minX) / 2 and minZ - (
                       maxZ - minZ) / 2 <= z < maxZ + (maxZ - minZ) / 2:
            coord = Coord(int(x), int(y), int(z))
            if st.matrix.would_be_grounded(coord):
                # print(coord)
                return coord

    return None
Ejemplo n.º 12
0
 def handle_keys(self):
     for event in pygame.event.get():
         if event.type == pygame.QUIT:
             sys.exit()
         elif event.type == KEYDOWN:
             pass
         elif event.type == KEYUP:
             pass
         elif event.type == MOUSEBUTTONDOWN:
             print(self.plan_map)
             print('BUTTON:', event.button)
             x, y = event.pos
             if event.button == 1:
                 if self.first_vertex:
                     self.plan_map.firstV.x = x
                     self.plan_map.firstV.y = y
                     self.first_vertex = not self.first_vertex
                 elif self.nearest_edge is None:
                     self.plan_map.split_edge(self.plan_map.lastE,
                                              Coord(x, y))
                 else:
                     self.plan_map.split_edge(self.nearest_edge,
                                              Coord(x, y))
             elif event.button == 3:
                 nearest_edge = self.plan_map.nearest_edge(Coord(x, y))
                 print('Nearest edge:', nearest_edge)
Ejemplo n.º 13
0
 def post(self):
     headers = request.headers
     game_id = headers["game"]
     if (game_id not in manager.games.keys()):
         return {"error": "game not in game manager"}
     g = manager.getGame(game_id)
     if (headers["action"] == "move"):
         fromC = Coord(headers["x1"], headers["y1"])
         toC = Coord(headers["x2"], headers["y2"])
         try:
             g.makeMove(fromC, toC)
             db.child("Games").child(game_id).set(
                 toJson(manager.games[game_id]))
             return {"done": True}
         except Exception as e:
             return {
                 "error": "error at moving, message included.",
                 "message": str(e)
             }
     if (headers["action"] == "getMoves"):
         fromC = Coord(headers["x1"], headers["y1"])
         try:
             valids = g.getValidMoves(fromC)
         except Exception as e:
             return {"error": str(e)}
         print([str(c) for c in valids])
         out = {"coords": []}
         # ind = 0
         for c in valids:
             out["coords"].append({"x": c.x, "y": c.y})
             # ind+=1
         return out
     g.debugPrint()
Ejemplo n.º 14
0
def parse_room_obj(room_input):
    try:
        room_json = json.loads(room_input)
    except TypeError:
        room_json = room_input
    origin = None
    bounds = None
    layout = None
    point = None
    try:
        # [Room, Point] format 
        if room_json[0][TYPE] != ROOM:
            print('Invalid Args: Type is not room')
            return None
        input_json = room_json[0]
        point = room_json[1]
    except (KeyError, IndexError):
        input_json = room_json
    origin = input_json[ORIGIN]
    bounds = input_json[BOUNDS]
    layout = input_json[LAYOUT]

    origin_coord = to_coord(origin)
    dimensions = Coord(bounds[ROWS], bounds[COLS])
    tiles = []
    doors = []
    for ii in range(0, bounds[ROWS]):
        for jj in range(0, bounds[COLS]):
            # ii = x jj = y
            if layout[ii][jj] != 0:
                tiles.append(Coord(origin[0] + ii, origin[1] + jj))
            if layout[ii][jj] == 2:
                doors.append(Coord(origin[0] + ii, origin[1] + jj))
    return {COORD: to_coord(point) if point else None, ROOM: Room(origin_coord, dimensions, tiles, doors)}
Ejemplo n.º 15
0
def aStar(mapCells, srcX, srcY, dstX, dstY):
    openSet = []
    closedSet = []
    startNode = Node(mapCells, srcX, srcY, dstX, dstY, None)
    openSet.append(startNode)
    while len(openSet) != 0:
        curCandidate = getLowestScoreNode(openSet)
        if curCandidate.x == dstX and curCandidate.y == dstY:
            #then success!
            path = []
            curNode = curCandidate
            while not (curNode.x == srcX and curNode.y == srcY):
                coord = Coord(curNode.x, curNode.y)
                path.append(coord)
                curNode = curNode.prev
            # we also add this last one
            coord = Coord(curNode.x, curNode.y)
            path.append(coord)
            path.reverse()
            return path
        openSet.remove(curCandidate)
        closedSet.append(curCandidate)
        # add this node's neighbors to the open list
        addNeighbors(curCandidate, openSet, closedSet, mapCells, dstX, dstY)
    print "oh no!"
Ejemplo n.º 16
0
def printPossibleMoves(g: Game, c: Coord):
    moves = g.getPossibleMoves(c)
    b = g.board
    print(Style.BRIGHT, end="")
    print(Fore.RED + "        Black  " + Fore.RESET)
    print("    0 1 2 3 4 5 6 7")
    print("  " + "▄" * 18)
    for y in range(len(b)):
        print(f"{y} █", end="")
        for x in range(len(b[y])):
            print(Back.LIGHTBLACK_EX if (x + y) % 2 == 1 else Back.BLACK,
                  end="")
            if (Coord(x, y) in moves):
                print(Back.LIGHTMAGENTA_EX, end="")
            elif (Coord(x, y) == c):
                print(Back.LIGHTCYAN_EX, end="")
            if (b[y][x].team == 1):
                print(Fore.RED, end="")
            elif (b[y][x].team == 0):
                print(Fore.BLUE, end="")
            print(chooseSprite(b[y][x]), end=" ")
            print(Back.RESET + Fore.RESET, end="")
        print("█")
    print("  " + "▀" * 18)
    print(Fore.BLUE + "        White  " + Fore.RESET)
    print(Style.RESET_ALL, end="")
Ejemplo n.º 17
0
def get_cardinal_coords(cur_pos):
    up = Coord(cur_pos.row - 1, cur_pos.col)
    down = Coord(cur_pos.row + 1, cur_pos.col)
    left = Coord(cur_pos.row, cur_pos.col - 1)
    right = Coord(cur_pos.row, cur_pos.col + 1)
    directions = [up, down, left, right]
    return directions
Ejemplo n.º 18
0
def maxSlices(pizza):
    matrix = pizza.grid
    print "matrix:"
    print matrix
    # Output Data Type
    slices = []

    iMax = pizza.R
    jMax = pizza.C
    i = 0
    while (i < (iMax - 1)):
        j = 0
        while (j < (jMax - 1)):
            startVal = matrix[i][j]
            endVal = matrix[i][j + 1]
            if (isValidSlice(startVal, endVal)):
                startCoord = Coord(i, j)
                endCoord = Coord(i, j + 1)
                currSlice = Slice(startCoord, endCoord)
                slices.append(currSlice)
                j += 2
            else:
                j += 1
        i += 1

    # print matrix
    for currSlice in slices:
        currSlice.printSlice()
    visitSlices(matrix, slices)
Ejemplo n.º 19
0
    def _inverse_kinematics(self, target):
        """Calculate the necessary angle for a target, in the YZ plane.
        Uses the circle intersection method."""
        # Circle Centers
        c0 = Coord(0, -BASE_RADIUS, 0);
        c1 = Coord(0, target.y - EFFECTOR_RADIUS, target.z);

        # Distance between both circles
        dist = c0.get_abs_distance(c1);

        # Cirle radius
        r0 = BICEP_LENGTH;
        r1 = math.sqrt(FOREARM_LENGTH**2 - target.x**2) + JOINT_OFFSET;

        # Check valid distance between the two
        if 0 >= dist or  dist > r0 + r1:
            print "Invalid position - Potentially outside of reach"
            # raise Exception();

        # Calculate middle point
        a = (r0**2 - r1**2 + dist**2) / (2 * dist);

        # Calculate the angle and return
        new_angle =  180 * (math.atan2(c1.z, -c1.y + c0.y) + math.acos(a/r0)) / math.pi;
        print "Calculated Angle: ", new_angle;
        return new_angle;
Ejemplo n.º 20
0
 def get_vision(self, direction: Snake.Direction, pos: Coord,
                cherry: Coord):
     vision = list()
     r_pos = Coord(pos.x, pos.y)
     adj = [(-1, 0), (0, -1), (1, 0)]
     for i in range(direction.value):
         adj = [(-y, x) for x, y in adj]
         r_pos.x, r_pos.y = -r_pos.y, r_pos.x
     x, y = (cherry - r_pos).get_unit_vector().get()
     if x == 0:
         vision += [0, 0, 0] if y == -1 else [1, 0, 0]
     elif x == 1:
         if y == 0:
             vision += [0, 1, 0]
         else:
             vision += [0, 0, 1] if y == -1 else [0, 1, 1]
     elif x == -1:
         if y == 0:
             vision += [1, 1, 0]
         else:
             vision += [1, 1, 1] if y == -1 else [1, 0, 1]
     for vector in adj:
         last = pos + vector
         if last not in self.cells or self.cells[last].is_wall():
             vision.append(1)
         elif self.cells[last].has_body:
             vision.append(1)
         elif self.cells[last].has_cherry:
             vision.append(0)
         else:
             vision.append(0)
     return vision
Ejemplo n.º 21
0
def part2(program):
    screen = {}
    score = None
    last_ball_x = 0
    last_paddle_x = 0

    def paddle_ai():
        return (last_ball_x > last_paddle_x) - (last_ball_x < last_paddle_x)

    computer = Computer(program, mem_override={0: 2}, input=paddle_ai)

    computer.input_func = paddle_ai
    while not computer.halted:
        try:
            x = computer.run()
            y = computer.run()
            pos = Coord(x, y)
            if pos == Coord(-1, 0):
                score = computer.run()
            else:
                screen[pos] = computer.run()
                if screen[pos] == 3:
                    last_paddle_x = pos.x
                if screen[pos] == 4:
                    last_ball_x = pos.x
        except Halted:
            pass
    return score
Ejemplo n.º 22
0
def test_coord():
    c1 = Coord(0, 0)
    c2 = Coord(0, 1)
    c3 = Coord(0, 0)
    assert c1 != c2
    assert c2 != c3
    assert c1 == c3
Ejemplo n.º 23
0
 def gen_ref(self, tx, wall_type, wall_pos):
     distance = 0
     if wall_type == "top" or wall_type == "bottom":
         distance = wall_pos - tx.y
         return Coord(tx.x, tx.y + 2 * distance), wall_type
     else:
         distance = wall_pos - tx.x
         return Coord(tx.x + 2 * distance, tx.y), wall_type
Ejemplo n.º 24
0
 def make_ray(dim, base, _dir):
     dim = Coord(dim)
     coord = Coord(base)
     _dir = Coord(_dir)
     result = []
     while inside(coord.reset(coord + _dir), dim):
         result.append(coord.dat)
     return result
Ejemplo n.º 25
0
def test_invalid_level_shared_coords(capsys, room1, level1):
    hall = Hallway([Coord(5, 15), Coord(10, 20)], [room1, room2])
    level1.hallways[0] = hall
    valid_level = check_level(level1)
    capture = capsys.readouterr() 
    # assert capture.out == 'Invalid Level: Hallway or Room sharing coordinates\n'
    # TODO: Fix hallway to be valid
    assert valid_level == False
Ejemplo n.º 26
0
def generate_diagonal_moves(piece: BasePiece,
                            all_pieces: Iterable[BasePiece],
                            repeat: bool = True):
    return generate_offset_moves(
        piece,
        all_pieces,
        (Coord(1, -1), Coord(-1, 1), Coord(1, 1), Coord(-1, -1)),
        repeat,
    )
Ejemplo n.º 27
0
def generate_straight_moves(piece: BasePiece,
                            all_pieces: Iterable[BasePiece],
                            repeat: bool = True):
    return generate_offset_moves(
        piece,
        all_pieces,
        (Coord(1, 0), Coord(-1, 0), Coord(0, 1), Coord(0, -1)),
        repeat,
    )
Ejemplo n.º 28
0
	def __init__(self, x, y, vx, vy, car_type='normal', attack_type=None):
		self.id = next(self.id_generator)
		self.position = Coord(x, y)
		self.speed = Coord(vx, vy)
		self.type = car_type
		self.generate_xpath()
		self.generate_ypath()
		self.attack_type = attack_type
		self.network = None
Ejemplo n.º 29
0
def shortest_path_algo(st):
    bot = st.bots[0]
    bot.smove(UP)

    minX, maxX, minY, maxY, minZ, maxZ = st.matrix.bounds
    print(st.matrix.bounds)
    minarea, maxbots = 6 * 6, 20
    width, depth = maxX - minX, maxZ - minZ
    mostarea = width * depth / maxbots
    rsize = ceil(sqrt(max(mostarea, minarea)))
    xbots, zbots = max(floor(width / rsize), 1), max(floor(depth / rsize), 1)
    nbots = xbots * zbots
    print("nbots: {}".format(nbots))
    regions = []
    for x in range(xbots):
        rX = min([maxX, minX + (x + 1) * rsize])
        if maxX - rX < rsize:
            rX = maxX
        for z in range(zbots):
            rZ = min([maxZ, minZ + (z + 1) * rsize])
            if maxZ - rZ < rsize:
                rZ = maxZ
            region = {
                "minX": int(minX + x * rsize),
                "maxX": int(rX),
                "minZ": int(minZ + z * rsize),
                "maxZ": int(rZ)
            }
            print(region)
            regions.append(region)
    # print(convex_hull(st))
    # print(st.matrix.bounds)
    st.step_all()

    for i in range(1, nbots):
        # print(st.bots[0].seeds)
        sorted(st.bots, key=lambda bot: -len(bot.seeds))[0].fission(FORWARD, 0)
        st.step_all()
        b = st.bots[i]
        b.region = regions[nbots - i - 1]
        path = shortest_path(st, b, Coord(b.region["minX"], 1,
                                          b.region["minZ"]))
        if path:
            compress(st, b, path)
        st.step_all()
    b = st.bots[0]
    b.region = regions[nbots - 1]
    path = shortest_path(st, b, Coord(b.region["minX"], 1, b.region["minZ"]))
    if path:
        compress(st, b, path)
    st.step_all()

    solve(st)
    print("finished solve")

    st.step_all()
Ejemplo n.º 30
0
    def get_introns(self):
        """Returns a list of coordinates that represent the introns for
        this transcript"""
        introns = []

        for i in range(len(self.exons) - 1):
            ex1 = self.exons[i]
            ex2 = self.exons[i + 1]

            if self.strand == -1:
                intron = Coord(self.chrom,
                               ex2.end + 1,
                               ex1.start - 1,
                               strand=self.strand)
            else:
                intron = Coord(self.chrom,
                               ex1.end + 1,
                               ex2.start - 1,
                               strand=self.strand)

            intron.exon_5p = ex1
            intron.exon_3p = ex2
            introns.append(intron)

            if self.intron_scores is not None:
                intron.score = self.intron_scores[i]

            if self.known_intron_flags is not None:
                if self.known_intron_flags[i] == "1":
                    intron.is_known = True
                else:
                    intron.is_known = False

        return introns
Ejemplo n.º 31
0
    def test_basic_matrix(self):
        m = Matrix(problem=1)
        c = Coord(8, 9, 10)
        self.assertTrue(m[c].is_void())
        m[c].set_full()
        self.assertTrue(m[c].is_full())
        self.assertFalse(m[c].is_grounded())
        m.yplane(9)[8, 10].set_grounded()
        self.assertTrue(m[c].is_grounded())

        self.assertTrue(m[Coord(13, 5, 8)].is_model())
Ejemplo n.º 32
0
 def add_target(self, random=True, set_location=Coord(0, 0)):
     if random == True:
         self.target_coords.append(
             Coord(randint(0, self.x - 1), randint(0, self.y - 1)))
         self.num_targets += 1
         self.total_targets += 1
     else:
         self.target_coords.append(set_location)
         self.num_targets += 1
         self.total_targets += 1
     self.target_set = True
Ejemplo n.º 33
0
    def get_introns(self):
        """Returns a list of coordinates that represent the introns for
        this transcript"""
        introns = []

        for i in range(len(self.exons)-1):
            ex1 = self.exons[i]
            ex2 = self.exons[i+1]

            if self.strand == -1:
                intron = Coord(self.chrom, ex2.end+1, ex1.start-1,
                               strand=self.strand)
            else:
                intron = Coord(self.chrom, ex1.end+1, ex2.start-1,
                               strand=self.strand)

            intron.exon_5p = ex1
            intron.exon_3p = ex2
            introns.append(intron)

            if self.intron_scores is not None:
                intron.score = self.intron_scores[i]

            if self.known_intron_flags is not None:                
                if self.known_intron_flags[i] == "1":
                    intron.is_known = True
                else:
                    intron.is_known = False
            
        return introns
Ejemplo n.º 34
0
Archivo: xc.py Proyecto: Iv/igc2kmz
 def from_element(cls, rtept, namespace):
     name = rtept.findtext('{%s}name' % namespace).encode('utf_8')
     lat = float(rtept.get('lat'))
     lon = float(rtept.get('lon'))
     ele_tag = rtept.find('{%s}ele' % namespace)
     ele = 0 if ele_tag is None else int(ele_tag.text)
     time_text = rtept.findtext('{%s}time' % namespace)
     dt = datetime.strptime(time_text, GPX_DATETIME_FORMAT)
     coord = Coord.deg(lat, lon, ele, dt)
     return cls(name, coord)
Ejemplo n.º 35
0
 def track(self):
     ele = 'ele' if any(b.ele for b in self.b) else 'alt'
     coords = [Coord.deg(b.lat, b.lon, getattr(b, ele), b.dt)
               for b in self.b]
     kwargs = {}
     kwargs['filename'] = os.path.basename(self.filename)
     if 'plt' in self.h and not NOT_SET_RE.match(self.h['plt']):
         kwargs['pilot_name'] = self.h['plt'].strip()
     if 'gty' in self.h and not NOT_SET_RE.match(self.h['gty']):
         kwargs['glider_type'] = self.h['gty'].strip()
     if 'gid' in self.h and not NOT_SET_RE.match(self.h['gid']):
         kwargs['glider_id'] = self.h['gid'].strip()
     for k in self.i.keys():
         if any(getattr(b, k) for b in self.b):
             kwargs[k] = [getattr(b, k) for b in self.b]
     if self.c:
         tps = [Turnpoint(c.name, Coord.deg(c.lat, c.lon, 0), 0)
                for c in self.c]
         kwargs['declaration'] = Task('Declaration', tps)
     return track.Track(coords, **kwargs)
Ejemplo n.º 36
0
    def interpolate(self, *vecs, **kwargs):
        """Interpolate the function at given points. The points are either
        provided as a large array with each row consisting of one point
        or as a tuple of vectors each defining one coordinate of the
        interpolation points. If `as_grid` is True, each combination of
        coordinates will be used (each point on the grid defined by the
        coordinates). Additional keyword args are passed to
        scipy.interpolate.interpn.
        TODO: write up properly"""

        as_grid = kwargs.get('as_grid', False)
        if as_grid:
            coo = Coord(*vecs)
            vecs = coo.asarr()

        method = kwargs.get('method', 'linear')
        bounds_error = kwargs.get('bounds_error', False)
        fill_value = kwargs.get('fill_value', 0.0)

        return interpn(self.coord.vecs, self.fvals, vecs, method=method,
                       bounds_error=bounds_error, fill_value=fill_value)
Ejemplo n.º 37
0
 def track(self):
     ele = 'ele' if any(b.ele for b in self.b) else 'alt'
     coords = [Coord.deg(b.lat, b.lon, getattr(b, ele), b.dt)
               for b in self.b]
     kwargs = {}
     kwargs['filename'] = os.path.basename(self.filename)
     if 'plt' in self.h and not NOT_SET_RE.match(self.h['plt']):
         kwargs['pilot_name'] = self.h['plt'].strip()
     if 'gty' in self.h and not NOT_SET_RE.match(self.h['gty']):
         kwargs['glider_type'] = self.h['gty'].strip()
     if 'gid' in self.h and not NOT_SET_RE.match(self.h['gid']):
         kwargs['glider_id'] = self.h['gid'].strip()
     for k in self.i.keys():
         if any(getattr(b, k) for b in self.b):
             kwargs[k] = [getattr(b, k) for b in self.b]
     return track.Track(coords, **kwargs)
Ejemplo n.º 38
0
 def from_element(cls, element, namespace):
     name = element.findtext("{%s}name" % namespace).encode("utf_8")
     desc_tag = element.find("{%s}desc" % namespace)
     desc = None if desc_tag is None else desc_tag.text.encode("utf_8")
     lat = float(element.get("lat"))
     lon = float(element.get("lon"))
     ele_tag = element.find("{%s}ele" % namespace)
     ele = 0 if ele_tag is None else int(ele_tag.text)
     time_tag = element.find("{%s}time" % namespace)
     if time_tag is None:
         dt = None
     else:
         dt = datetime.datetime.strptime(time_tag.text, GPX_DATETIME_FORMAT)
     coord = Coord.deg(lat, lon, ele, dt)
     radius_tag = element.find("{%s}extensions/{%s}radius" % (namespace, namespace))
     radius = 400 if radius_tag is None else int(radius_tag.text)
     enter = element.find("{%s}extensions/{%s}exit" % (namespace, namespace)) is None
     return cls(name, coord, radius, enter, desc)
Ejemplo n.º 39
0
Archivo: photo.py Proyecto: Iv/igc2kmz
 def __init__(self, url, path=None):
     self.url = url
     components = urlparse.urlparse(self.url)
     self.name = os.path.splitext(os.path.basename(components.path))[0]
     if path:
         file = open(path)
     else:
         file = urllib2.urlopen(self.url) 
         if file.info().typeheader != 'image/jpeg':
             raise RuntimeError, '%s: not an image/jpeg' % self.url
     self.jpeg = exif.JPEG(file)
     if 'DateTimeOriginal' in self.jpeg.exif:
         self.dt = exif.parse_datetime(self.jpeg.exif['DateTimeOriginal'])
     elif 'DateTime' in self.jpeg.exif:
         self.dt = exif.parse_datetime(self.jpeg.exif['DateTime'])
     else:
         self.dt = datetime.datetime(2000, 1, 1)
     if 'GPSVersionID' in self.jpeg.exif:
         lat = exif.parse_angle(self.jpeg.exif['GPSLatitude'])
         if self.jpeg.exif['GPSLatitudeRef'] == 'S\0':
             lat = -lat
         lon = exif.parse_angle(self.jpeg.exif['GPSLongitude'])
         if self.jpeg.exif['GPSLongitudeRef'] == 'W\0':
             lon = -lon
         if 'GPSAltitude' in self.jpeg.exif:
             gps_altitude = self.jpeg.exif['GPSAltitude']
             ele = float(gps_altitude[0]) / gps_altitude[1]
             self.elevation_data = True
         else:
             ele = 0
             self.elevation_data = False
         self.coord = Coord.deg(lat, lon, ele)
     else:
         self.coord = None
         self.elevation_data = None
     if 'UserComment' in self.jpeg.exif:
         user_comment = self.jpeg.exif['UserComment']
         self.description = exif.parse_usercomment(user_comment)
     else:
         self.description = None
Ejemplo n.º 40
0
def trouver_deco_atterro(trace_gps, conn_bdd):
    '''Chercher si la base de donnees a un decollage dans un rayon de 100 m
    du point de depart et un atterrissage dans un rayon de 100 m du point
    d'arrivee de la trace GPS.

    Le format de la trace GPS doit etre une liste d'objets de type Coord()
    '''

    cur = conn_bdd.cursor()
    
    dist_deco_le_plus_proche = 99999
    deco_proche = None
    
    cur.execute('''SELECT * from decos order by deco''')
    liste_decos_bdd = cur.fetchall()

    # Chercher le deco le plus proche du depart de la trace GPS
    for deco in liste_decos_bdd:
        # Verifier que la latitude et la longitude sont enregistrees dans la
        # base de donnees
        try:
            float(deco[2])
            float(deco[3])
        # sinon, passer au decollage suivant
        except:
            continue
        
        coord_deco = Coord(deco[2], deco[3])
        dist_deco = coord_deco.distance_to(trace_gps[0])
        if dist_deco <= dist_deco_le_plus_proche :
            deco_proche = deco[1]
            dist_deco_le_plus_proche = dist_deco
        
    dist_atterro_le_plus_proche = 99999
    atterro_proche = None
    
    cur.execute('''SELECT * from atterros order by atterro''')
    liste_atterros_bdd = cur.fetchall()

    # Chercher l'atterro le plus proche de l'arrive de la trace GPS
    for atterro in liste_atterros_bdd:
        # Verifier que la latitude et la longitude sont enregistrees dans la
        # base de donnees
        try:
            float(atterro[2])
            float(atterro[3])
        # sinon, passer a l'atterro suivant
        except:
            continue
        
        coord_atterro = Coord(atterro[2], atterro[3])
        dist_atterro = coord_atterro.distance_to(trace_gps[-1])
        if dist_atterro <= dist_atterro_le_plus_proche :
            atterro_proche = atterro[1]
            dist_atterro_le_plus_proche = dist_atterro

    # Verifier que le deco le plus proche est a moins de 100 m
    if not dist_deco_le_plus_proche < 100:
        deco_proche = None
    # Verifier que l'atterro le plus proche est a moins de 150 m
    if not dist_atterro_le_plus_proche < 150:
        atterro_proche = None

    return (deco_proche, atterro_proche)
Ejemplo n.º 41
0
 def __init__(self, name, lat, lon, ele, description=None):
     Coord.__init__(self, lat, lon, ele)
     self.name = name
     self.description = description
Ejemplo n.º 42
0
def read_transcripts(path, chrom_dict):
    """Retrives all transcripts from the specified transcript file"""

    f = open(path, "r")

    transcripts = []
    
    for row in txtfile.read_rows(f):
        if row['ID'] == "NA":
            tr_id = None
        else:
            tr_id = int(row['ID'])

        if row["NAME"] == "NA":
            name = None
        else:
            name = row['NAME']
        
        # parse CDS start/end
        if row['CDS.START'] == 'NA':
            cds_start = None
        else:
            cds_start = int(row['CDS.START'])

        if row['CDS.END'] == 'NA':
            cds_end = None
        else:
            cds_end = int(row['CDS.END'])

        strand = int(row['STRAND'])
        chrom = chrom_dict[row['CHROM']]

        # parse exons
        exon_starts = [int(x) for x in row['EXON.STARTS'].split(",")]
        exon_ends = [int(x) for x in row['EXON.ENDS'].split(",")]

        if "EXON.SCORES" in row:
            exon_scores = [float(x) for x in row['EXON.SCORES'].split(",")]
            if len(exon_scores) != len(exon_starts):
                raise ValueError("Expected %d exon scores, got %d" %
                                 (len(exon_starts), len(exon_scores)))
        else:
            exon_scores = None

        if ("INTRON.SCORES" in row) and (row['INTRON.SCORES'] != 'NA'):
            intron_scores = [float(x) for x in row['INTRON.SCORES'].split(",")]
            if len(intron_scores) != len(exon_starts) - 1:
                raise ValueError("Expected %d intron scores, got %d" %
                                 (len(exon_starts)-1, len(intron_scores)))
        else:
            intron_scores = None

        if ("KNOWN.INTRON" in row) and (row['KNOWN.INTRON'] != "NA"):
            intron_flags = row['KNOWN.INTRON'].split(",")
        else:
            intron_flags = None

        exons = []
        for i in range(len(exon_starts)):
            exon = Coord(chrom, exon_starts[i], exon_ends[i], strand)
            if exon_scores is not None:
                exon.score = exon_scores[i]
            exons.append(exon)
        
        tr = Transcript(name=name, exons=exons,
                        cds_start=cds_start, cds_end=cds_end,
                        intron_scores=intron_scores,
                        known_intron_flags=intron_flags,
                        idnum=tr_id)

        transcripts.append(tr)
        
    f.close()

    return transcripts