neuromeka-vfm 0.1.1__tar.gz

neuromeka_vfm-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+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.

neuromeka_vfm-0.1.1/PKG-INFO

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: neuromeka_vfm
+Version: 0.1.1
+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.1/README.md

@@ -0,0 +1,64 @@
+# 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.1/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "neuromeka_vfm"
+version = "0.1.1"
+description = "Client utilities for Neuromeka VFM FoundationPose RPC (upload meshes, call server)"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {file = "LICENSE"}
+dependencies = [
+    "numpy",
+    "pyzmq",
+    "paramiko",
+    "av",
+    "opencv-python-headless",
+]
+authors = [{name = "Neuromeka"}]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+
+[project.scripts]
+neuromeka-upload-mesh = "neuromeka_vfm.upload_mesh:cli"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

neuromeka_vfm-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

neuromeka_vfm-0.1.1/src/neuromeka_vfm/__init__.py

@@ -0,0 +1,13 @@
+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
+
+__all__ = [
+    "PoseEstimation",
+    "FoundationPoseClient",
+    "upload_mesh",
+    "Segmentation",
+    "NrmkRealtimeSegmentation",
+    "SEGMENTATION_COMPRESSION_STRATEGIES",
+]

neuromeka_vfm-0.1.1/src/neuromeka_vfm/compression.py

@@ -0,0 +1,167 @@
+from abc import ABC, abstractmethod
+from fractions import Fraction
+import av
+import numpy as np
+import cv2
+
+
+class CompressionStrategy(ABC):
+    def __init__(self, first_frame):
+        pass
+
+    @abstractmethod
+    def encode(self, frame):
+        pass
+
+    @abstractmethod
+    def decode(self, payload):
+        pass
+
+
+class NoneStrategy(CompressionStrategy):
+    def encode(self, frame):
+        return frame
+
+    def decode(self, payload):
+        return payload
+
+
+class H264LosslessCompression(CompressionStrategy):
+    def __init__(self, first_frame):
+        super().__init__(first_frame)
+        self.fps = 20
+
+    def _to_rgb3_and_flag(self, arr: np.ndarray):
+        if arr.dtype != np.uint8:
+            raise ValueError("Input must be uint8.")
+        if arr.ndim == 3 and arr.shape[2] == 1:
+            arr = arr[:, :, 0]
+        if arr.ndim == 2:
+            rgb = np.repeat(arr[:, :, None], 3, axis=2)
+            return rgb, True
+        if arr.ndim == 3 and arr.shape[2] == 3:
+            return arr, False
+        raise ValueError("Array must be HxW, HxWx1, or HxWx3 (uint8).")
+
+    def encode(self, arr: np.ndarray) -> bytes:
+        rgb, is_mask = self._to_rgb3_and_flag(arr)
+        h, w, _ = rgb.shape
+        enc = av.CodecContext.create("libx264rgb", "w")
+        enc.width = w
+        enc.height = h
+        enc.time_base = Fraction(1, self.fps)
+        enc.pix_fmt = "rgb24"
+        enc.options = {
+            "crf": "0",
+            "preset": "ultrafast",
+            "g": "1",
+            "keyint": "1",
+        }
+        enc.open()
+        frame = av.VideoFrame.from_ndarray(rgb, format="rgb24")
+        packets = []
+        packets.extend(enc.encode(frame))
+        packets.extend(enc.encode(None))
+        if not packets:
+            raise RuntimeError("H.264 encoder produced no packets.")
+        bitstream = b"".join(bytes(p) for p in packets)
+        header = b"\x01" if is_mask else b"\x00"
+        return header + bitstream
+
+    def decode(self, data: bytes) -> np.ndarray:
+        if len(data) < 2:
+            raise ValueError("Payload too short.")
+        header = data[0]
+        bitstream = data[1:]
+        is_mask = (header == 0x01)
+        dec = av.CodecContext.create("h264", "r")
+        packet = av.packet.Packet(bitstream)
+        frames = []
+        frames.extend(dec.decode(packet))
+        frames.extend(dec.decode(None))
+        if not frames:
+            raise RuntimeError("H.264 decoder produced no frames.")
+        img3 = frames[0].to_ndarray(format="rgb24")
+        if is_mask:
+            return img3[..., :1]
+        return img3
+
+
+class PNGCompression(CompressionStrategy):
+    def __init__(self, first_frame, compression_level=1):
+        self.compression_level = compression_level
+
+    def encode(self, arr):
+        if arr.dtype != np.uint8:
+            raise ValueError("Input must be uint8.")
+        if arr.ndim == 3 and arr.shape[2] == 1:
+            arr = arr[:, :, 0]
+        if arr.ndim == 2:
+            img_to_encode = arr
+        elif arr.ndim == 3 and arr.shape[2] == 3:
+            img_to_encode = arr
+        else:
+            raise ValueError("Array must be HxW, HxWx1, or HxWx3 (uint8).")
+        ok, buf = cv2.imencode(
+            ".png",
+            img_to_encode,
+            [cv2.IMWRITE_PNG_COMPRESSION, int(self.compression_level)],
+        )
+        if not ok:
+            raise RuntimeError("PNG encode failed.")
+        return buf.tobytes()
+
+    def decode(self, data):
+        buf = np.frombuffer(data, dtype=np.uint8)
+        img = cv2.imdecode(buf, cv2.IMREAD_UNCHANGED)
+        if img is None:
+            raise RuntimeError("PNG decode failed.")
+        if img.ndim == 2:
+            return img[..., np.newaxis]
+        if img.ndim == 3 and img.shape[2] == 3:
+            return img
+        raise ValueError(f"Unexpected PNG shape: {img.shape}")
+
+
+class JPEGCompression(CompressionStrategy):
+    def __init__(self, first_frame, quality=95):
+        self.quality = quality
+
+    def encode(self, arr):
+        if arr.dtype != np.uint8:
+            raise ValueError("Input must be uint8.")
+        if arr.ndim == 3 and arr.shape[2] == 1:
+            arr = arr[:, :, 0]
+        if arr.ndim == 2:
+            img_to_encode = arr
+        elif arr.ndim == 3 and arr.shape[2] == 3:
+            img_to_encode = arr
+        else:
+            raise ValueError("Array must be HxW, HxWx1, or HxWx3 (uint8).")
+        ok, buf = cv2.imencode(
+            ".jpg",
+            img_to_encode,
+            [cv2.IMWRITE_JPEG_QUALITY, int(self.quality)],
+        )
+        if not ok:
+            raise RuntimeError("JPEG encode failed.")
+        return buf.tobytes()
+
+    def decode(self, data):
+        buf = np.frombuffer(data, dtype=np.uint8)
+        img = cv2.imdecode(buf, cv2.IMREAD_UNCHANGED)
+        if img is None:
+            raise RuntimeError("JPEG decode failed.")
+        if img.ndim == 2:
+            return img[..., np.newaxis]
+        if img.ndim == 3 and img.shape[2] == 3:
+            return img
+        raise ValueError(f"Unexpected JPEG shape: {img.shape}")
+
+
+STRATEGIES = {
+    "none": NoneStrategy,
+    "h264": H264LosslessCompression,
+    "png": PNGCompression,
+    "jpeg": JPEGCompression,
+}

