Add files using upload-large-folder tool

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/configs/config_history.yaml

@@ -0,0 +1,107 @@
+#root_dir: '/home/ladmin/Documents/maniskill2_benchmark'
+root_dir: '/home/xuan/Code/maniskill2_benchmark'
+hydra:
+  run:    
+    dir: '${root_dir}/logs/${now:%Y-%m-%d}/${now:%H-%M-%S}'
+    
+# General settings
+trajectory_length: 32
+state_dim: 9
+
+# Device and debug settings
+device: 'cuda'
+debug: false
+
+# Mandatory settings
+seed: 11
+# results_dir: '${root_dir}/saved_models/${now:%m.%d-%H:%M}-seed${seed}'
+results_dir: '${root_dir}/saved_models/${now:%m.%d-%H.%M}_traj${trajectory_length}'
+batch_size: 256
+
+observation_wrapper: 'ObservationWrapperWithHistory'
+
+# Dataset
+dataset:
+  _target_: 'cfdp.datasets.maniskill2_trajectory.ManiSkill2TrajectoryWithHistory'
+  # dataset_file: '/mnt/Dataset/shelf_data.h5'
+  dataset_file: '/mnt/Dataset/full_cover.h5'
+  obs_keys: ['tcp_pose']
+  normalizer: 'LimitsNormalizer'
+  pcd: false
+  choice: 'interpolate'
+  pad_front: false
+  trajectory_length: ${trajectory_length}
+  history_length: 8
+  force_reload: false
+  load_count: -1
+  device: ${device}
+  stride: 2
+  verbose: false 
+
+val_set_size: 0.2
+
+model:
+  # Diffusion Model
+  model_class: 'GaussianDiffusionModel'
+  variance_schedule: 'exponential' # 'cosine', 'exponential'
+  n_steps: 25
+  prediction_mode: "epsilon"
+  use_ddim: false
+  # Unet
+  unet_dim_mults_option: 1
+  unet_input_dim: 64
+  conditioning_type: 'attention'
+  conditioning_embed_dim: 32
+  # Conext model
+  context_input_dim: ${multiply:10,${state_dim}}
+# Loss
+loss:
+  loss_class: 'GaussianDiffusionLoss'
+
+# Training parameters
+training:
+  lr: 1e-4
+  num_steps: 60000
+  use_ema: true
+  use_amp: false
+  steps_til_summary: 2000
+  steps_til_ckpt: 2000
+  summary_class: 'SummaryTrajectoryGeneration'
+
+# Inference settings
+inference:
+  env_id: 'ShelfPick-v0'
+  obs_mode: 'image'
+  control_mode: 'pd_ee_delta_pose_align'
+  reward_mode: 'dense'
+  use_ddim: true
+  robot_noise: 0.5
+  evaluate: false
+  model_dir: '${root_dir}/saved_models/05.11-15.57_traj${trajectory_length}'
+  use_ema: true
+  episodes: 100
+  replanning_interval: 4
+  n_samples: 30
+  n_diffusion_steps_without_noise: 0
+  index: 20
+  timestep: 5
+  sample_fn:
+    n_guide_steps: 4
+    t_start_guide: 5
+    noise_std_extra_schedule_fn: 0.5
+  validation_set_only: false
+  sim_with_history: true
+  camera_type: 'world'
+  guidance_weight: 0.175
+
+test:
+  inference_record: false # record obs, trajectory, step_info
+  recording_dir: '${root_dir}/inference_recordings/'
+  replay_dir: '${root_dir}/inference_recordings/concept_test_guidance'
+  # replay_dir: '${root_dir}/inference_recordings/recording_0421_2145'
+# WandB settings
+wandb:
+  enabled: true
+  mode: 'offline'
+  entity: 'xuanz_test'
+  project: 'simple test'

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/configs/config_history_ddim.yaml

@@ -0,0 +1,115 @@
+#root_dir: '/home/ladmin/Documents/maniskill2_benchmark'
+# root_dir: '/home/xuan/Code/maniskill2_benchmark'
+root_dir: '/home/xuan/Project/ManiSkill3/src'
+
+hydra:
+  run:    
+    dir: '${root_dir}/logs/${now:%Y-%m-%d}/${now:%H-%M-%S}'
+    
+# General settings
+trajectory_length: 32
+state_dim: 9
+
+# Device and debug settings
+device: 'cuda'
+debug: false
+
+# Mandatory settings
+seed: 11
+# results_dir: '${root_dir}/saved_models/${now:%m.%d-%H:%M}-seed${seed}'
+results_dir: '${root_dir}/saved_models/${now:%m.%d-%H.%M}_traj${trajectory_length}'
+batch_size: 256
+
+observation_wrapper: 'ObservationWrapperWithHistory'
+use_ee_control: true
+
+# Dataset
+dataset:
+  _target_: 'cfdp.datasets.maniskill2_trajectory.ManiSkill2TrajectoryWithHistory'
+  # dataset_file: '/mnt/Dataset/shelf_data.h5'
+  # dataset_file: '/mnt/Dataset/full_cover.h5'
+  dataset_file: '/mnt/Dataset/bowl_120_split.h5'
+  obs_keys: ['tcp_pose']
+  normalizer: 'LimitsNormalizer'
+  pcd: false
+  choice: 'interpolate'
+  pad_front: false
+  trajectory_length: ${trajectory_length}
+  history_length: 8
+  force_reload: false
+  load_count: -1
+  device: ${device}
+  stride: 2
+  verbose: false 
+
+val_set_size: 0.2
+
+model:
+  # Diffusion Model
+  model_class: 'GaussianDiffusionModel'
+  variance_schedule: 'cosine' # 'cosine', 'exponential'
+  n_steps: 25
+  prediction_mode: "v"
+  use_ddim: true
+  use_snr_weight: true
+  # Unet
+  unet_dim_mults_option: 1
+  unet_input_dim: 64
+  conditioning_type: 'attention'
+  conditioning_embed_dim: 32
+  # Conext model
+  context_input_dim: ${multiply:10,${state_dim}}
+# Loss
+loss:
+  loss_class: 'GaussianDiffusionLoss'
+
+# Training parameters
+training:
+  lr: 1e-4
+  num_steps: 100000
+  use_ema: true
+  use_amp: false
+  steps_til_summary: 2000
+  steps_til_ckpt: 2000
+  summary_class: 'SummaryTrajectoryGeneration'
+
+# Inference settings
+inference:
+  env_id: 'ShelfPick-v0'
+  obs_mode: 'image'
+  control_mode: 'pd_ee_delta_pose_align'
+  reward_mode: 'dense'
+  use_ddim: true
+  robot_noise: 0.5
+  evaluate: false
+  # model_dir: '${root_dir}/saved_models/08.17-15.43_traj${trajectory_length}' #all data
+  # model_dir: '${root_dir}/saved_models/07.28-14.55_traj${trajectory_length}' #shelf data
+  model_dir: '${root_dir}/saved_models/09.01-17.55_traj${trajectory_length}' #bowl 120 data
+  use_ema: true
+  episodes: 100
+  replanning_interval: 30
+  n_samples: 8
+  n_diffusion_steps_without_noise: 0
+  index: 20
+  timestep: 5
+  sample_fn:
+    n_guide_steps: 2
+    t_start_guide: 5
+    noise_std_extra_schedule_fn: 0.5
+  validation_set_only: false
+  sim_with_history: true
+  # camera_type: 'hand_camera'
+  camera_type: 'world'
+  guidance_weight: 1.0
+
+test:
+  inference_record: false # record obs, trajectory, step_info
+  recording_dir: '${root_dir}/inference_recordings/'
+  replay_dir: '${root_dir}/inference_recordings/concept_test_guidance'
+  # replay_dir: '${root_dir}/inference_recordings/recording_0421_2145'
+# WandB settings
+wandb:
+  enabled: true
+  mode: 'offline'
+  entity: 'xuanz_test'
+  project: 'simple test'

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/configs/config_history_joint.yaml

@@ -0,0 +1,107 @@
+root_dir: '/home/ladmin/Documents/maniskill2_benchmark'
+# root_dir: '/home/rui/Documents/maniskill2_benchmark'
+# root_dir: '/home/xuan/Code/maniskill2_benchmark'
+hydra:
+  run:    
+    dir: '${root_dir}/logs/${now:%Y-%m-%d}/${now:%H-%M-%S}'
+    
+# General settings
+trajectory_length: 32
+state_dim: 9
+
+# Device and debug settings
+device: 'cuda'
+debug: true
+
+# Mandatory settings
+seed: 11
+# results_dir: '${root_dir}/saved_models/${now:%m.%d-%H:%M}-seed${seed}'
+results_dir: '${root_dir}/saved_models/${now:%m.%d-%H.%M}_traj${trajectory_length}'
+batch_size: 256
+
+observation_wrapper: 'ObservationWrapperWithHistory'
+use_ee_control: false
+
+# Dataset
+dataset:
+  _target_: 'cfdp.datasets.maniskill2_trajectory.ManiSkill2TrajectoryWithHistory'
+  dataset_file: '/home/ladmin/20250626_165939.h5'
+  obs_keys: ['qpos']
+  normalizer: 'LimitsNormalizer'
+  pcd: false
+  choice: 'interpolate'
+  pad_front: false
+  trajectory_length: ${trajectory_length}
+  history_length: 8
+  force_reload: false
+  load_count: -1
+  device: ${device}
+  stride: 2
+  verbose: true 
+
+val_set_size: 0.2
+
+model:
+  # Diffusion Model
+  model_class: 'GaussianDiffusionModel'
+  variance_schedule: 'exponential' # 'cosine', 'exponential'
+  n_steps: 25
+  prediction_mode: "epsilon"
+  # Unet
+  unet_dim_mults_option: 1
+  unet_input_dim: 64
+  conditioning_type: 'attention'
+  conditioning_embed_dim: 32
+  # Conext model
+  context_input_dim: ${multiply:10,${state_dim}}
+# Loss
+loss:
+  loss_class: 'GaussianDiffusionLoss'
+
+# Training parameters
+training:
+  lr: 1e-4
+  num_steps: 200000
+  use_ema: true
+  use_amp: false
+  steps_til_summary: 2000
+  steps_til_ckpt: 2000
+  summary_class: 'SummaryTrajectoryGeneration'
+
+# Inference settings
+inference:
+  env_id: 'ShelfPick-v0'
+  obs_mode: 'image'
+  control_mode: 'pd_joint_delta_pos'
+  reward_mode: 'dense'
+  robot_noise: 0.5
+  evaluate: false
+  model_dir: '/home/ladmin/Documents/maniskill2_benchmark/saved_models/06.27-17.15_traj32'
+  use_ema: true
+  use_ddim: false
+  episodes: 100
+  replanning_interval: 4
+  n_samples: 1
+  n_diffusion_steps_without_noise: 0
+  index: 20
+  timestep: 5
+  sample_fn:
+    n_guide_steps: 3
+    t_start_guide: 3
+    noise_std_extra_schedule_fn: 0.5
+  validation_set_only: false
+  sim_with_history: true
+  camera_type: 'world'
+  guidance_weight: 5.5
+
+test:
+  inference_record: false # record obs, trajectory, step_info
+  recording_dir: '${root_dir}/inference_recordings/'
+  replay_dir: '${root_dir}/inference_recordings/concept_test_guidance'
+  # replay_dir: '${root_dir}/inference_recordings/recording_0421_2145'
+# WandB settings
+wandb:
+  enabled: true
+  mode: 'offline'
+  entity: 'xuanz_test'
+  project: 'simple test'

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/configs/config_history_rui.yaml

@@ -0,0 +1,106 @@
+root_dir: '/home/rui/Documents/maniskill2_benchmark'
+# root_dir: '/home/xuan/Code/maniskill2_benchmark'
+hydra:
+  run:    
+    dir: '${root_dir}/logs/${now:%Y-%m-%d}/${now:%H-%M-%S}'
+    
+# General settings
+trajectory_length: 32
+state_dim: 9
+
+# Device and debug settings
+device: 'cuda'
+debug: true
+
+# Mandatory settings
+seed: 11
+# results_dir: '${root_dir}/saved_models/${now:%m.%d-%H:%M}-seed${seed}'
+results_dir: '${root_dir}/saved_models/${now:%m.%d-%H.%M}_traj${trajectory_length}'
+batch_size: 256
+
+observation_wrapper: 'ObservationWrapperWithHistory'
+
+# Dataset
+dataset:
+  _target_: 'cfdp.datasets.maniskill2_trajectory.ManiSkill2TrajectoryWithHistory'
+  dataset_file: '/home/rui/Documents/maniskill2_benchmark/cfdp/data/shelf_data.h5'
+  obs_keys: ['tcp_pose']
+  normalizer: 'LimitsNormalizer'
+  pcd: false
+  choice: 'interpolate'
+  pad_front: false
+  trajectory_length: ${trajectory_length}
+  history_length: 8
+  force_reload: false
+  load_count: -1
+  device: ${device}
+  stride: 2
+  verbose: false 
+
+val_set_size: 0.2
+
+model:
+  # Diffusion Model
+  model_class: 'GaussianDiffusionModel'
+  variance_schedule: 'exponential' # 'cosine', 'exponential'
+  n_steps: 25
+  prediction_mode: "epsilon"
+  use_ddim: false
+  # Unet
+  unet_dim_mults_option: 1
+  unet_input_dim: 64
+  conditioning_type: 'attention'
+  conditioning_embed_dim: 32
+  # Conext model
+  context_input_dim: ${multiply:10,${state_dim}}
+# Loss
+loss:
+  loss_class: 'GaussianDiffusionLoss'
+
+# Training parameters
+training:
+  lr: 1e-4
+  num_steps: 40000
+  use_ema: true
+  use_amp: false
+  steps_til_summary: 4000
+  steps_til_ckpt: 4000
+  summary_class: 'SummaryTrajectoryGeneration'
+
+# Inference settings
+inference:
+  env_id: 'ShelfPick-v0'
+  obs_mode: 'image'
+  control_mode: 'pd_ee_delta_pose_align'
+  reward_mode: 'dense'
+  robot_noise: 0.5
+  evaluate: false
+  model_dir: '${root_dir}/saved_models/05.11-15.57_traj${trajectory_length}'
+  use_ema: true
+  episodes: 100
+  replanning_interval: 4
+  n_samples: 30
+  n_diffusion_steps_without_noise: 0
+  index: 20
+  timestep: 5
+  sample_fn:
+    n_guide_steps: 4
+    t_start_guide: 5
+    noise_std_extra_schedule_fn: 0.5
+  validation_set_only: false
+  sim_with_history: true
+  camera_type: 'world'
+  guidance_weight: 0.2
+
+test:
+  inference_record: false # record obs, trajectory, step_info
+  recording_dir: '${root_dir}/inference_recordings/'
+  # replay_dir: '${root_dir}/inference_recordings/concept_test_guidance'
+  # replay_dir: '${root_dir}/inference_recordings/small_box'
+  replay_dir: '${root_dir}/inference_recordings/recording_0421_2107'
+# WandB settings
+wandb:
+  enabled: true
+  mode: 'online'
+  entity: 'xuanz_test'
+  project: 'simple test'

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/configs/config_ms3_history_ddim.yaml

@@ -0,0 +1,121 @@
+#root_dir: '/home/ladmin/Documents/maniskill2_benchmark'
+# root_dir: '/home/xuan/Code/maniskill2_benchmark'
+root_dir: '/home/kyber/charles/project/ManiSkill3/src/maniskill2_benchmark'
+
+hydra:
+  run:    
+    dir: '${root_dir}/logs/${now:%Y-%m-%d}/${now:%H-%M-%S}'
+    
+# General settings
+trajectory_length: 32
+state_dim: 9
+
+# Device and debug settings
+device: 'cuda'
+debug: false
+
+# Mandatory settings
+seed: 11
+# results_dir: '${root_dir}/saved_models/${now:%m.%d-%H:%M}-seed${seed}'
+results_dir: '${root_dir}/saved_models/${now:%m.%d-%H.%M}_traj${trajectory_length}'
+batch_size: 256
+
+observation_wrapper: 'ObservationWrapperWithHistory'
+use_ee_control: true
+
+# Dataset
+dataset:
+  _target_: 'cfdp.datasets.maniskill2_trajectory.ManiSkill2TrajectoryWithHistory'
+  # dataset_file: '/mnt/Dataset/shelf_data.h5'
+  # dataset_file: '/mnt/Dataset/full_cover.h5'
+  # dataset_file: '/mnt/Dataset/bowl_300_split.h5'
+  # dataset_file: '/mnt/Dataset/bowl_reach_500.h5'
+  dataset_file: '${root_dir}/data/panda_wristcam/Merged/merged_cup5.rl.4.h5'
+  # dataset_file: '${root_dir}/data/panda_wristcam/GraspCup-v1/motionplanning/split_cup5.rl.4.h5'
+  obs_keys: ['tcp_pose']
+  normalizer: 'LimitsNormalizer'
+  pcd: false
+  choice: 'interpolate'
+  pad_front: false
+  trajectory_length: ${trajectory_length}
+  history_length: 8
+  force_reload: false
+  load_count: -1
+  device: ${device}
+  stride: 2
+  verbose: false 
+
+val_set_size: 0.2
+
+model:
+  # Diffusion Model
+  model_class: 'GaussianDiffusionModel'
+  variance_schedule: 'cosine' # 'cosine', 'exponential'
+  n_steps: 25
+  prediction_mode: "v"
+  use_ddim: true
+  use_snr_weight: true
+  # Unet
+  unet_dim_mults_option: 1
+  unet_input_dim: 64
+  conditioning_type: 'attention'
+  conditioning_embed_dim: 32
+  # Conext model
+  context_input_dim: ${multiply:10,${state_dim}}
+# Loss
+loss:
+  loss_class: 'GaussianDiffusionLoss'
+
+# Training parameters
+training:
+  lr: 1e-4
+  num_steps: 90000
+  use_ema: true
+  use_amp: false
+  steps_til_summary: 2000
+  steps_til_ckpt: 8000
+  summary_class: 'SummaryTrajectoryGeneration'
+
+# Inference settings
+inference:
+  env_id: 'GraspCup-v1'
+  obs_mode: 'rgb+position+segmentation'
+  control_mode: 'pd_ee_delta_pose'
+  reward_mode: 'dense'
+  use_ddim: true
+  robot_noise: 0.5
+  evaluate: false
+  # model_dir: '${root_dir}/saved_models/08.17-15.43_traj${trajectory_length}' #all data
+  # model_dir: '${root_dir}/saved_models/07.28-14.55_traj${trajectory_length}' #shelf data
+  # model_dir: '${root_dir}/saved_models/bowl_200_traj${trajectory_length}' #bowl 200 data
+  # model_dir: '${root_dir}/saved_models/bowl_300_new_traj${trajectory_length}' #bowl 300 data
+  # model_dir: '${root_dir}/saved_models/09.16-11.17_traj${trajectory_length}' #bowl reach 500 data
+  model_dir: '${root_dir}/saved_models/09.29-12.19_traj${trajectory_length}' #cup 5 data
+  use_ema: true
+  episodes: 100
+  replanning_interval: 30
+  n_samples: 8
+  n_diffusion_steps_without_noise: 0
+  index: 20
+  timestep: 5
+  sample_fn:
+    n_guide_steps: 2
+    t_start_guide: 8
+    noise_std_extra_schedule_fn: 0.5
+  validation_set_only: false
+  sim_with_history: true
+  # camera_type: 'hand_camera'
+  camera_type: 'world'
+  guidance_weight: 2.5
+
+test:
+  inference_record: false # record obs, trajectory, step_info
+  recording_dir: '${root_dir}/inference_recordings/'
+  replay_dir: '${root_dir}/inference_recordings/concept_test_guidance'
+  # replay_dir: '${root_dir}/inference_recordings/recording_0421_2145'
+# WandB settings
+wandb:
+  enabled: true
+  mode: 'offline'
+  entity: 'xuanz_test'
+  project: 'simple test'

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.circleci/build_count.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+Print the number of nightly builds
+"""
+
+from collections import Counter
+
+import yaml
+
+
+conf = yaml.safe_load(open("config.yml"))
+jobs = conf["workflows"]["build_and_test"]["jobs"]
+
+
+def jobtype(job):
+    if isinstance(job, str):
+        return job
+    if len(job) == 1:
+        [name] = job.keys()
+        return name
+    return "MULTIPLE PARTS"
+
+
+for i, j in Counter(map(jobtype, jobs)).items():
+    print(i, j)
+print()
+print(len(jobs))

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.circleci/check.sh

@@ -0,0 +1,13 @@
+#!/bin/bash -e
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+# Run this script before committing config.yml to verify it is valid yaml.
+
+python -c 'import yaml; yaml.safe_load(open("config.yml"))' && echo OK - valid yaml
+
+msg="circleci not installed so can't check schema"
+command -v circleci > /dev/null && (cd ..; circleci config validate) || echo "$msg"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.circleci/config.in.yml

@@ -0,0 +1,171 @@
+version: 2.1
+
+#examples:
+#https://github.com/facebookresearch/ParlAI/blob/master/.circleci/config.yml
+#https://github.com/facebookresearch/hydra/blob/master/.circleci/config.yml
+#https://github.com/facebookresearch/habitat-api/blob/master/.circleci/config.yml
+
+#drive tests with nox or tox or pytest?
+
+# -------------------------------------------------------------------------------------
+# environments where we run our jobs
+# -------------------------------------------------------------------------------------
+
+
+setupcuda: &setupcuda
+  run:
+    name: Setup CUDA
+    working_directory: ~/
+    command: |
+      # download and install nvidia drivers, cuda, etc
+      wget --no-verbose --no-clobber -P ~/nvidia-downloads https://developer.download.nvidia.com/compute/cuda/11.3.1/local_installers/cuda_11.3.1_465.19.01_linux.run
+      sudo sh ~/nvidia-downloads/cuda_11.3.1_465.19.01_linux.run --silent
+      echo "Done installing CUDA."
+      pyenv versions
+      nvidia-smi
+      pyenv global 3.9.1
+
+binary_common: &binary_common
+  parameters:
+    # Edit these defaults to do a release`
+    build_version:
+      description: "version number of release binary; by default, build a nightly"
+      type: string
+      default: ""
+    pytorch_version:
+      description: "PyTorch version to build against; by default, use a nightly"
+      type: string
+      default: ""
+    # Don't edit these
+    python_version:
+      description: "Python version to build against (e.g., 3.7)"
+      type: string
+    cu_version:
+      description: "CUDA version to build against, in CU format (e.g., cpu or cu100)"
+      type: string
+    wheel_docker_image:
+      description: "Wheel only: what docker image to use"
+      type: string
+      default: "pytorch/manylinux-cuda101"
+    conda_docker_image:
+      description: "what docker image to use for docker"
+      type: string
+      default: "pytorch/conda-cuda"
+  environment:
+    PYTHON_VERSION: << parameters.python_version >>
+    BUILD_VERSION: << parameters.build_version >>
+    PYTORCH_VERSION: << parameters.pytorch_version >>
+    CU_VERSION: << parameters.cu_version >>
+    TESTRUN_DOCKER_IMAGE: << parameters.conda_docker_image >>
+
+jobs:
+  main:
+    environment:
+      CUDA_VERSION: "11.3"
+    resource_class: gpu.nvidia.small.multi
+    machine:
+      image: linux-cuda-11:default
+    steps:
+      - checkout
+      - <<: *setupcuda
+      - run: pip3 install --progress-bar off imageio wheel matplotlib 'pillow<7'
+      - run: pip3 install --progress-bar off torch==1.10.0+cu113 torchvision==0.11.1+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+      # - run: conda create -p ~/conda_env python=3.7 numpy
+      # - run: conda activate ~/conda_env
+      # - run: conda install -c pytorch pytorch torchvision
+
+      - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/fvcore'
+      - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/iopath'
+      - run:
+          name: build
+          command: |
+            export LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-11.3/lib64
+            python3 setup.py build_ext --inplace
+      - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-11.3/lib64 python -m unittest discover -v -s tests -t .
+      - run: python3 setup.py bdist_wheel
+
+  binary_linux_wheel:
+    <<: *binary_common
+    docker:
+      - image: << parameters.wheel_docker_image >>
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+    resource_class: 2xlarge+
+    steps:
+      - checkout
+      - run: MAX_JOBS=15 packaging/build_wheel.sh
+      - store_artifacts:
+          path: dist
+      - persist_to_workspace:
+          root: dist
+          paths:
+            - "*"
+
+  binary_linux_conda:
+    <<: *binary_common
+    docker:
+      - image: "<< parameters.conda_docker_image >>"
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+    resource_class: 2xlarge+
+    steps:
+      - checkout
+      # This is building with cuda but no gpu present,
+      # so we aren't running the tests.
+      - run:
+          name: build
+          no_output_timeout: 40m
+          command: MAX_JOBS=15 TEST_FLAG=--no-test python3 packaging/build_conda.py
+      - store_artifacts:
+          path: /opt/conda/conda-bld/linux-64
+      - persist_to_workspace:
+          root: /opt/conda/conda-bld/linux-64
+          paths:
+            - "*"
+
+  binary_linux_conda_cuda:
+    <<: *binary_common
+    machine:
+      image: linux-cuda-11:default
+    resource_class: gpu.nvidia.small.multi
+    steps:
+    - checkout
+
+    - run:
+        name: Pull docker image
+        command: |
+          nvidia-smi
+          set -e
+
+          { docker login -u="$DOCKERHUB_USERNAME" -p="$DOCKERHUB_TOKEN" ; } 2> /dev/null
+
+          echo Pulling docker image $TESTRUN_DOCKER_IMAGE
+          docker pull $TESTRUN_DOCKER_IMAGE
+    - run:
+        name: Build and run tests
+        no_output_timeout: 40m
+        command: |
+          set -e
+
+          cd ${HOME}/project/
+
+          export JUST_TESTRUN=1
+          VARS_TO_PASS="-e PYTHON_VERSION -e BUILD_VERSION -e PYTORCH_VERSION -e CU_VERSION -e JUST_TESTRUN"
+
+          docker run --gpus all  --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${TESTRUN_DOCKER_IMAGE} python3 ./packaging/build_conda.py
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      # - main:
+      #     context: DOCKERHUB_TOKEN
+      {{workflows()}}
+      - binary_linux_conda_cuda:
+          name: testrun_conda_cuda_py310_cu117_pyt201
+          context: DOCKERHUB_TOKEN
+          python_version: "3.10"
+          pytorch_version: '2.0.1'
+          cu_version: "cu117"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.circleci/config.yml

@@ -0,0 +1,688 @@
+version: 2.1
+
+#examples:
+#https://github.com/facebookresearch/ParlAI/blob/master/.circleci/config.yml
+#https://github.com/facebookresearch/hydra/blob/master/.circleci/config.yml
+#https://github.com/facebookresearch/habitat-api/blob/master/.circleci/config.yml
+
+#drive tests with nox or tox or pytest?
+
+# -------------------------------------------------------------------------------------
+# environments where we run our jobs
+# -------------------------------------------------------------------------------------
+
+
+setupcuda: &setupcuda
+  run:
+    name: Setup CUDA
+    working_directory: ~/
+    command: |
+      # download and install nvidia drivers, cuda, etc
+      wget --no-verbose --no-clobber -P ~/nvidia-downloads https://developer.download.nvidia.com/compute/cuda/11.3.1/local_installers/cuda_11.3.1_465.19.01_linux.run
+      sudo sh ~/nvidia-downloads/cuda_11.3.1_465.19.01_linux.run --silent
+      echo "Done installing CUDA."
+      pyenv versions
+      nvidia-smi
+      pyenv global 3.9.1
+
+binary_common: &binary_common
+  parameters:
+    # Edit these defaults to do a release`
+    build_version:
+      description: "version number of release binary; by default, build a nightly"
+      type: string
+      default: ""
+    pytorch_version:
+      description: "PyTorch version to build against; by default, use a nightly"
+      type: string
+      default: ""
+    # Don't edit these
+    python_version:
+      description: "Python version to build against (e.g., 3.7)"
+      type: string
+    cu_version:
+      description: "CUDA version to build against, in CU format (e.g., cpu or cu100)"
+      type: string
+    wheel_docker_image:
+      description: "Wheel only: what docker image to use"
+      type: string
+      default: "pytorch/manylinux-cuda101"
+    conda_docker_image:
+      description: "what docker image to use for docker"
+      type: string
+      default: "pytorch/conda-cuda"
+  environment:
+    PYTHON_VERSION: << parameters.python_version >>
+    BUILD_VERSION: << parameters.build_version >>
+    PYTORCH_VERSION: << parameters.pytorch_version >>
+    CU_VERSION: << parameters.cu_version >>
+    TESTRUN_DOCKER_IMAGE: << parameters.conda_docker_image >>
+
+jobs:
+  main:
+    environment:
+      CUDA_VERSION: "11.3"
+    resource_class: gpu.nvidia.small.multi
+    machine:
+      image: linux-cuda-11:default
+    steps:
+      - checkout
+      - <<: *setupcuda
+      - run: pip3 install --progress-bar off imageio wheel matplotlib 'pillow<7'
+      - run: pip3 install --progress-bar off torch==1.10.0+cu113 torchvision==0.11.1+cu113 -f https://download.pytorch.org/whl/cu113/torch_stable.html
+      # - run: conda create -p ~/conda_env python=3.7 numpy
+      # - run: conda activate ~/conda_env
+      # - run: conda install -c pytorch pytorch torchvision
+
+      - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/fvcore'
+      - run: pip3 install --progress-bar off 'git+https://github.com/facebookresearch/iopath'
+      - run:
+          name: build
+          command: |
+            export LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-11.3/lib64
+            python3 setup.py build_ext --inplace
+      - run: LD_LIBRARY_PATH=$LD_LIBARY_PATH:/usr/local/cuda-11.3/lib64 python -m unittest discover -v -s tests -t .
+      - run: python3 setup.py bdist_wheel
+
+  binary_linux_wheel:
+    <<: *binary_common
+    docker:
+      - image: << parameters.wheel_docker_image >>
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+    resource_class: 2xlarge+
+    steps:
+      - checkout
+      - run: MAX_JOBS=15 packaging/build_wheel.sh
+      - store_artifacts:
+          path: dist
+      - persist_to_workspace:
+          root: dist
+          paths:
+            - "*"
+
+  binary_linux_conda:
+    <<: *binary_common
+    docker:
+      - image: "<< parameters.conda_docker_image >>"
+        auth:
+          username: $DOCKERHUB_USERNAME
+          password: $DOCKERHUB_TOKEN
+    resource_class: 2xlarge+
+    steps:
+      - checkout
+      # This is building with cuda but no gpu present,
+      # so we aren't running the tests.
+      - run:
+          name: build
+          no_output_timeout: 40m
+          command: MAX_JOBS=15 TEST_FLAG=--no-test python3 packaging/build_conda.py
+      - store_artifacts:
+          path: /opt/conda/conda-bld/linux-64
+      - persist_to_workspace:
+          root: /opt/conda/conda-bld/linux-64
+          paths:
+            - "*"
+
+  binary_linux_conda_cuda:
+    <<: *binary_common
+    machine:
+      image: linux-cuda-11:default
+    resource_class: gpu.nvidia.small.multi
+    steps:
+    - checkout
+
+    - run:
+        name: Pull docker image
+        command: |
+          nvidia-smi
+          set -e
+
+          { docker login -u="$DOCKERHUB_USERNAME" -p="$DOCKERHUB_TOKEN" ; } 2> /dev/null
+
+          echo Pulling docker image $TESTRUN_DOCKER_IMAGE
+          docker pull $TESTRUN_DOCKER_IMAGE
+    - run:
+        name: Build and run tests
+        no_output_timeout: 40m
+        command: |
+          set -e
+
+          cd ${HOME}/project/
+
+          export JUST_TESTRUN=1
+          VARS_TO_PASS="-e PYTHON_VERSION -e BUILD_VERSION -e PYTORCH_VERSION -e CU_VERSION -e JUST_TESTRUN"
+
+          docker run --gpus all  --ipc=host -v $(pwd):/remote -w /remote ${VARS_TO_PASS} ${TESTRUN_DOCKER_IMAGE} python3 ./packaging/build_conda.py
+
+workflows:
+  version: 2
+  build_and_test:
+    jobs:
+      # - main:
+      #     context: DOCKERHUB_TOKEN
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt210
+          python_version: '3.8'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt210
+          python_version: '3.8'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt211
+          python_version: '3.8'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt211
+          python_version: '3.8'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt212
+          python_version: '3.8'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt212
+          python_version: '3.8'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt220
+          python_version: '3.8'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt220
+          python_version: '3.8'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt222
+          python_version: '3.8'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt231
+          python_version: '3.8'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt240
+          python_version: '3.8'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt240
+          python_version: '3.8'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py38_cu118_pyt241
+          python_version: '3.8'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py38_cu121_pyt241
+          python_version: '3.8'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt210
+          python_version: '3.9'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt210
+          python_version: '3.9'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt211
+          python_version: '3.9'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt211
+          python_version: '3.9'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt212
+          python_version: '3.9'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt212
+          python_version: '3.9'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt220
+          python_version: '3.9'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt220
+          python_version: '3.9'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt222
+          python_version: '3.9'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt231
+          python_version: '3.9'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt240
+          python_version: '3.9'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt240
+          python_version: '3.9'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py39_cu118_pyt241
+          python_version: '3.9'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py39_cu121_pyt241
+          python_version: '3.9'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt210
+          python_version: '3.10'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt210
+          python_version: '3.10'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt211
+          python_version: '3.10'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt211
+          python_version: '3.10'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt212
+          python_version: '3.10'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt212
+          python_version: '3.10'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt220
+          python_version: '3.10'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt220
+          python_version: '3.10'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt222
+          python_version: '3.10'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt231
+          python_version: '3.10'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt240
+          python_version: '3.10'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt240
+          python_version: '3.10'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py310_cu118_pyt241
+          python_version: '3.10'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py310_cu121_pyt241
+          python_version: '3.10'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt210
+          python_version: '3.11'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt210
+          python_version: '3.11'
+          pytorch_version: 2.1.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt211
+          python_version: '3.11'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt211
+          python_version: '3.11'
+          pytorch_version: 2.1.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt212
+          python_version: '3.11'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt212
+          python_version: '3.11'
+          pytorch_version: 2.1.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt220
+          python_version: '3.11'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt220
+          python_version: '3.11'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt222
+          python_version: '3.11'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt231
+          python_version: '3.11'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt240
+          python_version: '3.11'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt240
+          python_version: '3.11'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py311_cu118_pyt241
+          python_version: '3.11'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py311_cu121_pyt241
+          python_version: '3.11'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt220
+          python_version: '3.12'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt220
+          python_version: '3.12'
+          pytorch_version: 2.2.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt222
+          python_version: '3.12'
+          pytorch_version: 2.2.2
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt231
+          python_version: '3.12'
+          pytorch_version: 2.3.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt240
+          python_version: '3.12'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt240
+          python_version: '3.12'
+          pytorch_version: 2.4.0
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda118
+          context: DOCKERHUB_TOKEN
+          cu_version: cu118
+          name: linux_conda_py312_cu118_pyt241
+          python_version: '3.12'
+          pytorch_version: 2.4.1
+      - binary_linux_conda:
+          conda_docker_image: pytorch/conda-builder:cuda121
+          context: DOCKERHUB_TOKEN
+          cu_version: cu121
+          name: linux_conda_py312_cu121_pyt241
+          python_version: '3.12'
+          pytorch_version: 2.4.1
+      - binary_linux_conda_cuda:
+          name: testrun_conda_cuda_py310_cu117_pyt201
+          context: DOCKERHUB_TOKEN
+          python_version: "3.10"
+          pytorch_version: '2.0.1'
+          cu_version: "cu117"

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/.circleci/regenerate.py

@@ -0,0 +1,183 @@
+#!/usr/bin/env python3
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# All rights reserved.
+#
+# This source code is licensed under the BSD-style license found in the
+# LICENSE file in the root directory of this source tree.
+
+"""
+This script is adapted from the torchvision one.
+"""
+
+import os.path
+
+import jinja2
+import yaml
+from packaging import version
+
+
+# The CUDA versions which have pytorch conda packages available for linux for each
+# version of pytorch.
+CONDA_CUDA_VERSIONS = {
+    "2.1.0": ["cu118", "cu121"],
+    "2.1.1": ["cu118", "cu121"],
+    "2.1.2": ["cu118", "cu121"],
+    "2.2.0": ["cu118", "cu121"],
+    "2.2.2": ["cu118", "cu121"],
+    "2.3.1": ["cu118", "cu121"],
+    "2.4.0": ["cu118", "cu121"],
+    "2.4.1": ["cu118", "cu121"],
+}
+
+
+def conda_docker_image_for_cuda(cuda_version):
+    if len(cuda_version) != 5:
+        raise ValueError("Unknown cuda version")
+    return "pytorch/conda-builder:cuda" + cuda_version[2:]
+
+
+def pytorch_versions_for_python(python_version):
+    if python_version in ["3.8", "3.9"]:
+        return list(CONDA_CUDA_VERSIONS)
+    if python_version == "3.10":
+        return [
+            i
+            for i in CONDA_CUDA_VERSIONS
+            if version.Version(i) >= version.Version("1.11.0")
+        ]
+    if python_version == "3.11":
+        return [
+            i
+            for i in CONDA_CUDA_VERSIONS
+            if version.Version(i) >= version.Version("2.1.0")
+        ]
+    if python_version == "3.12":
+        return [
+            i
+            for i in CONDA_CUDA_VERSIONS
+            if version.Version(i) >= version.Version("2.2.0")
+        ]
+
+
+def workflows(prefix="", filter_branch=None, upload=False, indentation=6):
+    w = []
+    for btype in ["conda"]:
+        for python_version in ["3.8", "3.9", "3.10", "3.11", "3.12"]:
+            for pytorch_version in pytorch_versions_for_python(python_version):
+                for cu_version in CONDA_CUDA_VERSIONS[pytorch_version]:
+                    w += workflow_pair(
+                        btype=btype,
+                        python_version=python_version,
+                        pytorch_version=pytorch_version,
+                        cu_version=cu_version,
+                        prefix=prefix,
+                        upload=upload,
+                        filter_branch=filter_branch,
+                    )
+
+    return indent(indentation, w)
+
+
+def workflow_pair(
+    *,
+    btype,
+    python_version,
+    pytorch_version,
+    cu_version,
+    prefix="",
+    upload=False,
+    filter_branch,
+):
+
+    w = []
+    py = python_version.replace(".", "")
+    pyt = pytorch_version.replace(".", "")
+    base_workflow_name = f"{prefix}linux_{btype}_py{py}_{cu_version}_pyt{pyt}"
+
+    w.append(
+        generate_base_workflow(
+            base_workflow_name=base_workflow_name,
+            python_version=python_version,
+            pytorch_version=pytorch_version,
+            cu_version=cu_version,
+            btype=btype,
+            filter_branch=filter_branch,
+        )
+    )
+
+    if upload:
+        w.append(
+            generate_upload_workflow(
+                base_workflow_name=base_workflow_name,
+                btype=btype,
+                cu_version=cu_version,
+                filter_branch=filter_branch,
+            )
+        )
+
+    return w
+
+
+def generate_base_workflow(
+    *,
+    base_workflow_name,
+    python_version,
+    cu_version,
+    pytorch_version,
+    btype,
+    filter_branch=None,
+):
+
+    d = {
+        "name": base_workflow_name,
+        "python_version": python_version,
+        "cu_version": cu_version,
+        "pytorch_version": pytorch_version,
+        "context": "DOCKERHUB_TOKEN",
+    }
+
+    conda_docker_image = conda_docker_image_for_cuda(cu_version)
+    if conda_docker_image is not None:
+        d["conda_docker_image"] = conda_docker_image
+
+    if filter_branch is not None:
+        d["filters"] = {"branches": {"only": filter_branch}}
+
+    return {f"binary_linux_{btype}": d}
+
+
+def generate_upload_workflow(*, base_workflow_name, btype, cu_version, filter_branch):
+    d = {
+        "name": f"{base_workflow_name}_upload",
+        "context": "org-member",
+        "requires": [base_workflow_name],
+    }
+
+    if btype == "wheel":
+        d["subfolder"] = cu_version + "/"
+
+    if filter_branch is not None:
+        d["filters"] = {"branches": {"only": filter_branch}}
+
+    return {f"binary_{btype}_upload": d}
+
+
+def indent(indentation, data_list):
+    if len(data_list) == 0:
+        return ""
+    return ("\n" + " " * indentation).join(
+        yaml.dump(data_list, default_flow_style=False).splitlines()
+    )
+
+
+if __name__ == "__main__":
+    d = os.path.dirname(__file__)
+    env = jinja2.Environment(
+        loader=jinja2.FileSystemLoader(d),
+        lstrip_blocks=True,
+        autoescape=False,
+        keep_trailing_newline=True,
+    )
+
+    with open(os.path.join(d, "config.yml"), "w") as f:
+        f.write(env.get_template("config.in.yml").render(workflows=workflows))

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/extern/pytorch3d/LICENSE-3RD-PARTY

@@ -0,0 +1,71 @@
+SRN license ( https://github.com/vsitzmann/scene-representation-networks/ ):
+
+MIT License
+
+Copyright (c) 2019 Vincent Sitzmann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+IDR license ( github.com/lioryariv/idr ):
+
+MIT License
+
+Copyright (c) 2020 Lior Yariv
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+
+NeRF https://github.com/bmild/nerf/
+
+Copyright (c) 2020 bmild
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/inference_server.py

@@ -0,0 +1,338 @@
+import warnings
+warnings.filterwarnings("ignore")
+import os
+import json
+import socket
+import threading
+import time
+import numpy as np
+import torch
+from tqdm import tqdm
+import gymnasium as gym
+import hydra
+from omegaconf import DictConfig, OmegaConf
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+import mani_skill2.envs
+import cfdp.envs as envs  # customized environments
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.utils.socket_utils import arr2base64, base64_to_arr
+from cfdp.utils import observation_wrapper
+from cfdp.envs import ROBOT_ASSETS_DIR, ENVS_DIR
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.utils.pointcloud_utils import get_pcd_obs
+
+from realsense_wrapper import RealsenseAPI
+from franka_robot_wrapper.camera_calibration import calibrate_external, calibrate_hand
+
+OBSTACLE_CONFIGS = []
+HOST='127.0.0.1'
+i = 2
+PORT_SEND=5001 + (2*i)
+PORT_RECV=5000 + (2*i)
+
+CAMERAS = {
+    'cam_front': {
+        "id": "317422074275",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317422074275.txt"
+    },
+    # 'cam_back': {
+    #     "id": "317222076109",
+    #     "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317222076109.txt"
+    # },
+    'gripper': {
+        "id": "317422074762",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317422074762.txt"
+    }
+}
+
+rs_list = []
+calibration_list = []
+
+obs = {'extra': {}}
+
+def process_cameras_and_get_point_clouds(cameras_dict):
+    global rs_list, calibration_list
+    """
+    Takes a dictionary representing cameras and processes each camera.
+    For demonstration, this function prints the camera id and calibration file.
+
+    Args:
+        cameras_dict (dict): Dictionary where each key is a camera name and value is a dict with camera info.
+    """
+    rs_list = [RealsenseAPI(info["id"]) for name, info in cameras_dict.items()]
+    calibration_list = [
+        calibrate_hand(info["calib_file"]) if name == "gripper" else calibrate_external(info["calib_file"])
+        for name, info in cameras_dict.items()
+    ]
+    # calibration_list = [calibrate_external(info["calib_file"]) for name, info in cameras_dict.items()]
+
+    return rs_list, calibration_list
+
+def initialize_server(host, port):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind((host, port))
+    s.listen(1)
+    print(f"[Server] Listening on {host}:{port}")
+    return s
+
+def send_response(socket_server, response):
+    """
+    Accept a single connection, send the response immediately, then exit.
+    """
+    conn, addr = socket_server.accept()
+    payload = arr2base64(response) 
+    # print(f"[Server] Connected by {addr}")
+    with conn:
+        conn.sendall(json.dumps(payload).encode())
+        print("[Server] Response sent", response)
+
+def update_observation(conn):
+    global obs
+    try:
+        data = conn.recv(4096)
+        if not data:
+            print("[Server] Connection closed by client.")
+        else:
+            request = json.loads(data.decode())
+            payload = base64_to_arr(request)
+            if payload is not None:
+                obs['extra']['tcp_pose'] = payload[:7]
+                obs['extra']['goal_pose'] = payload[7:]
+                obs['extra']['obstacle_point_cloud'] = get_pcd_obs(rs_list, calibration_list, obs['extra']['tcp_pose'])
+        # print("Observation:", obs['extra']['tcp_pose'])
+    except json.JSONDecodeError:
+        print("[Server] Received invalid JSON. Skipping.")
+    except Exception as e:
+        print("[Server] Error while receiving:", e)
+
+def handle_client(stop_event):
+    print("Starting server...")
+    socket_server = initialize_server(HOST, PORT_RECV)
+    while not stop_event.is_set():
+        conn, addr = socket_server.accept()
+        # print(f"[Server] Connected by {addr}")
+        with conn:
+            update_observation(conn)
+        # print(f"[Server] Connection from {addr} closed.")
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history")
+def main(cfg: DictConfig):
+    global obs
+    ########################################################################################################################
+    # Prepare the socket server for sending actions
+    socket_server_send = initialize_server(HOST, PORT_SEND)
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    #TODO: save / load normalizer. Do not use dataset
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        predict_epsilon=cfg.model.predict_epsilon,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+    
+    ########################################################################################################################
+    env = gym.make('CustomizedPick-v0',
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                   render_mode="cameras" if cfg.inference.evaluate else "human",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                   object_config_path=os.path.join(ENVS_DIR, "env_config"),
+                   create_obstacle_point_cloud=True)
+
+    # Initialize guide manager
+    guide = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    )
+    # guide = None
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset)
+    
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+    ########################################################################################################################
+    # Initialize policy
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        debug=cfg.debug)
+
+    ########################################################################################################################
+    # Run the policy
+    done = False
+    def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+        trajectory_index = policy.get_current_path_index()
+        trajectory_prior = trajectory_ortho6d[trajectory_index:]
+        current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+            torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+        ).squeeze(0)
+        return torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0)
+
+    step = 0
+    replanning_count = 0
+    mpd = False
+    while not done:
+        policy.observation_wrapper.update_history_buffer(obs)
+        replanning_interval = 2
+        if step % replanning_interval == 0:
+            if step == 0: # initial planning
+                policy.plan_path_with_history(obs, do_normalize=True)
+            elif not mpd: # replanning
+                print("1")
+                position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+                if position_diff > 0.10:
+                    print("Replanning count: ", replanning_count, "position_diff: ", position_diff)
+                    ## replanning with prior
+                    trajectory_prior = create_trajectory_prior(policy, obs, policy.planned_path)
+                    policy.plan_path_with_history(obs, 
+                                                trajectory_prior=trajectory_prior, 
+                                                do_normalize=True, 
+                                                timestep=cfg.inference.timestep,  # denoising step
+                                                choice='interpolate')
+                    ## replanning without prior
+                    # trajectory_ortho6d = policy.plan_path_with_history(obs, do_normalize=True)
+                    replanning_count += 1
+            # if not cfg.debug:
+            #     visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+
+        action = policy.follow_path(obs, real_robot=True)
+        
+        # Convert action to numpy array if it's a tensor
+        if torch.is_tensor(action):
+            action = action.detach().cpu().numpy()
+        send_response(socket_server_send, action)
+        print("Steps: ", step, "Replanning count: ", replanning_count)
+        step += 1
+        position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+        
+        
+        if position_diff < 0.02:
+            step = 0
+            replanning_count = 0
+        #     # Initialize policy
+        #     diffusion_configs = dict(
+        #         variance_schedule=cfg.model.variance_schedule,
+        #         n_diffusion_steps=cfg.model.n_steps,
+        #         predict_epsilon=cfg.model.predict_epsilon,
+        #     )
+
+        #     unet_configs = dict(
+        #         state_dim=cfg.state_dim,
+        #         n_support_points=cfg.trajectory_length,
+        #         unet_input_dim=cfg.model.unet_input_dim,
+        #         dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        #         conditioning_type=cfg.model.conditioning_type,
+        #         conditioning_embed_dim = cfg.model.conditioning_embed_dim
+        #     )
+
+        #     diffusion_model = get_model(
+        #         model_class=cfg.model.model_class,
+        #         model=TemporalUnet(**unet_configs),
+        #         tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        #         context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        #         **diffusion_configs,
+        #         **unet_configs
+        #     )
+
+        #     # load saved policy model
+        #     diffusion_model.load_state_dict(
+        #         torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+        #                 'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+        #                 map_location=cfg.device,
+        #                 weights_only=True)
+        #     )
+            
+        #     diffusion_model.eval()
+        #     model = diffusion_model
+
+        #     freeze_torch_model_params(model)
+        #     model = torch.compile(model)
+        #     # guide = None
+        #     ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+        #     obs_wrapper = ObservationWrapperClass(train_subset.dataset)
+        #     policy = NeuralMotionPlannerPolicy(
+        #         action_dim=env.action_space.shape[0],
+        #         model=model,
+        #         dataset=train_subset.dataset, 
+        #         trajectory_length=cfg.trajectory_length,
+        #         inference_cfg=cfg.inference,
+        #         observation_wrapper=obs_wrapper,
+        #         guide_manager=guide,
+        #         debug=cfg.debug)
+        #     guide = GuideManagerPath(
+        #     dataset = train_subset.dataset,
+        #     clip_grad=True,
+        #     tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        #     )
+            # step = 0
+            # replanning_count = 0
+    env.close()
+
+if __name__ == "__main__":
+    
+    process_cameras_and_get_point_clouds(CAMERAS)
+    try:
+        stop_event = threading.Event()
+        thread = threading.Thread(target=handle_client, args=(stop_event,))
+        thread.start()
+        main()
+        stop_event.set()
+        thread.join()
+    except KeyboardInterrupt:
+        print(f"\nEnded")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/inference_server_joint.py

@@ -0,0 +1,362 @@
+import warnings
+warnings.filterwarnings("ignore")
+
+# Standard library imports
+import json
+import os
+import random
+import socket
+import threading
+import time
+
+# Third-party imports
+from tqdm import tqdm
+import gymnasium as gym
+import hydra
+import numpy as np
+import torch
+from matplotlib import pyplot as plt
+from omegaconf import DictConfig, OmegaConf
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+# ManiSkill imports
+import mani_skill2.envs
+from mani_skill2.utils.wrappers import RecordEpisode
+
+# CFDP imports
+import cfdp.envs as envs  # customized environments
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerSTOMP
+from cfdp.diffusion_policy.models.sample_functions import ddpm_sample_fn_stomp
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.envs import ENVS_DIR, ROBOT_ASSETS_DIR
+from cfdp.motion_planner.motion_controller import EndEffectorController
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.utils.plot_utils import plot_trajectories, TrajectoryVisualizer
+from cfdp.utils.socket_utils import arr2base64, base64_to_arr
+from cfdp.utils.pointcloud_utils import get_pcd_obs
+
+# External hardware imports
+from franka_robot_wrapper.camera_calibration import calibrate_external, calibrate_hand
+from realsense_wrapper import RealsenseAPI
+
+# 1. Set random seeds for reproducibility
+np.random.seed(42)
+random.seed(42)
+
+# 2. Socket/Network configuration
+HOST = '127.0.0.1'
+i = 2
+PORT_RECV = 5000 + (2 * i)
+PORT_SEND = 5001 + (2 * i)
+OBSTACLE_CONFIGS = []
+
+
+# 3. Camera configuration
+CAMERAS = {
+    'cam_front': {
+        "id": "317422074275",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317422074275.txt"
+    },
+    'cam_back': {
+        "id": "317222076109",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317222076109.txt"
+    },
+    'cam_side': {
+        "id": "244222074448",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/244222074448.txt"
+    },
+    'gripper': {
+        "id": "317422074762",
+        "calib_file": "/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/317422074762.txt"
+    }
+}
+
+# 4. Camera and calibration lists (populated later)
+rs_list = []
+calibration_list = []
+
+# 5. Global observation dictionary
+obs = {'extra': {}, 'agent': {}}
+
+def process_cameras_and_get_point_clouds(cameras_dict):
+    global rs_list, calibration_list
+    """
+    Takes a dictionary representing cameras and processes each camera.
+    For demonstration, this function prints the camera id and calibration file.
+
+    Args:
+        cameras_dict (dict): Dictionary where each key is a camera name and value is a dict with camera info.
+    """
+    rs_list = [RealsenseAPI(info["id"]) for name, info in cameras_dict.items()]
+    calibration_list = [
+        calibrate_hand(info["calib_file"]) if name == "gripper" else calibrate_external(info["calib_file"])
+        for name, info in cameras_dict.items()
+    ]
+    # calibration_list = [calibrate_external(info["calib_file"]) for name, info in cameras_dict.items()]
+
+    return rs_list, calibration_list
+
+def initialize_server(host, port):
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.bind((host, port))
+    s.listen(1)
+    print(f"[Server] Listening on {host}:{port}")
+    return s
+
+def send_response(socket_server, response):
+    """
+    Accept a single connection, send the response immediately, then exit.
+    """
+    conn, addr = socket_server.accept()
+    payload = arr2base64(response) 
+    # print(f"[Server] Connected by {addr}")
+    with conn:
+        conn.sendall(json.dumps(payload).encode())
+        print("[Server] Response sent", response)
+
+def update_observation(conn):
+    global obs
+    try:
+        data = conn.recv(4096)
+        if not data:
+            print("[Server] Connection closed by client.")
+        else:
+            request = json.loads(data.decode())
+            payload = base64_to_arr(request)
+            if payload is not None: #TODO: Check if this is correct
+                obs['agent']['qpos'] = payload[:9]
+                obs['extra']['goal_qpos'] = payload[9:18]
+                obs['extra']['tcp_pose'] = payload[18:25]
+                obs['extra']['goal_pose'] = payload[25:]
+                obs['extra']['obstacle_point_cloud'] = get_pcd_obs(rs_list, calibration_list, obs['extra']['tcp_pose'])
+        # print("Observation:", obs['extra']['tcp_pose'])
+    except json.JSONDecodeError:
+        print("[Server] Received invalid JSON. Skipping.")
+    except Exception as e:
+        print("[Server] Error while receiving:", e)
+
+def handle_client(stop_event):
+    print("Starting server...")
+    socket_server = initialize_server(HOST, PORT_RECV)
+    while not stop_event.is_set():
+        conn, addr = socket_server.accept()
+        # print(f"[Server] Connected by {addr}")
+        with conn:
+            update_observation(conn)
+        # print(f"[Server] Connection from {addr} closed.")
+
+def plot_STOMP_debug_info(guide_debug_into, visualizer, point_cloud=None, 
+                          sphere_idx=24, time_step=-1):
+    sphere_trajectories = guide_debug_into[time_step].sphere_poses.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sphere_radii = guide_debug_into[time_step].sphere_radii.cpu().numpy() # [batch, seq_len, num_spheres]
+    sdf_costs = guide_debug_into[time_step].sdf_costs.cpu().numpy() # [batch, seq_len, num_spheres]
+    spheres_after_guidance = guide_debug_into[time_step].spheres_after_guidance.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sampled_spheres = guide_debug_into[time_step].sampled_spheres.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    #TODO: plot spheres_after_guidance
+    fig = visualizer.plot_trajectory_with_cost(sphere_trajectories, 
+                                         sdf_costs, 
+                                         spheres_after_guidance=spheres_after_guidance, 
+                                         sampled_spheres=sampled_spheres,
+                                         point_cloud=point_cloud, 
+                                         sphere_idx=sphere_idx,
+                                         time_step=time_step)
+    return fig
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history_joint")
+def main(cfg: DictConfig):
+    global obs
+    ########################################################################################################################
+    # Prepare the socket server for sending actions
+    socket_server_send = initialize_server(HOST, PORT_SEND)
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        predict_epsilon=cfg.model.predict_epsilon,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, 
+                               out_dim=cfg.model.conditioning_embed_dim, 
+                               input_field='tasks', 
+                               output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+
+    ########################################################################################################################
+    env = gym.make(cfg.inference.env_id,
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                #    render_mode="cameras" if cfg.inference.evaluate else "human",
+                   render_mode="human",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                   object_config_path=os.path.join(ENVS_DIR, "env_config","shelf"),
+                   create_obstacle_point_cloud=True,
+                   is_demo=True)
+
+    # Initialize guide manager
+    # guide = None
+    guide = GuideManagerSTOMP(
+        dataset = train_subset.dataset,
+        robot_model = env.agent.robot,
+        clip_grad=True,
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        guidance_weight=cfg.inference.guidance_weight,
+    )
+
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        use_ee_control=cfg.use_ee_control,
+        guide_manager=guide,
+        debug=cfg.debug)
+    policy.reset()
+
+    ######################### main inference loop #########################
+    def create_trajectory_prior(policy, obs, trajectory, replanning_interval):
+        trajectory_index = policy.get_current_path_index()
+        trajectory_prior = trajectory[trajectory_index:]
+        # trajectory_prior = trajectory[replanning_interval:]
+        current_joint_pose = torch.tensor(obs['agent']['qpos']).to(cfg.device)
+        return torch.cat([current_joint_pose.unsqueeze(0), trajectory_prior], dim=0)
+
+    # print("Waiting for 15 seconds")
+    # time.sleep(18)
+    #### Planning ####
+    try:
+        step = 0
+        done = False
+        stop_replan = False
+        replanning_count = 0
+        replanning_interval = 3       
+        
+        while not done:
+            # Calculate the difference between the current TCP pose and the goal pose
+            # obs['extra']['tcp_pose'] and obs['extra']['goal_pose'] are both expected to be arrays of length 7
+            current_tcp_pose = np.array(obs['extra']['tcp_pose'])[:3]
+            goal_pose_ee = obs['extra']['goal_pose'][:3]
+            tcp_pose_diff = np.linalg.norm(current_tcp_pose - goal_pose_ee)
+            if tcp_pose_diff < 0.375:
+                stop_replan = True
+            print("TCP pose difference:", tcp_pose_diff)
+            # Update obsqueue
+            policy.observation_wrapper.update_history_buffer(obs)
+            
+            if step % replanning_interval == 0 and (not stop_replan):
+                if step == 0:
+                    print("Initial planning")
+                    policy.plan_path_with_history(
+                        obs,
+                        do_normalize=True
+                    )
+                else:
+                    replanning_count += 1
+                    trajectory_prior = create_trajectory_prior(
+                        policy,
+                        obs,
+                        policy.planned_path,
+                        replanning_interval
+                    )
+                    policy.plan_path_with_history(
+                        obs,
+                        trajectory_prior=trajectory_prior,
+                        do_normalize=True,
+                        timestep=cfg.inference.timestep,  # denoising step
+                        choice='interpolate'
+                    )
+
+                # debug plot, sphere positions and sdf cost
+                # fig1 = plot_STOMP_debug_info(
+                #     guide.debug_state,
+                #     visualizer,
+                #     point_cloud=policy.point_cloud,
+                #     sphere_idx=24,
+                #     time_step=3
+                # )
+                # plt.show()
+                # guide.reset_debug_state()
+                    
+            if tcp_pose_diff < 0.25:
+                action = policy.planned_path[-1]
+            else:
+                action = policy.follow_path(obs, real_robot=True)
+            if torch.is_tensor(action):
+                done = True
+                action = action.detach().cpu().numpy()
+            send_response(socket_server_send, action)
+            print("Steps: ", step, "Replanning count: ", replanning_count)
+            step += 1          
+            
+        
+    except KeyboardInterrupt:
+        print("\nStopping simulation...")
+
+    print("Simulation finished")
+    env.close() 
+
+
+if __name__ == "__main__":
+        
+    process_cameras_and_get_point_clouds(CAMERAS)
+    try:
+        stop_event = threading.Event()
+        thread = threading.Thread(target=handle_client, args=(stop_event,))
+        thread.start()
+        main()
+        stop_event.set()
+        thread.join()
+    except KeyboardInterrupt:
+        print(f"\nEnded")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/robot_controller.py

@@ -0,0 +1,142 @@
+import sys
+sys.path.append('/home/ladmin/Documents/maniskill2_benchmark/')
+import time
+import json
+import socket
+import threading
+
+import gym
+import franka_gym
+from franka_gym.utils import *
+from franka_gym.agents import *
+
+from cfdp.utils.socket_utils import arr2base64, base64_to_arr
+
+
+CONFIG_FILE_PATH = '/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/franka_gym/configs/example.yaml'
+CONFIGS = configure(CONFIG_FILE_PATH)
+CONF_EXP = CONFIGS['experiment']
+ENV = gym.make(CONF_EXP['env-name'], config_file=CONFIG_FILE_PATH)
+ENV.reset()
+GOAL_POSE = np.array([0.45, 0.40, 0.08, 0.0, -1.0, 0.0, 0.0]) # 1
+GOAL_POSE = np.array([0.45, 0.50, 0.04, 0.0, -1.0, 0.0, 0.0]) # 2
+GOAL_POSE = np.array([0.465, 0.55, 0.08, 0.0, -1.0, 0.0, 0.0]) # 3
+GOAL_POSE = np.array([0.36, 0.58, 0.08, 0.0, -1.0, 0.0, 0.0]) # 4
+HOST='127.0.0.1'
+i = 2
+PORT_SEND=5000 + (2*i)
+PORT_RECV=5001 + (2*i)
+
+def get_robot_state():
+    try:
+        state = ENV.get_state()
+        robot_state = state['ee_states'][:7]
+        combined_state = np.concatenate([robot_state, GOAL_POSE])
+        return combined_state
+    except Exception as e:
+        print(f"Error getting robot state: {e}")
+        return None
+
+def send_observation(stop_event, host=HOST, port=PORT_SEND, interval=0.5):
+    try:
+        while not stop_event.is_set():
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.connect((host, port))
+
+                obs = get_robot_state()              # your function
+                payload = arr2base64(obs)            # your encoder
+                message = json.dumps(payload) + '\n' # newline-delimited JSON
+
+                s.sendall(message.encode())
+                # print("[Client] Payload sent:", payload)
+            except KeyboardInterrupt:
+                print("\n[Client] Interrupted by user. Shutting down.")
+                break
+            except Exception as e:
+                print("[Client] Error during send:", e) 
+                break
+            time.sleep(interval)
+    finally:
+        s.close()
+
+def move_to(location):
+    # global gripper_orientation_quat, env
+    distance_to_target = 1
+    while distance_to_target > 0.01:
+        ENV.move_to_ee_target_pose(ee_target_pos=location, control_mode = 'quat', iter_steps = 3)
+        state = get_robot_state()
+        distance_to_target = np.linalg.norm(state[:3] - location[:3])
+
+
+def receive_info():
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((HOST, PORT_RECV))
+    data = s.recv(4096)
+    response = json.loads(data.decode())
+    response = base64_to_arr(response)
+    print("[Client] Got from server:", response)
+    return response
+
+if __name__ == "__main__":
+    debug = False
+    joint1 = [0.14060218312656647, -0.1763630612130337, 0.04729701053311961, -1.2449121625967192, 0.029108238965272905, 1.1071924595832823, 0.9375217847931281]
+    joint2 = [0.19482878609080095, -0.1490429622283628, -0.48674890603699533, -1.520728926089772, -0.08023853053649267, 1.4145816124984727, 0.3123271169454759]
+    joint3 = [-0.30347477500480513, -0.12699215018749238, -0.0885380081042202, -1.1491600061885097, -0.05358308494422171, 1.0893443137146492, 0.25052567082056587]
+    # joint4 = [-0.2534497408239465, 0.14847098046645785, -0.12020468637205217, -2.1994750877179596, -0.024345323815941806, 2.3565164618492127, 0.7671496500118045]
+    ENV.move_to_joint_position(joint2)
+    if debug:
+        ENV.move_to_ee_target_pose(GOAL_POSE, control_mode = 'quat', iter_steps =200)
+    else:
+        stop_event = threading.Event()
+        thread = threading.Thread(target=send_observation, args=(stop_event,))
+        thread.start()
+        # Part 1
+        step = 0
+        done = False
+        while not done:
+            print("Observation: ", get_robot_state()[:7])
+            action = receive_info()
+            move_to(action)
+            position_diff = np.linalg.norm(GOAL_POSE[:3] - get_robot_state()[:3])
+            print("Step: ", step, "Position diff: ", position_diff)
+            if position_diff < 0.02:
+                done = True
+            step +=1
+        GOAL_POSE[2] -= 0.055
+        ENV.move_to_ee_target_pose(GOAL_POSE, control_mode = 'quat', iter_steps = 20)
+        ENV.grasp()
+
+        # Part 2
+        GOAL_POSE[2] = 0.20 # 4
+        move_to(GOAL_POSE)
+
+        # Move Above
+        GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.20, 0.0, 0.66, 0.75, 0.0])
+        move_to(GOAL_POSE)
+
+
+        GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.10, 0.0, 0.66, 0.75, 0.0])
+        move_to(GOAL_POSE)
+        ENV.open_grasp()
+
+
+        GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.20, 0.0, 0.66, 0.75, 0.0])
+        move_to(GOAL_POSE)
+        ENV.reset()
+        stop_event.set()
+        # step = 0
+        # done = False
+        # while not done:
+        #     print("Observation: ", get_robot_state()[:7])
+        #     action = receive_info()
+        #     move_to(action)
+        #     position_diff = np.linalg.norm(GOAL_POSE[:3] - get_robot_state()[:3])
+        #     print("Step: ", step, "Position diff: ", position_diff)
+        #     if position_diff < 0.01:
+        #         done = True
+        # #     step +=1
+        # GOAL_POSE[2] -= 0.1
+        # ENV.move_to_ee_target_pose(GOAL_POSE, control_mode = 'quat', iter_steps = 20)
+        # ENV.reset()
+        # stop_event.set()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/robot_controller_joint.py

@@ -0,0 +1,201 @@
+import sys
+sys.path.append('/home/ladmin/Documents/maniskill2_benchmark/')
+sys.path.append('/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/')
+sys.path.append('/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/franka_gym/')
+import time
+import json
+import socket
+import threading
+
+import numpy as np
+import gym
+import franka_gym
+from franka_gym.utils import *
+from franka_gym.agents import *
+
+from cfdp.utils.socket_utils import arr2base64, base64_to_arr
+
+
+CONFIG_FILE_PATH = '/home/ladmin/Documents/maniskill2_benchmark/franka_robot_wrapper/franka_gym/configs/example.yaml'
+CONFIGS = configure(CONFIG_FILE_PATH)
+CONF_EXP = CONFIGS['experiment']
+ENV = gym.make(CONF_EXP['env-name'], config_file=CONFIG_FILE_PATH)
+ENV.reset()
+# GOAL_POSE = np.array([0.45, 0.40, 0.08, 0.0, -1.0, 0.0, 0.0]) # Set a goal pose for the robot to move to
+# GOAL_POSE_JOINT = np.array([1.24, 0.44, 0.09, -2.15, -0.07, 2.64, 1.05, 0.04, 0.04])
+# GOAL_POSE_JOINT = np.array([0.654, 1.651, -1.608, -2.116, 0.626, 3.008, 1.775, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.13, 0.56, 0.09, 0.01, -0.85, -0.52, -0.01])
+# GOAL_POSE_JOINT = np.array([1.08, 0.48, -0.06, -2.24, 0.22, 2.66, 0.83, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.27, 0.45, 0.04, 0.01, -0.92, -0.38, 0.05])
+# # The working one for now:
+# GOAL_POSE_JOINT = np.array([0.80, 0.49, 0.05, -1.74, -0.06, 2.24, -0.04, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.44, 0.50, 0.19, 0.01, 0.66, 0.75, 0.01])
+# # # The one for the shelf:
+# GOAL_POSE_JOINT = np.array([-0.89, 0.17, -0.47, -1.22, 0.06, 1.37, 0.71, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.16, -0.56, 0.57, -0.00, -0.81, 0.59, 0.01])
+
+# # The one for the shelf:
+# GOAL_POSE_JOINT = np.array([0.37, 1.73, -1.19, -1.58, 1.79, 2.92, 0.74, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.55, -0.48, 0.05, -0.27, -0.70, 0.52, -0.38])
+
+# Lower Shelf, Top Down
+GOAL_POSE_JOINT = np.array([-0.74, 1.07, -0.31, -0.98, 0.29, 2.05, 0.70, 0.04, 0.04])
+GOAL_POSE_EE = np.array([0.48, -0.63, 0.11, -0.01, -0.89, 0.45, -0.01])
+
+# # Top Shelf
+# GOAL_POSE_JOINT = np.array([-1.09, 0.49, 0.05, -0.79, -0.04, 1.31, 0.80, 0.04, 0.04])
+# GOAL_POSE_EE = np.array([0.32, -0.58, 0.55, -0.01, -0.86, 0.51, -0.01])
+
+# Another Lower Shelf
+GOAL_POSE_JOINT = np.array([-0.55, 1.25, -0.36, -0.91, 0.40, 2.18, 0.43, 0.04, 0.04])
+GOAL_POSE_EE = np.array([0.59, -0.54, 0.03, -0.02, -0.97, 0.26, -0.03])
+
+HOST='127.0.0.1'
+i = 2
+PORT_SEND=5000 + (2*i)
+PORT_RECV=5001 + (2*i)
+
+def get_robot_state():
+    try:
+        state = ENV.get_state()
+        joint_state = np.concatenate([state['joint_pos'][:7], np.array([0, 0])]) # TODO: Change to joint state -- Check if this is correct
+        robot_state = state['ee_states'][:7]
+        combined_state = np.concatenate([joint_state, GOAL_POSE_JOINT, robot_state, GOAL_POSE_EE])
+        return combined_state
+    except Exception as e:
+        print(f"Error getting robot state: {e}")
+        return None
+
+def send_observation(stop_event, host=HOST, port=PORT_SEND, interval=0.5):
+    try:
+        while not stop_event.is_set():
+            try:
+                s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                s.connect((host, port))
+
+                obs = get_robot_state()              # your function
+                payload = arr2base64(obs)            # your encoder
+                message = json.dumps(payload) + '\n' # newline-delimited JSON
+
+                s.sendall(message.encode())
+                # print("[Client] Payload sent:", payload)
+            except KeyboardInterrupt:
+                print("\n[Client] Interrupted by user. Shutting down.")
+                break
+            except Exception as e:
+                print("[Client] Error during send:", e) 
+                break
+            time.sleep(interval)
+    finally:
+        s.close()
+
+def move_to(location):
+    # global gripper_orientation_quat, env
+    # distance_to_target = 1
+    # while distance_to_target > 0.01:
+    ENV.move_to_joint_position(location[:7])
+        # state = get_robot_state()
+        # distance_to_target = np.linalg.norm(state[:7] - location[:7])
+        # print("Distance to target: ", distance_to_target)
+
+
+def receive_info():
+    s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    s.connect((HOST, PORT_RECV))
+    data = s.recv(20000)
+    response = json.loads(data.decode())
+    response = base64_to_arr(response)
+    print("[Client] Got from server:", response)
+    return response
+
+if __name__ == "__main__":
+    debug = False
+    # Robot Frame: X-Axis, Y-Axis, Z-Axis
+    FRONT_MID_HIGH_0 = [0.079, -0.237, -0.059, -1.550, 0.029, 1.349, 0.721, 0.04, 0.04] #  High
+    FRONT_MID_HIGH_1 = [0.141, -0.176, 0.047, -1.245, 0.029, 1.107, 0.938, 0.04, 0.04] # Extra High
+    FRONT_LEFT_HIGH_0 = [0.195, -0.109, -0.487, -1.521, -0.080, 1.415, 0.312, 0.04, 0.04]
+    BACK_RIGHT_LOW_0 = [1.65, 0.33, 0.33, -2.12, -0.09, 2.48, 1.15]
+    BACK_RIGHT_HIGH_0 = [1.92, 0.12, 0.01, -1.29, 0.07, 1.52, 1.12]
+    TOP_SHELF_0 = [-1.09, 0.49, 0.05, -0.79, -0.04, 1.31, 0.80]
+    LOW_SHELF_0 = [-0.87, 1.17, 0.05, -0.95, -0.04, 2.19, 0.75]
+    FRONT_LEFT_TABLE_0 = [-0.84, 0.49, 0.20, -2.33, -0.16, 2.77, 0.50]
+    FRONT_MID_MID_0 = [0.25, 0.31, -0.09, -1.98, 0.01, 2.25, 0.85]
+    SHELF_LOW_0 = np.array([0.37, 1.73, -1.19, -1.58, 1.79, 2.92, 0.74, 0.04, 0.04])
+
+    # ENV.move_to_joint_position(GOAL_POSE_JOINT)
+    ENV.move_to_joint_position(BACK_RIGHT_HIGH_0)
+    # ENV.grasp()
+    grasp = True
+    # reset = True
+    # if reset:
+    #     GRASP_JOINT = [1.82, 0.61, 0.16, -2.10, -0.09, 2.72, 1.23]
+    #     ENV.move_to_joint_position(GRASP_JOINT)
+    #     ENV.open_grasp()
+    #     ENV.move_to_joint_position(BACK_RIGHT_LOW_0)
+
+    if grasp:
+        GRASP_JOINT = [1.82, 0.61, 0.16, -2.10, -0.09, 2.72, 1.23]
+        ENV.move_to_joint_position(GRASP_JOINT)
+        ENV.grasp()
+        # ENV.open_grasp()
+        ENV.move_to_joint_position(BACK_RIGHT_HIGH_0)
+        
+    if debug:
+        pass
+    else:
+        stop_event = threading.Event()
+        thread = threading.Thread(target=send_observation, args=(stop_event,))
+        thread.start()
+        # Part 1
+        step = 0
+        done = False
+        while not done:
+            print("Observation: ", get_robot_state()[:7])
+            action = receive_info()
+            move_to(action)
+            position_diff = np.linalg.norm(GOAL_POSE_JOINT[:7] - get_robot_state()[:7])
+            print("Step: ", step, "Position diff: ", position_diff)
+            if position_diff < 0.2:
+                done = True
+            step += 1
+        ENV.open_grasp()
+
+    #     # GOAL_POSE[2] -= 0.055
+    #     # ENV.move_to_ee_target_pose(GOAL_POSE, control_mode = 'quat', iter_steps = 20)
+    #     # ENV.grasp()
+
+    #     # # Part 2
+    #     # GOAL_POSE[2] = 0.20 # 4
+    #     # move_to(GOAL_POSE)
+
+    #     # # Move Above
+    #     # GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.20, 0.0, 0.66, 0.75, 0.0])
+    #     # move_to(GOAL_POSE)
+
+
+    #     # GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.10, 0.0, 0.66, 0.75, 0.0])
+    #     # move_to(GOAL_POSE)
+    #     # ENV.open_grasp()
+
+
+    #     # GOAL_POSE = np.array([-0.13914922, 0.67478615, 0.20, 0.0, 0.66, 0.75, 0.0])
+    #     # move_to(GOAL_POSE)
+    #     # ENV.reset()
+    #     # stop_event.set()
+    #     # step = 0
+    #     # done = False
+    #     # while not done:
+    #     #     print("Observation: ", get_robot_state()[:7])
+    #     #     action = receive_info()
+    #     #     move_to(action)
+    #     #     position_diff = np.linalg.norm(GOAL_POSE[:3] - get_robot_state()[:3])
+    #     #     print("Step: ", step, "Position diff: ", position_diff)
+    #     #     if position_diff < 0.01:
+    #     #         done = True
+    #     # #     step +=1
+    #     # GOAL_POSE[2] -= 0.1
+    #     # ENV.move_to_ee_target_pose(GOAL_POSE, control_mode = 'quat', iter_steps = 20)
+    #     # ENV.reset()
+    #     # stop_event.set()
+
+   

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/run.py

@@ -0,0 +1,103 @@
+# A script to train diffusion / FM policy
+import os
+import torch
+import hydra
+import wandb
+from omegaconf import DictConfig, OmegaConf
+import cfdp
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_loss, get_model, get_summary
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.diffusion_policy import trainer
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_ms3_history_ddim")
+def main(cfg: DictConfig):
+    os.environ["WANDB_MODE"] = "disabled"
+    # ... existing code ...
+    print(OmegaConf.to_yaml(cfg))
+
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+
+    print("train data_loader length, ", len(train_dataloader))
+    print("val data_loader length, ", len(val_dataloader))
+
+    dataset = train_subset.dataset #TrajectoryDataset
+    print("dataset, ", dataset)
+    
+    # Model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # Loss
+    loss_fn = val_loss_fn = get_loss(
+        loss_class=cfg.loss.loss_class
+    ) 
+    print("loss_fn, ", loss_fn, " type of loss_fn, ", type(loss_fn))
+
+    # Summary
+    summary_fn = get_summary(
+        summary_class=cfg.training.summary_class,
+        use_ddim=cfg.model.use_ddim
+    )
+
+    # WandB
+    wandb.init(
+        project=cfg.wandb.project,
+        entity=cfg.wandb.entity,
+        mode=cfg.wandb.mode,
+        dir=cfg.results_dir
+    )
+
+    print("number of epochs, ", trainer.get_num_epochs(cfg.training.num_steps, cfg.batch_size, len(dataset)))
+    # Train
+    trainer.train(
+        model=model,
+        train_dataloader=train_dataloader,
+        train_subset=train_subset,
+        val_dataloader=val_dataloader,
+        val_subset=train_subset,
+        epochs=trainer.get_num_epochs(cfg.training.num_steps, cfg.batch_size, len(dataset)),
+        model_dir=cfg.results_dir,
+        summary_fn=summary_fn,
+        lr=cfg.training.lr,
+        loss_fn=loss_fn,
+        val_loss_fn=val_loss_fn,
+        steps_til_summary=cfg.training.steps_til_summary,
+        steps_til_checkpoint=cfg.training.steps_til_ckpt,
+        clip_grad=True,
+        use_ema=cfg.training.use_ema,
+        use_amp=cfg.training.use_amp,
+        debug=cfg.debug,
+        tensor_args={'device': cfg.device, 'dtype': torch.float32}
+    )
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/run_inference.py

@@ -0,0 +1,334 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+import mani_skill2.envs
+import cfdp.envs as envs  # customized environments
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.envs import ROBOT_ASSETS_DIR
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.envs import ENVS_DIR
+
+import random
+import time
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+OBSTACLE_CONFIGS = []
+# OBSTACLE_CONFIGS = [
+#     # {
+#     #     'type': 'box',
+#     #     'half_size': [0.05, 0.05, 0.05],
+#     #     'pose': [0.5, 0, 0.1],  # [x, y, z, qw, qx, qy, qz]
+#     #     'color': (1, 0, 0),
+#     #     'n_points': 500
+#     # },
+#     {
+#         'type': 'sphere',
+#         'radius': 0.12,
+#         'pose': [0.5, 0.1, 0.2],
+#         'color': (0, 1, 0),
+#         'n_points': 500
+#     }
+#     # {
+#     #     'type': 'mesh',
+#     #     'mesh_path': 'path/to/mesh.obj',
+#     #     'scale': 1.0,
+#     #     'pose': [0.4, -0.2, 0.1, 1, 0, 0, 0],
+#     #     'color': (0, 0, 1),
+#     #     'n_points': 500
+#     # }
+# ]
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    #TODO: save / load normalizer. Do not use dataset
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+
+    ########################################################################################################################
+    
+    # Create environment
+    # env = gym.make('CustomizedPick-v0',
+    #                obs_mode=cfg.inference.obs_mode,
+    #                reward_mode=cfg.inference.reward_mode,
+    #                control_mode=cfg.inference.control_mode,
+    #                enable_shadow=False,
+    #                render_mode="cameras" if cfg.inference.evaluate else "human",
+    #                robot_init_qpos_noise=0.5,
+    #                obstacle_configs=OBSTACLE_CONFIGS,
+    #                object_config_path=os.path.join(ENVS_DIR, "env_config","smallbox_distractor"),
+    #             #    object_config_path=os.path.join(ENVS_DIR, "env_config","distractorbox"),
+    #             #    object_config_path=os.path.join(ENVS_DIR, "env_config","distractor25"),
+    #             #    object_config_path=os.path.join(ENVS_DIR, "env_config"),
+    #             #    object_config_path=os.path.join(ENVS_DIR, "concept_env_config"),
+    #                create_obstacle_point_cloud=True)
+
+    env = gym.make(cfg.inference.env_id,
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                   render_mode="cameras" if cfg.inference.evaluate else "human",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                   object_config_path=os.path.join(ENVS_DIR, "env_config","shelf"),
+                   create_obstacle_point_cloud=True)
+
+    # Initialize guide manager
+    # guide = GuideManagerPath(
+    #         dataset = train_subset.dataset,
+    #         clip_grad=True,
+    #         tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    #         guidance_weight=cfg.inference.guidance_weight,
+    # )
+    guide = None
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        debug=cfg.debug)
+
+    # Initialize a classical policy for reject sampling
+    agent = env.unwrapped.agent
+    planner_parameters = {
+        'action_dim': env.action_space.shape[0],
+        'urdf_path': os.path.join(ROBOT_ASSETS_DIR, "panda_v2.urdf"),
+        'srdf_path': os.path.join(ROBOT_ASSETS_DIR, "panda_v2.srdf"),
+        'agent': agent,
+        'control_timestep': env.control_timestep,
+        'planner_type': 'rrt'
+    }
+    classical_policy = ClassicalMotionPlannerPolicy(**planner_parameters)
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    ## inference recorder ##
+    if cfg.test.inference_record:
+        obs_inference_recorder = inference_recorder.InferenceRecorder(save_dir=cfg.test.recording_dir)
+    else:
+        obs_inference_recorder = None
+    ######################### main inference loop #########################
+    if cfg.inference.validation_set_only:
+         # run inference using validation set only
+        for _ in range(10):
+            combined_trajectories = generate_trajectories(model, val_subset.dataset, 10, cfg.trajectory_length)
+            plot_trajectories(combined_trajectories)
+
+    elif cfg.inference.sim_with_history:
+        def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+            trajectory_index = policy.get_current_path_index()
+            trajectory_prior = trajectory_ortho6d[trajectory_index:]
+            current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+                torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+            ).squeeze(0)
+            # Create a copy of the concatenated tensor to ensure we return a new object
+            result = torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0).clone()
+            return result
+
+        done = False
+        truncated = False
+        episode_count = 0
+        total_episodes = cfg.inference.episodes
+        episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+        
+        obs, _ = env.reset() # Obs Dict -- obs['extra']['tcp_pose']
+        policy.reset()
+        trajectory_prior = None
+
+        timestamp = time.strftime("%m%d_%H%M")
+        image_saving_path=os.path.join("/home/xuan/Documents/test_result", timestamp)
+
+        while episode_count < total_episodes:
+            try:   
+                step = 0
+                replanning_count = 0
+                while not (done or truncated):
+                    # Update obsqueue
+                    policy.observation_wrapper.update_history_buffer(obs)
+                    
+                    if not cfg.debug:
+                        env.render()
+                    
+                    replanning_interval = 4
+                    new_path = False
+                    if step % replanning_interval == 0:
+
+                        if step == 0: # initial planning
+                            policy.plan_path_with_history(obs, do_normalize=True)
+                            visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+                            # visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+                            new_path = True
+                        else: # replanning
+                            position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+                            if position_diff > 0.10:
+                                print("Replanning count: ", replanning_count, "position_diff: ", position_diff)
+                                ## replanning with prior
+                                trajectory_prior = create_trajectory_prior(policy, obs, policy.planned_path)
+                                denoising_steps = 3
+                                policy.plan_path_with_history(obs, 
+                                                            trajectory_prior=trajectory_prior, 
+                                                            do_normalize=True, 
+                                                            timestep=denoising_steps,  # denoising step
+                                                            choice='interpolate')
+                                ## replanning without prior
+                                # trajectory_ortho6d = policy.plan_path_with_history(obs, do_normalize=True)
+                                new_path = True
+                                replanning_count += 1
+                        # visualize trajectory with point cloud after replanning
+                        # if not cfg.debug:
+                        #     visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+                        if cfg.debug and policy.all_trajs is not None and new_path:
+                            plot_trajectories(policy.all_trajs, 
+                                            save_path=os.path.join(image_saving_path, str(episode_count), "multi_samples"))
+                            visualizer.plot_path_with_guidance(policy.model.diffusion_history, 
+                                                policy.model.grad_scaled_history,
+                                                point_cloud=policy.point_cloud,
+                                                save_path=os.path.join(image_saving_path, str(episode_count), "guidance"))
+                    if  cfg.test.inference_record:
+                        obs_inference_recorder.record_step(obs, 
+                                                           trajectory_prior=trajectory_prior,
+                                                           all_samples=policy.all_trajs, 
+                                                           planned_path=policy.planned_path)
+                
+                    action = policy.follow_path(obs) #delta end-effector pose
+                    obs, reward, done, truncated, info = env.step(action)
+                    step += 1
+                
+                if  cfg.test.inference_record:
+                    obs_inference_recorder.save_episode()
+
+                print("Simulation Done", "Total replanning count: ", replanning_count) 
+                obs, info = env.reset(options={"reconfigure": True})
+                policy.reset()
+                trajectory_prior = None
+                done = False
+                truncated = False
+                episode_count += 1
+                episode_pbar.update(1)  # Update progress bar
+            except KeyboardInterrupt:
+                print("\nStopping simulation...")
+                break
+        print("Simulation finished")
+        episode_pbar.close()  # Close progress bar
+        env.close() 
+
+    else:
+        #DDPM sampling and following trajectory in environment#
+        done = False
+        truncated = False
+        episode_count = 0
+        total_episodes = cfg.inference.episodes
+        # Create progress bar for episodes
+        episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+        
+        obs, _ = env.reset()
+
+        #### following trajectory ######
+        while episode_count < total_episodes:
+            print("obs start& goal: ", obs['extra'])
+            try:
+                classical_result = classical_policy.plan_path(obs)
+                while not (done or truncated or classical_result is None):
+                    action = policy(obs)
+                    
+                    # if policy.all_trajs is not None:
+                    #     plot_trajectories(policy.all_trajs)
+                    # visualizer.plot_trajectory(
+                    #     planned_path=policy.planned_path,
+                    #     obs=obs,
+                    #     point_cloud=policy.point_cloud
+                    # )
+                    if action is None:  
+                        print("Policy failed to generate action")
+                        break
+                    obs, reward, done, truncated, info = env.step(action)
+                    env.render()
+                
+                obs, info = env.reset(options={"reconfigure": True})
+                
+                policy.reset()
+                done = False
+                truncated = False
+                episode_count += 1
+                episode_pbar.update(1)  # Update progress bar
+                
+            except KeyboardInterrupt:
+                print("\nStopping simulation...")
+                break
+
+        episode_pbar.close()  # Close progress bar
+        env.close()
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/run_joint_demo.py

@@ -0,0 +1,321 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+import mani_skill2.envs
+import cfdp.envs as envs  # customized environments
+from cfdp.envs import ENVS_DIR
+
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.diffusion_policy.models.sample_functions import ddpm_sample_fn_stomp
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.envs import ROBOT_ASSETS_DIR
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerSTOMP
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.motion_planner.motion_controller import EndEffectorController
+from mani_skill2.utils.wrappers import RecordEpisode
+
+import random
+import time
+from matplotlib import pyplot as plt
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+OBSTACLE_CONFIGS = []
+
+
+def plot_STOMP_debug_info(guide_debug_into, visualizer, point_cloud=None, 
+                          sphere_idx=24, time_step=-1):
+    print(len(guide_debug_into))
+    sphere_trajectories = guide_debug_into[time_step].sphere_poses.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sphere_radii = guide_debug_into[time_step].sphere_radii.cpu().numpy() # [batch, seq_len, num_spheres]
+    sdf_costs = guide_debug_into[time_step].sdf_costs.cpu().numpy() # [batch, seq_len, num_spheres]
+    spheres_after_guidance = guide_debug_into[time_step].spheres_after_guidance.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sampled_spheres = guide_debug_into[time_step].sampled_spheres.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    #TODO: plot spheres_after_guidance
+    fig = visualizer.plot_trajectory_with_cost(sphere_trajectories, 
+                                         sdf_costs, 
+                                         spheres_after_guidance=spheres_after_guidance, 
+                                         sampled_spheres=sampled_spheres,
+                                         point_cloud=point_cloud, 
+                                         sphere_idx=sphere_idx,
+                                         time_step=time_step)
+    return fig
+
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history_joint")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    #TODO: save / load normalizer. Do not use dataset
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, 
+                               out_dim=cfg.model.conditioning_embed_dim, 
+                               input_field='tasks', 
+                               output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+    collision_lists = []
+    ########################################################################################################################
+    env = gym.make(cfg.inference.env_id,
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                #    render_mode="cameras" if cfg.inference.evaluate else "human",
+                   render_mode="human",
+                #    render_mode="cameras",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                   object_config_path=os.path.join(ENVS_DIR, "env_config","shelf"),
+                   create_obstacle_point_cloud=True,
+                   is_demo=True)
+
+    # Initialize guide manager
+    # guide = None
+    guide = GuideManagerSTOMP(
+        dataset = train_subset.dataset,
+        robot_model = env.agent.robot,
+        clip_grad=True,
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        guidance_weight=cfg.inference.guidance_weight,
+    )
+
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type, use_ee_control=cfg.use_ee_control)
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        use_ee_control=cfg.use_ee_control,
+        guide_manager=guide,
+        debug=cfg.debug)
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    ## controller to manually move the gripper ##
+    controller = EndEffectorController()
+    
+    ######################### main inference loop #########################
+    if cfg.inference.sim_with_history:
+        if cfg.use_ee_control:
+            def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+                trajectory_index = policy.get_current_path_index()
+                trajectory_prior = trajectory_ortho6d[trajectory_index:]
+                current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+                    torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+                ).squeeze(0)
+                return torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0)
+        else:
+            def create_trajectory_prior(policy, obs, trajectory):
+                trajectory_index = policy.get_current_path_index()
+                trajectory_prior = trajectory[trajectory_index:]
+                current_joint_pose = torch.tensor(obs['agent']['qpos']).to(cfg.device)
+                return torch.cat([current_joint_pose.unsqueeze(0), trajectory_prior], dim=0)
+
+
+    done = False
+    truncated = False
+    replanning_interval = 3
+    previous_replanning_index = -1
+    episode_count = 0
+    total_episodes = cfg.inference.episodes
+    episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+    
+    replanning_interval = cfg.inference.replanning_interval
+    print("replanning interval: ", replanning_interval)
+    obs, _ = env.reset() # Obs Dict -- obs['extra']['tcp_pose']
+    policy.reset()
+    trajectory_prior = None
+    
+    while episode_count < 1:
+        try:
+            step = 0
+            replanning_count = 0
+            while not (done or truncated):
+                # Update obsqueue
+                policy.observation_wrapper.update_history_buffer(obs)
+                new_path = True
+                env.render()
+
+                if step % replanning_interval == 0:
+                    
+                    if step == 0: # initial planning
+                        policy.plan_path_with_history(obs, do_normalize=True)
+                        new_path = True
+                    else: # replanning
+                        position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+                        if position_diff > 0.20:
+                            # print("Replanning count: ", replanning_count, "position_diff: ", position_diff)
+                            ## replanning with prior
+                            print("replanning with prior at step: ", step)
+                            trajectory_prior = create_trajectory_prior(policy, obs, policy.planned_path)
+                            denoising_steps = 4
+                            policy.plan_path_with_history(obs,
+                                                        trajectory_prior=trajectory_prior,
+                                                        do_normalize=True,
+                                                        timestep=denoising_steps,  # denoising step
+                                                        choice='interpolate')
+                            # # replanning without prior
+                            # trajectory_ortho6d = policy.plan_path_with_history(obs, do_normalize=True)
+                            replanning_count += 1
+
+                    fig1 = plot_STOMP_debug_info(guide.debug_state,
+                                              visualizer,
+                                              point_cloud=policy.point_cloud,
+                                              sphere_idx=24,
+                                              time_step=4)
+                    plt.show()
+                # visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+                
+                action = policy.follow_path(obs)
+                obs, reward, done, truncated, info = env.step(action)
+                step += 1
+
+            obs, info = env.reset(options={"reconfigure": True})
+            policy.reset()
+            trajectory_prior = None
+            done = False
+            truncated = False
+            episode_count += 1
+            episode_pbar.update(1)  # Update progress bar
+                
+        except KeyboardInterrupt:
+            print("\nStopping simulation...")
+            break
+    
+    print("Simulation finished")
+    episode_pbar.close()  # Close progress bar
+    env.close() 
+
+
+    # while episode_count < 1:
+    #     #### Planning ####
+    #     try:   
+    #         step = 0
+    #         replanning_count = 0
+    #         while not (done or truncated):
+    #             # Update obsqueue
+    #             policy.observation_wrapper.update_history_buffer(obs)
+                
+    #             if not cfg.debug:
+    #                 env.render()
+                
+    #             replanning_interval = 4
+    #             new_path = False
+    #             if step % replanning_interval == 0:
+
+    #                 if step == 0: # initial planning
+    #                     policy.plan_path_with_history(obs, do_normalize=True)
+    #                     # visualizer.plot_joint_trajectory(policy.all_trajs)
+    #                     # visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+    #                     new_path = True
+    #                     ## TODO:  debug plot, sphere positions and sdf cost
+    #                     fig1 = plot_STOMP_debug_info(guide.debug_state, 
+    #                                           visualizer,
+    #                                           point_cloud=policy.point_cloud,
+    #                                           sphere_idx=24,
+    #                                           time_step=4)
+    #                     fig2 = plot_STOMP_debug_info(guide.debug_state, 
+    #                                           visualizer,
+    #                                           point_cloud=policy.point_cloud,
+    #                                           sphere_idx=24,
+    #                                           time_step=0)
+    #                     fig3 = plot_STOMP_debug_info(guide.debug_state, 
+    #                                           visualizer,
+    #                                           point_cloud=policy.point_cloud,
+    #                                           sphere_idx=24,
+    #                                           time_step=2)
+    #                     plt.show()
+                
+    #             action = policy.follow_path(obs) #delta end-effector pose
+    #             obs, reward, done, truncated, info = env.step(action)
+    #             step += 1
+        
+    #         print("Open the gripper")
+    #         for _ in range(10):
+    #             action = controller.open_gripper(action)
+    #             obs, reward, done, truncated, info = env.step(action)
+    #             env.render()
+            
+    #         # Add a pause before resetting to see the final state
+    #         time.sleep(3.0)
+    #         print("Simulation Done", "Total replanning count: ", replanning_count) 
+    #         env.close()
+    #         obs, info = env.reset(options={"reconfigure": True})
+    #         policy.reset()
+    #         trajectory_prior = None
+    #         done = False
+    #         truncated = False
+    #         episode_count += 1
+    #         episode_pbar.update(1)  # Update progress bar
+    #     except KeyboardInterrupt:
+    #         print("\nStopping simulation...")
+    #         break
+    #     print("Simulation finished")
+    #     episode_pbar.close()  # Close progress bar
+    #     env.close() 
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/run_ms3_task_demo.py

@@ -0,0 +1,253 @@
+import os
+import hydra
+from typing import Any, Callable, Dict, List, Optional
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+from tqdm import tqdm
+import numpy as np
+import torch
+import random
+import copy,time
+from matplotlib import pyplot as plt
+import sapien.core as sapien
+from mani_skill.utils.wrappers.record import RecordEpisode
+#from mani_skill2.trajectory.merge_trajectory import merge_trajectories
+
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath, TrajectoryRanker
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.motion_planner.motion_controller import EndEffectorController
+from cfdp.motion_planner.adaptive_trigger_wrapper import AdaptiveTrigger
+
+import msx_envs
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+def plot_traj_ranking_debug_info(rank_debug_info, visualizer, point_cloud=None, 
+                                 sphere_idx=24, time_step=-1):
+    print(len(rank_debug_info))
+    sphere_trajectories = rank_debug_info[time_step].sphere_poses.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sphere_radii = rank_debug_info[time_step].sphere_radii.cpu().numpy() # [batch, seq_len, num_spheres]
+    sdf_costs = rank_debug_info[time_step].sdf_costs.cpu().numpy() # [batch, seq_len, num_spheres]
+    fig = visualizer.plot_trajectory_with_cost(sphere_trajectories, 
+                                         sdf_costs, 
+                                         spheres_after_guidance=None, 
+                                         sampled_spheres=None,
+                                         point_cloud=point_cloud, 
+                                         sphere_idx=sphere_idx,
+                                         time_step=time_step)
+    return fig
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_ms3_history_ddim")
+def main(cfg: DictConfig):
+    print(OmegaConf.to_yaml(cfg))
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, 
+                               out_dim=cfg.model.conditioning_embed_dim, 
+                               input_field='tasks', 
+                               output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+    collision_lists = []
+
+    # create env and run inference control
+    env = gym.make(
+        cfg.inference.env_id,
+        obs_mode=cfg.inference.obs_mode,
+        control_mode=cfg.inference.control_mode,
+        render_mode="human",
+        reward_mode=cfg.inference.reward_mode,
+        enable_shadow=False,
+        robot_init_qpos_noise = 0.2,
+        rand_level=1,
+        robot_uids="panda_sphere",
+        object_config_dir="base_configs/base_table_shelf.yaml",
+        # object_config_dir="base_configs/base_table.yaml",
+        is_inference=True
+    )
+    env = RecordEpisode(env, output_dir="videos", save_trajectory=True, trajectory_name="trajectory", save_video=True, video_fps=30)
+
+    # guide = None
+    # rank_fn = None
+    guide = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=cfg.inference.guidance_weight,
+    )
+    rank_fn = TrajectoryRanker(
+        dataset = train_subset.dataset,
+        robot_model = env.agent.robot,
+        get_current_qpos=lambda: env.agent.robot.get_qpos(),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    )
+
+    # to process observations for the policy
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(
+                    dataset=train_subset.dataset, 
+                    camera_type=cfg.inference.camera_type,
+                    sensor_data_key="sensor_data",
+                    sensor_param_key="sensor_param"
+                )
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        rank_fn=rank_fn, #can be None
+        debug=cfg.debug)
+    
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    ## controller to manually move the gripper ##
+    controller = EndEffectorController()
+
+    # ###### main inference loop ######
+    # function to create trajectory prior for policy
+    def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+        trajectory_index = policy.get_current_path_index()
+        trajectory_prior = trajectory_ortho6d[trajectory_index:]
+        current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+            torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+        ).squeeze(0)
+        # Create a copy of the concatenated tensor to ensure we return a new object
+        result = torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0).clone()
+        return result
+
+    # new planner wrapper: adaptive planner
+    adaptive_trigger = AdaptiveTrigger(
+        policy=policy,
+        controller=controller,
+        create_trajectory_prior=create_trajectory_prior,
+        replanning_interval=30,
+        pos_threshold=0.10,
+        denoising_steps=3,
+        grip_threshold=0.03,
+        debug=cfg.debug
+    )
+
+    done = False
+    truncated = False
+    episode_count = 0
+    total_episodes = cfg.inference.episodes
+    episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+
+    obs, _ = env.reset() # Obs Dict -- obs['extra']['tcp_pose']
+
+    policy.reset()
+    trajectory_prior = None
+
+    robot_executed_path  = []
+    def print_keys(d):
+        for key, value in d.items():
+            print(key)
+            if isinstance(value, dict):
+                print_keys(value)
+
+    while episode_count < 5:
+        #### Planning ####
+        try:   
+            while not (done or truncated):
+                action = adaptive_trigger.step(obs, task = "grasp cup")
+                print(f"action: {action}")
+                obs, reward, done, truncated, info = env.step(action)
+                #print_keys(obs)
+                robot_executed_path.append(obs['extra']['tcp_pose'])
+                
+                if adaptive_trigger.step_idx % 40 == 0:
+                    visualizer.plot_trajectory(planned_paths = adaptive_trigger.policy.all_trajs, 
+                                                obs = obs, 
+                                                point_cloud=adaptive_trigger.policy.point_cloud,
+                                                simplified_paths = adaptive_trigger.policy.planned_path)
+                    # fig1 = plot_traj_ranking_debug_info(rank_fn.debug_state,
+                    #                           visualizer,
+                    #                           point_cloud=policy.point_cloud,
+                    #                           sphere_idx=24,
+                    #                           time_step=2)
+                    # visualizer.plot_trajectory(policy.all_trajs, obs, policy.point_cloud)
+                    plt.show()
+                    # visualizer.plot_trajectory(planned_paths = adaptive_trigger.policy.all_traj_normalized, 
+                    #                             obs = obs, 
+                    #                             point_cloud=adaptive_trigger.policy.point_cloud,
+                    #                             simplified_paths = adaptive_trigger.policy.planned_path)
+        
+                env.render()
+            
+            # Add a pause before resetting qto see the final state
+            time.sleep(3.0)
+            # print("Simulation Done", "Total replanning count: ", replanning_count) 
+            obs, info = env.reset()
+            adaptive_trigger.reset()
+            trajectory_prior = None
+            done = False
+            truncated = False
+            episode_count += 1
+            episode_pbar.update(1)  # Update progress bar
+        except KeyboardInterrupt:
+            print("\nStopping simulation...")
+            break
+    print("Simulation finished")
+    episode_pbar.close()  # Close progress bar
+    env.close() 
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/run_shelf_demo.py

@@ -0,0 +1,286 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+import mani_skill2.envs
+import cfdp.envs as envs  # customized environments
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.envs import ROBOT_ASSETS_DIR
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath, TrajectoryRanker
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.envs import ENVS_DIR
+from cfdp.motion_planner.motion_controller import EndEffectorController
+from mani_skill2.utils.wrappers import RecordEpisode
+
+import random
+import time
+from matplotlib import pyplot as plt
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+OBSTACLE_CONFIGS = []
+
+def plot_traj_ranking_debug_info(rank_debug_info, visualizer, point_cloud=None, 
+                                 sphere_idx=24, time_step=-1):
+    print(len(rank_debug_info))
+    sphere_trajectories = rank_debug_info[time_step].sphere_poses.cpu().numpy() # [batch, seq_len, num_spheres, 3]
+    sphere_radii = rank_debug_info[time_step].sphere_radii.cpu().numpy() # [batch, seq_len, num_spheres]
+    sdf_costs = rank_debug_info[time_step].sdf_costs.cpu().numpy() # [batch, seq_len, num_spheres]
+    fig = visualizer.plot_trajectory_with_cost(sphere_trajectories, 
+                                         sdf_costs, 
+                                         spheres_after_guidance=None, 
+                                         sampled_spheres=None,
+                                         point_cloud=point_cloud, 
+                                         sphere_idx=sphere_idx,
+                                         time_step=time_step)
+    return fig
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history_ddim")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    #TODO: save / load normalizer. Do not use dataset
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, 
+                               out_dim=cfg.model.conditioning_embed_dim, 
+                               input_field='tasks', 
+                               output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+    collision_lists = []
+    ########################################################################################################################
+    env = gym.make(cfg.inference.env_id,
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                #    render_mode="cameras" if cfg.inference.evaluate else "human",
+                   render_mode="human",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                   object_config_path=os.path.join(ENVS_DIR, "env_config","shelf"),
+                   create_obstacle_point_cloud=True,
+                   is_demo=True)
+
+    # Initialize guide manager
+    # guide = None
+    guide = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=cfg.inference.guidance_weight,
+    )
+    
+    # guide = GuideManagerJointStates(
+    #     dataset = train_subset.dataset,
+    #     robot_model = env.agent.robot,
+    #     clip_grad=True,
+    #     tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    #     guidance_weight=cfg.inference.guidance_weight,
+    # )
+
+    rank_fn = TrajectoryRanker(
+        dataset = train_subset.dataset,
+        robot_model = env.agent.robot,
+        get_current_qpos=lambda: env.agent.robot.get_qpos(),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    )
+
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        rank_fn=rank_fn, #can be None
+        debug=cfg.debug)
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    ## controller to manually move the gripper ##
+    controller = EndEffectorController()
+    
+    ######################### main inference loop #########################
+    def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+        trajectory_index = policy.get_current_path_index()
+        trajectory_prior = trajectory_ortho6d[trajectory_index:]
+        current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+            torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+        ).squeeze(0)
+        # Create a copy of the concatenated tensor to ensure we return a new object
+        result = torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0).clone()
+        return result
+
+    # env = RecordEpisode(env, "/home/rui/Documents/maniskill2_benchmark", clean_on_close=False, save_video=True)
+
+    done = False
+    truncated = False
+    episode_count = 0
+    total_episodes = cfg.inference.episodes
+    episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+    
+    obs, _ = env.reset() # Obs Dict -- obs['extra']['tcp_pose']
+    policy.reset()
+    trajectory_prior = None
+
+    while episode_count < 1:
+
+        #### Move down the gripper and grasp the object #####
+        # calculate target end-effector pose
+        # current_ee_pose = obs['extra']['tcp_pose']
+        # target_ee_pose = current_ee_pose + np.array([0, 0, -0.22, 0, 0, 0, 0])
+        # # move down the gripper
+        # for _ in range(30):
+        #     collision_spheres = env.obtain_collision_spheres()
+        #     # print("collision_spheres: ", collision_spheres)
+        #     current_ee_pose = obs['extra']['tcp_pose']
+        #     action = controller.computer_control(current_ee_pose, target_ee_pose)
+        #     action = controller.open_gripper(action)
+        #     obs, reward, done, truncated, info = env.step(action)
+        #     ret = env.render()
+        #     # print(type(ret))
+        
+        # action = controller.computer_control(current_ee_pose, target_ee_pose)
+        # action = controller.close_gripper(action)
+        # obs, reward, done, truncated, info = env.step(action)
+        # env.render()
+        # print("Grasped the object")
+
+        #### Planning ####
+        try:   
+            step = 0
+            replanning_count = 0
+            while not (done or truncated):
+                # Update obsqueue
+                policy.observation_wrapper.update_history_buffer(obs)
+                
+                if not cfg.debug:
+                    env.render()
+                
+                replanning_interval = 10
+                new_path = False
+                if step % replanning_interval == 0:
+
+                    if step == 0: # initial planning
+                        policy.plan_path_with_history(obs, do_normalize=True)
+                        # visualizer.plot_trajectory(policy.all_trajs, obs, policy.point_cloud)
+                        # visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+                        new_path = True
+                    else: # replanning
+                        position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+                        if position_diff > 0.10:
+                            print("Replanning count: ", replanning_count, "position_diff: ", position_diff)
+                            ## replanning with prior
+                            trajectory_prior = create_trajectory_prior(policy, obs, policy.planned_path)
+                            denoising_steps = 3
+                            policy.plan_path_with_history(obs, 
+                                                        trajectory_prior=trajectory_prior, 
+                                                        do_normalize=True, 
+                                                        timestep=denoising_steps,  # denoising step
+                                                        choice='interpolate')
+                            ## replanning without prior
+                            # trajectory_ortho6d = policy.plan_path_with_history(obs, do_normalize=True)
+                            new_path = True
+                            replanning_count += 1
+                    
+                    # fig1 = plot_traj_ranking_debug_info(rank_fn.debug_state,
+                    #                           visualizer,
+                    #                           point_cloud=policy.point_cloud,
+                    #                           sphere_idx=24,
+                    #                           time_step=2)
+                    # visualizer.plot_trajectory(policy.all_trajs, obs, policy.point_cloud)
+                    # plt.show()
+
+                action = policy.follow_path(obs) #delta end-effector pose
+                obs, reward, done, truncated, info = env.step(action)
+                step += 1
+        
+            print("Open the gripper")
+            for _ in range(10):
+                action = controller.open_gripper(action)
+                obs, reward, done, truncated, info = env.step(action)
+                env.render()
+            
+            # Add a pause before resetting to see the final state
+            time.sleep(3.0)
+            print("Simulation Done", "Total replanning count: ", replanning_count) 
+            env.close()
+            obs, info = env.reset(options={"reconfigure": True})
+            policy.reset()
+            trajectory_prior = None
+            done = False
+            truncated = False
+            episode_count += 1
+            episode_pbar.update(1)  # Update progress bar
+        except KeyboardInterrupt:
+            print("\nStopping simulation...")
+            break
+        print("Simulation finished")
+        episode_pbar.close()  # Close progress bar
+        env.close() 
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/scripts/sim_benchmark.py

@@ -0,0 +1,302 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+import mani_skill2.envs
+import cfdp.envs as envs  # customized environments
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_model, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.envs import ROBOT_ASSETS_DIR
+from cfdp.utils.data_utils import transform_quat_to_ortho6d
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath, GuideManagerSTOMP, TrajectoryRanker
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+from cfdp.envs import ENVS_DIR
+from mani_skill2.utils.wrappers import RecordEpisode
+
+import random
+import time
+
+np.random.seed(42)
+random.seed(42)
+
+# backtrace debug
+import faulthandler
+faulthandler.enable()
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+OBSTACLE_CONFIGS = []
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history_ddim")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    #TODO: save / load normalizer. Do not use dataset
+
+    ########################################################################################################################
+    # Load prior model
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        prediction_mode=cfg.model.prediction_mode,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+
+    ########################################################################################################################
+
+    # Create environment
+    # env = gym.make(cfg.inference.env_id,
+    #                obs_mode=cfg.inference.obs_mode,
+    #                reward_mode=cfg.inference.reward_mode,
+    #                control_mode=cfg.inference.control_mode,
+    #                enable_shadow=False,
+    #                render_mode="cameras" if cfg.inference.evaluate else "human",
+    #                robot_init_qpos_noise=0.5,
+    #                obstacle_configs=OBSTACLE_CONFIGS)
+
+    env = gym.make('CustomizedPick-v0',
+                   obs_mode=cfg.inference.obs_mode,
+                   reward_mode=cfg.inference.reward_mode,
+                   control_mode=cfg.inference.control_mode,
+                   enable_shadow=False,
+                   render_mode="cameras",
+                #    render_mode="human",
+                   robot_init_qpos_noise=0.5,
+                   obstacle_configs=OBSTACLE_CONFIGS,
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config","smallbox_distractor"),
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config","distractor25"),
+                   object_config_path=os.path.join(ENVS_DIR, "env_config","distractorbox"),
+                #    object_config_path=os.path.join(ENVS_DIR, "concept_env_config"),
+                   create_obstacle_point_cloud=True)
+    
+
+    # Initialize guide manager
+    if cfg.use_ee_control:
+        guide = GuideManagerPath(
+                dataset = train_subset.dataset,
+                clip_grad=True,
+                tensor_args={'device': cfg.device, 'dtype': torch.float32},
+                guidance_weight=cfg.inference.guidance_weight,
+        )
+        rank_fn = TrajectoryRanker(
+            dataset = train_subset.dataset,
+            robot_model = env.agent.robot,
+            get_current_qpos=lambda: env.agent.robot.get_qpos(),
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            )
+        print("use ee guide and rank_fn")
+    else:
+        guide = GuideManagerSTOMP(
+            dataset = train_subset.dataset,
+            robot_model = env.agent.robot,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=cfg.inference.guidance_weight,
+            )
+        print("use joint guide")
+        rank_fn = None
+
+    # guide = None
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    # obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, 
+                                          camera_type=cfg.inference.camera_type, 
+                                          use_ee_control=cfg.use_ee_control)
+
+    policy = NeuralMotionPlannerPolicy(
+        action_dim=env.action_space.shape[0],
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        use_ee_control=cfg.use_ee_control,
+        guide_manager=guide,
+        rank_fn=rank_fn,
+        debug=cfg.debug)
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+
+    ## inference recorder ##
+    if cfg.test.inference_record:
+        obs_inference_recorder = inference_recorder.InferenceRecorder(save_dir=cfg.test.recording_dir)
+    else:
+        obs_inference_recorder = None
+
+    if cfg.inference.sim_with_history:
+        if cfg.use_ee_control:
+            def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+                trajectory_index = policy.get_current_path_index()
+                trajectory_prior = trajectory_ortho6d[trajectory_index:]
+                current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+                    torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+                ).squeeze(0)
+                return torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0)
+        else:
+            def create_trajectory_prior(policy, obs, trajectory):
+                trajectory_index = policy.get_current_path_index()
+                trajectory_prior = trajectory[trajectory_index:]
+                current_joint_pose = torch.tensor(obs['agent']['qpos']).to(cfg.device)
+                return torch.cat([current_joint_pose.unsqueeze(0), trajectory_prior], dim=0)
+
+        # env = RecordEpisode(env, "/home/xuan/Code/maniskill2_benchmark", clean_on_close=False, save_video=True)
+
+        done = False
+        truncated = False
+        episode_count = 0
+        total_episodes = 100
+        episode_pbar = tqdm(total=total_episodes, desc='Collecting episodes')
+        
+        obs, _ = env.reset() # Obs Dict -- obs['extra']['tcp_pose']
+        policy.reset()
+        trajectory_prior = None
+
+        timestamp = time.strftime("%m%d_%H%M")
+        image_saving_path=os.path.join("/home/xuan/Documents/test_result", timestamp)
+
+        success_count = 0 # Done = True, Collided = False
+        task_fail_count = 0 # Done = True
+        collision_count = 0 # Collided = True
+        replanning_interval = cfg.inference.replanning_interval
+        print("replanning interval: ", replanning_interval)
+        inference_time_list = []
+        while episode_count < total_episodes:
+            collided = False
+            try:   
+                step = 0
+                replanning_count = 0
+                while not (done or truncated or collided):
+                    if collided is False:
+                        collided = obs['extra']['collision']
+                    # Update obsqueue
+                    policy.observation_wrapper.update_history_buffer(obs)
+                
+                    # env.render()
+                    new_path = False
+                    if step % replanning_interval == 0:
+
+                        if step == 0: # initial planning
+                            # start_time = time.time()
+                            policy.plan_path_with_history(obs, do_normalize=True)
+                            # inference_time_list.append(time.time() - start_time)
+                            new_path = True
+                        else: # replanning
+                            position_diff = np.linalg.norm(obs['extra']['goal_pose'][:3] - obs['extra']['tcp_pose'][:3])
+                            if position_diff > 0.15:
+                                # print("Replanning count: ", replanning_count, "position_diff: ", position_diff)
+                                ## replanning with prior
+                                print("replanning with prior at step: ", step)
+                                trajectory_prior = create_trajectory_prior(policy, obs, policy.planned_path)
+                                denoising_steps = 4
+                                # start_time = time.time()
+                                policy.plan_path_with_history(obs, 
+                                                            trajectory_prior=trajectory_prior, 
+                                                            do_normalize=True, 
+                                                            timestep=denoising_steps,  # denoising step
+                                                            choice='interpolate')
+                                # inference_time_list.append(time.time() - start_time)
+                                # # replanning without prior
+                                # trajectory_ortho6d = policy.plan_path_with_history(obs, do_normalize=True)
+                                replanning_count += 1
+                    if  cfg.test.inference_record:
+                        obs_inference_recorder.record_step(obs, 
+                                                           trajectory_prior=trajectory_prior,
+                                                           all_samples=policy.all_trajs, 
+                                                           planned_path=policy.planned_path)
+                
+                    action = policy.follow_path(obs)
+                    obs, reward, done, truncated, info = env.step(action)
+                    # print("Statistical of inference time: ", np.mean(inference_time_list), "std: ", np.std(inference_time_list))
+
+                    step += 1
+                
+                if  cfg.test.inference_record:
+                    obs_inference_recorder.save_episode()
+
+                print("Simulation Done", "Total replanning count: ", replanning_count) 
+                print("done: ", done, "truncated: ", truncated, "collided: ", collided)
+                # Metrics Loggers
+                if done and collided is False:
+                    success_count += 1
+                elif collided:
+                    collision_count += 1
+                else:
+                    task_fail_count += 1
+
+                obs, info = env.reset(options={"reconfigure": True})
+                policy.reset()
+                print_task_rate(success_count, collision_count, task_fail_count, episode_count+1)
+                trajectory_prior = None
+                done = False
+                truncated = False
+                episode_count += 1
+                episode_pbar.update(1)  # Update progress bar
+                
+            except KeyboardInterrupt:
+                print("\nStopping simulation...")
+                break
+        print("Simulation finished")
+        print_task_rate(success_count, collision_count, task_fail_count, total_episodes)
+        episode_pbar.close()  # Close progress bar
+        env.close() 
+    else:
+        raise Exception("Error: Not implemented. You are using the wrong file.")
+
+def print_task_rate(success_count, collision_count, task_fail_count, episodes_count):
+    success_rate = success_count / episodes_count
+    task_fail_rate = task_fail_count / episodes_count
+    collision_rate = collision_count / episodes_count
+    print(f"Success rate: {success_count} / {episodes_count} = {success_rate:.4f}")
+    print(f"Task fail rate: {task_fail_count} / {episodes_count} = {task_fail_rate:.4f}")
+    print(f"Collision rate: {collision_count} / {episodes_count} = {collision_rate:.4f}")
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/mp_demo.py

@@ -0,0 +1,206 @@
+import sapien.core as sapien
+import mplib
+import numpy as np
+from sapien.utils.viewer import Viewer
+from mplib import Pose
+import trimesh
+
+class PlanningDemo():
+    def __init__(self):
+        self.engine = sapien.Engine()
+        self.renderer = sapien.SapienRenderer()
+        self.renderer.set_log_level('warning')
+        self.engine.set_renderer(self.renderer)
+
+        scene_config = sapien.SceneConfig()
+        self.scene = self.engine.create_scene(scene_config)
+        self.scene.set_timestep(1 / 240.0)
+        self.scene.add_ground(-0.8)
+        physical_material = self.scene.create_physical_material(1, 1, 0.0)
+        self.scene.default_physical_material = physical_material
+
+        self.scene.set_ambient_light([0.5, 0.5, 0.5])
+        self.scene.add_directional_light([0, 1, -1], [0.5, 0.5, 0.5], shadow=True)
+        self.scene.add_point_light([1, 2, 2], [1, 1, 1], shadow=True)
+        self.scene.add_point_light([1, -2, 2], [1, 1, 1], shadow=True)
+        self.scene.add_point_light([-1, 0, 1], [1, 1, 1], shadow=True)
+
+        self.viewer = Viewer(self.renderer)
+        self.viewer.set_scene(self.scene)
+        self.viewer.set_camera_xyz(x=1.2, y=0.25, z=0.4)
+        self.viewer.set_camera_rpy(r=0, p=-0.4, y=2.7)
+
+        # Robot
+        # Load URDF
+        loader: sapien.URDFLoader = self.scene.create_urdf_loader()
+        loader.fix_root_link = True
+        self.robot: sapien.Articulation = loader.load("/home/rui/Documents/maniskill2_benchmark/mani_skill2/assets/descriptions/panda_v2_sphere.urdf")
+        self.robot.set_root_pose(sapien.Pose([0, 0, 0], [1, 0, 0, 0]))
+        
+        #  0.5618216, 0.0823961, 0.0563702, 0.8212124
+        # Set initial joint positions
+        init_qpos = [0, 0.19634954084936207, 0.0, -2.617993877991494, 0.0, 2.941592653589793, 0.7853981633974483, 0, 0]
+        self.robot.set_qpos(init_qpos)
+
+        self.active_joints = self.robot.get_active_joints()
+        for joint in self.active_joints:
+            joint.set_drive_property(stiffness=1000, damping=200)
+
+        # table top
+        builder = self.scene.create_actor_builder()
+        builder.add_box_collision(half_size=[0.4, 0.4, 0.025])
+        builder.add_box_visual(half_size=[0.4, 0.4, 0.025])
+        self.table = builder.build_kinematic(name='table')
+        self.table.set_pose(sapien.Pose([0.56, 0, - 0.025]))
+
+        # boxes
+        builder = self.scene.create_actor_builder()
+        builder.add_box_collision(half_size=[0.02, 0.02, 0.06])
+        builder.add_box_visual(half_size=[0.02, 0.02, 0.06], color=[1, 0, 0])
+        self.red_cube = builder.build(name='red_cube')
+        self.red_cube.set_pose(sapien.Pose([0.4, 0.3, 0.06]))
+
+        builder = self.scene.create_actor_builder()
+        builder.add_box_collision(half_size=[0.02, 0.02, 0.04])
+        builder.add_box_visual(half_size=[0.02, 0.02, 0.04], color=[0, 1, 0])
+        self.green_cube = builder.build(name='green_cube')
+        self.green_cube.set_pose(sapien.Pose([0.2, -0.3, 0.04]))
+
+        builder = self.scene.create_actor_builder()
+        builder.add_box_collision(half_size=[0.08, 0.02, 0.07])
+        builder.add_box_visual(half_size=[0.08, 0.02, 0.07], color=[0, 0, 1])
+        self.blue_cube = builder.build(name='blue_cube')
+        self.blue_cube.set_pose(sapien.Pose([0.65, 0.1, 0.1]))
+
+        self.setup_planner()
+    
+    def setup_planner(self):
+        link_names = [link.get_name() for link in self.robot.get_links()]
+        joint_names = [joint.get_name() for joint in self.robot.get_active_joints()]
+        self.planner = mplib.Planner(
+            urdf="/home/rui/Documents/maniskill2_benchmark/mani_skill2/assets/descriptions/panda_v2_sphere.urdf",
+            srdf="/home/rui/Documents/maniskill2_benchmark/mani_skill2/assets/descriptions/panda_v2.srdf",
+            user_link_names=link_names,
+            user_joint_names=joint_names,
+            move_group="panda_hand",
+            joint_vel_limits=np.ones(7),
+            joint_acc_limits=np.ones(7))
+
+    def follow_path(self, result):
+        n_step = result['position'].shape[0]
+        for i in range(n_step):  
+            qf = self.robot.compute_passive_force(
+                gravity=True, 
+                coriolis_and_centrifugal=True)
+            self.robot.set_qf(qf)
+            for j in range(7):
+                self.active_joints[j].set_drive_target(result['position'][i][j])
+                self.active_joints[j].set_drive_velocity_target(result['velocity'][i][j])
+            self.scene.step()
+            
+            if i % 4 == 0:
+                self.scene.update_render()
+                self.viewer.render()
+
+    def open_gripper(self):
+        for joint in self.active_joints[-2:]:
+            joint.set_drive_target(0.4)
+        for i in range(100): 
+            qf = self.robot.compute_passive_force(
+                gravity=True, 
+                coriolis_and_centrifugal=True)
+            self.robot.set_qf(qf)
+            self.scene.step()
+            if i % 4 == 0:
+                self.scene.update_render()
+                self.viewer.render()
+
+    def close_gripper(self):
+        for joint in self.active_joints[-2:]:
+            joint.set_drive_target(0)
+        for i in range(100):  
+            qf = self.robot.compute_passive_force(
+                gravity=True, 
+                coriolis_and_centrifugal=True)
+            self.robot.set_qf(qf)
+            self.scene.step()
+            if i % 4 == 0:
+                self.scene.update_render()
+                self.viewer.render()
+
+    def add_point_cloud(self):
+        """We tell the planner about the obstacle through a point cloud"""
+
+        # add_point_cloud ankor
+        # box = trimesh.creation.box([0.1, 0.4, 0.2])
+        box = trimesh.creation.box([0.08*2, 0.02*2, 0.07*2])
+        points, _ = trimesh.sample.sample_surface(box, 500)
+        print(len(points))
+        points += [0.65, 0.1, 0.1]
+        self.planner.update_point_cloud(points, resolution=0.02)
+
+    def move_to_pose_with_RRTConnect(self, pose):
+        print(type(self.planner))
+        
+        result = self.planner.plan_pose(pose, self.robot.get_qpos(), time_step=1/250)
+        if result['status'] != "Success":
+            print(result['status'])
+            return -1
+        # self.follow_path(result)
+        return 0
+
+    def move_to_pose_with_screw(self, pose:Pose ):
+        print("pose in move to pose with screw: ", type(pose))
+        # mppose = Pose()
+        print(self.robot.get_qpos())
+        result = self.planner.plan_screw(mppose, self.robot.get_qpos(), time_step=1/250)
+        if result['status'] != "Success":
+            result = self.planner.plan_pose(pose, self.robot.get_qpos(), time_step=1/250)
+            if result['status'] != "Success":
+                print(result['status'])
+                return -1 
+        # self.follow_path(result)
+        return 0
+    
+    def move_to_pose(self, pose, with_screw):
+        print("pose in move to pose: ", pose)
+        if with_screw:
+            return self.move_to_pose_with_screw(pose)
+        else:
+            return self.move_to_pose_with_RRTConnect(pose)
+
+    def pose_lst_to_mppose(self, pose):
+        p = np.array(pose[0:3])
+        q = np.array(pose[3:7])
+        return Pose(p, q)
+
+    def demo(self, with_screw = True):
+        poses = [[0.4, 0.3, 0.12, 0, 1, 0, 0],
+                [0.2, -0.3, 0.08, 0, 1, 0, 0],
+                [0.6, 0.1, 0.14, 0, 1, 0, 0]]
+    
+        # poses = [[0.014, -0.022, 0.193, 0, 1, 0, 0],
+        #     [0.2, -0.3, 0.08, 0, 1, 0, 0],
+        #     [0.6, 0.1, 0.14, 0, 1, 0, 0]]
+        self.add_point_cloud()
+
+        for i in range(3):
+            pose = self.pose_lst_to_mppose(poses[i])
+            self.move_to_pose(pose, with_screw)
+            self.open_gripper()
+            # pose[2] -= 0.12
+            # self.move_to_pose(pose, with_screw)
+            # self.close_gripper()
+            # pose[2] += 0.12
+            # self.move_to_pose(pose, with_screw)
+            # pose[0] += 0.1
+            # self.move_to_pose(pose, with_screw)
+            # pose[2] -= 0.12
+            # self.move_to_pose(pose, with_screw)
+            # self.open_gripper()
+            # pose[2] += 0.12
+            # self.move_to_pose(pose, with_screw)
+
+if __name__ == '__main__':
+    demo = PlanningDemo()
+    demo.demo(with_screw=False)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/plot_sample_data.py

@@ -0,0 +1,16 @@
+from cfdp.datasets.maniskill2_trajectory import ManiSkill2Trajectory
+from cfdp.utils.plot_utils import plot_trajectories
+
+
+if __name__ == "__main__":   
+    # dataset_file = '/home/xuan/Dataset/Trajectory/videos/20250331_133545.h5'
+    dataset_file ='/mnt/Dataset/bowl_100_split.h5'
+    # dataset_file = 'data/panda_wristcam/GraspBowl-v1/motionplanning/bowl_60_split.h5'
+    dataset = ManiSkill2Trajectory(dataset_file = dataset_file, 
+                                   choice="interpolate", 
+                                   trajectory_length=16,
+                                   verbose=False)
+    #sample = dataset.get_random_sample(1)
+    #print(sample)
+    trajectory = dataset.get_random_trajectory(20, normalize=False)
+    plot_trajectories(trajectory, "Normalized Trajectory")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/replay_guidance_test.py

@@ -0,0 +1,198 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_loss, get_model, get_summary, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.utils.data_utils import ObsQueue, transform_quat_to_ortho6d, transform_ortho6d_to_quat
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+
+import random
+import time
+import datetime
+import matplotlib.pyplot as plt
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    ## Load prior model ##
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        predict_epsilon=cfg.model.predict_epsilon,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+
+    # Initialize guide manager
+    guide1 = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=0.2
+    )
+    guide2 = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=0.5
+    )
+    guide3 = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+            guidance_weight=1.0
+    )
+    # guide = None
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+
+    policy1 = NeuralMotionPlannerPolicy( 
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide1,
+        debug=cfg.debug)
+    policy2 = NeuralMotionPlannerPolicy(# without prior
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide2,
+        debug=cfg.debug)
+    
+    policy3 = NeuralMotionPlannerPolicy(# with prior/no guidance
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide3,
+        debug=cfg.debug)
+    
+    policy0 = NeuralMotionPlannerPolicy(# with prior/no guidance
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=None,
+        debug=cfg.debug)
+
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+    ##
+    def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+            trajectory_prior = trajectory_ortho6d[0:]
+            current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+                torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+            ).squeeze(0)
+            return torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0)
+    
+
+    ## load recordings and run inference
+    recorder = inference_recorder.ReplayRecorder(replay_dir=cfg.test.replay_dir)
+    first_plan = True
+    policy1.reset()
+    policy2.reset()
+    policy3.reset()
+    
+    # Create plots directory if it doesn't exist
+    plots_dir = os.path.join(cfg.test.replay_dir, "plots")
+    os.makedirs(plots_dir, exist_ok=True)
+    figures = []
+
+    # Timing metrics
+    with_prior_times = []
+    without_prior_times = []
+
+    episode_count = 0
+    recorder.set_episode(episode_count)
+
+    # Generate multiple prior using the initial planning 
+    obs, trajectory_prior, done, planned_path, = recorder.next_step() 
+    policy0.plan_path_with_history(obs, do_normalize=True) # without prior
+    policy1.plan_path_with_history(obs, do_normalize=True) # with prior
+    policy2.plan_path_with_history(obs, do_normalize=True) # without prior
+    policy3.plan_path_with_history(obs, do_normalize=True) # with prior/no guidance
+
+    
+    result_to_plot = [policy0.all_trajs[0:1], policy1.all_trajs[0:2], policy2.all_trajs[0:2], policy3.all_trajs[0:3]]
+
+    title_list = ['Trajectory samples under different guidance level', 'Right View']
+    fig = visualizer.plot_trajectories_dual_view(result_to_plot, 
+                                                policy0.point_cloud, 
+                                                label_list=['no guidance (λ=0)', 'weak guidance (λ=0.2)', 'mid guidance (λ=0.5)', 'strong guidance (λ=1.0)'],
+                                                color_list =['green', 'orange', 'blue', 'deeppink'],
+                                                title=title_list,
+                                                plot_2d=True)
+    # plt.show()
+    save_path = os.path.join(plots_dir, f"episode_{episode_count}_trajectories_guidance.png")
+    fig.savefig(save_path, dpi=300, bbox_inches='tight')
+    print(f"Saved trajectory plot to {save_path}")
+    # plt.show()
+    plt.close(fig)
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/replay_planning_test.py

@@ -0,0 +1,264 @@
+import os
+import hydra
+from omegaconf import DictConfig, OmegaConf
+import gymnasium as gym
+from tqdm import tqdm
+import numpy as np
+import torch
+from cfdp.diffusion_policy.utils.loaders import get_dataset, get_loss, get_model, get_summary, freeze_torch_model_params
+from cfdp.diffusion_policy.models import TemporalUnet, UNET_DIM_MULTS, MLPModel
+from cfdp.motion_planner.neural_motion_planner import NeuralMotionPlannerPolicy
+from cfdp.motion_planner.motion_planner_policy_base import ClassicalMotionPlannerPolicy
+from cfdp.utils.plot_utils import plot_trajectories
+from cfdp.utils.data_utils import ObsQueue, transform_quat_to_ortho6d, transform_ortho6d_to_quat
+from cfdp.diffusion_policy.models.guide_managers import GuideManagerPath
+from cfdp.diffusion_policy.utils.summary_trajectory import generate_trajectories
+from cfdp.utils import observation_wrapper, inference_recorder
+from cfdp.utils.plot_utils import TrajectoryVisualizer
+
+import random
+import time
+import datetime
+import matplotlib.pyplot as plt
+
+np.random.seed(42)
+random.seed(42)
+
+OmegaConf.register_new_resolver("multiply", lambda x, y: int(float(x)) * int(float(y)))
+
+@hydra.main(version_base="1.2", config_path="../configs", config_name="config_history")
+def main(cfg: DictConfig):
+    # print(OmegaConf.to_yaml(cfg))
+
+    ########################################################################################################################
+    # Load dataset with env, robot, task
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        cfg_dataset=cfg.dataset,
+        batch_size=cfg.batch_size,
+        val_set_size=cfg.val_set_size,
+        results_dir=cfg.results_dir,
+        save_indices=False
+    )
+    ## Load prior model ##
+    diffusion_configs = dict(
+        variance_schedule=cfg.model.variance_schedule,
+        n_diffusion_steps=cfg.model.n_steps,
+        predict_epsilon=cfg.model.predict_epsilon,
+    )
+
+    unet_configs = dict(
+        state_dim=cfg.state_dim,
+        n_support_points=cfg.trajectory_length,
+        unet_input_dim=cfg.model.unet_input_dim,
+        dim_mults=UNET_DIM_MULTS[cfg.model.unet_dim_mults_option],
+        conditioning_type=cfg.model.conditioning_type,
+        conditioning_embed_dim = cfg.model.conditioning_embed_dim
+    )
+
+    diffusion_model = get_model(
+        model_class=cfg.model.model_class,
+        model=TemporalUnet(**unet_configs),
+        tensor_args={'device': cfg.device, 'dtype': torch.float32},
+        context_model=MLPModel(in_dim=cfg.model.context_input_dim, out_dim=cfg.model.conditioning_embed_dim, input_field='tasks', output_field='condition'),
+        **diffusion_configs,
+        **unet_configs
+    )
+
+    # load saved policy model
+    diffusion_model.load_state_dict(
+        torch.load(os.path.join(cfg.inference.model_dir, 'checkpoints', 
+                'ema_model_current_state_dict.pth' if cfg.inference.use_ema else 'model_current_state_dict.pth'),
+                map_location=cfg.device,
+                weights_only=True)
+    )
+    diffusion_model.eval()
+    model = diffusion_model
+
+    freeze_torch_model_params(model)
+    model = torch.compile(model)
+
+    # Initialize guide manager
+    guide = GuideManagerPath(
+            dataset = train_subset.dataset,
+            clip_grad=True,
+            tensor_args={'device': cfg.device, 'dtype': torch.float32},
+    )
+    # guide = None
+    ObservationWrapperClass = getattr(observation_wrapper, cfg.observation_wrapper)
+    obs_wrapper = ObservationWrapperClass(train_subset.dataset, camera_type=cfg.inference.camera_type)
+
+    policy = NeuralMotionPlannerPolicy( 
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        debug=cfg.debug)
+    policy2 = NeuralMotionPlannerPolicy(# without prior
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=guide,
+        debug=cfg.debug)
+    
+    policy3 = NeuralMotionPlannerPolicy(# with prior/no guidance
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=None,
+        debug=cfg.debug)
+
+    policy4 = NeuralMotionPlannerPolicy(# without prior/no guidance
+        action_dim=7,
+        model=model,
+        dataset=train_subset.dataset, 
+        trajectory_length=cfg.trajectory_length,
+        inference_cfg=cfg.inference,
+        observation_wrapper=obs_wrapper,
+        guide_manager=None,
+        debug=cfg.debug)
+
+    ## visualizer ##
+    visualizer = TrajectoryVisualizer(normalizer=train_subset.dataset.normalizer)
+    ##
+    def create_trajectory_prior(policy, obs, trajectory_ortho6d):
+            trajectory_index = policy.get_current_path_index()
+            trajectory_prior = trajectory_ortho6d[trajectory_index:]
+            current_tcp_pose_ortho6d = transform_quat_to_ortho6d(
+                torch.tensor(obs['extra']['tcp_pose'], device=cfg.device).unsqueeze(0)
+            ).squeeze(0)
+            return torch.cat([current_tcp_pose_ortho6d.unsqueeze(0), trajectory_prior], dim=0)
+    ## load recordings and run inference
+    recorder = inference_recorder.ReplayRecorder(replay_dir=cfg.test.replay_dir)
+    first_plan = True
+    policy.reset()
+    policy2.reset()
+    
+    # Create plots directory if it doesn't exist
+    plots_dir = os.path.join(cfg.test.replay_dir, "plots")
+    os.makedirs(plots_dir, exist_ok=True)
+    figures = []
+
+    # Timing metrics
+    with_prior_times = []
+    without_prior_times = []
+
+    episode_count = 0
+    recorder.set_episode(episode_count)
+
+    for step in range(200):
+        obs, trajectory_prior, done, planned_path, = recorder.next_step() #TODO: select episode
+        if done:
+            policy.reset()
+            policy2.reset()
+            policy3.reset()
+            policy4.reset()
+            print("reset")
+            first_plan = True
+            episode_count += 1
+        
+        if first_plan:
+            policy.plan_path_with_history(obs, do_normalize=True) # with prior
+            policy2.plan_path_with_history(obs, do_normalize=True) # without prior
+            policy3.plan_path_with_history(obs, do_normalize=True) # with prior/no guidance
+            policy4.plan_path_with_history(obs, do_normalize=True) # without prior/no guidance
+            first_plan = False
+        else:
+            # Measure planning time with prior
+            # trajectory_prior = create_trajectory_prior(policy, obs, planned_path)
+            denoising_steps = 2
+            
+            start_time = time.time()
+
+            policy.plan_path_with_history(obs, 
+                                        trajectory_prior=trajectory_prior, 
+                                        do_normalize=True, 
+                                        timestep=denoising_steps,  # denoising step
+                                        choice='interpolate') #with prior
+            end_time = time.time()
+            with_prior_time = end_time - start_time
+            if step >30:
+                with_prior_times.append(with_prior_time)
+            
+            # Measure planning time without prior
+            start_time = time.time()
+            policy2.plan_path_with_history(obs, do_normalize=True) #without prior
+            end_time = time.time()
+            without_prior_time = end_time - start_time
+            without_prior_times.append(without_prior_time)
+
+            policy3.plan_path_with_history(obs, 
+                                        trajectory_prior=trajectory_prior, 
+                                        do_normalize=True, 
+                                        timestep=denoising_steps,  #
+                                        choice='interpolate') #with prior/no guidance
+            policy4.plan_path_with_history(obs, do_normalize=True) #without prior/no guidance
+            
+            # Print timing information every 10 steps
+            if len(with_prior_times) > 0 and len(with_prior_times) % 10 == 0:
+                avg_with_prior = sum(with_prior_times) / len(with_prior_times)
+                avg_without_prior = sum(without_prior_times) / len(without_prior_times)
+                print(f"Step {step}, Avg times - With prior: {avg_with_prior:.4f}s, Without prior: {avg_without_prior:.4f}s")
+
+        # visualizer.plot_trajectory(policy.planned_path, obs, policy.point_cloud)
+        # Create a new figure for this step
+        title_list = ['Trajectory generated with guidance (λ=0.5)', 'Right View']
+        if step%8 == 0:
+            if step == 0:
+                fig = visualizer.plot_trajectories_dual_view([policy.all_trajs, policy3.all_trajs], 
+                                            policy.point_cloud, label_list=['guidance only', 'no prior, no guidanc'], color_list=['orange', 'green'],
+                                            title=title_list)
+            else:
+                fig = visualizer.plot_trajectories_dual_view([policy.all_trajs, policy2.all_trajs, policy3.all_trajs, policy4.all_trajs], 
+                                                policy.point_cloud, label_list=['prior + guidance', 'guidance only', 'prior only', 'no prior, no guidance'],
+                                                color_list =['red', 'orange', 'blue', 'green'],
+                                                title=title_list)
+            # plt.show()
+            save_path = os.path.join(plots_dir, f"episode_{episode_count}_trajectories_{step}.png")
+            fig.savefig(save_path, dpi=300, bbox_inches='tight')
+            print(f"Saved trajectory plot to {save_path}")
+            # plt.show()
+            plt.close(fig)
+    
+    # # Calculate and print final timing statistics
+    # if with_prior_times and without_prior_times:
+    #     avg_with_prior = sum(with_prior_times) / len(with_prior_times)
+    #     avg_without_prior = sum(without_prior_times) / len(without_prior_times)
+        
+    #     min_with_prior = min(with_prior_times)
+    #     max_with_prior = max(with_prior_times)
+        
+    #     min_without_prior = min(without_prior_times)
+    #     max_without_prior = max(without_prior_times)
+        
+    #     std_with_prior = np.std(with_prior_times)
+    #     std_without_prior = np.std(without_prior_times)
+        
+    #     print("\n===== Timing Statistics =====")
+    #     print(f"Planning with prior:     Avg = {avg_with_prior:.4f}s, Std = {std_with_prior:.4f}s, Min = {min_with_prior:.4f}s, Max = {max_with_prior:.4f}s")
+    #     print(f"Planning without prior:  Avg = {avg_without_prior:.4f}s, Std = {std_without_prior:.4f}s, Min = {min_without_prior:.4f}s, Max = {max_without_prior:.4f}s")
+    #     print(f"Speedup with prior: {avg_without_prior/avg_with_prior:.2f}x")
+        
+    #     # Save timing results to a file
+    #     with open(os.path.join(plots_dir, "timing_results.txt"), "w") as f:
+    #         f.write("===== Timing Statistics =====\n")
+    #         f.write(f"Planning with prior:     Avg = {avg_with_prior:.4f}s, Min = {min_with_prior:.4f}s, Max = {max_with_prior:.4f}s\n")
+    #         f.write(f"Planning without prior:  Avg = {avg_without_prior:.4f}s, Min = {min_without_prior:.4f}s, Max = {max_without_prior:.4f}s\n")
+    #         f.write(f"Speedup with prior: {avg_without_prior/avg_with_prior:.2f}x\n")
+            
+    #         # Write raw timing data
+    #         f.write("\n===== Raw Timing Data =====\n")
+    #         f.write("Step,WithPrior,WithoutPrior\n")
+    #         for i, (wp, wop) in enumerate(zip(with_prior_times, without_prior_times)):
+    #             f.write(f"{i},{wp:.6f},{wop:.6f}\n")
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/test_clutter_env.py

@@ -0,0 +1,116 @@
+import pathlib
+import time
+import gymnasium as gym
+from tqdm import tqdm
+import numpy as np
+import mani_skill2.envs
+from mani_skill2.utils.wrappers.record import RecordEpisode
+import cfdp.envs as envs  # absolute import
+import argparse
+import os
+import cv2
+from cfdp.envs import ENVS_DIR
+import yaml
+
+def get_args():
+    # Add argument parser
+    parser = argparse.ArgumentParser(description='Motion Planning Environment Demo')
+    parser.add_argument('--env-id', type=str, default='SceneGenerator-v0', help='Environment ID')
+    parser.add_argument('--obs-mode', type=str, default='image', help='Observation mode') #'state_dict', 'image'
+    parser.add_argument('--control-mode', type=str, default='pd_joint_delta_pos', 
+                       choices=['pd_joint_delta_pos', 'pd_ee_target_delta_pos'],
+                       help='Control mode')
+    parser.add_argument('--reward-mode', type=str, default='dense', help='Reward mode')
+    parser.add_argument('--robot-noise', type=float, default=0.2, help='Robot initial position noise')
+    parser.add_argument('--planner-type', type=str, default='rrt', help='Motion planner type')
+    parser.add_argument('--show-obs', action='store_true', help='Show observation keys')
+    parser.add_argument('--episodes', type=int, default=10, help='Number of episodes to run')
+    parser.add_argument('--render', action='store_true', help='Enable rendering')
+    parser.add_argument('--record', action='store_true', help='Enable video recording')
+    parser.add_argument('--record-dir', type=str, default="recordings", help='Directory to store recordings')
+    parser.add_argument('--distractor-count', type=int, default=15, help='Number of distractors to add')
+    parser.add_argument('--base-object-config-path', type=str, default="scene/base_scene.yaml")
+    args = parser.parse_args()
+
+    return args
+
+
+def print_nested_keys(d, prefix=''):
+    for key in d.keys():
+        print(f"{prefix}{key}")
+        if isinstance(d[key], dict):
+            print_nested_keys(d[key], prefix=f"{prefix} ")
+
+def save_camera_img(img, img_path):
+    # cv2.imshow("Camera Image", img)
+    # cv2.waitKey(0)
+    # Convert from RGB to BGR format for OpenCV
+    img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(img_path, img_bgr)
+    print(f"Saved image to {img_path}")
+
+def main():
+    args = get_args()
+
+    # Create environment
+    env = gym.make(args.env_id,
+        obs_mode=args.obs_mode,
+        reward_mode=args.reward_mode,
+        control_mode=args.control_mode,
+        enable_shadow=False,
+        render_mode="cameras" if args.record else "human",
+        robot_init_qpos_noise=args.robot_noise,
+        obstacle_configs=[],
+        distractor_count=args.distractor_count,
+        base_object_config_path=args.base_object_config_path,
+        scene_config_serialization_mode='dict',
+        minimum_object_aabb_separation=0.01,
+        table_scale=[0.7, 0.7]
+    )
+
+    # if args.record:
+    #     env = RecordEpisode(env, output_dir=args.record_dir, save_trajectory=False, save_video=True)
+    #             #    object_config_path=os.path.join(ENVS_DIR, "object_pick_env.yaml"))
+    
+    options={}
+    # Run episodes
+    for episode in range(20):
+        obs, info = env.reset(options=options)
+        if args.show_obs:
+            print("Observation structure:")
+            print_nested_keys(obs)
+        ## The 'reconfigure' option causes a segfault...
+        ## I give up on this for now '\(-.-)/`
+        # Just remake the env if you need a different set of objects
+        # options={'reconfigure': True}
+        print(info)
+        scene_config = info['scene_config']
+
+        if args.record:
+            # Create env_config directory and parents if they don't exist
+            config_dir = pathlib.Path(ENVS_DIR) / "env_config"
+            config_dir.mkdir(parents=True, exist_ok=True)
+            
+            # Save scene config to env_config subdirectory
+            with open(config_dir / f"{episode}_scene_config.yaml", 'w') as f:
+                yaml.dump(scene_config, f)
+
+            render_image = env.render_rgb_array()
+            save_camera_img(render_image, str(config_dir / f"{episode}_scene_img.png"))
+            
+        time.sleep(0.1)
+        
+
+        # action = env.action_space.sample()
+        # env.step(action)
+        for i in range(20):
+            # action = env.action_space.sample()
+            # obs, reward, done, truncated, info = env.step(action)
+            if args.render:
+                env.render()
+            # if done or truncated:
+            #     break
+    
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/test_dataset.py

@@ -0,0 +1,39 @@
+import pytest
+from cfdp.diffusion_policy.utils.loaders import get_dataset
+
+@pytest.fixture
+def dataset_params():
+    return {
+        'dataset_class': 'ManiSkill2Trajectory',
+        'dataset_file': '/home/xuan/Dataset/Trajectory/videos/20250326_131842.h5',
+        'batch_size': 2,
+        'val_set_size': 0.2
+    }
+
+
+def test_get_dataset(dataset_params):
+    # Call function
+    train_subset, train_dataloader, val_subset, val_dataloader = get_dataset(
+        **dataset_params
+    )
+
+    # Check outputs
+    assert train_subset is not None
+    assert train_dataloader is not None  
+    assert val_subset is not None
+    assert val_dataloader is not None
+
+    # Check dataset split ratio
+    total_size = len(train_subset) + len(val_subset)
+    expected_val_size = int(total_size * dataset_params['val_set_size'])
+    assert len(val_subset) == expected_val_size
+
+    # Check batch size
+    for batch in train_dataloader:
+        assert len(batch) == 4
+        break
+
+    for batch in val_dataloader:
+        assert len(batch) == 4
+        break
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/test_envs.py

@@ -0,0 +1,139 @@
+import gymnasium as gym
+from tqdm import tqdm
+import numpy as np
+import mani_skill2.envs
+import cfdp.envs as envs  # absolute import
+import argparse
+import os
+import cv2
+from cfdp.envs import ENVS_DIR
+from cfdp.utils.observation_wrapper import ObservationWrapper
+from cfdp.datasets.maniskill2_trajectory import ManiSkill2Trajectory
+
+
+def print_nested_keys(d, prefix=''):
+    for key in d.keys():
+        print(f"{prefix}{key}")
+        if isinstance(d[key], dict):
+            print_nested_keys(d[key], prefix=f"{prefix} ")
+
+def save_camera_img(img, img_path):
+    # cv2.imshow("Camera Image", img)
+    # cv2.waitKey(0)
+    # Convert from RGB to BGR format for OpenCV
+    img_bgr = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    cv2.imwrite(img_path, img_bgr)
+    print(f"Saved image to {img_path}")
+
+def main():
+    # Add argument parser
+    parser = argparse.ArgumentParser(description='Motion Planning Environment Demo')
+    # parser.add_argument('--env-id', type=str, default='CustomizedPick-v0', help='Environment ID')
+    parser.add_argument('--env-id', type=str, default='ShelfPick-v0', help='Environment ID')
+    parser.add_argument('--obs-mode', type=str, default='image', help='Observation mode') #'state_dict', 'image'
+    parser.add_argument('--control-mode', type=str, default='pd_ee_delta_pose_align', 
+                       choices=['pd_joint_delta_pos', 'pd_ee_target_delta_pos', 'pd_ee_delta_pose_align'],
+                       help='Control mode')
+    parser.add_argument('--reward-mode', type=str, default='dense', help='Reward mode')
+    parser.add_argument('--robot-noise', type=float, default=0.2, help='Robot initial position noise')
+    parser.add_argument('--planner-type', type=str, default='rrt', help='Motion planner type')
+    parser.add_argument('--show-obs', action='store_true', help='Show observation keys')
+    parser.add_argument('--episodes', type=int, default=10, help='Number of episodes to run')
+    parser.add_argument('--render', action='store_true', help='Enable rendering')
+    parser.add_argument('--record', action='store_true', help='Enable video recording')
+    args = parser.parse_args()
+    # Create environment
+    env = gym.make(args.env_id,
+                   obs_mode=args.obs_mode,
+                   reward_mode=args.reward_mode,
+                   control_mode=args.control_mode,
+                   enable_shadow=False,
+                   render_mode="cameras" if args.record else "human",
+                   robot_init_qpos_noise=args.robot_noise,
+                   obstacle_configs=[],
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config", "empty_scene"),
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config", "smallbox_distractor"),
+                   object_config_path=os.path.join(ENVS_DIR, "env_config", "shelf"),
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config", "distractor25"),
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config", "distractorbox"),
+                #    object_config_path=os.path.join(ENVS_DIR, "env_config"),
+                #    object_config_path=os.path.join(ENVS_DIR, "concept_env_config"),
+                   create_obstacle_point_cloud=True,
+                   is_demo=True)
+    
+    # env = gym.make('RandomObstacleReach-v0',
+    #                obs_mode=args.obs_mode,
+    #                reward_mode=args.reward_mode,
+    #                control_mode=args.control_mode,
+    #                enable_shadow=False,
+    #                render_mode="cameras" if args.record else "human",
+    #                robot_init_qpos_noise=args.robot_noise,
+    #                obstacle_configs=[])
+
+
+    obstacle_configs = [
+        {
+            'type': 'sphere',
+            'radius': 0.18,
+            'pose': [0.6, 0.0, 0.1],
+            'color': (0, 1, 0),
+            'n_points': 500
+        }
+    ]
+
+    # env = gym.make('RandomObstacleReach-v0',
+    #                obs_mode=args.obs_mode,
+    #                reward_mode=args.reward_mode,
+    #                control_mode=args.control_mode,
+    #                enable_shadow=False,
+    #                render_mode="cameras" if args.record else "human",
+    #                robot_init_qpos_noise=args.robot_noise,
+    #                obstacle_configs=obstacle_configs)
+    
+    # # Test observation wrapper
+    # dataset_file ="/mnt/Dataset/20250402_131752.h5"
+    # dataset = ManiSkill2Trajectory(dataset_file = dataset_file, 
+    #                                choice="interpolate", 
+    #                                trajectory_length=16,
+    #                                verbose=False)
+    # obs_wrapper = ObservationWrapper(dataset)
+
+    ##### --- Run episodes --- ####
+    obs, info = env.reset(options={"reconfigure": True})
+    if args.show_obs:
+        print("Observation structure:")
+        print_nested_keys(obs)
+    # save_camera_img(obs['image']['base_camera']['Color'], 
+    #                         f"/home/xuan/Documents/test_result/scene_images/camera_img_{episode}.png")
+    
+    import pathlib
+    save_dir = pathlib.Path("/home/xuan/Documents/test_result/scene_images")
+    save_dir.mkdir(parents=True, exist_ok=True)
+    import time
+    
+    for episode in range(args.episodes):
+        obs, info = env.reset(options={"reconfigure": True})
+        # print_nested_keys(obs)
+
+        # render_image = env.render_rgb_array()
+        # timestamp = time.strftime("%H%M%S")
+        # save_camera_img(render_image, str(save_dir / f"{timestamp}_scene_img.png"))
+        # obs_wrapper.reset()
+
+        for _ in range(100):
+            # action = env.action_space.sample()
+            # obs, reward, done, truncated, info = env.step(action)
+            
+            # obs_wrapper.update_observation(obs)
+            if args.render:
+                env.render()
+            # if done or truncated:
+            #     break
+        time.sleep(1)
+        # env.reset()
+        
+    env.close()
+    
+
+if __name__ == "__main__":
+    main()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/test_fcm.py

@@ -0,0 +1,60 @@
+import os
+
+from cfdp.utils.fcm.vlc import VLC
+import cv2
+import mani_skill2.envs
+import numpy as np
+from cfdp.envs import ENVS_DIR
+
+vlc = VLC(
+    num_levels=3, contrast_filt_sigma=1,
+    contrast_pool_sigma=3, color_pool_sigma=3,
+    w_color=0.220, w_contrast=0.0660, w_orient=0.0269,
+    w_xyz=0.100, add_xyz=None
+)
+
+# image_dir = os.path.join(ENVS_DIR, "env_config", "smallbox_distractor")
+# image_dir = os.path.join(ENVS_DIR, "env_config", "distractorbox")
+# image_dir = os.path.join(ENVS_DIR, "env_config", "distractor25")
+image_dir = os.path.join(ENVS_DIR, "env_config", "empty_table")
+# Use os.listdir to get files and filter for PNG files
+image_files = [os.path.join(image_dir, f) for f in os.listdir(image_dir) if f.lower().endswith('.png')]
+print("image_files:", image_files)
+
+fcm_values = list()
+
+for image_file in image_files:
+    image = cv2.imread(str(image_file))
+
+    # crop the table
+    height, width = image.shape[:2]
+    # Crop vertically from y=200 to y=800, keep x dimension unchanged
+    start_y = 480
+    end_y = 750
+    # Keep full width (no change in x dimension)
+    start_x = 130
+    end_x = 900
+    cropped_image = image[start_y:end_y, start_x:end_x]
+    
+    # Display original and cropped image dimensions
+    print(f"Original image dimensions: {width}x{height}")
+    print(f"Cropped image dimensions: {cropped_image.shape[1]}x{cropped_image.shape[0]}")
+    
+    # Optionally save the cropped image
+    # crop_filename = os.path.splitext(image_file)[0] + "_cropped.png"
+    # cv2.imwrite(crop_filename, cv2.cvtColor(cropped_image, cv2.COLOR_RGB2BGR))
+    
+    # Use the original image for FCM processing
+    cropped_image = cv2.cvtColor(cropped_image, cv2.COLOR_RGB2BGR)  # Convert back to BGR for consistency
+    fcm = vlc.get_fcm(cropped_image, p=1)
+    fcm_values.append(fcm[0])
+    
+    print("image_file:", image_file)
+    print("fcm:",fcm[0])
+    # cv2.imshow("fcm", cropped_image)
+    # cv2.waitKey(0)
+# Calculate mean and std of all FCM values
+fcm_values_array = np.array(fcm_values)
+fcm_mean = fcm_values_array.mean()
+fcm_std = fcm_values_array.std()
+print(f"FCM mean across all images: {fcm_mean:.4f}, std: {fcm_std:.4f}")

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/test_sapien.py

@@ -0,0 +1,9 @@
+import sapien.core as sapien
+# # backtrace debug
+# import faulthandler
+# faulthandler.enable()
+
+engine = sapien.Engine()
+renderer = sapien.SapienRenderer()
+engine.set_renderer(renderer)
+scene = engine.create_scene()

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/tests/tools.py

@@ -0,0 +1,94 @@
+import h5py
+from cfdp.datasets.maniskill2_trajectory import ManiSkill2Trajectory
+import numpy as np
+
+def is_valid_quaternion(q):
+    """
+    Check if a quaternion is valid. 1: [w, x, y, z]
+    """
+    # Check if input is array-like and has 4 components
+    try:
+        q = np.array(q, dtype=float)
+        if q.shape != (4,):
+            return False
+    except:
+        return False
+    
+    # Check if quaternion is normalized (magnitude ≈ 1)
+    magnitude = np.sqrt(np.sum(q * q))
+    return np.abs(magnitude - 1.0) < 1e-6
+
+def quaternion_to_euler(q):
+    """
+    Convert quaternion [w, x, y, z] to Euler angles [roll, pitch, yaw] in radians.
+    Uses the ZYX convention (yaw, pitch, roll).
+    
+    Args:
+        q (array-like): Quaternion in [w, x, y, z] format
+        
+    Returns:
+        numpy.ndarray: Array of Euler angles [roll, pitch, yaw] in radians
+    """
+    # Extract quaternion components
+    w, x, y, z = q
+    
+    # Roll (x-axis rotation)
+    sinr_cosp = 2 * (w * x + y * z)
+    cosr_cosp = 1 - 2 * (x * x + y * y)
+    roll = np.arctan2(sinr_cosp, cosr_cosp)
+    
+    # Pitch (y-axis rotation)
+    sinp = 2 * (w * y - z * x)
+    pitch = np.arcsin(np.clip(sinp, -1.0, 1.0))
+    
+    # Yaw (z-axis rotation)
+    siny_cosp = 2 * (w * z + x * y)
+    cosy_cosp = 1 - 2 * (y * y + z * z)
+    yaw = np.arctan2(siny_cosp, cosy_cosp)
+    
+    return np.array([roll, pitch, yaw])
+
+def print_dataset_sizes(h5_group):
+    """Print the sizes of all datasets in an h5 file/group.
+    
+    Args:
+        h5_group: h5py.File or h5py.Group object
+    """
+    for name, item in h5_group.items():
+        if isinstance(item, h5py.Dataset):
+            size_mb = item.size * item.dtype.itemsize / (1024 * 1024)
+            print(f"{name}: {size_mb:.2f} MB")
+        elif isinstance(item, h5py.Group):
+            print(f"Group: {name}")
+            print_dataset_sizes(item)
+
+def test_dataset_loading(file_name):
+    dataset = ManiSkill2Trajectory(file_name, obs_keys = ['tcp_pose', 'base_pose'])
+    obs, actions, goal, data = dataset[1]
+    print(obs.shape)
+    print(actions.shape)
+    print(goal.shape)
+
+if __name__ == "__main__":
+    #########################################################
+    # test_dataset_loading("/home/xuan/Dataset/Trajectory/videos/20250324_222521.h5")
+    #########################################################
+    # with h5py.File("/home/xuan/Dataset/Trajectory/videos/20250324_164747.h5", 'r') as f:
+    #     print("Dataset sizes in MB:")
+    #     print_dataset_sizes(f)
+    #########################################################
+    q = [ 0.005171, 0.9916896, -0.01349258, 0.12783928]
+    print(is_valid_quaternion(q))
+
+    # Convert first quaternion to Euler angles
+    q1 = [0.04063901, 0.93449867, 0.2687286, -0.12474412]
+    euler1 = quaternion_to_euler(q1)
+    print(f"Euler angles for q1 (roll, pitch, yaw) in radians: {euler1}")
+    print(f"Euler angles for q1 in degrees: {np.degrees(euler1)}")
+
+    # Convert second quaternion to Euler angles
+    q2 = [-0.00972217, 0.98917925, 0.05200833, -0.07761869]
+    euler2 = quaternion_to_euler(q2)
+    print(f"Euler angles for q2 (roll, pitch, yaw) in radians: {euler2}")
+    print(f"Euler angles for q2 in degrees: {np.degrees(euler2)}")
+    

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/angle_utils.py

@@ -0,0 +1,350 @@
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+def quaternion_to_euler(q):
+    """
+    Convert quaternion [w, x, y, z] to Euler angles [roll, pitch, yaw] in radians.
+    Uses the ZYX convention (yaw, pitch, roll).
+    
+    Args:
+        q (array-like): Quaternion in [w, x, y, z] format
+        
+    Returns:
+        numpy.ndarray: Array of Euler angles [roll, pitch, yaw] in radians
+    """
+    # Extract quaternion components
+    w, x, y, z = q
+    
+    # Roll (x-axis rotation)
+    sinr_cosp = 2 * (w * x + y * z)
+    cosr_cosp = 1 - 2 * (x * x + y * y)
+    roll = np.arctan2(sinr_cosp, cosr_cosp)
+    
+    # Pitch (y-axis rotation)
+    sinp = 2 * (w * y - z * x)
+    pitch = np.arcsin(np.clip(sinp, -1.0, 1.0))
+    
+    # Yaw (z-axis rotation)
+    siny_cosp = 2 * (w * z + x * y)
+    cosy_cosp = 1 - 2 * (y * y + z * z)
+    yaw = np.arctan2(siny_cosp, cosy_cosp)
+    
+    return np.array([roll, pitch, yaw])
+
+def quaternion_multiply(q1, q2):
+    """Helper function to multiply two quaternions."""
+    w1, x1, y1, z1 = q1
+    w2, x2, y2, z2 = q2
+    return np.array([
+        w1*w2 - x1*x2 - y1*y2 - z1*z2,
+        w1*x2 + x1*w2 + y1*z2 - z1*y2,
+        w1*y2 - x1*z2 + y1*w2 + z1*x2,
+        w1*z2 + x1*y2 - y1*x2 + z1*w2
+        ])
+
+def quaternion_inverse(q):
+    w, x, y, z = q
+    norm_sq = w*w + x*x + y*y + z*z
+    return np.array([w, -x, -y, -z]) / norm_sq
+
+def quaternion_difference(q1, q2):
+    """
+    q1 - q2
+    """
+    q2_inv = quaternion_inverse(q2)
+    return quaternion_multiply(q1, q2_inv)
+
+def quat_normalize_t(q): # tensor
+    return q / (q.norm(dim=-1, keepdim=True) + 1e-12)
+
+def normalize_vector(v, return_mag=False):
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    device = v.device
+    batch = v.shape[0]
+    v_mag = torch.sqrt(v.pow(2).sum(1))
+    v_mag = torch.max(v_mag, torch.autograd.Variable(torch.FloatTensor([1e-8]).to(device)))
+    v_mag = v_mag.view(batch, 1).expand(batch, v.shape[1])
+    v = v / v_mag
+    if return_mag:
+        return v, v_mag[:, 0]
+    else:
+        return v
+
+def cross_product(u, v):
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    batch = u.shape[0]
+    i = u[:, 1] * v[:, 2] - u[:, 2] * v[:, 1]
+    j = u[:, 2] * v[:, 0] - u[:, 0] * v[:, 2]
+    k = u[:, 0] * v[:, 1] - u[:, 1] * v[:, 0]
+    out = torch.cat((i.view(batch, 1), j.view(batch, 1), k.view(batch, 1)), 1)
+    return out  # batch*3
+
+def _sqrt_positive_part(x: torch.Tensor) -> torch.Tensor:
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    """
+    Returns torch.sqrt(torch.max(0, x))
+    but with a zero subgradient where x is 0.
+    """
+    ret = torch.zeros_like(x)
+    positive_mask = x > 0
+    ret[positive_mask] = torch.sqrt(x[positive_mask])
+    return ret
+
+def compute_rotation_matrix_from_quaternion(quaternion):
+    # https://github.com/papagina/RotationContinuity/blob/master/sanity_test/code/tools.py
+    batch=quaternion.shape[0]  
+    
+    quat = normalize_vector(quaternion).contiguous()
+    
+    qw = quat[...,0].contiguous().view(batch, 1)
+    qx = quat[...,1].contiguous().view(batch, 1)
+    qy = quat[...,2].contiguous().view(batch, 1)
+    qz = quat[...,3].contiguous().view(batch, 1)
+
+    # Unit quaternion rotation matrices computatation  
+    xx = qx*qx
+    yy = qy*qy
+    zz = qz*qz
+    xy = qx*qy
+    xz = qx*qz
+    yz = qy*qz
+    xw = qx*qw
+    yw = qy*qw
+    zw = qz*qw
+    
+    row0 = torch.cat((1-2*yy-2*zz, 2*xy - 2*zw, 2*xz + 2*yw), 1) #batch*3
+    row1 = torch.cat((2*xy+ 2*zw,  1-2*xx-2*zz, 2*yz-2*xw  ), 1) #batch*3
+    row2 = torch.cat((2*xz-2*yw,   2*yz+2*xw,   1-2*xx-2*yy), 1) #batch*3
+    
+    matrix = torch.cat((row0.view(batch, 1, 3), row1.view(batch,1,3), row2.view(batch,1,3)),1) #batch*3*3
+    
+    return matrix
+
+def get_ortho6d_from_rotation_matrix(matrix):
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    # The orhto6d represents the first two column vectors a1 and a2 of the
+    # rotation matrix: [ | , |,  | ]
+    #                  [ a1, a2, a3]
+    #                  [ | , |,  | ]
+    ortho6d = matrix[:, :, :2].permute(0, 2, 1).flatten(-2)
+    return ortho6d
+
+def compute_rotation_matrix_from_ortho6d(ortho6d):
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    x_raw = ortho6d[:, 0:3]  # batch*3
+    y_raw = ortho6d[:, 3:6]  # batch*3
+
+    x = normalize_vector(x_raw)  # batch*3
+    z = cross_product(x, y_raw)  # batch*3
+    z = normalize_vector(z)  # batch*3
+    y = cross_product(z, x)  # batch*3
+
+    x = x.view(-1, 3, 1)
+    y = y.view(-1, 3, 1)
+    z = z.view(-1, 3, 1)
+    matrix = torch.cat((x, y, z), 2)  # batch*3*3
+    return matrix
+
+def compute_quaternion_from_rotation_matrix(matrix: torch.Tensor) -> torch.Tensor:
+    # https://github.com/nickgkan/3d_diffuser_actor/blob/master/diffuser_actor/utils/utils.py
+    """
+    Convert rotations given as rotation matrices to quaternions.
+
+    Args:
+        matrix: Rotation matrices as tensor of shape (..., 3, 3).
+
+    Returns:
+        quaternions with real part first, as tensor of shape (..., 4).
+    """
+    if matrix.size(-1) != 3 or matrix.size(-2) != 3:
+        raise ValueError(f"Invalid rotation matrix shape {matrix.shape}.")
+
+    batch_dim = matrix.shape[:-2]
+    m00, m01, m02, m10, m11, m12, m20, m21, m22 = torch.unbind(
+        matrix.reshape(batch_dim + (9,)), dim=-1
+    )
+
+    q_abs = _sqrt_positive_part(
+        torch.stack(
+            [
+                1.0 + m00 + m11 + m22,
+                1.0 + m00 - m11 - m22,
+                1.0 - m00 + m11 - m22,
+                1.0 - m00 - m11 + m22,
+            ],
+            dim=-1,
+        )
+    )
+
+    # we produce the desired quaternion multiplied by each of r, i, j, k
+    quat_by_rijk = torch.stack(
+        [
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([q_abs[..., 0] ** 2, m21 - m12, m02 - m20, m10 - m01], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m21 - m12, q_abs[..., 1] ** 2, m10 + m01, m02 + m20], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m02 - m20, m10 + m01, q_abs[..., 2] ** 2, m12 + m21], dim=-1),
+            # pyre-fixme[58]: `**` is not supported for operand types `Tensor` and
+            #  `int`.
+            torch.stack([m10 - m01, m20 + m02, m21 + m12, q_abs[..., 3] ** 2], dim=-1),
+        ],
+        dim=-2,
+    )
+
+    # We floor here at 0.1 but the exact level is not important; if q_abs is small,
+    # the candidate won't be picked.
+    flr = torch.tensor(0.1).to(dtype=q_abs.dtype, device=q_abs.device)
+    quat_candidates = quat_by_rijk / (2.0 * q_abs[..., None].max(flr))
+
+    # if not for numerical problems, quat_candidates[i] should be same (up to a sign),
+    # forall i; we pick the best-conditioned one (with the largest denominator)
+
+    return quat_candidates[
+        F.one_hot(q_abs.argmax(dim=-1), num_classes=4) > 0.5, :
+    ].reshape(batch_dim + (4,))
+
+def quat2ortho6d(quat):
+    # Shape of quat: (number of obs, 4)
+    # Returns ortho6d: (number of obs, 6)
+    mat = compute_rotation_matrix_from_quaternion(quat)
+    ortho6d = get_ortho6d_from_rotation_matrix(mat)
+    return ortho6d
+
+def ortho6d2quat(ortho6d):
+    mat = compute_rotation_matrix_from_ortho6d(ortho6d)
+    quat = compute_quaternion_from_rotation_matrix(mat)
+    return quat
+
+#------------- Continuous Euler Angle ------------#
+def q_normalize(q):
+    q = np.asarray(q, dtype=np.float64)
+    return q / (np.linalg.norm(q) + 1e-12)
+
+def q_conj(q):  # (w,x,y,z)
+    return np.array([q[0], -q[1], -q[2], -q[3]], dtype=np.float64)
+
+def q_mul(a, b):  # (wxyz)*(wxyz)
+    w1,x1,y1,z1 = a; w2,x2,y2,z2 = b
+    return np.array([
+        w1*w2 - x1*x2 - y1*y2 - z1*z2,
+        w1*x2 + x1*w2 + y1*z2 - z1*y2,
+        w1*y2 - x1*z2 + y1*w2 + z1*x2,
+        w1*z2 + x1*y2 - y1*x2 + z1*w2
+    ], dtype=np.float64)
+
+def same_hemisphere(q_ref, q):
+    """Flip q to keep dot>=0, avoiding sign flips across frames."""
+    return q if np.dot(q_ref, q) >= 0.0 else -q
+
+def quat_to_rotvec(q):
+    """
+    Quaternion (wxyz) -> rotation vector (axis*angle).
+    Angle in [0, pi]. Stable near 0.
+    """
+    q = q_normalize(q)
+    w, v = q[0], q[1:]
+    nv = np.linalg.norm(v)
+    # angle = 2*atan2(||v||, w). Clamp w>=0 to pick the shortest arc.
+    angle = 2.0 * np.arctan2(nv, max(w, 0.0))
+    if angle < 1e-8 or nv < 1e-12:
+        return np.zeros(3, dtype=np.float64)
+    axis = v / nv
+    return angle * axis
+
+def so3_delta_error(
+    q_curr, q_tgt, *, quat_order="wxyz", same_hemi=True,
+    max_step_deg=5.0, out="euler"
+):
+    """
+    Rotation error in WORLD frame between q_curr -> q_tgt.
+    Returns a 3D vector:
+      - out='euler': small-angle XYZ delta euler (we pass rotvec as delta euler)
+      - out='rotvec': rotation vector (axis*angle)
+    Args:
+      q_curr, q_tgt: quaternion arrays in given quat_order.
+      quat_order: 'wxyz' (default) or 'xyzw'.
+      same_hemi: enforce same hemisphere to avoid sign flips.
+      max_step_deg: clamp |rot| per step (set None to disable).
+    """
+    q_c = np.asarray(q_curr, dtype=np.float64)
+    q_t = np.asarray(q_tgt,  dtype=np.float64)
+
+    if quat_order == "xyzw":
+        q_c = np.array([q_c[3], q_c[0], q_c[1], q_c[2]], dtype=np.float64)
+        q_t = np.array([q_t[3], q_t[0], q_t[1], q_t[2]], dtype=np.float64)
+    elif quat_order != "wxyz":
+        raise ValueError("quat_order must be 'wxyz' or 'xyzw'.")
+
+    q_c = q_normalize(q_c)
+    q_t = q_normalize(q_t)
+    if same_hemi:
+        q_t = same_hemisphere(q_c, q_t)
+
+    # Relative rotation (shortest arc): q_delta = q_t * conj(q_c)
+    q_delta = q_mul(q_t, q_conj(q_c))
+
+    # Log-map to rotvec
+    rotvec = quat_to_rotvec(q_delta)
+
+    # Clamp step angle if requested
+    if max_step_deg is not None:
+        max_rad = np.deg2rad(max_step_deg)
+        ang = np.linalg.norm(rotvec)
+        if ang > max_rad and ang > 1e-12:
+            rotvec = rotvec * (max_rad / ang)
+
+    if out == "rotvec":
+        return rotvec
+    elif out == "euler":
+        # Small-angle: rotvec ≈ [dRx, dRy, dRz] in XYZ order
+        return rotvec.copy()
+    else:
+        raise ValueError("out must be 'euler' or 'rotvec'.")
+
+
+## Batch of code that can be useful if used with transforms3d quat2mat and mat2quat. Otherwise, do not use. Not efficient
+# def normalize_vector(v, return_mag=False):
+#     device = v.device
+#     v_mag = torch.sqrt(v.pow(2).sum(0))
+#     v_mag = torch.max(v_mag, torch.autograd.Variable(torch.FloatTensor([1e-8]).to(device)))
+#     v_mag = v_mag.expand(v.shape[0])
+#     v = v / v_mag
+#     if return_mag:
+#         return v, v_mag
+#     else:
+#         return v
+    
+# def cross_product(u, v):
+#     i = u[1] * v[2] - u[2] * v[1]
+#     j = u[2] * v[0] - u[0] * v[2] 
+#     k = u[0] * v[1] - u[1] * v[0]
+#     out = torch.stack([i, j, k])
+#     return out  # 3
+
+# def get_ortho6d_from_rotation_matrix(matrix):
+#     # The orhto6d represents the first two column vectors a1 and a2 of the
+#     # rotation matrix: [ | , |,  | ]
+#     #                  [ a1, a2, a3]
+#     #                  [ | , |,  | ]
+#     ortho6d = matrix[:, :2].permute(1, 0).flatten(-2)
+#     return ortho6d
+
+# def compute_rotation_matrix_from_ortho6d(ortho6d):
+#     x_raw = ortho6d[0:3]  # 3
+#     y_raw = ortho6d[3:6]  # 3
+
+#     x = normalize_vector(x_raw)  # 3
+#     z = cross_product(x, y_raw)  # 3
+#     z = normalize_vector(z)  # 3
+#     y = cross_product(z, x)  # 3
+
+#     x = x.view(3, 1)
+#     y = y.view(3, 1)
+#     z = z.view(3, 1)
+#     matrix = torch.cat((x, y, z), 1)  # 3x3
+#     return matrix

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/chamfer.py

@@ -0,0 +1,158 @@
+# Copyright (c) Facebook, Inc. and its affiliates. All rights reserved.
+
+from typing import Union
+
+import torch
+import torch.nn.functional as F
+from pytorch3d.ops.knn import knn_gather, knn_points
+from pytorch3d.structures.pointclouds import Pointclouds
+
+
+def _validate_chamfer_reduction_inputs(
+    batch_reduction: Union[str, None], point_reduction: str
+):
+    """Check the requested reductions are valid.
+    Args:
+        batch_reduction: Reduction operation to apply for the loss across the
+            batch, can be one of ["mean", "sum"] or None.
+        point_reduction: Reduction operation to apply for the loss across the
+            points, can be one of ["mean", "sum"].
+    """
+    if batch_reduction is not None and batch_reduction not in ["mean", "sum"]:
+        raise ValueError('batch_reduction must be one of ["mean", "sum"] or None')
+    if point_reduction not in ["mean", "sum"]:
+        raise ValueError('point_reduction must be one of ["mean", "sum"]')
+
+
+def _handle_pointcloud_input(
+    points: Union[torch.Tensor, Pointclouds],
+    lengths: Union[torch.Tensor, None],
+    normals: Union[torch.Tensor, None],
+):
+    """
+    If points is an instance of Pointclouds, retrieve the padded points tensor
+    along with the number of points per batch and the padded normals.
+    Otherwise, return the input points (and normals) with the number of points per cloud
+    set to the size of the second dimension of `points`.
+    """
+    if isinstance(points, Pointclouds):
+        X = points.points_padded()
+        lengths = points.num_points_per_cloud()
+        normals = points.normals_padded()  # either a tensor or None
+    elif torch.is_tensor(points):
+        if points.ndim != 3:
+            raise ValueError("Expected points to be of shape (N, P, D)")
+        X = points
+        if lengths is not None and (
+            lengths.ndim != 1 or lengths.shape[0] != X.shape[0]
+        ):
+            raise ValueError("Expected lengths to be of shape (N,)")
+        if lengths is None:
+            lengths = torch.full(
+                (X.shape[0],), X.shape[1], dtype=torch.int64, device=points.device
+            )
+        if normals is not None and normals.ndim != 3:
+            raise ValueError("Expected normals to be of shape (N, P, 3")
+    else:
+        raise ValueError(
+            "The input pointclouds should be either "
+            + "Pointclouds objects or torch.Tensor of shape "
+            + "(minibatch, num_points, 3)."
+        )
+    return X, lengths, normals
+
+class ChamferDistance(torch.nn.Module):
+    def forward(
+        self,
+        x,
+        y,
+        x_lengths=None,
+        y_lengths=None,
+        x_normals=None,
+        y_normals=None,
+        weights=None,
+        batch_reduction: Union[str, None] = "mean",
+        point_reduction: str = "mean",
+    ):
+        """
+        Chamfer distance between two pointclouds x and y.
+        Args:
+            x: FloatTensor of shape (N, P1, D) or a Pointclouds object representing
+                a batch of point clouds with at most P1 points in each batch element,
+                batch size N and feature dimension D.
+            y: FloatTensor of shape (N, P2, D) or a Pointclouds object representing
+                a batch of point clouds with at most P2 points in each batch element,
+                batch size N and feature dimension D.
+            x_lengths: Optional LongTensor of shape (N,) giving the number of points in each
+                cloud in x.
+            y_lengths: Optional LongTensor of shape (N,) giving the number of points in each
+                cloud in x.
+            x_normals: Optional FloatTensor of shape (N, P1, D).
+            y_normals: Optional FloatTensor of shape (N, P2, D).
+            weights: Optional FloatTensor of shape (N,) giving weights for
+                batch elements for reduction operation.
+            batch_reduction: Reduction operation to apply for the loss across the
+                batch, can be one of ["mean", "sum"] or None.
+            point_reduction: Reduction operation to apply for the loss across the
+                points, can be one of ["mean", "sum"].
+        Returns:
+            2-element tuple containing
+            - **loss**: Tensor giving the reduced distance between the pointclouds
+              in x and the pointclouds in y.
+            - **loss_normals**: Tensor giving the reduced cosine distance of normals
+              between pointclouds in x and pointclouds in y. Returns None if
+              x_normals and y_normals are None.
+        """
+        _validate_chamfer_reduction_inputs(batch_reduction, point_reduction)
+
+        x, x_lengths, x_normals = _handle_pointcloud_input(x, x_lengths, x_normals)
+        y, y_lengths, y_normals = _handle_pointcloud_input(y, y_lengths, y_normals)
+
+        return_normals = x_normals is not None and y_normals is not None
+
+        N, P1, D = x.shape
+        P2 = y.shape[1]
+
+        # Check if inputs are heterogeneous and create a lengths mask.
+        is_x_heterogeneous = (x_lengths != P1).any()
+        # is_y_heterogeneous = (y_lengths != P2).any()
+        x_mask = (
+            torch.arange(P1, device=x.device)[None] >= x_lengths[:, None]
+        )  # shape [N, P1]
+        # y_mask = (
+        #     torch.arange(P2, device=y.device)[None] >= y_lengths[:, None]
+        # )  # shape [N, P2]
+
+        if y.shape[0] != N or y.shape[2] != D:
+            raise ValueError("y does not have the correct shape.")
+        if weights is not None:
+            if weights.size(0) != N:
+                raise ValueError("weights must be of shape (N,).")
+            if not (weights >= 0).all():
+                raise ValueError("weights cannot be negative.")
+            if weights.sum() == 0.0:
+                weights = weights.view(N, 1)
+                if batch_reduction in ["mean", "sum"]:
+                    return (
+                        (x.sum((1, 2)) * weights).sum() * 0.0,
+                        (x.sum((1, 2)) * weights).sum() * 0.0,
+                    )
+                return ((x.sum((1, 2)) * weights) * 0.0, (x.sum((1, 2)) * weights) * 0.0)
+
+
+        x_nn = knn_points(x, y, lengths1=x_lengths, lengths2=y_lengths, K=1)
+        # y_nn = knn_points(y, x, lengths1=y_lengths, lengths2=x_lengths, K=1)
+
+        cham_x = x_nn.dists[..., 0]  # (N, P1)
+        # cham_y = y_nn.dists[..., 0]  # (N, P2)
+
+        if is_x_heterogeneous:
+            cham_x[x_mask] = 0.0
+        # if is_y_heterogeneous:
+        #     cham_y[y_mask] = 0.0
+
+        if weights is not None:
+            cham_x *= weights.view(N, 1)
+            # cham_y *= weights.view(N, 1)
+
+        return cham_x, x_nn.idx[...,-1]

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/data_utils.py

@@ -0,0 +1,538 @@
+import h5py
+import os
+import pickle as pkl
+# from mani_skill2.utils.io_utils import load_json
+import numpy as np
+import re
+import torch
+import torch.nn.functional as Functional
+
+from cfdp.utils.pointcloud_utils import convertRGBD2PCD
+from cfdp.utils.angle_utils import quat2ortho6d, ortho6d2quat
+
+def pad_tensor(tensor, target_length, pad_front=False):
+    """Pad a tensor by repeating first/last element to reach target length.
+    
+    Args:
+        tensor (torch.Tensor): Input tensor to pad
+        target_length (int): Desired length after padding
+        pad_front (bool): If True, pad at front by repeating first element
+                        If False, pad at back by repeating last element
+                        
+    Returns:
+        torch.Tensor: Padded tensor of length target_length
+    """
+    current_length = tensor.shape[0]
+
+    if current_length >= target_length:
+        return tensor
+        
+    pad_size = target_length - current_length
+    
+    if pad_front:
+        # Repeat first element at front
+        padding = tensor[0].unsqueeze(0).repeat(pad_size, *[1] * (len(tensor.shape) - 1))
+        return torch.cat([padding, tensor], dim=0)
+    else:
+        # Repeat last element at back
+        padding = tensor[-1].unsqueeze(0).repeat(pad_size, *[1] * (len(tensor.shape) - 1))
+        return torch.cat([tensor, padding], dim=0)
+
+def interpolate_points(points, num_interpolated_points, resample=False):
+    # https://github.com/SamsungLabs/RAMP/blob/c3bd23b2c296c94cdd80d6575390fd96c4f83d83/mppi_planning/cost/collision_cost.py#L89
+    if len(points.shape) == 2:
+        points = points.unsqueeze(0)
+        if resample:
+            points = resample_trajectory_torch_interp(points, num_interpolated_points)
+            # points = Functional.interpolate(points.transpose(-2, -1), 
+            #                                 size=num_interpolated_points, 
+            #                                 mode='nearest').transpose(-2, -1)
+        else:
+            points = Functional.interpolate(points.transpose(-2, -1), 
+                                            size=num_interpolated_points, 
+                                            mode='linear', align_corners=True).transpose(-2, -1)
+        return points[0]
+    elif len(points.shape) == 3:
+        if resample:
+            points = resample_trajectory_torch_interp(points, num_interpolated_points)
+            # points = Functional.interpolate(points.transpose(-2, -1), 
+            #                                 size=num_interpolated_points, 
+            #                                 mode='nearest').transpose(-2, -1)
+        else:
+            points = Functional.interpolate(points.transpose(-2, -1), 
+                                            size=num_interpolated_points, 
+                                            mode='linear', align_corners=True).transpose(-2, -1)
+        return points
+    else:
+        raise ValueError(f"points.shape = {points.shape} is not supported. Only accept 2D or 3D tensor.")
+
+
+def resample_trajectory_torch_interp(points, num_points):
+    """
+    Resample trajectory using torch interpolation for more evenly distributed points
+    based on arc length parameterization
+    """
+    device = points.device
+    batch_size, length, dim = points.shape
+    
+    # Calculate differences between consecutive points
+    diffs = points[:, 1:] - points[:, :-1]  # [N, length-1, dim]
+    
+    # Calculate segment lengths for each batch
+    segment_lengths = torch.norm(diffs, dim=2)  # [N, length-1]
+    
+    # Calculate cumulative lengths for each batch
+    zeros = torch.zeros((batch_size, 1), device=device)
+    cumulative_lengths = torch.cat([zeros, torch.cumsum(segment_lengths, dim=1)], dim=1)  # [N, length]
+    
+    # Create evenly spaced sampling points for each batch
+    max_lengths = cumulative_lengths[:, -1].unsqueeze(1)  # [N, 1]
+    even_samples = torch.linspace(0, 1, num_points, device=device).unsqueeze(0).repeat(batch_size, 1)  # [N, num_points]
+    even_samples = even_samples * max_lengths  # [N, num_points]
+    
+    # Initialize output tensor
+    resampled = torch.zeros((batch_size, num_points, dim), device=device)
+    
+    # Interpolate each dimension for each batch
+    for b in range(batch_size):
+        # Normalize cumulative lengths to [0, 1] for this batch
+        if max_lengths[b, 0] > 0:  # Avoid division by zero
+            norm_cum_lengths = cumulative_lengths[b] / max_lengths[b, 0]
+        else:
+            norm_cum_lengths = torch.linspace(0, 1, length, device=device)
+            
+        # Normalize sampling points to [0, 1]
+        norm_samples = even_samples[b] / max_lengths[b, 0] if max_lengths[b, 0] > 0 else torch.linspace(0, 1, num_points, device=device)
+        
+        for d in range(dim):
+            # For each point in norm_samples, find its interpolated value
+            for i in range(num_points):
+                sample = norm_samples[i]
+                
+                # Find the two points to interpolate between
+                idx = torch.searchsorted(norm_cum_lengths, sample) - 1
+                idx = torch.clamp(idx, 0, length - 2)
+                
+                # Get the two points and their normalized positions
+                x0 = norm_cum_lengths[idx]
+                x1 = norm_cum_lengths[idx + 1]
+                y0 = points[b, idx, d]
+                y1 = points[b, idx + 1, d]
+                
+                # Linear interpolation
+                if x1 > x0:  # Avoid division by zero
+                    alpha = (sample - x0) / (x1 - x0)
+                else:
+                    alpha = 0.0
+                    
+                resampled[b, i, d] = y0 + alpha * (y1 - y0)
+    
+    return resampled
+
+def get_flattened_obs(data, obs_keys):
+    data_dict = get_data_dict(data)
+    # Directly create torch tensor for the trajectory
+    obs_tensors = [transform_quat_to_ortho6d(torch.tensor(data_dict[k][:-1], dtype=torch.float32)) if k == 'tcp_pose' else torch.tensor(data_dict[k][:-1], dtype=torch.float32) for k in obs_keys]
+    # Concatenate torch tensors
+    return torch.cat(obs_tensors, dim = 1)
+
+def transform_quat_to_ortho6d(obs_tensor):
+    # Handle 1D tensor by adding batch dimension
+    if len(obs_tensor.shape) == 1:
+        obs_tensor = obs_tensor.unsqueeze(0)
+        
+    xyz = obs_tensor[:, :3]  # First 3 elements are xyz position
+    quat = obs_tensor[:, 3:]  # Next 4 elements are quaternion orientation
+    ortho6d = quat2ortho6d(quat)
+    return torch.cat([xyz, ortho6d], dim=1)
+
+def transform_ortho6d_to_quat(obs_tensor):
+    # Handle 1D tensor by adding batch dimension
+    if len(obs_tensor.shape) == 1:
+        obs_tensor = obs_tensor.unsqueeze(0)
+        
+    xyz = obs_tensor[:, :3]
+    ortho6d = obs_tensor[:, 3:]
+    quat = ortho6d2quat(ortho6d)
+    return torch.cat([xyz, quat], dim = 1)
+
+def load_raw_data(dataset_file, pcd, force_reload, load_count):
+    """Load raw data from h5 file or cached pickle file"""
+    # pkl_file = dataset_file.replace(".h5", ".pkl")
+    
+    # # Check if the pickle file exists and can be used
+    # if os.path.exists(pkl_file) and not force_reload:
+    #     # TODO: Load count is innacurate here. Not used for pkl file.
+    #     return load_from_pickle(pkl_file)
+    
+    # # Load from h5 file
+    return load_from_h5(dataset_file, pcd, load_count)#, pkl_file)
+
+def load_from_pickle(pkl_file):
+    """Load preprocessed data from pickle file"""
+    with open(pkl_file, "rb") as f:
+        return pkl.load(f)
+
+def load_from_h5(dataset_file, pcd, load_count):#, pkl_file):
+    """Load and process data from h5 file"""
+    data = h5py.File(dataset_file, "r")
+
+    # find all traj_* groups
+    traj_keys = [k for k in data.keys() if k.startswith("traj_")]
+    # natural sort so traj_2 comes before traj_10
+    def ns_key(s): 
+        return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", s)]
+    traj_keys = sorted(traj_keys, key=ns_key)
+
+    # decide how many to load
+    if load_count == -1 or load_count > len(traj_keys):
+        load_count = len(traj_keys)
+
+    allData = []
+    for k in traj_keys[:load_count]:
+        traj_data = hdf5_to_dict(data[k])
+        if pcd:
+            traj_data = convertRGBD2PCD(traj_data)
+        allData.append(traj_data)
+
+    return allData
+    # data = h5py.File(dataset_file, "r")
+    # json_path = dataset_file.replace(".h5", ".json")
+    # json_data = load_json(json_path)
+    # episodes = json_data["episodes"]
+    # env_info = json_data["env_info"]
+    # env_id = env_info["env_id"]
+    # env_kwargs = env_info["env_kwargs"]
+    
+    # allData = []
+    # if load_count == -1:
+    #     load_count = len(episodes)
+        
+    # for eps_id in range(load_count):
+    #     traj_data = hdf5_to_dict(data[f'traj_{eps_id}'])
+        
+    #     if pcd:
+    #         traj_data = convertRGBD2PCD(traj_data)
+    #     allData.append(traj_data)
+        
+    # # # Cache processed data
+    # # with open(pkl_file, "wb") as f:
+    # #     pkl.dump(allData, f)
+        
+    # return allData
+
+def hdf5_to_dict(hdf5_group):
+    """
+    Convert an HDF5 group to a dictionary.
+
+    This function recursively converts an HDF5 group into a nested dictionary,
+    where datasets are converted to their corresponding numpy arrays.
+
+    Args:
+        hdf5_group (h5py.Group): The HDF5 group to convert.
+
+    Returns:
+        dict: A dictionary representation of the HDF5 group.
+    """
+    def recursively_convert(hdf5_group):
+        result = {}
+        for key, item in hdf5_group.items():
+            if isinstance(item, h5py.Dataset):
+                result[key] = item[()]
+            elif isinstance(item, h5py.Group):
+                result[key] = recursively_convert(item)
+        return result
+    return recursively_convert(hdf5_group)
+
+class ObsQueue():
+    def __init__(self, size: int, obs=None):
+        self.size = size  # Fixed length of the data structure
+        if obs is not None:
+            self.queue = [obs] * size  # Initialize with the same float value
+        else:
+            self.queue = []  # Initialize with empty queue
+            
+    def append(self, obs):
+        # If queue is empty, initialize it with size copies of the first observation
+        if len(self.queue) == 0:
+            self.queue = [obs] * self.size
+        else:
+            # Normal append and maintain size
+            self.queue.append(obs)
+            self.queue = self.queue[-self.size:]  # Keep only the most recent 'size' elements
+            
+    def get_values_as_tensor(self):
+        # Convert the current queue into a PyTorch tensor
+        return torch.stack(self.queue[-self.size:])
+
+    def __repr__(self):
+        # Display the current state of the queue
+        return f"Queue({self.queue})"
+    
+    def __shape__(self):
+        return torch.stack(self.queue[-self.size:]).shape
+
+def create_trajectory_with_history(data, history_length, trajectory_length, stride = 5):
+    """Creates trajectories with historical context by combining past observations with interpolated future points.
+    
+    Args:
+        data (torch.Tensor): Input tensor of shape (N, D) containing N observations of dimension D
+        history_length (int): Number of past observations to include in each trajectory
+        trajectory_length (int): Total desired length of each trajectory
+        
+    Returns:
+        torch.Tensor: Tensor of shape (N-1, trajectory_length, D) containing trajectories that combine
+            history_length past observations with trajectory_length-history_length interpolated future points
+            
+    The function maintains a queue of past observations and combines them with interpolated future points
+    to create trajectories that have both historical context and predicted future states.
+    """
+    obsqueue = ObsQueue(history_length, data[0])
+    front_list = []
+    back_list = []
+    for i in range(1, data.shape[0]-history_length, stride):
+        front = obsqueue.get_values_as_tensor()
+        # Check if we have enough remaining observations
+        if data[i:].shape[0] >= trajectory_length:
+            # If enough data, interpolate
+            back = interpolate_points(data[i:], trajectory_length)
+        else:
+            # If not enough data, pad to trajectory length
+            back = pad_tensor(data[i:], trajectory_length, pad_front=False)
+        front_list.append(front)
+        back_list.append(back)
+        obsqueue.append(data[i])
+    return torch.stack(front_list), torch.stack(back_list)
+
+
+def get_data_dict(data):
+    def print_nested_keys(d, prefix=''):
+        for key, value in d.items():
+            if isinstance(value, dict):
+                print(f"{prefix}- {key}/")
+                print_nested_keys(value, prefix + '  ')
+            else:
+                print(f"{prefix}- {key}")
+
+    # print("All keys in data:")
+    # print_nested_keys(data)
+    # print("--------------------------------")
+    data_dict = {
+        'qpos': data.get('obs', {}).get('agent', {}).get('qpos', None),
+        'qvel': data.get('obs', {}).get('agent', {}).get('qvel', None),
+        'base_pose': data.get('obs', {}).get('agent', {}).get('base_pose', None),
+        'tcp_pose': data.get('obs', {}).get('extra', {}).get('tcp_pose', None),
+        'goal_pose': data.get('obs', {}).get('extra', {}).get('goal_pose', None),
+        'success': data.get('success', None),
+        'env_states': data.get('env_states', None)
+    }
+    return data_dict
+
+def get_flattened_obs_with_history(data, obs_keys, history_length, trajectory_length, stride = 5):
+    # data_dict = {
+    #     'qpos': data['obs']['agent']['qpos'],
+    #     'qvel': data['obs']['agent']['qvel'],
+    #     'base_pose': data['obs']['agent']['base_pose'],
+    #     'tcp_pose': data['obs']['extra']['tcp_pose'],
+    #     'goal_pose': data['obs']['extra']['goal_pose'],
+    #     'success': data['success'],
+    #     'env_states': data['env_states']
+    # }
+    data_dict = get_data_dict(data)
+    
+    # Directly create torch tensor for the trajectory
+    obs_tensors = []
+    trajectory_tensors = []
+    for k in obs_keys:
+        if k == 'tcp_pose':
+            tensor = transform_quat_to_ortho6d(torch.tensor(data_dict[k][:-1], dtype=torch.float32))
+            obs, trajectory = create_trajectory_with_history(tensor, history_length, trajectory_length, stride)
+        elif k == 'qpos':
+            tensor = torch.tensor(data_dict[k][:-1], dtype=torch.float32)
+            obs, trajectory = create_trajectory_with_history(tensor, history_length, trajectory_length, stride)
+        else:
+            raise NotImplementedError("Non-tcp_pose keys not yet implemented")
+        obs_tensors.append(obs)
+        trajectory_tensors.append(trajectory)
+        # import pdb; pdb.set_trace()  # Add breakpoint here
+    # Concatenate torch tensors
+    return torch.cat(obs_tensors, dim = 1), torch.cat(trajectory_tensors, dim = 1)
+
+def create_sample_indices(
+    end_idx: int,
+    sequence_length: int,
+    pad_before: int = 0,
+    pad_after: int = 0,
+):
+    indices = list()
+    start_idx = 0
+    episode_length = end_idx - start_idx
+
+    min_start = -pad_before
+    max_start = episode_length - sequence_length + pad_after
+
+    # range stops one idx before end
+    for idx in range(min_start, max_start + 1):
+        buffer_start_idx = max(idx, 0) + start_idx
+        buffer_end_idx = min(idx + sequence_length, episode_length) + start_idx
+        start_offset = buffer_start_idx - (idx + start_idx)
+        end_offset = (idx + sequence_length + start_idx) - buffer_end_idx
+        sample_start_idx = 0 + start_offset
+        sample_end_idx = sequence_length - end_offset
+        indices.append(
+            [buffer_start_idx, buffer_end_idx, sample_start_idx, sample_end_idx]
+        )
+    indices = np.array(indices)
+    return indices
+
+def sample_sequence(
+    train_data,
+    sequence_length,
+    buffer_start_idx,
+    buffer_end_idx,
+    sample_start_idx,
+    sample_end_idx,
+):
+    """
+    Extracts a sequence from train_data with padding if needed.
+    
+    Parameters:
+    - train_data: Dictionary of arrays containing the training data
+    - sequence_length: Desired length of the output sequence
+    - buffer_start_idx, buffer_end_idx: Indices to extract from the original data
+    - sample_start_idx: Index in the output sequence where the actual data should start
+                        (if > 0, padding is added before this index using the first value)
+    - sample_end_idx: Index in the output sequence where the actual data should end
+                      (if < sequence_length, padding is added after this index using the last value)
+    """
+    result = dict()
+    for key, input_arr in train_data.items():
+        sample = input_arr[buffer_start_idx:buffer_end_idx]
+        data = sample
+        if (sample_start_idx > 0) or (sample_end_idx < sequence_length):
+            # Create a zero-initialized array of the desired sequence length
+            data = np.zeros(
+                shape=(sequence_length,) + input_arr.shape[1:], dtype=input_arr.dtype
+            )
+            # If we need padding at the beginning, fill with the first value
+            if sample_start_idx > 0:
+                data[:sample_start_idx] = sample[0]
+            # If we need padding at the end, fill with the last value
+            if sample_end_idx < sequence_length:
+                data[sample_end_idx:] = sample[-1]
+            # Place the actual data in the middle
+            data[sample_start_idx:sample_end_idx] = sample
+        result[key] = data
+    return result
+
+def get_chunked_data(
+    data,
+    pred_horizon: int = 16,
+    obs_horizon: int = 2,
+    action_horizon: int = 8,
+    pad_before: int = None,
+    pad_after: int = None,
+):
+    pad_before = (
+        pad_before if pad_before is not None else obs_horizon - 1
+    )  # Default of Diffusion Policy
+    pad_after: int = (
+        pad_after if pad_after is not None else action_horizon - 1
+    )  # Default of Diffusion Policy
+
+    train_data = {}
+    train_data['obs'] = data['obs']['extra']['tcp_pose'][:-1]
+    train_data['actions'] = data['actions']
+    data_len = len(train_data['obs'])
+    indices = create_sample_indices(data_len, pred_horizon, pad_before, pad_after)
+    obs = list()
+    actions = list()
+    # Get all the samples of data
+    for idx in range(len(indices)):
+        buffer_start_idx, buffer_end_idx, sample_start_idx, sample_end_idx = indices[
+            idx
+        ]
+
+        # get nomralized data using these indices
+        nsample = sample_sequence(
+            train_data=train_data,
+            sequence_length=pred_horizon,
+            buffer_start_idx=buffer_start_idx,
+            buffer_end_idx=buffer_end_idx,
+            sample_start_idx=sample_start_idx,
+            sample_end_idx=sample_end_idx,
+        )
+        # nsample["obs"] = nsample["obs"][:obs_horizon, :]
+        obs.append(transform_quat_to_ortho6d(torch.tensor(nsample["obs"], dtype=torch.float32)))
+        actions.append(torch.tensor(nsample["actions"], dtype=torch.float32))
+    
+    # Convert lists to tensors
+    obs = torch.stack(obs)
+    actions = torch.stack(actions)
+    
+    return obs, actions
+
+class ObservationData:
+    """A structured class to handle different types of observation data"""
+    def __init__(self, data=None):
+        self.agent_data = {
+            'qpos': None,  # Joint positions
+            'qvel': None,  # Joint velocities
+            'base_pose': None,  # Base pose
+        }
+        self.extra_data = {
+            'tcp_pose': None,  # End effector pose
+            'goal_pose': None,  # Goal pose
+        }
+        if data is not None:
+            self.update_from_dict(data)
+    
+    def update_from_dict(self, data):
+        """Update observation data from a dictionary"""
+        if 'obs' in data:
+            if 'agent' in data['obs']:
+                for key in self.agent_data.keys():
+                    if key in data['obs']['agent']:
+                        self.agent_data[key] = data['obs']['agent'][key]
+            if 'extra' in data['obs']:
+                for key in self.extra_data.keys():
+                    if key in data['obs']['extra']:
+                        self.extra_data[key] = data['obs']['extra'][key]
+    
+    def to_tensor(self, device='cpu'):
+        """Convert observation data to tensors"""
+        tensor_data = {}
+        for key, value in self.agent_data.items():
+            if value is not None:
+                tensor_data[key] = torch.tensor(value, dtype=torch.float32).to(device)
+        for key, value in self.extra_data.items():
+            if value is not None:
+                tensor_data[key] = torch.tensor(value, dtype=torch.float32).to(device)
+        return tensor_data
+    
+    def get_hard_conditions(self, device='cpu', do_normalize=True, normalizer=None):
+        """Get hard conditions for both joint and end effector states"""
+        hard_conds = {}
+        tensor_data = self.to_tensor(device)
+        
+        # Handle end effector pose
+        if tensor_data.get('tcp_pose') is not None and tensor_data.get('goal_pose') is not None:
+            initial_state = transform_quat_to_ortho6d(tensor_data['tcp_pose'])
+            goal_state = transform_quat_to_ortho6d(tensor_data['goal_pose'])
+            
+            if do_normalize and normalizer is not None:
+                temp_tensor = torch.cat([initial_state, goal_state], dim=0)
+                normalized_state = normalizer.normalize(temp_tensor, 'tcp_pose')
+                hard_conds['tcp_pose'] = {0: normalized_state[0], -1: normalized_state[-1]}
+            else:
+                hard_conds['tcp_pose'] = {0: initial_state, -1: goal_state}
+        
+        # Handle joint positions
+        if tensor_data.get('qpos') is not None:
+            if do_normalize and normalizer is not None:
+                normalized_state = normalizer.normalize(tensor_data['qpos'], 'qpos')
+                hard_conds['qpos'] = {0: normalized_state[0], -1: normalized_state[-1]}
+            else:
+                hard_conds['qpos'] = {0: tensor_data['qpos'][0], -1: tensor_data['qpos'][-1]}
+        
+        return hard_conds

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/fcm/base_utils.py

@@ -0,0 +1,240 @@
+import cv2
+import numpy as np
+import pickle
+import os
+def normalize_image(img, min_val=None, new_range=(0,255), to_uint8=True):
+    axis = None if img.ndim == 2 else (0, 1)
+    if min_val is None:
+        old_min = np.min(img, axis=axis)
+    else:
+        old_min = np.zeros(img.shape[-1])
+    new_image = ((img - old_min) * (new_range[1]-(new_range[0])) /
+                 (np.max(img, axis=axis) - old_min)) + new_range[0]
+    if to_uint8:
+        new_image = new_image.astype(np.uint8)
+    return new_image
+
+def visualize_images(img_path):
+    # RGBXYZS
+    with open(img_path, 'rb') as f:
+        sample = pickle.load(f)
+    multi_img = np.array(sample).reshape((-1, 640, 7))
+    rgb_image = cv2.cvtColor(multi_img[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+    depth_img = normalize_image(multi_img[..., 5], 0)
+    xy_image = normalize_image(multi_img[..., 3:5])
+
+    rgb_depth = cv2.hconcat((rgb_image,cv2.cvtColor(depth_img, cv2.COLOR_GRAY2RGB)))
+    xy_image = cv2.hconcat((cv2.cvtColor(xy_image[..., 0], cv2.COLOR_GRAY2RGB),
+                            cv2.cvtColor(xy_image[..., 1], cv2.COLOR_GRAY2RGB)))
+    final_image = cv2.vconcat((rgb_depth, xy_image))
+
+    cv2.imshow('RGB-Depth-X-Y', final_image)
+    cv2.waitKey(0)
+    return rgb_image, depth_img, xy_image
+
+
+def get_image_pkl(img_path):
+    with open(img_path, 'rb') as f:
+        sample = pickle.load(f)
+    return np.array(sample).reshape((-1, 640, 7))
+
+def sort_images(res_dict, key):
+    key_vals = []
+    for res in res_dict:
+        key_vals.append(res[key])
+    return np.argsort(key_vals)
+
+def sort_images_real(res_dict, key):
+    key_vals = []
+    for k in sorted(res_dict):
+        key_vals.append(res_dict[k]['scores'][k])
+    return np.argsort(key_vals)
+
+def sort_images_target(list_dict, key):
+    key_vals = []
+    for cnt in sorted(list_dict):
+        key_vals.append(list_dict[cnt]['scores'][key])
+    return np.argsort(key_vals)
+
+
+def sort_images_real(list_dict, key):
+    key_vals = []
+    for img_dic in list_dict:
+        key_vals.append(img_dic[key])
+    return np.argsort(key_vals)
+
+
+def rename_files(folder_path ="samples_v2/camera_debug", count=None):
+    root_folder = folder_path
+    files = os.listdir(root_folder)
+    count = count or 1
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        # f = '_'.join(f.split('_')[1:])
+        os.rename(img_name, os.path.join(root_folder, f"{count}_{f}"))
+        count += 1
+
+def file_rename_real1():
+    root_folder = "real_samples/d1"
+    files = os.listdir(root_folder)
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        # print(f.split('_')[0], f.split('_')[0].isdigit())
+        if 'tall' in img_name and not f.split('_')[0].isdigit():
+            # img_name.replace('wrist', 'side')
+            # print(img_name)
+            newimg = f.replace('tall', 'side').split('_')
+            new_img_name = '_'.join([newimg[2], newimg[1], newimg[-1]])
+            new_img_name = os.path.join(root_folder, new_img_name)
+            print(img_name, new_img_name)
+            os.rename(img_name,new_img_name )
+
+def file_rename_real2():
+    root_folder = "real_samples/ds1_removal_clean"
+    files = os.listdir(root_folder)
+    files_dict = {}
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        img_idx = int(f.split('_')[0])
+        if img_idx not in files_dict:
+            files_dict[img_idx] = {}
+        files_dict[img_idx][f.split('_')[-1].split('.')[0]] = img_name
+    sf_dic = {}
+    tcnt = 0
+    fcnt = 0
+    for i, k in enumerate(sorted(files_dict.keys())):
+
+        for key, fname in files_dict[k].items():
+            task_id = tcnt//5
+            new_fn = os.path.join(os.path.dirname(fname), f"sc{task_id}_{fcnt}_removal_{key}.pkl")
+            os.rename(fname,new_fn)
+
+        tcnt += 1
+        fcnt += 1
+        if fcnt % 5 == 0 and fcnt != 0:
+            fcnt = 0
+        print(new_fn)
+        # # print(f.split('_')[0], f.split('_')[0].isdigit())
+        # if 'tall' in img_name and not f.split('_')[0].isdigit():
+        #     # img_name.replace('wrist', 'side')
+        #     # print(img_name)
+        #     newimg = f.replace('tall', 'side').split('_')
+        #     new_img_name = '_'.join([newimg[2], newimg[1], newimg[-1]])
+        #     new_img_name = os.path.join(root_folder, new_img_name)
+        #     print(img_name, new_img_name)
+        #     os.rename(img_name,new_img_name )
+    # print(files_dict)
+
+def file_rename_real3():
+    root_folder = "real_samples/ds2_shift_clean"
+    files = os.listdir(root_folder)
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        idx = int(f.split('_')[2])
+        if idx < 33 and 'sc' not in f:
+            new_file = os.path.join(root_folder, f"sc4_shift_{idx-29}_{f.split('_')[-1]}")
+            os.rename(img_name, new_file)
+
+        # # print(f.split('_')[0], f.split('_')[0].isdigit())
+        # if 'tall' in img_name and not f.split('_')[0].isdigit():
+        #     # img_name.replace('wrist', 'side')
+        #     # print(img_name)
+        #     newimg = f.replace('tall', 'side').split('_')
+        #     new_img_name = '_'.join([newimg[2], newimg[1], newimg[-1]])
+        #     new_img_name = os.path.join(root_folder, new_img_name)
+        #     print(img_name, new_img_name)
+        #     os.rename(img_name,new_img_name )
+
+def test_images():
+    root_folder = "real_samples/ds2_shift"
+    save_root_folder = f"output/test"
+    os.makedirs(save_root_folder, exist_ok=True)
+
+    files = os.listdir(root_folder)
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        with open(img_name, 'rb') as fs:
+            image = pickle.load(fs)
+            image = np.squeeze(image)
+
+        # for writing the scores on the image
+        im = cv2.cvtColor(image[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+        cv2.imwrite(os.path.join(save_root_folder, os.path.basename(img_name).split('.')[0]+".png"), im)
+
+def test_images_tile():
+    root_folder = "real_samples/ds2_shift_clean/side"
+    save_root_folder = f"output/test"
+    os.makedirs(save_root_folder, exist_ok=True)
+
+    files = os.listdir(root_folder)
+    for f in files:
+        img_name = os.path.join(root_folder, f)
+        with open(img_name, 'rb') as fs:
+            side_image = pickle.load(fs)
+            side_image = np.squeeze(side_image)
+        img_name = os.path.join(root_folder.replace('side', 'top'), f.replace('side', 'tall'))
+        with open(img_name, 'rb') as fs:
+            top_image = pickle.load(fs)
+            top_image = np.squeeze(top_image)
+        img_name = os.path.join(root_folder.replace('side', 'wrist'), f.replace('side', 'wrist'))
+        with open(img_name, 'rb') as fs:
+            wrist_image = pickle.load(fs)
+            wrist_image = np.squeeze(wrist_image)
+
+        # for writing the scores on the image
+        side_image = cv2.cvtColor(side_image[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+        top_image = cv2.cvtColor(top_image[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+        wrist_image = cv2.cvtColor(wrist_image[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+        fimg = cv2.hconcat([side_image, top_image, wrist_image])
+        cv2.imwrite(os.path.join(save_root_folder, os.path.basename(img_name).split('.')[0]+".png"), fimg)
+
+def get_real_image(img_name):
+    with open(img_name, 'rb') as fs:
+        image = pickle.load(fs)
+        image = np.squeeze(image)
+
+    return image
+
+def get_dict_variation(res_dict):
+    new_dict = {}
+    for cnt in res_dict:
+        for v in res_dict[cnt]:
+            if v not in new_dict:
+                new_dict[v] = {}
+            new_dict[v][cnt] = {'im': res_dict[cnt][v]['side'],
+                                'scores': res_dict[cnt][v]['scores']}
+    return new_dict
+
+def parse_image_names(root_folder):
+    fls = os.listdir(root_folder)
+    f_dict = {}
+    side = None
+    top = None
+    for f in fls:
+        fl = f.split('_')
+        task = fl[5].replace('\'', '').split('-')[0]
+        count = int(fl[2])
+        variation = int(fl[-1])
+        for _f in os.listdir(os.path.join(root_folder, f)):
+            if 'reset' not in _f and 'pkl' in _f:
+                if 'top' in _f:
+                    top = os.path.join(root_folder, f, _f)
+                else:
+                    side = os.path.join(root_folder, f, _f)
+        if task not in f_dict:
+            f_dict[task] = {}
+        if count not in f_dict[task]:
+            f_dict[task][count] = {}
+        if variation not in f_dict[task][count]:
+            f_dict[task][count][variation] = {'side': side, 'top': top}
+    return f_dict
+
+
+def write_stats(heading, stats_list, file_name):
+
+    with open(file_name, 'wt') as f:
+        f.write(heading + "\n")
+        for s in stats_list:
+            f.write(s)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/fcm/pyramid.py

@@ -0,0 +1,1662 @@
+from operator import mul
+from scipy import signal
+import functools
+import numpy as np
+import warnings
+
+from scipy.signal import convolve
+
+
+def steer_to_harmonics_mtx(harmonics, angles=None, even_phase=True):
+    '''Compute a steering matrix
+
+    This maps a directional basis set onto the angular Fourier harmonics.
+
+    Parameters
+    ----------
+    harmonics: `array_like`
+        array specifying the angular harmonics contained in the steerable basis/filters.
+    angles: `array_like` or None
+        vector specifying the angular position of each filter (in radians). If None, defaults to
+        `pi * np.arange(numh) / numh`, where `numh = harmonics.size + np.count_nonzero(harmonics)`
+    even_phase : `bool`
+        specifies whether the harmonics are cosine or sine phase aligned about those positions.
+
+    Returns
+    -------
+    imtx : `np.array`
+        This matrix is suitable for passing to the function `steer`.
+
+    '''
+    # default parameter
+    numh = harmonics.size + np.count_nonzero(harmonics)
+    if angles is None:
+        angles = np.pi * np.arange(numh) / numh
+
+    # Compute inverse matrix, which maps to Fourier components onto
+    # steerable basis
+    imtx = np.zeros((angles.size, numh))
+    col = 0
+    for h in harmonics:
+        args = h * angles
+        if h == 0:
+            imtx[:, col] = np.ones(angles.shape)
+            col += 1
+        elif even_phase:
+            imtx[:, col] = np.cos(args)
+            imtx[:, col + 1] = np.sin(args)
+            col += 2
+        else:  # odd phase
+            imtx[:, col] = np.sin(args)
+            imtx[:, col + 1] = -1.0 * np.cos(args)
+            col += 2
+
+    r = np.linalg.matrix_rank(imtx)
+    if r < np.min(imtx.shape):
+        warnings.warn("Matrix is not full rank")
+
+    return np.linalg.pinv(imtx)
+
+
+def steer(basis, angle, harmonics=None, steermtx=None, return_weights=False, even_phase=True):
+    '''Steer BASIS to the specfied ANGLE.
+
+    Parameters
+    ----------
+    basis : `array_like`
+        array whose columns are vectorized rotated copies of a steerable function, or the responses
+        of a set of steerable filters.
+    angle : `array_like` or `int`
+        scalar or column vector the size of the basis. specifies the angle(s) (in radians) to
+        steer to
+    harmonics : `list` or None
+        a list of harmonic numbers indicating the angular harmonic content of the basis. if None
+        (default), N even or odd low frequencies, as for derivative filters
+    steermtx : `array_like` or None.
+        matrix which maps the filters onto Fourier series components (ordered [cos0 cos1 sin1 cos2
+        sin2 ... sinN]). See steer_to_harmonics_mtx function for more details. If None (default),
+        assumes cosine phase harmonic components, and filter positions at 2pi*n/N.
+    return_weights : `bool`
+        whether to return the weights or not.
+    even_phase : `bool`
+        specifies whether the harmonics are cosine or sine phase aligned about those positions.
+
+    Returns
+    -------
+    res : `np.array`
+        the resteered basis
+    steervect : `np.array`
+        the weights used to resteer the basis. only returned if `return_weights` is True
+    '''
+
+    num = basis.shape[1]
+
+    if isinstance(angle, (int, float)):
+        angle = np.array([angle])
+    else:
+        if angle.shape[0] != basis.shape[0] or angle.shape[1] != 1:
+            raise Exception("""ANGLE must be a scalar, or a column vector
+                                    the size of the basis elements""")
+
+    # If HARMONICS is not specified, assume derivatives.
+    if harmonics is None:
+        harmonics = np.arange(1 - (num % 2), num, 2)
+
+    if len(harmonics.shape) == 1 or harmonics.shape[0] == 1:
+        # reshape to column matrix
+        harmonics = harmonics.reshape(harmonics.shape[0], 1)
+    elif harmonics.shape[0] != 1 and harmonics.shape[1] != 1:
+        raise Exception('input parameter HARMONICS must be 1D!')
+
+    if 2 * harmonics.shape[0] - (harmonics == 0).sum() != num:
+        raise Exception('harmonics list is incompatible with basis size!')
+
+    # If STEERMTX not passed, assume evenly distributed cosine-phase filters:
+    if steermtx is None:
+        steermtx = steer_to_harmonics_mtx(harmonics, np.pi * np.arange(num) / num,
+                                          even_phase=even_phase)
+
+    steervect = np.zeros((angle.shape[0], num))
+    arg = angle * harmonics[np.nonzero(harmonics)[0]].T
+    if all(harmonics):
+        steervect[:, range(0, num, 2)] = np.cos(arg)
+        steervect[:, range(1, num, 2)] = np.sin(arg)
+    else:
+        steervect[:, 0] = np.ones((arg.shape[0], 1))
+        steervect[:, range(1, num, 2)] = np.cos(arg)
+        steervect[:, range(2, num, 2)] = np.sin(arg)
+
+    steervect = np.dot(steervect, steermtx)
+
+    if steervect.shape[0] > 1:
+        tmp = np.dot(basis, steervect)
+        res = sum(tmp).T
+    else:
+        res = np.dot(basis, steervect.T)
+
+    if return_weights:
+        return res, np.array(steervect).reshape(num)
+    else:
+        return res
+
+
+def convert_pyr_coeffs_to_pyr(pyr_coeffs):
+    """this function takes a 'new pyramid' and returns the coefficients as a list
+
+    this is to enable backwards compatibility
+
+    Parameters
+    ----------
+    pyr_coeffs : `dict`
+        The `pyr_coeffs` attribute of a `pyramid`.
+
+    Returns
+    -------
+    coeffs : `list`
+        list of `np.array`, which contains the pyramid coefficients in each band, in order from
+        bottom of the pyramid to top (going through the orientations in order)
+    highpass : `np.array` or None
+        either the residual highpass from the pyramid or, if that doesn't exist, None
+    lowpass : `np.array` or None
+        either the residual lowpass from the pyramid or, if that doesn't exist, None
+
+    """
+    highpass = pyr_coeffs.pop('residual_highpass', None)
+    lowpass = pyr_coeffs.pop('residual_lowpass', None)
+    coeffs = [i[1] for i in sorted(pyr_coeffs.items(), key=lambda x: x[0])]
+    return coeffs, highpass, lowpass
+
+
+def max_pyr_height(imsz, filtsz):
+    '''Compute maximum pyramid height for given image and filter sizes.
+
+    Specifically, this computes the number of corrDn operations that can be sequentially performed
+    when subsampling by a factor of 2.
+
+    Parameters
+    ----------
+    imsz : `tuple` or `int`
+        the size of the image (should be 2-tuple if image is 2d, `int` if it's 1d)
+    filtsz : `tuple` or `int`
+        the size of the filter (should be 2-tuple if image is 2d, `int` if it's 1d)
+
+    Returns
+    -------
+    max_pyr_height : `int`
+        The maximum height of the pyramid
+    '''
+    # check if inputs are one of int, tuple and have consistent type
+    assert (isinstance(imsz, int) and isinstance(filtsz, int)) or (
+            isinstance(imsz, tuple) and isinstance(filtsz, tuple))
+    # 1D image case: reduce to the integer case
+    if isinstance(imsz, tuple) and (len(imsz) == 1 or 1 in imsz):
+        imsz = functools.reduce(mul, imsz)
+        filtsz = functools.reduce(mul, filtsz)
+    # integer case
+    if isinstance(imsz, int):
+        if imsz < filtsz:
+            return 0
+        else:
+            return 1 + max_pyr_height(imsz // 2, filtsz)
+    # 2D image case
+    if isinstance(imsz, tuple):
+        if min(imsz) < max(filtsz):
+            return 0
+        else:
+            return 1 + max_pyr_height((imsz[0] // 2, imsz[1] // 2), filtsz)
+
+
+def parse_filter(filt, normalize=True):
+    """Parse the name or array like, and return a column shaped filter (which is normalized by default)
+
+    Used during pyramid construction.
+
+    Parameters
+    ----------
+    filt : `str` or `array_like`.
+        Name of the filter, as accepted by `named_filter`, or array to use as a filter. See that function for acceptable names.
+
+    Returns
+    -------
+    filt : `array` or `dict`
+        If `filt` was one of the steerable pyramids, then this will be a dictionary
+        containing the various steerable pyramid filters. Else, it will be an array containing
+        the specified filter.
+
+    See also
+    --------
+    named_filter : function that converts `filter_name` str into an array or dict of arrays.
+    """
+
+    if isinstance(filt, str):
+        filt = named_filter(filt)
+
+    elif isinstance(filt, np.ndarray) or isinstance(filt, list) or isinstance(filt, tuple):
+        filt = np.array(filt)
+        if filt.ndim == 1:
+            filt = np.reshape(filt, (filt.shape[0], 1))
+        elif filt.ndim == 2 and filt.shape[0] == 1:
+            filt = np.reshape(filt, (-1, 1))
+
+    # TODO expand normalization options
+    if normalize:
+        filt = filt / filt.sum()
+
+    return filt
+
+
+def binomial_filter(order_plus_one):
+    '''returns a vector of binomial coefficients of order (order_plus_one-1)'''
+    if order_plus_one < 2:
+        raise Exception("Error: order_plus_one argument must be at least 2")
+
+    kernel = np.array([[0.5], [0.5]])
+    for i in range(order_plus_one - 2):
+        kernel = convolve(np.array([[0.5], [0.5]]), kernel)
+    return kernel
+
+
+def named_filter(name):
+    '''Some standard 1D filter kernels.
+
+    These are returned as column vectors (shape [N, 1]) and scaled such that their L2-norm is 1.0 (except for 'binomN')
+
+    * `'binomN'` - binomial coefficient filter of order N-1
+    * `'haar'` - Haar wavelet
+    * `'qmf8'`, `'qmf12'`, `'qmf16'` - Symmetric Quadrature Mirror Filters [1]_
+    * `'daub2'`, `'daub3'`, `'daub4'` - Daubechies wavelet [2]_
+    * `'qmf5'`, `'qmf9'`, `'qmf13'`   - Symmetric Quadrature Mirror Filters [3]_, [4]_
+    * `'spN_filters'` - steerable pyramid filters of order N (N must be one of {0, 1, 3, 5}) [5]_,
+                        [6]_
+
+    References
+    ----------
+    .. [1] J D Johnston, "A filter family designed for use in quadrature mirror filter banks",
+       Proc. ICASSP, pp 291-294, 1980.
+    .. [2] I Daubechies, "Orthonormal bases of compactly supported wavelets", Commun. Pure Appl.
+       Math, vol. 42, pp 909-996, 1988.
+    .. [3] E P Simoncelli,  "Orthogonal sub-band image transforms", PhD Thesis, MIT Dept. of Elec.
+       Eng. and Comp. Sci. May 1988. Also available as: MIT Media Laboratory Vision and Modeling
+       Technical Report #100.
+    .. [4] E P Simoncelli and E H Adelson, "Subband image coding", Subband Transforms, chapter 4,
+       ed. John W Woods, Kluwer Academic Publishers,  Norwell, MA, 1990, pp 143--192.
+    .. [5] E P Simoncelli and W T Freeman, "The Steerable Pyramid: A Flexible Architecture for
+       Multi-Scale Derivative Computation," Second Int'l Conf on Image Processing, Washington, DC,
+       Oct 1995.
+    .. [6] A Karasaridis and E P Simoncelli, "A Filter Design Technique for Steerable Pyramid
+       Image Transforms", ICASSP, Atlanta, GA, May 1996.
+
+    '''
+
+    if name.startswith("binom"):
+        kernel = np.sqrt(2) * binomial_filter(int(name[5:]))
+
+    elif name.startswith('sp'):
+        kernel = steerable_filters(name)
+
+    elif name == "qmf5":
+        kernel = np.array([[-0.076103], [0.3535534], [0.8593118], [0.3535534], [-0.076103]])
+    elif name == "qmf9":
+        kernel = np.array([[0.02807382], [-0.060944743], [-0.073386624], [0.41472545], [0.7973934],
+                           [0.41472545], [-0.073386624], [-0.060944743], [0.02807382]])
+    elif name == "qmf13":
+        kernel = np.array([[-0.014556438], [0.021651438], [0.039045125], [-0.09800052],
+                           [-0.057827797], [0.42995453], [0.7737113], [0.42995453], [-0.057827797],
+                           [-0.09800052], [0.039045125], [0.021651438], [-0.014556438]])
+    elif name == "qmf8":
+        kernel = np.sqrt(2) * np.array([[0.00938715], [-0.07065183], [0.06942827], [0.4899808],
+                                        [0.4899808], [0.06942827], [-0.07065183], [0.00938715]])
+    elif name == "qmf12":
+        kernel = np.array([[-0.003809699], [0.01885659], [-0.002710326], [-0.08469594],
+                           [0.08846992], [0.4843894], [0.4843894], [0.08846992],
+                           [-0.08469594], [-0.002710326], [0.01885659], [-0.003809699]])
+        kernel *= np.sqrt(2)
+    elif name == "qmf16":
+        kernel = np.array([[0.001050167], [-0.005054526], [-0.002589756], [0.0276414],
+                           [-0.009666376], [-0.09039223], [0.09779817], [0.4810284], [0.4810284],
+                           [0.09779817], [-0.09039223], [-0.009666376], [0.0276414],
+                           [-0.002589756], [-0.005054526], [0.001050167]])
+        kernel *= np.sqrt(2)
+    elif name == "haar":
+        kernel = np.array([[1], [1]]) / np.sqrt(2)
+    elif name == "daub2":
+        kernel = np.array([[0.482962913145], [0.836516303738], [0.224143868042],
+                           [-0.129409522551]])
+    elif name == "daub3":
+        kernel = np.array([[0.332670552950], [0.806891509311], [0.459877502118], [-0.135011020010],
+                           [-0.085441273882], [0.035226291882]])
+    elif name == "daub4":
+        kernel = np.array([[0.230377813309], [0.714846570553], [0.630880767930],
+                           [-0.027983769417], [-0.187034811719], [0.030841381836],
+                           [0.032883011667], [-0.010597401785]])
+    elif name == "gauss5":  # for backward-compatibility
+        kernel = np.sqrt(2) * np.array([[0.0625], [0.25], [0.375], [0.25], [0.0625]])
+    elif name == "gauss3":  # for backward-compatibility
+        kernel = np.sqrt(2) * np.array([[0.25], [0.5], [0.25]])
+    else:
+        raise Exception("Error: Unknown filter name: %s" % (name))
+
+    return kernel
+
+
+def steerable_filters(filter_name):
+    '''Steerable pyramid filters.
+
+    Transform described in [1]_, filter kernel design described in [2]_.
+
+    References
+    ----------
+    .. [1] E P Simoncelli and W T Freeman, "The Steerable Pyramid: A Flexible Architecture for
+       Multi-Scale Derivative Computation," Second Int'l Conf on Image Processing, Washington, DC,
+       Oct 1995.
+    .. [2] A Karasaridis and E P Simoncelli, "A Filter Design Technique for Steerable Pyramid
+       Image Transforms", ICASSP, Atlanta, GA, May 1996.
+    '''
+    if filter_name == 'sp0_filters':
+        return _sp0_filters()
+    elif filter_name == 'sp1_filters':
+        return _sp1_filters()
+    elif filter_name == 'sp3_filters':
+        return _sp3_filters()
+    elif filter_name == 'sp5_filters':
+        return _sp5_filters()
+    # elif os.path.isfile(filter_name):
+    #     raise Exception("Filter files not supported yet")
+    else:
+        raise Exception("filter parameters value %s not supported" % (filter_name))
+
+
+def _sp0_filters():
+    filters = {}
+    filters['harmonics'] = np.array([0])
+    filters['lo0filt'] = (
+        np.array([[-4.514000e-04, -1.137100e-04, -3.725800e-04, -3.743860e-03,
+                   -3.725800e-04, -1.137100e-04, -4.514000e-04],
+                  [-1.137100e-04, -6.119520e-03, -1.344160e-02, -7.563200e-03,
+                   -1.344160e-02, -6.119520e-03, -1.137100e-04],
+                  [-3.725800e-04, -1.344160e-02, 6.441488e-02, 1.524935e-01,
+                   6.441488e-02, -1.344160e-02, -3.725800e-04],
+                  [-3.743860e-03, -7.563200e-03, 1.524935e-01, 3.153017e-01,
+                   1.524935e-01, -7.563200e-03, -3.743860e-03],
+                  [-3.725800e-04, -1.344160e-02, 6.441488e-02, 1.524935e-01,
+                   6.441488e-02, -1.344160e-02, -3.725800e-04],
+                  [-1.137100e-04, -6.119520e-03, -1.344160e-02, -7.563200e-03,
+                   -1.344160e-02, -6.119520e-03, -1.137100e-04],
+                  [-4.514000e-04, -1.137100e-04, -3.725800e-04, -3.743860e-03,
+                   -3.725800e-04, -1.137100e-04, -4.514000e-04]]))
+    filters['lofilt'] = (
+        np.array([[-2.257000e-04, -8.064400e-04, -5.686000e-05, 8.741400e-04,
+                   -1.862800e-04, -1.031640e-03, -1.871920e-03, -1.031640e-03,
+                   -1.862800e-04, 8.741400e-04, -5.686000e-05, -8.064400e-04,
+                   -2.257000e-04],
+                  [-8.064400e-04, 1.417620e-03, -1.903800e-04, -2.449060e-03,
+                   -4.596420e-03, -7.006740e-03, -6.948900e-03, -7.006740e-03,
+                   -4.596420e-03, -2.449060e-03, -1.903800e-04, 1.417620e-03,
+                   -8.064400e-04],
+                  [-5.686000e-05, -1.903800e-04, -3.059760e-03, -6.401000e-03,
+                   -6.720800e-03, -5.236180e-03, -3.781600e-03, -5.236180e-03,
+                   -6.720800e-03, -6.401000e-03, -3.059760e-03, -1.903800e-04,
+                   -5.686000e-05],
+                  [8.741400e-04, -2.449060e-03, -6.401000e-03, -5.260020e-03,
+                   3.938620e-03, 1.722078e-02, 2.449600e-02, 1.722078e-02,
+                   3.938620e-03, -5.260020e-03, -6.401000e-03, -2.449060e-03,
+                   8.741400e-04],
+                  [-1.862800e-04, -4.596420e-03, -6.720800e-03, 3.938620e-03,
+                   3.220744e-02, 6.306262e-02, 7.624674e-02, 6.306262e-02,
+                   3.220744e-02, 3.938620e-03, -6.720800e-03, -4.596420e-03,
+                   -1.862800e-04],
+                  [-1.031640e-03, -7.006740e-03, -5.236180e-03, 1.722078e-02,
+                   6.306262e-02, 1.116388e-01, 1.348999e-01, 1.116388e-01,
+                   6.306262e-02, 1.722078e-02, -5.236180e-03, -7.006740e-03,
+                   -1.031640e-03],
+                  [-1.871920e-03, -6.948900e-03, -3.781600e-03, 2.449600e-02,
+                   7.624674e-02, 1.348999e-01, 1.576508e-01, 1.348999e-01,
+                   7.624674e-02, 2.449600e-02, -3.781600e-03, -6.948900e-03,
+                   -1.871920e-03],
+                  [-1.031640e-03, -7.006740e-03, -5.236180e-03, 1.722078e-02,
+                   6.306262e-02, 1.116388e-01, 1.348999e-01, 1.116388e-01,
+                   6.306262e-02, 1.722078e-02, -5.236180e-03, -7.006740e-03,
+                   -1.031640e-03],
+                  [-1.862800e-04, -4.596420e-03, -6.720800e-03, 3.938620e-03,
+                   3.220744e-02, 6.306262e-02, 7.624674e-02, 6.306262e-02,
+                   3.220744e-02, 3.938620e-03, -6.720800e-03, -4.596420e-03,
+                   -1.862800e-04],
+                  [8.741400e-04, -2.449060e-03, -6.401000e-03, -5.260020e-03,
+                   3.938620e-03, 1.722078e-02, 2.449600e-02, 1.722078e-02,
+                   3.938620e-03, -5.260020e-03, -6.401000e-03, -2.449060e-03,
+                   8.741400e-04],
+                  [-5.686000e-05, -1.903800e-04, -3.059760e-03, -6.401000e-03,
+                   -6.720800e-03, -5.236180e-03, -3.781600e-03, -5.236180e-03,
+                   -6.720800e-03, -6.401000e-03, -3.059760e-03, -1.903800e-04,
+                   -5.686000e-05],
+                  [-8.064400e-04, 1.417620e-03, -1.903800e-04, -2.449060e-03,
+                   -4.596420e-03, -7.006740e-03, -6.948900e-03, -7.006740e-03,
+                   -4.596420e-03, -2.449060e-03, -1.903800e-04, 1.417620e-03,
+                   -8.064400e-04],
+                  [-2.257000e-04, -8.064400e-04, -5.686000e-05, 8.741400e-04,
+                   -1.862800e-04, -1.031640e-03, -1.871920e-03, -1.031640e-03,
+                   -1.862800e-04, 8.741400e-04, -5.686000e-05, -8.064400e-04,
+                   -2.257000e-04]]))
+    filters['mtx'] = np.array([1.000000])
+    filters['hi0filt'] = (
+        np.array([[5.997200e-04, -6.068000e-05, -3.324900e-04, -3.325600e-04,
+                   -2.406600e-04, -3.325600e-04, -3.324900e-04, -6.068000e-05,
+                   5.997200e-04],
+                  [-6.068000e-05, 1.263100e-04, 4.927100e-04, 1.459700e-04,
+                   -3.732100e-04, 1.459700e-04, 4.927100e-04, 1.263100e-04,
+                   -6.068000e-05],
+                  [-3.324900e-04, 4.927100e-04, -1.616650e-03, -1.437358e-02,
+                   -2.420138e-02, -1.437358e-02, -1.616650e-03, 4.927100e-04,
+                   -3.324900e-04],
+                  [-3.325600e-04, 1.459700e-04, -1.437358e-02, -6.300923e-02,
+                   -9.623594e-02, -6.300923e-02, -1.437358e-02, 1.459700e-04,
+                   -3.325600e-04],
+                  [-2.406600e-04, -3.732100e-04, -2.420138e-02, -9.623594e-02,
+                   8.554893e-01, -9.623594e-02, -2.420138e-02, -3.732100e-04,
+                   -2.406600e-04],
+                  [-3.325600e-04, 1.459700e-04, -1.437358e-02, -6.300923e-02,
+                   -9.623594e-02, -6.300923e-02, -1.437358e-02, 1.459700e-04,
+                   -3.325600e-04],
+                  [-3.324900e-04, 4.927100e-04, -1.616650e-03, -1.437358e-02,
+                   -2.420138e-02, -1.437358e-02, -1.616650e-03, 4.927100e-04,
+                   -3.324900e-04],
+                  [-6.068000e-05, 1.263100e-04, 4.927100e-04, 1.459700e-04,
+                   -3.732100e-04, 1.459700e-04, 4.927100e-04, 1.263100e-04,
+                   -6.068000e-05],
+                  [5.997200e-04, -6.068000e-05, -3.324900e-04, -3.325600e-04,
+                   -2.406600e-04, -3.325600e-04, -3.324900e-04, -6.068000e-05,
+                   5.997200e-04]]))
+    filters['bfilts'] = (
+        np.array([-9.066000e-05, -1.738640e-03, -4.942500e-03, -7.889390e-03,
+                  -1.009473e-02, -7.889390e-03, -4.942500e-03, -1.738640e-03,
+                  -9.066000e-05, -1.738640e-03, -4.625150e-03, -7.272540e-03,
+                  -7.623410e-03, -9.091950e-03, -7.623410e-03, -7.272540e-03,
+                  -4.625150e-03, -1.738640e-03, -4.942500e-03, -7.272540e-03,
+                  -2.129540e-02, -2.435662e-02, -3.487008e-02, -2.435662e-02,
+                  -2.129540e-02, -7.272540e-03, -4.942500e-03, -7.889390e-03,
+                  -7.623410e-03, -2.435662e-02, -1.730466e-02, -3.158605e-02,
+                  -1.730466e-02, -2.435662e-02, -7.623410e-03, -7.889390e-03,
+                  -1.009473e-02, -9.091950e-03, -3.487008e-02, -3.158605e-02,
+                  9.464195e-01, -3.158605e-02, -3.487008e-02, -9.091950e-03,
+                  -1.009473e-02, -7.889390e-03, -7.623410e-03, -2.435662e-02,
+                  -1.730466e-02, -3.158605e-02, -1.730466e-02, -2.435662e-02,
+                  -7.623410e-03, -7.889390e-03, -4.942500e-03, -7.272540e-03,
+                  -2.129540e-02, -2.435662e-02, -3.487008e-02, -2.435662e-02,
+                  -2.129540e-02, -7.272540e-03, -4.942500e-03, -1.738640e-03,
+                  -4.625150e-03, -7.272540e-03, -7.623410e-03, -9.091950e-03,
+                  -7.623410e-03, -7.272540e-03, -4.625150e-03, -1.738640e-03,
+                  -9.066000e-05, -1.738640e-03, -4.942500e-03, -7.889390e-03,
+                  -1.009473e-02, -7.889390e-03, -4.942500e-03, -1.738640e-03,
+                  -9.066000e-05]))
+    filters['bfilts'] = filters['bfilts'].reshape(len(filters['bfilts']), 1)
+    return filters
+
+
+def _sp1_filters():
+    filters = {}
+    filters['harmonics'] = np.array([1])
+    filters['mtx'] = np.eye(2)
+    filters['lo0filt'] = (
+        np.array([[-8.701000e-05, -1.354280e-03, -1.601260e-03, -5.033700e-04,
+                   2.524010e-03, -5.033700e-04, -1.601260e-03, -1.354280e-03,
+                   -8.701000e-05],
+                  [-1.354280e-03, 2.921580e-03, 7.522720e-03, 8.224420e-03,
+                   1.107620e-03, 8.224420e-03, 7.522720e-03, 2.921580e-03,
+                   -1.354280e-03],
+                  [-1.601260e-03, 7.522720e-03, -7.061290e-03, -3.769487e-02,
+                   -3.297137e-02, -3.769487e-02, -7.061290e-03, 7.522720e-03,
+                   -1.601260e-03],
+                  [-5.033700e-04, 8.224420e-03, -3.769487e-02, 4.381320e-02,
+                   1.811603e-01, 4.381320e-02, -3.769487e-02, 8.224420e-03,
+                   -5.033700e-04],
+                  [2.524010e-03, 1.107620e-03, -3.297137e-02, 1.811603e-01,
+                   4.376250e-01, 1.811603e-01, -3.297137e-02, 1.107620e-03,
+                   2.524010e-03],
+                  [-5.033700e-04, 8.224420e-03, -3.769487e-02, 4.381320e-02,
+                   1.811603e-01, 4.381320e-02, -3.769487e-02, 8.224420e-03,
+                   -5.033700e-04],
+                  [-1.601260e-03, 7.522720e-03, -7.061290e-03, -3.769487e-02,
+                   -3.297137e-02, -3.769487e-02, -7.061290e-03, 7.522720e-03,
+                   -1.601260e-03],
+                  [-1.354280e-03, 2.921580e-03, 7.522720e-03, 8.224420e-03,
+                   1.107620e-03, 8.224420e-03, 7.522720e-03, 2.921580e-03,
+                   -1.354280e-03],
+                  [-8.701000e-05, -1.354280e-03, -1.601260e-03, -5.033700e-04,
+                   2.524010e-03, -5.033700e-04, -1.601260e-03, -1.354280e-03,
+                   -8.701000e-05]]))
+    filters['lofilt'] = (
+        np.array([[-4.350000e-05, 1.207800e-04, -6.771400e-04, -1.243400e-04,
+                   -8.006400e-04, -1.597040e-03, -2.516800e-04, -4.202000e-04,
+                   1.262000e-03, -4.202000e-04, -2.516800e-04, -1.597040e-03,
+                   -8.006400e-04, -1.243400e-04, -6.771400e-04, 1.207800e-04,
+                   -4.350000e-05],
+                  [1.207800e-04, 4.460600e-04, -5.814600e-04, 5.621600e-04,
+                   -1.368800e-04, 2.325540e-03, 2.889860e-03, 4.287280e-03,
+                   5.589400e-03, 4.287280e-03, 2.889860e-03, 2.325540e-03,
+                   -1.368800e-04, 5.621600e-04, -5.814600e-04, 4.460600e-04,
+                   1.207800e-04],
+                  [-6.771400e-04, -5.814600e-04, 1.460780e-03, 2.160540e-03,
+                   3.761360e-03, 3.080980e-03, 4.112200e-03, 2.221220e-03,
+                   5.538200e-04, 2.221220e-03, 4.112200e-03, 3.080980e-03,
+                   3.761360e-03, 2.160540e-03, 1.460780e-03, -5.814600e-04,
+                   -6.771400e-04],
+                  [-1.243400e-04, 5.621600e-04, 2.160540e-03, 3.175780e-03,
+                   3.184680e-03, -1.777480e-03, -7.431700e-03, -9.056920e-03,
+                   -9.637220e-03, -9.056920e-03, -7.431700e-03, -1.777480e-03,
+                   3.184680e-03, 3.175780e-03, 2.160540e-03, 5.621600e-04,
+                   -1.243400e-04],
+                  [-8.006400e-04, -1.368800e-04, 3.761360e-03, 3.184680e-03,
+                   -3.530640e-03, -1.260420e-02, -1.884744e-02, -1.750818e-02,
+                   -1.648568e-02, -1.750818e-02, -1.884744e-02, -1.260420e-02,
+                   -3.530640e-03, 3.184680e-03, 3.761360e-03, -1.368800e-04,
+                   -8.006400e-04],
+                  [-1.597040e-03, 2.325540e-03, 3.080980e-03, -1.777480e-03,
+                   -1.260420e-02, -2.022938e-02, -1.109170e-02, 3.955660e-03,
+                   1.438512e-02, 3.955660e-03, -1.109170e-02, -2.022938e-02,
+                   -1.260420e-02, -1.777480e-03, 3.080980e-03, 2.325540e-03,
+                   -1.597040e-03],
+                  [-2.516800e-04, 2.889860e-03, 4.112200e-03, -7.431700e-03,
+                   -1.884744e-02, -1.109170e-02, 2.190660e-02, 6.806584e-02,
+                   9.058014e-02, 6.806584e-02, 2.190660e-02, -1.109170e-02,
+                   -1.884744e-02, -7.431700e-03, 4.112200e-03, 2.889860e-03,
+                   -2.516800e-04],
+                  [-4.202000e-04, 4.287280e-03, 2.221220e-03, -9.056920e-03,
+                   -1.750818e-02, 3.955660e-03, 6.806584e-02, 1.445500e-01,
+                   1.773651e-01, 1.445500e-01, 6.806584e-02, 3.955660e-03,
+                   -1.750818e-02, -9.056920e-03, 2.221220e-03, 4.287280e-03,
+                   -4.202000e-04],
+                  [1.262000e-03, 5.589400e-03, 5.538200e-04, -9.637220e-03,
+                   -1.648568e-02, 1.438512e-02, 9.058014e-02, 1.773651e-01,
+                   2.120374e-01, 1.773651e-01, 9.058014e-02, 1.438512e-02,
+                   -1.648568e-02, -9.637220e-03, 5.538200e-04, 5.589400e-03,
+                   1.262000e-03],
+                  [-4.202000e-04, 4.287280e-03, 2.221220e-03, -9.056920e-03,
+                   -1.750818e-02, 3.955660e-03, 6.806584e-02, 1.445500e-01,
+                   1.773651e-01, 1.445500e-01, 6.806584e-02, 3.955660e-03,
+                   -1.750818e-02, -9.056920e-03, 2.221220e-03, 4.287280e-03,
+                   -4.202000e-04],
+                  [-2.516800e-04, 2.889860e-03, 4.112200e-03, -7.431700e-03,
+                   -1.884744e-02, -1.109170e-02, 2.190660e-02, 6.806584e-02,
+                   9.058014e-02, 6.806584e-02, 2.190660e-02, -1.109170e-02,
+                   -1.884744e-02, -7.431700e-03, 4.112200e-03, 2.889860e-03,
+                   -2.516800e-04],
+                  [-1.597040e-03, 2.325540e-03, 3.080980e-03, -1.777480e-03,
+                   -1.260420e-02, -2.022938e-02, -1.109170e-02, 3.955660e-03,
+                   1.438512e-02, 3.955660e-03, -1.109170e-02, -2.022938e-02,
+                   -1.260420e-02, -1.777480e-03, 3.080980e-03, 2.325540e-03,
+                   -1.597040e-03],
+                  [-8.006400e-04, -1.368800e-04, 3.761360e-03, 3.184680e-03,
+                   -3.530640e-03, -1.260420e-02, -1.884744e-02, -1.750818e-02,
+                   -1.648568e-02, -1.750818e-02, -1.884744e-02, -1.260420e-02,
+                   -3.530640e-03, 3.184680e-03, 3.761360e-03, -1.368800e-04,
+                   -8.006400e-04],
+                  [-1.243400e-04, 5.621600e-04, 2.160540e-03, 3.175780e-03,
+                   3.184680e-03, -1.777480e-03, -7.431700e-03, -9.056920e-03,
+                   -9.637220e-03, -9.056920e-03, -7.431700e-03, -1.777480e-03,
+                   3.184680e-03, 3.175780e-03, 2.160540e-03, 5.621600e-04,
+                   -1.243400e-04],
+                  [-6.771400e-04, -5.814600e-04, 1.460780e-03, 2.160540e-03,
+                   3.761360e-03, 3.080980e-03, 4.112200e-03, 2.221220e-03,
+                   5.538200e-04, 2.221220e-03, 4.112200e-03, 3.080980e-03,
+                   3.761360e-03, 2.160540e-03, 1.460780e-03, -5.814600e-04,
+                   -6.771400e-04],
+                  [1.207800e-04, 4.460600e-04, -5.814600e-04, 5.621600e-04,
+                   -1.368800e-04, 2.325540e-03, 2.889860e-03, 4.287280e-03,
+                   5.589400e-03, 4.287280e-03, 2.889860e-03, 2.325540e-03,
+                   -1.368800e-04, 5.621600e-04, -5.814600e-04, 4.460600e-04,
+                   1.207800e-04],
+                  [-4.350000e-05, 1.207800e-04, -6.771400e-04, -1.243400e-04,
+                   -8.006400e-04, -1.597040e-03, -2.516800e-04, -4.202000e-04,
+                   1.262000e-03, -4.202000e-04, -2.516800e-04, -1.597040e-03,
+                   -8.006400e-04, -1.243400e-04, -6.771400e-04, 1.207800e-04,
+                   -4.350000e-05]]))
+    filters['hi0filt'] = (
+        np.array([[-9.570000e-04, -2.424100e-04, -1.424720e-03, -8.742600e-04,
+                   -1.166810e-03, -8.742600e-04, -1.424720e-03, -2.424100e-04,
+                   -9.570000e-04],
+                  [-2.424100e-04, -4.317530e-03, 8.998600e-04, 9.156420e-03,
+                   1.098012e-02, 9.156420e-03, 8.998600e-04, -4.317530e-03,
+                   -2.424100e-04],
+                  [-1.424720e-03, 8.998600e-04, 1.706347e-02, 1.094866e-02,
+                   -5.897780e-03, 1.094866e-02, 1.706347e-02, 8.998600e-04,
+                   -1.424720e-03],
+                  [-8.742600e-04, 9.156420e-03, 1.094866e-02, -7.841370e-02,
+                   -1.562827e-01, -7.841370e-02, 1.094866e-02, 9.156420e-03,
+                   -8.742600e-04],
+                  [-1.166810e-03, 1.098012e-02, -5.897780e-03, -1.562827e-01,
+                   7.282593e-01, -1.562827e-01, -5.897780e-03, 1.098012e-02,
+                   -1.166810e-03],
+                  [-8.742600e-04, 9.156420e-03, 1.094866e-02, -7.841370e-02,
+                   -1.562827e-01, -7.841370e-02, 1.094866e-02, 9.156420e-03,
+                   -8.742600e-04],
+                  [-1.424720e-03, 8.998600e-04, 1.706347e-02, 1.094866e-02,
+                   -5.897780e-03, 1.094866e-02, 1.706347e-02, 8.998600e-04,
+                   -1.424720e-03],
+                  [-2.424100e-04, -4.317530e-03, 8.998600e-04, 9.156420e-03,
+                   1.098012e-02, 9.156420e-03, 8.998600e-04, -4.317530e-03,
+                   -2.424100e-04],
+                  [-9.570000e-04, -2.424100e-04, -1.424720e-03, -8.742600e-04,
+                   -1.166810e-03, -8.742600e-04, -1.424720e-03, -2.424100e-04,
+                   -9.570000e-04]]))
+    filters['bfilts'] = (
+        np.array([[6.125880e-03, -8.052600e-03, -2.103714e-02, -1.536890e-02,
+                   -1.851466e-02, -1.536890e-02, -2.103714e-02, -8.052600e-03,
+                   6.125880e-03, -1.287416e-02, -9.611520e-03, 1.023569e-02,
+                   6.009450e-03, 1.872620e-03, 6.009450e-03, 1.023569e-02,
+                   -9.611520e-03, -1.287416e-02, -5.641530e-03, 4.168400e-03,
+                   -2.382180e-02, -5.375324e-02, -2.076086e-02, -5.375324e-02,
+                   -2.382180e-02, 4.168400e-03, -5.641530e-03, -8.957260e-03,
+                   -1.751170e-03, -1.836909e-02, 1.265655e-01, 2.996168e-01,
+                   1.265655e-01, -1.836909e-02, -1.751170e-03, -8.957260e-03,
+                   0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,
+                   0.000000e+00, 0.000000e+00, 0.000000e+00, 0.000000e+00,
+                   0.000000e+00, 8.957260e-03, 1.751170e-03, 1.836909e-02,
+                   -1.265655e-01, -2.996168e-01, -1.265655e-01, 1.836909e-02,
+                   1.751170e-03, 8.957260e-03, 5.641530e-03, -4.168400e-03,
+                   2.382180e-02, 5.375324e-02, 2.076086e-02, 5.375324e-02,
+                   2.382180e-02, -4.168400e-03, 5.641530e-03, 1.287416e-02,
+                   9.611520e-03, -1.023569e-02, -6.009450e-03, -1.872620e-03,
+                   -6.009450e-03, -1.023569e-02, 9.611520e-03, 1.287416e-02,
+                   -6.125880e-03, 8.052600e-03, 2.103714e-02, 1.536890e-02,
+                   1.851466e-02, 1.536890e-02, 2.103714e-02, 8.052600e-03,
+                   -6.125880e-03],
+                  [-6.125880e-03, 1.287416e-02, 5.641530e-03, 8.957260e-03,
+                   0.000000e+00, -8.957260e-03, -5.641530e-03, -1.287416e-02,
+                   6.125880e-03, 8.052600e-03, 9.611520e-03, -4.168400e-03,
+                   1.751170e-03, 0.000000e+00, -1.751170e-03, 4.168400e-03,
+                   -9.611520e-03, -8.052600e-03, 2.103714e-02, -1.023569e-02,
+                   2.382180e-02, 1.836909e-02, 0.000000e+00, -1.836909e-02,
+                   -2.382180e-02, 1.023569e-02, -2.103714e-02, 1.536890e-02,
+                   -6.009450e-03, 5.375324e-02, -1.265655e-01, 0.000000e+00,
+                   1.265655e-01, -5.375324e-02, 6.009450e-03, -1.536890e-02,
+                   1.851466e-02, -1.872620e-03, 2.076086e-02, -2.996168e-01,
+                   0.000000e+00, 2.996168e-01, -2.076086e-02, 1.872620e-03,
+                   -1.851466e-02, 1.536890e-02, -6.009450e-03, 5.375324e-02,
+                   -1.265655e-01, 0.000000e+00, 1.265655e-01, -5.375324e-02,
+                   6.009450e-03, -1.536890e-02, 2.103714e-02, -1.023569e-02,
+                   2.382180e-02, 1.836909e-02, 0.000000e+00, -1.836909e-02,
+                   -2.382180e-02, 1.023569e-02, -2.103714e-02, 8.052600e-03,
+                   9.611520e-03, -4.168400e-03, 1.751170e-03, 0.000000e+00,
+                   -1.751170e-03, 4.168400e-03, -9.611520e-03, -8.052600e-03,
+                   -6.125880e-03, 1.287416e-02, 5.641530e-03, 8.957260e-03,
+                   0.000000e+00, -8.957260e-03, -5.641530e-03, -1.287416e-02,
+                   6.125880e-03]]).T)
+    filters['bfilts'] = np.negative(filters['bfilts'])
+    return filters
+
+
+def _sp3_filters():
+    filters = {}
+    filters['harmonics'] = np.array([1, 3])
+    filters['mtx'] = (
+        np.array([[0.5000, 0.3536, 0, -0.3536],
+                  [-0.0000, 0.3536, 0.5000, 0.3536],
+                  [0.5000, -0.3536, 0, 0.3536],
+                  [-0.0000, 0.3536, -0.5000, 0.3536]]))
+    filters['hi0filt'] = (
+        np.array([[-4.0483998600E-4, -6.2596000498E-4, -3.7829999201E-5,
+                   8.8387000142E-4, 1.5450799838E-3, 1.9235999789E-3,
+                   2.0687500946E-3, 2.0898699295E-3, 2.0687500946E-3,
+                   1.9235999789E-3, 1.5450799838E-3, 8.8387000142E-4,
+                   -3.7829999201E-5, -6.2596000498E-4, -4.0483998600E-4],
+                  [-6.2596000498E-4, -3.2734998967E-4, 7.7435001731E-4,
+                   1.5874400269E-3, 2.1750701126E-3, 2.5626500137E-3,
+                   2.2892199922E-3, 1.9755100366E-3, 2.2892199922E-3,
+                   2.5626500137E-3, 2.1750701126E-3, 1.5874400269E-3,
+                   7.7435001731E-4, -3.2734998967E-4, -6.2596000498E-4],
+                  [-3.7829999201E-5, 7.7435001731E-4, 1.1793200392E-3,
+                   1.4050999889E-3, 2.2253401112E-3, 2.1145299543E-3,
+                   3.3578000148E-4, -8.3368999185E-4, 3.3578000148E-4,
+                   2.1145299543E-3, 2.2253401112E-3, 1.4050999889E-3,
+                   1.1793200392E-3, 7.7435001731E-4, -3.7829999201E-5],
+                  [8.8387000142E-4, 1.5874400269E-3, 1.4050999889E-3,
+                   1.2960999738E-3, -4.9274001503E-4, -3.1295299996E-3,
+                   -4.5751798898E-3, -5.1014497876E-3, -4.5751798898E-3,
+                   -3.1295299996E-3, -4.9274001503E-4, 1.2960999738E-3,
+                   1.4050999889E-3, 1.5874400269E-3, 8.8387000142E-4],
+                  [1.5450799838E-3, 2.1750701126E-3, 2.2253401112E-3,
+                   -4.9274001503E-4, -6.3222697936E-3, -2.7556000277E-3,
+                   5.3632198833E-3, 7.3032598011E-3, 5.3632198833E-3,
+                   -2.7556000277E-3, -6.3222697936E-3, -4.9274001503E-4,
+                   2.2253401112E-3, 2.1750701126E-3, 1.5450799838E-3],
+                  [1.9235999789E-3, 2.5626500137E-3, 2.1145299543E-3,
+                   -3.1295299996E-3, -2.7556000277E-3, 1.3962360099E-2,
+                   7.8046298586E-3, -9.3812197447E-3, 7.8046298586E-3,
+                   1.3962360099E-2, -2.7556000277E-3, -3.1295299996E-3,
+                   2.1145299543E-3, 2.5626500137E-3, 1.9235999789E-3],
+                  [2.0687500946E-3, 2.2892199922E-3, 3.3578000148E-4,
+                   -4.5751798898E-3, 5.3632198833E-3, 7.8046298586E-3,
+                   -7.9501636326E-2, -0.1554141641, -7.9501636326E-2,
+                   7.8046298586E-3, 5.3632198833E-3, -4.5751798898E-3,
+                   3.3578000148E-4, 2.2892199922E-3, 2.0687500946E-3],
+                  [2.0898699295E-3, 1.9755100366E-3, -8.3368999185E-4,
+                   -5.1014497876E-3, 7.3032598011E-3, -9.3812197447E-3,
+                   -0.1554141641, 0.7303866148, -0.1554141641,
+                   -9.3812197447E-3, 7.3032598011E-3, -5.1014497876E-3,
+                   -8.3368999185E-4, 1.9755100366E-3, 2.0898699295E-3],
+                  [2.0687500946E-3, 2.2892199922E-3, 3.3578000148E-4,
+                   -4.5751798898E-3, 5.3632198833E-3, 7.8046298586E-3,
+                   -7.9501636326E-2, -0.1554141641, -7.9501636326E-2,
+                   7.8046298586E-3, 5.3632198833E-3, -4.5751798898E-3,
+                   3.3578000148E-4, 2.2892199922E-3, 2.0687500946E-3],
+                  [1.9235999789E-3, 2.5626500137E-3, 2.1145299543E-3,
+                   -3.1295299996E-3, -2.7556000277E-3, 1.3962360099E-2,
+                   7.8046298586E-3, -9.3812197447E-3, 7.8046298586E-3,
+                   1.3962360099E-2, -2.7556000277E-3, -3.1295299996E-3,
+                   2.1145299543E-3, 2.5626500137E-3, 1.9235999789E-3],
+                  [1.5450799838E-3, 2.1750701126E-3, 2.2253401112E-3,
+                   -4.9274001503E-4, -6.3222697936E-3, -2.7556000277E-3,
+                   5.3632198833E-3, 7.3032598011E-3, 5.3632198833E-3,
+                   -2.7556000277E-3, -6.3222697936E-3, -4.9274001503E-4,
+                   2.2253401112E-3, 2.1750701126E-3, 1.5450799838E-3],
+                  [8.8387000142E-4, 1.5874400269E-3, 1.4050999889E-3,
+                   1.2960999738E-3, -4.9274001503E-4, -3.1295299996E-3,
+                   -4.5751798898E-3, -5.1014497876E-3, -4.5751798898E-3,
+                   -3.1295299996E-3, -4.9274001503E-4, 1.2960999738E-3,
+                   1.4050999889E-3, 1.5874400269E-3, 8.8387000142E-4],
+                  [-3.7829999201E-5, 7.7435001731E-4, 1.1793200392E-3,
+                   1.4050999889E-3, 2.2253401112E-3, 2.1145299543E-3,
+                   3.3578000148E-4, -8.3368999185E-4, 3.3578000148E-4,
+                   2.1145299543E-3, 2.2253401112E-3, 1.4050999889E-3,
+                   1.1793200392E-3, 7.7435001731E-4, -3.7829999201E-5],
+                  [-6.2596000498E-4, -3.2734998967E-4, 7.7435001731E-4,
+                   1.5874400269E-3, 2.1750701126E-3, 2.5626500137E-3,
+                   2.2892199922E-3, 1.9755100366E-3, 2.2892199922E-3,
+                   2.5626500137E-3, 2.1750701126E-3, 1.5874400269E-3,
+                   7.7435001731E-4, -3.2734998967E-4, -6.2596000498E-4],
+                  [-4.0483998600E-4, -6.2596000498E-4, -3.7829999201E-5,
+                   8.8387000142E-4, 1.5450799838E-3, 1.9235999789E-3,
+                   2.0687500946E-3, 2.0898699295E-3, 2.0687500946E-3,
+                   1.9235999789E-3, 1.5450799838E-3, 8.8387000142E-4,
+                   -3.7829999201E-5, -6.2596000498E-4, -4.0483998600E-4]]))
+    filters['lo0filt'] = (
+        np.array([[-8.7009997515E-5, -1.3542800443E-3, -1.6012600390E-3,
+                   -5.0337001448E-4, 2.5240099058E-3, -5.0337001448E-4,
+                   -1.6012600390E-3, -1.3542800443E-3, -8.7009997515E-5],
+                  [-1.3542800443E-3, 2.9215801042E-3, 7.5227199122E-3,
+                   8.2244202495E-3, 1.1076199589E-3, 8.2244202495E-3,
+                   7.5227199122E-3, 2.9215801042E-3, -1.3542800443E-3],
+                  [-1.6012600390E-3, 7.5227199122E-3, -7.0612900890E-3,
+                   -3.7694871426E-2, -3.2971370965E-2, -3.7694871426E-2,
+                   -7.0612900890E-3, 7.5227199122E-3, -1.6012600390E-3],
+                  [-5.0337001448E-4, 8.2244202495E-3, -3.7694871426E-2,
+                   4.3813198805E-2, 0.1811603010, 4.3813198805E-2,
+                   -3.7694871426E-2, 8.2244202495E-3, -5.0337001448E-4],
+                  [2.5240099058E-3, 1.1076199589E-3, -3.2971370965E-2,
+                   0.1811603010, 0.4376249909, 0.1811603010,
+                   -3.2971370965E-2, 1.1076199589E-3, 2.5240099058E-3],
+                  [-5.0337001448E-4, 8.2244202495E-3, -3.7694871426E-2,
+                   4.3813198805E-2, 0.1811603010, 4.3813198805E-2,
+                   -3.7694871426E-2, 8.2244202495E-3, -5.0337001448E-4],
+                  [-1.6012600390E-3, 7.5227199122E-3, -7.0612900890E-3,
+                   -3.7694871426E-2, -3.2971370965E-2, -3.7694871426E-2,
+                   -7.0612900890E-3, 7.5227199122E-3, -1.6012600390E-3],
+                  [-1.3542800443E-3, 2.9215801042E-3, 7.5227199122E-3,
+                   8.2244202495E-3, 1.1076199589E-3, 8.2244202495E-3,
+                   7.5227199122E-3, 2.9215801042E-3, -1.3542800443E-3],
+                  [-8.7009997515E-5, -1.3542800443E-3, -1.6012600390E-3,
+                   -5.0337001448E-4, 2.5240099058E-3, -5.0337001448E-4,
+                   -1.6012600390E-3, -1.3542800443E-3, -8.7009997515E-5]]))
+    filters['lofilt'] = (
+        np.array([[-4.3500000174E-5, 1.2078000145E-4, -6.7714002216E-4,
+                   -1.2434000382E-4, -8.0063997302E-4, -1.5970399836E-3,
+                   -2.5168000138E-4, -4.2019999819E-4, 1.2619999470E-3,
+                   -4.2019999819E-4, -2.5168000138E-4, -1.5970399836E-3,
+                   -8.0063997302E-4, -1.2434000382E-4, -6.7714002216E-4,
+                   1.2078000145E-4, -4.3500000174E-5],
+                  [1.2078000145E-4, 4.4606000301E-4, -5.8146001538E-4,
+                   5.6215998484E-4, -1.3688000035E-4, 2.3255399428E-3,
+                   2.8898599558E-3, 4.2872801423E-3, 5.5893999524E-3,
+                   4.2872801423E-3, 2.8898599558E-3, 2.3255399428E-3,
+                   -1.3688000035E-4, 5.6215998484E-4, -5.8146001538E-4,
+                   4.4606000301E-4, 1.2078000145E-4],
+                  [-6.7714002216E-4, -5.8146001538E-4, 1.4607800404E-3,
+                   2.1605400834E-3, 3.7613599561E-3, 3.0809799209E-3,
+                   4.1121998802E-3, 2.2212199401E-3, 5.5381999118E-4,
+                   2.2212199401E-3, 4.1121998802E-3, 3.0809799209E-3,
+                   3.7613599561E-3, 2.1605400834E-3, 1.4607800404E-3,
+                   -5.8146001538E-4, -6.7714002216E-4],
+                  [-1.2434000382E-4, 5.6215998484E-4, 2.1605400834E-3,
+                   3.1757799443E-3, 3.1846798956E-3, -1.7774800071E-3,
+                   -7.4316998944E-3, -9.0569201857E-3, -9.6372198313E-3,
+                   -9.0569201857E-3, -7.4316998944E-3, -1.7774800071E-3,
+                   3.1846798956E-3, 3.1757799443E-3, 2.1605400834E-3,
+                   5.6215998484E-4, -1.2434000382E-4],
+                  [-8.0063997302E-4, -1.3688000035E-4, 3.7613599561E-3,
+                   3.1846798956E-3, -3.5306399222E-3, -1.2604200281E-2,
+                   -1.8847439438E-2, -1.7508180812E-2, -1.6485679895E-2,
+                   -1.7508180812E-2, -1.8847439438E-2, -1.2604200281E-2,
+                   -3.5306399222E-3, 3.1846798956E-3, 3.7613599561E-3,
+                   -1.3688000035E-4, -8.0063997302E-4],
+                  [-1.5970399836E-3, 2.3255399428E-3, 3.0809799209E-3,
+                   -1.7774800071E-3, -1.2604200281E-2, -2.0229380578E-2,
+                   -1.1091699824E-2, 3.9556599222E-3, 1.4385120012E-2,
+                   3.9556599222E-3, -1.1091699824E-2, -2.0229380578E-2,
+                   -1.2604200281E-2, -1.7774800071E-3, 3.0809799209E-3,
+                   2.3255399428E-3, -1.5970399836E-3],
+                  [-2.5168000138E-4, 2.8898599558E-3, 4.1121998802E-3,
+                   -7.4316998944E-3, -1.8847439438E-2, -1.1091699824E-2,
+                   2.1906599402E-2, 6.8065837026E-2, 9.0580143034E-2,
+                   6.8065837026E-2, 2.1906599402E-2, -1.1091699824E-2,
+                   -1.8847439438E-2, -7.4316998944E-3, 4.1121998802E-3,
+                   2.8898599558E-3, -2.5168000138E-4],
+                  [-4.2019999819E-4, 4.2872801423E-3, 2.2212199401E-3,
+                   -9.0569201857E-3, -1.7508180812E-2, 3.9556599222E-3,
+                   6.8065837026E-2, 0.1445499808, 0.1773651242,
+                   0.1445499808, 6.8065837026E-2, 3.9556599222E-3,
+                   -1.7508180812E-2, -9.0569201857E-3, 2.2212199401E-3,
+                   4.2872801423E-3, -4.2019999819E-4],
+                  [1.2619999470E-3, 5.5893999524E-3, 5.5381999118E-4,
+                   -9.6372198313E-3, -1.6485679895E-2, 1.4385120012E-2,
+                   9.0580143034E-2, 0.1773651242, 0.2120374441,
+                   0.1773651242, 9.0580143034E-2, 1.4385120012E-2,
+                   -1.6485679895E-2, -9.6372198313E-3, 5.5381999118E-4,
+                   5.5893999524E-3, 1.2619999470E-3],
+                  [-4.2019999819E-4, 4.2872801423E-3, 2.2212199401E-3,
+                   -9.0569201857E-3, -1.7508180812E-2, 3.9556599222E-3,
+                   6.8065837026E-2, 0.1445499808, 0.1773651242,
+                   0.1445499808, 6.8065837026E-2, 3.9556599222E-3,
+                   -1.7508180812E-2, -9.0569201857E-3, 2.2212199401E-3,
+                   4.2872801423E-3, -4.2019999819E-4],
+                  [-2.5168000138E-4, 2.8898599558E-3, 4.1121998802E-3,
+                   -7.4316998944E-3, -1.8847439438E-2, -1.1091699824E-2,
+                   2.1906599402E-2, 6.8065837026E-2, 9.0580143034E-2,
+                   6.8065837026E-2, 2.1906599402E-2, -1.1091699824E-2,
+                   -1.8847439438E-2, -7.4316998944E-3, 4.1121998802E-3,
+                   2.8898599558E-3, -2.5168000138E-4],
+                  [-1.5970399836E-3, 2.3255399428E-3, 3.0809799209E-3,
+                   -1.7774800071E-3, -1.2604200281E-2, -2.0229380578E-2,
+                   -1.1091699824E-2, 3.9556599222E-3, 1.4385120012E-2,
+                   3.9556599222E-3, -1.1091699824E-2, -2.0229380578E-2,
+                   -1.2604200281E-2, -1.7774800071E-3, 3.0809799209E-3,
+                   2.3255399428E-3, -1.5970399836E-3],
+                  [-8.0063997302E-4, -1.3688000035E-4, 3.7613599561E-3,
+                   3.1846798956E-3, -3.5306399222E-3, -1.2604200281E-2,
+                   -1.8847439438E-2, -1.7508180812E-2, -1.6485679895E-2,
+                   -1.7508180812E-2, -1.8847439438E-2, -1.2604200281E-2,
+                   -3.5306399222E-3, 3.1846798956E-3, 3.7613599561E-3,
+                   -1.3688000035E-4, -8.0063997302E-4],
+                  [-1.2434000382E-4, 5.6215998484E-4, 2.1605400834E-3,
+                   3.1757799443E-3, 3.1846798956E-3, -1.7774800071E-3,
+                   -7.4316998944E-3, -9.0569201857E-3, -9.6372198313E-3,
+                   -9.0569201857E-3, -7.4316998944E-3, -1.7774800071E-3,
+                   3.1846798956E-3, 3.1757799443E-3, 2.1605400834E-3,
+                   5.6215998484E-4, -1.2434000382E-4],
+                  [-6.7714002216E-4, -5.8146001538E-4, 1.4607800404E-3,
+                   2.1605400834E-3, 3.7613599561E-3, 3.0809799209E-3,
+                   4.1121998802E-3, 2.2212199401E-3, 5.5381999118E-4,
+                   2.2212199401E-3, 4.1121998802E-3, 3.0809799209E-3,
+                   3.7613599561E-3, 2.1605400834E-3, 1.4607800404E-3,
+                   -5.8146001538E-4, -6.7714002216E-4],
+                  [1.2078000145E-4, 4.4606000301E-4, -5.8146001538E-4,
+                   5.6215998484E-4, -1.3688000035E-4, 2.3255399428E-3,
+                   2.8898599558E-3, 4.2872801423E-3, 5.5893999524E-3,
+                   4.2872801423E-3, 2.8898599558E-3, 2.3255399428E-3,
+                   -1.3688000035E-4, 5.6215998484E-4, -5.8146001538E-4,
+                   4.4606000301E-4, 1.2078000145E-4],
+                  [-4.3500000174E-5, 1.2078000145E-4, -6.7714002216E-4,
+                   -1.2434000382E-4, -8.0063997302E-4, -1.5970399836E-3,
+                   -2.5168000138E-4, -4.2019999819E-4, 1.2619999470E-3,
+                   -4.2019999819E-4, -2.5168000138E-4, -1.5970399836E-3,
+                   -8.0063997302E-4, -1.2434000382E-4, -6.7714002216E-4,
+                   1.2078000145E-4, -4.3500000174E-5]]))
+    filters['bfilts'] = (
+        np.array([[-8.1125000725E-4, 4.4451598078E-3, 1.2316980399E-2,
+                   1.3955879956E-2, 1.4179450460E-2, 1.3955879956E-2,
+                   1.2316980399E-2, 4.4451598078E-3, -8.1125000725E-4,
+                   3.9103501476E-3, 4.4565401040E-3, -5.8724298142E-3,
+                   -2.8760801069E-3, 8.5267601535E-3, -2.8760801069E-3,
+                   -5.8724298142E-3, 4.4565401040E-3, 3.9103501476E-3,
+                   1.3462699717E-3, -3.7740699481E-3, 8.2581602037E-3,
+                   3.9442278445E-2, 5.3605638444E-2, 3.9442278445E-2,
+                   8.2581602037E-3, -3.7740699481E-3, 1.3462699717E-3,
+                   7.4700999539E-4, -3.6522001028E-4, -2.2522680461E-2,
+                   -0.1105690673, -0.1768419296, -0.1105690673,
+                   -2.2522680461E-2, -3.6522001028E-4, 7.4700999539E-4,
+                   0.0000000000, 0.0000000000, 0.0000000000,
+                   0.0000000000, 0.0000000000, 0.0000000000,
+                   0.0000000000, 0.0000000000, 0.0000000000,
+                   -7.4700999539E-4, 3.6522001028E-4, 2.2522680461E-2,
+                   0.1105690673, 0.1768419296, 0.1105690673,
+                   2.2522680461E-2, 3.6522001028E-4, -7.4700999539E-4,
+                   -1.3462699717E-3, 3.7740699481E-3, -8.2581602037E-3,
+                   -3.9442278445E-2, -5.3605638444E-2, -3.9442278445E-2,
+                   -8.2581602037E-3, 3.7740699481E-3, -1.3462699717E-3,
+                   -3.9103501476E-3, -4.4565401040E-3, 5.8724298142E-3,
+                   2.8760801069E-3, -8.5267601535E-3, 2.8760801069E-3,
+                   5.8724298142E-3, -4.4565401040E-3, -3.9103501476E-3,
+                   8.1125000725E-4, -4.4451598078E-3, -1.2316980399E-2,
+                   -1.3955879956E-2, -1.4179450460E-2, -1.3955879956E-2,
+                   -1.2316980399E-2, -4.4451598078E-3, 8.1125000725E-4],
+                  [0.0000000000, -8.2846998703E-4, -5.7109999034E-5,
+                   4.0110000555E-5, 4.6670897864E-3, 8.0871898681E-3,
+                   1.4807609841E-2, 8.6204400286E-3, -3.1221499667E-3,
+                   8.2846998703E-4, 0.0000000000, -9.7479997203E-4,
+                   -6.9718998857E-3, -2.0865600090E-3, 2.3298799060E-3,
+                   -4.4814897701E-3, 1.4917500317E-2, 8.6204400286E-3,
+                   5.7109999034E-5, 9.7479997203E-4, 0.0000000000,
+                   -1.2145539746E-2, -2.4427289143E-2, 5.0797060132E-2,
+                   3.2785870135E-2, -4.4814897701E-3, 1.4807609841E-2,
+                   -4.0110000555E-5, 6.9718998857E-3, 1.2145539746E-2,
+                   0.0000000000, -0.1510555595, -8.2495503128E-2,
+                   5.0797060132E-2, 2.3298799060E-3, 8.0871898681E-3,
+                   -4.6670897864E-3, 2.0865600090E-3, 2.4427289143E-2,
+                   0.1510555595, 0.0000000000, -0.1510555595,
+                   -2.4427289143E-2, -2.0865600090E-3, 4.6670897864E-3,
+                   -8.0871898681E-3, -2.3298799060E-3, -5.0797060132E-2,
+                   8.2495503128E-2, 0.1510555595, 0.0000000000,
+                   -1.2145539746E-2, -6.9718998857E-3, 4.0110000555E-5,
+                   -1.4807609841E-2, 4.4814897701E-3, -3.2785870135E-2,
+                   -5.0797060132E-2, 2.4427289143E-2, 1.2145539746E-2,
+                   0.0000000000, -9.7479997203E-4, -5.7109999034E-5,
+                   -8.6204400286E-3, -1.4917500317E-2, 4.4814897701E-3,
+                   -2.3298799060E-3, 2.0865600090E-3, 6.9718998857E-3,
+                   9.7479997203E-4, 0.0000000000, -8.2846998703E-4,
+                   3.1221499667E-3, -8.6204400286E-3, -1.4807609841E-2,
+                   -8.0871898681E-3, -4.6670897864E-3, -4.0110000555E-5,
+                   5.7109999034E-5, 8.2846998703E-4, 0.0000000000],
+                  [8.1125000725E-4, -3.9103501476E-3, -1.3462699717E-3,
+                   -7.4700999539E-4, 0.0000000000, 7.4700999539E-4,
+                   1.3462699717E-3, 3.9103501476E-3, -8.1125000725E-4,
+                   -4.4451598078E-3, -4.4565401040E-3, 3.7740699481E-3,
+                   3.6522001028E-4, 0.0000000000, -3.6522001028E-4,
+                   -3.7740699481E-3, 4.4565401040E-3, 4.4451598078E-3,
+                   -1.2316980399E-2, 5.8724298142E-3, -8.2581602037E-3,
+                   2.2522680461E-2, 0.0000000000, -2.2522680461E-2,
+                   8.2581602037E-3, -5.8724298142E-3, 1.2316980399E-2,
+                   -1.3955879956E-2, 2.8760801069E-3, -3.9442278445E-2,
+                   0.1105690673, 0.0000000000, -0.1105690673,
+                   3.9442278445E-2, -2.8760801069E-3, 1.3955879956E-2,
+                   -1.4179450460E-2, -8.5267601535E-3, -5.3605638444E-2,
+                   0.1768419296, 0.0000000000, -0.1768419296,
+                   5.3605638444E-2, 8.5267601535E-3, 1.4179450460E-2,
+                   -1.3955879956E-2, 2.8760801069E-3, -3.9442278445E-2,
+                   0.1105690673, 0.0000000000, -0.1105690673,
+                   3.9442278445E-2, -2.8760801069E-3, 1.3955879956E-2,
+                   -1.2316980399E-2, 5.8724298142E-3, -8.2581602037E-3,
+                   2.2522680461E-2, 0.0000000000, -2.2522680461E-2,
+                   8.2581602037E-3, -5.8724298142E-3, 1.2316980399E-2,
+                   -4.4451598078E-3, -4.4565401040E-3, 3.7740699481E-3,
+                   3.6522001028E-4, 0.0000000000, -3.6522001028E-4,
+                   -3.7740699481E-3, 4.4565401040E-3, 4.4451598078E-3,
+                   8.1125000725E-4, -3.9103501476E-3, -1.3462699717E-3,
+                   -7.4700999539E-4, 0.0000000000, 7.4700999539E-4,
+                   1.3462699717E-3, 3.9103501476E-3, -8.1125000725E-4],
+                  [3.1221499667E-3, -8.6204400286E-3, -1.4807609841E-2,
+                   -8.0871898681E-3, -4.6670897864E-3, -4.0110000555E-5,
+                   5.7109999034E-5, 8.2846998703E-4, 0.0000000000,
+                   -8.6204400286E-3, -1.4917500317E-2, 4.4814897701E-3,
+                   -2.3298799060E-3, 2.0865600090E-3, 6.9718998857E-3,
+                   9.7479997203E-4, -0.0000000000, -8.2846998703E-4,
+                   -1.4807609841E-2, 4.4814897701E-3, -3.2785870135E-2,
+                   -5.0797060132E-2, 2.4427289143E-2, 1.2145539746E-2,
+                   0.0000000000, -9.7479997203E-4, -5.7109999034E-5,
+                   -8.0871898681E-3, -2.3298799060E-3, -5.0797060132E-2,
+                   8.2495503128E-2, 0.1510555595, -0.0000000000,
+                   -1.2145539746E-2, -6.9718998857E-3, 4.0110000555E-5,
+                   -4.6670897864E-3, 2.0865600090E-3, 2.4427289143E-2,
+                   0.1510555595, 0.0000000000, -0.1510555595,
+                   -2.4427289143E-2, -2.0865600090E-3, 4.6670897864E-3,
+                   -4.0110000555E-5, 6.9718998857E-3, 1.2145539746E-2,
+                   0.0000000000, -0.1510555595, -8.2495503128E-2,
+                   5.0797060132E-2, 2.3298799060E-3, 8.0871898681E-3,
+                   5.7109999034E-5, 9.7479997203E-4, -0.0000000000,
+                   -1.2145539746E-2, -2.4427289143E-2, 5.0797060132E-2,
+                   3.2785870135E-2, -4.4814897701E-3, 1.4807609841E-2,
+                   8.2846998703E-4, -0.0000000000, -9.7479997203E-4,
+                   -6.9718998857E-3, -2.0865600090E-3, 2.3298799060E-3,
+                   -4.4814897701E-3, 1.4917500317E-2, 8.6204400286E-3,
+                   0.0000000000, -8.2846998703E-4, -5.7109999034E-5,
+                   4.0110000555E-5, 4.6670897864E-3, 8.0871898681E-3,
+                   1.4807609841E-2, 8.6204400286E-3, -3.1221499667E-3]]).T)
+    return filters
+
+
+def _sp5_filters():
+    filters = {}
+    filters['harmonics'] = np.array([1, 3, 5])
+    filters['mtx'] = (
+        np.array([[0.3333, 0.2887, 0.1667, 0.0000, -0.1667, -0.2887],
+                  [0.0000, 0.1667, 0.2887, 0.3333, 0.2887, 0.1667],
+                  [0.3333, -0.0000, -0.3333, -0.0000, 0.3333, -0.0000],
+                  [0.0000, 0.3333, 0.0000, -0.3333, 0.0000, 0.3333],
+                  [0.3333, -0.2887, 0.1667, -0.0000, -0.1667, 0.2887],
+                  [-0.0000, 0.1667, -0.2887, 0.3333, -0.2887, 0.1667]]))
+    filters['hi0filt'] = (
+        np.array([[-0.00033429, -0.00113093, -0.00171484,
+                   -0.00133542, -0.00080639, -0.00133542,
+                   -0.00171484, -0.00113093, -0.00033429],
+                  [-0.00113093, -0.00350017, -0.00243812,
+                   0.00631653, 0.01261227, 0.00631653,
+                   -0.00243812, -0.00350017, -0.00113093],
+                  [-0.00171484, -0.00243812, -0.00290081,
+                   -0.00673482, -0.00981051, -0.00673482,
+                   -0.00290081, -0.00243812, -0.00171484],
+                  [-0.00133542, 0.00631653, -0.00673482,
+                   -0.07027679, -0.11435863, -0.07027679,
+                   -0.00673482, 0.00631653, -0.00133542],
+                  [-0.00080639, 0.01261227, -0.00981051,
+                   -0.11435863, 0.81380200, -0.11435863,
+                   -0.00981051, 0.01261227, -0.00080639],
+                  [-0.00133542, 0.00631653, -0.00673482,
+                   -0.07027679, -0.11435863, -0.07027679,
+                   -0.00673482, 0.00631653, -0.00133542],
+                  [-0.00171484, -0.00243812, -0.00290081,
+                   -0.00673482, -0.00981051, -0.00673482,
+                   -0.00290081, -0.00243812, -0.00171484],
+                  [-0.00113093, -0.00350017, -0.00243812,
+                   0.00631653, 0.01261227, 0.00631653,
+                   -0.00243812, -0.00350017, -0.00113093],
+                  [-0.00033429, -0.00113093, -0.00171484,
+                   -0.00133542, -0.00080639, -0.00133542,
+                   -0.00171484, -0.00113093, -0.00033429]]))
+    filters['lo0filt'] = (
+        np.array([[0.00341614, -0.01551246, -0.03848215, -0.01551246,
+                   0.00341614],
+                  [-0.01551246, 0.05586982, 0.15925570, 0.05586982,
+                   -0.01551246],
+                  [-0.03848215, 0.15925570, 0.40304148, 0.15925570,
+                   -0.03848215],
+                  [-0.01551246, 0.05586982, 0.15925570, 0.05586982,
+                   -0.01551246],
+                  [0.00341614, -0.01551246, -0.03848215, -0.01551246,
+                   0.00341614]]))
+    filters['lofilt'] = (
+            2 * np.array([[0.00085404, -0.00244917, -0.00387812, -0.00944432,
+                           -0.00962054, -0.00944432, -0.00387812, -0.00244917,
+                           0.00085404],
+                          [-0.00244917, -0.00523281, -0.00661117, 0.00410600,
+                           0.01002988, 0.00410600, -0.00661117, -0.00523281,
+                           -0.00244917],
+                          [-0.00387812, -0.00661117, 0.01396746, 0.03277038,
+                           0.03981393, 0.03277038, 0.01396746, -0.00661117,
+                           -0.00387812],
+                          [-0.00944432, 0.00410600, 0.03277038, 0.06426333,
+                           0.08169618, 0.06426333, 0.03277038, 0.00410600,
+                           -0.00944432],
+                          [-0.00962054, 0.01002988, 0.03981393, 0.08169618,
+                           0.10096540, 0.08169618, 0.03981393, 0.01002988,
+                           -0.00962054],
+                          [-0.00944432, 0.00410600, 0.03277038, 0.06426333,
+                           0.08169618, 0.06426333, 0.03277038, 0.00410600,
+                           -0.00944432],
+                          [-0.00387812, -0.00661117, 0.01396746, 0.03277038,
+                           0.03981393, 0.03277038, 0.01396746, -0.00661117,
+                           -0.00387812],
+                          [-0.00244917, -0.00523281, -0.00661117, 0.00410600,
+                           0.01002988, 0.00410600, -0.00661117, -0.00523281,
+                           -0.00244917],
+                          [0.00085404, -0.00244917, -0.00387812, -0.00944432,
+                           -0.00962054, -0.00944432, -0.00387812, -0.00244917,
+                           0.00085404]]))
+    filters['bfilts'] = (
+        np.array([[0.00277643, 0.00496194, 0.01026699, 0.01455399, 0.01026699,
+                   0.00496194, 0.00277643, -0.00986904, -0.00893064,
+                   0.01189859, 0.02755155, 0.01189859, -0.00893064,
+                   -0.00986904, -0.01021852, -0.03075356, -0.08226445,
+                   -0.11732297, -0.08226445, -0.03075356, -0.01021852,
+                   0.00000000, 0.00000000, 0.00000000, 0.00000000, 0.00000000,
+                   0.00000000, 0.00000000, 0.01021852, 0.03075356, 0.08226445,
+                   0.11732297, 0.08226445, 0.03075356, 0.01021852, 0.00986904,
+                   0.00893064, -0.01189859, -0.02755155, -0.01189859,
+                   0.00893064, 0.00986904, -0.00277643, -0.00496194,
+                   -0.01026699, -0.01455399, -0.01026699, -0.00496194,
+                   -0.00277643],
+                  [-0.00343249, -0.00640815, -0.00073141, 0.01124321,
+                   0.00182078, 0.00285723, 0.01166982, -0.00358461,
+                   -0.01977507, -0.04084211, -0.00228219, 0.03930573,
+                   0.01161195, 0.00128000, 0.01047717, 0.01486305,
+                   -0.04819057, -0.12227230, -0.05394139, 0.00853965,
+                   -0.00459034, 0.00790407, 0.04435647, 0.09454202,
+                   -0.00000000, -0.09454202, -0.04435647, -0.00790407,
+                   0.00459034, -0.00853965, 0.05394139, 0.12227230,
+                   0.04819057, -0.01486305, -0.01047717, -0.00128000,
+                   -0.01161195, -0.03930573, 0.00228219, 0.04084211,
+                   0.01977507, 0.00358461, -0.01166982, -0.00285723,
+                   -0.00182078, -0.01124321, 0.00073141, 0.00640815,
+                   0.00343249],
+                  [0.00343249, 0.00358461, -0.01047717, -0.00790407,
+                   -0.00459034, 0.00128000, 0.01166982, 0.00640815,
+                   0.01977507, -0.01486305, -0.04435647, 0.00853965,
+                   0.01161195, 0.00285723, 0.00073141, 0.04084211, 0.04819057,
+                   -0.09454202, -0.05394139, 0.03930573, 0.00182078,
+                   -0.01124321, 0.00228219, 0.12227230, -0.00000000,
+                   -0.12227230, -0.00228219, 0.01124321, -0.00182078,
+                   -0.03930573, 0.05394139, 0.09454202, -0.04819057,
+                   -0.04084211, -0.00073141, -0.00285723, -0.01161195,
+                   -0.00853965, 0.04435647, 0.01486305, -0.01977507,
+                   -0.00640815, -0.01166982, -0.00128000, 0.00459034,
+                   0.00790407, 0.01047717, -0.00358461, -0.00343249],
+                  [-0.00277643, 0.00986904, 0.01021852, -0.00000000,
+                   -0.01021852, -0.00986904, 0.00277643, -0.00496194,
+                   0.00893064, 0.03075356, -0.00000000, -0.03075356,
+                   -0.00893064, 0.00496194, -0.01026699, -0.01189859,
+                   0.08226445, -0.00000000, -0.08226445, 0.01189859,
+                   0.01026699, -0.01455399, -0.02755155, 0.11732297,
+                   -0.00000000, -0.11732297, 0.02755155, 0.01455399,
+                   -0.01026699, -0.01189859, 0.08226445, -0.00000000,
+                   -0.08226445, 0.01189859, 0.01026699, -0.00496194,
+                   0.00893064, 0.03075356, -0.00000000, -0.03075356,
+                   -0.00893064, 0.00496194, -0.00277643, 0.00986904,
+                   0.01021852, -0.00000000, -0.01021852, -0.00986904,
+                   0.00277643],
+                  [-0.01166982, -0.00128000, 0.00459034, 0.00790407,
+                   0.01047717, -0.00358461, -0.00343249, -0.00285723,
+                   -0.01161195, -0.00853965, 0.04435647, 0.01486305,
+                   -0.01977507, -0.00640815, -0.00182078, -0.03930573,
+                   0.05394139, 0.09454202, -0.04819057, -0.04084211,
+                   -0.00073141, -0.01124321, 0.00228219, 0.12227230,
+                   -0.00000000, -0.12227230, -0.00228219, 0.01124321,
+                   0.00073141, 0.04084211, 0.04819057, -0.09454202,
+                   -0.05394139, 0.03930573, 0.00182078, 0.00640815,
+                   0.01977507, -0.01486305, -0.04435647, 0.00853965,
+                   0.01161195, 0.00285723, 0.00343249, 0.00358461,
+                   -0.01047717, -0.00790407, -0.00459034, 0.00128000,
+                   0.01166982],
+                  [-0.01166982, -0.00285723, -0.00182078, -0.01124321,
+                   0.00073141, 0.00640815, 0.00343249, -0.00128000,
+                   -0.01161195, -0.03930573, 0.00228219, 0.04084211,
+                   0.01977507, 0.00358461, 0.00459034, -0.00853965,
+                   0.05394139, 0.12227230, 0.04819057, -0.01486305,
+                   -0.01047717, 0.00790407, 0.04435647, 0.09454202,
+                   -0.00000000, -0.09454202, -0.04435647, -0.00790407,
+                   0.01047717, 0.01486305, -0.04819057, -0.12227230,
+                   -0.05394139, 0.00853965, -0.00459034, -0.00358461,
+                   -0.01977507, -0.04084211, -0.00228219, 0.03930573,
+                   0.01161195, 0.00128000, -0.00343249, -0.00640815,
+                   -0.00073141, 0.01124321, 0.00182078, 0.00285723,
+                   0.01166982]]).T)
+    return filters
+
+
+class Pyramid:
+    """Base class for multiscale pyramids
+
+    You should not instantiate this base class, it is instead inherited by the other classes found
+    in this module.
+
+    Parameters
+    ----------
+    image : `array_like`
+        1d or 2d image upon which to construct to the pyramid.
+    edge_type : {'circular', 'reflect1', 'reflect2', 'repeat', 'zero', 'extend', 'dont-compute'}
+        Specifies how to handle edges. Options are:
+
+        * `'circular'` - circular convolution
+        * `'reflect1'` - reflect about the edge pixels
+        * `'reflect2'` - reflect, doubling the edge pixels
+        * `'repeat'` - repeat the edge pixels
+        * `'zero'` - assume values of zero outside image boundary
+        * `'extend'` - reflect and invert
+        * `'dont-compute'` - zero output when filter overhangs imput boundaries.
+
+    Attributes
+    ----------
+    image : `array_like`
+        The input image used to construct the pyramid.
+    image_size : `tuple`
+        The size of the input image.
+    pyr_type : `str` or `None`
+        Human-readable string specifying the type of pyramid. For base class, is None.
+    edge_type : `str`
+        Specifies how edges were handled.
+    pyr_coeffs : `dict`
+        Dictionary containing the coefficients of the pyramid. Keys are `(level, band)` tuples and
+        values are 1d or 2d numpy arrays (same number of dimensions as the input image)
+    pyr_size : `dict`
+        Dictionary containing the sizes of the pyramid coefficients. Keys are `(level, band)`
+        tuples and values are tuples.
+    is_complex : `bool`
+        Whether the coefficients are complex- or real-valued. Only `SteerablePyramidFreq` can have
+        a value of True, all others must be False.
+    """
+
+    def __init__(self, image, edge_type):
+
+        self.image = np.array(image).astype(np.float)
+        if self.image.ndim == 1:
+            self.image = self.image.reshape(-1, 1)
+        assert self.image.ndim == 2, "Error: Input signal must be 1D or 2D."
+
+        self.image_size = self.image.shape
+        if not hasattr(self, 'pyr_type'):
+            self.pyr_type = None
+        self.edge_type = edge_type
+        self.pyr_coeffs = {}
+        self.pyr_size = {}
+        self.is_complex = False
+
+    def _set_num_scales(self, filter_name, height, extra_height=0):
+        """Figure out the number of scales (height) of the pyramid
+
+        The user should not call this directly. This is called during construction of a pyramid,
+        and is based on the size of the filters (thus, should be called after instantiating the
+        filters) and the input image, as well as the `extra_height` parameter (which corresponds to
+        the residuals, which the Gaussian pyramid contains and others do not).
+
+        This sets `self.num_scales` directly instead of returning something, so be careful.
+
+        Parameters
+        ----------
+        filter_name : `str`
+            Name of the filter in the `filters` dict that determines the height of the pyramid
+        height : `'auto'` or `int`
+            During construction, user can specify the number of scales (height) of the pyramid.
+            The pyramid will have this number of scales unless that's greater than the maximum
+            possible height.
+        extra_height : `int`, optional
+            The automatically calculated maximum number of scales is based on the size of the input
+            image and filter size. The Gaussian pyramid also contains the final residuals and so we
+            need to add one more to this number.
+
+        Returns
+        -------
+        None
+        """
+        # the Gaussian and Laplacian pyramids can go one higher than the value returned here, so we
+        # use the extra_height argument to allow for that
+        max_ht = max_pyr_height(self.image.shape, self.filters[filter_name].shape) + extra_height
+        if height == 'auto':
+            self.num_scales = max_ht
+        elif height > max_ht:
+            raise Exception("Cannot build pyramid higher than %d levels." % (max_ht))
+        else:
+            self.num_scales = int(height)
+
+    def _recon_levels_check(self, levels):
+        """Check whether levels arg is valid for reconstruction and return valid version
+
+        When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies
+        which levels to include. This makes sure those levels are valid and gets them in the form
+        we expect for the rest of the reconstruction. If the user passes `'all'`, this constructs
+        the appropriate list (based on the values of `self.pyr_coeffs`).
+
+        Parameters
+        ----------
+        levels : `list`, `int`,  or {`'all'`, `'residual_highpass'`, or `'residual_lowpass'`}
+            If `list` should contain some subset of integers from `0` to `self.num_scales-1`
+            (inclusive) and `'residual_highpass'` and `'residual_lowpass'` (if appropriate for the
+            pyramid). If `'all'`, returned value will contain all valid levels. Otherwise, must be
+            one of the valid levels.
+
+        Returns
+        -------
+        levels : `list`
+            List containing the valid levels for reconstruction.
+
+        """
+        if isinstance(levels, str) and levels == 'all':
+            levels = ['residual_highpass'] + list(range(self.num_scales)) + ['residual_lowpass']
+        else:
+            if not hasattr(levels, '__iter__') or isinstance(levels, str):
+                # then it's a single int or string
+                levels = [levels]
+            levs_nums = np.array([int(i) for i in levels if isinstance(i, int) or i.isdigit()])
+            assert (levs_nums >= 0).all(), "Level numbers must be non-negative."
+            assert (levs_nums < self.num_scales).all(), "Level numbers must be in the range [0, %d]" % (
+                        self.num_scales - 1)
+            levs_tmp = list(np.sort(levs_nums))  # we want smallest first
+            if 'residual_highpass' in levels:
+                levs_tmp = ['residual_highpass'] + levs_tmp
+            if 'residual_lowpass' in levels:
+                levs_tmp = levs_tmp + ['residual_lowpass']
+            levels = levs_tmp
+        # not all pyramids have residual highpass / lowpass, but it's easier to construct the list
+        # including them, then remove them if necessary.
+        if 'residual_lowpass' not in self.pyr_coeffs.keys() and 'residual_lowpass' in levels:
+            levels.pop(-1)
+        if 'residual_highpass' not in self.pyr_coeffs.keys() and 'residual_highpass' in levels:
+            levels.pop(0)
+        return levels
+
+    def _recon_bands_check(self, bands):
+        """Check whether bands arg is valid for reconstruction and return valid version
+
+        When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies
+        which orientations to include. This makes sure those orientations are valid and gets them
+        in the form we expect for the rest of the reconstruction. If the user passes `'all'`, this
+        constructs the appropriate list (based on the values of `self.pyr_coeffs`).
+
+        Parameters
+        ----------
+        bands : `list`, `int`, or `'all'`.
+            If list, should contain some subset of integers from `0` to `self.num_orientations-1`.
+            If `'all'`, returned value will contain all valid orientations. Otherwise, must be one
+            of the valid orientations.
+
+        Returns
+        -------
+        bands: `list`
+            List containing the valid orientations for reconstruction.
+        """
+        if isinstance(bands, str) and bands == "all":
+            bands = np.arange(self.num_orientations)
+        else:
+            bands = np.array(bands, ndmin=1)
+            assert (bands >= 0).all(), "Error: band numbers must be larger than 0."
+            assert (bands < self.num_orientations).all(), "Error: band numbers must be in the range [0, %d]" % (
+                        self.num_orientations - 1)
+        return bands
+
+    def _recon_keys(self, levels, bands, max_orientations=None):
+        """Make a list of all the relevant keys from `pyr_coeffs` to use in pyramid reconstruction
+
+        When reconstructing the input image (i.e., when calling `recon_pyr()`), the user specifies
+        some subset of the pyramid coefficients to include in the reconstruction. This function
+        takes in those specifications, checks that they're valid, and returns a list of tuples
+        that are keys into the `pyr_coeffs` dictionary.
+
+        Parameters
+        ----------
+        levels : `list`, `int`,  or {`'all'`, `'residual_highpass'`, `'residual_lowpass'`}
+            If `list` should contain some subset of integers from `0` to `self.num_scales-1`
+            (inclusive) and `'residual_highpass'` and `'residual_lowpass'` (if appropriate for the
+            pyramid). If `'all'`, returned value will contain all valid levels. Otherwise, must be
+            one of the valid levels.
+        bands : `list`, `int`, or `'all'`.
+            If list, should contain some subset of integers from `0` to `self.num_orientations-1`.
+            If `'all'`, returned value will contain all valid orientations. Otherwise, must be one
+            of the valid orientations.
+        max_orientations: `None` or `int`.
+            The maximum number of orientations we allow in the reconstruction. when we determine
+            which ints are allowed for bands, we ignore all those greater than max_orientations.
+
+        Returns
+        -------
+        recon_keys : `list`
+            List of `tuples`, all of which are keys in `pyr_coeffs`. These are the coefficients to
+            include in the reconstruction of the image.
+
+        """
+        levels = self._recon_levels_check(levels)
+        bands = self._recon_bands_check(bands)
+        if max_orientations is not None:
+            for i in bands:
+                if i >= max_orientations:
+                    warnings.warn(("You wanted band %d in the reconstruction but max_orientation"
+                                   " is %d, so we're ignoring that band" % (i, max_orientations)))
+            bands = [i for i in bands if i < max_orientations]
+        recon_keys = []
+        for level in levels:
+            # residual highpass and lowpass
+            if isinstance(level, str):
+                recon_keys.append(level)
+            # else we have to get each of the (specified) bands at
+            # that level
+            else:
+                recon_keys.extend([(level, band) for band in bands])
+        return recon_keys
+
+
+class SteerablePyramidBase(Pyramid):
+    """base class for steerable pyramid
+
+    should not be called directly, we just use it so we can make both SteerablePyramidFreq and
+    SteerablePyramidSpace inherit the steer_coeffs function
+
+    """
+
+    def __init__(self, image, edge_type):
+        super().__init__(image=image, edge_type=edge_type)
+
+    def steer_coeffs(self, angles, even_phase=True):
+        """Steer pyramid coefficients to the specified angles
+
+        This allows you to have filters that have the Gaussian derivative order specified in
+        construction, but arbitrary angles or number of orientations.
+
+        Parameters
+        ----------
+        angles : `list`
+            list of angles (in radians) to steer the pyramid coefficients to
+        even_phase : `bool`
+            specifies whether the harmonics are cosine or sine phase aligned about those positions.
+
+        Returns
+        -------
+        resteered_coeffs : `dict`
+            dictionary of re-steered pyramid coefficients. will have the same number of scales as
+            the original pyramid (though it will not contain the residual highpass or lowpass).
+            like `self.pyr_coeffs`, keys are 2-tuples of ints indexing the scale and orientation,
+            but now we're indexing `angles` instead of `self.num_orientations`.
+        resteering_weights : `dict`
+            dictionary of weights used to re-steer the pyramid coefficients. will have the same
+            keys as `resteered_coeffs`.
+
+        """
+        resteered_coeffs = {}
+        resteering_weights = {}
+        for i in range(self.num_scales):
+            basis = np.vstack([self.pyr_coeffs[(i, j)].flatten() for j in
+                               range(self.num_orientations)]).T
+            for j, a in enumerate(angles):
+                res, steervect = steer(basis, a, return_weights=True, even_phase=even_phase)
+                resteered_coeffs[(i, j)] = res.reshape(self.pyr_coeffs[(i, 0)].shape)
+                resteering_weights[(i, j)] = steervect
+
+        return resteered_coeffs, resteering_weights
+
+
+class SteerablePyramidSpace(SteerablePyramidBase):
+    """Steerable pyramid (using spatial convolutions)
+
+    Notes
+    -----
+    Transform described in [1]_, filter kernel design described in [2]_.
+
+    Parameters
+    ----------
+    image : `array_like`
+        2d image upon which to construct to the pyramid.
+    height : 'auto' or `int`.
+        The height of the pyramid. If 'auto', will automatically determine based on the size of
+        `image`.
+    order : {0, 1, 3, 5}.
+        The Gaussian derivative order used for the steerable filters. If you want a different
+        value, see SteerablePyramidFreq. Note that to achieve steerability the minimum number
+        of orientation is `order` + 1, and is used here. To get more orientations at the same
+        order, use the method `steer_coeffs`
+    edge_type : {'circular', 'reflect1', 'reflect2', 'repeat', 'zero', 'extend', 'dont-compute'}
+        Specifies how to handle edges. Options are:
+
+        * `'circular'` - circular convolution
+        * `'reflect1'` - reflect about the edge pixels
+        * `'reflect2'` - reflect, doubling the edge pixels
+        * `'repeat'` - repeat the edge pixels
+        * `'zero'` - assume values of zero outside image boundary
+        * `'extend'` - reflect and invert
+        * `'dont-compute'` - zero output when filter overhangs imput boundaries.
+
+    Attributes
+    ----------
+    image : `array_like`
+        The input image used to construct the pyramid.
+    image_size : `tuple`
+        The size of the input image.
+    pyr_type : `str` or `None`
+        Human-readable string specifying the type of pyramid. For base class, is None.
+    edge_type : `str`
+        Specifies how edges were handled.
+    pyr_coeffs : `dict`
+        Dictionary containing the coefficients of the pyramid. Keys are `(level, band)` tuples and
+        values are 1d or 2d numpy arrays (same number of dimensions as the input image)
+    pyr_size : `dict`
+        Dictionary containing the sizes of the pyramid coefficients. Keys are `(level, band)`
+        tuples and values are tuples.
+    is_complex : `bool`
+        Whether the coefficients are complex- or real-valued. Only `SteerablePyramidFreq` can have
+        a value of True, all others must be False.
+
+    References
+    ----------
+    .. [1] E P Simoncelli and W T Freeman, "The Steerable Pyramid: A Flexible Architecture for
+       Multi-Scale Derivative Computation," Second Int'l Conf on Image Processing, Washington, DC,
+       Oct 1995.
+    .. [2] A Karasaridis and E P Simoncelli, "A Filter Design Technique for Steerable Pyramid
+       Image Transforms", ICASSP, Atlanta, GA, May 1996.
+    """
+
+    def __init__(self, image, height='auto', order=1, edge_type='symm'):
+        super().__init__(image=image, edge_type=edge_type)
+
+        self.order = order
+        self.num_orientations = self.order + 1
+        self.filters = parse_filter("sp{:d}_filters".format(self.num_orientations - 1), normalize=False)
+        self.pyr_type = 'SteerableSpace'
+        self._set_num_scales('lofilt', height)
+
+        hi0 = corrDn(image=self.image, filt=self.filters['hi0filt'], edge_type=self.edge_type)
+
+        self.pyr_coeffs['residual_highpass'] = hi0
+        self.pyr_size['residual_highpass'] = hi0.shape
+
+        lo = corrDn(image=self.image, filt=self.filters['lo0filt'], edge_type=self.edge_type)
+        for i in range(self.num_scales):
+            # assume square filters  -- start of buildSpyrLevs
+            bfiltsz = int(np.floor(np.sqrt(self.filters['bfilts'].shape[0])))
+
+            for b in range(self.num_orientations):
+                filt = self.filters['bfilts'][:, b].reshape(bfiltsz, bfiltsz).T
+                band = corrDn(image=lo, filt=filt, edge_type=self.edge_type)
+                self.pyr_coeffs[(i, b)] = np.array(band)
+                self.pyr_size[(i, b)] = band.shape
+
+            lo = corrDn(image=lo, filt=self.filters['lofilt'], edge_type=self.edge_type, step=(2, 2))
+
+        self.pyr_coeffs['residual_lowpass'] = lo
+        self.pyr_size['residual_lowpass'] = lo.shape
+
+    def recon_pyr(self, order=None, edge_type=None, levels='all', bands='all'):
+        """Reconstruct the image, optionally using subset of pyramid coefficients.
+
+        Parameters
+        ----------
+        order : {None, 0, 1, 3, 5}.
+            the Gaussian derivative order you want to use for the steerable pyramid filters used to
+            reconstruct the pyramid. If None, uses the same order as that used to construct the
+            pyramid.
+        edge_type : {None, 'circular', 'reflect1', 'reflect2', 'repeat', 'zero', 'extend',
+                     'dont-compute'}
+            Specifies how to handle edges. Options are:
+
+            * None (default) - use `self.edge_type`, the edge_type used to construct the pyramid
+            * `'circular'` - circular convolution
+            * `'reflect1'` - reflect about the edge pixels
+            * `'reflect2'` - reflect, doubling the edge pixels
+            * `'repeat'` - repeat the edge pixels
+            * `'zero'` - assume values of zero outside image boundary
+            * `'extend'` - reflect and inverts
+            * `'dont-compute'` - zero output when filter overhangs imput boundaries.
+        levels : `list`, `int`,  or {`'all'`, `'residual_highpass'`}
+            If `list` should contain some subset of integers from `0` to `self.num_scales-1`
+            (inclusive) and `'residual_lowpass'`. If `'all'`, returned value will contain all
+            valid levels. Otherwise, must be one of the valid levels.
+        bands : `list`, `int`, or `'all'`.
+            If list, should contain some subset of integers from `0` to `self.num_orientations-1`.
+            If `'all'`, returned value will contain all valid orientations. Otherwise, must be one
+            of the valid orientations.
+
+        Returns
+        -------
+        recon : `np.array`
+            The reconstructed image.
+        """
+
+        if order is None:
+            filters = self.filters
+            recon_keys = self._recon_keys(levels, bands)
+        else:
+            filters = parse_filter("sp{:d}_filters".format(order), normalize=False)
+            recon_keys = self._recon_keys(levels, bands, order + 1)
+
+        # assume square filters  -- start of buildSpyrLevs
+        bfiltsz = int(np.floor(np.sqrt(filters['bfilts'].shape[0])))
+
+        if edge_type is None:
+            edges = self.edge_type
+        else:
+            edges = edge_type
+
+        # initialize reconstruction
+        if 'residual_lowpass' in recon_keys:
+            recon = self.pyr_coeffs['residual_lowpass']
+        else:
+            recon = np.zeros_like(self.pyr_coeffs['residual_lowpass'])
+
+        for lev in reversed(range(self.num_scales)):
+            # we need to upConv once per level, in order to up-sample
+            # the image back to the right shape.
+            recon = upConv(image=recon, filt=filters['lofilt'], edge_type=edges,
+                           step=(2, 2), start=(0, 0), stop=self.pyr_size[(lev, 0)])
+            # I think the most effective way to do this is to just
+            # check every possible sub-band and then only add in the
+            # ones we want (given that we have to loop through the
+            # levels above in order to up-sample)
+            for band in reversed(range(self.num_orientations)):
+                if (lev, band) in recon_keys:
+                    filt = filters['bfilts'][:, band].reshape(bfiltsz, bfiltsz, order='F')
+                    recon += upConv(image=self.pyr_coeffs[(lev, band)], filt=filt, edge_type=edges,
+                                    stop=self.pyr_size[(lev, band)])
+
+        # apply lo0filt
+        recon = upConv(image=recon, filt=filters['lo0filt'], edge_type=edges, stop=recon.shape)
+
+        if 'residual_highpass' in recon_keys:
+            recon += upConv(image=self.pyr_coeffs['residual_highpass'], filt=filters['hi0filt'],
+                            edge_type=edges, start=(0, 0), step=(1, 1), stop=recon.shape)
+
+        return recon
+
+
+def corrDn(image, filt, edge_type='symm', step=(1, 1), start=(0, 0), stop=None):
+    """Correlation of image with filter.
+
+        Parameters
+        ----------
+        image : `np.array`
+            The image to be filtered.
+        filt : `np.array`
+            The filter to be used.
+        edge_type: str {fill, wrap, symm}, optional
+        step : tuple of ints
+            The step size used to sample the image.
+        start : `tuple`
+            2-tuple which specifies the start of the window over which we perform the convolution.
+
+
+        """
+    if (stop is None):
+        stop = image.shape
+    filt_output = signal.correlate2d(image, filt, mode='same', boundary=edge_type)
+    output = filt_output[start[0]:stop[0]:step[0], start[1]:stop[1]:step[1]]
+    return output
+
+
+def upConv(image, filt, edge_type='symm', step=(1, 1), start=(0, 0), stop=None):
+    """Up-convolution of image with filter.
+    Up sample by inserting 0s and then apply the filter.
+
+        Parameters
+        ----------
+        image : `np.array`
+            The image to be filtered.
+        filt : `np.array`
+            The filter to be used.
+        edge_type: str {fill, wrap, symm}, optional
+            fill
+                pad input arrays with fillvalue.
+            wrap
+                circular boundary conditions.
+            symm
+                symmetrical boundary conditions.
+        step : tuple of ints
+            The step size used to upsample the image.
+        start : `tuple`
+            2-tuple which specifies the start of the image over which we perform the convolution.
+        """
+    if (stop is None):
+        stop = image.shape
+    output = np.zeros((int(stop[0] * step[0]), int(stop[1] * step[1])))
+    output[start[0]:stop[0] * step[0]:step[0], start[1]:stop[1] * step[0]:step[1]] = image
+    filt_output = signal.correlate2d(output, filt, mode='same', boundary=edge_type)
+    return filt_output

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/fcm/utils.py

@@ -0,0 +1,511 @@
+import cv2
+import numpy as np
+from scipy import signal
+from scipy import ndimage
+from PIL import Image
+from skimage import transform
+
+
+def RGB2Lab(im):
+    """
+
+    Converts RGB color space to CIELab color space
+
+    Parameters
+    ----------
+    im : an input RGB image
+
+    Returns
+    -------
+    im_Lab : the output Lab image
+
+    """
+
+    im = np.float32(im) / 255  # get r,g,b value in the range of [0,1]
+
+    # the figure from graybar.m and the infromation from the website
+    # http://www.cinenet.net/~spitzak/conversion/whysrgb.html, we can conclude
+    # that our RGB system is sRGB
+
+    # if RGB system is sRGB
+    mask = im >= 0.04045
+    im[mask] = ((im[mask] + 0.055) / 1.055) ** 2.4
+    im[~mask] = im[~mask] / 12.92
+
+    # Observer. = 2°, Illuminant = D65
+    matrix = np.array([[0.412453, 0.357580, 0.180423],
+                       [0.212671, 0.715160, 0.072169],
+                       [0.019334, 0.119193, 0.950227]])
+
+    c_im = np.dot(im, matrix.T)
+    c_im[:, :, 0] = c_im[:, :, 0] / 95.047
+    c_im[:, :, 1] = c_im[:, :, 1] / 100.000
+    c_im[:, :, 2] = c_im[:, :, 2] / 108.833
+
+    mask = c_im >= 0.008856
+    c_im[mask] = c_im[mask] ** (1 / 3)
+    c_im[~mask] = 7.787 * c_im[~mask] + 16 / 116
+
+    im_Lab = np.zeros_like(c_im)
+
+    im_Lab[:, :, 0] = (116 * c_im[:, :, 1]) - 16
+    im_Lab[:, :, 1] = 500 * (c_im[:, :, 0] - c_im[:, :, 1])
+    im_Lab[:, :, 2] = 200 * (c_im[:, :, 1] - c_im[:, :, 2])
+
+    return im_Lab
+
+
+def normlize(arr):
+    """
+
+    Normlizes the array input between (min, max) -> (0, 255)
+
+    """
+    return ((arr - arr.min()) * (1 / (arr.max() - arr.min()) * 255)).astype('uint8')
+
+
+def conv2(x, y, mode=None):
+    if mode == 'same':
+        return np.rot90(signal.convolve2d(np.rot90(x, 2), np.rot90(y, 2), mode=mode), 2)
+    else:
+        return signal.convolve2d(x, y)
+
+
+def RRoverlapconv(kernel, in_):
+    """
+
+    Filters the image in with filter kernel, where it only "counts" the
+    part of the filter that overlaps the image.  Rescales the filter so its
+    weights which overlap the image sum to the same as the full filter
+    kernel.
+
+    """
+
+    # Convolve with the original kernel
+    out = conv2(in_, kernel, mode='same')
+
+    # Convolve kernel with an image of 1's, of the same size as the input image
+    rect = np.ones_like(in_)
+
+    overlapsum = conv2(rect, kernel, 'same')
+    # Now scale the output image at each pixel by the relative overlap of the filter with the image
+    out = np.sum(kernel) * out / overlapsum
+    return out
+
+
+def RRgaussfilter1D(halfsupport, sigma, center=0):
+    """
+
+    Creates a 1D gaussian filter kernel, centered at center (default=0), with pixels from
+    a range -halfsupport:halfsupport+1, and standard deviation sigma.
+
+    """
+    t = list(range(-halfsupport, halfsupport + 1))
+    kernel = np.array([np.exp(-(x - center) ** 2 / (2 * sigma ** 2)) for x in t])
+    kernel = kernel / sum(kernel)
+
+    return kernel.reshape(1, kernel.shape[0])
+
+
+def DoG1filter(a, sigma):
+    """
+
+    Creates 2 1-D gaussian filters.
+
+    Parameters
+    ----------
+    a : half-support of the filter.
+    sigma: standard deviation.
+
+
+    Notes
+    -----
+    2-D DoG filters can be contructed by combining 2 1-D DoG filters separably, in x and y directions
+
+    References
+    ----------
+    Jitendra Malik and Pietro Perona. Preattentive texture discrimination
+    with early vision mechanisms. Journal of Optical Society of America A,
+    7(5), May 1990, 923-932.
+
+    Zhenlan Jin
+
+    """
+    sigi = 0.71 * sigma
+    sigo = 1.14 * sigma
+
+    t = range(-a, a + 1)
+
+    gi = [np.exp(-x ** 2 / (2 * sigi ** 2)) for x in t]
+    gi = gi / sum(gi)
+    go = [np.exp(- x ** 2 / (2 * sigo ** 2)) for x in t]
+    go = go / sum(go)
+
+    return gi.reshape(1, gi.shape[0]), go.reshape(1, go.shape[0])
+
+
+def addborder(im, xbdr, ybdr, arg):
+    """
+
+    imnew = addborder(im,xborder,yborder,arg)  Make image w/added border.
+    imnew = addborder(im,5,5,128)  Add 5 wide border of val 128.
+    imnew = addborder (im,5,5,'even')  Even reflection.
+    imnew = addborder (im,5,5,'odd')  Odd reflection.
+    imnew = addborder (im,5,5,'wrap')  Wraparound.
+
+    """
+    ysize, xsize = im.shape
+
+    # check thickness
+    if (xbdr > xsize) or (ybdr > ysize):
+        raise ValueError('borders must be thinner than image')
+
+    # if arg is a number, fill border with its value.
+    if isinstance(arg, (int, float)):
+        imbig = cv2.copyMakeBorder(im, ybdr, ybdr, xbdr, xbdr, cv2.BORDER_CONSTANT, value=arg)
+
+    # Even reflections
+    elif arg == 'even':
+        imbig = cv2.copyMakeBorder(im, ybdr, ybdr, xbdr, xbdr, cv2.BORDER_REFLECT)
+
+    # Odd reflections
+    elif arg == 'odd':
+        imbig = cv2.copyMakeBorder(im, ybdr, ybdr, xbdr, xbdr, cv2.BORDER_REFLECT_101)
+
+    # Wraparound
+    elif arg == 'wrap':
+        imbig = cv2.copyMakeBorder(im, ybdr, ybdr, xbdr, xbdr, cv2.BORDER_WRAP)
+    else:
+        raise ValueError('unknown border style')
+    return imbig
+
+
+def filt2(kernel, im1, reflect_style='odd'):
+    """
+
+    Improved version of filter2 in MATLAB, which includes reflection.
+    Default style is 'odd'. Also can be 'even', or 'wrap'.
+
+    Examples
+    --------
+    im2 = filt2(kern,image)  apply kernel with odd reflection (default).
+    im2 = filt2(kern,image,'even')  Use even reflection.
+    im2 = filt2(kern,image,128)  Fill with 128's.
+
+    Ruth Rosenholtz
+
+    """
+
+    ky, kx = kernel.shape
+    iy, ix = im1.shape
+
+    imbig = addborder(im1, kx, ky, reflect_style)
+    imbig = conv2(imbig, kernel, 'same')
+    im2 = imbig[ky:ky + iy, kx:kx + ix]
+
+    return im2
+
+
+def RRcontrast1channel(pyr, DoG_sigma=2):
+    """
+
+    Filters a Gaussian pyramid, pyr, with a 1-channel contrast feature detector.
+
+    Parameters
+    ----------
+    pyr : a Gaussian pyramid. It can be computed from this "pyrtools" package
+    DoG_sigma : size of the center-surround (Difference-of-Gaussian) filter used for computing the contrast. Default = 2. Refer to DoG1filter.
+
+    Code by Ruth Rosenholtz and Zhenlan Jin
+    modified by Yuanzhen Li, Sep 2004
+
+    """
+    levels = len(pyr)
+    contrast = [0] * levels
+
+    # Here we're using the difference-of-gaussian filters. Separable.
+    # Refer to routine 'DoG1filter'.
+    innerG1, outerG1 = DoG1filter(round(DoG_sigma * 3), DoG_sigma)
+
+    # Do contrast feature computation with these filters:
+    for i in range(0, levels):
+        inner = filt2(innerG1, pyr[(i, 0)])
+        inner = filt2(innerG1.T, inner)
+        outer = filt2(outerG1, pyr[(i, 0)])
+        outer = filt2(outerG1.T, outer)
+        tmp = inner - outer
+        contrast[i] = abs(tmp)  # ** 2
+
+    return contrast
+
+
+def reduce(image0, kernel=None):
+    """
+
+    Reduce: for building Gaussian or Laplacian pyramids. 1-D separable kernels.
+
+    Examples
+    --------
+    imnew = reduce(im0) Reduce w/default kernel: [.05 .25 .4 .25 .05]
+    imnew = reduce(im0, kern) Reduce with kern; sums to unity.
+
+    Ruth Rosenholtz
+    """
+
+    if kernel is None:
+        # Default kernel
+        kernel = np.array([[0.05, 0.25, 0.4, 0.25, 0.05]])
+
+    ysize, xsize = image0.shape
+
+    image0 = filt2(kernel, image0)  # Filter horizontally.
+    # filt2 is filter2 with reflection.
+    image1 = image0[:, range(0, xsize, 2)]
+
+    image1 = filt2(kernel.T, image1)  # Filter vertically.
+    image2 = image1[range(0, ysize, 2), :]
+
+    return image2
+
+
+def RRoverlapconvexpand(in_, kernel=None):
+    """
+
+    Examples
+    --------
+    out = RRoverlapconvexpand(in_)  return an image expanded to double size,
+    out = RRoverlapconvexpand(in, kernel); specify 1-D kernel with unity sum.
+
+    """
+
+    if kernel is None:
+        # Default kernel
+        kernel = np.array([[0.05, 0.25, 0.4, 0.25, 0.05]])
+
+    ysize, xsize = in_.shape
+    kernel = kernel * 2  # kernel sum=2 to account for padding.
+
+    tmp = np.zeros([ysize, 2 * xsize])  # First double the width
+    k = list(range(0, xsize))
+    k_2 = [x * 2 for x in k]
+    tmp[:, k_2] = in_[:, k]
+    tmp = RRoverlapconv(kernel, tmp)  # ..and filter horizontally.
+
+    out = np.zeros([2 * ysize, 2 * xsize])  # Next double the height
+    k = list(range(0, ysize))
+    k_2 = [x * 2 for x in k]
+    out[k_2, :] = tmp[k, :]
+    out = RRoverlapconv(kernel.T, out)  # ..and filter vertically.
+
+    return out
+
+
+def HV(in_):
+    """
+
+    Outputs H-V
+
+    """
+    out = in_[0] - in_[1]
+    return out
+
+
+def DD(in_):
+    """
+
+    Outputs R-L
+
+    """
+    out = in_[3] - in_[2]
+    return out
+
+
+def sumorients(in_):
+    """
+
+    Sums the four orientations into one image.
+
+    """
+
+    out = in_[0] + in_[1] + in_[2] + in_[3]
+    return out
+
+
+def poolnew(in_, sigma=None):
+    """
+
+    Pools with a gaussian.  Note assumes that input image is actually
+    4 equal-size images, side by side.
+
+    """
+
+    in1 = in_[0]  # H -> first quarter
+    in2 = in_[1]  # V -> second quarter
+    in3 = in_[2]  # L -> third quarter
+    in4 = in_[3]  # R -> last quarter
+
+    if sigma is None:
+        out1 = reduce(RRoverlapconvexpand(in1))
+        out2 = reduce(RRoverlapconvexpand(in2))
+        out3 = reduce(RRoverlapconvexpand(in3))
+        out4 = reduce(RRoverlapconvexpand(in4))
+    else:
+        kernel = RRgaussfilter1D(round(2 * sigma), sigma)
+        out1 = reduce(RRoverlapconvexpand(in1, kernel), kernel)
+        out2 = reduce(RRoverlapconvexpand(in2, kernel), kernel)
+        out3 = reduce(RRoverlapconvexpand(in3, kernel), kernel)
+        out4 = reduce(RRoverlapconvexpand(in4, kernel), kernel)
+
+    out = out1, out2, out3, out4
+
+    return out
+
+
+def imrotate_cv(image, angle, method='bicubic', bbox='crop'):
+  image_center = tuple(np.array(image.shape[1::-1]) / 2)
+  rot_mat = cv2.getRotationMatrix2D(image_center, angle, 1.0)
+  result = cv2.warpAffine(image, rot_mat, image.shape[1::-1], flags=cv2.INTER_LINEAR)
+  return result
+
+
+def imrotate_skimage(im, angle, method='bicubic', bbox='crop'):
+    """
+
+    rotate an image by Skimage package.  Basically just a wrapper to
+    deal with the fact that skimage thinks floating point images need to be between [-1.0,1.0]
+
+    angle is in DEGREE
+
+    """
+
+    func_bbox = {'loose': True, 'crop': False}
+
+    immin = np.min(im)
+    imrange = np.max(im) - immin
+    im = im - immin
+    im = im / imrange
+    im = transform.rotate(im, angle, order=3, resize=func_bbox[bbox])
+    im = im * imrange
+    im = im + immin
+    return im
+
+
+def imrotate_pil(im, angle, method='nearest', bbox='crop'):
+    """
+
+    roatate an image by PIL package
+
+    """
+
+    # interpolation methods
+    func_method = {'nearest': 0, 'bilinear': 2, 'bicubic': 3, 'cubic': 3}
+    # crop or not methods
+    func_bbox = {'loose': True, 'crop': False}
+    PIL_im = Image.fromarray(im)
+    # roatate
+    im_rot = PIL_im.rotate(angle, expand=func_bbox[bbox], resample=func_method[method])
+    return np.array(im_rot)
+
+
+def imrotate_scipy(im, angle, method='bicubic', bbox='crop'):
+    """
+
+    roatate an image by Scipy package
+
+    """
+
+    # By default rotate uses cubic interpolation
+    return ndimage.rotate(im, angle=angle, order=3, reshape=False)
+
+
+def orient_filtnew(pyr, sigma=16 / 14):
+    """
+
+    ORIENT_FILTNEW Filters "pyr" (in principle, one level of the Gaussian pyramid generated by gausspyr) with 2nd
+    derivative filters in 4 directions.
+
+    Returns
+    -------
+    hvdd : the 4 output images appended together in a list, in the order horizontal, vertical, up-left, and down-right.
+    """
+
+    halfsupport = round(3 * sigma)
+    # halfsupport was 10, for default sigma.  We need a halfsupport of about
+    # 2*sigma for a single Gaussian.  Here we have three, one at -sigma, one at
+    # sigma, so we should need a halfsupport of about 3*sigma.
+
+    sigy = sigma
+    sigx = sigma  # Was sigx = 3*sigma.
+
+    gx = RRgaussfilter1D(halfsupport, sigx)
+    gy = RRgaussfilter1D(halfsupport, sigy, sigma)
+    Ga = conv2(gx, gy.T)
+    Ga = Ga / sum(sum(Ga))
+    gy = RRgaussfilter1D(halfsupport, sigy)
+    Gb = conv2(gx, gy.T)
+    Gb = Gb / sum(sum(Gb))
+    gy = RRgaussfilter1D(halfsupport, sigy, -sigma)
+    Gc = conv2(gx, gy.T)
+    Gc = Gc / sum(sum(Gc))
+    H = -Ga + 2 * Gb - Gc
+    V = H.T
+
+    GGa = imrotate_skimage(Ga, 45, 'bicubic', 'crop')
+    GGa = GGa / sum(sum(GGa))
+    GGb = imrotate_skimage(Gb, 45, 'bicubic', 'crop')
+    GGb = GGb / sum(sum(GGb))
+    GGc = imrotate_skimage(Gc, 45, 'bicubic', 'crop')
+    GGc = GGc / sum(sum(GGc))
+    R = -GGa + 2 * GGb - GGc
+    GGa = imrotate_skimage(Ga, -45, 'bicubic', 'crop')
+    GGa = GGa / sum(sum(GGa))
+    GGb = imrotate_skimage(Gb, -45, 'bicubic', 'crop')
+    GGb = GGb / sum(sum(GGb))
+    GGc = imrotate_skimage(Gc, -45, 'bicubic', 'crop')
+    GGc = GGc / sum(sum(GGc))
+    L = -GGa + 2 * GGb - GGc
+
+    hout = filt2(H, pyr)
+    vout = filt2(V, pyr)
+    lout = filt2(L, pyr)
+    rout = filt2(R, pyr)
+
+    hvdd = hout, vout, lout, rout
+
+    return hvdd
+
+
+def histc(x, bins):
+    """
+
+    MATLAB `histc` equivalent.
+
+    """
+    map_to_bins = np.digitize(x, bins)  # Get indices of the bins to which each value in input array belongs.
+    res = np.zeros(bins.shape)
+    for el in map_to_bins:
+        res[el - 1] += 1  # Increment appropriate bin.
+    return res
+
+
+def entropy(x, nbins=None):
+    """
+
+    Computes the entropy of signal "x", given the number of bins "nbins" used uniform binning in the calculation.
+
+    """
+
+    nsamples = x.shape[0]
+
+    if nbins is None:
+        nbins = int(np.ceil(np.sqrt(nsamples)))
+    elif nbins == 1:
+        return 0
+
+    edges = np.histogram(x, bins=nbins - 1)[1]
+    ref_hist = histc(x, edges)
+    ref_hist = ref_hist / float(np.sum(ref_hist))
+    ref_hist = ref_hist[np.nonzero(ref_hist)]
+    ref_ent = -np.sum(ref_hist * np.log(ref_hist))
+
+    return ref_ent

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/fcm/vlc.py

@@ -0,0 +1,838 @@
+import copy
+import os
+import cv2
+import pickle
+import numpy as np
+# import pyrtools as pt
+from PIL import Image
+from .utils import RRgaussfilter1D, RGB2Lab, conv2
+from .utils import normlize, RRoverlapconv, RRcontrast1channel
+from .utils import orient_filtnew, poolnew, HV
+from .utils import DD, sumorients, entropy
+from .pyramid import upConv
+from .base_utils import normalize_image, visualize_images, get_image_pkl
+from .base_utils import sort_images, rename_files, get_real_image
+from .base_utils import sort_images_target, get_dict_variation, parse_image_names
+from .base_utils import write_stats, sort_images_real
+
+class VLC:
+    """
+    Class for computing Feature Congestion Map.
+    ref:     Ruth Rosenholtz, Yuanzhen Li, and Lisa Nakano. "Measuring Visual Clutter".
+    Journal of Vision, 7(2), 2007.
+    """
+    """
+
+    Class of two measures of visual clutter (Feature Congestion and Subband Entropy)
+
+    Parameters
+    ----------
+    inputImage : gives the input. It can be one of the following 2 things: 1. an RGB image; 2. a string, i.e., file name of an RGB image.
+    numlevels : the number of levels.
+    contrast_filt_sigma : the sigma (standard deviation) of the center-surround DoG1 filter used for computing the contrast
+    contrast_pool_sigma : the sigma (standard deviation) of this Gaussian window for contrast clutter. Default = 3*filt_sigma.
+    color_pool_sigma : the sigma (standard deviation) of this Gaussian window for color clutter, Defaults to 3.
+
+    Methods
+    -------
+    getClutter_FC: computes Feature Congestion clutter, outputs both a scalar (clutter of the whole image) and a map (local clutter).
+    getClutter_SE: computes Subband Entropy clutter, outputs only a scalar.
+    colorClutter: computes clutter maps indicating local variability in color
+    contrastClutter: computes clutter maps indicating local variability in contrast
+    orientationClutter: computes clutter maps indicating local variability in orientation
+
+    (Please see individual routines for more info about parameters and outputs.)
+
+    References
+    ----------
+    Ruth Rosenholtz, Yuanzhen Li, and Lisa Nakano. "Measuring Visual Clutter".
+    Journal of Vision, 7(2), 2007. http://www.journalofvision.com/7/2/
+    Ruth Rosenholtz, Yuanzhen Li, and Lisa Nakano, March 2007.
+
+    Ruth Rosenholtz, Yuanzhen Li, Jonathan Mansfield, and Zhenlan Jin. "Feature Congestion: A Measure of Display Clutter".
+    CHI '05: Proc. of the SIGCHI conference on Human factors in computing systems. May 2005. 761-770.
+
+    """
+
+    def __init__(self, add_xyz=None, num_levels=3, contrast_filt_sigma=1,
+                 contrast_pool_sigma=None, color_pool_sigma=3, xyz_sigma=1,
+                 w_color=0.2088, w_contrast=0.0660, w_orient=0.0269,
+                 w_xyz=0.1):
+        """
+        :param add_xyz: whether to add xyz channels. options: None, all, 'x' or 'y' or 'z'
+        :param num_levels: number of sacles
+        :param contrast_filt_sigma: sigma for gaussian filter for contrast
+        :param contrast_pool_sigma:  gaussian window size for contrast
+        :param color_pool_sigma: gaussian window for color
+        :param xyz_sigma: gaussian window for xyz
+        :param w_color: mixing weight of color clutter
+        :param w_contrast: mixing weight of contrast clutter
+        :param w_orient: mixing weight of orientation clutter
+        :param w_xyz: mixing weight of orientation clutter
+
+        """
+        self.add_xyz = add_xyz
+        self.num_levels = num_levels
+        self.contrast_filt_sigma = contrast_filt_sigma
+        self.contrast_pool_sigma = 3 * contrast_filt_sigma if contrast_pool_sigma is None else contrast_pool_sigma
+        self.color_pool_sigma = color_pool_sigma
+        self.xyz_sigma = xyz_sigma
+
+        # orient_pool_sigma is the sigma (standard deviation) of this Gaussian window, and here is hard-wired to 7/2.
+        self.orient_pool_sigma = 7 / 2
+        self.w_color = w_color
+        self.w_contrast = w_contrast
+        self.w_orient = w_orient
+        self.w_xyz = w_xyz
+        self.L_pyr, self.a_pyr, self.b_pyr = None, None, None
+        self.x, self.y, self.z, self.xyz = None, None, None, None
+    def collapse(self, clutter_levels):
+        """
+        Collapses multple scale clutter maps into a unified one
+        :param clutter_levels:  number of scales of clutter maps
+        :return:
+            clutter_map:  a unified clutter map
+        """
+
+        kernel_1d = np.array([[0.05, 0.25, 0.4, 0.25, 0.05]])
+        kernel_2d = conv2(kernel_1d, kernel_1d.T)
+
+        clutter_map = clutter_levels[0].copy()
+        for scale in range(1, len(clutter_levels)):
+            clutter_here = clutter_levels[scale]
+
+            for kk in range(scale, 0, -1):
+                # clutter_here = upConv(image=clutter_here, filt=kernel_2d,
+                #                       edge_type='reflect1',
+                #                       step=[2, 2],
+                #                       start=[0, 0])
+                clutter_here = upConv(image=clutter_here,
+                                      filt=kernel_2d,
+                                      edge_type='symm',
+                                      step=[2, 2],
+                                      start=[0, 0])
+
+            common_sz = (min(clutter_map.shape[0], clutter_here.shape[0]),
+                         min(clutter_map.shape[1], clutter_here.shape[1]))
+            for i in range(0, common_sz[0]):
+                for j in range(0, common_sz[1]):
+                    clutter_map[i][j] = max(clutter_map[i][j], clutter_here[i][j])
+
+        return clutter_map
+
+    def get_orient_opponent_energy(self, num_levels, L_pyr):
+        """
+        :param num_levels: number of scales
+        :param L_pyr: luminance pyramid
+        :return:
+            out: oriented opponent energy
+        """
+        hvdd = [0] * num_levels
+        hv = [0] * num_levels
+        dd = [0] * num_levels
+        out = [0] * num_levels
+        total = [0] * num_levels
+
+        noise = 1.0  # Was 1.5
+        filterScale = 16 / 14 * 1.75
+        poolScale = 1.75
+        # These probably seem like arbitrary numbers, but it's just trying to get
+        # three very different feature extraction methods to operate at basically
+        # the same scales.
+
+        for scale in range(0, num_levels):
+            # Check this is the right order for Landy/Bergen. RRR
+            hvdd[scale] = orient_filtnew(L_pyr[(scale, 0)], filterScale)
+            # filt with 4 oriented filters 0, 45, 90, 135.  Was sigma = 16/14, orient_filtnew,
+            # then 16/14*1.75 to match contrast and other scales.
+            # Eventually make this sigma a variable that's passed to this routine.
+            # hvdd[scale] is the 4 output images concatenated together,
+            # in the order horizontal, vertical, up-left, and down-right.
+
+            hvdd[scale] = [x ** 2 for x in hvdd[scale]]  # local energy
+            hvdd[scale] = poolnew(hvdd[scale],
+                                  poolScale)  # Pools with a gaussian filter.  Was effectively sigma=1, then 1.75 to match 1.75 above.
+            # RRR Should look at these results and see if this is the right amount of
+            # pooling for the new filters.  It was right for the Landy-Bergen
+            # filters.
+            hv[scale] = HV(hvdd[scale])  # get the difference image between horizontal and vertical: H-V (0-90)
+            dd[scale] = DD(hvdd[scale])  # get the difference image between right and left: R-L (45-135)
+            # Normalize by the total response at this scale, assuming the total
+            # response is high enough.  If it's too low, we'll never see this
+            # orientation.  I'm not sure what to do here -- set it to zeros and
+            # it's like that's the orientation.  Maybe output the total response
+            # and decide what to do later.  RRR
+            total[scale] = sumorients(hvdd[scale]) + noise  # add noise based upon sum orients at visibility threshold
+            hv[scale] = hv[scale] / total[scale]  # normalize the hv and dd image
+            dd[scale] = dd[scale] / total[scale]
+            out[scale] = hv[scale], dd[
+                scale]  # out is the 2 output images concatenated together, in the order of hv, dd
+
+        return out
+
+    def compute_orientation_clutter(self):
+        """
+        Computes the orientation clutter maps
+        :return:
+            orient_clt_lvls: list of orientation clutter maps as multiple scales (specified by numLevels)
+        """
+
+        noise = 0.001  # Was eps, but that gave too much orientation noise in the saliency maps.  Then changed to 0.000001
+        poolScale = 7 / 2
+
+        numlevels = len(self.L_pyr)
+        Dc = [0] * numlevels  # mean "cos 2 theta" at distractor scale
+        Ds = [0] * numlevels  # mean "sin 2 theta" at distractor scale
+
+        # Get approximations to cos(2theta) and sin(2theta) from oriented opponent
+        # energy, at each of the numlevels of the pyramid
+        angles = self.get_orient_opponent_energy(self.num_levels, self.L_pyr)
+
+        # Compute the two-vector [meancos, meansin] at each scale, as well as the
+        # things we need to compute the mean and covariance of this two-vector at
+        # the larger, distractor scale.
+        bigG = RRgaussfilter1D(round(8 * poolScale), 4 * poolScale)
+        maxbigG = max(bigG) ** 2
+
+        covMx = {}
+        orient_clt_lvls = [0] * numlevels
+
+        for i in range(0, numlevels):
+            cmx = angles[i][0]
+            smx = angles[i][1]
+
+            # Pool to get means at distractor scale. In pooling, don't pool over the target
+            # region (implement this by pooling with a big Gaussian, then
+            # subtracting the pooling over the target region computed above.  Note,
+            # however, that we first need to scale the target region pooling so
+            # that its peak is the same height as this much broader Gaussian used
+            # to pool over the distractor region.
+            Dc[i] = RRoverlapconv(bigG, cmx)
+            Dc[i] = RRoverlapconv(bigG.T, Dc[i])
+            Ds[i] = RRoverlapconv(bigG, smx)
+            Ds[i] = RRoverlapconv(bigG.T, Ds[i])
+
+            # Covariance matrix elements.  Compare with computations in
+            # RRStatisticalSaliency.  I tried to match computeColorClutter, but I
+            # don't remember the meaning of some of the terms I removed.  XXX
+            covMx[(i, 0, 0)] = RRoverlapconv(bigG, cmx ** 2)
+            covMx[(i, 0, 0)] = RRoverlapconv(bigG.T, covMx[(i, 0, 0)]) - Dc[i] ** 2 + noise
+            covMx[(i, 0, 1)] = RRoverlapconv(bigG, cmx * smx)
+            covMx[(i, 0, 1)] = RRoverlapconv(bigG.T, covMx[(i, 0, 1)]) - Dc[i] * Ds[i]
+            covMx[(i, 1, 1)] = RRoverlapconv(bigG, smx ** 2)
+            covMx[(i, 1, 1)] = RRoverlapconv(bigG.T, covMx[(i, 1, 1)]) - Ds[i] ** 2 + noise
+
+            # Get determinant of covariance matrix, which is the volume of the
+            # covariance ellipse
+            detIm = covMx[(i, 0, 0)] * covMx[(i, 1, 1)] - covMx[(i, 0, 1)] ** 2
+            # Take the square root considering variance is squared, and the square
+            # root again, since this is the area and the contrast measure is a "length"
+            orient_clt_lvls[i] = detIm ** (1 / 4)
+
+        return orient_clt_lvls
+
+    def get_contrast_clutter(self):
+        """
+        Computes the contrast clutter map(s) of an image.
+        :return:
+            contrast_clt_lvls: list of contrast clutter maps as multiple scales (specified by numLevels)
+            contrast_clt_map: an array of same size as input image computed by taking the max of clutter maps at different
+            scales (i.e. combined map)
+        """
+
+        # Compute "contrast-energy" by filtering the luminance
+        # channel L by a center-surround filter and squaring (or taking the absolute
+        # values of) the filter outputs. The center-surround filter is a DoG1 filter
+        # with std 'contrast_filt_sigma'.
+        contrast = RRcontrast1channel(self.L_pyr, self.contrast_filt_sigma)
+
+        # Get a Gaussian filter for computing the variance of contrast
+        # Since we used a Gaussian pyramid to find contrast features, these filters
+        # have the same size regardless of the scale of processing.
+        bigG = RRgaussfilter1D(round(self.contrast_pool_sigma * 2), self.contrast_pool_sigma)
+        contrast_clt_lvls = self.compute_variance(bigG, contrast)
+        contrast_clt_map = self.collapse(contrast_clt_lvls)
+        return contrast_clt_lvls, contrast_clt_map
+
+    def compute_multi_ch_covar(self, bigG, pyr_1, pyr_2, pyr_3,
+                               delta1=0., delta2=0., delta3=0.):
+        """
+        Computes the covariance of multi-layer feature map
+        :param bigG: Gaussian kernel
+        :param delta1: Delta value to be added (for Color)
+        :param delta2: Delta value to be added (for Color)
+        :param delta3: Delta value to be added (for Color)
+        :return:
+            Covariances for each scale
+        """
+        covMx = {}
+        clutter_lvls = [0] * self.num_levels
+        D1 = [0] * self.num_levels
+        D2 = [0] * self.num_levels
+        D3 = [0] * self.num_levels
+        for i in range(0, self.num_levels):
+            # get E(X) by filtering X with a 1-D Gaussian window separably in x and y directions:
+            D1[i] = RRoverlapconv(bigG, pyr_1[(i, 0)])
+            D1[i] = RRoverlapconv(bigG.T, D1[i])  # E(L)
+            D2[i] = RRoverlapconv(bigG, pyr_2[(i, 0)])
+            D2[i] = RRoverlapconv(bigG.T, D2[i])  # E(a)
+            D3[i] = RRoverlapconv(bigG, pyr_3[(i, 0)])
+            D3[i] = RRoverlapconv(bigG.T, D3[i])  # E(b)
+
+            # Covariance matrix
+            # covMx(L,a,b) = | cov(L,L)  cov(L,a)  cov(L,b) |
+            #                | cov(a,L)  cov(a,a)  cov(a,b) |
+            #                | cov(b,L)  cov(b,a)  cov(b,b) |
+            # where cov(X,Y) = E(XY) - E(X)E(Y)
+            #   and if X is the same as Y, then it's the variance var(X) =
+            #   E(X.^2)-E(X).^2
+            # and as cov(X,Y) = cov(Y,X), covMx is symmetric
+            # covariance matrix elements:
+            covMx[(i, 0, 0)] = RRoverlapconv(bigG, pyr_1[(i, 0)] ** 2)
+            covMx[(i, 0, 0)] = RRoverlapconv(bigG.T, covMx[(i, 0, 0)]) - D1[i] ** 2 + delta1  # cov(L,L) + deltaL2
+            covMx[(i, 0, 1)] = RRoverlapconv(bigG, pyr_1[(i, 0)] * pyr_2[(i, 0)])
+            covMx[(i, 0, 1)] = RRoverlapconv(bigG.T, covMx[(i, 0, 1)]) - D1[i] * D2[i]  # cov(L,a)
+            covMx[(i, 0, 2)] = RRoverlapconv(bigG, pyr_1[(i, 0)] * pyr_3[(i, 0)])
+            covMx[(i, 0, 2)] = RRoverlapconv(bigG.T, covMx[(i, 0, 2)]) - D1[i] * D3[i]  # cov(L,b)
+            covMx[(i, 1, 1)] = RRoverlapconv(bigG, pyr_2[(i, 0)] ** 2)
+            covMx[(i, 1, 1)] = RRoverlapconv(bigG.T, covMx[(i, 1, 1)]) - D2[i] ** 2 + delta2  # cov(a,a) + deltaa2
+            covMx[(i, 1, 2)] = RRoverlapconv(bigG, pyr_2[(i, 0)] * pyr_3[(i, 0)])
+            covMx[(i, 1, 2)] = RRoverlapconv(bigG.T, covMx[(i, 1, 2)]) - D2[i] * D3[i]  # cov(a,b)
+            covMx[(i, 2, 2)] = RRoverlapconv(bigG, pyr_3[(i, 0)] ** 2)
+            covMx[(i, 2, 2)] = RRoverlapconv(bigG.T, covMx[(i, 2, 2)]) - D3[i] ** 2 + delta3  # cov(b,b) + deltab2
+
+            # Get the determinant of covariance matrix
+            # which is the "volume" of the covariance ellipsoid
+            detIm = covMx[(i, 0, 0)] * (covMx[(i, 1, 1)] * covMx[(i, 2, 2)] - covMx[(i, 1, 2)] * covMx[(i, 1, 2)]) - \
+                    covMx[(i, 0, 1)] * (covMx[(i, 0, 1)] * covMx[(i, 2, 2)] - covMx[(i, 1, 2)] * covMx[(i, 0, 2)]) + \
+                    covMx[(i, 0, 2)] * (covMx[(i, 0, 1)] * covMx[(i, 1, 2)] - covMx[(i, 1, 1)] * covMx[(i, 0, 2)])
+
+            # take the square root considering variance is squared, and the cube
+            # root, since this is the volume and the contrast measure is a "length"
+            detIm[detIm < 0] = 0
+            clutter_lvls[i] = np.sqrt(detIm) ** (1 / 3)
+        return clutter_lvls
+
+    def compute_variance(self, bigG, pyr):
+        # initiate clutter_map and clutter_levels:
+        m, n = len(pyr), 1
+        clutter_lvls = [0] * m
+        for scale in range(0, m):
+            for channel in range(0, n):
+                # var(X) = E(X.^2) - E(X).^2
+                # get E(X) by filtering X with a 1-D Gaussian window separably in x and y directions
+                meanD = RRoverlapconv(bigG, pyr[scale])
+                meanD = RRoverlapconv(bigG.T, meanD)
+                # get E(X.^2) by filtering X.^2 with a 1-D Gaussian window separably in x and y directions
+                meanD2 = RRoverlapconv(bigG, pyr[scale] ** 2)
+                meanD2 = RRoverlapconv(bigG.T, meanD2)
+
+                # get variance by var(X) = E(X.^2) - E(X).^2
+                stddevD = np.sqrt(abs(meanD2 - meanD ** 2))
+                clutter_lvls[scale] = stddevD
+        return clutter_lvls
+
+    def get_color_clutter(self):
+        """
+        Computes color clutter maps for a given image
+        Color clutter is computed as the "volume" of a color distribution
+        ellipsoid, which is the determinant of covariance matrix. Covariance
+        matrix can be computed efficiently through linear filtering. More
+        specifically, cov(X,Y) = E(XY)-E(X)E(Y), where E (expectation value)
+        can be approximated by filtering with a Gaussian window.
+
+        :return:
+            color_clt_lvls: list of color clutter maps as multiple scales (specified by numLevels)
+            color_clt_map: an array of same size as input image computed by taking the max of clutter maps at different
+            scales (i.e. combined map)
+        """
+        # Compute clutter
+        # sensitivities to the L,a,and b channels are different, therefore we use
+        # deltaL2, deltaa2, and deltab2 to "scale" the L,a,b axes when computing
+        # the covariance matrix. Eventually these numbers should be vary according
+        # to the spatial scales, mimicing our visual system's sensitivity function
+        deltaL2 = 0.0007 ** 2
+        deltaa2 = 0.1 ** 2
+        deltab2 = 0.05 ** 2
+
+        # Get a Gaussian filter for computing the covariance
+        bigG = RRgaussfilter1D(round(2 * self.color_pool_sigma), self.color_pool_sigma)
+        color_clt_lvls = self.compute_multi_ch_covar(bigG, self.L_pyr, self.a_pyr, self.b_pyr,
+                                                     deltaL2, deltaa2, deltab2)
+
+        color_clt_map = self.collapse(color_clt_lvls)
+
+        return color_clt_lvls, color_clt_map
+
+    def get_xyz_clutter(self):
+        """
+        Computes the color clutter maps
+        :return:
+            color_clt_lvls: ist of color clutter maps as multiple scales (specified by numLevels)
+        """
+        # Get a Gaussian filter for computing the covariance
+        bigG = RRgaussfilter1D(round(2 * self.xyz_sigma), self.xyz_sigma)
+        # xyz_clt_lvls = self.compute_multi_ch_covar(bigG, self.x_pyr,self.y_pyr,self.z_pyr)
+        if self.add_xyz == 'all':
+            xyz_clt_lvls, xyz_clt_map = [], []
+            for pyr in [self.x_pyr, self.y_pyr, self.z_pyr]:
+                clt_lvls = self.compute_variance(bigG, pyr)
+                clt_map = self.collapse(clt_lvls)
+                xyz_clt_lvls.append(clt_lvls)
+                xyz_clt_map.append(clt_map)
+        else:
+            xyz_clt_lvls = self.compute_variance(bigG, self.xyz_pyr)
+            xyz_clt_map = self.collapse(xyz_clt_lvls)
+
+        return xyz_clt_lvls, xyz_clt_map
+
+    def get_orientation_clutter(self):
+        """
+        Computes the orientation clutter map(s) of an image.
+        :return:
+            orient_clt_lvls: list of orientation clutter maps as multiple scales (specified by numLevels)
+            orient_clt_map: an array of same size as input image computed by taking the max of clutter maps at different
+            scales (i.e. combined map)
+        """
+        #  Compute clutter
+        orient_clt_lvls = self.compute_orientation_clutter()
+        orient_clt_map = self.collapse(orient_clt_lvls)
+
+        return orient_clt_lvls, orient_clt_map
+
+    def get_clutter(self, image):
+        """
+        Computes Feature Congestion clutter map(s) of an image.
+        :param image: Path to or the image of interest
+        :return: Clutter maps for each given feature
+        """
+        self.get_image(image)
+        # compute the color clutter
+        color_clt_lvls, color_clt_map = self.get_color_clutter()
+        # compute the contrast clutter
+        contrast_clt_lvls, contrast_clt_map = self.get_contrast_clutter()
+        # compute the orientation clutter
+        orient_clt_lvls, orientation_clt_map = self.get_orientation_clutter()
+
+        xyz_clutter = None
+        if self.add_xyz is not None:
+            xyz_clt_lvls, xyz_clt_map = self.get_xyz_clutter()
+            xyz_clutter = [xyz_clt_lvls, xyz_clt_map]
+
+        # output them in list structures
+        color_clutter = [color_clt_lvls, color_clt_map]
+        contrast_clutter = [contrast_clt_lvls, contrast_clt_map]
+        orientation_clutter = [orient_clt_lvls, orientation_clt_map]
+
+        return color_clutter, contrast_clutter, orientation_clutter, xyz_clutter
+
+    def get_image(self, image):
+        """
+        Loads and coverts the image to Lab image space
+        :param image: path to or image
+        :return: None
+        """
+
+        if isinstance(image, str):
+            image = cv2.imread(image)
+            image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
+
+        image_rgb = image[..., :3]
+        # image_rgb = cv2.cvtColor(image_rgb, cv2.COLOR_BGR2RGB)
+
+        # we first convert it into the perceptually-based CIELab color space.
+        Lab = RGB2Lab(image_rgb)
+
+        # luminance(L) and the chrominance(a,b) channels
+        l, a, b = cv2.split(Lab.astype(np.float32))
+        l_pyr_cof, a_pyr_cof, b_pyr_cof = {}, {}, {}
+
+        if self.add_xyz is not None:
+            if self.add_xyz == 'all':
+                assert image.shape[-1] >= 6
+                x_pyr_cof, y_pyr_cof, z_pyr_cof = {}, {}, {}
+                x, y, z = image[..., 3], image[..., 4], image[..., 5]
+            else:
+                xyz_pyr_cof = {}
+                idx = 3 if image.ndim == 4 else {'x': 3, 'y': 4, 'z': 5}[self.add_xyz]
+                xyz = image[...,idx]
+
+        # Get Gaussian pyramids (one for each of L,a,b)
+        for i in range(0, self.num_levels):
+            l_pyr_cof[(i, 0)] = cv2.pyrDown(l)
+            a_pyr_cof[(i, 0)] = cv2.pyrDown(a)
+            b_pyr_cof[(i, 0)] = cv2.pyrDown(b)
+            l = copy.deepcopy(l_pyr_cof[(i, 0)])
+            a = copy.deepcopy(a_pyr_cof[(i, 0)])
+            b = copy.deepcopy(b_pyr_cof[(i, 0)])
+            if self.add_xyz == 'all':
+                # key = (i,0)
+                key = i
+                x_pyr_cof[key] = cv2.pyrDown(x)
+                y_pyr_cof[key] = cv2.pyrDown(y)
+                z_pyr_cof[key] = cv2.pyrDown(z)
+                x = copy.deepcopy(x_pyr_cof[key])
+                y = copy.deepcopy(y_pyr_cof[key])
+                z = copy.deepcopy(z_pyr_cof[key])
+            elif self.add_xyz in ['x', 'y', 'z']:
+                key = i
+                xyz_pyr_cof[key] = cv2.pyrDown(xyz)
+                xyz = copy.deepcopy(xyz_pyr_cof[key])
+
+        self.L_pyr = l_pyr_cof
+        self.a_pyr = a_pyr_cof
+        self.b_pyr = b_pyr_cof
+        if self.add_xyz == 'all':
+            self.x_pyr = x_pyr_cof
+            self.y_pyr = y_pyr_cof
+            self.z_pyr = z_pyr_cof
+        elif self.add_xyz is not None:
+            self.xyz_pyr = xyz_pyr_cof
+
+    def get_fcm(self, image,
+                p=1, save_maps=False,
+                img_name="sample.png"):
+        """
+        Computes the Feature Congestion Measure (FCM) for visual clutter based on local variability of color, orientation,
+        and contrast
+        :param image: Path to or the image of interest
+        :param p: order of Minkowski distance (\\sigma (x-y)**p)**(1/p)
+        :param save_maps: whether to save the maps
+        :param img_name: path_to the image
+        :return:
+            fcm_scalar: the value of metric
+            fcm_map: clutter map which gives the information about local clutter information
+        """
+        color_clt, contrast_clt, orient_clt, xyz_clt = self.get_clutter(image)
+        fcm_map = (color_clt[1] / self.w_color + contrast_clt[1] / self.w_contrast +
+                   orient_clt[1] / self.w_orient)
+        if self.add_xyz is not None:
+            xyz_clt_val = None
+            if isinstance(xyz_clt[1],list):
+                for idx, cl in enumerate(xyz_clt[1]):
+                    if idx == 0:
+                        xyz_clt_val = cl/self.w_xyz
+                    else:
+                        xyz_clt_val += cl/self.w_xyz
+            else:
+                xyz_clt_val = xyz_clt[1]/self.w_xyz
+            fcm_map += xyz_clt_val
+
+        fcm_scalar = np.mean(fcm_map ** p) ** (1 / p)  # element wise
+
+        if save_maps:
+            save_root_fl = f"output/{os.path.dirname(img_name)}_maps"
+            os.makedirs(save_root_fl, exist_ok=True)
+            for k, v in {'color_map': color_clt[1], 'contrast_map': contrast_clt[1],
+                         'orient_map': orient_clt[1]}.items():
+                pil_image = Image.fromarray(normlize(v))
+                # save collapsed clutter map(s)
+                pil_image.save(os.path.join(save_root_fl, f"{os.path.basename(img_name).split('.')[0]}_{k}.png"))
+
+        return fcm_scalar, fcm_map
+
+
+
+def test_multiview(out_put_file='data_bases/test.pkl'):
+    root_folder = "sim_data_v2"
+    save_root_folder = f"output/{root_folder}"
+    os.makedirs(save_root_folder, exist_ok=True)
+
+    files_dic = parse_image_names(root_folder)
+
+    clt = VLC(num_levels=3, contrast_filt_sigma=1,
+              contrast_pool_sigma=3, color_pool_sigma=3,
+              w_color=0.220, w_contrast=0.0660, w_orient=0.0269,
+              add_xyz=None)
+
+    clt_xyz = VLC(num_levels=3, contrast_filt_sigma=1,
+                  contrast_pool_sigma=3, color_pool_sigma=3,
+                  w_color=0.220, w_contrast=0.0660, w_orient=0.0269,
+                  w_xyz=0.100, add_xyz='all')
+    # idx = 0
+    for task in files_dic:
+        # if task != 'GraspSingleOpenedCokeCanInScene':
+        #     continue
+        for cnt in files_dic[task]:
+            for variation in files_dic[task][cnt]:
+                # idx += 1
+                # if idx < 81:
+                #     continue
+                side_img = get_image_pkl(files_dic[task][cnt][variation]['side'])
+                top_img = get_image_pkl(files_dic[task][cnt][variation]['top'])
+                side_fc, _ = clt.get_fcm(side_img[...,:3], p=1, save_maps=False,
+                                         img_name=files_dic[task][cnt][variation]['side'])
+                side_fc_xyz, _ = clt_xyz.get_fcm(side_img, p=1, save_maps=False,
+                                                 img_name=files_dic[task][cnt][variation]['side'])
+                top_fc, _ = clt.get_fcm(top_img[...,:3], p=1, save_maps=False,
+                                        img_name=files_dic[task][cnt][variation]['side'])
+                # cv2.imshow('test', cv2.cvtColor(top_img[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR))
+                # cv2.waitKey(0)
+                # Do xyz version
+                top_fc_xyz, _ = clt_xyz.get_fcm(top_img, p=1, save_maps=False,
+                                                img_name=files_dic[task][cnt][variation]['side'])
+                files_dic[task][cnt][variation]['scores'] = {
+                    'fc_s': side_fc, 'fc_t': top_fc, 'fc_avg':np.mean([side_fc, top_fc]),
+                    'fcx_s': side_fc_xyz, 'fcx_t': top_fc_xyz, 'fcx_avg':np.mean([side_fc_xyz, top_fc_xyz])}
+                print(files_dic[task][cnt][variation]['side'],
+                      side_fc, top_fc, np.mean([side_fc, top_fc]),
+                      side_fc_xyz, top_fc_xyz, np.mean([side_fc_xyz, top_fc_xyz]))
+    os.makedirs(os.path.dirname(out_put_file), exist_ok=True)
+    with open(out_put_file, 'wb') as f:
+        pickle.dump(files_dic, f, pickle.HIGHEST_PROTOCOL)
+    return files_dic, out_put_file
+
+def test_sorting_xyz(root_folder ="sim_data",
+                     db_root= "data_bases/test.pkl",
+                     gen_images=True):
+    save_root_folder = f"output/{root_folder}_multi_combined"
+    os.makedirs(save_root_folder, exist_ok=True)
+    with open(db_root, 'rb') as f:
+        res_dict = pickle.load(f)
+    stats = []
+    for task in res_dict:
+        skeys = res_dict[task][1][0]['scores'].keys()
+        var_dict = get_dict_variation(res_dict[task])
+        for v in var_dict:
+            log_stat = False
+            for sort_key in skeys:
+                idxs = sort_images_target(var_dict[v], sort_key)
+                fimg = None
+                h_image = []
+                for i, idx in enumerate(idxs):
+                    image_dic = var_dict[v][idx+1]
+                    text1 = (f"fcm_s: {image_dic['scores']['fc_s']:.2},  fcm_t: {image_dic['scores']['fc_t']:.2}, "
+                             f"fcm_avg: {image_dic['scores']['fc_avg']:.3}")
+                    text2 = (f"fcmx_s: {image_dic['scores']['fcx_s']:.2},  fcmx_t: {image_dic['scores']['fcx_t']:.2}, "
+                             f"fcmx_avg: {image_dic['scores']['fcx_avg']:.3}")
+                    if not log_stat:
+                        stats.append(f"{task}, {v}, {idx+1}, {image_dic['scores']['fc_s']:.4}, {image_dic['scores']['fc_t']:.4},"
+                                     f"{image_dic['scores']['fc_avg']:.4}, {image_dic['scores']['fcx_s']:.4},"
+                                     f"{image_dic['scores']['fcx_t']:.4},{image_dic['scores']['fcx_avg']:.4}\n")
+                    if gen_images:
+                        im = get_image_pkl(image_dic['im'])
+                        im = cv2.cvtColor(im[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+                        im = cv2.resize(im, (320, 240), im)
+
+                        im = cv2.putText(im, text1,
+                                         (0, im.shape[0] - 30),
+                                         cv2.FONT_HERSHEY_SIMPLEX,
+                                         0.5, (255, 0, 255), 1)
+                        im = cv2.putText(im, text2,
+                                         (0, im.shape[0] - 10),
+                                         cv2.FONT_HERSHEY_SIMPLEX,
+                                         0.5, (255, 165, 0), 1)
+                        im = cv2.putText(im, f"{idx+1}",
+                                         (0, 30),
+                                         cv2.FONT_HERSHEY_SIMPLEX,
+                                         1, (255, 165, 0), 2)
+                    if gen_images:
+                        if i == 5:
+                            h_image.append(fimg)
+                        if i == 0 or i == 5:
+                            fimg = im
+                        else:
+                            fimg = cv2.hconcat([fimg, im])
+                if gen_images:
+                    h_image.append(fimg)
+                    fimg = cv2.vconcat(h_image)
+                    img_name = os.path.join(root_folder, f"{task}_{v}_{sort_key}") + '.png'
+                    cv2.imwrite(os.path.join(save_root_folder, os.path.basename(img_name)), fimg)
+                log_stat = True
+    write_stats(heading="task, variation, count, fcm_s, fcm_t, fcm_avg, fcmx_s, fcmx_t, fcmx_avg",
+                stats_list=stats, file_name= os.path.join(save_root_folder, 'stats_sim_v2.csv'))
+
+def test_multiview_real(root_folder="real_samples",
+                        db_root="data_bases/real_db.pkl"):
+    subset = "removal_clean"
+    camera = 'side'
+    root_folder = f"{root_folder}/{subset}/{camera}"
+    save_root_folder = f"output/{root_folder}_multi"
+
+    os.makedirs(save_root_folder, exist_ok=True)
+
+    files = os.listdir(root_folder)
+    clt = VLC(num_levels=3, contrast_filt_sigma=1,
+              contrast_pool_sigma=3, color_pool_sigma=3,
+              w_color=0.220, w_contrast=0.0660, w_orient=0.0269,
+              add_xyz=None)
+
+    sc_dict = {}
+    for f in files:
+        if 'pkl' not in f or 'reset' in f:
+            continue
+        side_fname = os.path.join(root_folder, f)
+        side_img = get_real_image(side_fname)
+        top_img = get_real_image(side_fname.replace('side', 'tall'))
+
+        side_img = cv2.cvtColor(side_img[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+        top_img = cv2.cvtColor(top_img[..., :3].astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+        # os.rename(img_name, os.path.join(root_folder, f"{count}.png"))
+        side_fc, _ = clt.get_fcm(side_img, p=1, save_maps=False, img_name=f)
+        top_fc, _ = clt.get_fcm(top_img, p=1, save_maps=False, img_name=f)
+        sc_id = f.split('_')[0]
+        if sc_id not in sc_dict:
+            sc_dict[sc_id] = []
+
+        image_dic = {'im': side_fname, 'fcm_s': side_fc, 'fcm_t': top_fc,
+                     'fcm_avg': np.mean([side_fc, top_fc])}
+        sc_dict[sc_id].append(image_dic)
+        # Do xyz version
+        print(image_dic['fcm_s'],image_dic['fcm_t'], image_dic['fcm_avg'])
+
+    with open(db_root, 'wb') as f:
+        pickle.dump(sc_dict, f, pickle.HIGHEST_PROTOCOL)
+    return root_folder
+
+def test_sorting_real(root_folder="real_samples",
+                      db_root= "data_bases/real_db.pkl",
+                      skeys=('fcm_s', 'fcm_t', 'fcm_avg'),
+                      gen_images= True):
+    save_root_folder = f"output/{root_folder}_multi_combined"
+    os.makedirs(save_root_folder, exist_ok=True)
+    with open(db_root, 'rb') as f:
+        sc_dict = pickle.load(f)
+    stats = []
+    for scid, sc_list in sc_dict.items():
+        h_image = []
+        log_stat = False
+        for sort_key in skeys:
+            idxs = sort_images_real(sc_list, sort_key)
+            fimg = None
+            for i, idx in enumerate(idxs):
+                image_dic = sc_list[idx]
+                # for writing the scores on the image
+                text1 = (f"fcm_s: {image_dic['fcm_s']:.2},  fcm_t: {image_dic['fcm_t']:.2}, "
+                         f"fcm_avg: {image_dic['fcm_avg']:.3}")
+                img_id = os.path.basename(image_dic['im']).split('_')[1]
+                if not log_stat:
+                    stats.append(f"{scid}, {img_id}, {image_dic['fcm_s']:.4}, {image_dic['fcm_t']:.4},"
+                                 f"{image_dic['fcm_avg']:.4}\n")
+
+                if gen_images:
+                    im = get_real_image(image_dic['im'])[..., :3] if 'pkl' in image_dic['im'] else \
+                    cv2.imread(image_dic['im'])
+                    im = cv2.cvtColor(im.astype(np.uint8), cv2.COLOR_RGB2BGR)
+                    im = cv2.resize(im, (320, 240), im)
+                    im = cv2.putText(im, img_id,
+                                     (0, 30),
+                                     cv2.FONT_HERSHEY_SIMPLEX,
+                                     1, (255, 100, 0), 2)
+                    im = cv2.putText(im, text1,
+                                     (0, im.shape[0] - 10),
+                                     cv2.FONT_HERSHEY_SIMPLEX,
+                                     0.5, (255, 0, 255), 1)
+                    fimg = im if i == 0 else cv2.hconcat([fimg, im])
+
+            if gen_images:
+                h_image.append(fimg)
+            log_stat = True
+
+        if gen_images:
+            fimg = cv2.vconcat(h_image)
+            img_name = os.path.join(root_folder, f"{scid}_{'-'.join(skeys)}") + '.png'
+            cv2.imwrite(os.path.join(save_root_folder, os.path.basename(img_name)), fimg)
+    write_stats(heading="scid, imgid, fcm_s, fcm_t, fcm_avg",
+                stats_list=stats, file_name= os.path.join(save_root_folder, 'stats.csv'))
+
+root = "camera_pointcloud_recolor_2_v4"
+# files = os.listdir(root)
+
+def test_multiview_target(out_put_file='data_bases/recolor.pkl'):
+    root_folder = "camera_pointcloud_recolor_2_v4"
+    save_root_folder = f"output/{root_folder}"
+    os.makedirs(save_root_folder, exist_ok=True)
+
+    # files_dic = parse_image_names(root_folder)
+
+    clt_xyz = VLC(num_levels=3, contrast_filt_sigma=1,
+                  contrast_pool_sigma=3, color_pool_sigma=3,
+                  w_color=0.220, w_contrast=0.0660, w_orient=0.0269,
+                  w_xyz=0.100, add_xyz='all')
+
+    files_dic = {}
+    for task in os.listdir(root_folder):
+        files_dic[task] = {}
+        for f in os.listdir((os.path.join(root_folder, task))):
+            if 'pkl' not in f:
+                continue
+            key = None
+            if '_wo_' in f:
+                key = 'wot'
+            else:
+                key = 't'
+            if key not in files_dic[task]:
+                files_dic[task][key] = {'top': None, 'side': None}
+
+            if 'top' in f:
+                files_dic[task][key]['top'] = os.path.join(root_folder, task, f)
+            else:
+                files_dic[task][key]['side'] = os.path.join(root_folder, task, f)
+
+
+    # idx = 0
+    for task in files_dic:
+
+        side_img = get_image_pkl(files_dic[task]['t']['side'])
+        top_img = get_image_pkl(files_dic[task]['t']['top'])
+        side_fc, _ = clt_xyz.get_fcm(side_img, p=1, save_maps=False,
+                                         img_name=files_dic[task]['t']['side'])
+        top_fc, _ = clt_xyz.get_fcm(top_img, p=1, save_maps=False,
+                                    img_name=files_dic[task]['t']['side'])
+
+        side_img_wot = get_image_pkl(files_dic[task]['wot']['side'])
+        top_img_wot = get_image_pkl(files_dic[task]['wot']['top'])
+        side_fc_wot, _ = clt_xyz.get_fcm(side_img_wot, p=1, save_maps=False,
+                                         img_name=files_dic[task]['t']['side'])
+        top_fc_wot, _ = clt_xyz.get_fcm(top_img_wot, p=1, save_maps=False,
+                                    img_name=files_dic[task]['t']['side'])
+        sc_wot = np.mean([side_fc_wot, top_fc_wot])
+        sc_t = np.mean([side_fc, top_fc])
+        print(f"wot: {sc_wot}, t: {sc_t}, delta: {sc_t - sc_wot}")
+        os.makedirs(os.path.dirname(save_root_folder), exist_ok=True)
+        side_img_t = side_img[...,:3][...,[2,1,0]].astype(np.uint8)
+        side_img_wot = side_img_wot[...,:3][...,[2,1,0]].astype(np.uint8)
+        simg = cv2.hconcat([side_img_wot, side_img_t])
+        im = cv2.putText(simg, f"wot: {sc_wot}, t: {sc_t}, delta: {sc_t - sc_wot}",
+                         (0, simg.shape[0] - 10),
+                         cv2.FONT_HERSHEY_SIMPLEX,
+                         1, (255, 0, 0), 1)
+        cv2.imwrite(os.path.join(save_root_folder, f"{task}.png"),im)
+
+        # Do xyz version
+    #
+    #     files_dic[task]['scores'] = {
+    #         'fc_s': side_fc, 'fc_t': top_fc, 'fc_avg':np.mean([side_fc, top_fc]),
+    #         'fcx_s': side_fc_xyz, 'fcx_t': top_fc_xyz, 'fcx_avg':np.mean([side_fc_xyz, top_fc_xyz])}
+    #     print(files_dic[task][cnt][variation]['side'],
+    #           side_fc, top_fc, np.mean([side_fc, top_fc]),
+    #           side_fc_xyz, top_fc_xyz, np.mean([side_fc_xyz, top_fc_xyz]))
+    # os.makedirs(os.path.dirname(out_put_file), exist_ok=True)
+    # with open(out_put_file, 'wb') as f:
+    #     pickle.dump(files_dic, f, pickle.HIGHEST_PROTOCOL)
+    # return files_dic, out_put_file
+
+# test_multiview(out_put_file='data_bases/sim_sample_v2.pkl')
+# test_sorting_xyz(root_folder="sim_data_v2",
+#                  db_root= "data_bases/sim_sample_v2.pkl", gen_images=False)
+# test_multiview_real()
+# test_sorting_real(gen_images=True)
+# test_rgb_real()
+# test_xyz()
+# test_depth()
+# test_average()
+# test_sorting()
+
+# test_multiview_target()
+
+# for i, fold in enumerate(files):
+#     os.rename(os.path.join(root, fold), os.path.join(root, f"{i}"))
+# for fold in files:
+#     fold_files = os.listdir(os.path.join(root, fold))
+#     for fi in fold_files:
+#         if 'pkl' not in fi:
+#             continue
+#         img = side_img = get_image_pkl(os.path.join(root, fold, fi))
+#         cv2.imshow("dool", img[...,:3][...,[2,1,0]] .astype(np.uint8))
+#         cv2.waitKey(0)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/inference_recorder.py

@@ -0,0 +1,94 @@
+import time
+import os
+import pickle
+
+class InferenceRecorder:
+    def __init__(self, save_dir):
+        self.save_dir = save_dir
+        self.timestamp = time.strftime("%m%d_%H%M")
+        self.recording_dir = os.path.join(save_dir, f"recording_{self.timestamp}")
+        os.makedirs(self.recording_dir, exist_ok=True)
+        self.current_episode = 0
+        self.episode_data = []
+            
+    def record_step(self, obs, 
+                    trajectory_prior,
+                    all_samples=None, 
+                    planned_path=None):
+        # Record data for the current step
+        data = {
+            'observation': obs,
+            'trajectory_prior': trajectory_prior,
+            'all_samples': all_samples, #unnormalized result from policy(obs, trajectory_prior) 
+            'planned_path': planned_path, #unnormalized result from policy(obs, trajectory_prior) 
+            'episode': self.current_episode,
+        }
+        self.episode_data.append(data)
+        
+    def save_episode(self):
+        # Save episode data (similar to DataRecorder.save_episode)        
+        # Create episode directory
+        # Save episode data directly to the recording directory with episode number in filename
+        episode_file = os.path.join(self.recording_dir, f"episode_{self.current_episode}.pkl")
+        with open(episode_file, 'wb') as f:
+            pickle.dump(self.episode_data, f)
+        
+        print(f"Saved episode {self.current_episode} data to {episode_file}")
+        
+        # Reset for next episode
+        self.episode_data = []
+        self.current_step = 0
+        self.current_episode += 1
+
+class ReplayRecorder:
+    def __init__(self, replay_dir):
+        self.replay_dir = replay_dir
+        self.episode_files = sorted([f for f in os.listdir(replay_dir) if f.endswith('.pkl')])
+        self.total_episodes = len(self.episode_files)
+        print(f"Found {self.total_episodes} episode recordings in {replay_dir}")
+        self.current_episode = 0
+        self._load_episode(self.current_episode)
+
+    def _load_episode(self, episode_id):
+        episode_file = os.path.join(self.replay_dir, f"episode_{episode_id}.pkl")
+        with open(episode_file, 'rb') as f:
+            self.current_episode_data = pickle.load(f)
+        self.current_step = 0
+    
+    def set_episode(self, episode_id):
+        self.current_episode = episode_id
+        self._load_episode(self.current_episode)
+
+    def next_step(self):
+        if self.current_step >= len(self.current_episode_data):
+            print(f"Episode {self.current_episode} finished")
+            self.current_episode += 1
+            if self.current_episode >= self.total_episodes:
+                print("All episodes finished")
+                return None, None, None, None
+            self.current_step = 0
+            self._load_episode(self.current_episode)
+
+        # Get observation from current step
+        obs = self.current_episode_data[self.current_step]['observation']
+        trajectory_prior = self.current_episode_data[self.current_step]['trajectory_prior']
+        planned_path = self.current_episode_data[self.current_step]['planned_path']
+
+        is_last_step = (self.current_step == len(self.current_episode_data) - 1)
+        done = is_last_step
+        # print("current step: ", self.current_step)
+        # print("is last step: ", is_last_step)
+        # print("length of current episode data: ", len(self.current_episode_data))
+        self.current_step += 1
+        return obs, trajectory_prior, done, planned_path, 
+
+
+if __name__ == "__main__":
+    recorder = ReplayRecorder(replay_dir="/home/xuan/Code/maniskill2_benchmark/inference_recordings/recording_0414_1723")
+    for _ in range(175):
+        obs, _, done, _ = recorder.next_step()
+        print(obs['extra']['tcp_pose'].shape)
+        print(done)
+
+    
+    

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/object_placement_2.py

@@ -0,0 +1,101 @@
+# Updated API calls
+"""Extracted object placement algorithm."""
+
+from dataclasses import dataclass
+from typing import List, Tuple
+
+import numpy as np
+import sapien.core as sapien
+import torch
+
+
+@dataclass(frozen=True)
+class ObjectBoundingBox:
+    min: tuple[float, float, float]
+    max: tuple[float, float, float]
+
+
+@dataclass(frozen=True)
+class PlacementBounds:
+    low: tuple[float, float]
+    high: tuple[float, float]
+    size: tuple[int, ...]
+
+    def random_in(self, rng: np.random.RandomState):
+        return rng.uniform(self.low, self.high, size=self.size)
+
+def is_overlapping(bb1_min, bb1_max, bb2_min, bb2_max, pos1, pos2, padding=0.05, check_z=False):
+    # Translate bounding boxes based on positions
+    bb1_min_trans = np.add(bb1_min, pos1) - padding
+    bb1_max_trans = np.add(bb1_max, pos1) + padding
+    bb2_min_trans = np.add(bb2_min, pos2) - padding
+    bb2_max_trans = np.add(bb2_max, pos2) + padding
+    
+    # Check for overlap in each dimension
+    overlap_x = not (bb1_max_trans[0] < bb2_min_trans[0] or bb2_max_trans[0] < bb1_min_trans[0])
+    overlap_y = not (bb1_max_trans[1] < bb2_min_trans[1] or bb2_max_trans[1] < bb1_min_trans[1])
+    overlap_z = False
+    if check_z:
+        overlap_z = not (bb1_max_trans[2] < bb2_min_trans[2] or bb2_max_trans[2] < bb1_min_trans[2])
+        return overlap_x and overlap_y and overlap_z
+    
+    return overlap_x and overlap_y
+
+
+def find_valid_position_2d(
+    placement_bounds: PlacementBounds,
+    actor: sapien.Entity,
+    actor_local_bbox: ObjectBoundingBox,
+    placed_objects: List[Tuple[sapien.Entity, ObjectBoundingBox]],
+    rng: np.random.RandomState,
+    retries: int,
+    minimum_aabb_separation: float = 0.005
+) -> tuple[float, float]:
+    """Bounding box is for cached collision check."""
+    attempt = 0
+
+    half_obj_xy_dim = 0.5 * (actor_local_bbox.max - actor_local_bbox.min)[:2]
+    assert (
+        np.linalg.norm(half_obj_xy_dim)
+        < np.linalg.norm(np.subtract(placement_bounds.high, placement_bounds.low))
+    ), "Surface is much smaller than object"
+
+    low_bounds = placement_bounds.low + half_obj_xy_dim
+    high_bounds = placement_bounds.high - half_obj_xy_dim
+    size = placement_bounds.size
+
+    while attempt < 1 + retries:
+        xy = rng.uniform(low_bounds, high_bounds, size=size)
+
+        overlap_found = False
+        for obj, bbox in placed_objects:
+            # Convert pose to numpy safely
+            obj_pos = obj.pose.p
+            if isinstance(obj_pos, torch.Tensor):
+                obj_pos = obj_pos.detach().cpu().numpy().reshape(-1)
+            else:
+                obj_pos = np.array(obj_pos, dtype=float).reshape(-1)
+
+            if is_overlapping(
+                bbox.min,
+                bbox.max,
+                actor_local_bbox.min,
+                actor_local_bbox.max,
+                np.pad(xy, (0, 1)),   # add z=0
+                obj_pos,
+                padding=0.5 * minimum_aabb_separation,
+                check_z=False
+            ):
+                overlap_found = True
+                break
+
+        if not overlap_found:
+            return xy
+        attempt += 1
+
+    return None
+
+
+
+def level_to_surface(surface_height: float, bbox: ObjectBoundingBox):
+    return surface_height + 0.5 * -bbox.min[2] + 0.05

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/observation_wrapper.py

@@ -0,0 +1,231 @@
+# wrap observation for inference usage
+import numpy as np
+import torch
+from cfdp.utils.pointcloud_utils import convertRGBD2PCD
+from cfdp.utils.plot_utils import visualize_rgbd_and_pointcloud
+from cfdp.utils.data_utils import ObsQueue, transform_quat_to_ortho6d, transform_ortho6d_to_quat
+
+class ObservationWrapper:
+    def __init__(self, dataset, camera_type="world", sensor_data_key="image", sensor_param_key="camera_param"):
+        self.dataset = dataset
+        self._processed_obs = {'hard_conds': None, 'context': None, 'environment': None}
+        self.device = dataset.device
+        self.camera_type = camera_type
+        self.sensor_data_key = sensor_data_key
+        self.sensor_param_key = sensor_param_key
+
+    def _transform_positions_to_world(self, obs, camera_type="hand_camera"):
+        """
+        Transform position coordinates from camera frame to world frame for both cameras.
+        
+        Args:
+            obs (dict): Observation dictionary containing camera parameters and images
+            
+        Returns:
+            dict: Updated observation dictionary with transformed positions
+        """
+        point_cloud = {}
+        # Get position data and reshape to (N, 3)
+        # pos = obs[self.sensor_data_key][camera_type]['Position'][:,:,:3]
+        pos = obs[self.sensor_data_key][camera_type]['position'][:,:,:3]
+        if isinstance(pos, torch.Tensor):
+            pos = pos.cpu().numpy()
+        pos = pos.reshape(-1, 3)
+        
+        # Get camera to world transformation matrix
+        cam2world = obs[self.sensor_param_key][camera_type]['cam2world_gl']
+        
+        # Convert to homogeneous coordinates by adding 1 as fourth coordinate
+        pos_homog = np.ones((pos.shape[0], 4))
+        pos_homog[:, :3] = pos
+        
+        # Transform to world frame
+        pos_world = (cam2world @ pos_homog.T).T  # Matrix multiplication and transpose
+        point_cloud[camera_type] = pos_world[:, :3]
+
+        return point_cloud
+
+    #TODO: optimize calculation speed
+    def clip_point_cloud_with_boxes(self, point_cloud, world_range, 
+                                    tcp_pose, goal_pose, 
+                                    box_size=0.1, original_shapes=None):
+        """
+        Efficiently clip point cloud using world range and bounding boxes around TCP and goal poses.
+        
+        Args:
+            point_cloud: Dictionary of point clouds for each camera
+            world_range: Global clipping range
+            tcp_pose: TCP pose [x, y, z, ...]
+            goal_pose: Goal pose [x, y, z, ...]
+            box_size: Size of the bounding box around poses (default: 0.2 meters)
+            original_shapes: Original image shapes (for visualization crop)
+        """
+        clipped_point_cloud = {}
+        valid_masks = {}
+        
+        half_size = box_size / 2
+        
+        for camera, points in point_cloud.items():
+            # World range mask - compute all axes at once
+            world_mins = np.array([world_range['x'][0], world_range['y'][0], world_range['z'][0]])
+            world_maxs = np.array([world_range['x'][1], world_range['y'][1], world_range['z'][1]])
+            
+            if isinstance(points, torch.Tensor):
+                points = points.cpu().numpy()
+
+            world_mask = np.all((points[:, :3] >= world_mins) & (points[:, :3] <= world_maxs), axis=1)
+            
+            # TCP and goal box masks - compute all axes at once
+            tcp_mins = tcp_pose[:3] - half_size
+            tcp_maxs = tcp_pose[:3] + half_size
+            goal_mins = goal_pose[:3] - half_size
+            goal_maxs = goal_pose[:3] + half_size
+
+            if isinstance(tcp_mins, torch.Tensor):
+                tcp_mins = tcp_mins.cpu().numpy()
+            if isinstance(tcp_maxs, torch.Tensor):
+                tcp_maxs = tcp_maxs.cpu().numpy()
+            if isinstance(goal_mins, torch.Tensor):
+                goal_mins = goal_mins.cpu().numpy()
+            if isinstance(goal_maxs, torch.Tensor):
+                goal_maxs = goal_maxs.cpu().numpy()
+            
+            # print("tcp_pose shape: ", tcp_pose.shape)
+            # print("tcp mins shape: ", tcp_mins.shape)
+            # print("tcp maxs shape: ", tcp_maxs.shape)
+            # print("goal mins shape: ", goal_mins.shape)
+            # print("goal maxs shape: ", goal_maxs.shape)
+            
+            # Invert the TCP and goal masks to exclude points within these boxes
+            tcp_mask = ~np.all((points[:, :3] >= tcp_mins) & (points[:, :3] <= tcp_maxs), axis=1)
+            goal_mask = ~np.all((points[:, :3] >= goal_mins) & (points[:, :3] <= goal_maxs), axis=1)
+            
+            # # Combine masks: keep points that are within world bounds AND outside both TCP and goal boxes
+            # print("world_mask shape: ", world_mask.shape)
+            # print("tcp_mask shape: ", tcp_mask.shape)
+            # print("goal_mask shape: ", goal_mask.shape)
+
+            final_mask = world_mask & tcp_mask & goal_mask
+            
+            clipped_point_cloud[camera] = points[final_mask]
+            if original_shapes is not None:
+                valid_masks[camera] = final_mask.reshape(original_shapes[0], original_shapes[1])
+            else:
+                valid_masks[camera] = None
+        return clipped_point_cloud, valid_masks
+
+    def crop_rgb_with_mask(self, rgb_image, mask):
+        return rgb_image[mask]
+
+    def _process_point_cloud(self, obs, point_cloud, camera_type):
+        """
+        Process point cloud by clipping with world range and bounding boxes.
+        
+        Args:
+            obs: Observation dictionary
+            point_cloud: Dictionary of point clouds for each camera
+            camera_type: Type of camera ('world', 'base_camera', etc.)
+            
+        Returns:
+            tuple: Processed point cloud and cropped colors (if applicable)
+        """
+        tcp_pose = obs['extra']['tcp_pose']
+        goal_pose = obs['extra']['goal_pose']
+        clip_range = {
+            'x': (-0.25, 1.5),
+            'y': (-1.0, 1.0),
+            'z': (-0.01, 0.8)
+        }
+        
+        cropped_colors = None
+        
+        if camera_type == 'world':
+            point_cloud, valid_masks = self.clip_point_cloud_with_boxes(point_cloud, 
+                                                         clip_range, 
+                                                         tcp_pose, 
+                                                         goal_pose,
+                                                         box_size=0.08,
+                                                         original_shapes=None)
+        else:
+            point_cloud, valid_masks = self.clip_point_cloud_with_boxes(point_cloud, 
+                                                            clip_range, 
+                                                            tcp_pose, 
+                                                            goal_pose,
+                                                            box_size=0.08,
+                                                            original_shapes=obs[self.sensor_data_key][camera_type]['rgb'].shape[:2])
+            # Crop RGB images according to valid masks
+            if valid_masks is not None:
+                cropped_colors = {}
+                for camera in point_cloud.keys():
+                    # rgb_image = obs[self.sensor_data_key][camera]['Color'][:,:,:3]
+                    rgb_image = obs[self.sensor_data_key][camera]['rgb'][:,:,:3]
+                    cropped_colors[camera] = self.crop_rgb_with_mask(rgb_image, valid_masks[camera])
+        # visualize_rgbd_and_pointcloud(obs[self.sensor_data_key][camera_type]['Color'][:,:,:3], 
+        #                               obs[self.sensor_data_key][camera_type]['Position'][:,:,3], 
+        #                               point_cloud[camera_type], 
+        #                               cropped_colors[camera_type])
+
+        # print(obs_pointcloud['base_camera'].shape)
+        # print(obs_pointcloud['hand_camera'].shape)
+        # from cfdp.utils.pointcloud_utils import visualize_cloud_with_axes
+        # # visualize_cloud_with_axes(point_cloud['world'])
+        return point_cloud, cropped_colors
+
+    def update_observation(self, obs):
+        hard_conds = self.dataset.get_hard_conds(obs, do_normalize=True)
+        context = self.dataset.get_context(obs, do_normalize=True)
+        if 'obstacle_point_cloud' in obs['extra'] and self.camera_type == 'world':
+            point_cloud = {'world': obs['extra']['obstacle_point_cloud']}
+        else:
+            point_cloud = self._transform_positions_to_world(obs, camera_type=self.camera_type)
+
+        if point_cloud is not None:
+            point_cloud, _ = self._process_point_cloud(obs, point_cloud, self.camera_type)
+            self._processed_obs['point_cloud'] = point_cloud[self.camera_type]
+        else:
+            self._processed_obs['point_cloud'] = None
+        
+        self._processed_obs['hard_conds'] = hard_conds
+        self._processed_obs['context'] = context
+        return self._processed_obs
+    
+    def get_processed_obs(self):
+        return self._processed_obs
+    
+    def reset(self):
+        self._processed_obs = {'hard_conds': None, 'context': None, 'environment': None}
+
+
+class ObservationWrapperWithHistory(ObservationWrapper):
+    def __init__(self, dataset, camera_type="world", use_ee_control=True, sensor_data_key="image", sensor_param_key="camera_param"):
+        super().__init__(dataset, camera_type, sensor_data_key=sensor_data_key, sensor_param_key=sensor_param_key)
+        self.history_length = dataset.history_length
+        self.history_buffer = []
+        self.obsqueue = ObsQueue(size=self.history_length, obs=None)
+        self.use_ee_control = use_ee_control
+
+    def update_history_buffer(self, obs):
+        if self.use_ee_control:
+            self.obsqueue.append(transform_quat_to_ortho6d(torch.tensor(obs['extra']['tcp_pose'], dtype=torch.float32).to(self.device)))
+        else:
+            self.obsqueue.append(torch.tensor(obs['agent']['qpos'], dtype=torch.float32).to(self.device))
+
+    def update_observation(self, obs):
+        self.update_history_buffer(obs)
+        hard_conds = self.dataset.get_hard_conds(obs, do_normalize=True)
+        context = self.dataset.get_context(obs, obsqueue=self.obsqueue, do_normalize=True)
+        if 'obstacle_point_cloud' in obs['extra'] and self.camera_type == 'world':
+            point_cloud = {'world': obs['extra']['obstacle_point_cloud']}
+        else:
+            point_cloud = self._transform_positions_to_world(obs, camera_type=self.camera_type)
+        
+        if point_cloud[self.camera_type] is not None:
+            point_cloud, _ = self._process_point_cloud(obs, point_cloud, self.camera_type)
+            self._processed_obs['point_cloud'] = point_cloud[self.camera_type]
+        else:
+            self._processed_obs['point_cloud'] = None
+
+        self._processed_obs['hard_conds'] = hard_conds
+        self._processed_obs['context'] = context
+        return self._processed_obs
+        

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/pointcloud_sdf.py

@@ -0,0 +1,180 @@
+# General imports
+import logging
+import numpy as np
+import random
+import time
+from typing import Union
+
+# NN imports
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from cfdp.utils.chamfer import ChamferDistance
+
+# Set seeds for reproducibility
+def set_seed(seed=42):
+    """
+    Set seeds for NumPy, PyTorch, and Python's random module for reproducibility.
+    
+    :param seed: The seed value to use (default: 42)
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    torch.cuda.manual_seed_all(seed)
+    torch.backends.cudnn.deterministic = True
+    torch.backends.cudnn.benchmark = False
+
+
+class PointCloud_CSDF(nn.Module):
+    def __init__(
+        self,
+        pcd: Union[np.ndarray, None],
+        sphere_radius: float = 0.05,
+        max_distance: float = None,
+        device: str = 'cuda'
+    ):
+        
+        """
+        Brute force estimation of SDF for a point cloud.
+        
+        :param pcd: N x 3 numpy array describing the point cloud
+        :param sphere_radius: Radius of sphere enclosing each point in the point cloud
+        :param max_distance: Maximum distance beyond which we don't need gradients
+        :param device: Device to load the point cloud
+        """
+        
+        super().__init__()
+        
+        self._device = device
+        self._sphere_radius = sphere_radius
+        self._max_distance = max_distance
+        
+        if pcd is not None:
+            self.pcd = torch.from_numpy(pcd).float().to(self._device)
+        else:
+            self.pcd = None
+        
+        self.chamfer_distance = ChamferDistance()
+    
+    def update_pcd(self, pcd: np.ndarray):
+
+        """
+        Function for updating the internal point cloud.
+        
+        :param pcd: N x 3 numpy array describing the point cloud
+        """
+
+        self.pcd = torch.from_numpy(pcd).float().to(self._device)
+    
+    def compute_distances(self, x: torch.Tensor):
+
+        """
+        Function for computing the distances of passed points to the internally saved point cloud.
+        
+        :param x: batch_size x num_points x 3 query points
+        :returns: batch_size x num_points distance values
+        """
+
+        # Save shape features of input (batch_size x num_points x 3)
+        batch_size = x.shape[0]
+        num_points = x.shape[1]
+        
+        # Compute distance (ChamferDistance returns the squared distance between the point clouds)
+        dist_x_to_pcd, _ = self.chamfer_distance(x.reshape(-1, 3).unsqueeze(0), self.pcd.unsqueeze(0))
+        dist_x_to_pcd = torch.sqrt(dist_x_to_pcd.reshape((batch_size, num_points))) - self._sphere_radius
+
+        return dist_x_to_pcd
+
+        
+    def forward(self, x: torch.Tensor):
+        """
+        Function for returning C-SDF values of passed points to the internally saved point cloud.
+        With clipping at max_distance to prevent gradients beyond that distance.
+        
+        :param x: batch_size x num_points x 3 query points
+        :returns: batch_size C-SDF values
+        """
+        # Maximum distance beyond which we don't need gradients
+        # Compute distances
+        dist_x_to_pcd = self.compute_distances(x)
+        
+        if self._max_distance is not None:
+            # Clip the distances to max_distance
+            # This creates a flat region in the SDF beyond max_distance
+            clipped_distances = torch.minimum(dist_x_to_pcd, torch.tensor(self._max_distance, device=self._device))
+        else:
+            clipped_distances = dist_x_to_pcd
+        # print("clipped_distances: ", clipped_distances)
+        
+        return clipped_distances
+    
+def running_avg(tensor, window_size):
+    """
+    Computes running average using PyTorch's conv1d operation.
+    
+    :param tensor: Input tensor of shape [batch_size, seq_len, dim]
+    :param window_size: Size of the sliding window
+    :return: Tensor with same shape as input, containing running averages
+    """
+    # PyTorch doesn't have a direct convolve function like numpy
+    # Need to handle batch dimensions properly for trajectory data
+    batch_size, seq_len, dim = tensor.shape
+    result = torch.zeros_like(tensor)
+    
+    # Create the kernel for the running average
+    kernel = torch.ones(window_size, device=tensor.device) / window_size
+    
+    # Apply running average to each dimension separately
+    for b in range(batch_size):
+        for d in range(dim):
+            # Use 1D convolution for running average
+            # F.conv1d expects input shape [batch, channels, length]
+            padded = torch.nn.functional.pad(tensor[b, :, d].unsqueeze(0).unsqueeze(0), 
+                                            (window_size-1, 0), mode='reflect')
+            convolved = torch.nn.functional.conv1d(padded, 
+                                                  kernel.view(1, 1, -1))
+            result[b, :, d] = convolved.squeeze()
+    
+    return result
+
+if __name__ == "__main__":
+    # Set seed for reproducibility
+    set_seed(42)
+    
+    DEVICE = "cuda"
+    CONTROL_POINTS = 8
+    
+    
+    # pcd = np.load('/home/vasileiosv/scene_pcd.npy')
+    pcd = np.random.rand(1000,3)
+
+    model = PointCloud_CSDF(sphere_radius=0.01, max_distance=0.2, pcd=pcd, device=DEVICE)
+    model.eval()
+    model.to(DEVICE)
+    
+    points = torch.rand((2, CONTROL_POINTS, 3), device=DEVICE, requires_grad=True)
+    # print("points:", points)
+    since = time.time()
+    model.update_pcd(pcd)
+    
+    # with torch.no_grad():
+    sdf_values = model(points)
+    print(f'Total time to compute the SDF value: {time.time()-since}')
+    
+    # total_sdf_value = sdf_values.sum()
+    # since = time.time()
+    # total_sdf_value.backward()
+    sdf_values.sum().backward()
+    sdf_gradient = points.grad
+    # sdf_gradient = sdf_gradient[torch.nonzero(sdf_gradient).data[0][0]]
+    # # print(f'SDF values: {sdf_values.cpu().detach().numpy()}')
+    # print(f'SDF gradient: {sdf_gradient.cpu().detach().numpy()}')
+
+    print("sdf_gradient: ", sdf_gradient)
+    sliding_window_avg_sdf_gradient = running_avg(sdf_gradient, 2)
+    print("--------------------------------------------------------------")
+    print("sliding window avg sdf gradient: ", sliding_window_avg_sdf_gradient)
+    print("sliding_window_avg_sdf_gradient shape: ", sliding_window_avg_sdf_gradient.shape)
+    # print(f'Total time to compute the SDF gradient: {time.time()-since}')
+

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/rdp_path_simplify.py

@@ -0,0 +1,137 @@
+import torch
+from cfdp.utils.angle_utils import quaternion_difference, quaternion_to_euler, quat_normalize_t
+from cfdp.utils.data_utils import transform_ortho6d_to_quat
+
+
+def quat_geodesic_angle_t(q1, q2):
+    """ q1,q2: (...,4) -> angle (...,) """
+    q1 = quat_normalize_t(q1)
+    q2 = quat_normalize_t(q2)
+    dot = torch.abs((q1 * q2).sum(-1))
+    dot = torch.clamp(dot, -1.0, 1.0)
+    return 2.0 * torch.arccos(dot)
+
+def quat_slerp_t(q0, q1, t: float):
+    """ q0,q1: (4,), t: float in [0,1] """
+    q0 = quat_normalize_t(q0)
+    q1 = quat_normalize_t(q1)
+    dot = torch.dot(q0, q1)
+    if dot < 0.0:
+        q1 = -q1
+        dot = -dot
+    dot = torch.clamp(dot, -1.0, 1.0)
+    if dot > 0.9995:
+        q = q0 + t*(q1 - q0)
+        return quat_normalize_t(q)
+    th0 = torch.arccos(dot)
+    sin_th0 = torch.sin(th0)
+    th = th0 * t
+    s0 = torch.sin(th0 - th) / sin_th0
+    s1 = torch.sin(th) / sin_th0
+    return s0*q0 + s1*q1
+
+def point_segment_distance_t(p, a, b):
+    """ return dist, t """
+    ap = p - a
+    ab = b - a
+    denom = torch.dot(ab, ab)
+    if denom < 1e-18:
+        return torch.norm(ap), 0.0
+    t = torch.clamp(torch.dot(ap, ab) / denom, 0.0, 1.0)
+    proj = a + t*ab
+    return torch.norm(p - proj), float(t)
+
+def find_max_pos_deviation_t(pos, i, j):
+    a, b = pos[i], pos[j]
+    max_dev = -1.0
+    max_k = -1
+    for k in range(i+1, j):
+        d, _ = point_segment_distance_t(pos[k], a, b)
+        if d > max_dev:
+            max_dev, max_k = d, k
+    return max_dev, max_k
+
+def find_max_ori_deviation_t(quat, i, j):
+    qi, qj = quat[i], quat[j]
+    L = j - i
+    max_ang = -1.0
+    max_k = -1
+    for k in range(i+1, j):
+        t = (k - i) / L
+        q_interp = quat_slerp_t(qi, qj, t)
+        ang = float(quat_geodesic_angle_t(quat[k].unsqueeze(0), q_interp.unsqueeze(0)))
+        if ang > max_ang:
+            max_ang, max_k = ang, k
+    return max_ang, max_k
+
+def rdp_indices_with_ori_t(pos, quat, eps_pos=0.02, eps_ang_rad=0.17):
+    """
+    pos: (N,3) torch tensor
+    quat: (N,4) torch tensor
+    returns: indices (M,) torch.long
+    """
+    N = pos.shape[0]
+    if N <= 2:
+        return torch.arange(N, device=pos.device)
+
+    keep = torch.zeros(N, dtype=torch.bool, device=pos.device)
+    keep[0] = True; keep[-1] = True
+    stack = [(0, N-1)]
+
+    while stack:
+        i, j = stack.pop()
+        max_pos, k_pos = find_max_pos_deviation_t(pos, i, j)
+        max_ang, k_ang = find_max_ori_deviation_t(quat, i, j)
+
+        pos_ok = (max_pos <= eps_pos)
+        ang_ok = (max_ang <= eps_ang_rad)
+
+        if pos_ok and ang_ok:
+            continue
+
+        if not pos_ok and ang_ok:
+            mid = k_pos
+        elif pos_ok and not ang_ok:
+            mid = k_ang
+        else:
+            pos_ratio = max_pos / (eps_pos + 1e-12)
+            ang_ratio = max_ang / (eps_ang_rad + 1e-12)
+            mid = k_pos if pos_ratio >= ang_ratio else k_ang
+
+        keep[mid] = True
+        if mid - i >= 1: stack.append((i, mid))
+        if j - mid >= 1: stack.append((mid, j))
+
+    return torch.nonzero(keep, as_tuple=False).squeeze(-1)
+
+def simplify_waypoints_preserve_format_t(waypoints: torch.Tensor,
+                                         eps_pos: float = 0.02,
+                                         eps_ang_deg: float | None = 10.0):
+    """
+    waypoints: (N,3)/(N,7)/(N,9) torch.Tensor
+      - 3: pos
+      - 7: pos + quat(wxyz)
+      - 9: pos + ortho6d
+    returns: (keep_idx, simplified_waypoints)
+    """
+    assert waypoints.ndim == 2 and waypoints.shape[1] in (3,7,9), "Expect (N,3)/(N,7)/(N,9)"
+    device, dtype = waypoints.device, waypoints.dtype
+    D = waypoints.shape[1]
+    pos = waypoints[:, :3]
+
+    # position only
+    if (D == 3) or (eps_ang_deg is None):
+        idx = rdp_indices_pos_only_t(pos, eps_pos)
+        return idx, waypoints.index_select(0, idx)
+
+    # orientation guarding: take quat (7D directly, 9D first convert from 6D)
+    if D == 7:
+        quat = waypoints[:, 3:7]
+    else:  # D == 9
+        # quat = ortho6d_to_quat_t(waypoints[:, 3:9])
+        quat_waypoints = transform_ortho6d_to_quat(waypoints)
+        quat = quat_waypoints[:, 3:7]
+
+    eps_ang_rad = torch.deg2rad(torch.tensor(eps_ang_deg, device=device, dtype=dtype))
+    idx = rdp_indices_with_ori_t(pos, quat, eps_pos=eps_pos, eps_ang_rad=float(eps_ang_rad))
+    return idx, waypoints.index_select(0, idx)

project/ManiSkill3/src/maniskill2_benchmark/cfdp_experiment/cfdp/utils/socket_utils.py

@@ -0,0 +1,13 @@
+import base64
+import numpy as np
+
+def arr2base64(arr):
+    arr_bytes = arr.tobytes()
+    encoded_arr = base64.b64encode(arr_bytes).decode('ascii')
+    return {'data': encoded_arr, 'dtype': str(arr.dtype), 'shape': arr.shape}
+
+def base64_to_arr(arr_dict):
+    arr_bytes = base64.b64decode(arr_dict['data'])
+    arr = np.frombuffer(arr_bytes, np.dtype(arr_dict['dtype']))
+    arr = arr.reshape(arr_dict['shape'])
+    return arr

project/ManiSkill3/src/maniskill2_benchmark/msx_envs/msx_envs/env_config/distractorbox/7_scene_config.yaml

@@ -0,0 +1,458 @@
+objects:
+- collision:
+    path: object/table/desktable.obj
+  name: table
+  pose:
+    position:
+    - 0.4000000059604645
+    - 0.0
+    - -0.75
+    quaternion:
+    - 0.0
+    - 0.0
+    - 0.7071068286895752
+    - 0.7071068286895752
+  scale:
+  - 2.0
+  - 1.0
+  - 1.5
+  visual:
+    path: object/table/desktable.glb
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_01
+  pose:
+    position:
+    - 0.5411531925201416
+    - -0.33478599786758423
+    - 0.19764788448810577
+    quaternion:
+    - 0.9953973889350891
+    - 1.1641532182693481e-09
+    - 2.3010215954855084e-10
+    - -0.09583356231451035
+  scale:
+  - 0.43156745678016356
+  - 0.4938321481829596
+  - 1.0544241940054395
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/box_01/box_01.gltf
+  name: box_02
+  pose:
+    position:
+    - 0.18066096305847168
+    - -0.3856646418571472
+    - 0.12996400892734528
+    quaternion:
+    - 0.9750638008117676
+    - 1.862645149230957e-09
+    - 3.5033735912293196e-09
+    - -0.22192484140396118
+  scale:
+  - 0.40738405359814406
+  - 0.5761527279656022
+  - 0.7179754719214234
+  visual:
+    path: object/box_01/box_01.gltf
+- collision:
+    path: object/051_large_clamp/collision.obj
+  name: large_clamp
+  pose:
+    position:
+    - 0.3960020840167999
+    - 0.4104568660259247
+    - 0.0048619951121509075
+    quaternion:
+    - 0.7836728692054749
+    - 0.0002483418211340904
+    - -0.00019835252896882594
+    - -0.6211735606193542
+  scale: 1.0
+  visual:
+    path: object/051_large_clamp/textured.obj
+- collision:
+    path: object/032_knife/collision.obj
+  name: knife
+  pose:
+    position:
+    - 0.16431424021720886
+    - -0.26314669847488403
+    - 0.2801703214645386
+    quaternion:
+    - 0.9511080384254456
+    - -0.05688799172639847
+    - 0.021953586488962173
+    - -0.3027794361114502
+  scale: 1.0
+  visual:
+    path: object/032_knife/textured.obj
+- collision:
+    path: object/038_padlock/collision.obj
+  name: padlock
+  pose:
+    position:
+    - 0.6913907527923584
+    - -0.47387224435806274
+    - 0.00037308820174075663
+    quaternion:
+    - 0.7253404259681702
+    - 4.12575900554657e-06
+    - 4.9620866775512695e-06
+    - -0.6883903741836548
+  scale: 1.0
+  visual:
+    path: object/038_padlock/textured.obj
+- collision:
+    path: object/005_tomato_soup_can/collision.obj
+  name: tomato_soup_can
+  pose:
+    position:
+    - 0.4213438630104065
+    - -0.10455051809549332
+    - 0.036737337708473206
+    quaternion:
+    - 0.9973571300506592
+    - 0.004662784282118082
+    - -0.0008021022658795118
+    - -0.07250283658504486
+  scale: 1.0
+  visual:
+    path: object/005_tomato_soup_can/textured.obj
+- collision:
+    path: object/057_racquetball/collision.obj
+  name: racquetball
+  pose:
+    position:
+    - 0.6549382209777832
+    - -0.7179558873176575
+    - 0.013666164129972458
+    quaternion:
+    - -0.944601833820343
+    - -0.2577575147151947
+    - 0.007072235457599163
+    - -0.203073188662529
+  scale: 1.0
+  visual:
+    path: object/057_racquetball/textured.obj
+- collision:
+    path: object/054_softball/collision.obj
+  name: softball
+  pose:
+    position:
+    - 0.3998604118824005
+    - 0.16705569624900818
+    - 0.03259090706706047
+    quaternion:
+    - 0.9982295632362366
+    - 0.009225627407431602
+    - -0.023404540494084358
+    - 0.05389898642897606
+  scale: 1.0
+  visual:
+    path: object/054_softball/textured.obj
+- collision:
+    path: object/009_gelatin_box/collision.obj
+  name: gelatin_box
+  pose:
+    position:
+    - 0.08669579029083252
+    - 0.3514019250869751
+    - 0.0009558660676702857
+    quaternion:
+    - 0.746235728263855
+    - 3.0816299840807915e-06
+    - 9.892610250972211e-07
+    - -0.6656818389892578
+  scale: 1.0
+  visual:
+    path: object/009_gelatin_box/textured.obj
+- collision:
+    path: object/011_banana/collision.obj
+  name: banana
+  pose:
+    position:
+    - 0.11127632856369019
+    - 0.18324284255504608
+    - 0.004434763453900814
+    quaternion:
+    - 0.9793081879615784
+    - -0.0016427943482995033
+    - -0.0029420959763228893
+    - -0.20234665274620056
+  scale: 1.0
+  visual:
+    path: object/011_banana/textured.obj
+- collision:
+    path: object/043_phillips_screwdriver/collision.obj
+  name: phillips_screwdriver
+  pose:
+    position:
+    - 0.651358425617218
+    - 0.06117602437734604
+    - -2.2212043404579163e-06
+    quaternion:
+    - 0.8662685751914978
+    - -0.02353747934103012
+    - -0.08970711380243301
+    - 0.49089452624320984
+  scale: 1.0
+  visual:
+    path: object/043_phillips_screwdriver/textured.obj
+- collision:
+    path: object/073-a_lego_duplo/collision.obj
+  name: lego_duplo
+  pose:
+    position:
+    - 0.07054553925991058
+    - 0.45550820231437683
+    - -0.0019614154007285833
+    quaternion:
+    - 0.7769989967346191
+    - -5.024252459406853e-06
+    - -1.7005615518428385e-05
+    - 0.6295019388198853
+  scale: 1.0
+  visual:
+    path: object/073-a_lego_duplo/textured.obj
+- collision:
+    path: object/006_mustard_bottle/collision.obj
+  name: mustard_bottle
+  pose:
+    position:
+    - 0.6522485017776489
+    - -0.02355482429265976
+    - 0.017643030732870102
+    quaternion:
+    - 0.31925877928733826
+    - 0.4426552951335907
+    - 0.5555307865142822
+    - 0.6273083686828613
+  scale: 1.0
+  visual:
+    path: object/006_mustard_bottle/textured.obj
+- collision:
+    path: object/002_master_chef_can/collision.obj
+  name: master_chef_can
+  pose:
+    position:
+    - 0.39390599727630615
+    - 0.034177470952272415
+    - 0.05646386370062828
+    quaternion:
+    - 0.8733154535293579
+    - 3.2882962841540575e-06
+    - -4.950270522385836e-07
+    - -0.48715531826019287
+  scale: 1.0
+  visual:
+    path: object/002_master_chef_can/textured.obj
+- collision:
+    path: object/036_wood_block/collision.obj
+  name: wood_block
+  pose:
+    position:
+    - 0.16562879085540771
+    - -0.14416122436523438
+    - 0.043825723230838776
+    quaternion:
+    - -0.010184310376644135
+    - 0.6387211680412292
+    - -0.3020576536655426
+    - -0.7075966596603394
+  scale: 1.0
+  visual:
+    path: object/036_wood_block/textured.obj
+- collision:
+    path: object/012_strawberry/collision.obj
+  name: strawberry
+  pose:
+    position:
+    - 0.2075018435716629
+    - -0.059122636914253235
+    - 0.008252094499766827
+    quaternion:
+    - 0.9944765567779541
+    - -0.06852412968873978
+    - -0.0287138931453228
+    - 0.07413822412490845
+  scale: 1.0
+  visual:
+    path: object/012_strawberry/textured.obj
+- collision:
+    path: object/072-c_toy_airplane/collision.obj
+  name: toy_airplane
+  pose:
+    position:
+    - 0.24646730720996857
+    - 0.24238541722297668
+    - 0.019568663090467453
+    quaternion:
+    - 0.935096800327301
+    - 0.002827427815645933
+    - 0.00012870205682702363
+    - -0.3543815016746521
+  scale: 1.0
+  visual:
+    path: object/072-c_toy_airplane/textured.obj
+- collision:
+    path: object/015_peach/collision.obj
+  name: peach
+  pose:
+    position:
+    - 0.601452112197876
+    - 0.3438147306442261
+    - 0.01431876327842474
+    quaternion:
+    - 0.8866758942604065
+    - -0.0986284390091896
+    - -0.22087711095809937
+    - -0.3940708637237549
+  scale: 1.0
+  visual:
+    path: object/015_peach/textured.obj
+- collision:
+    path: object/014_lemon/collision.obj
+  name: lemon
+  pose:
+    position:
+    - 0.5213211178779602
+    - -0.4761643707752228
+    - 0.012237854301929474
+    quaternion:
+    - 0.9941476583480835
+    - 6.818398833274841e-05
+    - 3.129243850708008e-07
+    - 0.10803081095218658
+  scale: 1.0
+  visual:
+    path: object/014_lemon/textured.obj
+- collision:
+    path: object/055_baseball/collision.obj
+  name: baseball
+  pose:
+    position:
+    - 0.10353413969278336
+    - -0.024039605632424355
+    - 0.02265048772096634
+    quaternion:
+    - 0.1044173389673233
+    - 0.8803550004959106
+    - 0.06693390011787415
+    - -0.45781248807907104
+  scale: 1.0
+  visual:
+    path: object/055_baseball/textured.obj
+- collision:
+    path: object/026_sponge/collision.obj
+  name: sponge
+  pose:
+    position:
+    - 0.28831154108047485
+    - 0.2725689113140106
+    - 0.0306338332593441
+    quaternion:
+    - 0.689015805721283
+    - -0.31184300780296326
+    - 0.3014889359474182
+    - -0.5806166529655457
+  scale: 1.0
+  visual:
+    path: object/026_sponge/textured.obj
+- collision:
+    path: object/007_tuna_fish_can/collision.obj
+  name: tuna_fish_can
+  pose:
+    position:
+    - 0.4987218379974365
+    - -0.22164365649223328
+    - 0.4239289164543152
+    quaternion:
+    - 0.9792429208755493
+    - -0.004228629171848297
+    - 0.008018635213375092
+    - 0.20248772203922272
+  scale: 1.0
+  visual:
+    path: object/007_tuna_fish_can/textured.obj
+- collision:
+    path: object/017_orange/collision.obj
+  name: orange
+  pose:
+    position:
+    - 0.16483265161514282
+    - -0.4286644160747528
+    - 0.021655144169926643
+    quaternion:
+    - 0.8321624994277954
+    - 0.04870299994945526
+    - -0.002386651933193207
+    - -0.5523840188980103
+  scale: 1.0
+  visual:
+    path: object/017_orange/textured.obj
+- collision:
+    path: object/033_spatula/collision.obj
+  name: spatula
+  pose:
+    position:
+    - 0.2773701250553131
+    - -0.03216280788183212
+    - 0.010732786729931831
+    quaternion:
+    - 0.7247846722602844
+    - 0.5543031692504883
+    - -0.3050392270088196
+    - -0.2727387845516205
+  scale: 1.0
+  visual:
+    path: object/033_spatula/textured.obj
+- collision:
+    path: object/077_rubiks_cube/collision.obj
+  name: rubiks_cube
+  pose:
+    position:
+    - 0.3757307827472687
+    - -0.42385706305503845
+    - 0.014687028713524342
+    quaternion:
+    - 0.9600054025650024
+    - -0.002521239221096039
+    - 0.0010814964771270752
+    - 0.2799682915210724
+  scale: 1.0
+  visual:
+    path: object/077_rubiks_cube/textured.obj
+- collision:
+    path: object/004_sugar_box/collision.obj
+  name: sugar_box
+  pose:
+    position:
+    - 0.5863490700721741
+    - 0.41124847531318665
+    - 0.07367444783449173
+    quaternion:
+    - 0.8212317824363708
+    - -0.010641193017363548
+    - -0.006307687144726515
+    - -0.5704607963562012
+  scale: 1.0
+  visual:
+    path: object/004_sugar_box/textured.obj
+- collision:
+    path: object/003_cracker_box/collision.obj
+  name: cracker_box
+  pose:
+    position:
+    - 0.5719598531723022
+    - -0.38586848974227905
+    - 0.06775876134634018
+    quaternion:
+    - 0.4747459888458252
+    - 0.47796034812927246
+    - -0.5211132764816284
+    - -0.5240334272384644
+  scale: 1.0
+  visual:
+    path: object/003_cracker_box/textured.obj