neuromeka-vfm 0.1.0__tar.gz → 0.1.2__tar.gz

neuromeka_vfm-0.1.2/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: neuromeka_vfm
+Version: 0.1.2
+Summary: Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)
+Author: Neuromeka
+License: MIT License
+        
+        Copyright (c) 2025 Neuromeka Co., Ltd.
+        
+        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.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyzmq
+Requires-Dist: paramiko
+Requires-Dist: av
+Requires-Dist: opencv-python-headless
+Dynamic: license-file
+
+# neuromeka_vfm
+
+클라이언트 PC에서 Segmentation (SAM2, Grounding DINO), Pose Estimation (NVIDIA FoundationPose) 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
+
+- 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
+
+## VFM (Vision Foundation Model) latency benchmark
+로컬 서버 구동 시 측정. 빈칸은 아직 미측정 항목입니다. 
+
+**RTX 5060**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) | 0.86 | 0.35 | 0.50 | 0.52 |
+| DINOv2 | image prompt | 0.85 | 0.49 | 0.65 | 0.63 |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+**RTX 5090**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) |  |  |  |  |
+| DINOv2 | image prompt |  |  |  |  |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+
+## Installation
+```bash
+pip install neuromeka_vfm
+```
+
+## 사용 예
+### Python API
+```python
+from neuromeka_vfm import PoseEstimation, upload_mesh
+# (옵션) Realtime segmentation client도 포함됩니다.
+
+# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
+upload_mesh(
+    host="192.168.10.72",
+    user="user",
+    password="pass",          # 또는 key="~/.ssh/id_rsa"
+    local="mesh/123.stl",
+    remote="/home/user/meshes/123.stl",
+)
+
+# 2) PoseEstimation 클라이언트
+pose = PoseEstimation(host="192.168.10.72", port=5557)
+pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
+# ...
+pose.close()
+
+# 3) Realtime segmentation client (예)
+from neuromeka_vfm import Segmentation
+seg = Segmentation(
+    hostname="192.168.10.63",
+    port=5432,                     # 해당 도커/서버 포트
+    compression_strategy="png",    # none | png | jpeg | h264
+    benchmark=False,
+)
+# seg.register_first_frame(...)
+# seg.get_next(...)
+# seg.reset()
+# seg.finish()
+```
+
+## 주의
+- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
+- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
+
+
+
+## API 레퍼런스 (Python)
+
+### PoseEstimation (FoundationPose RPC)
+- `PoseEstimation(host=None, port=None)`
+    - `host`: FoundationPose 도커 서버가 구동 중인 PC의 IP.
+    - `port`: 5557
+- `init(mesh_path, apply_scale=1.0, force_apply_color=False, apply_color=(160,160,160), est_refine_iter=10, track_refine_iter=3, min_n_views=40, inplane_step=60)`: 서버에 메쉬 등록 및 초기화.
+- `register(rgb, depth, mask, K, iteration=None, check_vram=True)`: 첫 프레임 등록. `iteration`을 생략하면 서버 기본 반복 횟수를 사용하며, `check_vram=False`로 두면 GPU 메모리 사전 체크를 건너뜁니다.
+- `track(rgb, depth, K, iteration=None, bbox_xywh=None)`: 추적/갱신. `bbox_xywh` 제공 시 해당 영역으로 탐색 범위를 좁힙니다.
+- `reset()`: 세션 리셋.
+- `reset_object()`: 캐시된 메쉬로 서버 측 `reset_object` 재호출.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### Segmentation (실시간 SAM2/GroundingDINO)
+- `Segmentation(hostname, port, compression_strategy="none", benchmark=False)`:
+    - `compression_strategy`: `none|png|jpeg|h264`
+    - `hostname`: 세그멘테이션 도커 서버가 구동 중인 PC의 IP.
+- `add_image_prompt(object_name, object_image)`: 이미지 프롬프트 등록.
+- `register_first_frame(frame, prompt, use_image_prompt=False) -> bool`: 첫 프레임 등록, 성공 시 `True` 반환. `use_image_prompt=True`면 모든 이름을 사전에 `add_image_prompt`로 등록해야 합니다(누락 시 `ValueError`).
+- `get_next(frame) -> dict[obj_id, mask] | None`: 다음 프레임 세그멘테이션/트래킹 결과.
+- `switch_compression_strategy(compression_strategy)`: 런타임 압축 방식 교체.
+- `reset()`: 내부 상태 및 벤치마크 타이머 리셋.
+- `finish()`: 로컬 상태 초기화.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### 업로드 CLI/API
+- `upload_mesh(host, user, port=22, password=None, key=None, local=None, remote=None)`: SSH/SFTP로 메쉬 전송, 비밀번호 또는 키 중 하나 필수.
+- CLI: `neuromeka-upload-mesh --host ... --user ... (--password ... | --key ...) --local ... --remote ...`
+
+### 예제
+- 실시간 Pose + Segmentation 데모: `python -m neuromeka_vfm.examples.pose_demo` (RealSense 필요, 서버 실행 상태에서 사용).
+
+
+## 릴리스 노트
+- 0.1.1: PoseEstimation/Segmentation에서 리소스 정리 개선, iteration 미전달 시 서버 기본값 사용, pose 데모 예제 추가.
+- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.

neuromeka_vfm-0.1.2/README.md

