Datasets:

Cybernetic-Labs
/

packingbench-assets

"""
Package the task-9 packing-area scene as a SELF-CONTAINED background.
Takes the composition-based export (assets/task9_packing_area/
task9_packing_area.usd, see export_task9_scene_usd.py) and produces a fully
independent folder that can be copied anywhere (e.g. backend
storage/backgrounds/):
    assets/packing_area_background/
        scene.usd        flattened composed stage (only ACTIVE prims: the
                         warehouse shell, cleared bench, dressing props,
                         lights -- deactivated zones don't compose)
        resource/...     every texture/material file the scene references,
                         copied in and rewritten to package-relative paths
Texture slimming (the dataset ships 4K PNGs at 20-50 MB each): building-shell
textures are capped at 1K and prop textures at 2K -- the benchmark cameras
render at 640x480, and the shell is never closer than a few meters. Files are
deduplicated by content hash. <UDIM> patterns are expanded tile-by-tile.
Bare shader names (OmniPBR.mdl etc.) resolve from the Isaac install and are
left alone; unreachable omniverse:// paths are left as-is (benign warnings,
same as the source dataset).
Run phase 1 (needs pxr -- Isaac USD libs), which then invokes phase 2
(texture downscale, needs system python3 + PIL) automatically:
    USDLIBS=/opt/isaac-sim/extscache/omni.usd.libs-1.0.1+69cbf6ad.lx64.r.cp311
    PYTHONPATH=$USDLIBS LD_LIBRARY_PATH=$USDLIBS/bin \
        /opt/isaac-sim/kit/python/bin/python3 simready_warehouse_tasks/package_task9_background.py
"""

import hashlib
import os
from pathlib import Path
import re
import shutil
import subprocess
import sys

SCRIPT_DIR = Path(__file__).resolve().parent
PROJECT_DIR = SCRIPT_DIR.parent
SRC = PROJECT_DIR / "assets" / "task9_packing_area" / "task9_packing_area.usd"
OUT_DIR = PROJECT_DIR / "assets" / "packing_area_background"
SCENE = OUT_DIR / "scene.usd"
MANIFEST = OUT_DIR / "resource" / "textures_manifest.tsv"

SHELL_MAX_PX = 512  # building-shell textures: never seen closer than ~3 m
PROP_MAX_PX = 2048   # bench/rack/box textures: can fill a wrist-camera frame


