def grow_projected_map()

in occant_utils/common.py [0:0]

• 69 lines of code
• 9 McCabe index (conditional complexity)

def grow_projected_map(proj_map, local_map, iterations=2):
    """
    proj_map - (H, W, 2) map
    local_map - (H, W, 2) map

    channel 0 - 1 if occupied, 0 otherwise
    channel 1 - 1 if explored, 0 otherwise
    """
    proj_map = np.copy(proj_map)
    HEIGHT, WIDTH = proj_map.shape[:2]

    explored_local_mask = local_map[..., 1] == 1
    free_local_mask = (local_map[..., 0] == 0) & explored_local_mask
    occ_local_mask = (local_map[..., 0] == 1) & explored_local_mask

    # Iteratively expand multiple times
    for i in range(iterations):
        # Generate regions which are predictable

        # ================ Processing free space ===========================
        # Pick only free areas that are visible
        explored_proj_map = (proj_map[..., 1] == 1).astype(np.uint8) * 255
        free_proj_map = ((proj_map[..., 0] == 0) & explored_proj_map).astype(
            np.uint8
        ) * 255
        occ_proj_map = ((proj_map[..., 0] == 1) & explored_proj_map).astype(
            np.uint8
        ) * 255

        # For the first iteration, aggressively close holes
        if i == 0:
            close_kernel = np.ones((3, 3), np.uint8)
            for itr in range(5):
                free_proj_map = cv2.morphologyEx(
                    free_proj_map, cv2.MORPH_CLOSE, close_kernel
                )
            free_proj_map = (free_proj_map > 0).astype(np.uint8) * 255

        dilate_kernel = np.ones((7, 7), np.uint8)

        # Expand only GT free area
        for itr in range(2):
            free_proj_map_edges = cv2.Canny(free_proj_map, 50, 100)
            free_proj_map_edges_dilated = cv2.dilate(
                free_proj_map_edges, dilate_kernel, iterations=3
            )
            free_mask = (
                (free_proj_map_edges_dilated > 0) | (free_proj_map > 0)
            ) & free_local_mask
            free_proj_map = free_mask.astype(np.uint8) * 255

        # Dilate to include some occupied area
        free_proj_map = cv2.dilate(free_proj_map, dilate_kernel, iterations=1)
        free_proj_map = (free_proj_map > 0).astype(np.uint8)

        # Close holes
        close_kernel = np.ones((3, 3), np.uint8)
        free_proj_map = cv2.morphologyEx(free_proj_map, cv2.MORPH_CLOSE, close_kernel)

        # ================ Processing occupied space ===========================
        # For the first iteration, aggressively close holes
        if i == 0:
            close_kernel = np.ones((3, 3), np.uint8)
            for itr in range(3):
                occ_proj_map = cv2.morphologyEx(
                    occ_proj_map, cv2.MORPH_CLOSE, close_kernel
                )
            occ_proj_map = (occ_proj_map > 0).astype(np.uint8) * 255

        dilate_kernel = np.ones((3, 3), np.uint8)

        # Expand only GT occupied area
        for itr in range(1):
            occ_proj_map_edges = cv2.Canny(occ_proj_map, 50, 100)
            occ_proj_map_edges_dilated = cv2.dilate(
                occ_proj_map_edges, dilate_kernel, iterations=3
            )
            occ_mask = (
                (occ_proj_map_edges_dilated > 0) | (occ_proj_map > 0)
            ) & occ_local_mask
            occ_proj_map = occ_mask.astype(np.uint8) * 255

        dilate_kernel = np.ones((9, 9), np.uint8)
        # Expand the free space around the GT occupied area
        for itr in range(2):
            occ_proj_map_dilated = cv2.dilate(occ_proj_map, dilate_kernel, iterations=3)
            free_mask_around_occ = (occ_proj_map_dilated > 0) & free_local_mask
            occ_proj_map = ((occ_proj_map > 0) | free_mask_around_occ).astype(
                np.uint8
            ) * 255

        # Close holes
        close_kernel = np.ones((3, 3), np.uint8)
        occ_proj_map = cv2.morphologyEx(occ_proj_map, cv2.MORPH_CLOSE, close_kernel)

        # Include originally present areas in proj_map
        predictable_regions_mask = (
            (explored_proj_map > 0) | (free_proj_map > 0) | (occ_proj_map > 0)
        )

        # Create new proj_map
        proj_map = np.zeros((HEIGHT, WIDTH, 2), np.float32)
        proj_map[predictable_regions_mask & occ_local_mask, 0] = 1
        proj_map[predictable_regions_mask, 1] = 1

    gt_map = proj_map

    return gt_map