neuromeka_vfm-0.1.1/src/neuromeka_vfm/pickle_client.py

@@ -0,0 +1,22 @@
+import pickle
+import zmq
+
+
+class PickleClient:
+    """Minimal ZeroMQ pickle-based RPC client."""
+
+    def __init__(self, hostname: str, port: int):
+        self.hostname = hostname
+        self.port = port
+        self.context = zmq.Context()
+        self.socket = self.context.socket(zmq.REQ)
+        self.socket.connect(f"tcp://{self.hostname}:{self.port}")
+
+    def send_data(self, data):
+        self.socket.send(pickle.dumps(data))
+        response = pickle.loads(self.socket.recv())
+        return response
+
+    def close(self):
+        self.socket.close()
+        self.context.term()

neuromeka_vfm-0.1.1/src/neuromeka_vfm/pose_estimation.py

@@ -0,0 +1,80 @@
+from typing import Optional, Sequence
+import numpy as np
+
+from .pickle_client import PickleClient
+
+
+class PoseEstimation:
+    """
+    Client for FoundationPose pickle RPC server.
+    """
+
+    def __init__(self, host: Optional[str] = None, port: Optional[int] = None):
+        import os
+
+        host = host or os.environ.get("FPOSE_HOST", "localhost")
+        port = port or int(os.environ.get("FPOSE_PORT", "5557"))
+        self.client = PickleClient(host, port)
+
+    def init(
+        self,
+        mesh_path: str,
+        apply_scale: float = 1.0,
+        force_apply_color: bool = False,
+        apply_color: Sequence[float] = (160, 160, 160),
+        est_refine_iter: int = 10,
+        track_refine_iter: int = 3,
+        min_n_views: int = 40,
+        inplane_step: int = 60,
+    ):
+        return self.client.send_data(
+            {
+                "operation": "init",
+                "mesh_path": mesh_path,
+                "apply_scale": apply_scale,
+                "force_apply_color": force_apply_color,
+                "apply_color": list(apply_color),
+                "est_refine_iter": est_refine_iter,
+                "track_refine_iter": track_refine_iter,
+                "min_n_views": min_n_views,
+                "inplane_step": inplane_step,
+            }
+        )
+
+    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 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,
+            }
+        )
+
+    def reset(self):
+        return self.client.send_data({"operation": "reset"})
+
+    def reset_object(self):
+        """Re-run server-side reset_object/make_rotation_grid with cached mesh from init."""
+        return self.client.send_data({"operation": "reset_object"})
+
+    def close(self):
+        self.client.close()
+
+
+# Backward-compat alias
+FoundationPoseClient = PoseEstimation

