photonlibpy 2025.0.0a0__py3-none-any.whl → 2025.0.0b2__py3-none-any.whl

photonlibpy/simulation/visionSystemSim.py

@@ -0,0 +1,237 @@
+import typing
+
+import wpilib
+from robotpy_apriltag import AprilTagFieldLayout
+from wpilib import Field2d
+from wpimath.geometry import Pose2d, Pose3d, Transform3d
+
+# TODO(auscompgeek): update import path when RobotPy re-exports are fixed
+from wpimath.interpolation._interpolation import TimeInterpolatablePose3dBuffer
+from wpimath.units import seconds
+
+from ..estimation import TargetModel
+from .photonCameraSim import PhotonCameraSim
+from .visionTargetSim import VisionTargetSim
+
+
+class VisionSystemSim:
+    def __init__(self, visionSystemName: str):
+        self.dbgField: Field2d = Field2d()
+        self.bufferLength: seconds = 1.5
+
+        self.camSimMap: typing.Dict[str, PhotonCameraSim] = {}
+        self.camTrfMap: typing.Dict[PhotonCameraSim, TimeInterpolatablePose3dBuffer] = (
+            {}
+        )
+        self.robotPoseBuffer: TimeInterpolatablePose3dBuffer = (
+            TimeInterpolatablePose3dBuffer(self.bufferLength)
+        )
+        self.targetSets: typing.Dict[str, list[VisionTargetSim]] = {}
+
+        self.tableName: str = "VisionSystemSim-" + visionSystemName
+        wpilib.SmartDashboard.putData(self.tableName + "/Sim Field", self.dbgField)
+
+    def getCameraSim(self, name: str) -> PhotonCameraSim | None:
+        return self.camSimMap.get(name, None)
+
+    def getCameraSims(self) -> list[PhotonCameraSim]:
+        return [*self.camSimMap.values()]
+
+    def addCamera(self, cameraSim: PhotonCameraSim, robotToCamera: Transform3d) -> None:
+        name = cameraSim.getCamera().getName()
+        if name not in self.camSimMap:
+            self.camSimMap[name] = cameraSim
+            self.camTrfMap[cameraSim] = TimeInterpolatablePose3dBuffer(
+                self.bufferLength
+            )
+            self.camTrfMap[cameraSim].addSample(
+                wpilib.Timer.getFPGATimestamp(), Pose3d() + robotToCamera
+            )
+
+    def clearCameras(self) -> None:
+        self.camSimMap.clear()
+        self.camTrfMap.clear()
+
+    def removeCamera(self, cameraSim: PhotonCameraSim) -> bool:
+        name = cameraSim.getCamera().getName()
+        if name in self.camSimMap:
+            del self.camSimMap[name]
+            return True
+        else:
+            return False
+
+    def getRobotToCamera(
+        self,
+        cameraSim: PhotonCameraSim,
+        time: seconds = wpilib.Timer.getFPGATimestamp(),
+    ) -> Transform3d | None:
+        if cameraSim in self.camTrfMap:
+            trfBuffer = self.camTrfMap[cameraSim]
+            sample = trfBuffer.sample(time)
+            if sample is None:
+                return None
+            else:
+                return Transform3d(Pose3d(), sample)
+        else:
+            return None
+
+    def getCameraPose(
+        self,
+        cameraSim: PhotonCameraSim,
+        time: seconds = wpilib.Timer.getFPGATimestamp(),
+    ) -> Pose3d | None:
+        robotToCamera = self.getRobotToCamera(cameraSim, time)
+        if robotToCamera is None:
+            return None
+        else:
+            return self.getRobotPose(time) + robotToCamera
+
+    def adjustCamera(
+        self, cameraSim: PhotonCameraSim, robotToCamera: Transform3d
+    ) -> bool:
+        if cameraSim in self.camTrfMap:
+            self.camTrfMap[cameraSim].addSample(
+                wpilib.Timer.getFPGATimestamp(), Pose3d() + robotToCamera
+            )
+            return True
+        else:
+            return False
+
+    def resetCameraTransforms(self, cameraSim: PhotonCameraSim | None = None) -> None:
+        now = wpilib.Timer.getFPGATimestamp()
+
+        def resetSingleCamera(self, cameraSim: PhotonCameraSim) -> bool:
+            if cameraSim in self.camTrfMap:
+                trfBuffer = self.camTrfMap[cameraSim]
+                lastTrf = Transform3d(Pose3d(), trfBuffer.sample(now))
+                trfBuffer.clear()
+                self.adjustCamera(cameraSim, lastTrf)
+                return True
+            else:
+                return False
+
+        if cameraSim is None:
+            for camera in self.camTrfMap.keys():
+                resetSingleCamera(self, camera)
+        else:
+            resetSingleCamera(self, cameraSim)
+
+    def getVisionTargets(self, targetType: str | None = None) -> list[VisionTargetSim]:
+        if targetType is None:
+            all: list[VisionTargetSim] = []
+            for targets in self.targetSets.values():
+                for target in targets:
+                    all.append(target)
+            return all
+        else:
+            return self.targetSets[targetType]
+
+    def addVisionTargets(
+        self, targets: list[VisionTargetSim], targetType: str = "targets"
+    ) -> None:
+        if targetType not in self.targetSets:
+            self.targetSets[targetType] = targets
+        else:
+            self.targetSets[targetType] += targets
+
+    def addAprilTags(self, layout: AprilTagFieldLayout) -> None:
+        targets: list[VisionTargetSim] = []
+        for tag in layout.getTags():
+            tag_pose = layout.getTagPose(tag.ID)
+            # TODO this was done to make the python gods happy. Confirm that this is desired or if types dont matter
+            assert tag_pose is not None
+            targets.append(
+                VisionTargetSim(tag_pose, TargetModel.AprilTag36h11(), tag.ID)
+            )
+        self.addVisionTargets(targets, "apriltag")
+
+    def clearVisionTargets(self) -> None:
+        self.targetSets.clear()
+
+    def clearAprilTags(self) -> None:
+        self.removeVisionTargetType("apriltag")
+
+    def removeVisionTargetType(self, targetType: str) -> None:
+        del self.targetSets[targetType]
+
+    def removeVisionTargets(
+        self, targets: list[VisionTargetSim]
+    ) -> list[VisionTargetSim]:
+        removedList: list[VisionTargetSim] = []
+        for target in targets:
+            for _, currentTargets in self.targetSets.items():
+                if target in currentTargets:
+                    removedList.append(target)
+                    currentTargets.remove(target)
+        return removedList
+
+    def getRobotPose(
+        self, timestamp: seconds = wpilib.Timer.getFPGATimestamp()
+    ) -> Pose3d:
+        return self.robotPoseBuffer.sample(timestamp)
+
+    def resetRobotPose(self, robotPose: Pose2d | Pose3d) -> None:
+        if type(robotPose) is Pose2d:
+            robotPose = Pose3d(robotPose)
+        assert type(robotPose) is Pose3d
+
+        self.robotPoseBuffer.clear()
+        self.robotPoseBuffer.addSample(wpilib.Timer.getFPGATimestamp(), robotPose)
+
+    def getDebugField(self) -> Field2d:
+        return self.dbgField
+
+    def update(self, robotPose: Pose2d | Pose3d) -> None:
+        if type(robotPose) is Pose2d:
+            robotPose = Pose3d(robotPose)
+        assert type(robotPose) is Pose3d
+
+        for targetType, targets in self.targetSets.items():
+            posesToAdd: list[Pose2d] = []
+            for target in targets:
+                posesToAdd.append(target.getPose().toPose2d())
+            self.dbgField.getObject(targetType).setPoses(posesToAdd)
+
+        now = wpilib.Timer.getFPGATimestamp()
+        self.robotPoseBuffer.addSample(now, robotPose)
+        self.dbgField.setRobotPose(robotPose.toPose2d())
+
+        allTargets: list[VisionTargetSim] = []
+        for targets in self.targetSets.values():
+            for target in targets:
+                allTargets.append(target)
+
+        visTgtPoses2d: list[Pose2d] = []
+        cameraPoses2d: list[Pose2d] = []
+        processed = False
+        for camSim in self.camSimMap.values():
+            optTimestamp = camSim.consumeNextEntryTime()
+            if optTimestamp is None:
+                continue
+            else:
+                processed = True
+
+            timestampNt = optTimestamp
+            latency = camSim.prop.estLatency()
+            timestampCapture = timestampNt * 1.0e-6 - latency
+
+            lateRobotPose = self.getRobotPose(timestampCapture)
+            lateCameraPose = lateRobotPose + self.getRobotToCamera(
+                camSim, timestampCapture
+            )
+            cameraPoses2d.append(lateCameraPose.toPose2d())
+
+            camResult = camSim.process(latency, lateCameraPose, allTargets)
+            camSim.submitProcessedFrame(camResult, timestampNt)
+            for target in camResult.getTargets():
+                trf = target.getBestCameraToTarget()
+                if trf == Transform3d():
+                    continue
+
+                visTgtPoses2d.append(lateCameraPose.transformBy(trf).toPose2d())
+
+        if processed:
+            self.dbgField.getObject("visibleTargetPoses").setPoses(visTgtPoses2d)
+
+        if len(cameraPoses2d) != 0:
+            self.dbgField.getObject("cameras").setPoses(cameraPoses2d)

