photonlibpy 2025.0.0b8__py3-none-any.whl → 2026.1.1__py3-none-any.whl

photonlibpy/__init__.py

@@ -1,21 +1,35 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
-from .estimatedRobotPose import EstimatedRobotPose  # noqa
-from .packet import Packet  # noqa
-from .photonCamera import PhotonCamera  # noqa
-from .photonPoseEstimator import PhotonPoseEstimator, PoseStrategy  # noqa
+from .estimatedRobotPose import EstimatedRobotPose
+from .packet import Packet
+from .photonCamera import PhotonCamera
+from .photonPoseEstimator import PhotonPoseEstimator
+
+__all__ = (
+    "EstimatedRobotPose",
+    "Packet",
+    "PhotonCamera",
+    "PhotonPoseEstimator",
+)

photonlibpy/estimatedRobotPose.py

@@ -16,15 +16,11 @@
 ###############################################################################
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING
 
 from wpimath.geometry import Pose3d
 
 from .targeting.photonTrackedTarget import PhotonTrackedTarget
 
-if TYPE_CHECKING:
-    from .photonPoseEstimator import PoseStrategy
-
 
 @dataclass
 class EstimatedRobotPose:
@@ -38,6 +34,3 @@ class EstimatedRobotPose:
 
     targetsUsed: list[PhotonTrackedTarget]
     """A list of the targets used to compute this pose"""
-
-    strategy: "PoseStrategy"
-    """The strategy actually used to produce this pose"""

photonlibpy/generated/MultiTargetPNPResultSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/generated/PhotonPipelineMetadataSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/generated/PhotonPipelineResultSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/generated/PhotonTrackedTargetSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/generated/PnpResultSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/generated/TargetCornerSerde.py

@@ -1,19 +1,26 @@
-###############################################################################
-## 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/>.
-###############################################################################
+#
+# MIT License
+#
+# Copyright (c) PhotonVision
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
 
 ###############################################################################
 ## THIS FILE WAS AUTO-GENERATED BY ./photon-serde/generate_messages.py.

photonlibpy/networktables/NTTopicSet.py

@@ -47,6 +47,13 @@ class NTTopicSet:
 
         self.driverModeSubscriber.getTopic().publish().setDefault(False)
 
+        self.fpsLimitPublisher = self.subTable.getIntegerTopic("fpsLimit").publish()
+        self.fpsLimitSubscriber = self.subTable.getIntegerTopic(
+            "fpsLimitRequest"
+        ).subscribe(-1)
+
+        self.fpsLimitSubscriber.getTopic().publish().setDefault(-1)
+
         self.latencyMillisEntry = self.subTable.getDoubleTopic(
             "latencyMillis"
         ).publish()

photonlibpy/photonCamera.py

@@ -18,6 +18,7 @@
 from enum import Enum
 from typing import List
 
+import hal
 import ntcore
 
 # magical import to make serde stuff work
@@ -27,6 +28,7 @@ from wpilib import RobotController, Timer
 
 from .packet import Packet
 from .targeting.photonPipelineResult import PhotonPipelineResult
+from .timesync.timeSyncServer import inst
 from .version import PHOTONLIB_VERSION  # type: ignore[import-untyped]
 
 
@@ -47,6 +49,8 @@ def setVersionCheckEnabled(enabled: bool):
 
 
 class PhotonCamera:
+    instance_count = 1
+
     def __init__(self, cameraName: str):
         """Constructs a PhotonCamera from the name of the camera.
 
@@ -70,6 +74,12 @@ class PhotonCamera:
         self._driverModeSubscriber = self._cameraTable.getBooleanTopic(
             "driverMode"
         ).subscribe(False)
+        self._fpsLimitPublisher = self._cameraTable.getIntegerTopic(
+            "fpsLimitRequest"
+        ).publish()
+        self._fpsLimitSubscriber = self._cameraTable.getIntegerTopic(
+            "fpsLimit"
+        ).subscribe(-1)
         self._inputSaveImgEntry = self._cameraTable.getIntegerTopic(
             "inputSaveImgCmd"
         ).getEntry(0)
@@ -104,6 +114,16 @@ class PhotonCamera:
         self._prevHeartbeat = 0
         self._prevHeartbeatChangeTime = Timer.getFPGATimestamp()
 
+        # Start the time sync server
+        inst.start()
+
+        # Usage reporting
+        hal.report(
+            hal.tResourceType.kResourceType_PhotonCamera.value,
+            PhotonCamera.instance_count,
+        )
+        PhotonCamera.instance_count += 1
+
     def getAllUnreadResults(self) -> List[PhotonPipelineResult]:
         """
         The list of pipeline results sent by PhotonVision since the last call to getAllUnreadResults().
@@ -176,6 +196,22 @@ class PhotonCamera:
 
         self._driverModePublisher.set(driverMode)
 
