greenstream-config 3.31.0__tar.gz → 4.0.1__tar.gz

{greenstream_config-3.31.0 → greenstream_config-4.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenstream_config
-Version: 3.31.0
+Version: 4.0.1
 Summary: A library for reading / writing Greenstream config files
 Home-page: https://github.com/Greenroom-Robotics/greenstream
 Author: Greenroom Robotics
@@ -14,7 +14,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Build Tools
 Description-Content-Type: text/markdown
-Requires-Dist: gr-urchin
 Requires-Dist: setuptools
 
 # Greenstream Config

greenstream_config-4.0.1/greenstream_config/__init__.py

@@ -0,0 +1,31 @@
+from greenstream_config.namespace_helpers import (
+    get_camera_namespace,
+    get_camera_topic_base,
+    get_sensor_frame_compressed_topic,
+    get_sensor_frame_id,
+    get_sensor_frame_topic,
+    get_sensor_node_name,
+    get_sensor_topic,
+)
+from greenstream_config.types import (
+    Camera,
+    Cameras,
+    CameraSensor,
+    CameraSensorType,
+    GreenstreamConfig,
+)
+
+__all__ = [
+    "GreenstreamConfig",
+    "Camera",
+    "Cameras",
+    "CameraSensor",
+    "CameraSensorType",
+    "get_camera_namespace",
+    "get_camera_topic_base",
+    "get_sensor_frame_compressed_topic",
+    "get_sensor_frame_id",
+    "get_sensor_frame_topic",
+    "get_sensor_node_name",
+    "get_sensor_topic",
+]

greenstream_config-4.0.1/greenstream_config/namespace_helpers.py

@@ -0,0 +1,36 @@
+def get_sensor_topic(namespace_vessel: str, sensor_name: str) -> str:
+    """Generate sensor camera topic path for a sensor."""
+    return f"/{namespace_vessel}/sensors/cameras/{sensor_name}"
+
+
+def get_sensor_frame_topic(namespace_vessel: str, sensor_name: str) -> str:
+    """Generate frame topic path for camera images."""
+    if namespace_vessel == "":
+        return f"perception/frames/{sensor_name}"
+    else:
+        return f"/{namespace_vessel}/perception/frames/{sensor_name}"
+
+
+def get_sensor_frame_compressed_topic(namespace_vessel: str, sensor_name: str) -> str:
+    """Generate compressed frame topic path."""
+    return f"{get_sensor_frame_topic(namespace_vessel, sensor_name)}/compressed"
+
+
+def get_sensor_frame_id(namespace_vessel: str, sensor_name: str) -> str:
+    """Generate optical frame ID for a camera sensor."""
+    return f"{namespace_vessel}_{sensor_name}_optical_frame"
+
+
+def get_sensor_node_name(node_type: str, sensor_name: str) -> str:
+    """Generate ROS node name for a sensor-specific node."""
+    return f"{node_type}_{sensor_name}"
+
+
+def get_camera_namespace(namespace_full: str, camera_name: str) -> str:
+    """Generate ROS namespace for PTZ driver."""
+    return f"{namespace_full}/cameras/{camera_name}"
+
+
+def get_camera_topic_base(namespace_vessel: str, camera_name: str) -> str:
+    """Generate base topic path for PTZ control."""
+    return f"/{namespace_vessel}/sensors/cameras/{camera_name}"

greenstream_config-4.0.1/greenstream_config/test/test_namespace_helpers.py

@@ -0,0 +1,46 @@
+from greenstream_config.namespace_helpers import (
+    get_camera_namespace,
+    get_camera_topic_base,
+    get_sensor_frame_compressed_topic,
+    get_sensor_frame_id,
+    get_sensor_frame_topic,
+    get_sensor_node_name,
+    get_sensor_topic,
+)
+
+
+def test_get_sensor_topic():
+    assert get_sensor_topic("vessel_1", "bow_color") == "/vessel_1/sensors/cameras/bow_color"
+
+
+def test_get_sensor_frame_id():
+    assert get_sensor_frame_id("vessel_1", "bow_color") == "vessel_1_bow_color_optical_frame"
+
+
+def test_get_sensor_node_name():
+    assert get_sensor_node_name("node", "bow_color") == "node_bow_color"
+
+
+def test_get_sensor_frame_topic():
+    assert (
+        get_sensor_frame_topic("vessel_1", "bow_color") == "/vessel_1/perception/frames/bow_color"
+    )
+
+
+def test_get_sensor_frame_topic_empty_namespace():
+    assert get_sensor_frame_topic("", "bow_color") == "perception/frames/bow_color"
+
+
+def test_get_sensor_frame_compressed_topic():
+    assert (
+        get_sensor_frame_compressed_topic("vessel_1", "bow_color")
+        == "/vessel_1/perception/frames/bow_color/compressed"
+    )
+
+
+def test_get_camera_namespace():
+    assert get_camera_namespace("namespace", "bow") == "namespace/cameras/bow"
+
+
+def test_get_camera_topic_base():
+    assert get_camera_topic_base("vessel_1", "bow") == "/vessel_1/sensors/cameras/bow"

greenstream_config-4.0.1/greenstream_config/test/test_types.py

@@ -0,0 +1,179 @@
+import pytest
+from greenstream_config.types import Camera, CameraSensor, CameraSensorType
+from pydantic import ValidationError
+
+
+class TestCameraSensorValidation:
+    """Test ROS-friendly name validation for CameraSensor."""
+
+    def test_valid_lowercase_name(self):
+        """Valid: lowercase name."""
+        sensor = CameraSensor(name="bow_color", type=CameraSensorType.COLOR)
+        assert sensor.name == "bow_color"
+
+    def test_valid_name_with_underscores(self):
+        """Valid: lowercase with underscores."""
+        sensor = CameraSensor(name="stern_ir_sensor", type=CameraSensorType.IR)
+        assert sensor.name == "stern_ir_sensor"
+
+    def test_valid_name_with_numbers(self):
+        """Valid: lowercase with numbers (not at start)."""
+        sensor = CameraSensor(name="camera_1_color", type=CameraSensorType.COLOR)
+        assert sensor.name == "camera_1_color"
+
+    def test_valid_name_starting_with_underscore(self):
+        """Valid: name starting with underscore."""
+        sensor = CameraSensor(name="_private_sensor", type=CameraSensorType.COLOR)
+        assert sensor.name == "_private_sensor"
+
+    def test_invalid_uppercase_name(self):
+        """Invalid: uppercase letters."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="BowColor", type=CameraSensorType.COLOR)
+
+    def test_invalid_camel_case_name(self):
+        """Invalid: camelCase name."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="bowColor", type=CameraSensorType.COLOR)
+
+    def test_invalid_name_with_hyphen(self):
+        """Invalid: name with hyphens."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="bow-color", type=CameraSensorType.COLOR)
+
+    def test_invalid_name_with_space(self):
+        """Invalid: name with spaces."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="bow color", type=CameraSensorType.COLOR)
+
+    def test_invalid_name_starting_with_number(self):
+        """Invalid: name starting with number."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="1_bow_color", type=CameraSensorType.COLOR)
+
+    def test_invalid_name_with_special_chars(self):
+        """Invalid: name with special characters."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            CameraSensor(name="bow@color", type=CameraSensorType.COLOR)
+
+
+class TestCameraValidation:
+    """Test ROS-friendly name validation for Camera."""
+
+    def test_valid_lowercase_name(self):
+        """Valid: lowercase name."""
+        camera = Camera(
+            name="bow",
+            with_ptz=False,
+            sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+        )
+        assert camera.name == "bow"
+
+    def test_valid_name_with_underscores(self):
+        """Valid: lowercase with underscores."""
+        camera = Camera(
+            name="port_camera",
+            with_ptz=False,
+            sensors=[CameraSensor(name="port_camera_color", type=CameraSensorType.COLOR)],
+        )
+        assert camera.name == "port_camera"
+
+    def test_valid_name_with_numbers(self):
+        """Valid: lowercase with numbers (not at start)."""
+        camera = Camera(
+            name="camera_1",
+            with_ptz=False,
+            sensors=[CameraSensor(name="camera_1_color", type=CameraSensorType.COLOR)],
+        )
+        assert camera.name == "camera_1"
+
+    def test_valid_name_starting_with_underscore(self):
+        """Valid: name starting with underscore."""
+        camera = Camera(
+            name="_test_camera",
+            with_ptz=False,
+            sensors=[CameraSensor(name="_test_camera_color", type=CameraSensorType.COLOR)],
+        )
+        assert camera.name == "_test_camera"
+
+    def test_invalid_uppercase_name(self):
+        """Invalid: uppercase letters."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="BowCamera",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_invalid_camel_case_name(self):
+        """Invalid: camelCase name."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="bowCamera",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_invalid_name_with_hyphen(self):
+        """Invalid: name with hyphens."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="bow-camera",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_invalid_name_with_space(self):
+        """Invalid: name with spaces."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="bow camera",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_invalid_name_starting_with_number(self):
+        """Invalid: name starting with number."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="1_bow",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_invalid_name_with_special_chars(self):
+        """Invalid: name with special characters."""
+        with pytest.raises(ValidationError, match="not ROS-friendly"):
+            Camera(
+                name="bow@camera",
+                with_ptz=False,
+                sensors=[CameraSensor(name="bow_color", type=CameraSensorType.COLOR)],
+            )
+
+    def test_default_sensor_creation(self):
+        """Test that a camera without sensors gets a default sensor named {camera_name}_color."""
+        camera = Camera(name="bow", with_ptz=False)
+        assert len(camera.sensors) == 1
+        assert camera.sensors[0].name == "bow_color"
+        assert camera.sensors[0].type == CameraSensorType.COLOR
+
+    def test_default_sensor_with_ptz(self):
+        """Test that a PTZ camera without sensors gets a default sensor named {camera_name}_color."""
+        camera = Camera(name="stern", with_ptz=True)
+        assert len(camera.sensors) == 1
+        assert camera.sensors[0].name == "stern_color"
+        assert camera.sensors[0].type == CameraSensorType.COLOR
+
+    def test_explicit_sensors_preserved(self):
+        """Test that explicitly provided sensors are preserved and default is not created."""
+        camera = Camera(
+            name="bow",
+            with_ptz=False,
+            sensors=[
+                CameraSensor(name="bow_color", type=CameraSensorType.COLOR),
+                CameraSensor(name="bow_ir", type=CameraSensorType.IR),
+            ],
+        )
+        assert len(camera.sensors) == 2
+        assert camera.sensors[0].name == "bow_color"
+        assert camera.sensors[1].name == "bow_ir"

greenstream_config-4.0.1/greenstream_config/types.py

@@ -0,0 +1,137 @@
+import re
+from enum import Enum
+from typing import List, Optional
+
+from pydantic import BaseModel, Field, RootModel, field_validator, model_validator
+
+
+class CameraSensorType(str, Enum):
+    """Supported camera sensor types for different sensor modalities."""
+
+    COLOR = "color"
+    IR = "ir"
+
+
+class CameraSensor(BaseModel):
+    """Individual camera sensor within a physical camera housing.
+
+    Represents a logical camera stream (e.g., color, thermal) that shares
+    the same physical mounting point and PTZ control with other sensors.
+    """
+
+    name: str = Field(
+        description="Sensor identifier used in ROS topics and frame IDs. This should be prefixed with the camera housing name"
+    )
+    type: CameraSensorType = Field(
+        default=CameraSensorType.COLOR, description="Type of camera sensor/modality"
+    )
+    with_camera_info: bool = Field(
+        default=True, description="Whether to launch camera_info publisher for this sensor"
+    )
+    with_pipeline: bool = Field(default=True, description="Whether to launch the pipeline")
+    with_image_compressor: bool = Field(
+        default=True, description="Whether to launch the image compressor"
+    )
+
+    @field_validator("name")
+    @classmethod
+    def validate_ros_friendly_name(cls, v: str) -> str:
+        """Ensure name follows ROS naming convention: lowercase with underscores, not starting with numbers."""
+        if not re.match(r"^[a-z_][a-z0-9_]*$", v):
+            raise ValueError(
+                f"Name '{v}' is not ROS-friendly. Names must be lowercase with underscores, "
+                "not starting with numbers (e.g., 'bow_color', 'stern_ir')"
+            )
+        return v
+
+
+class Camera(BaseModel):
+    """Physical camera housing/mount that can host multiple camera sensors.
+
+    Represents the physical hardware unit including PTZ mechanisms.
+    Multiple sensors (color, thermal, etc.) can share the same PTZ control.
+    """
+
+    name: str = Field(
+        description="Physical camera housing identifier (e.g., 'bow', 'stern', 'port')"
+    )
+    with_ptz: bool = Field(
+        default=False,
+        description="Whether we should launch a PTZ driver",
+    )
+    sensors: List[CameraSensor] = Field(
+        default_factory=list, description="List of camera sensors mounted in this housing"
+    )
+
+    @field_validator("name")
+    @classmethod
+    def validate_ros_friendly_name(cls, v: str) -> str:
+        """Ensure name follows ROS naming convention: lowercase with underscores, not starting with numbers."""
+        if not re.match(r"^[a-z_][a-z0-9_]*$", v):
+            raise ValueError(
+                f"Name '{v}' is not ROS-friendly. Names must be lowercase with underscores, "
+                "not starting with numbers (e.g., 'bow', 'stern', 'port_camera')"
+            )
+        return v
+
+    @model_validator(mode="after")
+    def validate_camera_sensors(self):
+        """Ensure camera has valid sensor configuration.
+
+        If no sensors are specified, creates a default COLOR sensor named {camera_name}_{type}.
+        """
+        if not self.sensors:
+            # Create default sensor with camera's name and type suffix
+            sensor_type = CameraSensorType.COLOR
+            self.sensors = [
+                CameraSensor(name=f"{self.name}_{sensor_type.value}", type=sensor_type)
+            ]
+
+        return self
+
+
+class Cameras(RootModel):
+    root: list[Camera] = Field(default_factory=list)
+
+
+class GreenstreamConfig(BaseModel):
+    """Complete configuration for the Greenstream video streaming system.
+
+    Defines the camera housings and their sensors, along with system-wide
+    settings for WebRTC streaming and ROS integration.
+    """
+
+    cameras: List[Camera] = Field(
+        description="List of physical camera housings and their sensors to deploy"
+    )
+    signalling_server_port: int = Field(
+        default=8443, description="Port for the WebRTC signalling server"
+    )
+    namespace_vessel: str = Field(
+        default="vessel_1", description="Vessel identifier for multi-vessel deployments"
+    )
+    namespace_application: str = Field(default="greenstream", description="Application namespace")
+    ui_port: int = Field(default=8000, description="Port for the web UI server")
+    debug: bool = Field(default=False, description="Enable debug logging and tracing")
+    diagnostics_topic: str = Field(default="diagnostics", description="ROS diagnostics topic name")
+    cert_path: Optional[str] = Field(None, description="SSL certificate path for HTTPS signalling")
+    cert_password: Optional[str] = Field(None, description="SSL certificate password")
+
+    @model_validator(mode="after")
+    def validate_global_configuration(self):
+        """Ensure system-wide configuration is valid."""
+
+        # Check for duplicate camera names
+        camera_names = [camera.name for camera in self.cameras]
+        if len(set(camera_names)) != len(camera_names):
+            raise ValueError("Duplicate camera names found")
+
+        # Check for duplicate sensor names across all cameras
+        all_sensor_names = []
+        for camera in self.cameras:
+            for sensor in camera.sensors:
+                all_sensor_names.append(sensor.name)
+        if len(set(all_sensor_names)) != len(all_sensor_names):
+            raise ValueError("Duplicate sensor names found across cameras")
+
+        return self

{greenstream_config-3.31.0 → greenstream_config-4.0.1}/greenstream_config.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: greenstream_config
-Version: 3.31.0
+Version: 4.0.1
 Summary: A library for reading / writing Greenstream config files
 Home-page: https://github.com/Greenroom-Robotics/greenstream
 Author: Greenroom Robotics
@@ -14,7 +14,6 @@ Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python
 Classifier: Topic :: Software Development :: Build Tools
 Description-Content-Type: text/markdown
-Requires-Dist: gr-urchin
 Requires-Dist: setuptools
 
 # Greenstream Config

{greenstream_config-3.31.0 → greenstream_config-4.0.1}/greenstream_config.egg-info/SOURCES.txt

@@ -4,11 +4,11 @@ setup.py
 greenstream_config/__init__.py
 greenstream_config/namespace_helpers.py
 greenstream_config/types.py
-greenstream_config/urdf.py
 greenstream_config.egg-info/PKG-INFO
 greenstream_config.egg-info/SOURCES.txt
 greenstream_config.egg-info/dependency_links.txt
 greenstream_config.egg-info/requires.txt
 greenstream_config.egg-info/top_level.txt
 greenstream_config.egg-info/zip-safe
-greenstream_config/test/test_namespace_helpers.py
+greenstream_config/test/test_namespace_helpers.py
+greenstream_config/test/test_types.py

{greenstream_config-3.31.0 → greenstream_config-4.0.1}/greenstream_config.egg-info/requires.txt

@@ -1,2 +1 @@
-gr-urchin
 setuptools

{greenstream_config-3.31.0 → greenstream_config-4.0.1}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = greenstream_config
-version = 3.31.0
+version = 4.0.1
 url = https://github.com/Greenroom-Robotics/greenstream
 author = Greenroom Robotics
 author_email = team@greenroomrobotics.com
@@ -21,7 +21,6 @@ long_description_content_type = text/markdown
 [options]
 packages = find:
 install_requires = 
-	gr-urchin
 	setuptools
 zip_safe = true
 

greenstream_config-3.31.0/greenstream_config/__init__.py

@@ -1,33 +0,0 @@
-from greenstream_config.namespace_helpers import (
-    camera_frame_topic,
-    camera_frame_topic_from_camera,
-    camera_namespace,
-    camera_namespace_from_camera,
-    camera_node_name,
-    camera_node_name_from_camera,
-    camera_topic,
-    camera_topic_from_camera,
-    frame_id,
-    frame_id_from_camera,
-)
-from greenstream_config.types import Camera, GreenstreamConfig, Offsets, PTZOffsets
-from greenstream_config.urdf import get_camera_urdf, get_cameras_urdf
-
-__all__ = [
-    "GreenstreamConfig",
-    "Camera",
-    "Offsets",
-    "PTZOffsets",
-    "get_camera_urdf",
-    "get_cameras_urdf",
-    "camera_topic",
-    "frame_id",
-    "camera_namespace",
-    "camera_node_name",
-    "camera_topic_from_camera",
-    "frame_id_from_camera",
-    "camera_namespace_from_camera",
-    "camera_node_name_from_camera",
-    "camera_frame_topic",
-    "camera_frame_topic_from_camera",
-]

greenstream_config-3.31.0/greenstream_config/namespace_helpers.py

@@ -1,54 +0,0 @@
-from pathlib import PosixPath as Path
-
-from greenstream_config.types import Camera
-
-
-def camera_topic(namespace_vessel: str, camera_name: str, camera_type: str) -> str:
-    return str(
-        Path("/") / namespace_vessel / "sensors" / "cameras" / f"{camera_name}_{camera_type}"
-    )
-
-
-def camera_topic_from_camera(namespace_vessel: str, camera: Camera) -> str:
-    return camera_topic(namespace_vessel, camera.name, camera.type)
-
-
-def frame_id(namespace_vessel: str, camera_name: str, camera_type: str) -> str:
-    return f"{namespace_vessel}_{camera_name}_{camera_type}_optical_frame"
-
-
-def frame_id_from_camera(namespace_vessel: str, camera: Camera) -> str:
-    return frame_id(namespace_vessel, camera.name, camera.type)
-
-
-def camera_namespace(namespace_full: str, camera_name: str) -> str:
-    return str(Path(namespace_full) / "cameras" / camera_name)
-
-
-def camera_namespace_from_camera(namespace_full: str, camera: Camera) -> str:
-    return camera_namespace(namespace_full, camera.name)
-
-
-def camera_node_name(node_type: str, camera_name: str, camera_type: str) -> str:
-    return f"{node_type}_{camera_name}_{camera_type}"
-
-
-def camera_node_name_from_camera(node_type: str, camera: Camera) -> str:
-    return camera_node_name(node_type, camera.name, camera.type)
-
-
-def camera_frame_topic(namespace_vessel: str, camera_name: str, camera_type: str) -> str:
-    if namespace_vessel == "":
-        return str(Path("perception") / "frames" / f"{camera_name}_{camera_type}")
-    else:
-        return str(
-            Path("/") / namespace_vessel / "perception" / "frames" / f"{camera_name}_{camera_type}"
-        )
-
-
-def camera_frame_topic_from_camera(namespace_vessel: str, camera: Camera) -> str:
-    return camera_frame_topic(namespace_vessel, camera.name, camera.type)
-
-
-def camera_frame_compressed_topic_from_camera(namespace_vessel: str, camera: Camera) -> str:
-    return str(Path(camera_frame_topic_from_camera(namespace_vessel, camera)) / "compressed")

greenstream_config-3.31.0/greenstream_config/test/test_namespace_helpers.py

@@ -1,73 +0,0 @@
-import pytest
-from greenstream_config.types import Camera
-
-from libs.greenstream_config.greenstream_config.namespace_helpers import (
-    camera_frame_topic,
-    camera_frame_topic_from_camera,
-    camera_namespace,
-    camera_namespace_from_camera,
-    camera_node_name,
-    camera_node_name_from_camera,
-    camera_topic,
-    camera_topic_from_camera,
-    frame_id,
-    frame_id_from_camera,
-)
-
-
-@pytest.fixture
-def camera():
-    return Camera(name="bow", type="color", order=0)
-
-
-def test_camera_topic():
-    assert camera_topic("vessel_1", "bow", "color") == "/vessel_1/sensors/cameras/bow_color"
-
-
-def test_camera_topic_from_camera(camera):
-    assert camera_topic_from_camera("vessel_1", camera) == "/vessel_1/sensors/cameras/bow_color"
-
-
-def test_frame_id():
-    assert frame_id("vessel_1", "bow", "color") == "vessel_1_bow_color_optical_frame"
-
-
-def test_frame_id_from_camera(camera):
-    assert frame_id_from_camera("vessel_1", camera) == "vessel_1_bow_color_optical_frame"
-
-
-def test_camera_namespace():
-    assert camera_namespace("namespace", "bow") == "namespace/cameras/bow"
-
-
-def test_camera_namespace_from_camera(camera):
-    assert camera_namespace_from_camera("namespace", camera) == "namespace/cameras/bow"
-
-
-def test_camera_node_name():
-    assert camera_node_name("node", "bow", "color") == "node_bow_color"
-
-
-def test_camera_node_name_from_camera(camera):
-    assert camera_node_name_from_camera("node", camera) == "node_bow_color"
-
-
-def test_camera_frame_topic():
-    assert (
-        camera_frame_topic("vessel_1", "bow", "color") == "/vessel_1/perception/frames/bow_color"
-    )
-
-
-def test_camera_frame_topic_empty_namespace():
-    assert camera_frame_topic("", "bow", "color") == "perception/frames/bow_color"
-
-
-def test_camera_frame_topic_from_camera(camera):
-    assert (
-        camera_frame_topic_from_camera("vessel_1", camera)
-        == "/vessel_1/perception/frames/bow_color"
-    )
-
-
-def test_camera_frame_topic_from_camera_empty_namespace(camera):
-    assert camera_frame_topic_from_camera("", camera) == "perception/frames/bow_color"

greenstream_config-3.31.0/greenstream_config/types.py

@@ -1,67 +0,0 @@
-from typing import List, Literal, Optional
-
-from pydantic import BaseModel, Field, model_validator
-
-
-class Offsets(BaseModel):
-    """Spatial offsets in the Front-Left-Up (FLU) coordinate frame."""
-
-    roll: Optional[float] = Field(None, description="Roll rotation in radians (FLU frame)")
-    pitch: Optional[float] = Field(None, description="Pitch rotation in radians (FLU frame)")
-    yaw: Optional[float] = Field(None, description="Yaw rotation in radians (FLU frame)")
-    forward: Optional[float] = Field(None, description="Forward translation in meters")
-    left: Optional[float] = Field(None, description="Left translation in meters")
-    up: Optional[float] = Field(None, description="Up translation in meters")
-
-
-class PTZOffsets(Offsets):
-    """PTZ-specific offsets with joint type specification."""
-
-    type: Literal["pan", "tilt"] = Field(description="PTZ joint type (pan or tilt)")
-
-
-class Camera(BaseModel):
-    """Camera configuration for video streaming and control."""
-
-    name: str = Field(
-        description="Camera identifier used in frame IDs, ROS topics, and WebRTC streams"
-    )
-    order: int = Field(description="Display order in the web UI")
-    type: str = Field(default="color", description="Camera type (e.g., color, ir, depth)")
-    publish_camera_info: bool = Field(
-        default=True, description="Whether to launch camera info publisher node"
-    )
-    ptz: bool = Field(
-        default=False, description="Whether to launch PTZ driver for pan-tilt-zoom control"
-    )
-    camera_offsets: Optional[Offsets] = Field(
-        None, description="Camera position offsets relative to base_link"
-    )
-    ptz_offsets: List[PTZOffsets] = Field(
-        default=[], description="PTZ joint offsets (required when ptz=True)"
-    )
-
-    @model_validator(mode="after")
-    def validate_ptz_with_offsets(self):
-        """Ensure that ptz_offsets is set when ptz is True."""
-        if self.ptz and not self.ptz_offsets:
-            raise ValueError("ptz_offsets cannot be empty when ptz is set to True")
-        return self
-
-
-class GreenstreamConfig(BaseModel):
-    """Complete configuration for the Greenstream video streaming system."""
-
-    cameras: List[Camera] = Field(description="List of camera configurations to deploy")
-    signalling_server_port: int = Field(
-        default=8443, description="Port for the WebRTC signalling server"
-    )
-    namespace_vessel: str = Field(
-        default="vessel_1", description="Vessel identifier for multi-vessel deployments"
-    )
-    namespace_application: str = Field(default="greenstream", description="Application namespace")
-    ui_port: int = Field(default=8000, description="Port for the web UI server")
-    debug: bool = Field(default=False, description="Enable debug logging and tracing")
-    diagnostics_topic: str = Field(default="diagnostics", description="ROS diagnostics topic name")
-    cert_path: Optional[str] = Field(None, description="SSL certificate path for HTTPS signalling")
-    cert_password: Optional[str] = Field(None, description="SSL certificate password")

greenstream_config-3.31.0/greenstream_config/urdf.py

@@ -1,197 +0,0 @@
-from typing import List, Tuple
-
-from gr_urchin import Joint, Link, xyz_rpy_to_matrix
-from greenstream_config.types import Camera
-
-
-def get_camera_urdf(
-    camera: Camera,
-    links: List[Link],
-    joints: List[Joint],
-    add_optical_frame: bool = True,
-    has_duplicate_camera_link: bool = False,
-) -> Tuple[List[Link], List[Joint]]:
-    # This is the camera urdf from the gama/lookout greenstream.launch.py
-    # We need to generate this from the camera config
-
-    # Only generate camera link if it currently doesn't exist. This checks for multiple cameras within the same housing
-    # etc: bow camera has both visible and thermal cameras, it is assumed that they are connected via the same ptz system
-    if not has_duplicate_camera_link:
-        camera_xyz_rpy = (
-            [
-                camera.camera_offsets.forward or 0.0,
-                camera.camera_offsets.left or 0.0,
-                camera.camera_offsets.up or 0.0,
-                camera.camera_offsets.roll or 0.0,
-                camera.camera_offsets.pitch or 0.0,
-                camera.camera_offsets.yaw or 0.0,
-            ]
-            if camera.camera_offsets
-            else [0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
-        )
-
-        links.append(
-            Link(
-                name=f"{camera.name}_link",
-                inertial=None,
-                visuals=None,
-                collisions=None,
-            )
-        )
-        joints.append(
-            Joint(
-                name=f"{camera.name}_joint",
-                parent="base_link",
-                child=f"{camera.name}_link",
-                joint_type="fixed",
-                origin=xyz_rpy_to_matrix(camera_xyz_rpy),
-            )
-        )
-
-        if camera.ptz:
-            for ptz_component in camera.ptz_offsets:
-                parent_link = links[-1].name
-                if ptz_component.type == "pan":
-                    links.append(
-                        Link(
-                            name=f"{camera.name}_pan_link",
-                            inertial=None,
-                            visuals=None,
-                            collisions=None,
-                        ),
-                    )
-
-                    camera_pan_xyz_rpy = [
-                        ptz_component.forward or 0.0,
-                        ptz_component.left or 0.0,
-                        ptz_component.up or 0.0,
-                        ptz_component.roll or 0.0,
-                        ptz_component.pitch or 0.0,
-                        ptz_component.yaw or 0.0,
-                    ]
-
-                    joints.append(
-                        Joint(
-                            name=f"{camera.name}_pan_joint",
-                            parent=parent_link,
-                            child=f"{camera.name}_pan_link",
-                            joint_type="continuous",
-                            origin=xyz_rpy_to_matrix(camera_pan_xyz_rpy),
-                            axis=[0, 0, 1],
-                        )
-                    )
-
-                elif ptz_component.type == "tilt":
-                    links.append(
-                        Link(
-                            name=f"{camera.name}_tilt_link",
-                            inertial=None,
-                            visuals=None,
-                            collisions=None,
-                        ),
-                    )
-
-                    camera_tilt_xyz_rpy = [
-                        ptz_component.forward or 0.0,
-                        ptz_component.left or 0.0,
-                        ptz_component.up or 0.0,
-                        ptz_component.roll or 0.0,
-                        ptz_component.pitch or 0.0,
-                        ptz_component.yaw or 0.0,
-                    ]
-
-                    joints.append(
-                        Joint(
-                            name=f"{camera.name}_tilt_joint",
-                            parent=parent_link,
-                            child=f"{camera.name}_tilt_link",
-                            joint_type="continuous",
-                            origin=xyz_rpy_to_matrix(camera_tilt_xyz_rpy),
-                            axis=[0, 1, 0],
-                        )
-                    )
-
-    if add_optical_frame:
-
-        if has_duplicate_camera_link:
-            # search for the parent link of another camera frame bounded by the same camera link (i.e. color, thermal within the same housing)
-            for joint in reversed(joints):
-                child_link_name = joint.child
-                if (
-                    child_link_name.startswith(camera.name)
-                    and child_link_name.endswith("frame")
-                    and "optical" not in child_link_name
-                ):
-                    parent_link = joint.parent
-                    break
-        else:
-            parent_link = links[-1].name
-
-        links.append(
-            Link(
-                name=f"{camera.name}_{camera.type}_frame",
-                inertial=None,
-                visuals=None,
-                collisions=None,
-            )
-        )
-        links.append(
-            Link(
-                name=f"{camera.name}_{camera.type}_optical_frame",
-                inertial=None,
-                visuals=None,
-                collisions=None,
-            )
-        )
-        # fixed transforms between camera frame and optical frame FRD -> NED
-        joints.append(
-            Joint(
-                name=f"{parent_link}_to_{camera.type}_frame",
-                parent=f"{parent_link}",
-                child=f"{camera.name}_{camera.type}_frame",
-                joint_type="fixed",
-                origin=xyz_rpy_to_matrix([0, 0, 0, 0, 0, 0]),
-            )
-        )
-        joints.append(
-            Joint(
-                name=f"{camera.name}_{camera.type}_frame_to_optical_frame",
-                parent=f"{camera.name}_{camera.type}_frame",
-                child=f"{camera.name}_{camera.type}_optical_frame",
-                joint_type="fixed",
-                origin=xyz_rpy_to_matrix([0, 0, 0, -1.570796, 0, -1.570796]),
-            )
-        )
-
-    return (links, joints)
-
-
-def get_cameras_urdf(
-    cameras: List[Camera],
-    add_optical_frame: bool = True,
-) -> Tuple[List[Link], List[Joint]]:
-
-    links: List[Link] = []
-    joints: List[Joint] = []
-
-    for camera in cameras:
-
-        # skip duplicate camera links, only add optical frame of camera of a different type (i.e. color, thermal)
-        if camera.name in [prev_camera.name for prev_camera in cameras[: cameras.index(camera)]]:
-            links, joints = get_camera_urdf(
-                camera,
-                links,
-                joints,
-                add_optical_frame,
-                has_duplicate_camera_link=True,
-            )
-        else:
-            links, joints = get_camera_urdf(
-                camera,
-                links,
-                joints,
-                add_optical_frame,
-                has_duplicate_camera_link=False,
-            )
-
-    return links, joints