photonlibpy/simulation/visionTargetSim.py

@@ -0,0 +1,50 @@
+import math
+
+from wpimath.geometry import Pose3d, Translation3d
+
+from ..estimation.targetModel import TargetModel
+
+
+class VisionTargetSim:
+    def __init__(self, pose: Pose3d, model: TargetModel, id: int = -1):
+        self.pose: Pose3d = pose
+        self.model: TargetModel = model
+        self.fiducialId: int = id
+        self.objDetClassId: int = -1
+        self.objDetConf: float = -1.0
+
+    def __lt__(self, right) -> bool:
+        return self.pose.translation().norm() < right.pose.translation().norm()
+
+    def __eq__(self, other) -> bool:
+        # Use 1 inch and 1 degree tolerance
+        return (
+            abs(self.pose.translation().X() - other.getPose().translation().X())
+            < 0.0254
+            and abs(self.pose.translation().Y() - other.getPose().translation().Y())
+            < 0.0254
+            and abs(self.pose.translation().Z() - other.getPose().translation().Z())
+            < 0.0254
+            and abs(self.pose.rotation().X() - other.getPose().rotation().X())
+            < math.radians(1)
+            and abs(self.pose.rotation().Y() - other.getPose().rotation().Y())
+            < math.radians(1)
+            and abs(self.pose.rotation().Z() - other.getPose().rotation().Z())
+            < math.radians(1)
+            and self.model.getIsPlanar() == other.getModel().getIsPlanar()
+        )
+
+    def setPose(self, newPose: Pose3d) -> None:
+        self.pose = newPose
+
+    def setModel(self, newModel: TargetModel) -> None:
+        self.model = newModel
+
+    def getPose(self) -> Pose3d:
+        return self.pose
+
+    def getModel(self) -> TargetModel:
+        return self.model
+
+    def getFieldVertices(self) -> list[Translation3d]:
+        return self.model.getFieldVertices(self.pose)