+    def getFPSLimit(self) -> int:
+        """Returns the current FPS limit set on the camera.
+
+        :returns: The current FPS limit.
+        """
+
+        return self._fpsLimitSubscriber.get()
+
+    def setFPSLimit(self, fpsLimit: int) -> None:
+        """Sets the FPS limit on the camera.
+
+        :param fpsLimit: The FPS limit to set. Set to -1 for unlimited FPS.
+        """
+
+        self._fpsLimitPublisher.set(fpsLimit)
+
     def takeInputSnapshot(self) -> None:
         """Request the camera to save a new image file from the input camera stream with overlays. Images
         take up space in the filesystem of the PhotonCamera. Calling it frequently will fill up disk

photonlibpy/photonPoseEstimator.py

@@ -15,52 +15,30 @@
 ## along with this program.  If not, see <https://www.gnu.org/licenses/>.
 ###############################################################################
 
-import enum
 from typing import Optional
 
+import hal
 import wpilib
+import wpimath.units
 from robotpy_apriltag import AprilTagFieldLayout
-from wpimath.geometry import Pose2d, Pose3d, Transform3d
+from wpimath.geometry import (
+    Pose2d,
+    Pose3d,
+    Rotation2d,
+    Rotation3d,
+    Transform3d,
+    Translation2d,
+    Translation3d,
+)
+from wpimath.interpolation import TimeInterpolatableRotation2dBuffer
 
 from .estimatedRobotPose import EstimatedRobotPose
-from .photonCamera import PhotonCamera
 from .targeting.photonPipelineResult import PhotonPipelineResult
 
 
-class PoseStrategy(enum.Enum):
-    """
-    Position estimation strategies that can be used by the PhotonPoseEstimator class.
-    """
-
-    LOWEST_AMBIGUITY = enum.auto()
-    """Choose the Pose with the lowest ambiguity."""
-
-    CLOSEST_TO_CAMERA_HEIGHT = enum.auto()
-    """Choose the Pose which is closest to the camera height."""
-
-    CLOSEST_TO_REFERENCE_POSE = enum.auto()
-    """Choose the Pose which is closest to a set Reference position."""
-
-    CLOSEST_TO_LAST_POSE = enum.auto()
-    """Choose the Pose which is closest to the last pose calculated."""
-
-    AVERAGE_BEST_TARGETS = enum.auto()
-    """Return the average of the best target poses using ambiguity as weight."""
-
-    MULTI_TAG_PNP_ON_COPROCESSOR = enum.auto()
-    """
-    Use all visible tags to compute a single pose estimate on coprocessor.
-    This option needs to be enabled on the PhotonVision web UI as well.
-    """
-
-    MULTI_TAG_PNP_ON_RIO = enum.auto()
-    """
-    Use all visible tags to compute a single pose estimate.
-    This runs on the RoboRIO, and can take a lot of time.
-    """
-
-
 class PhotonPoseEstimator:
+    instance_count = 1
+
     """
     The PhotonPoseEstimator class filters or combines readings from all the AprilTags visible at a
     given timestamp on the field to produce a single robot in field pose, using the strategy set
@@ -70,8 +48,6 @@ class PhotonPoseEstimator:
     def __init__(
         self,
         fieldTags: AprilTagFieldLayout,
-        strategy: PoseStrategy,
-        camera: PhotonCamera,
         robotToCamera: Transform3d,
     ):
         """Create a new PhotonPoseEstimator.
@@ -80,23 +56,21 @@ class PhotonPoseEstimator:
                            with respect to the FIRST field using the Field Coordinate System.
                            Note that setting the origin of this layout object will affect the
                            results from this class.
-        :param strategy: The strategy it should use to determine the best pose.
-        :param camera: PhotonCamera
         :param robotToCamera: Transform3d from the center of the robot to the camera mount position (i.e.,
                                 robot ➔ camera) in the Robot Coordinate System.
         """
         self._fieldTags = fieldTags
-        self._primaryStrategy = strategy
-        self._camera = camera
         self.robotToCamera = robotToCamera
 
-        self._multiTagFallbackStrategy = PoseStrategy.LOWEST_AMBIGUITY
         self._reportedErrors: set[int] = set()
-        self._poseCacheTimestampSeconds = -1.0
-        self._lastPose: Optional[Pose3d] = None
-        self._referencePose: Optional[Pose3d] = None
+        self._headingBuffer = TimeInterpolatableRotation2dBuffer(1)
 
-        # TODO: Implement HAL reporting
+        # Usage reporting
+        hal.report(
+            hal.tResourceType.kResourceType_PhotonPoseEstimator.value,
+            PhotonPoseEstimator.instance_count,
+        )
+        PhotonPoseEstimator.instance_count += 1
 
     @property
     def fieldTags(self) -> AprilTagFieldLayout:
@@ -116,160 +90,120 @@ class PhotonPoseEstimator:
 
         :param fieldTags: the AprilTagFieldLayout
         """
-        self._checkUpdate(self._fieldTags, fieldTags)
         self._fieldTags = fieldTags
 
-    @property
-    def primaryStrategy(self) -> PoseStrategy:
-        """Get the Position Estimation Strategy being used by the Position Estimator.
-
-        :returns: the strategy
+    def addHeadingData(
+        self, timestampSeconds: wpimath.units.seconds, heading: Rotation2d | Rotation3d
+    ) -> None:
         """
-        return self._primaryStrategy
-
-    @primaryStrategy.setter
-    def primaryStrategy(self, strategy: PoseStrategy):
-        """Set the Position Estimation Strategy used by the Position Estimator.
+        Add robot heading data to buffer. Must be called periodically for the **PNP_DISTANCE_TRIG_SOLVE** strategy.
 
