photonlibpy 2025.0.0b2__tar.gz → 2025.0.0b3__tar.gz

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: photonlibpy
-Version: 2025.0.0b2
-Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-beta-2 .
+Version: 2025.0.0b3
+Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-beta-3 .
 Home-page: https://photonvision.org
 Author: Photonvision Development Team
 Description-Content-Type: text/markdown

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/estimation/openCVHelp.py

@@ -1,5 +1,5 @@
 import math
-from typing import Any, Tuple
+from typing import Any
 
 import cv2 as cv
 import numpy as np
@@ -48,13 +48,13 @@ class OpenCVHelp:
         )
 
     @staticmethod
-    def avgPoint(points: list[Tuple[float, float]]) -> Tuple[float, float]:
+    def avgPoint(points: np.ndarray) -> np.ndarray:
         x = 0.0
         y = 0.0
         for p in points:
-            x += p[0]
-            y += p[1]
-        return (x / len(points), y / len(points))
+            x += p[0, 0]
+            y += p[0, 1]
+        return np.array([[x / len(points), y / len(points)]])
 
     @staticmethod
     def pointsToTargetCorners(points: np.ndarray) -> list[TargetCorner]:
@@ -126,6 +126,9 @@ class OpenCVHelp:
         objectMat = np.array(OpenCVHelp.translationToTVec(modelTrls))
 
         alt: Transform3d | None = None
+        reprojectionError: cv.typing.MatLike | None = None
+        best: Transform3d = Transform3d()
+
         for tries in range(2):
             retval, rvecs, tvecs, reprojectionError = cv.solvePnPGeneric(
                 objectMat,
@@ -145,7 +148,9 @@ class OpenCVHelp:
                     OpenCVHelp.rVecToRotation(rvecs[1]),
                 )
 
-            if not math.isnan(reprojectionError[0, 0]):
+            if reprojectionError is not None and not math.isnan(
+                reprojectionError[0, 0]
+            ):
                 break
             else:
                 pt = imagePoints[0]
@@ -153,7 +158,7 @@ class OpenCVHelp:
                 pt[0, 1] -= 0.001
                 imagePoints[0] = pt
 
-        if math.isnan(reprojectionError[0, 0]):
+        if reprojectionError is None or math.isnan(reprojectionError[0, 0]):
             print("SolvePNP_Square failed!")
             return None
 

photonlibpy-2025.0.0b3/photonlibpy/estimation/rotTrlTransform3d.py

@@ -0,0 +1,55 @@
+from typing import Self
+
+from wpimath.geometry import Pose3d, Rotation3d, Transform3d, Translation3d
+
+
+class RotTrlTransform3d:
+    def __init__(
+        self, rot: Rotation3d = Rotation3d(), trl: Translation3d = Translation3d()
+    ):
+        self.rot = rot
+        self.trl = trl
+
+    def inverse(self) -> Self:
+        invRot = -self.rot
+        invTrl = -(self.trl.rotateBy(invRot))
+        return type(self)(invRot, invTrl)
+
+    def getTransform(self) -> Transform3d:
+        return Transform3d(self.trl, self.rot)
+
+    def getTranslation(self) -> Translation3d:
+        return self.trl
+
+    def getRotation(self) -> Rotation3d:
+        return self.rot
+
+    def applyTranslation(self, trlToApply: Translation3d) -> Translation3d:
+        return trlToApply.rotateBy(self.rot) + self.trl
+
+    def applyRotation(self, rotToApply: Rotation3d) -> Rotation3d:
+        return rotToApply + self.rot
+
+    def applyPose(self, poseToApply: Pose3d) -> Pose3d:
+        return Pose3d(
+            self.applyTranslation(poseToApply.translation()),
+            self.applyRotation(poseToApply.rotation()),
+        )
+
+    def applyTrls(self, rots: list[Rotation3d]) -> list[Rotation3d]:
+        retVal: list[Rotation3d] = []
+        for rot in rots:
+            retVal.append(self.applyRotation(rot))
+        return retVal
+
+    @classmethod
+    def makeRelativeTo(cls, pose: Pose3d) -> Self:
+        return cls(pose.rotation(), pose.translation()).inverse()
+
+    @classmethod
+    def makeBetweenPoses(cls, initial: Pose3d, last: Pose3d) -> Self:
+        return cls(
+            last.rotation() - initial.rotation(),
+            last.translation()
+            - initial.translation().rotateBy(last.rotation() - initial.rotation()),
+        )

photonlibpy-2025.0.0b3/photonlibpy/estimation/targetModel.py

