Update

.gitignore

@@ -1 +1,3 @@
-results
+__pycache__
+results
+src/

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "scenediffuser"]
+	path = scenediffuser
+	url = https://github.com/scenediffuser/Scene-Diffuser

app.py

@@ -1,160 +1,104 @@
 import os
+import sys
+sys.path.append('./scenediffuser/')
 import gradio as gr
-import random
-import pickle
-import numpy as np
-import zipfile
-import trimesh
-from PIL import Image
-from huggingface_hub import hf_hub_download
 
-def pose_generation(scene, count):
-    assert isinstance(scene, str)
-    results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/pose_generation/results.pkl')
-    with open(results_path, 'rb') as f:
-        results = pickle.load(f)
-    
-    images = [Image.fromarray(results[scene][random.randint(0, 19)]) for i in range(count)]
-    return images
+import interface as IF
 
-def pose_generation_mesh(scene, count):
-    assert isinstance(scene, str)
-    scene_path = f"./results/pose_generation/mesh_results/{scene}/scene_downsample.ply"
-    if not os.path.exists(scene_path):
-        results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/pose_generation/mesh_results.zip')
-        os.makedirs('./results/pose_generation/', exist_ok=True)
-        with zipfile.ZipFile(results_path, 'r') as zip_ref:
-            zip_ref.extractall('./results/pose_generation/')
-    
-    res = './results/pose_generation/tmp.glb'
-    S = trimesh.Scene()
-    S.add_geometry(trimesh.load(scene_path))
-    for i in range(count):
-        rid = random.randint(0, 19)
-        S.add_geometry(trimesh.load(
-            f"./results/pose_generation/mesh_results/{scene}/body{rid:0>3d}.ply"
-        ))
-    S.export(res)
-    
-    return res
+with gr.Blocks(css='style.css') as demo:
+    with gr.Column(elem_id="col-container"):
+        gr.Markdown("<p align='center' style='font-size: 1.5em;'>Diffusion-based Generation, Optimization, and Planning in 3D Scenes</p>")
+        gr.HTML(value="<img src='file/figures/teaser.png' alt='Teaser' width='710px' height='284px' style='display: block; margin: auto;'>")
+        gr.HTML(value="<p align='center' style='font-size: 1.2em; color: #485fc7;'><a href='https://arxiv.org/abs/2301.06015' target='_blank'>arXiv</a> | <a href='https://scenediffuser.github.io/' target='_blank'>Project Page</a> | <a href='https://github.com/scenediffuser/Scene-Diffuser' target='_blank'>Code</a></p>")
+        gr.Markdown("<p align='center'><i>\"SceneDiffuser provides a unified model for solving scene-conditioned generation, optimization, and planning.\"</i></p>")
 