-        :param strategy: the strategy to set
+        :param timestampSeconds :timestamp of the robot heading data
+        :param heading: field-relative robot heading at given timestamp
         """
-        self._checkUpdate(self._primaryStrategy, strategy)
-        self._primaryStrategy = strategy
+        if isinstance(heading, Rotation3d):
+            heading = heading.toRotation2d()
+        self._headingBuffer.addSample(timestampSeconds, heading)
 
-    @property
-    def multiTagFallbackStrategy(self) -> PoseStrategy:
-        return self._multiTagFallbackStrategy
-
-    @multiTagFallbackStrategy.setter
-    def multiTagFallbackStrategy(self, strategy: PoseStrategy):
-        """Set the Position Estimation Strategy used in multi-tag mode when only one tag can be seen. Must
-        NOT be MULTI_TAG_PNP
-
-        :param strategy: the strategy to set
+    def resetHeadingData(
+        self, timestampSeconds: wpimath.units.seconds, heading: Rotation2d | Rotation3d
+    ) -> None:
         """
-        self._checkUpdate(self._multiTagFallbackStrategy, strategy)
-        if (
-            strategy is PoseStrategy.MULTI_TAG_PNP_ON_COPROCESSOR
-            or strategy is PoseStrategy.MULTI_TAG_PNP_ON_RIO
-        ):
-            wpilib.reportWarning(
-                "Fallback cannot be set to MULTI_TAG_PNP! Setting to lowest ambiguity",
-                False,
-            )
-            strategy = PoseStrategy.LOWEST_AMBIGUITY
-        self._multiTagFallbackStrategy = strategy
+        Clears all heading data in the buffer, and adds a new seed. Useful for preventing estimates
+        from utilizing heading data provided prior to a pose or rotation reset.
 
-    @property
-    def referencePose(self) -> Optional[Pose3d]:
-        """Return the reference position that is being used by the estimator.
-
-        :returns: the referencePose
+        :param timestampSeconds: timestamp of the robot heading data
+        :param  heading: field-relative robot heading at given timestamp
         """
-        return self._referencePose
-
-    @referencePose.setter
-    def referencePose(self, referencePose: Pose3d | Pose2d):
-        """Update the stored reference pose for use when using the **CLOSEST_TO_REFERENCE_POSE**
-        strategy.
+        self._headingBuffer.clear()
+        self.addHeadingData(timestampSeconds, heading)
 
-        :param referencePose: the referencePose to set
+    def _shouldEstimate(self, cameraResult: PhotonPipelineResult) -> bool:
         """
-        if isinstance(referencePose, Pose2d):
-            referencePose = Pose3d(referencePose)
-        self._checkUpdate(self._referencePose, referencePose)
-        self._referencePose = referencePose
+        :param cameraResult: A pipeline result from the camera.
 
-    @property
-    def lastPose(self) -> Optional[Pose3d]:
-        return self._lastPose
-
-    @lastPose.setter
-    def lastPose(self, lastPose: Pose3d | Pose2d):
-        """Update the stored last pose. Useful for setting the initial estimate when using the
-        **CLOSEST_TO_LAST_POSE** strategy.
-
-        :param lastPose: the lastPose to set
+        :returns: Whether or not estimation should be done.
         """
-        if isinstance(lastPose, Pose2d):
-            lastPose = Pose3d(lastPose)
-        self._checkUpdate(self._lastPose, lastPose)
-        self._lastPose = lastPose
-
-    def _invalidatePoseCache(self) -> None:
-        self._poseCacheTimestampSeconds = -1.0
+        if cameraResult.getTimestampSeconds() < 0:
+            return False
 
-    def _checkUpdate(self, oldObj, newObj) -> None:
-        if oldObj != newObj and oldObj is not None and oldObj is not newObj:
-            self._invalidatePoseCache()
+        # If no targets seen, trivial case -- can't do estimation
+        return len(cameraResult.targets) > 0
 
-    def update(
-        self, cameraResult: Optional[PhotonPipelineResult] = None
+    def estimatePnpDistanceTrigSolvePose(
+        self, result: PhotonPipelineResult
     ) -> Optional[EstimatedRobotPose]:
         """
-        Updates the estimated position of the robot. Returns empty if:
 
-         - The timestamp of the provided pipeline result is the same as in the previous call to
-         ``update()``.
+        Return the estimated position of the robot by using distance data from best visible tag to
+        compute a Pose. This runs on the RoboRIO in order to access the robot's yaw heading, and MUST
+        have addHeadingData called every frame so heading data is up-to-date.
 
-         - No targets were found in the pipeline results.
+        Yields a Pose2d in estimatedRobotPose (0 for z, roll, pitch)
 
-        :param cameraResult: The latest pipeline result from the camera
+        https://www.chiefdelphi.com/t/frc-6328-mechanical-advantage-2025-build-thread/477314/98
 
-        :returns: an :class:`EstimatedRobotPose` with an estimated pose, timestamp, and targets used to
-                   create the estimate.
-        """
-        if not cameraResult:
-            if not self._camera:
-                wpilib.reportError("[PhotonPoseEstimator] Missing camera!", False)
-                return None
-            cameraResult = self._camera.getLatestResult()
 
-        if cameraResult.getTimestampSeconds() < 0:
-            return None
-
-        # If the pose cache timestamp was set, and the result is from the same
-        # timestamp, return an
-        # empty result
+        :param result: A pipeline result from the camera.
+        :returns: An :class:`EstimatedRobotPose` with an estimated pose, timestamp, and targets used
+          to create the estimate.
+        """
         if (
-            self._poseCacheTimestampSeconds > 0.0
-            and abs(
-                self._poseCacheTimestampSeconds - cameraResult.getTimestampSeconds()
-            )
-            < 1e-6
+            not self._shouldEstimate(result)
+            or (bestTarget := result.getBestTarget()) is None
         ):
             return None
 
-        # Remember the timestamp of the current result used
-        self._poseCacheTimestampSeconds = cameraResult.getTimestampSeconds()
-
-        # If no targets seen, trivial case -- return empty result
-        if not cameraResult.targets:
+        if (
+            headingSample := self._headingBuffer.sample(result.getTimestampSeconds())
+        ) is None:
             return None
 
-        return self._update(cameraResult, self._primaryStrategy)
+        if (tagPose := self._fieldTags.getTagPose(bestTarget.fiducialId)) is None:
+            return None
 