@@ -0,0 +1,120 @@
+import math
+from typing import List, Self
+
+from wpimath.geometry import Pose3d, Rotation2d, Rotation3d, Translation3d
+from wpimath.units import meters
+
+from . import RotTrlTransform3d
+
+
+class TargetModel:
+
+    def __init__(self):
+        self.vertices: List[Translation3d] = []
+        self.isPlanar = False
+        self.isSpherical = False
+
+    @classmethod
+    def createPlanar(cls, width: meters, height: meters) -> Self:
+        tm = cls()
+
+        tm.isPlanar = True
+        tm.isSpherical = False
+        tm.vertices = [
+            Translation3d(0.0, -width / 2.0, -height / 2.0),
+            Translation3d(0.0, width / 2.0, -height / 2.0),
+            Translation3d(0.0, width / 2.0, height / 2.0),
+            Translation3d(0.0, -width / 2.0, height / 2.0),
+        ]
+        return tm
+
+    @classmethod
+    def createCuboid(cls, length: meters, width: meters, height: meters) -> Self:
+        tm = cls()
+        verts = [
+            Translation3d(length / 2.0, -width / 2.0, -height / 2.0),
+            Translation3d(length / 2.0, width / 2.0, -height / 2.0),
+            Translation3d(length / 2.0, width / 2.0, height / 2.0),
+            Translation3d(length / 2.0, -width / 2.0, height / 2.0),
+            Translation3d(-length / 2.0, -width / 2.0, height / 2.0),
+            Translation3d(-length / 2.0, width / 2.0, height / 2.0),
+            Translation3d(-length / 2.0, width / 2.0, -height / 2.0),
+            Translation3d(-length / 2.0, -width / 2.0, -height / 2.0),
+        ]
+
+        tm._common_construction(verts)
+
+        return tm
+
+    @classmethod
+    def createSpheroid(cls, diameter: meters) -> Self:
+        tm = cls()
+
+        tm.isPlanar = False
+        tm.isSpherical = True
+        tm.vertices = [
+            Translation3d(0.0, -diameter / 2.0, 0.0),
+            Translation3d(0.0, 0.0, -diameter / 2.0),
+            Translation3d(0.0, diameter / 2.0, 0.0),
+            Translation3d(0.0, 0.0, diameter / 2.0),
+        ]
+
+        return tm
+
+    @classmethod
+    def createArbitrary(cls, verts: List[Translation3d]) -> Self:
+        tm = cls()
+        tm._common_construction(verts)
+
+        return tm
+
+    def _common_construction(self, verts: List[Translation3d]) -> None:
+        self.isSpherical = False
+        if len(verts) <= 2:
+            self.vertices = []
+            self.isPlanar = False
+        else:
+            cornersPlaner = True
+            for corner in verts:
+                if abs(corner.X() < 1e-4):
+                    cornersPlaner = False
+            self.isPlanar = cornersPlaner
+
+        self.vertices = verts
+
+    def getFieldVertices(self, targetPose: Pose3d) -> List[Translation3d]:
+        basisChange = RotTrlTransform3d(targetPose.rotation(), targetPose.translation())
+
+        retVal = []
+
+        for vert in self.vertices:
+            retVal.append(basisChange.applyTranslation(vert))
+
+        return retVal
+
+    @classmethod
+    def getOrientedPose(cls, tgtTrl: Translation3d, cameraTrl: Translation3d):
+        relCam = cameraTrl - tgtTrl
+        orientToCam = Rotation3d(
+            0.0,
+            Rotation2d(math.hypot(relCam.X(), relCam.Y()), relCam.Z()).radians(),
+            Rotation2d(relCam.X(), relCam.Y()).radians(),
+        )
+        return Pose3d(tgtTrl, orientToCam)
+
+    def getVertices(self) -> List[Translation3d]:
+        return self.vertices
+
+    def getIsPlanar(self) -> bool:
+        return self.isPlanar
+
+    def getIsSpherical(self) -> bool:
+        return self.isSpherical
+
+    @classmethod
+    def AprilTag36h11(cls) -> Self:
+        return cls.createPlanar(width=6.5 * 0.0254, height=6.5 * 0.0254)
+
+    @classmethod
+    def AprilTag16h5(cls) -> Self:
+        return cls.createPlanar(width=6.0 * 0.0254, height=6.0 * 0.0254)

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/estimation/visionEstimation.py

@@ -16,10 +16,10 @@ class VisionEstimation:
             id = tag.getFiducialId()
             maybePose = layout.getTagPose(id)
             if maybePose:
-                tag = AprilTag()
-                tag.ID = id
-                tag.pose = maybePose
-                retVal.append(tag)
+                aprilTag = AprilTag()
+                aprilTag.ID = id
+                aprilTag.pose = maybePose
+                retVal.append(aprilTag)
         return retVal
 
     @staticmethod

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/MultiTargetPNPResultSerde.py

@@ -20,8 +20,14 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import MultiTargetPNPResult  # noqa
+    from ..targeting import PnpResult  # noqa
 
 
 class MultiTargetPNPResultSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/PhotonPipelineMetadataSerde.py

@@ -20,8 +20,13 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import PhotonPipelineMetadata  # noqa
 
 
 class PhotonPipelineMetadataSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/PhotonPipelineResultSerde.py

@@ -20,8 +20,16 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import MultiTargetPNPResult  # noqa
+    from ..targeting import PhotonPipelineMetadata  # noqa
+    from ..targeting import PhotonPipelineResult  # noqa
+    from ..targeting import PhotonTrackedTarget  # noqa
 
 
 class PhotonPipelineResultSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/PhotonTrackedTargetSerde.py

@@ -20,8 +20,14 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import PhotonTrackedTarget  # noqa
+    from ..targeting import TargetCorner  # noqa
 
 
 class PhotonTrackedTargetSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/PnpResultSerde.py