@@ -0,0 +1,113 @@
+# neuromeka_vfm
+
+클라이언트 PC에서 Segmentation (SAM2, Grounding DINO), Pose Estimation (NVIDIA FoundationPose) 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
+
+- 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
+
+## VFM (Vision Foundation Model) latency benchmark
+로컬 서버 구동 시 측정. 빈칸은 아직 미측정 항목입니다. 
+
+**RTX 5060**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) | 0.86 | 0.35 | 0.50 | 0.52 |
+| DINOv2 | image prompt | 0.85 | 0.49 | 0.65 | 0.63 |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+**RTX 5090**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) |  |  |  |  |
+| DINOv2 | image prompt |  |  |  |  |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+
+## Installation
+```bash
+pip install neuromeka_vfm
+```
+
+## 사용 예
+### Python API
+```python
+from neuromeka_vfm import PoseEstimation, upload_mesh
+# (옵션) Realtime segmentation client도 포함됩니다.
+
+# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
+upload_mesh(
+    host="192.168.10.72",
+    user="user",
+    password="pass",          # 또는 key="~/.ssh/id_rsa"
+    local="mesh/123.stl",
+    remote="/home/user/meshes/123.stl",
+)
+
+# 2) PoseEstimation 클라이언트
+pose = PoseEstimation(host="192.168.10.72", port=5557)
+pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
+# ...
+pose.close()
+
+# 3) Realtime segmentation client (예)
+from neuromeka_vfm import Segmentation
+seg = Segmentation(
+    hostname="192.168.10.63",
+    port=5432,                     # 해당 도커/서버 포트
+    compression_strategy="png",    # none | png | jpeg | h264
+    benchmark=False,
+)
+# seg.register_first_frame(...)
+# seg.get_next(...)
+# seg.reset()
+# seg.finish()
+```
+
+## 주의
+- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
+- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
+
+
+
+## API 레퍼런스 (Python)
+
+### PoseEstimation (FoundationPose RPC)
+- `PoseEstimation(host=None, port=None)`
+    - `host`: FoundationPose 도커 서버가 구동 중인 PC의 IP.
+    - `port`: 5557
+- `init(mesh_path, apply_scale=1.0, force_apply_color=False, apply_color=(160,160,160), est_refine_iter=10, track_refine_iter=3, min_n_views=40, inplane_step=60)`: 서버에 메쉬 등록 및 초기화.
+- `register(rgb, depth, mask, K, iteration=None, check_vram=True)`: 첫 프레임 등록. `iteration`을 생략하면 서버 기본 반복 횟수를 사용하며, `check_vram=False`로 두면 GPU 메모리 사전 체크를 건너뜁니다.
+- `track(rgb, depth, K, iteration=None, bbox_xywh=None)`: 추적/갱신. `bbox_xywh` 제공 시 해당 영역으로 탐색 범위를 좁힙니다.
+- `reset()`: 세션 리셋.
+- `reset_object()`: 캐시된 메쉬로 서버 측 `reset_object` 재호출.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### Segmentation (실시간 SAM2/GroundingDINO)
+- `Segmentation(hostname, port, compression_strategy="none", benchmark=False)`:
+    - `compression_strategy`: `none|png|jpeg|h264`
+    - `hostname`: 세그멘테이션 도커 서버가 구동 중인 PC의 IP.
+- `add_image_prompt(object_name, object_image)`: 이미지 프롬프트 등록.
+- `register_first_frame(frame, prompt, use_image_prompt=False) -> bool`: 첫 프레임 등록, 성공 시 `True` 반환. `use_image_prompt=True`면 모든 이름을 사전에 `add_image_prompt`로 등록해야 합니다(누락 시 `ValueError`).
+- `get_next(frame) -> dict[obj_id, mask] | None`: 다음 프레임 세그멘테이션/트래킹 결과.
+- `switch_compression_strategy(compression_strategy)`: 런타임 압축 방식 교체.
+- `reset()`: 내부 상태 및 벤치마크 타이머 리셋.
+- `finish()`: 로컬 상태 초기화.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### 업로드 CLI/API
+- `upload_mesh(host, user, port=22, password=None, key=None, local=None, remote=None)`: SSH/SFTP로 메쉬 전송, 비밀번호 또는 키 중 하나 필수.
+- CLI: `neuromeka-upload-mesh --host ... --user ... (--password ... | --key ...) --local ... --remote ...`
+
+### 예제
+- 실시간 Pose + Segmentation 데모: `python -m neuromeka_vfm.examples.pose_demo` (RealSense 필요, 서버 실행 상태에서 사용).
+
+
+## 릴리스 노트
+- 0.1.1: PoseEstimation/Segmentation에서 리소스 정리 개선, iteration 미전달 시 서버 기본값 사용, pose 데모 예제 추가.
+- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.