def main():
    from pxr import Sdf, Usd, UsdUtils

    if OUT_DIR.exists():
        shutil.rmtree(OUT_DIR)
    (OUT_DIR / "resource").mkdir(parents=True)

    print(f"[1/3] Flattening {SRC} (only active prims compose)...")
    stage = Usd.Stage.Open(str(SRC))
    stage.Export(str(SCENE))
    print(f"  scene.usd: {SCENE.stat().st_size / 1e6:.1f} MB")

    print("[2/3] Collecting referenced assets (dedup by content hash)...")
    src_dir = SRC.parent
    layer = Sdf.Layer.FindOrOpen(str(SCENE))
    hash_to_rel = {}
    rel_class = {}  # rel path -> "prop" | "shell" (prop wins on dedup collisions)
    stats = {"copied": 0, "deduped": 0, "external": 0, "missing": []}

    def classify(abs_path):
        # Actual objects (bench, boxes, racks) live under Props/general and
        # Props/assembly; Props/materials and Props/skies hold the shared
        # building-shell materials despite the folder name.
        return "prop" if ("/Props/general/" in abs_path or "/Props/assembly/" in abs_path) else "shell"

    def copy_one(abs_path, dest_name_hint):
        digest = hashlib.sha1(Path(abs_path).read_bytes()).hexdigest()[:16]
        if digest in hash_to_rel:
            stats["deduped"] += 1
            rel = hash_to_rel[digest]
            if classify(abs_path) == "prop":
                rel_class[rel] = "prop"
            return rel
        rel = f"resource/{digest}_{dest_name_hint}"
        shutil.copy2(abs_path, OUT_DIR / rel)
        hash_to_rel[digest] = rel
        rel_class[rel] = classify(abs_path)
        stats["copied"] += 1
        return rel

    mdl_dirs = {}  # mdl content digest -> package-relative mdl path
    _tex_index = {}  # dataset-wide basename -> path index, built on first miss

    def find_texture_anywhere(basename):
        if not _tex_index:
            print("  building dataset-wide texture index (first fallback miss)...")
            for dirpath, _dirs, files in os.walk(PROJECT_DIR / "assets" / "physicalai_simready_warehouse_01"):
                for f in files:
                    if f.lower().endswith((".png", ".jpg", ".jpeg", ".tga", ".hdr", ".exr")):
                        _tex_index.setdefault(f, os.path.join(dirpath, f))
        return _tex_index.get(basename)

    def copy_mdl(abs_path):
        """Copy a custom .mdl into its own package folder together with every
        texture it references internally (relative to the .mdl's location),
        preserving the relative layout so those internal references keep
        resolving. Built-in shader names (OmniPBR.mdl) never reach here."""
        digest = hashlib.sha1(Path(abs_path).read_bytes()).hexdigest()[:16]
        if digest in mdl_dirs:
            stats["deduped"] += 1
            return mdl_dirs[digest]
        mdl_name = os.path.basename(abs_path)
        dest_dir = OUT_DIR / f"resource/mdl_{digest}"
        dest_dir.mkdir(parents=True, exist_ok=True)
        shutil.copy2(abs_path, dest_dir / mdl_name)
        stats["copied"] += 1
        src_mdl_dir = os.path.dirname(abs_path)
        text = Path(abs_path).read_text(errors="replace")
        for ref in set(re.findall(r'"([^"]+\.(?:png|jpg|jpeg|tga|hdr|exr))"', text, re.IGNORECASE)):
            ref_norm = ref.lstrip("./")
            if ref_norm.startswith("..") or os.path.isabs(ref):
                print(f"  WARNING: mdl ref escapes its folder, skipped: {mdl_name}: {ref}")
                continue
            tiles = [ref_norm]
            if "<UDIM>" in ref_norm:
                pattern = os.path.basename(ref_norm).replace("<UDIM>", "[0-9][0-9][0-9][0-9]")
                folder = Path(src_mdl_dir) / os.path.dirname(ref_norm)
                tiles = [os.path.join(os.path.dirname(ref_norm), t.name) for t in sorted(folder.glob(pattern))]
            for tile in tiles:
                src_tex = os.path.normpath(os.path.join(src_mdl_dir, tile))
                if not os.path.exists(src_tex):
                    # The dataset's MDLs are sloppy about case/subfolders
                    # ("Textures/foo.png" vs "textures/Chrome_A/foo.png");
                    # Omniverse's MDL resolver tolerates it, so fall back to a
                    # by-name search under the MDL's own folder and copy the
                    # hit to the path the MDL actually references.
                    candidates = sorted(Path(src_mdl_dir).rglob(os.path.basename(tile)))
                    if candidates:
                        src_tex = str(candidates[0])
                    else:
                        # This MDL copy has no textures nearby at all; take
                        # the same-named file from anywhere in the dataset.
                        src_tex = find_texture_anywhere(os.path.basename(tile))
                        if src_tex is None:
                            stats["missing"].append(f"{mdl_name}: {tile}")
                            continue
                dst_tex = dest_dir / tile
                dst_tex.parent.mkdir(parents=True, exist_ok=True)
                if not dst_tex.exists():
                    shutil.copy2(src_tex, dst_tex)
                    rel_class[f"resource/mdl_{digest}/{tile}"] = classify(abs_path)
                    stats["copied"] += 1
        rel = f"resource/mdl_{digest}/{mdl_name}"
        mdl_dirs[digest] = rel
        return rel

    def rewrite(path):
        if not path:
            return path
        if path.startswith(("omniverse://", "http")) or "/" not in path:
            # unreachable server paths and bare shader names (OmniPBR.mdl):
            # leave as authored.
            stats["external"] += 1
            return path
        abs_path = path if os.path.isabs(path) else os.path.normpath(str(src_dir / path))
        if abs_path.endswith(".mdl"):
            if not os.path.exists(abs_path):
                stats["missing"].append(path)
                return path
            return "./" + copy_mdl(abs_path)
        name = os.path.basename(abs_path)
        if "<UDIM>" in name:
            # expand tiles: copy each 4-digit tile under a shared hint so the
            # rewritten pattern resolves to all of them.
            folder = Path(os.path.dirname(abs_path))
            tiles = sorted(folder.glob(name.replace("<UDIM>", "[0-9][0-9][0-9][0-9]")))
            if not tiles:
                stats["missing"].append(path)
                return path
            hint = name.replace("<UDIM>", "UDIM")
            digest = hashlib.sha1(("udim:" + abs_path).encode()).hexdigest()[:16]
            for tile in tiles:
                tile_no = tile.name[len(name.split("<UDIM>")[0]):][:4]
                tile_rel = f"resource/{digest}_{hint.replace('UDIM', tile_no)}"
                dst = OUT_DIR / tile_rel
                if not dst.exists():
                    shutil.copy2(tile, dst)
                    rel_class[tile_rel] = classify(str(tile))
                    stats["copied"] += 1
            return f"./resource/{digest}_{hint.replace('UDIM', '<UDIM>')}"
        if not os.path.exists(abs_path):
            stats["missing"].append(path)
            return path
        return "./" + copy_one(abs_path, name)

    UsdUtils.ModifyAssetPaths(layer, rewrite)
    layer.Save()
    print(f"  copied {stats['copied']} files ({stats['deduped']} duplicate refs), "
          f"{stats['external']} left external")
    if stats["missing"]:
        print(f"  WARNING missing: {stats['missing']}")

    # Classification for the downscale pass: a file is a PROP texture if ANY
    # of its source paths lived under /Props/, else building shell.
    with open(MANIFEST, "w") as mf:
        for rel, cls in sorted(rel_class.items()):
            mf.write(f"{rel}\t{cls}\n")

    print("[3/3] Downscaling textures with system python3 + PIL...")
    downscale = subprocess.run(
        [sys.executable if "isaac" not in sys.executable else "python3",
         str(SCRIPT_DIR / "_downscale_textures.py"), str(OUT_DIR),
         str(SHELL_MAX_PX), str(PROP_MAX_PX)],
        capture_output=True, text=True,
    )
    print(downscale.stdout)
    if downscale.returncode != 0:
        print(downscale.stderr)
        raise SystemExit("texture downscale failed")

    total = sum(f.stat().st_size for f in OUT_DIR.rglob("*") if f.is_file())
    print(f"DONE: package total {total / 1e6:.1f} MB at {OUT_DIR}")


