camera-client 0.3.0__tar.gz → 0.3.2__tar.gz

{camera_client-0.3.0/camera_client.egg-info → camera_client-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camera-client
-Version: 0.3.0
+Version: 0.3.2
 Summary: Python SDK for camera calibration and projection transformations - handle lens distortion, coordinate transformations, and 3D ray casting with symbolic expressions.
 Author-email: Alexander Abramov <extremal.ru@gmail.com>
 License: MIT
@@ -133,9 +133,9 @@ net = CameraNetwork(cameras)
 
 ### Spatial covariance
 
-`get_covariance` computes 3x3 spatial covariance matrices for 3D points.
-The matrix encodes how pixel-level uncertainty (distortion + geometric calibration + detection)
-propagates into world-space uncertainty through the camera's ray geometry.
+`get_covariance` computes 3x3 spatial covariance matrices for 3D points —
+both per-camera and fused across all visible cameras in a single call.
+Returns a `NetworkCovariance` object.
 
 ```python
 points = np.array([
@@ -143,15 +143,15 @@ points = np.array([
     [18.0, 6.0, 1.5],
 ])
 
-# Per-camera covariance (no fusion, no visibility check)
-covs_cam = net.get_covariance(points, camera_id=1177, detection_sigma=0.01)
-# covs_cam[i] is a (3, 3) covariance matrix from camera 1177
+result = net.get_covariance(points, detection_sigma=0.01)
+
+# Per-camera covariance (None if camera doesn't see the point)
+cov_cam = result[1177][0]       # camera 1177, point 0
 
 # Fused covariance from all visible cameras (information fusion)
-covs_fused = net.get_covariance(points, detection_sigma=0.01)
-# covs_fused[i] is (3, 3) fused covariance, or None if not visible to any camera
+cov_fused = result.fused[0]     # fused, point 0 (or None if no camera sees it)
 
-for i, cov in enumerate(covs_fused):
+for i, cov in enumerate(result.fused):
     if cov is not None:
         stds = np.sqrt(np.linalg.eigvalsh(cov))
         print(f"Point {i}: σ = {stds[0]:.3f}m, {stds[1]:.3f}m, {stds[2]:.3f}m")
@@ -236,12 +236,20 @@ Out-of-bounds points return NaN. Height `h` can be a scalar or per-point (N,) ar
 | Method | Description |
 |--------|-------------|
 | `CameraNetwork(cameras)` | Create network from list of `CameraProjection` instances |
-| `get_covariance(points, ...)` | Fused 3x3 covariance for (N, 3) points from all visible cameras |
-| `get_covariance(points, camera_id=id, ...)` | Per-camera 3x3 covariance (no fusion, no visibility check) |
+| `get_covariance(points, ...)` | Returns `NetworkCovariance` with per-camera and fused 3x3 covariances |
 | `triangulate(observations, ...)` | 3D point + covariance from `{camera_id: src_point}` observations |
 
 Common parameters: `detection_sigma` (float), `sigma_binding` (float), `use_efov` (bool), `n_sigma` (float).
 
+### `NetworkCovariance`
+
+| Access | Description |
+|--------|-------------|
+| `result[camera_id]` | List of N per-camera covariances (3x3 or None) |
+| `result.fused` | List of N fused covariances (3x3 or None) |
+| `result.camera_ids` | List of all camera IDs in the network |
+| `result.visible_camera_ids(i=0)` | List of camera IDs that see point i |
+
 ### `triangulation` module
 
 | Function | Description |

{camera_client-0.3.0 → camera_client-0.3.2}/README.md

@@ -103,9 +103,9 @@ net = CameraNetwork(cameras)
 
 ### Spatial covariance
 
-`get_covariance` computes 3x3 spatial covariance matrices for 3D points.
-The matrix encodes how pixel-level uncertainty (distortion + geometric calibration + detection)
-propagates into world-space uncertainty through the camera's ray geometry.
+`get_covariance` computes 3x3 spatial covariance matrices for 3D points —
+both per-camera and fused across all visible cameras in a single call.
+Returns a `NetworkCovariance` object.
 
 ```python
 points = np.array([
@@ -113,15 +113,15 @@ points = np.array([
     [18.0, 6.0, 1.5],
 ])
 
-# Per-camera covariance (no fusion, no visibility check)
-covs_cam = net.get_covariance(points, camera_id=1177, detection_sigma=0.01)
-# covs_cam[i] is a (3, 3) covariance matrix from camera 1177
+result = net.get_covariance(points, detection_sigma=0.01)
+
+# Per-camera covariance (None if camera doesn't see the point)
+cov_cam = result[1177][0]       # camera 1177, point 0
 
 # Fused covariance from all visible cameras (information fusion)
-covs_fused = net.get_covariance(points, detection_sigma=0.01)
-# covs_fused[i] is (3, 3) fused covariance, or None if not visible to any camera
+cov_fused = result.fused[0]     # fused, point 0 (or None if no camera sees it)
 
-for i, cov in enumerate(covs_fused):
+for i, cov in enumerate(result.fused):
     if cov is not None:
         stds = np.sqrt(np.linalg.eigvalsh(cov))
         print(f"Point {i}: σ = {stds[0]:.3f}m, {stds[1]:.3f}m, {stds[2]:.3f}m")
@@ -206,12 +206,20 @@ Out-of-bounds points return NaN. Height `h` can be a scalar or per-point (N,) ar
 | Method | Description |
 |--------|-------------|
 | `CameraNetwork(cameras)` | Create network from list of `CameraProjection` instances |
-| `get_covariance(points, ...)` | Fused 3x3 covariance for (N, 3) points from all visible cameras |
-| `get_covariance(points, camera_id=id, ...)` | Per-camera 3x3 covariance (no fusion, no visibility check) |
+| `get_covariance(points, ...)` | Returns `NetworkCovariance` with per-camera and fused 3x3 covariances |
 | `triangulate(observations, ...)` | 3D point + covariance from `{camera_id: src_point}` observations |
 
 Common parameters: `detection_sigma` (float), `sigma_binding` (float), `use_efov` (bool), `n_sigma` (float).
 
+### `NetworkCovariance`
+
+| Access | Description |
+|--------|-------------|
+| `result[camera_id]` | List of N per-camera covariances (3x3 or None) |
+| `result.fused` | List of N fused covariances (3x3 or None) |
+| `result.camera_ids` | List of all camera IDs in the network |
+| `result.visible_camera_ids(i=0)` | List of camera IDs that see point i |
+
 ### `triangulation` module
 
 | Function | Description |

camera_client-0.3.2/camera_client/__init__.py

@@ -0,0 +1,5 @@
+from camera_client.client import CameraProjection
+from camera_client.camera_network import CameraNetwork, NetworkCovariance
+from camera_client import triangulation
+
+__all__ = ["CameraProjection", "CameraNetwork", "NetworkCovariance", "triangulation"]

{camera_client-0.3.0 → camera_client-0.3.2}/camera_client/camera_network.py

@@ -31,6 +31,37 @@ def _points_in_polygon(points_xy, polygon_xy):
     return np.bitwise_xor.reduce(crosses, axis=1)
 
 
+class NetworkCovariance:
+    """Result of CameraNetwork.get_covariance().
+
+    Access per-camera covariance lists by camera_id:
+        result[1177]  — list of N covariance matrices (or None) for camera 1177
+
+    Access fused covariance:
+        result.fused  — list of N fused covariance matrices (or None)
+    """
+
+    def __init__(self, cameras, fused):
+        self._cameras = cameras  # dict {camera_id: [cov_or_none, ...]}
+        self.fused = fused       # list [cov_or_none, ...]
+
+    def __getitem__(self, camera_id):
+        return self._cameras[camera_id]
+
+    @property
+    def camera_ids(self):
+        return list(self._cameras.keys())
+
+    def visible_camera_ids(self, point_index=0):
+        """Return list of camera_ids that see the given point."""
+        return [cid for cid, covs in self._cameras.items() if covs[point_index] is not None]
+
+    def __repr__(self):
+        n = len(self.fused)
+        n_visible = sum(1 for c in self.fused if c is not None)
+        return f"NetworkCovariance(points={n}, visible={n_visible}, cameras={self.camera_ids})"
+
+
 class CameraNetwork:
     """A network of cameras with spatial covariance models.
 
@@ -88,52 +119,49 @@ class CameraNetwork:
                     visible.append(cid)
         return visible
 
-    def get_covariance(self, points, detection_sigma=0.0, sigma_binding=0.0,
-                       use_efov=True, camera_id=None):
-        """Compute covariance for 3D points.
+    def get_covariance(self, points, detection_sigma=0.0, sigma_binding=0.0, use_efov=True):
+        """Compute per-camera and fused covariance for 3D points.
 
-        If camera_id is None (default), fuses covariances from all visible cameras
-        via information fusion. If camera_id is specified, computes covariance
-        from that single camera (no visibility check, no fusion).
+        Visibility is always checked:
+        - use_efov=True (default): point's xy projection must fall inside the
+          camera's ground EFOV polygon
+        - use_efov=False: point must project onto valid image area
 
         Args:
             points: (N, 3) array of 3D points [x, y, z]
             detection_sigma: detection uncertainty (fraction of image width)
             sigma_binding: spatial binding uncertainty in meters
             use_efov: if True, use EFOV ground polygons for visibility;
-                      if False, use image projection bounds (ignored when camera_id is set)
-            camera_id: if set, compute covariance from this camera only
+                      if False, use image projection bounds
 
         Returns:
-            list of N elements, each either a (3, 3) covariance matrix
-            or None if the point is not visible to any camera
+            NetworkCovariance with:
+              result[camera_id] — list of N per-camera covariances (or None)
+              result.fused       — list of N fused covariances (or None)
         """
         points = np.asarray(points, dtype=np.float64)
         if points.ndim != 2 or points.shape[1] != 3:
             raise ValueError(f"Expected (N, 3) array, got shape {points.shape}")
 
         N = len(points)
-        result = [None] * N
-
-        if camera_id is not None:
-            cov_model = self.covariances[camera_id]
-            for i in range(N):
-                result[i] = cov_model.get_covariance(points[i], detection_sigma, sigma_binding)
-            return result
+        per_camera = {cid: [None] * N for cid in self.cameras}
+        fused = [None] * N
 
         for i in range(N):
             p = points[i]
             visible_ids = self._visible_camera_ids(p, use_efov)
-            if not visible_ids:
-                continue
 
-            covs = [
-                self.covariances[cid].get_covariance(p, detection_sigma, sigma_binding)
-                for cid in visible_ids
-            ]
-            result[i] = triangulation.fuse_covariances(covs)
+            covs_for_fusion = []
+            for cid in visible_ids:
+                cov = self.covariances[cid].get_covariance(p, detection_sigma, sigma_binding)
+                if cov is not None:
+                    per_camera[cid][i] = cov
+                    covs_for_fusion.append(cov)
+
+            if covs_for_fusion:
+                fused[i] = triangulation.fuse_covariances(covs_for_fusion)
 
-        return result
+        return NetworkCovariance(per_camera, fused)
 
     def triangulate(self, observations, detection_sigma=0.0, sigma_binding=0.0, n_sigma=3.0):
         """Triangulate a 3D point from observations in multiple cameras.
@@ -187,6 +215,8 @@ class CameraNetwork:
             cov = self.covariances[cid].get_covariance(
                 p_on_ray, detection_sigma, sigma_binding
             )
+            if cov is None:
+                return None
             ray_points.append(p_on_ray)
             ray_covs.append(cov)
 

{camera_client-0.3.0 → camera_client-0.3.2}/camera_client/error_model.py

@@ -197,6 +197,9 @@ class CameraSpatialCovariance:
             p: 3D point [x, y, z]
             detection_sigma: detection uncertainty (fraction of image width)
             sigma_binding: spatial binding uncertainty in meters
+
+        Returns:
+            (3, 3) covariance matrix, or None if the point is outside the image
         """
         p = np.asarray(p, dtype=np.float64)
         cam = self.camera
@@ -204,6 +207,9 @@ class CameraSpatialCovariance:
         ctd = cam.gnd_to_ctd(p.reshape(1, 3))[0]
         x_ctd, y_ctd = float(ctd[0]), float(ctd[1])
 
+        if not (0 <= x_ctd < cam.im_width and 0 <= y_ctd < cam.im_height):
+            return None
+
         d = np.linalg.norm(p - self.key_point)
         e_ray = cam.ctd_to_ray(np.array([[x_ctd, y_ctd]]))[0]
         J = cam.ctd_to_ray_jacobian(x_ctd, y_ctd)

{camera_client-0.3.0 → camera_client-0.3.2/camera_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: camera-client
-Version: 0.3.0
+Version: 0.3.2
 Summary: Python SDK for camera calibration and projection transformations - handle lens distortion, coordinate transformations, and 3D ray casting with symbolic expressions.
 Author-email: Alexander Abramov <extremal.ru@gmail.com>
 License: MIT
@@ -133,9 +133,9 @@ net = CameraNetwork(cameras)
 
 ### Spatial covariance
 
-`get_covariance` computes 3x3 spatial covariance matrices for 3D points.
-The matrix encodes how pixel-level uncertainty (distortion + geometric calibration + detection)
-propagates into world-space uncertainty through the camera's ray geometry.
+`get_covariance` computes 3x3 spatial covariance matrices for 3D points —
+both per-camera and fused across all visible cameras in a single call.
+Returns a `NetworkCovariance` object.
 
 ```python
 points = np.array([
@@ -143,15 +143,15 @@ points = np.array([
     [18.0, 6.0, 1.5],
 ])
 
-# Per-camera covariance (no fusion, no visibility check)
-covs_cam = net.get_covariance(points, camera_id=1177, detection_sigma=0.01)
-# covs_cam[i] is a (3, 3) covariance matrix from camera 1177
+result = net.get_covariance(points, detection_sigma=0.01)
+
+# Per-camera covariance (None if camera doesn't see the point)
+cov_cam = result[1177][0]       # camera 1177, point 0
 
 # Fused covariance from all visible cameras (information fusion)
-covs_fused = net.get_covariance(points, detection_sigma=0.01)
-# covs_fused[i] is (3, 3) fused covariance, or None if not visible to any camera
+cov_fused = result.fused[0]     # fused, point 0 (or None if no camera sees it)
 
-for i, cov in enumerate(covs_fused):
+for i, cov in enumerate(result.fused):
     if cov is not None:
         stds = np.sqrt(np.linalg.eigvalsh(cov))
         print(f"Point {i}: σ = {stds[0]:.3f}m, {stds[1]:.3f}m, {stds[2]:.3f}m")
@@ -236,12 +236,20 @@ Out-of-bounds points return NaN. Height `h` can be a scalar or per-point (N,) ar
 | Method | Description |
 |--------|-------------|
 | `CameraNetwork(cameras)` | Create network from list of `CameraProjection` instances |
-| `get_covariance(points, ...)` | Fused 3x3 covariance for (N, 3) points from all visible cameras |
-| `get_covariance(points, camera_id=id, ...)` | Per-camera 3x3 covariance (no fusion, no visibility check) |
+| `get_covariance(points, ...)` | Returns `NetworkCovariance` with per-camera and fused 3x3 covariances |
 | `triangulate(observations, ...)` | 3D point + covariance from `{camera_id: src_point}` observations |
 
 Common parameters: `detection_sigma` (float), `sigma_binding` (float), `use_efov` (bool), `n_sigma` (float).
 
+### `NetworkCovariance`
+
+| Access | Description |
+|--------|-------------|
+| `result[camera_id]` | List of N per-camera covariances (3x3 or None) |
+| `result.fused` | List of N fused covariances (3x3 or None) |
+| `result.camera_ids` | List of all camera IDs in the network |
+| `result.visible_camera_ids(i=0)` | List of camera IDs that see point i |
+
 ### `triangulation` module
 
 | Function | Description |

{camera_client-0.3.0 → camera_client-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "camera-client"
-version = "0.3.0"
+version = "0.3.2"
 description = "Python SDK for camera calibration and projection transformations - handle lens distortion, coordinate transformations, and 3D ray casting with symbolic expressions."
 readme = "README.md"
 requires-python = ">=3.7"

camera_client-0.3.0/camera_client/__init__.py

@@ -1,5 +0,0 @@
-from camera_client.client import CameraProjection
-from camera_client.camera_network import CameraNetwork
-from camera_client import triangulation
-
-__all__ = ["CameraProjection", "CameraNetwork", "triangulation"]