neuromeka_vfm-0.1.1/src/neuromeka_vfm/segmentation.py

@@ -0,0 +1,116 @@
+import time
+from typing import Union, List
+import numpy as np
+
+from .pickle_client import PickleClient
+from .compression import STRATEGIES
+
+
+class Segmentation:
+    """
+    Client for realtime segmentation/tracking server (ZeroMQ pickle RPC).
+    """
+
+    def __init__(self, hostname, port, compression_strategy="none", benchmark=False):
+        self.first_frame_registered = False
+        self.client = PickleClient(hostname, port)
+        self.tracking_object_ids = []
+        self.current_frame_masks = {}
+        if compression_strategy in STRATEGIES:
+            self.compression_strategy_name = compression_strategy
+        else:
+            raise ValueError(f"Only valid compression strategies are {list(STRATEGIES.keys())}")
+        self.benchmark = benchmark
+        if self.benchmark:
+            self.call_time = {"add_image_prompt": 0, "register_first_frame": 0, "get_next": 0}
+            self.call_count = {"add_image_prompt": 0, "register_first_frame": 0, "get_next": 0}
+
+    def switch_compression_strategy(self, compression_strategy):
+        if compression_strategy in STRATEGIES:
+            self.compression_strategy_name = compression_strategy
+        else:
+            raise ValueError(f"Only valid compression strategies are {list(STRATEGIES.keys())}")
+
+    def reset(self):
+        self.first_frame_registered = False
+        self.tracking_object_ids = []
+        self.current_frame_masks = {}
+        self.encoder = None
+        if self.benchmark:
+            self.call_time = {"add_image_prompt": 0, "register_first_frame": 0, "get_next": 0}
+            self.call_count = {"add_image_prompt": 0, "register_first_frame": 0, "get_next": 0}
+
+    def add_image_prompt(self, object_name, object_image):
+        if self.benchmark:
+            start = time.time()
+        data = {"operation": "add_image_prompt", "object_name": object_name, "object_image": object_image}
+        response = self.client.send_data(data)
+        if self.benchmark:
+            self.call_time["add_image_prompt"] += time.time() - start
+            self.call_count["add_image_prompt"] += 1
+        return response
+
+    def register_first_frame(self, frame: np.ndarray, prompt: Union[str, List[str]], use_image_prompt: bool = False):
+        if self.benchmark:
+            start = time.time()
+        self.compression_strategy = STRATEGIES[self.compression_strategy_name](frame)
+        data = {
+            "operation": "start",
+            "prompt": prompt,
+            "frame": self.compression_strategy.encode(frame),
+            "use_image_prompt": use_image_prompt,
+            "compression_strategy": self.compression_strategy_name,
+        }
+        response = self.client.send_data(data)
+        if response.get("result") == "SUCCESS":
+            self.first_frame_registered = True
+            self.tracking_object_ids = response["data"]["obj_ids"]
+            masks = {}
+            for i, obj_id in enumerate(self.tracking_object_ids):
+                mask = self.compression_strategy.decode(response["data"]["masks"][i])
+                if np.any(mask):
+                    masks[obj_id] = mask
+            self.current_frame_masks = masks
+            if self.benchmark:
+                self.call_time["register_first_frame"] += time.time() - start
+                self.call_count["register_first_frame"] += 1
+            return True
+        else:
+            if self.benchmark:
+                self.call_time["register_first_frame"] += time.time() - start
+                self.call_count["register_first_frame"] += 1
+            return False
+
+    def get_next(self, frame: np.ndarray):
+        if not self.first_frame_registered:
+            print("Segmentation: register_first_frame must be called first")
+            return None
+        if self.benchmark:
+            start = time.time()
+        response = self.client.send_data({"operation": "get_next", "frame": self.compression_strategy.encode(frame)})
+        if response.get("result") == "SUCCESS":
+            masks = {}
+            for i, obj_id in enumerate(self.tracking_object_ids):
+                mask = self.compression_strategy.decode(response["data"]["masks"][i])
+                if np.any(mask):
+                    masks[obj_id] = mask
+            self.current_frame_masks = masks
+            if self.benchmark:
+                self.call_time["get_next"] += time.time() - start
+                self.call_count["get_next"] += 1
+            return masks
+        if self.benchmark:
+            self.call_time["get_next"] += time.time() - start
+            self.call_count["get_next"] += 1
+        return None
+
+    def finish(self):
+        if not self.first_frame_registered:
+            print("Warning: Segmentation: register_first_frame must be called first")
+        self.first_frame_registered = False
+        self.tracking_object_ids = []
+        self.current_frame_masks = {}
+
+
+# Backward-compat alias
+NrmkRealtimeSegmentation = Segmentation

