photonlibpy 2024.3.1__py3-none-any.whl → 2025.0.0b1__py3-none-any.whl

photonlibpy/packet.py

@@ -1,10 +1,28 @@
+###############################################################################
+## Copyright (C) Photon Vision.
+###############################################################################
+## This program is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program.  If not, see <https://www.gnu.org/licenses/>.
+###############################################################################
+
 import struct
+from typing import Any, Optional, Type
 from wpimath.geometry import Transform3d, Translation3d, Rotation3d, Quaternion
 import wpilib
 
 
 class Packet:
-    def __init__(self, data: bytes):
+    def __init__(self, data: bytes = b""):
         """
         * Constructs an empty packet.
         *
@@ -67,7 +85,9 @@ class Packet:
         for _ in range(numBytes):
             intList.append(self._getNextByteAsInt())
 
-        # Interpret the bytes as a floating point number
+        # Interpret the bytes as the requested type.
+        # Note due to NT's byte order assumptions,
+        # we have to flip the order of intList
         value = struct.unpack(unpackFormat, bytes(intList))[0]
 
         return value
@@ -78,23 +98,39 @@ class Packet:
         *
         * @return A decoded byte from the packet.
         """
-        return self._decodeGeneric(">b", 1)
+        return self._decodeGeneric("<b", 1)
 
     def decode16(self) -> int:
         """
-        * Returns a single decoded byte from the packet.
+        * Returns a single decoded short from the packet.
         *
-        * @return A decoded byte from the packet.
+        * @return A decoded short from the packet.
         """
-        return self._decodeGeneric(">h", 2)
+        return self._decodeGeneric("<h", 2)
 
-    def decode32(self) -> int:
+    def decodeInt(self) -> int:
         """
         * Returns a decoded int (32 bytes) from the packet.
         *
         * @return A decoded int from the packet.
         """
-        return self._decodeGeneric(">l", 4)
+        return self._decodeGeneric("<l", 4)
+
+    def decodeFloat(self) -> float:
+        """
+        * Returns a decoded float from the packet.
+        *
+        * @return A decoded float from the packet.
+        """
+        return self._decodeGeneric("<f", 4)
+
+    def decodeLong(self) -> int:
+        """
+        * Returns a decoded int64 from the packet.
+        *
+        * @return A decoded int64 from the packet.
+        """
+        return self._decodeGeneric("<q", 8)
 
     def decodeDouble(self) -> float:
         """
@@ -102,7 +138,7 @@ class Packet:
         *
         * @return A decoded double from the packet.
         """
-        return self._decodeGeneric(">d", 8)
+        return self._decodeGeneric("<d", 8)
 
     def decodeBoolean(self) -> bool:
         """
@@ -115,14 +151,22 @@ class Packet:
     def decodeDoubleArray(self, length: int) -> list[float]:
         """
         * Returns a decoded array of floats from the packet.
-        *
-        * @return A decoded array of floats from the packet.
         """
         ret = []
         for _ in range(length):
             ret.append(self.decodeDouble())
         return ret
 
+    def decodeShortList(self) -> list[float]:
+        """
+        * Returns a decoded array of shorts from the packet.
+        """
+        length = self.decode8()
+        ret = []
+        for _ in range(length):
+            ret.append(self.decode16())
+        return ret
+
     def decodeTransform(self) -> Transform3d:
         """
         * Returns a decoded Transform3d
@@ -141,3 +185,123 @@ class Packet:
         rotation = Rotation3d(Quaternion(w, x, y, z))
 
         return Transform3d(translation, rotation)
