Datasets:

jacodd
/

SynthField

Tasks:

License:

Dataset card Files Files and versions

xet

Community

SynthField / utils /scene_generator.py

jacodd

Update utils/scene_generator.py

59cf78b verified 4 months ago

Raw History Blame Contribute Delete

10.8 kB

import omni
import random
import numpy as np
from pxr import Usd, UsdGeom, Gf, Sdf, UsdShade
from scipy.spatial.transform import Rotation

# --- Asset and Scene Configuration ---

CROP_ASSETS = {
    "soybean": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
    "sorghum": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
    "cotton": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
    "corn": ["_1", "_2", "_3", "_4", "_5", "_6", "_61", "_62", "_7", "_71", "_72", "_8", "_81", "_9", "_91", "_92"],
    "cane": ["_1", "_2"]
}

CROP_AGES = {
    "y": ["_1", "_2"],
    "y-m": ["_3", "_4", "_5"],
    "m-l": ["_5", "_6", "_7"],
    "l": ["_8", "_9"]
}

ROW_SPACING = {
    "corn": 0.45,
    "soybean": 0.45,
    "sorghum": 0.45,
    "cotton": 0.9,
    "cane": 1.0
}

WEED_ASSETS = [
    "/World/weed/broadleaf_1",
    "/World/weed/broadleaf_2",
    "/World/weed/grass_1",
    "/World/weed/grass_2"
]

OBSTACLE_ASSETS = [
    "/World/obstacle/cones/c1",
    "/World/obstacle/cones/c2",
    "/World/obstacle/cones/c3",
    "/World/obstacle/cones/c4",
    "/World/obstacle/female_adult_police_01_new",
    "/World/obstacle/male_adult_construction_01_new",
    # "/World/ood/Tractor"
]

# Weed
VOLUME_MAPPING = {
    "none": 0,
    "some": 50,  # Number of assets to spawn
    "lot": 500
}

OBSTACLE_VOLUME_MAPPING = {
    "none": 0,
    "some": 5,
    "lot": 15
}

TIME_OF_DAY_MAPPING = {
    "early": 85,
    "noon": 0,
    "late": -75
}

# 
GROUND_MATERIALS = [
        "/FlatGrid/Looks/Dirt",
        "/FlatGrid/Looks/Mulch_Brown",
        "/FlatGrid/Looks/Mulch_Dry"
]

# --- Helper Functions ---

def change_ground_material(stage):
    """Changes the ground material using the MaterialBindingAPI."""
    ground_path = "/FlatGrid/Environment"
    ground_prim = stage.GetPrimAtPath(ground_path)
    
    if not ground_prim:
        print(f"Ground prim not found at {ground_path}.")
        return

    material_path = random.choice(GROUND_MATERIALS)
    material_prim = stage.GetPrimAtPath(material_path)
    
    if not material_prim:
        print(f"Material prim not found at {material_path}.")
        return

    # Ensure the target prim is actually a Material
    material = UsdShade.Material(material_prim)
    if not material:
        print(f"Prim at {material_path} is not a valid UsdShadeMaterial.")
        return

    # Apply the MaterialBindingAPI to the ground prim
    binding_api = UsdShade.MaterialBindingAPI.Apply(ground_prim)
    
    # Bind the material. 
    # UsdShade.Tokens.strongerThanDescendants ensures this material 
    # overrides any materials assigned to child prims.
    binding_api.Bind(material, bindingStrength=UsdShade.Tokens.strongerThanDescendants)

    print(f"Successfully bound {ground_path} to {material_path}")