-    def _update(
-        self, cameraResult: PhotonPipelineResult, strat: PoseStrategy
-    ) -> Optional[EstimatedRobotPose]:
-        if strat is PoseStrategy.LOWEST_AMBIGUITY:
-            estimatedPose = self._lowestAmbiguityStrategy(cameraResult)
-        elif strat is PoseStrategy.MULTI_TAG_PNP_ON_COPROCESSOR:
-            estimatedPose = self._multiTagOnCoprocStrategy(cameraResult)
-        else:
-            wpilib.reportError(
-                "[PhotonPoseEstimator] Unknown Position Estimation Strategy!", False
+        camToTagTranslation = (
+            Translation3d(
+                bestTarget.getBestCameraToTarget().translation().norm(),
+                Rotation3d(
+                    0,
+                    -wpimath.units.degreesToRadians(bestTarget.getPitch()),
+                    -wpimath.units.degreesToRadians(bestTarget.getYaw()),
+                ),
             )
-            return None
+            .rotateBy(self.robotToCamera.rotation())
+            .toTranslation2d()
+            .rotateBy(headingSample)
+        )
 
-        if not estimatedPose:
-            self._lastPose = None
+        fieldToCameraTranslation = (
+            tagPose.toPose2d().translation() - camToTagTranslation
+        )
+        camToRobotTranslation: Translation2d = -(
+            self.robotToCamera.translation().toTranslation2d()
+        )
+        camToRobotTranslation = camToRobotTranslation.rotateBy(headingSample)
+        robotPose = Pose2d(
+            fieldToCameraTranslation + camToRobotTranslation, headingSample
+        )
 
-        return estimatedPose
+        return EstimatedRobotPose(
+            Pose3d(robotPose), result.getTimestampSeconds(), result.getTargets()
+        )
 
-    def _multiTagOnCoprocStrategy(
+    def estimateCoprocMultiTagPose(
         self, result: PhotonPipelineResult
     ) -> Optional[EstimatedRobotPose]:
-        if result.multitagResult is not None:
+        """
+        Return the estimated position of the robot by using all visible tags to compute a single
+        pose estimate on coprocessor. This option needs to be enabled on the PhotonVision web UI as
+        well.
+
+        :param result: A pipeline result from the camera.
+        :returns: An :class:`EstimatedRobotPose` with an estimated pose, timestamp, and targets used
+          to create the estimate.
+        """
+        if result.multitagResult is not None and self._shouldEstimate(result):
             best_tf = result.multitagResult.estimatedPose.best
             best = (
                 Pose3d()
@@ -281,23 +215,22 @@ class PhotonPoseEstimator:
                 best,
                 result.getTimestampSeconds(),
                 result.targets,
-                PoseStrategy.MULTI_TAG_PNP_ON_COPROCESSOR,
             )
         else:
-            return self._update(result, self._multiTagFallbackStrategy)
+            return None
 
-    def _lowestAmbiguityStrategy(
+    def estimateLowestAmbiguityPose(
         self, result: PhotonPipelineResult
     ) -> Optional[EstimatedRobotPose]:
         """
-        Return the estimated position of the robot with the lowest position ambiguity from a List of
-        pipeline results.
-
-        :param result: pipeline result
+        Return the estimated position of the robot with the lowest position ambiguity from a pipeline results.
 
-        :returns: the estimated position of the robot in the FCS and the estimated timestamp of this
-                  estimation.
+        :param result: A pipeline result from the camera.
+        :returns: An :class:`EstimatedRobotPose` with an estimated pose, timestamp, and targets used
+          to create the estimate.
         """
+        if not self._shouldEstimate(result):
+            return None
         lowestAmbiguityTarget = None
 
         lowestAmbiguityScore = 10.0
@@ -328,7 +261,6 @@ class PhotonPoseEstimator:
             ).transformBy(self.robotToCamera.inverse()),
             result.getTimestampSeconds(),
             result.targets,
-            PoseStrategy.LOWEST_AMBIGUITY,
         )
 
     def _reportFiducialPoseError(self, fiducialId: int) -> None:

photonlibpy/py.typed

@@ -1 +0,0 @@
-

photonlibpy/simulation/__init__.py

@@ -3,3 +3,11 @@ from .simCameraProperties import SimCameraProperties
 from .videoSimUtil import VideoSimUtil
 from .visionSystemSim import VisionSystemSim
 from .visionTargetSim import VisionTargetSim
+
+__all__ = (
+    "PhotonCameraSim",
+    "SimCameraProperties",
+    "VideoSimUtil",
+    "VisionSystemSim",
+    "VisionTargetSim",
+)

photonlibpy/simulation/photonCameraSim.py

@@ -36,6 +36,9 @@ class PhotonCameraSim:
         self,
         camera: PhotonCamera,
         props: SimCameraProperties = SimCameraProperties.PERFECT_90DEG(),
+        tagLayout: AprilTagFieldLayout = AprilTagFieldLayout.loadField(
+            AprilTagField.kDefaultField
+        ),
         minTargetAreaPercent: float | None = None,
         maxSightRange: meters | None = None,
     ):
@@ -48,7 +51,7 @@ class PhotonCameraSim:
 
         :param camera:               The camera to be simulated
         :param prop:                 Properties of this camera such as FOV and FPS
-        :param minTargetAreaPercent: The minimum percentage(0 - 100) a detected target must take up of
+        :param minTargetAreaPercent: The minimum percentage (0 - 100) a detected target must take up of
                                      the camera's image to be processed. Match this with your contour filtering settings in the
                                      PhotonVision GUI.
         :param maxSightRangeMeters:  Maximum distance at which the target is illuminated to your camera.
@@ -64,7 +67,7 @@ class PhotonCameraSim:
         self.videoSimProcEnabled: bool = False
         self.heartbeatCounter: int = 0
         self.nextNtEntryTime = wpilib.Timer.getFPGATimestamp()
-        self.tagLayout = AprilTagFieldLayout.loadField(AprilTagField.k2024Crescendo)
+        self.tagLayout = tagLayout
 
         self.cam = camera
         self.prop = props