+
+    def decodeList(self, serde: Type):
+        retList = []
+        arr_len = self.decode8()
+        for _ in range(arr_len):
+            retList.append(serde.unpack(self))
+        return retList
+
+    def decodeOptional(self, serde: Type) -> Optional[Any]:
+        if self.decodeBoolean():
+            return serde.unpack(self)
+        else:
+            return None
+
+    def _encodeGeneric(self, packFormat, value):
+        """
+        Append bytes to the packet data buffer.
+        """
+        self.packetData = self.packetData + struct.pack(packFormat, value)
+        self.size = len(self.packetData)
+
+    def encode8(self, value: int):
+        """
+        Encodes a single byte and appends it to the packet.
+        """
+        self._encodeGeneric("<b", value)
+
+    def encode16(self, value: int):
+        """
+        Encodes a short (2 bytes) and appends it to the packet.
+        """
+        self._encodeGeneric("<h", value)
+
+    def encodeInt(self, value: int):
+        """
+        Encodes an int (4 bytes) and appends it to the packet.
+        """
+        self._encodeGeneric("<l", value)
+
+    def encodeFloat(self, value: float):
+        """
+        Encodes a float (4 bytes) and appends it to the packet.
+        """
+        self._encodeGeneric("<f", value)
+
+    def encodeLong(self, value: int):
+        """
+        Encodes a long (8 bytes) and appends it to the packet.
+        """
+        self._encodeGeneric("<q", value)
+
+    def encodeDouble(self, value: float):
+        """
+        Encodes a double (8 bytes) and appends it to the packet.
+        """
+        self._encodeGeneric("<d", value)
+
+    def encodeBoolean(self, value: bool):
+        """
+        Encodes a boolean as a single byte and appends it to the packet.
+        """
+        self.encode8(1 if value else 0)
+
+    def encodeDoubleArray(self, values: list[float]):
+        """
+        Encodes an array of doubles and appends it to the packet.
+        """
+        self.encode8(len(values))
+        for value in values:
+            self.encodeDouble(value)
+
+    def encodeShortList(self, values: list[int]):
+        """
+        Encodes a list of shorts, with length prefixed as a single byte.
+        """
+        self.encode8(len(values))
+        for value in values:
+            self.encode16(value)
+
+    def encodeTransform(self, transform: Transform3d):
+        """
+        Encodes a Transform3d (translation and rotation) and appends it to the packet.
+        """
+        # Encode Translation3d part (x, y, z)
+        self.encodeDouble(transform.translation().x)
+        self.encodeDouble(transform.translation().y)
+        self.encodeDouble(transform.translation().z)
+
+        # Encode Rotation3d as Quaternion (w, x, y, z)
+        quaternion = transform.rotation().getQuaternion()
+        self.encodeDouble(quaternion.W())
+        self.encodeDouble(quaternion.X())
+        self.encodeDouble(quaternion.Y())
+        self.encodeDouble(quaternion.Z())
+
+    def encodeList(self, values: list[Any], serde: Type):
+        """
+        Encodes a list of items using a specific serializer and appends it to the packet.
+        """
+        self.encode8(len(values))
+        for item in values:
+            packed = serde.pack(item)
+            self.packetData = self.packetData + packed.getData()
+            self.size = len(self.packetData)
+
+    def encodeOptional(self, value: Optional[Any], serde: Type):
+        """
+        Encodes an optional value using a specific serializer.
+        """
+        if value is None:
+            self.encodeBoolean(False)
+        else:
+            self.encodeBoolean(True)
+            packed = serde.pack(value)
+            self.packetData = self.packetData + packed.getData()
+            self.size = len(self.packetData)
+
+    def encodeBytes(self, value: bytes):
+        self.packetData = self.packetData + value
+        self.size = len(self.packetData)

photonlibpy/photonCamera.py

@@ -1,10 +1,31 @@
+###############################################################################
+## Copyright (C) Photon Vision.
+###############################################################################
+## This program is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program.  If not, see <https://www.gnu.org/licenses/>.
+###############################################################################
+
 from enum import Enum
+from typing import List
 import ntcore
-from wpilib import Timer
+from wpilib import RobotController, Timer
 import wpilib
-from photonlibpy.packet import Packet
-from photonlibpy.photonPipelineResult import PhotonPipelineResult
-from photonlibpy.version import PHOTONVISION_VERSION, PHOTONLIB_VERSION  # type: ignore[import-untyped]
+from .packet import Packet
+from .targeting.photonPipelineResult import PhotonPipelineResult
+from .version import PHOTONVISION_VERSION, PHOTONLIB_VERSION  # type: ignore[import-untyped]
+
+# magical import to make serde stuff work
+import photonlibpy.generated  # noqa
 
 
 class VisionLEDMode(Enum):