-def motion_generation(scene):
-    assert isinstance(scene, str)
-    cnt = {
-        'MPH1Library': 3,
-        'MPH16': 6,
-        'N0SittingBooth': 7,
-        'N3OpenArea': 5
-    }[scene]
+        ## five task
+        ## pose generation
+        with gr.Tab("Pose Generation"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    selector1 = gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes', value='MPH16', interactive=True)
+                    with gr.Row():
+                        sample1 = gr.Slider(minimum=1, maximum=8, step=1, label='Count', interactive=True, value=1)
+                        seed1 = gr.Slider(minimum=0, maximum=2 ** 16, step=1, label='Seed', interactive=True, value=2023)
+                    opt1 = gr.Checkbox(label='Optimizer Guidance', interactive=True, value=True)
+                    scale1 = gr.Slider(minimum=0.1, maximum=9.9, step=0.1, label='Scale', interactive=True, value=1.1)
+                    button1 = gr.Button("Run")
+                with gr.Column(scale=3):
+                    image1 = gr.Gallery(label="Image [Result]").style(grid=[1], height="50")
+                    # model1 = gr.Model3D(clear_color=[255, 255, 255, 255], label="3D Model [Result]")
+        input1 = [selector1, sample1, seed1, opt1, scale1]
+        button1.click(IF.pose_generation, inputs=input1, outputs=[image1])
 
-    res = f"./results/motion_generation/results/{scene}/{random.randint(0, cnt-1)}.gif"
-    if not os.path.exists(res):
-        results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/motion_generation/results.zip')
-        os.makedirs('./results/motion_generation/', exist_ok=True)
-        with zipfile.ZipFile(results_path, 'r') as zip_ref:
-            zip_ref.extractall('./results/motion_generation/')
-    
-    return res
+        ## motion generation
+        # with gr.Tab("Motion Generation"):
+        #     with gr.Row():
+        #         with gr.Column(scale=2):
+        #             selector2 = gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes', value='MPH16', interactive=True)
+        #             with gr.Row():
+        #                 sample2 = gr.Slider(minimum=1, maximum=8, step=1, label='Count', interactive=True, value=1)
+        #                 seed2 = gr.Slider(minimum=0, maximum=2 ** 16, step=1, label='Seed', interactive=True, value=2023)
+        #             with gr.Row():
+        #                 withstart = gr.Checkbox(label='With Start', interactive=True, value=False)
+        #             opt2 = gr.Checkbox(label='Optimizer Guidance', interactive=True, value=True)
+        #             scale_opt2 = gr.Slider(minimum=0.1, maximum=9.9, step=0.1, label='Scale', interactive=True, value=1.1)
+        #             button2 = gr.Button("Run")
+        #         with gr.Column(scale=3):
+        #             image2 = gr.Image(label="Result")
+        # input2 = [selector2, sample2, seed2, withstart, opt2, scale_opt2]
+        # button2.click(IF.motion_generation, inputs=input2, outputs=image2)
+        with gr.Tab("Motion Generation"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    input2 = [
+                        gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes')
+                    ]
+                    button2 = gr.Button("Generate")
+                    gr.HTML("<p style='font-size: 0.9em; color: #555555;'>Notes: the output results are pre-sampled results. We will deploy a real-time model for this task soon.</p>")
+                with gr.Column(scale=3):
+                    output2 = gr.Image(label="Result")
+        button2.click(IF.motion_generation, inputs=input2, outputs=output2)
+        
+        ## grasp generation
+        with gr.Tab("Grasp Generation"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    input3 = [
+                        gr.Dropdown(choices=['contactdb+apple', 'contactdb+camera', 'contactdb+cylinder_medium', 'contactdb+door_knob', 'contactdb+rubber_duck', 'contactdb+water_bottle', 'ycb+baseball', 'ycb+pear', 'ycb+potted_meat_can', 'ycb+tomato_soup_can'], label='Objects')
+                    ]
+                    button3 = gr.Button("Run")
+                    gr.HTML("<p style='font-size: 0.9em; color: #555555;'>Notes: the output results are pre-sampled results. We will deploy a real-time model for this task soon.</p>")
+                with gr.Column(scale=3):
+                    output3 = [
+                        gr.Model3D(clear_color=[255, 255, 255, 255], label="Result")
+                    ]
+        button3.click(IF.grasp_generation, inputs=input3, outputs=output3)
+        
+        ## path planning
+        with gr.Tab("Path Planing"):
+            with gr.Row():
+                with gr.Column(scale=2):
+                    selector4 = gr.Dropdown(choices=['scene0603_00', 'scene0621_00', 'scene0626_00', 'scene0634_00', 'scene0637_00', 'scene0640_00', 'scene0641_00', 'scene0645_00', 'scene0653_00', 'scene0667_00', 'scene0672_00', 'scene0673_00', 'scene0678_00', 'scene0694_00', 'scene0698_00'], label='Scenes', value='scene0621_00', interactive=True)
+                    mode4 = gr.Radio(choices=['Sampling', 'Planning'], value='Sampling', label='Mode', interactive=True)
+                    with gr.Row():
+                        sample4 = gr.Slider(minimum=1, maximum=8, step=1, label='Count', interactive=True, value=1)
+                        seed4 = gr.Slider(minimum=0, maximum=2 ** 16, step=1, label='Seed', interactive=True, value=2023)
+                    with gr.Box():
+                        opt4 = gr.Checkbox(label='Optimizer Guidance', interactive=True, value=True)
+                        scale_opt4 = gr.Slider(minimum=0.02, maximum=4.98, step=0.02, label='Scale', interactive=True, value=1.0)
+                    with gr.Box():
+                        pla4 = gr.Checkbox(label='Planner Guidance', interactive=True, value=True)
+                        scale_pla4 = gr.Slider(minimum=0.02, maximum=0.98, step=0.02, label='Scale', interactive=True, value=0.2)
+                    button4 = gr.Button("Run")
+                with gr.Column(scale=3):
+                    image4 = gr.Gallery(label="Image [Result]").style(grid=[1], height="50")
+                    number4 = gr.Number(label="Steps", precision=0)
+                    gr.HTML("<p style='font-size: 0.9em; color: #555555;'>Notes: 1. It may take a long time to do planning in <b>Planning</b> mode. 2. The <span style='color: #cc0000;'>red</span> balls represent the planning result, starting with the lightest red ball and ending with the darkest red ball. The <span style='color: #00cc00;'>green</span> ball indicates the target position.</p>")
+        input4 = [selector4, mode4, sample4, seed4, opt4, scale_opt4, pla4, scale_pla4]
+        button4.click(IF.path_planning, inputs=input4, outputs=[image4, number4])
 
-def grasp_generation(case_id):
-    assert isinstance(case_id, str)
-    res = f"./results/grasp_generation/results/{case_id}/{random.randint(0, 19)}.glb"
-    if not os.path.exists(res):
-        results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/grasp_generation/results.zip')
-        os.makedirs('./results/grasp_generation/', exist_ok=True)
-        with zipfile.ZipFile(results_path, 'r') as zip_ref:
-            zip_ref.extractall('./results/grasp_generation/')
-    
-    return res
+        ## arm motion planning
+        with gr.Tab("Arm Motion Planning"):
+            gr.Markdown('Coming soon!')
 
-def path_planning(case_id):
-    assert isinstance(case_id, str)
-    results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/path_planning/results.pkl')
-    with open(results_path, 'rb') as f:
-        results = pickle.load(f)
-
-    case = results[case_id]
-    steps = case['step']
-    image = Image.fromarray(case['image'])
-    return image, steps
-
-with gr.Blocks() as demo:
-    gr.Markdown("# **<p align='center'>Diffusion-based Generation, Optimization, and Planning in 3D Scenes</p>**")
-    gr.HTML(value="<img src='file/figures/teaser.png' alt='Teaser' width='710px' height='284px' style='display: block; margin: auto;'>")
-    gr.HTML(value="<p align='center' style='font-size: 1.25em; color: #485fc7;'><a href='' target='_blank'>Paper</a> | <a href='' target='_blank'>Project Page</a> | <a href='' target='_blank'>Github</a></p>")
-    gr.Markdown("<p align='center'><i>\"SceneDiffuser provides a unified model for solving scene-conditioned generation, optimization, and planning.\"</i></p>")
-
-    ## five task
-    ## pose generation
-    with gr.Tab("Pose Generation"):
-        with gr.Row():
-            with gr.Column():
-                input1 = [
-                    gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes'),
-                    gr.Slider(minimum=1, maximum=4, step=1, label='Count', interactive=True)
-                ]
-                button1 = gr.Button("Generate")
-            with gr.Column():
-                output1 = [
-                    gr.Gallery(label="Result").style(grid=[1], height="auto")
-                ]
-    button1.click(pose_generation, inputs=input1, outputs=output1)
-
-    with gr.Tab("Pose Generation Mesh"):
-        input11 = [
-            gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes'),
-            gr.Slider(minimum=1, maximum=4, step=1, label='Count', interactive=True)
-        ]
-        button11 = gr.Button("Generate")
-        output11 = gr.Model3D(clear_color=[255, 255, 255, 255], label="Result")
-    button11.click(pose_generation_mesh, inputs=input11, outputs=output11)
-
-    ## motion generation
-    with gr.Tab("Motion Generation"):
-        with gr.Row():
-            with gr.Column():
-                input2 = [
-                    gr.Dropdown(choices=['MPH16', 'MPH1Library', 'N0SittingBooth', 'N3OpenArea'], label='Scenes')
-                ]
-                button2 = gr.Button("Generate")
-            with gr.Column():
-                output2 = gr.Image(label="Result")
-    button2.click(motion_generation, inputs=input2, outputs=output2)
-    
-    ## grasp generation
-    with gr.Tab("Grasp Generation"):
-        with gr.Row():
-            with gr.Column():
-                input3 = [
-                    gr.Dropdown(choices=['contactdb+apple', 'contactdb+camera', 'contactdb+cylinder_medium', 'contactdb+door_knob', 'contactdb+rubber_duck', 'contactdb+water_bottle', 'ycb+baseball', 'ycb+pear', 'ycb+potted_meat_can', 'ycb+tomato_soup_can'], label='Objects')
-                ]
-                button3 = gr.Button("Run")
-            with gr.Column():
-                output3 = [
-                    gr.Model3D(clear_color=[255, 255, 255, 255], label="Result")
-                ]
-    button3.click(grasp_generation, inputs=input3, outputs=output3)
-    
-    ## path planning
-    with gr.Tab("Path Planing"):
-        with gr.Row():
-            with gr.Column():
-                input4 = [
-                    gr.Dropdown(choices=['scene0603_00_N0pT', 'scene0621_00_cJ4H', 'scene0634_00_48Y3', 'scene0634_00_gIRH', 'scene0637_00_YgjR', 'scene0640_00_BO94', 'scene0641_00_3K6J', 'scene0641_00_KBKx', 'scene0641_00_cb7l', 'scene0645_00_35Hy', 'scene0645_00_47D1', 'scene0645_00_XfLE', 'scene0667_00_DK4F', 'scene0667_00_o7XB', 'scene0667_00_rUMp', 'scene0672_00_U250', 'scene0673_00_Jyw8', 'scene0673_00_u1lJ', 'scene0678_00_QbNL', 'scene0678_00_RrY0', 'scene0678_00_aE1p', 'scene0678_00_hnXu', 'scene0694_00_DgAL', 'scene0694_00_etF5', 'scene0698_00_tT3Q'], label='Scenes'),
-                ]
-                button4 = gr.Button("Run")
-            with gr.Column():
-                # output4 = gr.Gallery(label="Result").style(grid=[1], height="auto")
-                output4 = [
-                    gr.Image(label="Result"),
-                    gr.Number(label="Steps", precision=0)
-                ]
-    button4.click(path_planning, inputs=input4, outputs=output4)
-
-    ## arm motion planning
-    with gr.Tab("Arm Motion Planning"):
-        gr.Markdown('Coming soon!')
-
-    gr.Markdown("<p>Note: Currently, the output results are pre-sampled results. We will deploy a real-time model after we release the code.</p>")
-    
-demo.launch()
+demo.launch()

interface.py

@@ -0,0 +1,267 @@
+import os
+import random
+import torch
+import hydra
+import numpy as np
+import zipfile
+
+from typing import Any
+from hydra import compose, initialize
+from omegaconf import DictConfig, OmegaConf
+from huggingface_hub import hf_hub_download
+
+from utils.misc import compute_model_dim
+from datasets.base import create_dataset
+from datasets.misc import collate_fn_general, collate_fn_squeeze_pcd_batch
+from models.base import create_model
+from models.visualizer import create_visualizer
+from models.environment import create_enviroment
+
+def pretrain_pointtrans_weight_path():
+    return hf_hub_download('SceneDiffuser/SceneDiffuser', 'weights/POINTTRANS_C_32768/model.pth')
+
+def model_weight_path(task, has_observation=False):
+    if task == 'pose_gen':
+        return hf_hub_download('SceneDiffuser/SceneDiffuser', 'weights/2022-11-09_11-22-52_PoseGen_ddm4_lr1e-4_ep100/ckpts/model.pth')
+    elif task == 'motion_gen' and has_observation == True:
+        return hf_hub_download('SceneDiffuser/SceneDiffuser', 'weights//ckpts/model.pth')
+    elif task == 'motion_gen' and has_observation == False:
+        return hf_hub_download('SceneDiffuser/SceneDiffuser', 'weights//ckpts/model.pth')
+    elif task == 'path_planning':
+        return hf_hub_download('SceneDiffuser/SceneDiffuser', 'weights/2022-11-25_20-57-28_Path_ddm4_LR1e-4_E100_REL/ckpts/model.pth')
+    else:
+        raise Exception('Unexcepted task.')
+
+def pose_motion_data_path():
+    zip_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'hf_data/pose_motion.zip')
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(os.path.dirname(zip_path))
+    
+    rpath = os.path.join(os.path.dirname(zip_path), 'pose_motion')
+
+    return (
+        os.path.join(rpath, 'PROXD_temp'),
+        os.path.join(rpath, 'models_smplx_v1_1/models/'),
+        os.path.join(rpath, 'PROX'),
+        os.path.join(rpath, 'PROX/V02_05')
+    )
+
+def path_planning_data_path():
+    zip_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'hf_data/path_planning.zip')
+    with zipfile.ZipFile(zip_path, 'r') as zip_ref:
+        zip_ref.extractall(os.path.dirname(zip_path))
+    
+    return os.path.join(os.path.dirname(zip_path), 'path_planning')
+
+def load_ckpt(model: torch.nn.Module, path: str) -> None:
+    """ load ckpt for current model
+
+    Args:
+        model: current model
+        path: save path
+    """
+    assert os.path.exists(path), 'Can\'t find provided ckpt.'
+
+    saved_state_dict = torch.load(path)['model']
+    model_state_dict = model.state_dict()
+
+    for key in model_state_dict:
+        if key in saved_state_dict:
+            model_state_dict[key] = saved_state_dict[key]
+        ## model is trained with ddm
+        if 'module.'+key in saved_state_dict:
+            model_state_dict[key] = saved_state_dict['module.'+key]
+    
+    model.load_state_dict(model_state_dict)
+
+def _sampling(cfg: DictConfig, scene: str) -> Any:
+    ## compute modeling dimension according to task
+    cfg.model.d_x = compute_model_dim(cfg.task)
+    
+    if cfg.gpu is not None:
+        device = f'cuda:{cfg.gpu}'
+    else:
+        device = 'cpu'
+    
+    dataset = create_dataset(cfg.task.dataset, 'test', cfg.slurm, case_only=True, specific_scene=scene)
+    
+    if cfg.model.scene_model.name == 'PointTransformer':
+        collate_fn = collate_fn_squeeze_pcd_batch
+    else:
+        collate_fn = collate_fn_general
+    
+    dataloader = dataset.get_dataloader(
+        batch_size=1,
+        collate_fn=collate_fn,
+        shuffle=True,
+    )
+    
+    ## create model and load ckpt
+    model = create_model(cfg, slurm=cfg.slurm, device=device)
+    model.to(device=device)
+    load_ckpt(model, path=model_weight_path(cfg.task.name, cfg.task.has_observation if 'has_observation' in cfg.task else False))
+    
+    ## create visualizer and visualize
+    visualizer = create_visualizer(cfg.task.visualizer)
+    results = visualizer.visualize(model, dataloader)
+    return results
+
+def _planning(cfg: DictConfig, scene: str) -> Any:
+    ## compute modeling dimension according to task
+    cfg.model.d_x = compute_model_dim(cfg.task)
+    
+    if cfg.gpu is not None:
+        device = f'cuda:{cfg.gpu}'
+    else:
+        device = 'cpu'
+    
+    dataset = create_dataset(cfg.task.dataset, 'test', cfg.slurm, case_only=True, specific_scene=scene)
+    
+    if cfg.model.scene_model.name == 'PointTransformer':
+        collate_fn = collate_fn_squeeze_pcd_batch
+    else:
+        collate_fn = collate_fn_general
+    
+    dataloader = dataset.get_dataloader(
+        batch_size=1,
+        collate_fn=collate_fn,
+        shuffle=True,
+    )
+    
+    ## create model and load ckpt
+    model = create_model(cfg, slurm=cfg.slurm, device=device)
+    model.to(device=device)
+    load_ckpt(model, path=model_weight_path(cfg.task.name, cfg.task.has_observation if 'has_observation' in cfg.task else False))
+    
+    ## create environment for planning task and run
+    env = create_enviroment(cfg.task.env)
+    results = env.run(model, dataloader)
+    return results
+
+
+## interface for five task
+## real-time model: pose generation, path planning
+def pose_generation(scene, count, seed, opt, scale) -> Any:
+    scene_model_weight_path = pretrain_pointtrans_weight_path()
+    data_dir, smpl_dir, prox_dir, vposer_dir = pose_motion_data_path()
+    override_config = [
+        "diffuser=ddpm",
+        "model=unet",
+        f"model.scene_model.pretrained_weights={scene_model_weight_path}",
+        "task=pose_gen",
+        "task.visualizer.name=PoseGenVisualizerHF",
+        f"task.visualizer.ksample={count}",
+        f"task.dataset.data_dir={data_dir}",
+        f"task.dataset.smpl_dir={smpl_dir}",
+        f"task.dataset.prox_dir={prox_dir}",
+        f"task.dataset.vposer_dir={vposer_dir}",
+    ]
+
+    if opt == True:
+        override_config += [
+            "optimizer=pose_in_scene",
+            "optimizer.scale_type=div_var",
+            f"optimizer.scale={scale}",
+            "optimizer.vposer=false",
+            "optimizer.contact_weight=0.02",
+            "optimizer.collision_weight=1.0"
+        ]
+    
+    initialize(config_path="./scenediffuser/configs", version_base=None)
+    config = compose(config_name="default", overrides=override_config)
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+    res = _sampling(config, scene)
+
+    hydra.core.global_hydra.GlobalHydra.instance().clear()
+    return res
+
+def motion_generation(scene):
+    assert isinstance(scene, str)
+    cnt = {
+        'MPH1Library': 3,
+        'MPH16': 6,
+        'N0SittingBooth': 7,
+        'N3OpenArea': 5
+    }[scene]
+
+    res = f"./results/motion_generation/results/{scene}/{random.randint(0, cnt-1)}.gif"
+    if not os.path.exists(res):
+        results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/motion_generation/results.zip')
+        os.makedirs('./results/motion_generation/', exist_ok=True)
+        with zipfile.ZipFile(results_path, 'r') as zip_ref:
+            zip_ref.extractall('./results/motion_generation/')
+    
+    return res
+
+def grasp_generation(case_id):
+    assert isinstance(case_id, str)
+    res = f"./results/grasp_generation/results/{case_id}/{random.randint(0, 19)}.glb"
+    if not os.path.exists(res):
+        results_path = hf_hub_download('SceneDiffuser/SceneDiffuser', 'results/grasp_generation/results.zip')
+        os.makedirs('./results/grasp_generation/', exist_ok=True)
+        with zipfile.ZipFile(results_path, 'r') as zip_ref:
+            zip_ref.extractall('./results/grasp_generation/')
+    
+    return res
+
+def path_planning(scene, mode, count, seed, opt, scale_opt, pla, scale_pla):
+
+    scene_model_weight_path = pretrain_pointtrans_weight_path()
+    data_dir = path_planning_data_path()
+
+    override_config = [
+        "diffuser=ddpm",
+        "model=unet",
+        "model.use_position_embedding=true",
+        f"model.scene_model.pretrained_weights={scene_model_weight_path}",
+        "task=path_planning",
+        "task.visualizer.name=PathPlanningRenderingVisualizerHF",
+        f"task.visualizer.ksample={count}",
+        f"task.dataset.data_dir={data_dir}",
+        "task.dataset.repr_type=relative",
+        "task.env.name=PathPlanningEnvWrapperHF",
+        "task.env.inpainting_horizon=16",
+        "task.env.robot_top=3.0",
+        "task.env.env_adaption=false"
+    ]
+
+    if opt == True:
+        override_config += [
+            "optimizer=path_in_scene",
+            "optimizer.scale_type=div_var",
+            "optimizer.continuity=false",
+            f"optimizer.scale={scale_opt}",
+        ]
+    if pla == True:
+        override_config += [
+            "planner=greedy_path_planning",
+            f"planner.scale={scale_pla}",
+            "planner.scale_type=div_var",
+            "planner.greedy_type=all_frame_exp"
+        ]
+    
+    initialize(config_path="./scenediffuser/configs", version_base=None)
+    config = compose(config_name="default", overrides=override_config)
+
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+
+    if mode == 'Sampling':
+        img = _sampling(config, scene)
+        res = (img, 0)
+    elif mode == 'Planning':
+        res = _planning(config, scene)
+    else:
+        res = (None, 0)
+
+    hydra.core.global_hydra.GlobalHydra.instance().clear()
+    return res

scenediffuser

@@ -0,0 +1 @@
+Subproject commit 2e6055e4aba5807f8ff81b5eaa4b171b93306067

style.css

@@ -0,0 +1 @@
+#col-container {max-width: 1000px; margin-left: auto; margin-right: auto;}