{neuromeka_vfm-0.1.0 → neuromeka_vfm-0.1.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "neuromeka_vfm"
-version = "0.1.0"
+version = "0.1.2"
 description = "Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)"
 readme = "README.md"
 requires-python = ">=3.8"

neuromeka_vfm-0.1.2/src/neuromeka_vfm/examples/__init__.py

@@ -0,0 +1 @@
+# Examples package for neuromeka_vfm

neuromeka_vfm-0.1.2/src/neuromeka_vfm/examples/pose_demo.py

@@ -0,0 +1,364 @@
+"""
+Real-time demo using neuromeka_vfm Segmentation + PoseEstimation clients.
+- Streams RGB/Depth from an attached RealSense
+- Uses segmentation masks to register/track in FoundationPose
+- Renders 3D bounding box + axes overlay in a window
+
+Requirements:
+- A running segmentation server (SAM2/GroundingDINO) reachable by ZeroMQ
+- A running FoundationPose RPC server
+- A connected RealSense camera (pyrealsense2 installed)
+"""
+
+import os
+import time
+from typing import Optional, Tuple
+
+import cv2
+import numpy as np
+import pyrealsense2 as rs
+
+from neuromeka_vfm import PoseEstimation, Segmentation
+
+
+def to_homogeneous(pts: np.ndarray) -> np.ndarray:
+    """Append 1.0 to points for homogeneous projection."""
+    assert pts.ndim == 2, f"Expected (N,2|3), got {pts.shape}"
+    return np.concatenate((pts, np.ones((pts.shape[0], 1))), axis=-1)
+
+
+def draw_posed_3d_box(
+    K: np.ndarray,
+    img: np.ndarray,
+    ob_in_cam: np.ndarray,
+    bbox: np.ndarray,
+    line_color=(0, 255, 0),
+    linewidth=2,
+) -> np.ndarray:
+    """Project a 3D bbox onto the image."""
+
+    def project_line(start, end, canvas):
+        pts = np.stack((start, end), axis=0).reshape(-1, 3)
+        pts = (ob_in_cam @ to_homogeneous(pts).T).T[:, :3]
+        projected = (K @ pts.T).T
+        uv = np.round(projected[:, :2] / projected[:, 2].reshape(-1, 1)).astype(int)
+        return cv2.line(
+            canvas,
+            uv[0].tolist(),
+            uv[1].tolist(),
+            color=line_color,
+            thickness=linewidth,
+            lineType=cv2.LINE_AA,
+        )
+
+    min_xyz = bbox.min(axis=0)
+    max_xyz = bbox.max(axis=0)
+    xmin, ymin, zmin = min_xyz
+    xmax, ymax, zmax = max_xyz
+
+    for y in [ymin, ymax]:
+        for z in [zmin, zmax]:
+            start = np.array([xmin, y, z])
+            end = start + np.array([xmax - xmin, 0, 0])
+            img = project_line(start, end, img)
+
+    for x in [xmin, xmax]:
+        for z in [zmin, zmax]:
+            start = np.array([x, ymin, z])
+            end = start + np.array([0, ymax - ymin, 0])
+            img = project_line(start, end, img)
+
+    for x in [xmin, xmax]:
+        for y in [ymin, ymax]:
+            start = np.array([x, y, zmin])
+            end = start + np.array([0, 0, zmax - zmin])
+            img = project_line(start, end, img)
+    return img
+
+
+def project_point(pt: np.ndarray, K: np.ndarray, ob_in_cam: np.ndarray) -> np.ndarray:
+    pt = pt.reshape(4, 1)
+    projected = K @ ((ob_in_cam @ pt)[:3, :])
+    projected = projected.reshape(-1)
+    projected = projected / projected[2]
+    return projected[:2].round().astype(int)
+
+
+def draw_axes(
+    img: np.ndarray,
+    ob_in_cam: np.ndarray,
+    scale: float,
+    K: np.ndarray,
+    thickness: int = 3,
+    transparency: float = 0.0,
+    is_input_rgb: bool = False,
+) -> np.ndarray:
+    """Overlay XYZ axes."""
+    if is_input_rgb:
+        img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)
+    origin = tuple(project_point(np.array([0, 0, 0, 1]), K, ob_in_cam))
+    xx = tuple(project_point(np.array([scale, 0, 0, 1]), K, ob_in_cam))
+    yy = tuple(project_point(np.array([0, scale, 0, 1]), K, ob_in_cam))
+    zz = tuple(project_point(np.array([0, 0, scale, 1]), K, ob_in_cam))
+
+    base = img.copy()
+    next_img = cv2.arrowedLine(base.copy(), origin, xx, color=(0, 0, 255), thickness=thickness, line_type=cv2.LINE_AA)
+    mask = np.linalg.norm(next_img - base, axis=-1) > 0
+    base[mask] = base[mask] * transparency + next_img[mask] * (1 - transparency)
+
+    next_img = cv2.arrowedLine(base.copy(), origin, yy, color=(0, 255, 0), thickness=thickness, line_type=cv2.LINE_AA)
+    mask = np.linalg.norm(next_img - base, axis=-1) > 0
+    base[mask] = base[mask] * transparency + next_img[mask] * (1 - transparency)
+
+    next_img = cv2.arrowedLine(base.copy(), origin, zz, color=(255, 0, 0), thickness=thickness, line_type=cv2.LINE_AA)
+    mask = np.linalg.norm(next_img - base, axis=-1) > 0
+    base[mask] = base[mask] * transparency + next_img[mask] * (1 - transparency)
+
+    if is_input_rgb:
+        base = cv2.cvtColor(base.astype(np.uint8), cv2.COLOR_BGR2RGB)
+    return base.astype(np.uint8)
+
+
+def setup_realsense(
+    rgb_shape: Tuple[int, int] = (960, 540),
+    depth_shape: Tuple[int, int] = (640, 480),
+    fps: int = 30,
+) -> Tuple[rs.pipeline, rs.align, float, np.ndarray]:
+    pipeline = rs.pipeline()
+    config = rs.config()
+    config.enable_stream(rs.stream.color, rgb_shape[0], rgb_shape[1], rs.format.bgr8, fps)
+    config.enable_stream(rs.stream.depth, depth_shape[0], depth_shape[1], rs.format.z16, fps)
+
+    profile = pipeline.start(config)
+    align_to_color = rs.align(rs.stream.color)
+
+    depth_sensor = profile.get_device().first_depth_sensor()
+    depth_scale = depth_sensor.get_depth_scale()
+
+    color_stream = profile.get_stream(rs.stream.color).as_video_stream_profile()
+    intr = color_stream.get_intrinsics()
+    cam_K = np.array(
+        [[intr.fx, 0.0, intr.ppx], [0.0, intr.fy, intr.ppy], [0.0, 0.0, 1.0]],
+        dtype=np.float32,
+    )
+    print("Intrinsics W,H:", intr.width, intr.height)
+    print("cam_K:\n", cam_K)
+    print("Depth scale:", depth_scale)
+    if depth_sensor.supports(rs.option.min_distance):
+        print("min_distance:", depth_sensor.get_option(rs.option.min_distance))
+    if depth_sensor.supports(rs.option.max_distance):
+        print("max_distance:", depth_sensor.get_option(rs.option.max_distance))
+
+    return pipeline, align_to_color, depth_scale, cam_K
+
+
+def to_binary_mask(mask_obj: Optional[object]) -> Optional[np.ndarray]:
+    """Normalize mask outputs (dict/array) to a single uint8 binary mask."""
+    if mask_obj is None:
+        return None
+    if isinstance(mask_obj, dict):
+        if not mask_obj:
+            return None
+        mask_arrays = [np.asarray(m) for m in mask_obj.values() if m is not None]
+        if not mask_arrays:
+            return None
+        mask_arrays = [np.squeeze(m) for m in mask_arrays]
+        mask = np.zeros_like(mask_arrays[0], dtype=np.uint8)
+        for m in mask_arrays:
+            mask |= (np.asarray(m) > 0).astype(np.uint8)
+        if mask.ndim > 2:
+            mask = np.squeeze(mask)
+        return mask.astype(np.uint8)
+
+    mask_arr = np.asarray(mask_obj)
+    if mask_arr.ndim > 2:
+        mask_arr = np.squeeze(mask_arr)
+    if mask_arr.ndim > 2:
+        mask_arr = mask_arr[..., 0]
+    return (mask_arr > 0).astype(np.uint8)
+
+
+def bbox_to_mask(bbox_xywh, shape_hw) -> Optional[np.ndarray]:
+    """Convert xywh bbox to a binary mask."""
+    if bbox_xywh is None:
+        return None
+    x, y, w, h = bbox_xywh
+    h_img, w_img = shape_hw
+    if w <= 0 or h <= 0:
+        return None
+    mask = np.zeros((h_img, w_img), dtype=np.uint8)
+    x0, y0 = int(x), int(y)
+    x1, y1 = min(w_img, x0 + int(w)), min(h_img, y0 + int(h))
+    mask[y0:y1, x0:x1] = 1
+    return mask
+
+
+def overlay_mask(img_rgb: np.ndarray, mask: Optional[np.ndarray]) -> np.ndarray:
+    if mask is None:
+        return img_rgb
+    mask_bool = mask.astype(bool)
+    if not np.any(mask_bool):
+        return img_rgb
+    overlay = img_rgb.copy()
+    overlay_color = np.array([0, 255, 0], dtype=overlay.dtype)
+    overlay[mask_bool] = (
+        0.6 * overlay[mask_bool].astype(np.float32) + 0.4 * overlay_color.astype(np.float32)
+    ).astype(overlay.dtype)
+    return overlay
+
+
+def bbox_from_mask(mask_np: np.ndarray):
+    erosion_size = 5
+    kernel = np.ones((erosion_size, erosion_size), np.uint8)
+    mask_np = cv2.erode(mask_np.astype(np.uint8), kernel, iterations=1)
+
+    rows = np.any(mask_np, axis=1)
+    cols = np.any(mask_np, axis=0)
+    if np.any(rows) and np.any(cols):
+        y_min, y_max = np.where(rows)[0][[0, -1]]
+        x_min, x_max = np.where(cols)[0][[0, -1]]
+        bbox = [x_min, y_min, x_max - x_min, y_max - y_min]
+    else:
+        bbox = [-1, -1, 0, 0]
+    return bbox
+
+
+def main():
+    mesh_path = os.environ.get("FPOSE_MESH_PATH", "/app/modules/foundation_pose/mesh/drug_box.stl")
+    fpose_host = os.environ.get("FPOSE_HOST", "192.168.10.69")
+    fpose_port = int(os.environ.get("FPOSE_PORT", "5557"))
+    seg_host = os.environ.get("SEG_HOST", "192.168.10.69")
+    seg_port = int(os.environ.get("SEG_PORT", "5432"))
+    seg_prompt = os.environ.get("SEG_PROMPT", "piece")
+    seg_ref_image = os.environ.get("SEG_REF_IMAGE", "piece.jpg")
+    seg_compression = os.environ.get("SEG_COMPRESSION", "none")
+
+    pipeline, align_to_color, depth_scale, cam_K = setup_realsense()
+
+    print("Init detector. path", seg_ref_image)
+    detector = Segmentation(seg_host, seg_port, compression_strategy=seg_compression)
+    use_image_prompt = False
+    if os.path.exists(seg_ref_image):
+        ref_img = cv2.imread(seg_ref_image)
+        if ref_img is not None:
+            ref_rgb = cv2.cvtColor(ref_img, cv2.COLOR_BGR2RGB)
+            detector.add_image_prompt(seg_prompt, ref_rgb)
+            use_image_prompt = True
+            print(f"Loaded image prompt '{seg_ref_image}' for '{seg_prompt}'")
+        else:
+            print(f"Failed to load reference image at {seg_ref_image}, falling back to text prompt.")
+    else:
+        print(f"Reference image {seg_ref_image} not found; using text prompt only.")
+
+    print("Init FP")
+    pose = PoseEstimation(host=fpose_host, port=fpose_port)
+    init_resp = pose.init(
+        mesh_path=mesh_path,
+        apply_scale=float(os.environ.get("FPOSE_APPLY_SCALE", "1.0")),
+        force_apply_color=os.environ.get("FPOSE_FORCE_APPLY_COLOR", "false").lower() == "true",
+        apply_color=tuple(map(float, os.environ.get("FPOSE_APPLY_COLOR", "160,160,160").split(","))),
+        est_refine_iter=int(7),
+        track_refine_iter=int(3),
+        min_n_views=int(5),
+        inplane_step=int(150),
+    )
+    if init_resp.get("result") != "SUCCESS":
+        print("Init failed:", init_resp)
+        return
+    to_origin = np.asarray(init_resp["data"]["to_origin"])
+    bbox = np.asarray(init_resp["data"]["bbox"])
+
+    initialized = False
+    current_pose = None
+    current_mask = None
+
+    cv2.namedWindow("neuromeka_vfm Pose Demo", cv2.WINDOW_NORMAL)
+
+    try:
+        while True:
+            frames = pipeline.wait_for_frames()
+            frames = align_to_color.process(frames)
+            color_frame = frames.get_color_frame()
+            depth_frame = frames.get_depth_frame()
+            if not color_frame or not depth_frame:
+                continue
+
+            color_bgr = np.asanyarray(color_frame.get_data())
+            depth = np.asanyarray(depth_frame.get_data()).astype(np.float32)
+            depth *= depth_scale
+            depth[(depth < 0.001) | np.isinf(depth)] = 0
+            color = cv2.cvtColor(color_bgr, cv2.COLOR_BGR2RGB)
+
+            if not initialized:
+                tic = time.time()
+                if detector.register_first_frame(color, seg_prompt, use_image_prompt=use_image_prompt):
+                    detector.get_next(color)
+                    init_mask_raw = detector.current_frame_masks
+                else:
+                    init_mask_raw = None
+                    print("First segmentation failed.")
+                    cv2.imshow("neuromeka_vfm Pose Demo", color_bgr)
+                    if cv2.waitKey(1) & 0xFF == 27:
+                        break
+                    continue
+
+                init_mask = to_binary_mask(init_mask_raw)
+                if init_mask is None:
+                    print("No mask returned on first frame.")
+                    continue
+                mask_uint8 = init_mask.astype(np.uint8) * 255
+
+                resp = pose.register(rgb=color, depth=depth, mask=mask_uint8, K=cam_K, iteration=7)
+                if resp.get("result") != "SUCCESS":
+                    print("Register failed:", resp)
+                    continue
+                current_pose = np.asarray(resp["data"]["pose"])
+                current_mask = init_mask
+                initialized = True
+                print(f"Registration: {time.time() - tic:.4f}s")
+            else:
+                tic = time.time()
+                detector.get_next(color)
+                current_mask_raw = detector.current_frame_masks
+                current_mask = to_binary_mask(current_mask_raw)
+                bbox_xywh = bbox_from_mask(current_mask) if current_mask is not None else None
+                if bbox_xywh is not None and (bbox_xywh[2] <= 0 or bbox_xywh[3] <= 0):
+                    bbox_xywh = None
+                resp = pose.track(rgb=color, depth=depth, K=cam_K, iteration=3, bbox_xywh=bbox_xywh)
+                if resp.get("result") != "SUCCESS":
+                    print("Track failed:", resp)
+                    continue
+                data = resp.get("data", {})
+                current_pose = np.asarray(data.get("pose"))
+                print(f"Track: {time.time() - tic:.4f}s")
+
+            pose_np = current_pose[0] if current_pose.ndim == 3 else current_pose
+            center_pose = pose_np @ np.linalg.inv(to_origin)
+            vis_rgb = overlay_mask(color, current_mask)
+            vis_rgb = draw_posed_3d_box(cam_K, img=vis_rgb, ob_in_cam=center_pose, bbox=bbox)
+            vis_rgb = draw_axes(
+                vis_rgb,
+                ob_in_cam=center_pose,
+                scale=0.1,
+                K=cam_K,
+                thickness=3,
+                transparency=0,
+                is_input_rgb=True,
+            )
+
+            vis_bgr = cv2.cvtColor(vis_rgb, cv2.COLOR_RGB2BGR)
+            cv2.imshow("neuromeka_vfm Pose Demo", vis_bgr)
+            if cv2.waitKey(1) & 0xFF == 27:
+                break
+
+    except KeyboardInterrupt:
+        pass
+    finally:
+        detector.close()
+        pipeline.stop()
+        cv2.destroyAllWindows()
+        pose.close()
+
+
+if __name__ == "__main__":
+    main()