@@ -32,7 +53,9 @@ class PhotonCamera:
         self._cameraTable = photonvision_root_table.getSubTable(cameraName)
         self._path = self._cameraTable.getPath()
         self._rawBytesEntry = self._cameraTable.getRawTopic("rawBytes").subscribe(
-            "rawBytes", bytes([]), ntcore.PubSubOptions(periodic=0.01, sendAll=True)
+            f"photonstruct:PhotonPipelineResult:{PhotonPipelineResult.photonStruct.MESSAGE_VERSION}",
+            bytes([]),
+            ntcore.PubSubOptions(periodic=0.01, sendAll=True),
         )
 
         self._driverModePublisher = self._cameraTable.getBooleanTopic(
@@ -75,23 +98,52 @@ class PhotonCamera:
         self._prevHeartbeat = 0
         self._prevHeartbeatChangeTime = Timer.getFPGATimestamp()
 
+    def getAllUnreadResults(self) -> List[PhotonPipelineResult]:
+        """
+        The list of pipeline results sent by PhotonVision since the last call to getAllUnreadResults().
+        Calling this function clears the internal FIFO queue, and multiple calls to
+        getAllUnreadResults() will return different (potentially empty) result arrays. Be careful to
+        call this exactly ONCE per loop of your robot code! FIFO depth is limited to 20 changes, so
+        make sure to call this frequently enough to avoid old results being discarded, too!
+        """
+
+        self._versionCheck()
+
+        changes = self._rawBytesEntry.readQueue()
+
+        ret = []
+
+        for change in changes:
+            byteList = change.value
+            timestamp = change.time
+
+            if len(byteList) < 1:
+                pass
+            else:
+                newResult = PhotonPipelineResult()
+                pkt = Packet(byteList)
+                newResult = PhotonPipelineResult.photonStruct.unpack(pkt)
+                # NT4 allows us to correct the timestamp based on when the message was sent
+                newResult.ntReceiveTimestampMicros = timestamp
+                ret.append(newResult)
+
+        return ret
+
     def getLatestResult(self) -> PhotonPipelineResult:
         self._versionCheck()
 
-        retVal = PhotonPipelineResult()
+        now = RobotController.getFPGATime()
         packetWithTimestamp = self._rawBytesEntry.getAtomic()
         byteList = packetWithTimestamp.value
-        timestamp = packetWithTimestamp.time
+        packetWithTimestamp.time
 
         if len(byteList) < 1:
-            return retVal
+            return PhotonPipelineResult()
         else:
             pkt = Packet(byteList)
-            retVal.populateFromPacket(pkt)
-            # NT4 allows us to correct the timestamp based on when the message was sent
-            retVal.setTimestampSeconds(
-                timestamp / 1e6 - retVal.getLatencyMillis() / 1e3
-            )
+            retVal = PhotonPipelineResult.photonStruct.unpack(pkt)
+            # We don't trust NT4 time, hack around
+            retVal.ntReceiveTimestampMicros = now
             return retVal
 
     def getDriverMode(self) -> bool:
@@ -147,6 +199,16 @@ class PhotonCamera:
             cameraNames = (
                 self._cameraTable.getInstance().getTable(self._tableName).getSubTables()
             )
+            # Look for only cameras with rawBytes entry that exists
+            cameraNames = list(
+                filter(
+                    lambda it: self._cameraTable.getSubTable(it)
+                    .getEntry("rawBytes")
+                    .exists(),
+                    cameraNames,
+                )
+            )
+
             if len(cameraNames) == 0:
                 wpilib.reportError(
                     "Could not find any PhotonVision coprocessors on NetworkTables. Double check that PhotonVision is running, and that your camera is connected!",
@@ -165,7 +227,20 @@ class PhotonCamera:
             )
 
         versionString = self.versionEntry.get(defaultValue="")
-        if len(versionString) > 0 and versionString != PHOTONVISION_VERSION:
+        localUUID = PhotonPipelineResult.photonStruct.MESSAGE_VERSION
+
+        remoteUUID = self._rawBytesEntry.getTopic().getProperty("message_uuid")
+
+        if remoteUUID is None or len(remoteUUID) == 0:
+            wpilib.reportWarning(
+                f"PhotonVision coprocessor at path {self._path} has not reported a message interface UUID - is your coprocessor's camera started?",
+                True,
+            )
+
+        # ntcore hands us a JSON string with leading/trailing quotes - remove those
+        remoteUUID = remoteUUID.replace('"', "")
+
+        if localUUID != remoteUUID:
             # Verified version mismatch
 
             bfw = """
@@ -190,6 +265,6 @@ class PhotonCamera:
 
             wpilib.reportWarning(bfw)
 
-            errText = f"Photon version {PHOTONLIB_VERSION} does not match coprocessor version {versionString}. Please install photonlibpy version {PHOTONLIB_VERSION}."
+            errText = f"Photonlibpy version {PHOTONLIB_VERSION} (With message UUID {localUUID}) does not match coprocessor version {versionString} (with message UUID {remoteUUID}). Please install photonlibpy version {versionString}, or update your coprocessor to {PHOTONLIB_VERSION}."
             wpilib.reportError(errText, True)
             raise Exception(errText)

photonlibpy/photonPoseEstimator.py

@@ -1,3 +1,20 @@
+###############################################################################
+## Copyright (C) Photon Vision.
+###############################################################################
+## This program is free software: you can redistribute it and/or modify
+## it under the terms of the GNU General Public License as published by
+## the Free Software Foundation, either version 3 of the License, or
+## (at your option) any later version.
+##
+## This program is distributed in the hope that it will be useful,
+## but WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+## GNU General Public License for more details.
+##
+## You should have received a copy of the GNU General Public License
+## along with this program.  If not, see <https://www.gnu.org/licenses/>.
+###############################################################################
+
 import enum
 from typing import Optional
 
@@ -5,7 +22,7 @@ import wpilib
 from robotpy_apriltag import AprilTagFieldLayout
 from wpimath.geometry import Transform3d, Pose3d, Pose2d
 
-from .photonPipelineResult import PhotonPipelineResult
+from .targeting.photonPipelineResult import PhotonPipelineResult
 from .photonCamera import PhotonCamera
 from .estimatedRobotPose import EstimatedRobotPose
 
@@ -207,7 +224,7 @@ class PhotonPoseEstimator:
                 return None
             cameraResult = self._camera.getLatestResult()
 
-        if cameraResult.timestampSec < 0:
+        if cameraResult.getTimestampSeconds() < 0:
             return None
 
         # If the pose cache timestamp was set, and the result is from the same
@@ -215,12 +232,15 @@ class PhotonPoseEstimator:
         # empty result
         if (
             self._poseCacheTimestampSeconds > 0.0
-            and abs(self._poseCacheTimestampSeconds - cameraResult.timestampSec) < 1e-6
+            and abs(
+                self._poseCacheTimestampSeconds - cameraResult.getTimestampSeconds()
+            )
+            < 1e-6
         ):
             return None
 
         # Remember the timestamp of the current result used
-        self._poseCacheTimestampSeconds = cameraResult.timestampSec
+        self._poseCacheTimestampSeconds = cameraResult.getTimestampSeconds()
 
         # If no targets seen, trivial case -- return empty result
         if not cameraResult.targets:
@@ -249,8 +269,8 @@ class PhotonPoseEstimator:
     def _multiTagOnCoprocStrategy(
         self, result: PhotonPipelineResult
     ) -> Optional[EstimatedRobotPose]:
-        if result.multiTagResult.estimatedPose.isPresent:
-            best_tf = result.multiTagResult.estimatedPose.best
+        if result.multitagResult is not None:
+            best_tf = result.multitagResult.estimatedPose.best
             best = (
                 Pose3d()
                 .transformBy(best_tf)  # field-to-camera
@@ -259,7 +279,7 @@ class PhotonPoseEstimator:
             )
             return EstimatedRobotPose(
                 best,
-                result.timestampSec,
+                result.getTimestampSeconds(),
                 result.targets,
                 PoseStrategy.MULTI_TAG_PNP_ON_COPROCESSOR,
             )
@@ -281,7 +301,6 @@ class PhotonPoseEstimator:
         lowestAmbiguityTarget = None
 
         lowestAmbiguityScore = 10.0
-
         for target in result.targets:
             targetPoseAmbiguity = target.poseAmbiguity
 
@@ -307,7 +326,7 @@ class PhotonPoseEstimator:
             targetPosition.transformBy(
                 lowestAmbiguityTarget.getBestCameraToTarget().inverse()
             ).transformBy(self.robotToCamera.inverse()),
-            result.timestampSec,
+            result.getTimestampSeconds(),
             result.targets,
             PoseStrategy.LOWEST_AMBIGUITY,
         )

photonlibpy/targeting/TargetCorner.py

@@ -0,0 +1,9 @@
+from dataclasses import dataclass
+
+
+@dataclass
+class TargetCorner:
+    x: float = 0
+    y: float = 9
+
+    photonStruct: "TargetCornerSerde" = None

photonlibpy/targeting/__init__.py

@@ -0,0 +1,6 @@
+# no one but us chickens
+
+from .TargetCorner import TargetCorner  # noqa
+from .multiTargetPNPResult import MultiTargetPNPResult, PnpResult  # noqa
+from .photonPipelineResult import PhotonPipelineMetadata, PhotonPipelineResult  # noqa
+from .photonTrackedTarget import PhotonTrackedTarget  # noqa

photonlibpy/targeting/multiTargetPNPResult.py

@@ -0,0 +1,34 @@
+from dataclasses import dataclass, field
+from wpimath.geometry import Transform3d
+from ..packet import Packet
+
+
+@dataclass
+class PnpResult:
+    best: Transform3d = field(default_factory=Transform3d)
+    alt: Transform3d = field(default_factory=Transform3d)
+    ambiguity: float = 0.0
+    bestReprojErr: float = 0.0
+    altReprojErr: float = 0.0
+
+    photonStruct: "PNPResultSerde" = None
+
+
+@dataclass
+class MultiTargetPNPResult:
+    _MAX_IDS = 32
+
+    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: "MultiTargetPNPResultSerde" = None

photonlibpy/targeting/photonPipelineResult.py

@@ -0,0 +1,69 @@
+from dataclasses import dataclass, field
+from typing import Optional
+
+from .multiTargetPNPResult import MultiTargetPNPResult
+from .photonTrackedTarget import PhotonTrackedTarget
+
+
+@dataclass
+class PhotonPipelineMetadata:
+    # Image capture and NT publish timestamp, in microseconds and in the coprocessor timebase. As
+    # reported by WPIUtilJNI::now.
+    captureTimestampMicros: int = -1
+    publishTimestampMicros: int = -1
+
+    # Mirror of the heartbeat entry -- monotonically increasing
+    sequenceID: int = -1
+
+    timeSinceLastPong: int = -1
+
+    photonStruct: "PhotonPipelineMetadataSerde" = None
+
+
+@dataclass
+class PhotonPipelineResult:
+    # Since we don't trust NT time sync, keep track of when we got this packet into robot code
+    ntReceiveTimestampMicros: int = -1
+
+    targets: list[PhotonTrackedTarget] = field(default_factory=list)
+    # Python users beware! We don't currently run a Time Sync Server, so these timestamps are in
+    # an arbitrary timebase. This is not true in C++ or Java.
+    metadata: PhotonPipelineMetadata = field(default_factory=PhotonPipelineMetadata)
+    multitagResult: Optional[MultiTargetPNPResult] = None
+
+    def getLatencyMillis(self) -> float:
+        return (
+            self.metadata.publishTimestampMicros - self.metadata.captureTimestampMicros
+        ) / 1e3
+
+    def getTimestampSeconds(self) -> float:
+        """
+        Returns the estimated time the frame was taken, in the Received system's time base. This is
+        calculated as (NT Receive time (robot base) - (publish timestamp, coproc timebase - capture
+        timestamp, coproc timebase))
+        """
+        # TODO - we don't trust NT4 to correctly latency-compensate ntReceiveTimestampMicros
+        return (
+            self.ntReceiveTimestampMicros
+            - (
+                self.metadata.publishTimestampMicros
+                - self.metadata.captureTimestampMicros
+            )
+        ) / 1e6
+
+    def getTargets(self) -> list[PhotonTrackedTarget]:
+        return self.targets
+
+    def hasTargets(self) -> bool:
+        return len(self.targets) > 0
+
+    def getBestTarget(self) -> PhotonTrackedTarget:
+        """
+        Returns the best target in this pipeline result. If there are no targets, this method will
+        return null. The best target is determined by the target sort mode in the PhotonVision UI.
+        """
+        if not self.hasTargets():
+            return None
+        return self.getTargets()[0]
+
+    photonStruct: "PhotonPipelineResultSerde" = None

photonlibpy/{photonTrackedTarget.py → targeting/photonTrackedTarget.py}

@@ -1,20 +1,11 @@
 from dataclasses import dataclass, field
 from wpimath.geometry import Transform3d
-from photonlibpy.packet import Packet
-
-
-@dataclass
-class TargetCorner:
-    x: float
-    y: float
+from ..packet import Packet
+from .TargetCorner import TargetCorner
 
 
 @dataclass
 class PhotonTrackedTarget:
-    _MAX_CORNERS = 8
-    _NUM_BYTES_IN_FLOAT = 8
-    _PACK_SIZE_BYTES = _NUM_BYTES_IN_FLOAT * (5 + 7 + 2 * 4 + 1 + 7 + 2 * _MAX_CORNERS)
-
     yaw: float = 0.0
     pitch: float = 0.0
     area: float = 0.0
@@ -22,9 +13,11 @@ class PhotonTrackedTarget:
     fiducialId: int = -1
     bestCameraToTarget: Transform3d = field(default_factory=Transform3d)
     altCameraToTarget: Transform3d = field(default_factory=Transform3d)
-    minAreaRectCorners: list[TargetCorner] | None = None
-    detectedCorners: list[TargetCorner] | None = None
+    minAreaRectCorners: list[TargetCorner] = field(default_factory=list[TargetCorner])
+    detectedCorners: list[TargetCorner] = field(default_factory=list[TargetCorner])
     poseAmbiguity: float = 0.0
+    objDetectId: int = -1
+    objDetectConf: float = 0.0
 
     def getYaw(self) -> float:
         return self.yaw
@@ -44,10 +37,10 @@ class PhotonTrackedTarget:
     def getPoseAmbiguity(self) -> float:
         return self.poseAmbiguity
 
-    def getMinAreaRectCorners(self) -> list[TargetCorner] | None:
+    def getMinAreaRectCorners(self) -> list[TargetCorner]:
         return self.minAreaRectCorners
 
-    def getDetectedCorners(self) -> list[TargetCorner] | None:
+    def getDetectedCorners(self) -> list[TargetCorner]:
         return self.detectedCorners
 
     def getBestCameraToTarget(self) -> Transform3d:
@@ -64,19 +57,4 @@ class PhotonTrackedTarget:
             retList.append(TargetCorner(cx, cy))
         return retList
 
-    def createFromPacket(self, packet: Packet) -> Packet:
-        self.yaw = packet.decodeDouble()
-        self.pitch = packet.decodeDouble()
-        self.area = packet.decodeDouble()
-        self.skew = packet.decodeDouble()
-        self.fiducialId = packet.decode32()
-
-        self.bestCameraToTarget = packet.decodeTransform()
-        self.altCameraToTarget = packet.decodeTransform()
-
-        self.poseAmbiguity = packet.decodeDouble()
-
-        self.minAreaRectCorners = self._decodeTargetList(packet, 4)  # always four
-        numCorners = packet.decode8()
-        self.detectedCorners = self._decodeTargetList(packet, numCorners)
-        return packet
+    photonStruct: "PhotonTrackedTargetSerde" = None

photonlibpy/version.py

@@ -1,2 +1,2 @@
-PHOTONLIB_VERSION="2024.3.1"
-PHOTONVISION_VERSION="v2024.3.1"
+PHOTONLIB_VERSION="v2025.0.0.beta.1"
+PHOTONVISION_VERSION="v2025.0.0-beta-1"