Map Generation

Benchmark map patterns (u, l, random) for occupancy-grid experiments.

MapGenerator

create_grid staticmethod

create_grid(
    width=100,
    height=100,
    seed=None,
    obstacle_rate=0.25,
    robot_radius=0.0,
    resolution=1.0,
    max_iter=20,
    tolerance=0.01,
    min_size=10,
    max_size=30,
    n_walls=25,
    wall_thickness=2,
    min_wall_length=20,
    border=True,
    type="U",
    shape_type="rect",
)

Source code in src/hivebr/engine/map_generator.py

@staticmethod
def create_grid(
    width=100,
    height=100,
    seed=None,
    obstacle_rate=0.25,
    robot_radius=0.0,
    resolution=1.0,
    max_iter=20,
    tolerance=0.01,
    min_size=10,
    max_size=30,
    n_walls=25,
    wall_thickness=2,
    min_wall_length=20,
    border=True,
    type="U",
    shape_type="rect"
):
    grid = np.zeros((height, width), dtype=bool)
    if type == 'U':
        grid[10:90, 10:20] = True # Esquerda
        grid[10:90, 80:90] = True # Direita
        grid[80:90, 20:80] = True # Base
        return grid, []
    elif type == 'L':
        grid[10:90, 10:20] = True # Esquerda
        grid[80:90, 20:90] = True # Base
        return grid, []


    elif type == 'benchmark':

        rng = np.random.default_rng(seed)

        grid = MapGenerator._generate_benchmark_map(
            width,
            height,
            rng,
            n_walls=n_walls,
            wall_thickness=wall_thickness,
            min_wall_length=min_wall_length
        )

        if border:
            grid[0, :] = True
            grid[-1, :] = True
            grid[:, 0] = True
            grid[:, -1] = True

        return grid, [] # Benchmark não retorna lista de obstáculos detalhada no momento
    else:
        rng = np.random.default_rng(seed)

        radius = int(np.ceil(robot_radius / resolution))
        kernel = MapGenerator._disk_kernel(radius)

        # chute inicial (IMPORTANTE: menor que obstacle_rate)
        density = obstacle_rate * 0.4

        best = None
        best_obstacles = []
        best_err = 1e9

        for _ in range(max_iter):

            raw, current_obstacles = MapGenerator._generate_shapes(
                width,
                height,
                density,
                resolution,
                rng,
                shape_type=shape_type,
                min_size=min_size,
                max_size=max_size
            )

            inflated = binary_dilation(raw, structure=kernel)

            occ = inflated.mean()
            err = abs(occ - obstacle_rate)

            if err < best_err:
                best_err = err
                best = inflated.copy()
                best_obstacles = current_obstacles

            if err < tolerance:
                break

            # ajuste estável (evita explosão)
            if occ > obstacle_rate:
                density *= 0.85
            else:
                density *= 1.10

            density = np.clip(density, 0.01, 0.60)

        grid = best

        # bordas (muito importante para planning benchmark)
        if border:
            grid[0, :] = True
            grid[-1, :] = True
            grid[:, 0] = True
            grid[:, -1] = True

    return grid, best_obstacles

save staticmethod

save(grid, path)

Source code in src/hivebr/engine/map_generator.py

@staticmethod
def save(grid, path):
    img = (np.logical_not(np.flipud(grid)) * 255).astype(np.uint8)
    Image.fromarray(img).save(path)