@@ -203,7 +206,7 @@ class PhotonCameraSim:
         return None
 
     def setMinTargetAreaPercent(self, areaPercent: float) -> None:
-        """The minimum percentage(0 - 100) a detected target must take up of the camera's image to be
+        """The minimum percentage (0 - 100) a detected target must take up of the camera's image to be
         processed.
         """
         self.minTargetAreaPercent = areaPercent
@@ -268,6 +271,9 @@ class PhotonCameraSim:
         camRt = RotTrlTransform3d.makeRelativeTo(cameraPose)
 
         for tgt in targets:
+            if len(detectableTgts) >= 50:
+                break
+
             # pose isn't visible, skip to next
             if not self.canSeeTargetPose(cameraPose, tgt):
                 continue
@@ -417,14 +423,15 @@ class PhotonCameraSim:
 
         # put this simulated data to NT
         self.heartbeatCounter += 1
-        now_micros = wpilib.Timer.getFPGATimestamp() * 1e6
+        publishTimestampMicros = wpilib.Timer.getFPGATimestamp() * 1e6
         return PhotonPipelineResult(
+            ntReceiveTimestampMicros=int(publishTimestampMicros + 10),
             metadata=PhotonPipelineMetadata(
-                self.heartbeatCounter,
-                int(now_micros - latency * 1e6),
-                int(now_micros),
+                captureTimestampMicros=int(publishTimestampMicros - latency * 1e6),
+                publishTimestampMicros=int(publishTimestampMicros),
+                sequenceID=self.heartbeatCounter,
                 # Pretend like we heard a pong recently
-                int(np.random.uniform(950, 1050)),
+                timeSinceLastPong=int(np.random.uniform(950, 1050)),
             ),
             targets=detectableTgts,
             multitagResult=multiTagResults,
@@ -474,11 +481,11 @@ class PhotonCameraSim:
 
         intrinsics = self.prop.getIntrinsics()
         intrinsicsView = intrinsics.flatten().tolist()
-        self.ts.cameraIntrinsicsPublisher.set(intrinsicsView, receiveTimestamp_us)
+        self.ts.cameraIntrinsicsPublisher.set(list(intrinsicsView), receiveTimestamp_us)
 
         distortion = self.prop.getDistCoeffs()
         distortionView = distortion.flatten().tolist()
-        self.ts.cameraDistortionPublisher.set(distortionView, receiveTimestamp_us)
+        self.ts.cameraDistortionPublisher.set(list(distortionView), receiveTimestamp_us)
 
         self.ts.heartbeatPublisher.set(self.heartbeatCounter, receiveTimestamp_us)
         self.heartbeatCounter += 1

photonlibpy/simulation/simCameraProperties.py

@@ -195,7 +195,7 @@ class SimCameraProperties:
         return self.latencyStdDev
 
     def getContourAreaPercent(self, points: np.ndarray) -> float:
-        """The percentage(0 - 100) of this camera's resolution the contour takes up in pixels of the
+        """The percentage (0 - 100) of this camera's resolution the contour takes up in pixels of the
         image.
 
         :param points: Points of the contour

photonlibpy/targeting/__init__.py

@@ -1,6 +1,13 @@
-# no one but us chickens
+from .multiTargetPNPResult import MultiTargetPNPResult, PnpResult
+from .photonPipelineResult import PhotonPipelineMetadata, PhotonPipelineResult
+from .photonTrackedTarget import PhotonTrackedTarget
+from .TargetCorner import TargetCorner
 
-from .multiTargetPNPResult import MultiTargetPNPResult, PnpResult  # noqa
-from .photonPipelineResult import PhotonPipelineMetadata, PhotonPipelineResult  # noqa
-from .photonTrackedTarget import PhotonTrackedTarget  # noqa
-from .TargetCorner import TargetCorner  # noqa
+__all__ = (
+    "MultiTargetPNPResult",
+    "PnpResult",
+    "PhotonPipelineMetadata",
+    "PhotonPipelineResult",
+    "PhotonTrackedTarget",
+    "TargetCorner",
+)

photonlibpy/targeting/photonPipelineResult.py

@@ -47,13 +47,10 @@ class PhotonPipelineResult:
         timestamp, coproc timebase))
         """
         # TODO - we don't trust NT4 to correctly latency-compensate ntReceiveTimestampMicros
-        return (
-            self.ntReceiveTimestampMicros
-            - (
-                self.metadata.publishTimestampMicros
-                - self.metadata.captureTimestampMicros
-            )
-        ) / 1e6
+        latency = (
+            self.metadata.publishTimestampMicros - self.metadata.captureTimestampMicros
+        )
+        return (self.ntReceiveTimestampMicros - latency) / 1e6
 
     def getTargets(self) -> list[PhotonTrackedTarget]:
         return self.targets

photonlibpy/timesync/__init__.py

@@ -0,0 +1 @@
+# no one but us chickens

photonlibpy/timesync/timeSyncServer.py