{neuromeka_vfm-0.1.0 → neuromeka_vfm-0.1.2}/src/neuromeka_vfm/pose_estimation.py

@@ -41,29 +41,38 @@ class PoseEstimation:
             }
         )
 
-    def register(self, rgb: np.ndarray, depth: np.ndarray, mask: np.ndarray, K: np.ndarray, iteration: int = None):
-        return self.client.send_data(
-            {
-                "operation": "register",
-                "rgb": rgb,
-                "depth": depth,
-                "mask": mask,
-                "K": K,
-                "iteration": iteration,
-            }
-        )
+    def register(
+        self,
+        rgb: np.ndarray,
+        depth: np.ndarray,
+        mask: np.ndarray,
+        K: np.ndarray,
+        iteration: int = None,
+        check_vram: bool = True,
+    ):
+        payload = {
+            "operation": "register",
+            "rgb": rgb,
+            "depth": depth,
+            "mask": mask,
+            "K": K,
+            "check_vram": bool(check_vram),
+        }
+        if iteration is not None:
+            payload["iteration"] = iteration
+        return self.client.send_data(payload)
 
     def track(self, rgb: np.ndarray, depth: np.ndarray, K: np.ndarray, iteration: int = None, bbox_xywh=None):
-        return self.client.send_data(
-            {
-                "operation": "track",
-                "rgb": rgb,
-                "depth": depth,
-                "K": K,
-                "iteration": iteration,
-                "bbox_xywh": bbox_xywh,
-            }
-        )
+        payload = {
+            "operation": "track",
+            "rgb": rgb,
+            "depth": depth,
+            "K": K,
+            "bbox_xywh": bbox_xywh,
+        }
+        if iteration is not None:
+            payload["iteration"] = iteration
+        return self.client.send_data(payload)
 
     def reset(self):
         return self.client.send_data({"operation": "reset"})