@@ -20,8 +20,13 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import PnpResult  # noqa
 
 
 class PnpResultSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/generated/TargetCornerSerde.py

@@ -20,8 +20,13 @@
 ##                        --> DO NOT MODIFY <--
 ###############################################################################
 
+from typing import TYPE_CHECKING
+
 from ..packet import Packet
-from ..targeting import *
+from ..targeting import *  # noqa
+
+if TYPE_CHECKING:
+    from ..targeting import TargetCorner  # noqa
 
 
 class TargetCornerSerde:

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/networktables/NTTopicSet.py

@@ -10,8 +10,10 @@ PhotonPipelineResult_TYPE_STRING = (
 
 class NTTopicSet:
 
-    def __init__(self) -> None:
-        self.subTable = nt.NetworkTableInstance.getDefault()
+    def __init__(self, tableName: str, cameraName: str) -> None:
+        instance = nt.NetworkTableInstance.getDefault()
+        photonvision_root_table = instance.getTable(tableName)
+        self.subTable = photonvision_root_table.getSubTable(cameraName)
 
     def updateEntries(self) -> None:
         options = nt.PubSubOptions()

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/photonCamera.py

@@ -231,7 +231,7 @@ class PhotonCamera:
         versionString = self.versionEntry.get(defaultValue="")
         localUUID = PhotonPipelineResult.photonStruct.MESSAGE_VERSION
 
-        remoteUUID = self._rawBytesEntry.getTopic().getProperty("message_uuid")
+        remoteUUID = str(self._rawBytesEntry.getTopic().getProperty("message_uuid"))
 
         if not remoteUUID:
             wpilib.reportWarning(

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/simulation/photonCameraSim.py

@@ -4,8 +4,8 @@ import typing
 import cscore as cs
 import cv2 as cv
 import numpy as np
-import robotpy_apriltag
 import wpilib
+from robotpy_apriltag import AprilTagField, AprilTagFieldLayout
 from wpimath.geometry import Pose3d, Transform3d
 from wpimath.units import meters, seconds
 
@@ -31,7 +31,7 @@ class PhotonCameraSim:
     def __init__(
         self,
         camera: PhotonCamera,
-        props: SimCameraProperties | None = None,
+        props: SimCameraProperties = SimCameraProperties.PERFECT_90DEG(),
         minTargetAreaPercent: float | None = None,
         maxSightRange: meters | None = None,
     ):
@@ -41,37 +41,12 @@ class PhotonCameraSim:
         self.videoSimRawEnabled: bool = False
         self.videoSimWireframeEnabled: bool = False
         self.videoSimWireframeResolution: float = 0.1
-        self.videoSimProcEnabled: bool = True
-        self.ts = NTTopicSet()
+        self.videoSimProcEnabled: bool = (
+            False  # TODO switch this back to default True when the functionality is enabled
+        )
         self.heartbeatCounter: int = 0
         self.nextNtEntryTime = int(wpilib.Timer.getFPGATimestamp() * 1e6)
-        self.tagLayout = robotpy_apriltag.loadAprilTagLayoutField(
-            robotpy_apriltag.AprilTagField.k2024Crescendo
-        )
-
-        if (
-            camera is not None
-            and props is None
-            and minTargetAreaPercent is None
-            and maxSightRange is None
-        ):
-            props = SimCameraProperties.PERFECT_90DEG()
-        elif (
-            camera is not None
-            and props is not None
-            and minTargetAreaPercent is not None
-            and maxSightRange is not None
-        ):
-            pass
-        elif (
-            camera is not None
-            and props is not None
-            and minTargetAreaPercent is None
-            and maxSightRange is None
-        ):
-            pass
-        else:
-            raise Exception("Invalid Constructor Called")
+        self.tagLayout = AprilTagFieldLayout.loadField(AprilTagField.k2024Crescendo)
 
         self.cam = camera
         self.prop = props
@@ -101,16 +76,11 @@ class PhotonCameraSim:
             (self.prop.getResWidth(), self.prop.getResHeight())
         )
 
-        self.ts.subTable = self.cam._cameraTable
+        self.ts = NTTopicSet("photonvision", self.cam.getName())
         self.ts.updateEntries()
 
         # Handle this last explicitly for this function signature because the other constructor is called in the initialiser list
-        if (
-            camera is not None
-            and props is not None
-            and minTargetAreaPercent is not None
-            and maxSightRange is not None
-        ):
+        if minTargetAreaPercent is not None and maxSightRange is not None:
             self.minTargetAreaPercent = minTargetAreaPercent
             self.maxSightRange = maxSightRange
 
@@ -194,19 +164,19 @@ class PhotonCameraSim:
         self.maxSightRange = range
 
     def enableRawStream(self, enabled: bool) -> None:
+        self.videoSimRawEnabled = enabled
         raise Exception("Raw stream not implemented")
-        # self.videoSimRawEnabled = enabled
 
     def enableDrawWireframe(self, enabled: bool) -> None:
+        self.videoSimWireframeEnabled = enabled
         raise Exception("Wireframe not implemented")
-        # self.videoSimWireframeEnabled = enabled
 
     def setWireframeResolution(self, resolution: float) -> None:
         self.videoSimWireframeResolution = resolution
 
     def enableProcessedStream(self, enabled: bool) -> None:
+        self.videoSimProcEnabled = enabled
         raise Exception("Processed stream not implemented")
-        # self.videoSimProcEnabled = enabled
 
     def process(
         self, latency: seconds, cameraPose: Pose3d, targets: list[VisionTargetSim]
@@ -217,9 +187,7 @@ class PhotonCameraSim:
 
         targets.sort(key=distance, reverse=True)
 
-        visibleTgts: list[
-            typing.Tuple[VisionTargetSim, list[typing.Tuple[float, float]]]
-        ] = []
+        visibleTgts: list[typing.Tuple[VisionTargetSim, np.ndarray]] = []
         detectableTgts: list[PhotonTrackedTarget] = []
 
         camRt = RotTrlTransform3d.makeRelativeTo(cameraPose)
@@ -258,6 +226,7 @@ class PhotonCameraSim:
                 ] * 4
                 t = (l + 1) % 4
                 b = (l + 1) % 4
+                r = 0
                 for i in range(4):
                     if i == l:
                         continue
@@ -271,14 +240,14 @@ class PhotonCameraSim:
                     if i != t and i != l and i != b:
                         r = i
                 rect = cv.RotatedRect(
-                    center,
+                    (center[0, 0], center[0, 1]),
                     (
                         imagePoints[r, 0, 0] - lc[0, 0],
                         imagePoints[b, 0, 1] - imagePoints[t, 0, 1],
                     ),
                     -angles[r],
                 )
-                imagePoints = rect.points()
+                imagePoints = np.array([[p[0], p[1], p[2]] for p in rect.points()])
 
             visibleTgts.append((tgt, imagePoints))
             noisyTargetCorners = self.prop.estPixelNoise(imagePoints)
@@ -325,13 +294,13 @@ class PhotonCameraSim:
             )
 
         # Video streams disabled for now