photonlibpy/targeting/TargetCorner.py

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

photonlibpy/targeting/__init__.py

@@ -1,6 +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
+from .TargetCorner import TargetCorner  # noqa

photonlibpy/targeting/multiTargetPNPResult.py

@@ -1,17 +1,23 @@
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, ClassVar
+
 from wpimath.geometry import Transform3d
+
 from ..packet import Packet
 
+if TYPE_CHECKING:
+    from .. import generated
+
 
 @dataclass
 class PnpResult:
     best: Transform3d = field(default_factory=Transform3d)
     alt: Transform3d = field(default_factory=Transform3d)
     ambiguity: float = 0.0
-    bestReprojError: float = 0.0
-    altReprojError: float = 0.0
+    bestReprojErr: float = 0.0
+    altReprojErr: float = 0.0
 
-    photonStruct: "PNPResultSerde" = None
+    photonStruct: ClassVar["generated.PnpResultSerde"]
 
 
 @dataclass
@@ -31,4 +37,4 @@ class MultiTargetPNPResult:
                 self.fiducialIDsUsed.append(fidId)
         return packet
 
-    photonStruct: "MultiTargetPNPResultSerde" = None
+    photonStruct: ClassVar["generated.MultiTargetPNPResultSerde"]

photonlibpy/targeting/photonPipelineResult.py

@@ -1,9 +1,12 @@
 from dataclasses import dataclass, field
-from typing import Optional
+from typing import TYPE_CHECKING, ClassVar, Optional
 
 from .multiTargetPNPResult import MultiTargetPNPResult
 from .photonTrackedTarget import PhotonTrackedTarget
 
+if TYPE_CHECKING:
+    from .. import generated
+
 
 @dataclass
 class PhotonPipelineMetadata:
@@ -15,7 +18,9 @@ class PhotonPipelineMetadata:
     # Mirror of the heartbeat entry -- monotonically increasing
     sequenceID: int = -1
 
