neuromeka-vfm 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

neuromeka_vfm/__init__.py

@@ -2,7 +2,6 @@ from .pose_estimation import PoseEstimation, FoundationPoseClient
 from .upload_mesh import upload_mesh
 from .segmentation import Segmentation, NrmkRealtimeSegmentation
 from .compression import STRATEGIES as SEGMENTATION_COMPRESSION_STRATEGIES
-from .grasp_gen import GraspPoseGeneration
 
 __all__ = [
     "PoseEstimation",
@@ -11,5 +10,4 @@ __all__ = [
     "Segmentation",
     "NrmkRealtimeSegmentation",
     "SEGMENTATION_COMPRESSION_STRATEGIES",
-    "GraspPoseGeneration",
 ]

neuromeka_vfm/generate_mesh.py

@@ -0,0 +1,122 @@
+"""
+Utility to generate simple parametric meshes (currently rectangular box) as binary STL.
+
+Design goals
+- Units: meters
+- Origin: object center at (0, 0, 0)
+- Axes: faces aligned to +/-X, +/-Y, +/-Z
+- Output: binary STL saved to /opt/meshes (docker volume mount)
+
+Usage (programmatic):
+    from backend.generate_mesh import write_box_stl
+    path = write_box_stl("custom_box.stl", width=0.054, depth=0.097, height=0.054)
+
+CLI (optional):
+    python -m backend.generate_mesh box custom_box.stl 0.054 0.097 0.054
+"""
+
+from __future__ import annotations
+
+import struct
+import sys
+from pathlib import Path
+from typing import Iterable, Tuple
+
+MESH_DIR = Path("/opt/meshes")
+
+
+def _ensure_dir(path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+def _pack_triangle(normal: Iterable[float], v1: Iterable[float], v2: Iterable[float], v3: Iterable[float]) -> bytes:
+    """Pack one triangle (normal + 3 vertices) into binary STL record."""
+    return struct.pack(
+        "<12fH",
+        *normal,
+        *v1,
+        *v2,
+        *v3,
+        0,  # attribute byte count
+    )
+
+
+def _box_triangles(width: float, depth: float, height: float):
+    """Generate normals and vertices for a box centered at origin."""
+    hx, hy, hz = width / 2.0, depth / 2.0, height / 2.0
+    # 8 vertices
+    p = [
+        (-hx, -hy, -hz),
+        (hx, -hy, -hz),
+        (hx, hy, -hz),
+        (-hx, hy, -hz),
+        (-hx, -hy, hz),
+        (hx, -hy, hz),
+        (hx, hy, hz),
+        (-hx, hy, hz),
+    ]
+    # Each face: two triangles (ccw when looking from outside)
+    faces = [
+        ((-1, 0, 0), (0, 1, 3, 7, 4)),  # -X
+        ((1, 0, 0), (1, 2, 6, 5)),  # +X
+        ((0, -1, 0), (0, 1, 5, 4)),  # -Y
+        ((0, 1, 0), (3, 2, 6, 7)),  # +Y
+        ((0, 0, -1), (0, 1, 2, 3)),  # -Z
+        ((0, 0, 1), (4, 5, 6, 7)),  # +Z
+    ]
+    for normal, idx in faces:
+        if len(idx) == 4:
+            a, b, c, d = idx
+            # two triangles: (a,b,c) and (a,c,d)
+            yield normal, p[a], p[b], p[c]
+            yield normal, p[a], p[c], p[d]
+        else:
+            raise ValueError("Face index must have 4 vertices.")
+
+
+def write_box_stl(filename: str, width: float, depth: float, height: float) -> Path:
+    """
+    Create a rectangular box STL.
+
+    Args:
+        filename: output file name (placed under /opt/meshes). If only a name is
+                  given, it is resolved relative to MESH_DIR.
+        width, depth, height: box dimensions in meters (must be > 0).
+
+    Returns:
+        Path to the written STL file.
+    """
+    if width <= 0 or depth <= 0 or height <= 0:
+        raise ValueError("width, depth, height must be positive.")
+
+    out_path = Path(filename)
+    if not out_path.is_absolute():
+        out_path = MESH_DIR / out_path
+    _ensure_dir(out_path)
+
+    triangles = list(_box_triangles(width, depth, height))
+    header = b"rect_box_stl" + b"\0" * (80 - len("rect_box_stl"))
+    with out_path.open("wb") as f:
+        f.write(header)
+        f.write(struct.pack("<I", len(triangles)))
+        for tri in triangles:
+            f.write(_pack_triangle(*tri))
+    return out_path
+
+
+def _cli(args: list[str]) -> int:
+    if len(args) != 5 or args[0].lower() != "box":
+        print("Usage: python -m backend.generate_mesh box <filename> <width> <depth> <height>")
+        return 1
+    _, fname, w, d, h = args
+    try:
+        path = write_box_stl(fname, float(w), float(d), float(h))
+    except Exception as exc:  # noqa: BLE001
+        print(f"Error: {exc}")
+        return 1
+    print(f"STL written to: {path}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(_cli(sys.argv[1:]))

{neuromeka_vfm-0.1.5.dist-info → neuromeka_vfm-0.1.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: neuromeka_vfm
-Version: 0.1.5
+Version: 0.1.6
 Summary: Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)
 Author: Neuromeka
 License: MIT License
@@ -47,50 +47,50 @@ Dynamic: license-file
 
 # neuromeka_vfm
 
-클라이언트 PC에서 Segmentation (SAM2, Grounding DINO), Pose Estimation (NVIDIA FoundationPose) 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
+A lightweight client SDK for communicating with Segmentation (SAM2, Grounding DINO) and Pose Estimation (NVIDIA FoundationPose) servers over RPC/ZeroMQ. It also provides SSH/SFTP utilities to upload mesh files to the host.
 
 - Website: http://www.neuromeka.com
-- Source code: https://github.com/neuromeka-robotics/neuromeka_vfm
 - PyPI package: https://pypi.org/project/neuromeka_vfm/
 - Documents: https://docs.neuromeka.com
 
-## Web UI (VFM Tester)를 통해 사용 가능
-
-- VFM Tester (Web UI): https://gitlab.com/neuromeka-group/nrmkq/nrmk_vfm_tester
-
-
 ## Installation
+
 ```bash
 pip install neuromeka_vfm
 ```
 
-## Python API (예제로 보는 사용법)
+## Python API (usage by example)
 
-* 내 PC: 어플리케이션을 구현하고 이 패키지 (neuromeka_vfm)이 설치된 PC
-* 서버PC (Host): Segmentation, Pose Estimation 도커 서버가 설치된 PC. 내 PC에 도커를 설치할 경우 localhost 사용.
+- Client PC: the machine running your application with this package installed.
+- Host PC: the machine running Segmentation and Pose Estimation Docker servers. If you run Docker locally, use `localhost`.
 
 ### Segmentation
+
 ```python
 from neuromeka_vfm import Segmentation
 
 seg = Segmentation(
-    hostname="192.168.10.63", 
+    hostname="192.168.10.63",
     port=5432,
     compression_strategy="png",    # none | png | jpeg | h264
 )
 
-# Image Prompt를 이용한 등록
+# Register using an image prompt
 seg.add_image_prompt("drug_box", ref_rgb)
-seg.register_first_frame(frame=first_rgb, 
-                        prompt="drug_box", # ID str
-                        use_image_prompt=True)
+seg.register_first_frame(
+    frame=first_rgb,
+    prompt="drug_box",     # ID string
+    use_image_prompt=True,
+)
 
-# Text Prompt를 이용한 등록
-seg.register_first_frame(frame=first_rgb, 
-                        prompt="box .",   # Text prompt (끝에 띄어쓰기 . 필수)
-                        use_image_prompt=False)
+# Register using a text prompt
+seg.register_first_frame(
+    frame=first_rgb,
+    prompt="box .",         # Text prompt (must end with " .")
+    use_image_prompt=False,
+)
 
-# 등록된 mask에 대한 SAM2 tracking
+# SAM2 tracking on the registered mask(s)
 resp = seg.get_next(next_rgb)
 if isinstance(resp, dict) and resp.get("result") == "ERROR":
     print(f"Tracking error: {resp.get('message')}")
@@ -98,7 +98,7 @@ if isinstance(resp, dict) and resp.get("result") == "ERROR":
 else:
     masks = resp
 
-# Segmentation 설정/모델 선택 (nrmk_realtime_segmentation v0.2+)
+# Segmentation settings / model selection (nrmk_realtime_segmentation v0.2+)
 caps = seg.get_capabilities()["data"]
 current = seg.get_config()["data"]
 seg.set_config(
@@ -126,15 +126,26 @@ seg.set_config(
     }
 )
 
-# SAM2 object 제거 (v0.2+, use_legacy=False에서만 지원)
+# Remove an object (v0.2+, only when use_legacy=False)
 seg.remove_object("cup_0")
 
-
 seg.close()
 ```
 
-#### Segmentation v0.2 설정 요약 (defaults/choices)
-`seg.get_capabilities()` 결과는 서버 설정에 따라 달라질 수 있습니다. 아래는 v0.2 기본값입니다.
+Additional Segmentation APIs and behaviors
+
+- `benchmark=True` in the constructor enables timing counters (`call_time`, `call_count`) for `add_image_prompt`, `register_first_frame`, and `get_next`.
+- `switch_compression_strategy()` lets you change the compression strategy at runtime.
+- `register_first_frame()` returns `True`/`False` and raises `ValueError` if image prompts are missing when `use_image_prompt=True`.
+- `register_first_frame()` accepts a list of prompt IDs when `use_image_prompt=True`.
+- `get_next()` returns `None` if called before registration; it can also return the server error dict when available.
+- `reset()` performs a server-side reset, while `finish()` clears only local state.
+- Exposed state: `tracking_object_ids`, `current_frame_masks`, `invisible_object_ids`.
+- Backward-compat alias: `NrmkRealtimeSegmentation`.
+
+#### Segmentation v0.2 config summary (defaults/choices)
+`seg.get_capabilities()` can differ depending on server configuration. The following reflects v0.2 defaults.
+
 ```yaml
 grounding_dino:
   backbone:
@@ -187,70 +198,82 @@ sam2:
     default: false
 ```
 
-#### Segmentation v0.2 주의사항/변경사항
-- SAM2 VRAM 추정 실패 시 `seg.get_next()`가 `{"result":"ERROR"}`로 반환될 수 있으니 에러 처리 후 `reset`/재등록을 권장합니다.
-- SAM2 `compile=True`는 첫 프레임 등록 및 `reset`이 느려질 수 있습니다.
-- SAM2 CPU offloading은 `offload_state_to_cpu=True`와 `offload_video_to_cpu=True`를 함께 설정할 때 효과가 큽니다(legacy 모드에서는 `offload_video_to_cpu` 미지원).
-- SAM2 `remove_object`는 `use_legacy=False`에서만 지원됩니다.
-- GroundingDINO는 Swin-B 백본이 추가되었고, 프롬프트 토큰 병합 이슈가 수정되었습니다.
+#### Segmentation v0.2 notes and changes
+
+- If SAM2 VRAM estimation fails, `seg.get_next()` may return `{"result":"ERROR"}`. Handle the error and call `reset` before re-registering.
+- `compile=True` can slow down first-frame registration and `reset`.
+- CPU offloading is most effective when both `offload_state_to_cpu=True` and `offload_video_to_cpu=True` are set (legacy mode does not support `offload_video_to_cpu`).
+- `remove_object` is supported only when `use_legacy=False`.
+- GroundingDINO added the Swin-B backbone and fixed prompt-token merge issues.
 
 ### Pose Estimation
 
-**Mesh 파일 업로드**: 등록/인식하고자 하는 mesh 파일 (stl)을 호스트PC의 '/opt/meshes/' 경로에 업로드 (직접 SSH 통해 파일을 옮겨도 됨)
+**Mesh upload**: Upload the mesh file (STL) to `/opt/meshes/` on the host PC. You can also use SSH directly.
+
 ```python
 from neuromeka_vfm import upload_mesh
+
 upload_mesh(
     host="192.168.10.63",
     user="user",
-    password="pass",                  
-    local="mesh/my_mesh.stl",         # 내 PC mesh 경로
-    remote="/opt/meshes/my_mesh.stl", # 호스트PC mesh 경로 (도커 볼륨마운트)
+    password="pass",
+    local="mesh/my_mesh.stl",         # local mesh path
+    remote="/opt/meshes/my_mesh.stl", # host mesh path (Docker volume)
 )
 ```
 
-초기화
+Initialization
+
 ```python
 from neuromeka_vfm import PoseEstimation
 
-pose = PoseEstimation(host="192.168.10.72", port=5557)  
+pose = PoseEstimation(host="192.168.10.72", port=5557)
 
 pose.init(
     mesh_path="/app/modules/foundation_pose/mesh/my_mesh.stl",
-    apply_scale=1.0,  
+    apply_scale=1.0,
     track_refine_iter=3,
     min_n_views=40,
-    inplane_step=60
+    inplane_step=60,
 )
 ```
-- mesh_path: 사용할 물체 메시 파일(STL/OBJ 등) 경로. 없으면 초기화 실패.
-- apply_scale: 메시를 로드한 뒤 전체를 배율 조정하는 스케일 값. 단위 없는 곱셈 계수.
-    - STL 모델이 미터 단위라면 1.0 (스케일 없음)
-    - STL 모델이 센티미터 단위라면 0.01 (1 cm → 0.01 m)
-    - STL 모델이 밀리미터 단위라면 0.001 (1 mm → 0.001 m)
-- force_apply_color: True일 때 메시에 단색 텍스처를 강제로 입힘. 메시가 색상을 안 가졌을 때 시각화 안정성을 위해 사용.
-- apply_color: force_apply_color가 True일 때 적용할 RGB 색상값(0~255) 튜플.
-- est_refine_iter: 초기 등록(register) 단계에서 포즈를 반복 정련하는 횟수. 값이 클수록 정확도 ↑, 연산 시간 ↑.
-- track_refine_iter: 추적(track) 단계에서 한 프레임당 포즈 정련 반복 횟수.
-- min_n_views: 초기 뷰 샘플링 시 생성할 최소 카메라 뷰 수(회전 후보 수에 영향).
-- inplane_step: in-plane 회전 샘플링 간격(도 단위). 값이 작을수록 더 많은 회전 후보를 생성.
-
-
-인식 및 추적
+
+- mesh_path: path to the mesh file (STL/OBJ). Initialization fails if missing.
+- apply_scale: scalar applied after loading the mesh.
+  - STL in meters: 1.0 (no scaling)
+  - STL in centimeters: 0.01 (1 cm -> 0.01 m)
+  - STL in millimeters: 0.001 (1 mm -> 0.001 m)
+- force_apply_color: if True, forces a solid color when the mesh lacks color data.
+- apply_color: RGB tuple (0-255) used when `force_apply_color=True`.
+- est_refine_iter: number of refinement iterations during registration (higher = more accurate, slower).
+- track_refine_iter: number of refinement iterations per frame during tracking.
+- min_n_views: minimum number of sampled camera views (affects rotation candidates).
+- inplane_step: in-plane rotation step in degrees (smaller = more candidates).
+
+Registration and tracking
+
 ```python
-# 초기 등록 (iteration 생략 시 서버 기본값, check_vram=True로 VRAM 사전 체크)
+# Registration (server defaults when iteration is omitted, check_vram=True pre-checks VRAM)
 register_resp = pose.register(rgb=rgb0, depth=depth0, mask=mask0, K=cam_K, check_vram=True)
 
-# 추적 (bbox_xywh로 탐색 범위 제한 가능)
+# Tracking (optionally limit search area with bbox_xywh)
 track_resp = pose.track(rgb=rgb1, depth=depth1, K=cam_K, bbox_xywh=bbox_xywh)
+
 pose.close()
 ```
-- cam_K: camera intrinsic
-- RGB resolution이 크거나, min_n_views 값이 크거나, inplane_step이 작을 경우 GPU VRAM 초과 에러 발생. 
-- register check_vram=True 일 경우 VRAM 초과 사전 검사하여 shutdown 방지.
 
+- cam_K: camera intrinsics.
+- Large RGB resolution, large `min_n_views`, or small `inplane_step` can cause GPU VRAM errors.
+- `check_vram=True` in `register` performs a pre-check to prevent server shutdown due to OOM.
+- `iteration` in `register`/`track` can override the server default if provided.
+- `reset()` resets the server state; `reset_object()` reuses the cached mesh to rebuild the rotation grid.
+- Default host/port can come from `FPOSE_HOST` and `FPOSE_PORT` environment variables.
+- Backward-compat alias: `FoundationPoseClient`.
+
+<!--
+## Benchmark
 
-## VFM (Vision Foundation Model) latency benchmark
-로컬 서버 구동 시 측정. 빈칸은 아직 미측정 항목입니다. 
+Measured on local servers. Empty cells are not yet measured.
 
 **RTX 5060**
 | Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
@@ -269,17 +292,10 @@ pose.close()
 | SAM2 | - |  |  |  |  |
 | FoundationPose registration | - | 0.4 | - |  |  |
 | FoundationPose track | - | 0.03 |  |  |  |
+-->
 
-**Jetson Orin**
-| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
-| --- | --- | --- | --- | --- | --- |
-| Grounding DINO | text (human . cup .) |  |  |  |  |
-| DINOv2 | image prompt |  |  |  |  |
-| SAM2 | - |  |  |  |  |
-| FoundationPose registration | - | 0.4 | - |  |  |
-| FoundationPose track | - | 0.03 |  |  |  |
+## Release notes
 
-## 릴리스 노트
-- 0.1.2: Segmentation 응답 성공 판정 개선(`result`/`success`/`status` 모두 지원), image prompt 등록/사용 오류 수정, PoseEstimation `register`에 `check_vram` 옵션 반영.
-- 0.1.1: PoseEstimation/Segmentation에서 리소스 정리 개선, iteration 미전달 시 서버 기본값 사용, pose 데모 예제 추가.
-- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.
+- 0.1.2: Improved success detection for Segmentation responses (`result`/`success`/`status`), fixed image prompt registration/usage, added `check_vram` to PoseEstimation `register`.
+- 0.1.1: Improved resource cleanup in PoseEstimation/Segmentation, use server defaults when iteration is omitted, added pose demo example.
+- 0.1.0: Initial public release. Includes FoundationPose RPC client, real-time segmentation client, SSH-based mesh upload CLI/API.

{neuromeka_vfm-0.1.5.dist-info → neuromeka_vfm-0.1.6.dist-info}/RECORD

@@ -1,6 +1,6 @@
-neuromeka_vfm/__init__.py,sha256=e3VVyc7AvMjjUeSeatwq0pHTLBFFYiZXRJFjxE3CTtY,492
+neuromeka_vfm/__init__.py,sha256=h5ODdWFgN7a9TBzF6Qfdyx5VxUr2hG0pFTwq57jEvDo,422
 neuromeka_vfm/compression.py,sha256=d2xOz4XBJZ60pPSXwQ5LPYwhpsaNORvNoY_0CUiAvt0,5191
-neuromeka_vfm/grasp_gen.py,sha256=-9LOhkMBFaa5i5IO9y_lElBIPGEZkmRx6t6Mrhs1nGA,2448
+neuromeka_vfm/generate_mesh.py,sha256=HV2dUfVXROPQ9kDDPmkwdn5E5gelWIQDsPsZuvZxI6E,3634
 neuromeka_vfm/pickle_client.py,sha256=Iw2fpxdnKB20oEUgsd0rJlvzOd5JhetphpKkF9qQcX0,591
 neuromeka_vfm/point_cloud_utils.py,sha256=ZnCh8Xg6pLGoyi5ufZkz59HzE9RuRdihE8z-XNYT1PA,13261
 neuromeka_vfm/pose_estimation.py,sha256=3MUVhL0nMcpHApZDAzutS7fINPHcb-tu_WoXvNGU33E,2625
@@ -8,9 +8,9 @@ neuromeka_vfm/segmentation.py,sha256=8kmMut_gNJ3wa9F0l7iEYFNqHJzHJ5KPBzs7vSiwjqg
 neuromeka_vfm/upload_mesh.py,sha256=aW5G9aE5OeiDN5pEVKDzMeV538U-I2iRYZvVZTfGsr4,2728
 neuromeka_vfm/examples/__init__.py,sha256=dEhb0FqhpEGNmg0pMunmrTlViIcxvd95fYEjZ49IOTQ,37
 neuromeka_vfm/examples/pose_demo.py,sha256=zq1Z0_kxQc4CB-ltfwm_oMoC7JLoN5GyeE3C6jKGQKw,13658
-neuromeka_vfm-0.1.5.dist-info/licenses/LICENSE,sha256=40cBWxFahhu0p_EB0GhU8oVIifVNmH1o2fZtx0bIif8,1076
-neuromeka_vfm-0.1.5.dist-info/METADATA,sha256=k6-RvxOIAIivCYteyq8yXFmC0usn6-Gd1ii3b90k9kU,10753
-neuromeka_vfm-0.1.5.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-neuromeka_vfm-0.1.5.dist-info/entry_points.txt,sha256=Wl4XqiUt_GLQ08oTJtsYjLW0iYxZ52ysVd1-cN0kYP4,72
-neuromeka_vfm-0.1.5.dist-info/top_level.txt,sha256=uAH_yXikUvxXTSEnUC0M8Zl5ggxbnkYtXlmTfEG8MUk,14
-neuromeka_vfm-0.1.5.dist-info/RECORD,,
+neuromeka_vfm-0.1.6.dist-info/licenses/LICENSE,sha256=40cBWxFahhu0p_EB0GhU8oVIifVNmH1o2fZtx0bIif8,1076
+neuromeka_vfm-0.1.6.dist-info/METADATA,sha256=zHBuQ5sHDJjOdY96dmxLiwtE8OHIRJg0VcyzUB0rV48,10628
+neuromeka_vfm-0.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+neuromeka_vfm-0.1.6.dist-info/entry_points.txt,sha256=Wl4XqiUt_GLQ08oTJtsYjLW0iYxZ52ysVd1-cN0kYP4,72
+neuromeka_vfm-0.1.6.dist-info/top_level.txt,sha256=uAH_yXikUvxXTSEnUC0M8Zl5ggxbnkYtXlmTfEG8MUk,14
+neuromeka_vfm-0.1.6.dist-info/RECORD,,

{neuromeka_vfm-0.1.5.dist-info → neuromeka_vfm-0.1.6.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.10.1)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

neuromeka_vfm/grasp_gen.py

@@ -1,79 +0,0 @@
-from typing import Tuple
-
-import numpy as np
-import trimesh
-
-from . import point_cloud_utils
-
-
-class GraspPoseGeneration:
-    """
-    Wrapper class for point cloud utilities used in grasp pose workflows.
-    """
-
-    def knn_points(self, X: np.ndarray, K: int, norm: int):
-        return point_cloud_utils.knn_points(X=X, K=K, norm=norm)
-
-    def point_cloud_outlier_removal(
-        self, obj_pc: np.ndarray, threshold: float = 0.014, K: int = 20
-    ) -> Tuple[np.ndarray, np.ndarray]:
-        return point_cloud_utils.point_cloud_outlier_removal(
-            obj_pc=obj_pc, threshold=threshold, K=K
-        )
-
-    def point_cloud_outlier_removal_with_color(
-        self,
-        obj_pc: np.ndarray,
-        obj_pc_color: np.ndarray,
-        threshold: float = 0.014,
-        K: int = 20,
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        return point_cloud_utils.point_cloud_outlier_removal_with_color(
-            obj_pc=obj_pc,
-            obj_pc_color=obj_pc_color,
-            threshold=threshold,
-            K=K,
-        )
-
-    def depth_and_segmentation_to_point_clouds(
-        self,
-        depth_image: np.ndarray,
-        segmentation_mask: np.ndarray,
-        fx: float,
-        fy: float,
-        cx: float,
-        cy: float,
-        rgb_image: np.ndarray = None,
-        target_object_id: int = 1,
-        remove_object_from_scene: bool = False,
-    ) -> Tuple[np.ndarray, np.ndarray, np.ndarray, np.ndarray]:
-        return point_cloud_utils.depth_and_segmentation_to_point_clouds(
-            depth_image=depth_image,
-            segmentation_mask=segmentation_mask,
-            fx=fx,
-            fy=fy,
-            cx=cx,
-            cy=cy,
-            rgb_image=rgb_image,
-            target_object_id=target_object_id,
-            remove_object_from_scene=remove_object_from_scene,
-        )
-
-    def filter_colliding_grasps(
-        self,
-        scene_pc: np.ndarray,
-        grasp_poses: np.ndarray,
-        gripper_collision_mesh: trimesh.Trimesh,
-        collision_threshold: float = 0.002,
-        num_collision_samples: int = 2000,
-    ) -> np.ndarray:
-        return point_cloud_utils.filter_colliding_grasps(
-            scene_pc=scene_pc,
-            grasp_poses=grasp_poses,
-            gripper_collision_mesh=gripper_collision_mesh,
-            collision_threshold=collision_threshold,
-            num_collision_samples=num_collision_samples,
-        )
-
-
-__all__ = ["GraspPoseGeneration"]