{neuromeka_vfm-0.1.0 → neuromeka_vfm-0.1.2}/src/neuromeka_vfm/segmentation.py

@@ -16,6 +16,7 @@ class Segmentation:
         self.client = PickleClient(hostname, port)
         self.tracking_object_ids = []
         self.current_frame_masks = {}
+        self.image_prompt_names = set()
         if compression_strategy in STRATEGIES:
             self.compression_strategy_name = compression_strategy
         else:
@@ -45,6 +46,8 @@ class Segmentation:
             start = time.time()
         data = {"operation": "add_image_prompt", "object_name": object_name, "object_image": object_image}
         response = self.client.send_data(data)
+        if response.get("result") == "SUCCESS":
+            self.image_prompt_names.add(object_name)
         if self.benchmark:
             self.call_time["add_image_prompt"] += time.time() - start
             self.call_count["add_image_prompt"] += 1
@@ -53,10 +56,17 @@ class Segmentation:
     def register_first_frame(self, frame: np.ndarray, prompt: Union[str, List[str]], use_image_prompt: bool = False):
         if self.benchmark:
             start = time.time()
+        prompt_to_send = prompt
+        if use_image_prompt:
+            prompt_list = prompt if isinstance(prompt, list) else [prompt]
+            missing = [p for p in prompt_list if p not in self.image_prompt_names]
+            if missing:
+                raise ValueError(f"Image prompt(s) not registered: {missing}. Call add_image_prompt first.")
+            prompt_to_send = prompt_list
         self.compression_strategy = STRATEGIES[self.compression_strategy_name](frame)
         data = {
             "operation": "start",
-            "prompt": prompt,
+            "prompt": prompt_to_send,
             "frame": self.compression_strategy.encode(frame),
             "use_image_prompt": use_image_prompt,
             "compression_strategy": self.compression_strategy_name,
@@ -111,6 +121,13 @@ class Segmentation:
         self.tracking_object_ids = []
         self.current_frame_masks = {}
 
+    def close(self):
+        """Close underlying ZeroMQ socket/context."""
+        try:
+            self.finish()
+        finally:
+            self.client.close()
+
 
 # Backward-compat alias
 NrmkRealtimeSegmentation = Segmentation

{neuromeka_vfm-0.1.0 → neuromeka_vfm-0.1.2}/src/neuromeka_vfm/upload_mesh.py

@@ -10,7 +10,7 @@ import sys
 import paramiko
 
 
-def upload_mesh(host: str, port: int = 22, user: str, password: str = None, key: str = None, local: str = None, remote: str = None):
+def upload_mesh(host: str, user: str, port: int = 22, password: str = None, key: str = None, local: str = None, remote: str = None):
     if not local or not remote:
         raise ValueError("local and remote paths are required")
     if not os.path.isfile(local):

neuromeka_vfm-0.1.2/src/neuromeka_vfm.egg-info/PKG-INFO

@@ -0,0 +1,159 @@
+Metadata-Version: 2.4
+Name: neuromeka_vfm
+Version: 0.1.2
+Summary: Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)
+Author: Neuromeka
+License: MIT License
+        
+        Copyright (c) 2025 Neuromeka Co., Ltd.
+        
+        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.
+        
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy
+Requires-Dist: pyzmq
+Requires-Dist: paramiko
+Requires-Dist: av
+Requires-Dist: opencv-python-headless
+Dynamic: license-file
+
+# neuromeka_vfm
+
+클라이언트 PC에서 Segmentation (SAM2, Grounding DINO), Pose Estimation (NVIDIA FoundationPose) 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
+
+- 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
+
+## VFM (Vision Foundation Model) latency benchmark
+로컬 서버 구동 시 측정. 빈칸은 아직 미측정 항목입니다. 
+
+**RTX 5060**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) | 0.86 | 0.35 | 0.50 | 0.52 |
+| DINOv2 | image prompt | 0.85 | 0.49 | 0.65 | 0.63 |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+**RTX 5090**
+| Task | Prompt | None (s) | JPEG (s) | PNG (s) | h264 (s) |
+| --- | --- | --- | --- | --- | --- |
+| Grounding DINO | text (human . cup .) |  |  |  |  |
+| DINOv2 | image prompt |  |  |  |  |
+| SAM2 | - |  |  |  |  |
+| FoundationPose registration | - |  |  |  |  |
+| FoundationPose track | - |  |  |  |  |
+
+
+## Installation
+```bash
+pip install neuromeka_vfm
+```
+
+## 사용 예
+### Python API
+```python
+from neuromeka_vfm import PoseEstimation, upload_mesh
+# (옵션) Realtime segmentation client도 포함됩니다.
+
+# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
+upload_mesh(
+    host="192.168.10.72",
+    user="user",
+    password="pass",          # 또는 key="~/.ssh/id_rsa"
+    local="mesh/123.stl",
+    remote="/home/user/meshes/123.stl",
+)
+
+# 2) PoseEstimation 클라이언트
+pose = PoseEstimation(host="192.168.10.72", port=5557)
+pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
+# ...
+pose.close()
+
+# 3) Realtime segmentation client (예)
+from neuromeka_vfm import Segmentation
+seg = Segmentation(
+    hostname="192.168.10.63",
+    port=5432,                     # 해당 도커/서버 포트
+    compression_strategy="png",    # none | png | jpeg | h264
+    benchmark=False,
+)
+# seg.register_first_frame(...)
+# seg.get_next(...)
+# seg.reset()
+# seg.finish()
+```
+
+## 주의
+- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
+- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
+
+
+
+## API 레퍼런스 (Python)
+
+### PoseEstimation (FoundationPose RPC)
+- `PoseEstimation(host=None, port=None)`
+    - `host`: FoundationPose 도커 서버가 구동 중인 PC의 IP.
+    - `port`: 5557
+- `init(mesh_path, apply_scale=1.0, force_apply_color=False, apply_color=(160,160,160), est_refine_iter=10, track_refine_iter=3, min_n_views=40, inplane_step=60)`: 서버에 메쉬 등록 및 초기화.
+- `register(rgb, depth, mask, K, iteration=None, check_vram=True)`: 첫 프레임 등록. `iteration`을 생략하면 서버 기본 반복 횟수를 사용하며, `check_vram=False`로 두면 GPU 메모리 사전 체크를 건너뜁니다.
+- `track(rgb, depth, K, iteration=None, bbox_xywh=None)`: 추적/갱신. `bbox_xywh` 제공 시 해당 영역으로 탐색 범위를 좁힙니다.
+- `reset()`: 세션 리셋.
+- `reset_object()`: 캐시된 메쉬로 서버 측 `reset_object` 재호출.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### Segmentation (실시간 SAM2/GroundingDINO)
+- `Segmentation(hostname, port, compression_strategy="none", benchmark=False)`:
+    - `compression_strategy`: `none|png|jpeg|h264`
+    - `hostname`: 세그멘테이션 도커 서버가 구동 중인 PC의 IP.
+- `add_image_prompt(object_name, object_image)`: 이미지 프롬프트 등록.
+- `register_first_frame(frame, prompt, use_image_prompt=False) -> bool`: 첫 프레임 등록, 성공 시 `True` 반환. `use_image_prompt=True`면 모든 이름을 사전에 `add_image_prompt`로 등록해야 합니다(누락 시 `ValueError`).
+- `get_next(frame) -> dict[obj_id, mask] | None`: 다음 프레임 세그멘테이션/트래킹 결과.
+- `switch_compression_strategy(compression_strategy)`: 런타임 압축 방식 교체.
+- `reset()`: 내부 상태 및 벤치마크 타이머 리셋.
+- `finish()`: 로컬 상태 초기화.
+- `close()`: ZeroMQ 소켓/컨텍스트 정리 (사용 후 필수 호출 권장).
+
+### 업로드 CLI/API
+- `upload_mesh(host, user, port=22, password=None, key=None, local=None, remote=None)`: SSH/SFTP로 메쉬 전송, 비밀번호 또는 키 중 하나 필수.
+- CLI: `neuromeka-upload-mesh --host ... --user ... (--password ... | --key ...) --local ... --remote ...`
+
+### 예제
+- 실시간 Pose + Segmentation 데모: `python -m neuromeka_vfm.examples.pose_demo` (RealSense 필요, 서버 실행 상태에서 사용).
+
+
+## 릴리스 노트
+- 0.1.1: PoseEstimation/Segmentation에서 리소스 정리 개선, iteration 미전달 시 서버 기본값 사용, pose 데모 예제 추가.
+- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.