-        if self.enableRawStream:
+        if self.videoSimRawEnabled:
             # VideoSimUtil::UpdateVideoProp(videoSimRaw, prop);
             # cv::Size videoFrameSize{prop.GetResWidth(), prop.GetResHeight()};
             # cv::Mat blankFrame = cv::Mat::zeros(videoFrameSize, CV_8UC1);
             # blankFrame.assignTo(videoSimFrameRaw);
             pass
-        if self.enableProcessedStream:
+        if self.videoSimProcEnabled:
             # VideoSimUtil::UpdateVideoProp(videoSimProcessed, prop);
             pass
 
@@ -385,6 +354,7 @@ class PhotonCameraSim:
             self.ts.targetSkewEntry.set(0.0, receiveTimestamp)
         else:
             bestTarget = result.getBestTarget()
+            assert bestTarget
 
             self.ts.targetPitchEntry.set(bestTarget.getPitch(), receiveTimestamp)
             self.ts.targetYawEntry.set(bestTarget.getYaw(), receiveTimestamp)

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/simulation/simCameraProperties.py

@@ -11,7 +11,7 @@ from ..estimation import RotTrlTransform3d
 
 
 class SimCameraProperties:
-    def __init__(self, path: str | None = None, width: int = 0, height: int = 0):
+    def __init__(self):
         self.resWidth: int = -1
         self.resHeight: int = -1
         self.camIntrinsics: np.ndarray = np.zeros((3, 3))  # [3,3]
@@ -24,57 +24,41 @@ class SimCameraProperties:
         self.latencyStdDev: seconds = 0.0
         self.viewplanes: list[np.ndarray] = []  # [3,1]
 
-        if path is None:
-            self.setCalibration(960, 720, fovDiag=Rotation2d(math.radians(90.0)))
-        else:
-            raise Exception("not yet implemented")
-
-    def setCalibration(
-        self,
-        width: int,
-        height: int,
-        *,
-        fovDiag: Rotation2d | None = None,
-        newCamIntrinsics: np.ndarray | None = None,
-        newDistCoeffs: np.ndarray | None = None,
-    ):
-        # Should be an inverted XOR on the args to differentiate between the signatures
-
-        has_fov_args = fovDiag is not None
-        has_matrix_args = newCamIntrinsics is not None and newDistCoeffs is not None
+        self.setCalibrationFromFOV(960, 720, fovDiag=Rotation2d(math.radians(90.0)))
 
-        if (has_fov_args and has_matrix_args) or (
-            not has_matrix_args and not has_fov_args
-        ):
-            raise Exception("not a correct function sig")
+    def setCalibrationFromFOV(
+        self, width: int, height: int, fovDiag: Rotation2d
+    ) -> None:
+        if fovDiag.degrees() < 1.0 or fovDiag.degrees() > 179.0:
+            fovDiag = Rotation2d.fromDegrees(max(min(fovDiag.degrees(), 179.0), 1.0))
+            logging.error("Requested invalid FOV! Clamping between (1, 179) degrees...")
 