-    photonStruct: "PhotonPipelineMetadataSerde" = None
+    timeSinceLastPong: int = -1
+
+    photonStruct: ClassVar["generated.PhotonPipelineMetadataSerde"]
 
 
 @dataclass
@@ -24,8 +29,10 @@ class PhotonPipelineResult:
     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
+    multitagResult: Optional[MultiTargetPNPResult] = None
 
     def getLatencyMillis(self) -> float:
         return (
@@ -53,7 +60,7 @@ class PhotonPipelineResult:
     def hasTargets(self) -> bool:
         return len(self.targets) > 0
 
-    def getBestTarget(self) -> PhotonTrackedTarget:
+    def getBestTarget(self) -> Optional[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.
@@ -62,4 +69,4 @@ class PhotonPipelineResult:
             return None
         return self.getTargets()[0]
 
-    photonStruct: "PhotonPipelineResultSerde" = None
+    photonStruct: ClassVar["generated.PhotonPipelineResultSerde"]

photonlibpy/targeting/photonTrackedTarget.py

@@ -1,8 +1,14 @@
 from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, ClassVar
+
 from wpimath.geometry import Transform3d
+
 from ..packet import Packet
 from .TargetCorner import TargetCorner
 
+if TYPE_CHECKING:
+    from .. import generated
+
 
 @dataclass
 class PhotonTrackedTarget:
@@ -13,9 +19,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
@@ -35,10 +43,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:
@@ -55,4 +63,4 @@ class PhotonTrackedTarget:
             retList.append(TargetCorner(cx, cy))
         return retList
 
-    photonStruct: "PhotonTrackedTargetSerde" = None
+    photonStruct: ClassVar["generated.PhotonTrackedTargetSerde"]

photonlibpy/version.py

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

{photonlibpy-2025.0.0a0.dist-info → photonlibpy-2025.0.0b2.dist-info}/METADATA

@@ -1,13 +1,17 @@
 Metadata-Version: 2.1
 Name: photonlibpy
-Version: 2025.0.0a0
-Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-alpha-0 .
+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 .
 Home-page: https://photonvision.org
 Author: Photonvision Development Team
 Description-Content-Type: text/markdown
+Requires-Dist: numpy~=1.25
 Requires-Dist: wpilib<2025,>=2024.0.0b2
 Requires-Dist: robotpy-wpimath<2025,>=2024.0.0b2
 Requires-Dist: robotpy-apriltag<2025,>=2024.0.0b2
+Requires-Dist: robotpy-cscore<2025,>=2024.0.0.b2
 Requires-Dist: pyntcore<2025,>=2024.0.0b2
+Requires-Dist: opencv-python; platform_machine != "roborio"
+Requires-Dist: robotpy-opencv; platform_machine == "roborio"
 
 A Pure-python implementation of PhotonLib

photonlibpy-2025.0.0b2.dist-info/RECORD

@@ -0,0 +1,36 @@
+photonlibpy/__init__.py,sha256=WW1OGrrcNXwwxaHSZlkxmhH2GYiQIHHxSxGVTJZhZbY,1136
+photonlibpy/estimatedRobotPose.py,sha256=X7wF9xdPXGKSVy0MY0qrWZJOEbuZPd721lYp0KXKlP0,1603
+photonlibpy/packet.py,sha256=5YomViVFwOljL2FGOetWM9FbPc_yCQ15ylzkYlgLIs8,9724
+photonlibpy/photonCamera.py,sha256=wz55_9XoKzGX6UQ-2Oa3kjrz9KM6R7-wExiaUPkUeto,10176
+photonlibpy/photonPoseEstimator.py,sha256=2iMqxPFsQHTsq95yv-WCSv1a6wXNcHPqOyMc4Bu6IG0,12584
+photonlibpy/version.py,sha256=gk9q-HkZ3pUpfERPbTZbPNGvNy0gR9d01A_Db5oMkZ4,77
+photonlibpy/estimation/__init__.py,sha256=pZ-d6fN1DJvT-lRl4FfIos5HAvlzmetIOrGIinrdv7k,223
+photonlibpy/estimation/cameraTargetRelation.py,sha256=i7DPBXtkZve4ToXQscEIe-5F1oGQ1Qmf5QBaE__EeMQ,1158
+photonlibpy/estimation/openCVHelp.py,sha256=ThJDVuJ_QFteuuSeo7wQHoE4YzPQOx60_bmFRnILS1Y,6544
+photonlibpy/estimation/rotTrlTransform3d.py,sha256=nX60k9rgei7bkLRR3Ykl2lhnjpsiSNuImk6fERFcy2w,915
+photonlibpy/estimation/targetModel.py,sha256=e5IaDKFdNtek6pJLrzw2poit5wxvraIRtHPDmN-rqUk,4416
+photonlibpy/estimation/visionEstimation.py,sha256=jCOBHHOjhzjNOD-_kn-jpTOXqlGxek24oKL51GiRSKU,2999
+photonlibpy/generated/MultiTargetPNPResultSerde.py,sha256=WoCdln8kkciBltG-YdFn5OjdLGMD3VwwHymfe95QF4s,2342
+photonlibpy/generated/PhotonPipelineMetadataSerde.py,sha256=0beAVUFeQ1Shq5ku4q5IgE-sYkMzk3XoemRnC5Vx8Hg,2767
+photonlibpy/generated/PhotonPipelineResultSerde.py,sha256=q2w8ei-8X1ZJgHnYsTfX7NHTybUboP-DqQkdGY5bj1M,2847
+photonlibpy/generated/PhotonTrackedTargetSerde.py,sha256=TT18q7jb2WzcPDOf26NOo1l23W9gY80CyrNYUBXbHYs,4271
+photonlibpy/generated/PnpResultSerde.py,sha256=FVvv34GzQ856uGobpRSUO8TbV-h7IVipkTqgqfRa35Y,2586
+photonlibpy/generated/TargetCornerSerde.py,sha256=rUJUBfs02gTWgkHvSjuaGLQdSzZcfpRRcSLDlFo8-_E,2080
+photonlibpy/generated/__init__.py,sha256=mElM8M88---wxTWO-SRqIJ4EfxN0fdIUwZBZ-UIGuRw,428
+photonlibpy/networktables/NTTopicSet.py,sha256=9jagxRAxO6nN7LvHZti86qA9V_d9_FStoDz5C3siM7Y,2545
+photonlibpy/networktables/__init__.py,sha256=o_LxTdyIylAszMy_zhUtTkXHyu6jqxccccj78d44OrI,35
+photonlibpy/simulation/__init__.py,sha256=HKJV02of5d8bOnuI7syLzSYtOYge7XUrHSaLvawh99M,227
+photonlibpy/simulation/photonCameraSim.py,sha256=xul2eXUe1XgJ-RWALG6cgU4zDPcDOvHHvjFjAASS188,14706
+photonlibpy/simulation/simCameraProperties.py,sha256=LAmxwm9FSyx-CTsVO-TRhfn4Pz5oanJV0Jh7KUnCNgM,20557
+photonlibpy/simulation/videoSimUtil.py,sha256=xMuTvJ2Jx9IoQqmAJi_zUm06MdEwhVpIz9OyzYQp0k4,29
+photonlibpy/simulation/visionSystemSim.py,sha256=q4ifF4q_XkCJ9jIkHBX6lYY6INc-uvFBi4c2OLQR3WA,8615
+photonlibpy/simulation/visionTargetSim.py,sha256=AN7jXW3guQfNUu2EiQl23Jj8Mkgn4gYmRphGXL0-Dqk,1734
+photonlibpy/targeting/TargetCorner.py,sha256=5a7RdK_WLCgui7BVE3KnHmb3jHbXeM5_SfFSDbnmd0M,251
+photonlibpy/targeting/__init__.py,sha256=YzINSpq6A0cjr-yAQcFqHoiYdLGKPFXThlVYlMjY11w,295
+photonlibpy/targeting/multiTargetPNPResult.py,sha256=zcUF1rIAgovURXu9saiLHIjuspSpRn3r7-J6tB_YlU4,1125
+photonlibpy/targeting/photonPipelineResult.py,sha256=Sy_KBvI0ps1pQOJ80XYHTrz50aqUDBcuvIC_b1ku3G4,2617
+photonlibpy/targeting/photonTrackedTarget.py,sha256=m6y-dBqP8iVt5J0WcGDxYpmgctVy6SNL358ZY1YgjCc,1917
+photonlibpy-2025.0.0b2.dist-info/METADATA,sha256=EdH_l3RSbxbU8Z2s7SIBpIwca7DCOPRaOwVuniX1fro,752
+photonlibpy-2025.0.0b2.dist-info/WHEEL,sha256=bFJAMchF8aTQGUgMZzHJyDDMPTO3ToJ7x23SLJa1SVo,92
+photonlibpy-2025.0.0b2.dist-info/top_level.txt,sha256=T8Xc6U6he2VjKUAca6zawSkHdUZuLanxYIc4nxw2ctc,12
+photonlibpy-2025.0.0b2.dist-info/RECORD,,

{photonlibpy-2025.0.0a0.dist-info → photonlibpy-2025.0.0b2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.44.0)
+Generator: bdist_wheel (0.45.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

photonlibpy-2025.0.0a0.dist-info/RECORD

@@ -1,22 +0,0 @@
-photonlibpy/__init__.py,sha256=JnwWj53fEM263hUjEFGmJ--M3XCX0LYovdrl4wcNRnU,1136
-photonlibpy/estimatedRobotPose.py,sha256=X7wF9xdPXGKSVy0MY0qrWZJOEbuZPd721lYp0KXKlP0,1603
-photonlibpy/packet.py,sha256=gcikxwQZLoNGHuzNpAmnXjyLty-8w8HIVR3gGl4QPX4,6024
-photonlibpy/photonCamera.py,sha256=nc80dRGm_4OT_EcJo9zmmCaiDY3FMmAgYoYDrTCKEfk,10187
-photonlibpy/photonPoseEstimator.py,sha256=cgTW2Ja9cJK08bIKd-zW0l1V8mLL5NM_unaIOgEsedk,12596
-photonlibpy/version.py,sha256=Fg2UjgOnC98Q0vrMlyrceRwAyQMW9fCGWswIYeblBQY,79
-photonlibpy/generated/MultiTargetPNPResultSerde.py,sha256=vtcg17D83gVtXJBCAez8xFmxdENV020QcY4gfYZOBd4,1957
-photonlibpy/generated/PhotonPipelineMetadataSerde.py,sha256=eXLgqVQfaK7nPLeu832Z2RsH3BfffGPDCXvw0DCvjTw,2081
-photonlibpy/generated/PhotonPipelineResultSerde.py,sha256=jPq9C1895UO1fbipuO9V6TPrFZ5IOVbTNzctnlTjRBQ,2261
-photonlibpy/generated/PhotonTrackedTargetSerde.py,sha256=v_VFmq8h6KIarAdmqsV1DLClF3mQUVJzRbk-DLDwjU4,3070
-photonlibpy/generated/PnpResultSerde.py,sha256=LqQ2-25ac8o8BoV24UL0gkG4cQ6KrZNbajNZngYjSI4,2080
-photonlibpy/generated/TargetCornerSerde.py,sha256=ehkIitRVneMppqnEn3XPn_giUNH-czT3O_YID5fxdos,1790
-photonlibpy/generated/__init__.py,sha256=WdCA9k7QNY1i8B9u5kBilnibajDBg7zfU8GbV7F2H8g,505
-photonlibpy/targeting/TargetCorner.py,sha256=iFWTWu5HcpkBQyvhz_klpAB0TEmy-7_SsD1FHeNfnkE,147
-photonlibpy/targeting/__init__.py,sha256=1GUy4MC8NbZ-TEcFgsnvSm_X0LYeZ0HZagMMRmGpx8A,295
-photonlibpy/targeting/multiTargetPNPResult.py,sha256=CZ7jULJV1VpTK5mxLvMVKHkBMKdTk9X428cNChzizAY,1010
-photonlibpy/targeting/photonPipelineResult.py,sha256=t3fHHEb6YgucJyTajCi3-SIG9FSQGQ4sUQLadFfhIks,2316
-photonlibpy/targeting/photonTrackedTarget.py,sha256=B1kMfx6Re0VF_RsMZ7H0ZyxaGy4PR4XITiaCbe0ViZ0,1708
-photonlibpy-2025.0.0a0.dist-info/METADATA,sha256=zZc6rK9qOYvIQGeXfoCx6qorsNoMaYn2YKdcBMrib48,556
-photonlibpy-2025.0.0a0.dist-info/WHEEL,sha256=eOLhNAGa2EW3wWl_TU484h7q1UNgy0JXjjoqKoxAAQc,92
-photonlibpy-2025.0.0a0.dist-info/top_level.txt,sha256=T8Xc6U6he2VjKUAca6zawSkHdUZuLanxYIc4nxw2ctc,12
-photonlibpy-2025.0.0a0.dist-info/RECORD,,