{neuromeka_vfm-0.1.0 → neuromeka_vfm-0.1.2}/src/neuromeka_vfm.egg-info/SOURCES.txt

@@ -12,4 +12,6 @@ src/neuromeka_vfm.egg-info/SOURCES.txt
 src/neuromeka_vfm.egg-info/dependency_links.txt
 src/neuromeka_vfm.egg-info/entry_points.txt
 src/neuromeka_vfm.egg-info/requires.txt
-src/neuromeka_vfm.egg-info/top_level.txt
+src/neuromeka_vfm.egg-info/top_level.txt
+src/neuromeka_vfm/examples/__init__.py
+src/neuromeka_vfm/examples/pose_demo.py

neuromeka_vfm-0.1.0/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.1
-Name: neuromeka_vfm
-Version: 0.1.0
-Summary: Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)
-Author: Neuromeka
-License: MIT License
-        
-        Copyright (c) 2025 Neuromeka Co., Ltd.
-        
-        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.
-        
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pyzmq
-Requires-Dist: paramiko
-Requires-Dist: av
-Requires-Dist: opencv-python-headless
-
-# neuromeka_vfm
-
-클라이언트 PC에서 FoundationPose 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
-
-## 설치
-```bash
-pip install neuromeka_vfm
-```
-
-### 로컬 개발
-```bash
-pip install -e .
-```
-
-## 사용 예
-### Python API
-```python
-from neuromeka_vfm import PoseEstimation, upload_mesh
-# (옵션) Realtime segmentation client도 포함됩니다.
-
-# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
-upload_mesh(
-    host="192.168.10.72",
-    user="user",
-    password="pass",          # 또는 key="~/.ssh/id_rsa"
-    local="mesh/123.stl",
-    remote="/home/user/meshes/123.stl",
-)
-
-# 2) PoseEstimation 클라이언트
-pose = PoseEstimation(host="192.168.10.72", port=5557)
-pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
-# ...
-pose.close()
-
-# 3) Realtime segmentation client (예)
-from neuromeka_vfm import Segmentation
-seg = Segmentation(
-    hostname="192.168.10.72",
-    port=5432,                     # 해당 도커/서버 포트
-    compression_strategy="png",    # none | png | jpeg | h264
-    benchmark=False,
-)
-# seg.register_first_frame(...), seg.get_next(...), seg.finish(), seg.reset()
-```
-
-### CLI 업로드
-```bash
-neuromeka-upload-mesh --host 192.168.10.72 --user user --password pass \
-  --local mesh/123.stl --remote /home/user/meshes/123.stl
-```
-
-## 주의
-- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
-- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
-
-## 링크
-- 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
-
-## 릴리스 노트
-- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.