@@ -0,0 +1,94 @@
+import logging
+import socket
+import struct
+import threading
+from typing import Callable, Optional
+
+from wpilib import Timer
+
+
+class TspPing:
+    def __init__(self, version: int, message_id: int, client_time: int):
+        self.version = version
+        self.message_id = message_id
+        self.client_time = client_time
+
+    @staticmethod
+    def unpack(data: bytes) -> "TspPing":
+        # Unpack using struct.unpack
+        version, message_id, client_time = struct.unpack("<BBQ", data)
+        return TspPing(version, message_id, client_time)
+
+    def pack(self) -> bytes:
+        # Pack using struct.pack
+        return struct.pack("<BBQ", self.version, self.message_id, self.client_time)
+
+
+class TspPong:
+    def __init__(self, ping: "TspPing", server_time: int):
+        self.version = ping.version
+        self.message_id = 2  # Pong message ID
+        self.client_time = ping.client_time
+        self.server_time = server_time
+
+    def pack(self) -> bytes:
+        # Pack using struct.pack
+        return struct.pack(
+            "<BBQQ", self.version, self.message_id, self.client_time, self.server_time
+        )
+
+    @staticmethod
+    def unpack(data: bytes) -> "TspPong":
+        # Unpack using struct.unpack
+        version, message_id, client_time, server_time = struct.unpack("<BBQQ", data)
+        ping = TspPing(version, message_id, client_time)
+        return TspPong(ping, server_time)
+
+
+class TimeSyncServer:
+    """This class is a python re-write of the UDP time sync server protocol
+    which runs on a roboRIO to establish a timebase for all PhotonVision coprocessors.
+    """
+
+    PORT = 5810
+
+    def __init__(self, time_provider: Optional[Callable[[], int]] = None):
+        self.time_provider = time_provider or Timer.getFPGATimestamp
+        self._process: Optional[threading.Thread] = None
+        self.logger = logging.getLogger("PhotonVision-TimeSyncServer")
+
+    def _udp_server(self):
+        with socket.socket(socket.AF_INET, socket.SOCK_DGRAM) as udp_socket:
+            udp_socket.bind(("0.0.0.0", self.PORT))
+            while True:
+                data, addr = udp_socket.recvfrom(1024)  # Buffer size of 1024 bytes
+
+                if len(data) < 10:
+                    self.logger.error("Too few bytes")
+                    continue  # Ignore incomplete packets
+
+                ping = TspPing.unpack(data)
+                if ping.version != 1 or ping.message_id != 1:
+                    self.logger.error("Invalid Version/ID")
+                    continue  # Ignore invalid pings
+
+                server_time = int(self.time_provider() * 1e6)  # Convert to microseconds
+                pong = TspPong(ping, server_time)
+                udp_socket.sendto(pong.pack(), addr)
+
+    def start(self):
+        if self._process is not None and self._process.is_alive():
+            return  # Nothing to do
+
+        self._process = threading.Thread(target=self._udp_server, daemon=True)
+        self._process.start()
+        self.logger.info("Server Started")
+
+    def stop(self):
+        if self._process is not None:
+            self._process.join()
+            self._process = None
+            self.logger.info("Server Stopped")
+
+
+inst = TimeSyncServer()

photonlibpy/version.py

@@ -1,2 +1,2 @@
-PHOTONLIB_VERSION="v2025.0.0.beta.8"
-PHOTONVISION_VERSION="v2025.0.0-beta-8"
+PHOTONLIB_VERSION="2026.1.1"
+PHOTONVISION_VERSION="v2026.1.1"

photonlibpy-2026.1.1.dist-info/METADATA

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: photonlibpy
+Version: 2026.1.1
+Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2026.1.1 .
+Home-page: https://photonvision.org
+Author: Photonvision Development Team
+Classifier: License :: OSI Approved :: MIT License
+Description-Content-Type: text/markdown
+Requires-Dist: numpy~=2.3
+Requires-Dist: wpilib<2027,>=2026.2.1
+Requires-Dist: robotpy-wpimath<2027,>=2026.2.1
+Requires-Dist: robotpy-apriltag<2027,>=2026.2.1
+Requires-Dist: robotpy-cscore<2027,>=2026.2.1
+Requires-Dist: pyntcore<2027,>=2026.2.1
+Requires-Dist: opencv-python; platform_machine != "roborio"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+A Pure-python implementation of PhotonLib