def set_time_of_day(stage, time_of_day):
    """Sets the absolute time of day by finding or creating the rotation op."""
    sun_path = "/World/CumulusLight/AxisNorth/AxisLatitude/AxisSHA"
    sun_prim = stage.GetPrimAtPath(sun_path)
    
    if not sun_prim:
        print(f"Warning: Sun prim not found at {sun_path}.")
        return

    angle = TIME_OF_DAY_MAPPING.get(time_of_day, 180)
    xform = UsdGeom.Xformable(sun_prim)
    
    # 1. Look for an existing RotateX operation in the stack
    rotate_op = None
    for op in xform.GetOrderedXformOps():
        if op.GetOpType() == UsdGeom.XformOp.TypeRotateX:
            rotate_op = op
            break
    
    # 2. If it exists, set the absolute value. If not, create it.
    if rotate_op:
        rotate_op.Set(float(angle))
    else:
        # This adds the op to the stack and sets the initial absolute value
        xform.AddRotateXOp(precision=UsdGeom.XformOp.PrecisionFloat).Set(float(angle))

def set_robust_transform(prim, translation=None, rotation_euler=None, scale=None):
    """
    Robustly updates or adds transform operations to a prim.
    Handles existing Ops, different precisions, and Quaternion vs Euler rotations.
    """
    xform = UsdGeom.Xformable(prim)
    # We use this to track which ops we've updated to avoid duplicates
    found_ops = {"translate": None, "rotate": None, "scale": None}
    
    for op in xform.GetOrderedXformOps():
        op_type = op.GetOpType()
        if op_type in [UsdGeom.XformOp.TypeTranslate]:
            found_ops["translate"] = op
        elif op_type in [UsdGeom.XformOp.TypeRotateXYZ, UsdGeom.XformOp.TypeOrient]:
            found_ops["rotate"] = op
        elif op_type in [UsdGeom.XformOp.TypeScale]:
            found_ops["scale"] = op

    # --- Handle Translation ---
    if translation is not None:
        if found_ops["translate"]:
            found_ops["translate"].Set(translation)
        else:
            xform.AddTranslateOp().Set(translation)

    # --- Handle Rotation (Euler Z to XYZ or Quat) ---
    if rotation_euler is not None:
        z_deg = rotation_euler[2] # Assuming we mostly care about Z for plants
        if found_ops["rotate"]:
            op = found_ops["rotate"]
            attr_type = op.GetAttr().GetTypeName()
            
            if attr_type in (Sdf.ValueTypeNames.Quatf, Sdf.ValueTypeNames.Quatd):
                # Convert Euler to Quat
                r = Rotation.from_euler('z', z_deg, degrees=True)
                q = r.as_quat() # x, y, z, w
                quat_val = Gf.Quatd(q[3], q[0], q[1], q[2]) if attr_type == Sdf.ValueTypeNames.Quatd else Gf.Quatf(q[3], q[0], q[1], q[2])
                op.Set(quat_val)
            else:
                # Standard Euler (Vec3f or Vec3d)
                current_rot = op.Get() or Gf.Vec3f(0)
                op.Set(Gf.Vec3f(current_rot[0], current_rot[1], z_deg))
        else:
            xform.AddRotateXYZOp().Set(Gf.Vec3f(0, 0, z_deg))

    # --- Handle Scale ---
    if scale is not None:
        if found_ops["scale"]:
            found_ops["scale"].Set(scale)
        else:
            xform.AddScaleOp().Set(scale)

def scatter_assets(stage, asset_paths, num_assets, area_min, area_max, root_path):
    if num_assets == 0: return
    stage.DefinePrim(root_path, "Xform")
    
    for i in range(num_assets):
        asset_path = random.choice(asset_paths)
        new_path = f"{root_path}/item_{i}"
        omni.usd.duplicate_prim(stage, asset_path, new_path)
        
        prim = stage.GetPrimAtPath(new_path)
        pos = Gf.Vec3f(random.uniform(area_min[0], area_max[0]), 
                       random.uniform(area_min[1], area_max[1]), 0)
        rot = Gf.Vec3f(0, 0, random.uniform(0, 360))
        
        set_robust_transform(prim, translation=pos, rotation_euler=rot, scale=Gf.Vec3f(1.0))

def get_crop_paths (crop_type, crop_age):
    """Get valid prim paths for the selected crop type and age."""
    base_path = f"/World/base/{crop_type}"
    age_suffixes = CROP_AGES.get(crop_age, [])
    available_suffixes = CROP_ASSETS.get(crop_type, [])
    valid_suffixes = [s for s in age_suffixes if s in available_suffixes]
    if not valid_suffixes:
        raise ValueError(f"No assets found for crop {crop_type} with age {crop_age}'.")
    return [f"{base_path}/{suffix}" for suffix in valid_suffixes]