neuromeka_vfm-0.1.0/README.md

@@ -1,64 +0,0 @@
-# neuromeka_vfm
-
-클라이언트 PC에서 FoundationPose 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
-
-## 설치
-```bash
-pip install neuromeka_vfm
-```
-
-### 로컬 개발
-```bash
-pip install -e .
-```
-
-## 사용 예
-### Python API
-```python
-from neuromeka_vfm import PoseEstimation, upload_mesh
-# (옵션) Realtime segmentation client도 포함됩니다.
-
-# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
-upload_mesh(
-    host="192.168.10.72",
-    user="user",
-    password="pass",          # 또는 key="~/.ssh/id_rsa"
-    local="mesh/123.stl",
-    remote="/home/user/meshes/123.stl",
-)
-
-# 2) PoseEstimation 클라이언트
-pose = PoseEstimation(host="192.168.10.72", port=5557)
-pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
-# ...
-pose.close()
-
-# 3) Realtime segmentation client (예)
-from neuromeka_vfm import Segmentation
-seg = Segmentation(
-    hostname="192.168.10.72",
-    port=5432,                     # 해당 도커/서버 포트
-    compression_strategy="png",    # none | png | jpeg | h264
-    benchmark=False,
-)
-# seg.register_first_frame(...), seg.get_next(...), seg.finish(), seg.reset()
-```
-
-### CLI 업로드
-```bash
-neuromeka-upload-mesh --host 192.168.10.72 --user user --password pass \
-  --local mesh/123.stl --remote /home/user/meshes/123.stl
-```
-
-## 주의
-- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
-- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
-
-## 링크
-- 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
-
-## 릴리스 노트
-- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.