-        if has_fov_args:
-            if fovDiag.degrees() < 1.0 or fovDiag.degrees() > 179.0:
-                fovDiag = Rotation2d.fromDegrees(
-                    max(min(fovDiag.degrees(), 179.0), 1.0)
-                )
-                logging.error(
-                    "Requested invalid FOV! Clamping between (1, 179) degrees..."
-                )
+        resDiag = math.sqrt(width * width + height * height)
+        diagRatio = math.tan(fovDiag.radians() / 2.0)
+        fovWidth = Rotation2d(math.atan((diagRatio * (width / resDiag)) * 2))
+        fovHeight = Rotation2d(math.atan(diagRatio * (height / resDiag)) * 2)
 
-            resDiag = math.sqrt(width * width + height * height)
-            diagRatio = math.tan(fovDiag.radians() / 2.0)
-            fovWidth = Rotation2d(math.atan((diagRatio * (width / resDiag)) * 2))
-            fovHeight = Rotation2d(math.atan(diagRatio * (height / resDiag)) * 2)
+        newDistCoeffs = np.zeros((8, 1))
 
-            newDistCoeffs = np.zeros((8, 1))
+        cx = width / 2.0 - 0.5
+        cy = height / 2.0 - 0.5
 
-            cx = width / 2.0 - 0.5
-            cy = height / 2.0 - 0.5
+        fx = cx / math.tan(fovWidth.radians() / 2.0)
+        fy = cy / math.tan(fovHeight.radians() / 2.0)
 
-            fx = cx / math.tan(fovWidth.radians() / 2.0)
-            fy = cy / math.tan(fovHeight.radians() / 2.0)
+        newCamIntrinsics = np.array([[fx, 0.0, cx], [0.0, fy, cy], [0.0, 0.0, 1.0]])
 
-            newCamIntrinsics = np.array([[fx, 0.0, cx], [0.0, fy, cy], [0.0, 0.0, 1.0]])
+        self.setCalibrationFromIntrinsics(
+            width, height, newCamIntrinsics, newDistCoeffs
+        )
 
-        # really convince python we are doing the right thing
-        assert newCamIntrinsics is not None
-        assert newDistCoeffs is not None
+    def setCalibrationFromIntrinsics(
+        self,
+        width: int,
+        height: int,
+        newCamIntrinsics: np.ndarray,
+        newDistCoeffs: np.ndarray,
+    ) -> None:
 
         self.resWidth = width
         self.resHeight = height
@@ -171,10 +155,8 @@ class SimCameraProperties:
     def getLatencyStdDev(self) -> seconds:
         return self.latencyStdDev
 
-    def getContourAreaPercent(self, points: list[typing.Tuple[float, float]]) -> float:
-        return (
-            cv.contourArea(cv.convexHull(np.array(points))) / self.getResArea() * 100.0
-        )
+    def getContourAreaPercent(self, points: np.ndarray) -> float:
+        return cv.contourArea(cv.convexHull(points)) / self.getResArea() * 100.0
 
     def getPixelYaw(self, pixelX: float) -> Rotation2d:
         fx = self.camIntrinsics[0, 0]
@@ -188,14 +170,14 @@ class SimCameraProperties:
         yOffset = cy - pixelY
         return Rotation2d(fy, -yOffset)
 
-    def getPixelRot(self, point: typing.Tuple[int, int]) -> Rotation3d:
+    def getPixelRot(self, point: cv.typing.Point2f) -> Rotation3d:
         return Rotation3d(
             0.0,
             self.getPixelPitch(point[1]).radians(),
             self.getPixelYaw(point[0]).radians(),
         )
 
-    def getCorrectedPixelRot(self, point: typing.Tuple[float, float]) -> Rotation3d:
+    def getCorrectedPixelRot(self, point: cv.typing.Point2f) -> Rotation3d:
         fx = self.camIntrinsics[0, 0]
         cx = self.camIntrinsics[0, 2]
         xOffset = cx - point[0]
@@ -226,8 +208,8 @@ class SimCameraProperties:
     def getVisibleLine(
         self, camRt: RotTrlTransform3d, a: Translation3d, b: Translation3d
     ) -> typing.Tuple[float | None, float | None]:
-        relA = camRt.apply(a)
-        relB = camRt.apply(b)
+        relA = camRt.applyTranslation(a)
+        relB = camRt.applyTranslation(b)
 
         if relA.X() <= 0.0 and relB.X() <= 0.0:
             return (None, None)
@@ -279,7 +261,7 @@ class SimCameraProperties:
                     ipts[i] = None
                     break
 
-            if not ipts[i]:
+            if ipts[i] is None:
                 continue
 
             for j in range(i - 1, 0 - 1):