def generate_scene(config):
    stage = omni.usd.get_context().get_stage()
    # ... [Config parsing logic] ...

    # --- Field Generation ---
    root_crop_path = Sdf.Path(f"/root/{config['crop_type']}_{config['crop_age']}_field")
    if stage.GetPrimAtPath(root_crop_path): stage.RemovePrim(root_crop_path)
    stage.DefinePrim(root_crop_path, "Xform")

    curve_effect = np.sin(np.linspace(0, 6 * np.pi, config["num_plants_in_row"])) * 0.35 if config["curve"] else np.zeros(config["num_plants_in_row"])

    print(f"Generating {config['num_rows']} rows with {config['num_plants_in_row']} plants each (Curve: {config['curve']})")

    for i in range(config["num_rows"]):
        for j in range(config["num_plants_in_row"]):
            if random.random() < 0.1: continue

            new_prim_path = f"{root_crop_path}/row_{i}_plant_{j}"
            omni.usd.duplicate_prim(stage, random.choice(get_crop_paths(config["crop_type"], config["crop_age"])), new_prim_path)
            
            prim = stage.GetPrimAtPath(new_prim_path)
            
            # Position logic
            offset = random.uniform(-0.02, 0.02)
            x_pos = i * ROW_SPACING.get(config["crop_type"], 0.45) + offset + curve_effect[j]
            y_pos = j * 0.1 + offset
            
            # Scale logic
            s = 1.0 + random.uniform(-0.05, 0.05)
            
            set_robust_transform(
                prim, 
                translation=Gf.Vec3f(x_pos, y_pos, 0), 
                rotation_euler=Gf.Vec3f(0, 0, random.uniform(0, 360)),
                scale=Gf.Vec3f(s, s, s)
            )

    # Scatter Weeds/Obstacles
    field_w = config["num_rows"] * ROW_SPACING.get(config["crop_type"], 0.45)
    field_l = config["num_plants_in_row"] * 0.1

    print(f"Scattering weeds and obstacles (Weeds: {config['weed_volume']}, Obstacles: {config['obstacle_volume']})")
    scatter_assets(stage, WEED_ASSETS, VOLUME_MAPPING[config["weed_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Weeds"))
    print(f"Scattering obstacles (Volume: {config['obstacle_volume']})")
    scatter_assets(stage, OBSTACLE_ASSETS, OBSTACLE_VOLUME_MAPPING[config["obstacle_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Obstacles"))
    # print(f"Setting time of day to {config['time_of_day']}")
    # set_time_of_day(stage, config["time_of_day"])
    # print("Changing ground material")
    # change_ground_material(stage)
    print("Scene generation complete!")


# --- USER CONFIGURATION ---
# Modify the values in this dictionary to change the generated scene.
CONFIG = {
    "crop_type": "cane",           # Options: "soybean", "sorghum", "cotton", "corn"
    "crop_age": "y",             # Options: "y", "y-m", "m-l", "l"
    "curve": False,                 # Options: True or False
    "num_plants_in_row": 250,        # Number of plants in each row
    "num_rows": 20,                 # Number of rows in the field
    "weed_volume": "none",         # Options: "none", "some", "lot"
    "obstacle_volume": "none",     # Options: "none", "some", "lot"
    "time_of_day": "noon"          # Options: "early", "noon", "late"
}
# --- END USER CONFIGURATION ---

# Execute the scene generation
generate_scene(CONFIG)

# for crop_type in ["soybean", "sorghum", "cotton", "corn"]:
#     for crop_age in ["y", "y-m", "m-l", "l"]:
#         CONFIG = {
#             "crop_type": crop_type,
#             "crop_age": crop_age,
#             "curve": False,
#             "num_plants_in_row": 250,
#             "num_rows": 20,
#             "weed_volume": "some",
#             "obstacle_volume": "some",
#             "time_of_day": "noon"
#         }
#         generate_scene(CONFIG)


	import omni
	import random
	import numpy as np
	from pxr import Usd, UsdGeom, Gf, Sdf, UsdShade
	from scipy.spatial.transform import Rotation

	# --- Asset and Scene Configuration ---

	CROP_ASSETS = {
	"soybean": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
	"sorghum": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
	"cotton": ["_1", "_2", "_3", "_4", "_5", "_6", "_7", "_8", "_9"],
	"corn": ["_1", "_2", "_3", "_4", "_5", "_6", "_61", "_62", "_7", "_71", "_72", "_8", "_81", "_9", "_91", "_92"],
	"cane": ["_1", "_2"]
	}

	CROP_AGES = {
	"y": ["_1", "_2"],
	"y-m": ["_3", "_4", "_5"],
	"m-l": ["_5", "_6", "_7"],
	"l": ["_8", "_9"]
	}

	ROW_SPACING = {
	"corn": 0.45,
	"soybean": 0.45,
	"sorghum": 0.45,
	"cotton": 0.9,
	"cane": 1.0
	}

	WEED_ASSETS = [
	"/World/weed/broadleaf_1",
	"/World/weed/broadleaf_2",
	"/World/weed/grass_1",
	"/World/weed/grass_2"
	]

	OBSTACLE_ASSETS = [
	"/World/obstacle/cones/c1",
	"/World/obstacle/cones/c2",
	"/World/obstacle/cones/c3",
	"/World/obstacle/cones/c4",
	"/World/obstacle/female_adult_police_01_new",
	"/World/obstacle/male_adult_construction_01_new",
	# "/World/ood/Tractor"
	]

	# Weed
	VOLUME_MAPPING = {
	"none": 0,
	"some": 50, # Number of assets to spawn
	"lot": 500
	}

	OBSTACLE_VOLUME_MAPPING = {
	"none": 0,
	"some": 5,
	"lot": 15
	}

	TIME_OF_DAY_MAPPING = {
	"early": 85,
	"noon": 0,
	"late": -75
	}

	#
	GROUND_MATERIALS = [
	"/FlatGrid/Looks/Dirt",
	"/FlatGrid/Looks/Mulch_Brown",
	"/FlatGrid/Looks/Mulch_Dry"
	]

	# --- Helper Functions ---

	def change_ground_material(stage):
	"""Changes the ground material using the MaterialBindingAPI."""
	ground_path = "/FlatGrid/Environment"
	ground_prim = stage.GetPrimAtPath(ground_path)

	if not ground_prim:
	print(f"Ground prim not found at {ground_path}.")
	return

	material_path = random.choice(GROUND_MATERIALS)
	material_prim = stage.GetPrimAtPath(material_path)

	if not material_prim:
	print(f"Material prim not found at {material_path}.")
	return

	# Ensure the target prim is actually a Material
	material = UsdShade.Material(material_prim)
	if not material:
	print(f"Prim at {material_path} is not a valid UsdShadeMaterial.")
	return

	# Apply the MaterialBindingAPI to the ground prim
	binding_api = UsdShade.MaterialBindingAPI.Apply(ground_prim)

	# Bind the material.
	# UsdShade.Tokens.strongerThanDescendants ensures this material
	# overrides any materials assigned to child prims.
	binding_api.Bind(material, bindingStrength=UsdShade.Tokens.strongerThanDescendants)

	print(f"Successfully bound {ground_path} to {material_path}")


	def set_time_of_day(stage, time_of_day):
	"""Sets the absolute time of day by finding or creating the rotation op."""
	sun_path = "/World/CumulusLight/AxisNorth/AxisLatitude/AxisSHA"
	sun_prim = stage.GetPrimAtPath(sun_path)

	if not sun_prim:
	print(f"Warning: Sun prim not found at {sun_path}.")
	return

	angle = TIME_OF_DAY_MAPPING.get(time_of_day, 180)
	xform = UsdGeom.Xformable(sun_prim)

	# 1. Look for an existing RotateX operation in the stack
	rotate_op = None
	for op in xform.GetOrderedXformOps():
	if op.GetOpType() == UsdGeom.XformOp.TypeRotateX:
	rotate_op = op
	break

	# 2. If it exists, set the absolute value. If not, create it.
	if rotate_op:
	rotate_op.Set(float(angle))
	else:
	# This adds the op to the stack and sets the initial absolute value
	xform.AddRotateXOp(precision=UsdGeom.XformOp.PrecisionFloat).Set(float(angle))

	def set_robust_transform(prim, translation=None, rotation_euler=None, scale=None):
	"""
	Robustly updates or adds transform operations to a prim.
	Handles existing Ops, different precisions, and Quaternion vs Euler rotations.
	"""
	xform = UsdGeom.Xformable(prim)
	# We use this to track which ops we've updated to avoid duplicates
	found_ops = {"translate": None, "rotate": None, "scale": None}

	for op in xform.GetOrderedXformOps():
	op_type = op.GetOpType()
	if op_type in [UsdGeom.XformOp.TypeTranslate]:
	found_ops["translate"] = op
	elif op_type in [UsdGeom.XformOp.TypeRotateXYZ, UsdGeom.XformOp.TypeOrient]:
	found_ops["rotate"] = op
	elif op_type in [UsdGeom.XformOp.TypeScale]:
	found_ops["scale"] = op

	# --- Handle Translation ---
	if translation is not None:
	if found_ops["translate"]:
	found_ops["translate"].Set(translation)
	else:
	xform.AddTranslateOp().Set(translation)

	# --- Handle Rotation (Euler Z to XYZ or Quat) ---
	if rotation_euler is not None:
	z_deg = rotation_euler[2] # Assuming we mostly care about Z for plants
	if found_ops["rotate"]:
	op = found_ops["rotate"]
	attr_type = op.GetAttr().GetTypeName()

	if attr_type in (Sdf.ValueTypeNames.Quatf, Sdf.ValueTypeNames.Quatd):
	# Convert Euler to Quat
	r = Rotation.from_euler('z', z_deg, degrees=True)
	q = r.as_quat() # x, y, z, w
	quat_val = Gf.Quatd(q[3], q[0], q[1], q[2]) if attr_type == Sdf.ValueTypeNames.Quatd else Gf.Quatf(q[3], q[0], q[1], q[2])
	op.Set(quat_val)
	else:
	# Standard Euler (Vec3f or Vec3d)
	current_rot = op.Get() or Gf.Vec3f(0)
	op.Set(Gf.Vec3f(current_rot[0], current_rot[1], z_deg))
	else:
	xform.AddRotateXYZOp().Set(Gf.Vec3f(0, 0, z_deg))

	# --- Handle Scale ---
	if scale is not None:
	if found_ops["scale"]:
	found_ops["scale"].Set(scale)
	else:
	xform.AddScaleOp().Set(scale)

	def scatter_assets(stage, asset_paths, num_assets, area_min, area_max, root_path):
	if num_assets == 0: return
	stage.DefinePrim(root_path, "Xform")

	for i in range(num_assets):
	asset_path = random.choice(asset_paths)
	new_path = f"{root_path}/item_{i}"
	omni.usd.duplicate_prim(stage, asset_path, new_path)

	prim = stage.GetPrimAtPath(new_path)
	pos = Gf.Vec3f(random.uniform(area_min[0], area_max[0]),
	random.uniform(area_min[1], area_max[1]), 0)
	rot = Gf.Vec3f(0, 0, random.uniform(0, 360))

	set_robust_transform(prim, translation=pos, rotation_euler=rot, scale=Gf.Vec3f(1.0))

	def get_crop_paths (crop_type, crop_age):
	"""Get valid prim paths for the selected crop type and age."""
	base_path = f"/World/base/{crop_type}"
	age_suffixes = CROP_AGES.get(crop_age, [])
	available_suffixes = CROP_ASSETS.get(crop_type, [])
	valid_suffixes = [s for s in age_suffixes if s in available_suffixes]
	if not valid_suffixes:
	raise ValueError(f"No assets found for crop {crop_type} with age {crop_age}'.")
	return [f"{base_path}/{suffix}" for suffix in valid_suffixes]

	def generate_scene(config):
	stage = omni.usd.get_context().get_stage()
	# ... [Config parsing logic] ...

	# --- Field Generation ---
	root_crop_path = Sdf.Path(f"/root/{config['crop_type']}_{config['crop_age']}_field")
	if stage.GetPrimAtPath(root_crop_path): stage.RemovePrim(root_crop_path)
	stage.DefinePrim(root_crop_path, "Xform")

	curve_effect = np.sin(np.linspace(0, 6 * np.pi, config["num_plants_in_row"])) * 0.35 if config["curve"] else np.zeros(config["num_plants_in_row"])

	print(f"Generating {config['num_rows']} rows with {config['num_plants_in_row']} plants each (Curve: {config['curve']})")

	for i in range(config["num_rows"]):
	for j in range(config["num_plants_in_row"]):
	if random.random() < 0.1: continue

	new_prim_path = f"{root_crop_path}/row_{i}_plant_{j}"
	omni.usd.duplicate_prim(stage, random.choice(get_crop_paths(config["crop_type"], config["crop_age"])), new_prim_path)

	prim = stage.GetPrimAtPath(new_prim_path)

	# Position logic
	offset = random.uniform(-0.02, 0.02)
	x_pos = i * ROW_SPACING.get(config["crop_type"], 0.45) + offset + curve_effect[j]
	y_pos = j * 0.1 + offset

	# Scale logic
	s = 1.0 + random.uniform(-0.05, 0.05)

	set_robust_transform(
	prim,
	translation=Gf.Vec3f(x_pos, y_pos, 0),
	rotation_euler=Gf.Vec3f(0, 0, random.uniform(0, 360)),
	scale=Gf.Vec3f(s, s, s)
	)

	# Scatter Weeds/Obstacles
	field_w = config["num_rows"] * ROW_SPACING.get(config["crop_type"], 0.45)
	field_l = config["num_plants_in_row"] * 0.1

	print(f"Scattering weeds and obstacles (Weeds: {config['weed_volume']}, Obstacles: {config['obstacle_volume']})")
	scatter_assets(stage, WEED_ASSETS, VOLUME_MAPPING[config["weed_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Weeds"))
	print(f"Scattering obstacles (Volume: {config['obstacle_volume']})")
	scatter_assets(stage, OBSTACLE_ASSETS, OBSTACLE_VOLUME_MAPPING[config["obstacle_volume"]], (0,0), (field_w, field_l), Sdf.Path("/root/Obstacles"))
	# print(f"Setting time of day to {config['time_of_day']}")
	# set_time_of_day(stage, config["time_of_day"])
	# print("Changing ground material")
	# change_ground_material(stage)
	print("Scene generation complete!")


	# --- USER CONFIGURATION ---
	# Modify the values in this dictionary to change the generated scene.
	CONFIG = {
	"crop_type": "cane", # Options: "soybean", "sorghum", "cotton", "corn"
	"crop_age": "y", # Options: "y", "y-m", "m-l", "l"
	"curve": False, # Options: True or False
	"num_plants_in_row": 250, # Number of plants in each row
	"num_rows": 20, # Number of rows in the field
	"weed_volume": "none", # Options: "none", "some", "lot"
	"obstacle_volume": "none", # Options: "none", "some", "lot"
	"time_of_day": "noon" # Options: "early", "noon", "late"
	}
	# --- END USER CONFIGURATION ---

	# Execute the scene generation
	generate_scene(CONFIG)

	# for crop_type in ["soybean", "sorghum", "cotton", "corn"]:
	# for crop_age in ["y", "y-m", "m-l", "l"]:
	# CONFIG = {
	# "crop_type": crop_type,
	# "crop_age": crop_age,
	# "curve": False,
	# "num_plants_in_row": 250,
	# "num_rows": 20,
	# "weed_volume": "some",
	# "obstacle_volume": "some",
	# "time_of_day": "noon"
	# }
	# generate_scene(CONFIG)