neuromeka_vfm-0.1.0/src/neuromeka_vfm.egg-info/PKG-INFO

@@ -1,109 +0,0 @@
-Metadata-Version: 2.1
-Name: neuromeka_vfm
-Version: 0.1.0
-Summary: Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)
-Author: Neuromeka
-License: MIT License
-        
-        Copyright (c) 2025 Neuromeka Co., Ltd.
-        
-        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.
-        
-Classifier: Development Status :: 3 - Alpha
-Classifier: Intended Audience :: Developers
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-License-File: LICENSE
-Requires-Dist: numpy
-Requires-Dist: pyzmq
-Requires-Dist: paramiko
-Requires-Dist: av
-Requires-Dist: opencv-python-headless
-
-# neuromeka_vfm
-
-클라이언트 PC에서 FoundationPose 서버(RPC, ZeroMQ)와 통신하고, SSH/SFTP로 호스트에 mesh를 업로드하는 간단한 유틸 패키지입니다.
-
-## 설치
-```bash
-pip install neuromeka_vfm
-```
-
-### 로컬 개발
-```bash
-pip install -e .
-```
-
-## 사용 예
-### Python API
-```python
-from neuromeka_vfm import PoseEstimation, upload_mesh
-# (옵션) Realtime segmentation client도 포함됩니다.
-
-# 1) 서버로 mesh 업로드 (호스트 경로는 컨테이너에 -v로 마운트된 곳)
-upload_mesh(
-    host="192.168.10.72",
-    user="user",
-    password="pass",          # 또는 key="~/.ssh/id_rsa"
-    local="mesh/123.stl",
-    remote="/home/user/meshes/123.stl",
-)
-
-# 2) PoseEstimation 클라이언트
-pose = PoseEstimation(host="192.168.10.72", port=5557)
-pose.init(mesh_path="/app/modules/foundation_pose/mesh/123.stl")
-# ...
-pose.close()
-
-# 3) Realtime segmentation client (예)
-from neuromeka_vfm import Segmentation
-seg = Segmentation(
-    hostname="192.168.10.72",
-    port=5432,                     # 해당 도커/서버 포트
-    compression_strategy="png",    # none | png | jpeg | h264
-    benchmark=False,
-)
-# seg.register_first_frame(...), seg.get_next(...), seg.finish(), seg.reset()
-```
-
-### CLI 업로드
-```bash
-neuromeka-upload-mesh --host 192.168.10.72 --user user --password pass \
-  --local mesh/123.stl --remote /home/user/meshes/123.stl
-```
-
-## 주의
-- `remote`는 **호스트** 경로입니다. 컨테이너 실행 시 `-v /home/user/meshes:/app/modules/foundation_pose/mesh`처럼 마운트하면, 업로드 직후 컨테이너에서 접근 가능합니다.
-- RPC 포트(기본 5557)는 서버가 `-p 5557:5557`으로 노출되어 있어야 합니다.
-
-## 링크
-- 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
-
-## 릴리스 노트
-- 0.1.0: 초기 공개 버전. FoundationPose RPC 클라이언트, 실시간 세그멘테이션 클라이언트, SSH 기반 mesh 업로드 CLI/API 포함.