photonlibpy-2026.1.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+photonlibpy/__init__.py,sha256=zPyxHwPCDSeCz7OeAAtzfn9-TnHNlG2qRyNQ8yPy0yQ,1379
+photonlibpy/estimatedRobotPose.py,sha256=gKKALm4PcMDBzkF7WganGW9srONJQgQjZioHY588AHA,1413
+photonlibpy/packet.py,sha256=5YomViVFwOljL2FGOetWM9FbPc_yCQ15ylzkYlgLIs8,9724
+photonlibpy/photonCamera.py,sha256=chSwxxfCbunlam9t0BaE9deNMxJ6x9KyBPJBA9esir4,13908
+photonlibpy/photonPoseEstimator.py,sha256=t10pyh38FLRMwvqAuz9rnf9MNaE8AEkBFhoYaODW3kI,10387
+photonlibpy/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+photonlibpy/version.py,sha256=6_AEn0cUFelka8gVEzXz3CFr_yA8RdW99pRU9O8et4s,62
+photonlibpy/estimation/__init__.py,sha256=pZ-d6fN1DJvT-lRl4FfIos5HAvlzmetIOrGIinrdv7k,223
+photonlibpy/estimation/cameraTargetRelation.py,sha256=i7DPBXtkZve4ToXQscEIe-5F1oGQ1Qmf5QBaE__EeMQ,1158
+photonlibpy/estimation/openCVHelp.py,sha256=O1dV7v7RHSyw7l5L0QXbal6t9K7iyvEG76tG-t4AFVg,12388
+photonlibpy/estimation/rotTrlTransform3d.py,sha256=oRYk4V1XF7guNxefJsCPcBWPIkKZl0HYD_Gs86wwToE,2671
+photonlibpy/estimation/targetModel.py,sha256=fIhkf0-_Sfv-KhYEBnhFWMF4Xu84FfF6B-KUEsuuGjQ,6459
+photonlibpy/estimation/visionEstimation.py,sha256=Q4KWdLCV1H0wJUJCzG7OYNhVmk2jR1iPUmX_PFylLdA,4174
+photonlibpy/generated/MultiTargetPNPResultSerde.py,sha256=GH31IKMyHglymJ5phA2I-xJW3QmI9jEv-hmql6r6RoU,2693
+photonlibpy/generated/PhotonPipelineMetadataSerde.py,sha256=RjYLPVE_Od-N2LfeI0_5wvtYKCAjOhArsNSZOcQShmY,3074
+photonlibpy/generated/PhotonPipelineResultSerde.py,sha256=4TrLO8a61eLSfT_cux3Y4AAgjhDoGOiRCfyBLTL6mBg,3302
+photonlibpy/generated/PhotonTrackedTargetSerde.py,sha256=vTuugrX6EzegQYOBspa5i0YAWXvru4NxaBlNkjmnEz0,4624
+photonlibpy/generated/PnpResultSerde.py,sha256=YHKEGaTHNRvd0NMIpw-cO3hOuSqXnkPxmSi3v3nr5OE,2880
+photonlibpy/generated/TargetCornerSerde.py,sha256=FJ6rPTGlwpp6ORUYU-y09xaZxBFlV1o1pft2uVHJMKQ,2377
+photonlibpy/generated/__init__.py,sha256=mElM8M88---wxTWO-SRqIJ4EfxN0fdIUwZBZ-UIGuRw,428
+photonlibpy/networktables/NTTopicSet.py,sha256=sSZtW23OJVNzpfwc2abx1lFW4RWrGpGeta62pKe18ZY,3241
+photonlibpy/networktables/__init__.py,sha256=o_LxTdyIylAszMy_zhUtTkXHyu6jqxccccj78d44OrI,35
+photonlibpy/simulation/__init__.py,sha256=HazsBMXg1HT8TnyxYO8QI9NXwZOrtuCSytnTdquLBKw,358
+photonlibpy/simulation/photonCameraSim.py,sha256=RojKliUvmgc5UTdSKttvtj1CW7ANZyt11_xYqixamTs,20241
+photonlibpy/simulation/simCameraProperties.py,sha256=qU-3zDpETKcmM23Mi1UvcL1uOE0buBYlblPlZrFtvDs,27196
+photonlibpy/simulation/videoSimUtil.py,sha256=xMuTvJ2Jx9IoQqmAJi_zUm06MdEwhVpIz9OyzYQp0k4,29
+photonlibpy/simulation/visionSystemSim.py,sha256=GmKs0d32WE8B020YEWnj-0dQuCnVv1ScGdcFl1fOsKo,13835
+photonlibpy/simulation/visionTargetSim.py,sha256=FH85fKE4NntowUvssfgZ1KlE-I_3Z-QuAgb2bFqvfdY,2219
+photonlibpy/targeting/TargetCorner.py,sha256=ouKj3E5uD76OZSNHHuSDzKOY65a8HqtcOsuejH-MVsU,276
+photonlibpy/targeting/__init__.py,sha256=OxxkBvBa6sFdjG7T1hO8CwBkRHk6GYdXbVhVgYfW7Gc,402
+photonlibpy/targeting/multiTargetPNPResult.py,sha256=Y9rweHtMzoCZ6mv6F8CutQi2Thq5pHN0ydBWvTCsOwY,806
+photonlibpy/targeting/photonPipelineResult.py,sha256=H_wsIQfdo41xNT32YqfttH6AYQRZhAMR7XDiysMa3lw,2700
+photonlibpy/targeting/photonTrackedTarget.py,sha256=zCoFp32hX-3GmBYEmsYBQieBoMzXtP2F_55_q0zPOXA,1956
+photonlibpy/timesync/__init__.py,sha256=pECFraHRZC2Dl4x4OrmhW8oWkawP68pCb-Y61dZycJs,25
+photonlibpy/timesync/timeSyncServer.py,sha256=0d76uHBS_Jo3etvougdZHapbRrbb31iu-jlf8h9U_QQ,3194
+photonlibpy-2026.1.1.dist-info/METADATA,sha256=KdRf2WnQteiGxvdUy1bQpG0t-__rKPyi1SMDmg-16nM,871
+photonlibpy-2026.1.1.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+photonlibpy-2026.1.1.dist-info/top_level.txt,sha256=T8Xc6U6he2VjKUAca6zawSkHdUZuLanxYIc4nxw2ctc,12
+photonlibpy-2026.1.1.dist-info/RECORD,,

{photonlibpy-2025.0.0b8.dist-info → photonlibpy-2026.1.1.dist-info}/WHEEL

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

photonlibpy-2025.0.0b8.dist-info/METADATA

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: photonlibpy
-Version: 2025.0.0b8
-Summary: Pure-python implementation of PhotonLib for interfacing with PhotonVision on coprocessors. Implemented with PhotonVision version v2025.0.0-beta-8 .
-Home-page: https://photonvision.org
-Author: Photonvision Development Team
-Description-Content-Type: text/markdown
-Requires-Dist: numpy~=2.1
-Requires-Dist: wpilib<2026,>=2025.0.0b1
-Requires-Dist: robotpy-wpimath<2026,>=2025.0.0b1
-Requires-Dist: robotpy-apriltag<2026,>=2025.0.0b1
-Requires-Dist: robotpy-cscore<2026,>=2025.0.0b1
-Requires-Dist: pyntcore<2026,>=2025.0.0b1
-Requires-Dist: opencv-python; platform_machine != "roborio"
-
-A Pure-python implementation of PhotonLib

photonlibpy-2025.0.0b8.dist-info/RECORD