if __name__ == "__main__":
    main()

	"""
	Package the task-9 packing-area scene as a SELF-CONTAINED background.

	Takes the composition-based export (assets/task9_packing_area/
	task9_packing_area.usd, see export_task9_scene_usd.py) and produces a fully
	independent folder that can be copied anywhere (e.g. backend
	storage/backgrounds/):

	assets/packing_area_background/
	scene.usd flattened composed stage (only ACTIVE prims: the
	warehouse shell, cleared bench, dressing props,
	lights -- deactivated zones don't compose)
	resource/... every texture/material file the scene references,
	copied in and rewritten to package-relative paths

	Texture slimming (the dataset ships 4K PNGs at 20-50 MB each): building-shell
	textures are capped at 1K and prop textures at 2K -- the benchmark cameras
	render at 640x480, and the shell is never closer than a few meters. Files are
	deduplicated by content hash. <UDIM> patterns are expanded tile-by-tile.
	Bare shader names (OmniPBR.mdl etc.) resolve from the Isaac install and are
	left alone; unreachable omniverse:// paths are left as-is (benign warnings,
	same as the source dataset).

	Run phase 1 (needs pxr -- Isaac USD libs), which then invokes phase 2
	(texture downscale, needs system python3 + PIL) automatically:

	USDLIBS=/opt/isaac-sim/extscache/omni.usd.libs-1.0.1+69cbf6ad.lx64.r.cp311
	PYTHONPATH=$USDLIBS LD_LIBRARY_PATH=$USDLIBS/bin \
	/opt/isaac-sim/kit/python/bin/python3 simready_warehouse_tasks/package_task9_background.py
	"""

	import hashlib
	import os
	from pathlib import Path
	import re
	import shutil
	import subprocess
	import sys

	SCRIPT_DIR = Path(__file__).resolve().parent
	PROJECT_DIR = SCRIPT_DIR.parent
	SRC = PROJECT_DIR / "assets" / "task9_packing_area" / "task9_packing_area.usd"
	OUT_DIR = PROJECT_DIR / "assets" / "packing_area_background"
	SCENE = OUT_DIR / "scene.usd"
	MANIFEST = OUT_DIR / "resource" / "textures_manifest.tsv"

	SHELL_MAX_PX = 512 # building-shell textures: never seen closer than ~3 m
	PROP_MAX_PX = 2048 # bench/rack/box textures: can fill a wrist-camera frame


	def main():
	from pxr import Sdf, Usd, UsdUtils

	if OUT_DIR.exists():
	shutil.rmtree(OUT_DIR)
	(OUT_DIR / "resource").mkdir(parents=True)

	print(f"[1/3] Flattening {SRC} (only active prims compose)...")
	stage = Usd.Stage.Open(str(SRC))
	stage.Export(str(SCENE))
	print(f" scene.usd: {SCENE.stat().st_size / 1e6:.1f} MB")

	print("[2/3] Collecting referenced assets (dedup by content hash)...")
	src_dir = SRC.parent
	layer = Sdf.Layer.FindOrOpen(str(SCENE))
	hash_to_rel = {}
	rel_class = {} # rel path -> "prop" \| "shell" (prop wins on dedup collisions)
	stats = {"copied": 0, "deduped": 0, "external": 0, "missing": []}

	def classify(abs_path):
	# Actual objects (bench, boxes, racks) live under Props/general and
	# Props/assembly; Props/materials and Props/skies hold the shared
	# building-shell materials despite the folder name.
	return "prop" if ("/Props/general/" in abs_path or "/Props/assembly/" in abs_path) else "shell"

	def copy_one(abs_path, dest_name_hint):
	digest = hashlib.sha1(Path(abs_path).read_bytes()).hexdigest()[:16]
	if digest in hash_to_rel:
	stats["deduped"] += 1
	rel = hash_to_rel[digest]
	if classify(abs_path) == "prop":
	rel_class[rel] = "prop"
	return rel
	rel = f"resource/{digest}_{dest_name_hint}"
	shutil.copy2(abs_path, OUT_DIR / rel)
	hash_to_rel[digest] = rel
	rel_class[rel] = classify(abs_path)
	stats["copied"] += 1
	return rel

	mdl_dirs = {} # mdl content digest -> package-relative mdl path
	_tex_index = {} # dataset-wide basename -> path index, built on first miss

	def find_texture_anywhere(basename):
	if not _tex_index:
	print(" building dataset-wide texture index (first fallback miss)...")
	for dirpath, _dirs, files in os.walk(PROJECT_DIR / "assets" / "physicalai_simready_warehouse_01"):
	for f in files:
	if f.lower().endswith((".png", ".jpg", ".jpeg", ".tga", ".hdr", ".exr")):
	_tex_index.setdefault(f, os.path.join(dirpath, f))
	return _tex_index.get(basename)

	def copy_mdl(abs_path):
	"""Copy a custom .mdl into its own package folder together with every
	texture it references internally (relative to the .mdl's location),
	preserving the relative layout so those internal references keep
	resolving. Built-in shader names (OmniPBR.mdl) never reach here."""
	digest = hashlib.sha1(Path(abs_path).read_bytes()).hexdigest()[:16]
	if digest in mdl_dirs:
	stats["deduped"] += 1
	return mdl_dirs[digest]
	mdl_name = os.path.basename(abs_path)
	dest_dir = OUT_DIR / f"resource/mdl_{digest}"
	dest_dir.mkdir(parents=True, exist_ok=True)
	shutil.copy2(abs_path, dest_dir / mdl_name)
	stats["copied"] += 1
	src_mdl_dir = os.path.dirname(abs_path)
	text = Path(abs_path).read_text(errors="replace")
	for ref in set(re.findall(r'"([^"]+\.(?:png\|jpg\|jpeg\|tga\|hdr\|exr))"', text, re.IGNORECASE)):
	ref_norm = ref.lstrip("./")
	if ref_norm.startswith("..") or os.path.isabs(ref):
	print(f" WARNING: mdl ref escapes its folder, skipped: {mdl_name}: {ref}")
	continue
	tiles = [ref_norm]
	if "<UDIM>" in ref_norm:
	pattern = os.path.basename(ref_norm).replace("<UDIM>", "[0-9][0-9][0-9][0-9]")
	folder = Path(src_mdl_dir) / os.path.dirname(ref_norm)
	tiles = [os.path.join(os.path.dirname(ref_norm), t.name) for t in sorted(folder.glob(pattern))]
	for tile in tiles:
	src_tex = os.path.normpath(os.path.join(src_mdl_dir, tile))
	if not os.path.exists(src_tex):
	# The dataset's MDLs are sloppy about case/subfolders
	# ("Textures/foo.png" vs "textures/Chrome_A/foo.png");
	# Omniverse's MDL resolver tolerates it, so fall back to a
	# by-name search under the MDL's own folder and copy the
	# hit to the path the MDL actually references.
	candidates = sorted(Path(src_mdl_dir).rglob(os.path.basename(tile)))
	if candidates:
	src_tex = str(candidates[0])
	else:
	# This MDL copy has no textures nearby at all; take
	# the same-named file from anywhere in the dataset.
	src_tex = find_texture_anywhere(os.path.basename(tile))
	if src_tex is None:
	stats["missing"].append(f"{mdl_name}: {tile}")
	continue
	dst_tex = dest_dir / tile
	dst_tex.parent.mkdir(parents=True, exist_ok=True)
	if not dst_tex.exists():
	shutil.copy2(src_tex, dst_tex)
	rel_class[f"resource/mdl_{digest}/{tile}"] = classify(abs_path)
	stats["copied"] += 1
	rel = f"resource/mdl_{digest}/{mdl_name}"
	mdl_dirs[digest] = rel
	return rel

	def rewrite(path):
	if not path:
	return path
	if path.startswith(("omniverse://", "http")) or "/" not in path:
	# unreachable server paths and bare shader names (OmniPBR.mdl):
	# leave as authored.
	stats["external"] += 1
	return path
	abs_path = path if os.path.isabs(path) else os.path.normpath(str(src_dir / path))
	if abs_path.endswith(".mdl"):
	if not os.path.exists(abs_path):
	stats["missing"].append(path)
	return path
	return "./" + copy_mdl(abs_path)
	name = os.path.basename(abs_path)
	if "<UDIM>" in name:
	# expand tiles: copy each 4-digit tile under a shared hint so the
	# rewritten pattern resolves to all of them.
	folder = Path(os.path.dirname(abs_path))
	tiles = sorted(folder.glob(name.replace("<UDIM>", "[0-9][0-9][0-9][0-9]")))
	if not tiles:
	stats["missing"].append(path)
	return path
	hint = name.replace("<UDIM>", "UDIM")
	digest = hashlib.sha1(("udim:" + abs_path).encode()).hexdigest()[:16]
	for tile in tiles:
	tile_no = tile.name[len(name.split("<UDIM>")[0]):][:4]
	tile_rel = f"resource/{digest}_{hint.replace('UDIM', tile_no)}"
	dst = OUT_DIR / tile_rel
	if not dst.exists():
	shutil.copy2(tile, dst)
	rel_class[tile_rel] = classify(str(tile))
	stats["copied"] += 1
	return f"./resource/{digest}_{hint.replace('UDIM', '<UDIM>')}"
	if not os.path.exists(abs_path):
	stats["missing"].append(path)
	return path
	return "./" + copy_one(abs_path, name)

	UsdUtils.ModifyAssetPaths(layer, rewrite)
	layer.Save()
	print(f" copied {stats['copied']} files ({stats['deduped']} duplicate refs), "
	f"{stats['external']} left external")
	if stats["missing"]:
	print(f" WARNING missing: {stats['missing']}")

	# Classification for the downscale pass: a file is a PROP texture if ANY
	# of its source paths lived under /Props/, else building shell.
	with open(MANIFEST, "w") as mf:
	for rel, cls in sorted(rel_class.items()):
	mf.write(f"{rel}\t{cls}\n")

	print("[3/3] Downscaling textures with system python3 + PIL...")
	downscale = subprocess.run(
	[sys.executable if "isaac" not in sys.executable else "python3",
	str(SCRIPT_DIR / "_downscale_textures.py"), str(OUT_DIR),
	str(SHELL_MAX_PX), str(PROP_MAX_PX)],
	capture_output=True, text=True,
	)
	print(downscale.stdout)
	if downscale.returncode != 0:
	print(downscale.stderr)
	raise SystemExit("texture downscale failed")

	total = sum(f.stat().st_size for f in OUT_DIR.rglob("*") if f.is_file())
	print(f"DONE: package total {total / 1e6:.1f} MB at {OUT_DIR}")


	if __name__ == "__main__":
	main()