@@ -357,7 +339,7 @@ class SimCameraProperties:
     @classmethod
     def PI4_LIFECAM_320_240(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             320,
             240,
             newCamIntrinsics=np.array(
@@ -391,7 +373,7 @@ class SimCameraProperties:
     @classmethod
     def PI4_LIFECAM_640_480(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             640,
             480,
             newCamIntrinsics=np.array(
@@ -425,7 +407,7 @@ class SimCameraProperties:
     @classmethod
     def LL2_640_480(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             640,
             480,
             newCamIntrinsics=np.array(
@@ -459,7 +441,7 @@ class SimCameraProperties:
     @classmethod
     def LL2_960_720(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             960,
             720,
             newCamIntrinsics=np.array(
@@ -493,7 +475,7 @@ class SimCameraProperties:
     @classmethod
     def LL2_1280_720(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             1280,
             720,
             newCamIntrinsics=np.array(
@@ -527,7 +509,7 @@ class SimCameraProperties:
     @classmethod
     def OV9281_640_480(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             640,
             480,
             newCamIntrinsics=np.array(
@@ -561,7 +543,7 @@ class SimCameraProperties:
     @classmethod
     def OV9281_800_600(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             800,
             600,
             newCamIntrinsics=np.array(
@@ -595,7 +577,7 @@ class SimCameraProperties:
     @classmethod
     def OV9281_1280_720(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             1280,
             720,
             newCamIntrinsics=np.array(
@@ -629,7 +611,7 @@ class SimCameraProperties:
     @classmethod
     def OV9281_1920_1080(cls) -> typing.Self:
         prop = cls()
-        prop.setCalibration(
+        prop.setCalibrationFromIntrinsics(
             1920,
             1080,
             newCamIntrinsics=np.array(

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/simulation/visionSystemSim.py

@@ -84,7 +84,11 @@ class VisionSystemSim:
         if robotToCamera is None:
             return None
         else:
-            return self.getRobotPose(time) + robotToCamera
+            pose = self.getRobotPose(time)
+            if pose:
+                return pose + robotToCamera
+            else:
+                return None
 
     def adjustCamera(
         self, cameraSim: PhotonCameraSim, robotToCamera: Transform3d
@@ -167,7 +171,7 @@ class VisionSystemSim:
 
     def getRobotPose(
         self, timestamp: seconds = wpilib.Timer.getFPGATimestamp()
-    ) -> Pose3d:
+    ) -> Pose3d | None:
         return self.robotPoseBuffer.sample(timestamp)
 
     def resetRobotPose(self, robotPose: Pose2d | Pose3d) -> None:
@@ -216,15 +220,16 @@ class VisionSystemSim:
             timestampCapture = timestampNt * 1.0e-6 - latency
 
             lateRobotPose = self.getRobotPose(timestampCapture)
-            lateCameraPose = lateRobotPose + self.getRobotToCamera(
-                camSim, timestampCapture
-            )
+            robotToCamera = self.getRobotToCamera(camSim, timestampCapture)
+            if lateRobotPose is None or robotToCamera is None:
+                return None
+            lateCameraPose = lateRobotPose + robotToCamera
             cameraPoses2d.append(lateCameraPose.toPose2d())
 
             camResult = camSim.process(latency, lateCameraPose, allTargets)
             camSim.submitProcessedFrame(camResult, timestampNt)
-            for target in camResult.getTargets():
-                trf = target.getBestCameraToTarget()
+            for tgt in camResult.getTargets():
+                trf = tgt.getBestCameraToTarget()
                 if trf == Transform3d():
                     continue
 

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/targeting/TargetCorner.py

@@ -2,7 +2,7 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, ClassVar
 
 if TYPE_CHECKING:
-    from .. import generated
+    from ..generated.TargetCornerSerde import TargetCornerSerde
 
 
 @dataclass
@@ -10,4 +10,4 @@ class TargetCorner:
     x: float = 0
     y: float = 9
 
-    photonStruct: ClassVar["generated.TargetCornerSerde"]
+    photonStruct: ClassVar["TargetCornerSerde"]

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/targeting/multiTargetPNPResult.py

@@ -3,10 +3,9 @@ from typing import TYPE_CHECKING, ClassVar
 
 from wpimath.geometry import Transform3d
 
-from ..packet import Packet
-
 if TYPE_CHECKING:
-    from .. import generated
+    from ..generated.MultiTargetPNPResultSerde import MultiTargetPNPResultSerde
+    from ..generated.PnpResultSerde import PnpResultSerde
 
 
 @dataclass
@@ -17,7 +16,7 @@ class PnpResult:
     bestReprojErr: float = 0.0
     altReprojErr: float = 0.0
 
-    photonStruct: ClassVar["generated.PnpResultSerde"]
+    photonStruct: ClassVar["PnpResultSerde"]
 
 
 @dataclass
@@ -27,14 +26,4 @@ class MultiTargetPNPResult:
     estimatedPose: PnpResult = field(default_factory=PnpResult)
     fiducialIDsUsed: list[int] = field(default_factory=list)
 
-    def createFromPacket(self, packet: Packet) -> Packet:
-        self.estimatedPose = PnpResult()
-        self.estimatedPose.createFromPacket(packet)
-        self.fiducialIDsUsed = []
-        for _ in range(MultiTargetPNPResult._MAX_IDS):
-            fidId = packet.decode16()
-            if fidId >= 0:
-                self.fiducialIDsUsed.append(fidId)
-        return packet
-
-    photonStruct: ClassVar["generated.MultiTargetPNPResultSerde"]
+    photonStruct: ClassVar["MultiTargetPNPResultSerde"]

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/targeting/photonPipelineResult.py

@@ -5,7 +5,8 @@ from .multiTargetPNPResult import MultiTargetPNPResult
 from .photonTrackedTarget import PhotonTrackedTarget
 
 if TYPE_CHECKING:
-    from .. import generated
+    from ..generated.PhotonPipelineMetadataSerde import PhotonPipelineMetadataSerde
+    from ..generated.PhotonPipelineResultSerde import PhotonPipelineResultSerde
 
 
 @dataclass
@@ -20,7 +21,7 @@ class PhotonPipelineMetadata:
 
     timeSinceLastPong: int = -1
 
-    photonStruct: ClassVar["generated.PhotonPipelineMetadataSerde"]
+    photonStruct: ClassVar["PhotonPipelineMetadataSerde"]
 
 
 @dataclass
@@ -69,4 +70,4 @@ class PhotonPipelineResult:
             return None
         return self.getTargets()[0]
 
-    photonStruct: ClassVar["generated.PhotonPipelineResultSerde"]
+    photonStruct: ClassVar["PhotonPipelineResultSerde"]

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy/targeting/photonTrackedTarget.py

@@ -7,7 +7,7 @@ from ..packet import Packet
 from .TargetCorner import TargetCorner
 
 if TYPE_CHECKING:
-    from .. import generated
+    from ..generated.PhotonTrackedTargetSerde import PhotonTrackedTargetSerde
 
 
 @dataclass
@@ -63,4 +63,4 @@ class PhotonTrackedTarget:
             retList.append(TargetCorner(cx, cy))
         return retList
 
-    photonStruct: ClassVar["generated.PhotonTrackedTargetSerde"]
+    photonStruct: ClassVar["PhotonTrackedTargetSerde"]

photonlibpy-2025.0.0b3/photonlibpy/version.py

@@ -0,0 +1,2 @@
+PHOTONLIB_VERSION="v2025.0.0.beta.3"
+PHOTONVISION_VERSION="v2025.0.0-beta-3"

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: photonlibpy
-Version: 2025.0.0b2
-Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-beta-2 .
+Version: 2025.0.0b3
+Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-beta-3 .
 Home-page: https://photonvision.org
 Author: Photonvision Development Team
 Description-Content-Type: text/markdown

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/photonlibpy.egg-info/SOURCES.txt

@@ -1,3 +1,4 @@
+pyproject.toml
 setup.py
 photonlibpy/__init__.py
 photonlibpy/estimatedRobotPose.py

photonlibpy-2025.0.0b3/photonlibpy.egg-info/requires.txt

@@ -0,0 +1,12 @@
+numpy~=2.1
+wpilib<2026,>=2025.0.0b1
+robotpy-wpimath<2026,>=2025.0.0b1
+robotpy-apriltag<2026,>=2025.0.0b1
+robotpy-cscore<2026,>=2025.0.0b1
+pyntcore<2026,>=2025.0.0b1
+
+[:platform_machine != "roborio"]
+opencv-python
+
+[:platform_machine == "roborio"]
+robotpy-opencv

photonlibpy-2025.0.0b3/pyproject.toml

@@ -0,0 +1,2 @@
+[tool.mypy]
+exclude = ["build","setup.py"]

{photonlibpy-2025.0.0b2 → photonlibpy-2025.0.0b3}/setup.py

@@ -57,12 +57,12 @@ setup(
     packages=find_packages(),
     version=versionString,
     install_requires=[
-        "numpy~=1.25",
-        "wpilib<2025,>=2024.0.0b2",
-        "robotpy-wpimath<2025,>=2024.0.0b2",
-        "robotpy-apriltag<2025,>=2024.0.0b2",
-        "robotpy-cscore<2025,>=2024.0.0.b2",
-        "pyntcore<2025,>=2024.0.0b2",
+        "numpy~=2.1",
+        "wpilib<2026,>=2025.0.0b1",
+        "robotpy-wpimath<2026,>=2025.0.0b1",
+        "robotpy-apriltag<2026,>=2025.0.0b1",
+        "robotpy-cscore<2026,>=2025.0.0b1",
+        "pyntcore<2026,>=2025.0.0b1",
         "robotpy-opencv;platform_machine=='roborio'",
         "opencv-python;platform_machine!='roborio'",
     ],

photonlibpy-2025.0.0b2/photonlibpy/estimation/rotTrlTransform3d.py

@@ -1,32 +0,0 @@
-from typing import Self
-
-from wpimath.geometry import Pose3d, Rotation3d, Transform3d, Translation3d
-
-
-class RotTrlTransform3d:
-    def __init__(
-        self, rot: Rotation3d = Rotation3d(), trl: Translation3d = Translation3d()
-    ):
-        self.rot = rot
-        self.trl = trl
-
-    def inverse(self) -> Self:
-        invRot = -self.rot
-        invTrl = -(self.trl.rotateBy(invRot))
-        return type(self)(invRot, invTrl)
-
-    def getTransform(self) -> Transform3d:
-        return Transform3d(self.trl, self.rot)
-
-    def getTranslation(self) -> Translation3d:
-        return self.trl
-
-    def getRotation(self) -> Rotation3d:
-        return self.rot
-
-    def apply(self, trlToApply: Translation3d) -> Translation3d:
-        return trlToApply.rotateBy(self.rot) + self.trl
-
-    @classmethod
-    def makeRelativeTo(cls, pose: Pose3d) -> Self:
-        return cls(pose.rotation(), pose.translation()).inverse()

photonlibpy-2025.0.0b2/photonlibpy/estimation/targetModel.py

@@ -1,137 +0,0 @@
-import math
-from typing import List, Self
-
-from wpimath.geometry import Pose3d, Rotation2d, Rotation3d, Translation3d
-from wpimath.units import meters
-
-from . import RotTrlTransform3d
-
-
-class TargetModel:
-    def __init__(
-        self,
-        *,
-        width: meters | None = None,
-        height: meters | None = None,
-        length: meters | None = None,
-        diameter: meters | None = None,
-        verts: List[Translation3d] | None = None
-    ):
-
-        if (
-            width is not None
-            and height is not None
-            and length is None
-            and diameter is None
-            and verts is None
-        ):
-            self.isPlanar = True
-            self.isSpherical = False
-            self.vertices = [
-                Translation3d(0.0, -width / 2.0, -height / 2.0),
-                Translation3d(0.0, width / 2.0, -height / 2.0),
-                Translation3d(0.0, width / 2.0, height / 2.0),
-                Translation3d(0.0, -width / 2.0, height / 2.0),
-            ]
-
-            return
-
-        elif (
-            length is not None
-            and width is not None
-            and height is not None
-            and diameter is None
-            and verts is None
-        ):
-            verts = [
-                Translation3d(length / 2.0, -width / 2.0, -height / 2.0),
-                Translation3d(length / 2.0, width / 2.0, -height / 2.0),
-                Translation3d(length / 2.0, width / 2.0, height / 2.0),
-                Translation3d(length / 2.0, -width / 2.0, height / 2.0),
-                Translation3d(-length / 2.0, -width / 2.0, height / 2.0),
-                Translation3d(-length / 2.0, width / 2.0, height / 2.0),
-                Translation3d(-length / 2.0, width / 2.0, -height / 2.0),
-                Translation3d(-length / 2.0, -width / 2.0, -height / 2.0),
-            ]
-            # Handle the rest of this in the "default" case
-        elif (
-            diameter is not None
-            and width is None
-            and height is None
-            and length is None
-            and verts is None
-        ):
-            self.isPlanar = False
-            self.isSpherical = True
-            self.vertices = [
-                Translation3d(0.0, -diameter / 2.0, 0.0),
-                Translation3d(0.0, 0.0, -diameter / 2.0),
-                Translation3d(0.0, diameter / 2.0, 0.0),
-                Translation3d(0.0, 0.0, diameter / 2.0),
-            ]
-            return
-        elif (
-            verts is not None
-            and width is None
-            and height is None
-            and length is None
-            and diameter is None
-        ):
-            # Handle this in the "default" case
-            pass
-        else:
-            raise Exception("Not a valid overload")
-
-        # TODO maybe remove this if there is a better/preferred way
-        # make the python type checking gods happy
-        assert verts is not None
-
-        self.isSpherical = False
-        if len(verts) <= 2:
-            self.vertices: List[Translation3d] = []
-            self.isPlanar = False
-        else:
-            cornersPlaner = True
-            for corner in verts:
-                if abs(corner.X() < 1e-4):
-                    cornersPlaner = False
-            self.isPlanar = cornersPlaner
-
-        self.vertices = verts
-
-    def getFieldVertices(self, targetPose: Pose3d) -> List[Translation3d]:
-        basisChange = RotTrlTransform3d(targetPose.rotation(), targetPose.translation())
-
-        retVal = []
-
-        for vert in self.vertices:
-            retVal.append(basisChange.apply(vert))
-
-        return retVal
-
-    @classmethod
-    def getOrientedPose(cls, tgtTrl: Translation3d, cameraTrl: Translation3d):
-        relCam = cameraTrl - tgtTrl
-        orientToCam = Rotation3d(
-            0.0,
-            Rotation2d(math.hypot(relCam.X(), relCam.Y()), relCam.Z()).radians(),
-            Rotation2d(relCam.X(), relCam.Y()).radians(),
-        )
-        return Pose3d(tgtTrl, orientToCam)
-
-    def getVertices(self) -> List[Translation3d]:
-        return self.vertices
-
-    def getIsPlanar(self) -> bool:
-        return self.isPlanar
-
-    def getIsSpherical(self) -> bool:
-        return self.isSpherical
-
-    @classmethod
-    def AprilTag36h11(cls) -> Self:
-        return cls(width=6.5 * 0.0254, height=6.5 * 0.0254)
-
-    @classmethod
-    def AprilTag16h5(cls) -> Self:
-        return cls(width=6.0 * 0.0254, height=6.0 * 0.0254)

photonlibpy-2025.0.0b2/photonlibpy/version.py

@@ -1,2 +0,0 @@
-PHOTONLIB_VERSION="v2025.0.0.beta.2"
-PHOTONVISION_VERSION="v2025.0.0-beta-2"

photonlibpy-2025.0.0b2/photonlibpy.egg-info/requires.txt

@@ -1,12 +0,0 @@
-numpy~=1.25
-wpilib<2025,>=2024.0.0b2
-robotpy-wpimath<2025,>=2024.0.0b2
-robotpy-apriltag<2025,>=2024.0.0b2
-robotpy-cscore<2025,>=2024.0.0.b2
-pyntcore<2025,>=2024.0.0b2
-
-[:platform_machine != "roborio"]
-opencv-python
-
-[:platform_machine == "roborio"]
-robotpy-opencv