@@ -1,37 +0,0 @@
-photonlibpy/__init__.py,sha256=WW1OGrrcNXwwxaHSZlkxmhH2GYiQIHHxSxGVTJZhZbY,1136
-photonlibpy/estimatedRobotPose.py,sha256=X7wF9xdPXGKSVy0MY0qrWZJOEbuZPd721lYp0KXKlP0,1603
-photonlibpy/packet.py,sha256=5YomViVFwOljL2FGOetWM9FbPc_yCQ15ylzkYlgLIs8,9724
-photonlibpy/photonCamera.py,sha256=ENBHp959it4aLnFtV66rHoAIYCvK4bTflZMrGSCwnZ8,12905
-photonlibpy/photonPoseEstimator.py,sha256=2iMqxPFsQHTsq95yv-WCSv1a6wXNcHPqOyMc4Bu6IG0,12584
-photonlibpy/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-photonlibpy/version.py,sha256=Gi-5Nspy6P3-YhTRXS3INLKV_X1zGeRsdORosEs-li4,77
-photonlibpy/estimation/__init__.py,sha256=pZ-d6fN1DJvT-lRl4FfIos5HAvlzmetIOrGIinrdv7k,223
-photonlibpy/estimation/cameraTargetRelation.py,sha256=i7DPBXtkZve4ToXQscEIe-5F1oGQ1Qmf5QBaE__EeMQ,1158
-photonlibpy/estimation/openCVHelp.py,sha256=O1dV7v7RHSyw7l5L0QXbal6t9K7iyvEG76tG-t4AFVg,12388
-photonlibpy/estimation/rotTrlTransform3d.py,sha256=oRYk4V1XF7guNxefJsCPcBWPIkKZl0HYD_Gs86wwToE,2671
-photonlibpy/estimation/targetModel.py,sha256=fIhkf0-_Sfv-KhYEBnhFWMF4Xu84FfF6B-KUEsuuGjQ,6459
-photonlibpy/estimation/visionEstimation.py,sha256=Q4KWdLCV1H0wJUJCzG7OYNhVmk2jR1iPUmX_PFylLdA,4174
-photonlibpy/generated/MultiTargetPNPResultSerde.py,sha256=CzsCosHUnzxAoSC_sSAqpsXsDp54KW-BClnIXdzfMPc,2506
-photonlibpy/generated/PhotonPipelineMetadataSerde.py,sha256=9pq5XUEDEoRowCd7sRnuGV7xtugu5HZCRrnwqZG2xXc,2887
-photonlibpy/generated/PhotonPipelineResultSerde.py,sha256=8_YhW1icdhPOx5eAqwKadvnR29NABmhHr6ERAWK8wEo,3115
-photonlibpy/generated/PhotonTrackedTargetSerde.py,sha256=-6vKir_ABDVBGbg8ktM48IKm_nBMFBbiyuZLiO_fP9U,4437
-photonlibpy/generated/PnpResultSerde.py,sha256=YoTKdQ51oSdxC-7Poy6hunL0-zkMKvP5uedqaHWPudY,2693
-photonlibpy/generated/TargetCornerSerde.py,sha256=kziD_rQIwyhzPfgOaDgn-3d87tvtXiAYbBjzu76biYU,2190
-photonlibpy/generated/__init__.py,sha256=mElM8M88---wxTWO-SRqIJ4EfxN0fdIUwZBZ-UIGuRw,428
-photonlibpy/networktables/NTTopicSet.py,sha256=29wPgXcuqT-u72-YXwSjRHWhECNzU8eDsexcqlA8KQ0,2967
-photonlibpy/networktables/__init__.py,sha256=o_LxTdyIylAszMy_zhUtTkXHyu6jqxccccj78d44OrI,35
-photonlibpy/simulation/__init__.py,sha256=HKJV02of5d8bOnuI7syLzSYtOYge7XUrHSaLvawh99M,227
-photonlibpy/simulation/photonCameraSim.py,sha256=8ELLcOXUtDftV_OYzGG03wigANimJs2SehV-fluWy3k,19907
-photonlibpy/simulation/simCameraProperties.py,sha256=ODVxnylF8zw9HZSbw0PzG_OEtUo9ChRo-G_iEgADOCg,27195
-photonlibpy/simulation/videoSimUtil.py,sha256=xMuTvJ2Jx9IoQqmAJi_zUm06MdEwhVpIz9OyzYQp0k4,29
-photonlibpy/simulation/visionSystemSim.py,sha256=GmKs0d32WE8B020YEWnj-0dQuCnVv1ScGdcFl1fOsKo,13835
-photonlibpy/simulation/visionTargetSim.py,sha256=FH85fKE4NntowUvssfgZ1KlE-I_3Z-QuAgb2bFqvfdY,2219
-photonlibpy/targeting/TargetCorner.py,sha256=ouKj3E5uD76OZSNHHuSDzKOY65a8HqtcOsuejH-MVsU,276
-photonlibpy/targeting/__init__.py,sha256=YzINSpq6A0cjr-yAQcFqHoiYdLGKPFXThlVYlMjY11w,295
-photonlibpy/targeting/multiTargetPNPResult.py,sha256=Y9rweHtMzoCZ6mv6F8CutQi2Thq5pHN0ydBWvTCsOwY,806
-photonlibpy/targeting/photonPipelineResult.py,sha256=MbaSyHZTJpoKTtLOZztpSGSt9xWWFqhzgwj8medObVA,2732
-photonlibpy/targeting/photonTrackedTarget.py,sha256=zCoFp32hX-3GmBYEmsYBQieBoMzXtP2F_55_q0zPOXA,1956
-photonlibpy-2025.0.0b8.dist-info/METADATA,sha256=f0Zgv_wfJOSge_dKazRJUnuld9Vb_3oWMLC_AOTeMwI,689
-photonlibpy-2025.0.0b8.dist-info/WHEEL,sha256=tZoeGjtWxWRfdplE7E3d45VPlLNQnvbKiYnx7gwAy8A,92
-photonlibpy-2025.0.0b8.dist-info/top_level.txt,sha256=T8Xc6U6he2VjKUAca6zawSkHdUZuLanxYIc4nxw2ctc,12
-photonlibpy-2025.0.0b8.dist-info/RECORD,,