# Source code for pyfrc.physics.visionsim

```
"""
The 'vision simulator' provides objects that assist in modeling inputs
from a camera processing system.
"""
import collections
import math
inf = float("inf")
twopi = math.pi * 2.0
def _in_angle_interval(x, a, b):
return (x - a) % twopi <= (b - a) % twopi
[docs]class VisionSimTarget:
"""
Target object that you pass the to the constructor of :class:`.VisionSim`
"""
def __init__(self, x, y, view_angle_start, view_angle_end):
"""
:param x: Target x position
:param y: Target y position
:param view_angle_start:
:param view_angle_end: clockwise from start angle
View angle is defined in degrees from 0 to 360, with 0 = east,
increasing clockwise. So, if the robot could only see
the target from the south east side, you would use a view angle
of start=0, end=90.
"""
self.x = x
self.y = y
self.view_angle_start = math.radians(view_angle_start)
self.view_angle_end = math.radians(view_angle_end)
def compute(self, now, x, y, angle):
# incoming angle must be normalized to -180,180 (done in VisionSim)
# note: the position tracking of the robot has Y incrementing
# positively downwards, presumably because it's convenient for
# drawing stuff. Not what I had expected.
# compute target distance
dx = self.x - x
dy = self.y - y
distance = math.hypot(dx, dy)
# at the right distance?
if distance < self.view_dst_start or distance > self.view_dst_end:
return
# determine the absolute angle of the target relative to the robot
target_angle = math.atan2(dy, dx)
# in the view range?
if not _in_angle_interval(
target_angle + math.pi, self.view_angle_start, self.view_angle_end
):
return
# is the robot facing the target?
a = angle - self.fov2
b = angle + self.fov2
if _in_angle_interval(target_angle + math.pi, a + math.pi, b + math.pi):
offset = math.degrees(
(((target_angle - angle) + math.pi) % (math.pi * 2)) - math.pi
)
return (1, now, offset, distance)
[docs]class VisionSim:
"""
This helper object is designed to help you simulate input from a
vision system. The algorithm is a very simple approximation and
has some weaknesses, but it should be a good start and general
enough to work for many different usages.
There are a few assumptions that this makes:
- Your camera code sends new data at a constant frequency
- The data from the camera lags behind at a fixed latency
- If the camera is too close, the target cannot be seen
- If the camera is too far, the target cannot be seen
- You can only 'see' the target when the 'front' of the robot is
around particular angles to the target
- The camera is in the center of your robot (this simplifies some
things, maybe fix this in the future...)
To use this, create an instance in your physics simulator::
targets = [
VisionSim.Target(...)
]
Then call the :meth:`compute` method from your ``update_sim`` method
whenever your camera processing is enabled::
# in physics engine update_sim()
x, y, angle = self.physics_controller.get_position()
if self.camera_enabled:
data = self.vision_sim.compute(now, x, y, angle)
if data is not None:
self.nt.putNumberArray('/camera/target', data[0])
else:
self.vision_sim.dont_compute()
.. note:: There is a working example in the examples repository
you can use to try this functionality out
"""
Target = VisionSimTarget
def __init__(
self,
targets,
camera_fov,
view_dst_start,
view_dst_end,
data_frequency=15,
data_lag=0.050,
physics_controller=None,
):
"""
There are a lot of constructor parameters:
:param targets: List of target positions (x, y) on field in feet
:param view_angle_start: Center angle that the robot can 'see' the target from (in degrees)
:param camera_fov: Field of view of camera (in degrees)
:param view_dst_start: If the robot is closer than this, the target cannot be seen
:param view_dst_end: If the robot is farther than this, the target cannot be seen
:param data_frequency: How often the camera transmits new coordinates
:param data_lag: How long it takes for the camera data to be processed
and make it to the robot
:param physics_controller: If set, will draw target information in UI
"""
fov2 = math.radians(camera_fov / 2.0)
self.distance = 0
self.update_period = 1.0 / data_frequency
self.data_lag = data_lag
self.last_compute_time = -10
self.send_queue = collections.deque()
self.targets = targets
assert view_dst_start < view_dst_end
assert self.data_lag > 0.001
objects = []
if physics_controller:
objects = physics_controller.config_obj["pyfrc"]["field"]["objects"]
for target in targets:
target.camera_fov = camera_fov
target.view_dst_start = view_dst_start
target.view_dst_end = view_dst_end
target.fov2 = fov2
objects.append(
{"color": "red", "rect": [target.x - 0.1, target.y - 0.1, 0.4, 0.4]}
)
[docs] def dont_compute(self):
"""
Call this when vision processing should be disabled
"""
self.send_queue.clear()
[docs] def get_immediate_distance(self):
"""
Use this data to feed to a sensor that is mostly instantaneous
(such as an ultrasonic sensor).
.. note:: You must call :meth:`compute` first.
"""
return self.distance
[docs] def compute(self, now, x, y, angle):
"""
Call this when vision processing should be enabled
:param now: The value passed to ``update_sim``
:param x: Returned from physics_controller.get_position
:param y: Returned from physics_controller.get_position
:param angle: Returned from physics_controller.get_position
:returns: None or list of tuples of (found=0 or 1, capture_time, offset_degrees, distance).
The tuples are ordered by absolute offset from the
target. If a list is returned, it is guaranteed to have at
least one element in it.
Note: If your vision targeting doesn't have the ability
to focus on multiple targets, then you should ignore
the other elements.
"""
# Normalize angle to [-180,180]
output = []
angle = ((angle + math.pi) % (math.pi * 2)) - math.pi
for target in self.targets:
proposed = target.compute(now, x, y, angle)
if proposed:
output.append(proposed)
if not output:
output.append((0, now, inf, 0))
self.distance = None
else:
# order by absolute offset
output.sort(key=lambda i: abs(i[2]))
self.distance = output[-1][3]
# Only store stuff every once in awhile
if now - self.last_compute_time > self.update_period:
self.last_compute_time = now
self.send_queue.appendleft(output)
# simulate latency by delaying camera output
if self.send_queue:
output = self.send_queue[-1]
if now - output[0][1] > self.data_lag:
return self.send_queue.pop()
```