[Question] Is there a tutorial for creating subterrains using the terrain importer class ?

[Dafodilrat]

Question

I want to create multiple sub terrains separated by a gap with each sub terrain having its own prim. Currently I am able to create a grid with multiple sub-terrains but they are not separated and are all part of a single mesh ie. show up as a single plane.

figure illustrates 4 sub terrains combined to create 1 sub terrain. What I want is for the 4 subterrains to be its own thing with its own prims and all separated by a gap.

`import random
import math
from omni.isaac.kit import SimulationApp

Initialize SimulationApp

app = SimulationApp({
"headless": False,
"hide_ui": False,
"window_width": 1280,
"window_height": 720,
})
from isaacsim.core.api import World
from isaacsim.core.utils.prims import is_prim_path_valid, get_prim_at_path, create_prim
from isaaclab.terrains import TerrainImporter, TerrainImporterCfg, TerrainGeneratorCfg
from isaaclab.terrains.height_field import HfRandomUniformTerrainCfg
from pxr import UsdGeom, Gf
import logging

Set up logging

logging.basicConfig(level=logging.DEBUG)
logger = logging.getLogger(name)

Initialize World

world = World(stage_units_in_meters=1.0, set_defaults=True, device="cuda")
world.reset() # Initialize the simulation context

Ensure /World prim exists

if not is_prim_path_valid("/World"):
create_prim("/World", "Xform")
logger.debug("Created /World prim")

class TrainingGroundGenerator:
@staticmethod
def spawn_grid(n=1, cell_size=15.0, sub_terrain_types=None, prim_path="/World/TerrainGrid", gap_factor=3.0):
logger.debug(f"Spawning grid with n={n}, cell_size={cell_size}, gap_factor={gap_factor}, prim_path={prim_path}")
num_rows = math.ceil(math.sqrt(n))
num_cols = math.ceil(n / num_rows)
logger.debug(f"Computed grid: {num_rows}x{num_cols}")

    all_sub_terrains = {
        "plane": HfRandomUniformTerrainCfg(
            proportion=1.0,
            noise_range=(0.0, 0.0),
            noise_step=0.1,
            horizontal_scale=0.1,
            vertical_scale=0.005,
            slope_threshold=0.0,
        ),
        "rocky": HfRandomUniformTerrainCfg(
            proportion=0.0,
            noise_range=(0.05, 0.20),
            noise_step=0.05,
            horizontal_scale=0.05,
            vertical_scale=0.01,
            slope_threshold=0.7,
        ),
    }

    if sub_terrain_types is None:
        sub_terrain_types = ["plane"]
    sub_terrains = {k: v for k, v in all_sub_terrains.items() if k in sub_terrain_types}
    logger.debug(f"Selected sub_terrain_types: {sub_terrain_types}")

    if len(sub_terrains) > 0:
        total_prop = sum(cfg.proportion for cfg in sub_terrains.values())
        if total_prop == 0:
            equal_prop = 1.0 / len(sub_terrains)
            for cfg in sub_terrains.values():
                cfg.proportion = equal_prop
        else:
            for cfg in sub_terrains.values():
                cfg.proportion /= total_prop
    logger.debug(f"Normalized proportions: {[cfg.proportion for cfg in sub_terrains.values()]}")

    genCfg = TerrainGeneratorCfg(
        num_rows=num_rows,
        num_cols=num_cols,
        size=(cell_size, cell_size),
        vertical_scale=0.005,
        color_scheme="random",
        sub_terrains=sub_terrains,
        curriculum=False,
        border_width=2,
        border_height=1
    )
    logger.debug(f"Generator config: {genCfg}")

    impCfg = TerrainImporterCfg(
        prim_path=prim_path,
        terrain_type="generator",  # Use generator to avoid USD asset issues
        terrain_generator=genCfg,
        env_spacing=10.0,
        debug_vis=False,
        num_envs=n,
    )
    logger.debug(f"Importer config: {impCfg}")


    importer = TerrainImporter(impCfg)


    root_prim = get_prim_at_path(prim_path)
    if not root_prim.IsValid():
        raise RuntimeError(f"Failed to create terrain grid at {prim_path}. Check TerrainImporter configuration.")
    logger.debug(f"Root prim at {prim_path} is valid: {root_prim.IsValid()}")

    print(importer, flush=True)
    # print(importer.terrain_names(), flush=True)
    return root_prim`

[RandomOakForest]

Thank you for posting this. While there isn’t a single “tutorial” page dedicated only to subterrains with TerrainImporter, the official API docs show how to configure and generate sub-terrains with TerrainGenerator and then import them via TerrainImporter, and the Tutorials section has end-to-end examples that use this pipeline. The workflow is: define sub-terrain configs in TerrainGeneratorCfg, generate the mesh and sub-terrain origins, and feed that into TerrainImporter to place them in-sim and derive env origins.

I'll move this post to our Discussions for the team and others to follow up.

[Dafodilrat]

I went ahead and made my own spin of a terrain generator which does what I want. It wraps around the terrainImporter from isaac lab.

tools.py
TrainingGround.py

every time you create a training ground object it automatically adds it to a grid.