def setUp(self) -> None:
self.embedded_camera = MagicMock()
self.letter_position_extractor = MagicMock()
self.vision_service = VisionService(
self.embedded_camera,
self.letter_position_extractor,
self.A_TARGET,
self.ANOTHER_TARGET,
)
def _create_vision_service(self):
starting_zone_corners_detector = HardcodedStartingZoneDetector()
obstacle_detector = OpenCvObstacleDetector(
DICT_4X4_50,
OBSTACLE_ARUCO_MARKER_ID,
CAMERA_MATRIX,
DISTORTION_COEFFICIENTS,
OBSTACLE_ARUCO_MARKER_SIZE,
OBSTACLE_HEIGHT,
)
image_calibrator = OpenCvCalibrator(CALIBRATION_FILE_PATH)
maze_factory = MazeFactory(ROBOT_RADIUS, OBSTACLE_RADIUS)
table_detector = OpenCvTableDetector()
self._world_camera = self._create_world_camera()
robot_detector = OpenCvRobotDetector(
DICT_4X4_50,
ROBOT_ARUCO_MARKER_ID,
ROBOT_ARUCO_MARKER_SIZE,
CAMERA_MATRIX,
DISTORTION_COEFFICIENTS,
ROBOT_HEIGHT,
)
puck_zone_center_position = Position(DEFAULT_PUCK_ZONE_POSITION[0],
DEFAULT_PUCK_ZONE_POSITION[1])
return VisionService(
starting_zone_corners_detector,
obstacle_detector,
image_calibrator,
table_detector,
self._world_camera,
maze_factory,
robot_detector,
TemplateMatchingPuckDetector(),
puck_zone_center_position,
)
class TestVisionService(TestCase):
A_TARGET = 1200
ANOTHER_TARGET = 1300
def setUp(self) -> None:
self.embedded_camera = MagicMock()
self.letter_position_extractor = MagicMock()
self.vision_service = VisionService(
self.embedded_camera,
self.letter_position_extractor,
self.A_TARGET,
self.ANOTHER_TARGET,
)
def test_givenTarget_whenRotateCameraHorizontally_thenCameraIsRotated(
self):
self.vision_service.rotate_camera_horizontally(self.A_TARGET)
self.embedded_camera.rotate_horizontally.assert_called_with(
self.A_TARGET)
def test_givenTarget_whenRotateCameraVertically_thenCameraIsRotated(self):
self.vision_service.rotate_camera_vertically(self.A_TARGET)
self.embedded_camera.rotate_vertically.assert_called_with(
self.A_TARGET)
def test_whenMakeCameraLookDown_thenCameraRotatesVerticallyWithLookDownTarget(
self, ):
self.vision_service.make_camera_look_down()
self.embedded_camera.rotate_vertically.assert_called_with(
self.A_TARGET)
def test_whenMakeCameraLookUp_thenCameraRotatesVerticallyWithLookUpTarget(
self, ):
self.vision_service.make_camera_look_up()
self.embedded_camera.rotate_vertically.assert_called_with(
self.ANOTHER_TARGET)
def test_givenIndex_whenTakeImage_thenImageTaken(self):
self.vision_service.take_image()
self.embedded_camera.take_image.assert_called()
def update_vision_state(vision_service: VisionService):
try:
table_image, robot_pose = vision_service.get_vision_state()
GameState.get_instance().set_table_image(table_image)
GameState.get_instance().set_robot_pose(robot_pose)
VisionWorker.last_known_pose = robot_pose
except RobotNotFoundException:
GameState.get_instance().set_robot_pose(
VisionWorker.last_known_pose)
def setUp(self):
self.setUpMocks()
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.vision_service = VisionService(
self.starting_zone_detector,
self.obstacle_detector,
self.image_calibrator,
self.table_detector,
self.world_camera,
self.maze_factory,
self.robot_detector,
self.puck_detector,
self.PUCK_ZONE_CENTER,
)
self.table_detector.crop_table.return_value = self.AN_IMAGE
self.obstacle_detector.detect.return_value = self.A_POSITION_LIST
self.AN_IMAGE.shape = self.AN_IMAGE_SHAPE
def _create_vision_service(self):
embedded_camera = self._create_embedded_camera()
letter_position_detector = PytesseractLetterPositionExtractor()
return VisionService(
embedded_camera,
letter_position_detector,
CAMERA_LOOK_DOWN_TARGET,
CAMERA_LOOK_UP_TARGET,
)
def _close_capture(self):
self._capture.release()
if __name__ == "__main__":
movement_command_factory = MovementCommandFactory(
ROBOT_MAXIMUM_SPEED,
SERVOING_CONSTANT,
BASE_COMMAND_DURATION,
)
motor_controller = StmMotorController(
serial.Serial(port=STM_PORT_NAME, baudrate=STM_BAUD_RATE)
)
camera = OpenCvEmbeddedCamera(0)
vision_service = VisionService(camera, MagicMock())
ALIGNED_OHMMETER_HORIZONTAL_POSITION = 349
OHMMETER_ALIGNMENT_THRESHOLD = 10
movement_service = MovementService(movement_command_factory, motor_controller)
starting_zone_line_detector = OpenCvStartingZoneLineDetector()
ohmmeter_alignment_corrector = OhmmeterAlignmentCorrector(
Position(ALIGNED_OHMMETER_HORIZONTAL_POSITION, 0),
OHMMETER_ALIGNMENT_THRESHOLD,
starting_zone_line_detector,
)
while True:
instruction = input("ready? (y/n)")
if instruction == "y":
configure_maestro_channel(maestro, GRIPPER_VERTICAL_SERVO_ID)
configure_maestro_channel(maestro, CAMERA_HORIZONTAL_SERVO_ID)
configure_maestro_channel(maestro, CAMERA_VERTICAL_SERVO_ID)
embedded_camera = OpenCvEmbeddedCamera(
CAMERA_INDEX,
maestro,
CAMERA_HORIZONTAL_SERVO_ID,
CAMERA_VERTICAL_SERVO_ID,
HORIZONTAL_ANGLE_RANGE,
VERTICAL_ANGLE_RANGE,
)
letter_position_detector = MagicMock()
vision_service = VisionService(
embedded_camera,
letter_position_detector,
CAMERA_LOOK_DOWN_TARGET,
CAMERA_LOOK_UP_TARGET,
)
print("-------------- Press to look left ----------------")
input("Press Enter to start test")
vision_service.rotate_camera_horizontally(5000)
print("-------------- Press to look middle ----------------")
input("Press Enter to start test")
vision_service.rotate_camera_horizontally(6200)
print("-------------- Press to make camera look up ----------------")
input("Press Enter to start test")
vision_service.make_camera_look_up()
class TestVisionService(TestCase):
A_STARTING_ZONE = MagicMock()
AN_IMAGE = MagicMock()
UNDISTORTED_TABLE_IMAGE = MagicMock()
PUCK_ZONE_CENTER = Position(100, 200)
AN_IMAGE_SHAPE = [120, 200, 3]
A_POSITION_LIST = [Position(100, 100), Position(200, 200)]
A_MAZE = MagicMock()
A_ROBOT_POSE = MagicMock()
A_POSITION = MagicMock()
A_COLOR = Color.BLUE
SOME_PUCKS = MagicMock()
def setUp(self):
self.setUpMocks()
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.vision_service = VisionService(
self.starting_zone_detector,
self.obstacle_detector,
self.image_calibrator,
self.table_detector,
self.world_camera,
self.maze_factory,
self.robot_detector,
self.puck_detector,
self.PUCK_ZONE_CENTER,
)
self.table_detector.crop_table.return_value = self.AN_IMAGE
self.obstacle_detector.detect.return_value = self.A_POSITION_LIST
self.AN_IMAGE.shape = self.AN_IMAGE_SHAPE
def setUpMocks(self):
self.starting_zone_detector = MagicMock()
self.obstacle_detector = MagicMock()
self.image_calibrator = MagicMock()
self.table_detector = MagicMock()
self.world_camera = MagicMock()
self.maze_factory = MagicMock()
self.robot_detector = MagicMock()
self.puck_detector = MagicMock()
def test_whenCreateGameTable_thenWorldImageIsTaken(self):
self.vision_service.create_game_table()
self.world_camera.take_world_image.assert_called()
def test_whenCreateGameTable_thenStartingZoneDetectorUseWorldImage(self):
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.vision_service.create_game_table()
self.starting_zone_detector.detect.assert_called_with(self.AN_IMAGE)
def test_whenCreateGameTable_thenGameTableContainsStartingZoneDetected(self):
self.starting_zone_detector.detect.return_value = self.A_STARTING_ZONE
actual_starting_zone = (
self.vision_service.create_game_table().get_starting_zone()
)
self.assertEqual(self.A_STARTING_ZONE, actual_starting_zone)
def test_whenCreateGameTable_thenObstaclesAreDetectedUsingUndistortedImage(self):
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.UNDISTORTED_TABLE_IMAGE.shape = self.AN_IMAGE_SHAPE
self.vision_service.create_game_table()
self.obstacle_detector.detect.assert_called_with(self.AN_IMAGE)
def test_whenCreateGameTable_thenGameTableHasRightPuckZonePosition(self):
game_table = self.vision_service.create_game_table()
self.assertEqual(self.PUCK_ZONE_CENTER, game_table.get_puck_zone_center())
def test_givenWorldCameraTakesPictureOfTable_createGameTable_thenMazeIsCreatedWithRightDimensionsAndObstacles(
self,
):
self.image_calibrator.calibrate.return_value = self.AN_IMAGE
self.vision_service.create_game_table()
self.maze_factory.create_from_shape_and_obstacles_and_pucks_as_obstacles.assert_called()
def test_whenGetVisionState_thenTableImageIsTaken(self):
self.vision_service.get_vision_state()
self.world_camera.take_world_image.assert_called()
def test_whenGetVisionState_thenRobotIsDetected(self):
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.vision_service.get_vision_state()
self.robot_detector.detect.assert_called_with(self.AN_IMAGE)
def test_whenGetVisionState_thenTableImageAndRobotPoseAreReturned(self):
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.robot_detector.detect.return_value = self.A_ROBOT_POSE
actual_table_image, actual_robot_pose = self.vision_service.get_vision_state()
self.assertEqual(actual_table_image, self.AN_IMAGE)
self.assertEqual(actual_robot_pose, self.A_ROBOT_POSE)
def test_givenColorAndCalibratedTableImage_whenFindPuck_thenUsePuckDetectorToDetectRightColor(
self,
):
self.image_calibrator.calibrate.return_value = self.AN_IMAGE
a_color = Color.YELLOW
self.vision_service.find_puck_position(a_color)
self.puck_detector.detect.assert_called_with(self.AN_IMAGE, a_color)
def test_givenPuckDetectedByDetector_whenFindPuck_thenReturnPuckPosition(self):
self.puck_detector.detect.return_value = self.A_POSITION
actual_position = self.vision_service.find_puck_position(self.A_COLOR)
self.assertEqual(self.A_POSITION, actual_position)
def test_whenCreateGameTable_thenAllPucksAreDetected(self):
self.world_camera.take_world_image.return_value = self.AN_IMAGE
self.image_calibrator.calibrate.return_value = self.AN_IMAGE
expected_calls = [
call(self.AN_IMAGE, color) for color in Color if color != Color.NONE
]
self.vision_service.create_game_table()
self.puck_detector.detect.assert_has_calls(expected_calls)
def test_givenPucksDetected_whenCreateGameTable_thenGameTableHasPucks(self):
self.puck_detector.detect.return_value = self.A_POSITION
puck_colors = len(Color) - 1
actual_game_table = self.vision_service.create_game_table()
self.assertEqual(len(actual_game_table.get_pucks()), puck_colors)