neuromeka_vfm-0.1.1/src/neuromeka_vfm/upload_mesh.py

@@ -0,0 +1,81 @@
+"""
+Upload a mesh file from client PC to server host via SSH/SFTP.
+Expose both API (upload_mesh) and CLI (neuromeka-upload-mesh).
+"""
+import argparse
+import os
+import pathlib
+import sys
+
+import paramiko
+
+
+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):
+        raise FileNotFoundError(f"Local file not found: {local}")
+    if password is None and key is None:
+        raise ValueError("Either password or key must be provided")
+
+    ssh = paramiko.SSHClient()
+    ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
+    try:
+        if key:
+            ssh.connect(hostname=host, port=port, username=user, key_filename=key)
+        else:
+            ssh.connect(hostname=host, port=port, username=user, password=password)
+        sftp = ssh.open_sftp()
+        remote_dir = os.path.dirname(remote)
+        if remote_dir:
+            # ensure directories exist
+            parts = pathlib.Path(remote_dir).parts
+            cur = ""
+            for p in parts:
+                cur = os.path.join(cur, p)
+                try:
+                    sftp.stat(cur)
+                except FileNotFoundError:
+                    sftp.mkdir(cur)
+        sftp.put(local, remote)
+        print(f"Uploaded {local} -> {remote}")
+    finally:
+        try:
+            sftp.close()
+        except Exception:
+            pass
+        ssh.close()
+
+
+def _parse_args():
+    ap = argparse.ArgumentParser(description="Upload mesh file to host via SSH (for FoundationPose docker volume).")
+    ap.add_argument("--host", required=True, help="Host IP or name")
+    ap.add_argument("--port", type=int, default=22, help="SSH port (default: 22)")
+    ap.add_argument("--user", required=True, help="SSH username")
+    auth = ap.add_mutually_exclusive_group(required=True)
+    auth.add_argument("--password", help="SSH password")
+    auth.add_argument("--key", help="SSH private key path")
+    ap.add_argument("--local", required=True, help="Local mesh file path (e.g., mesh/123.stl)")
+    ap.add_argument("--remote", required=True, help="Remote host path (mounted into container)")
+    return ap.parse_args()
+
+
+def cli():
+    args = _parse_args()
+    try:
+        upload_mesh(
+            host=args.host,
+            port=args.port,
+            user=args.user,
+            password=args.password,
+            key=args.key,
+            local=args.local,
+            remote=args.remote,
+        )
+    except Exception as e:
+        print(f"Upload failed: {e}", file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    cli()

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

@@ -0,0 +1,109 @@
+Metadata-Version: 2.1
+Name: neuromeka_vfm
+Version: 0.1.1
+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.1/src/neuromeka_vfm.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+src/neuromeka_vfm/__init__.py
+src/neuromeka_vfm/compression.py
+src/neuromeka_vfm/pickle_client.py
+src/neuromeka_vfm/pose_estimation.py
+src/neuromeka_vfm/segmentation.py
+src/neuromeka_vfm/upload_mesh.py
+src/neuromeka_vfm.egg-info/PKG-INFO
+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

neuromeka_vfm-0.1.1/src/neuromeka_vfm.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neuromeka_vfm-0.1.1/src/neuromeka_vfm.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+neuromeka-upload-mesh = neuromeka_vfm.upload_mesh:cli

neuromeka_vfm-0.1.1/src/neuromeka_vfm.egg-info/requires.txt

@@ -0,0 +1,5 @@
+numpy
+pyzmq
+paramiko
+av
+opencv-python-headless

neuromeka_vfm-0.1.1/src/neuromeka_vfm.egg-info/top_level.txt

@@ -0,0 +1 @@
+neuromeka_vfm