Marcadores nas paredes

O que o robô precisa fazer

Os marcadores nas paredes (wall tokens) valem a maior parte dos seus pontos, e cada informe errado custa 5 pontos. Então, para cada marcador que encontrar, você precisa decidir entre:

É…	O que fazer
Uma vítima de letra (Φ, Ψ, Ω)	Informe H, S ou U
Uma vítima falsa (os mesmos símbolos, tridimensionais)	Não a informe e deixe-a fora do mapa
Um alvo cognitivo com soma de 0 a 3	Informe F, P, C ou O
Um alvo cognitivo com qualquer outra soma	É falso: não o informe e deixe-o fora do mapa

Veja as Regras para as definições exatas e Comunicação para saber como enviar o informe.

O que a câmera vê

A câmera do robô inicial tem 64 × 40 pixels. Nessa resolução, um marcador ocupa só alguns pixels até o robô chegar perto, então o melhor é procurar candidatos de longe e depois se aproximar para lê-los. Lembre que, para informar, o robô precisa estar a no máximo meio ladrilho do marcador, e que câmeras personalizadas podem ter uma resolução maior, com um custo.

As vítimas de letra (letter victims) são símbolos pretos em um quadrado branco, e podem estar giradas em qualquer ângulo, então o seu método não pode depender da orientação.

Lendo um alvo cognitivo

Um alvo cognitivo (cognitive target) é formado por cinco partes concêntricas, então não é preciso reconhecer a sua forma: depois de encontrar o centro e o raio externo, você pode amostrar a cor no meio de cada parte. As partes têm raios de 0,5, 1, 1,5, 2 e 2,5 cm, então os pontos do meio delas ficam em 0, 0,3, 0,5, 0,7 e 0,9 do raio externo.

Esta função faz isso com o OpenCV em Python. Para encontrar o centro e o raio, você pode, por exemplo, usar o contorno do alvo, como em Navegue pelo labirinto.

Python

import cv2 as cv
import numpy as np

# Colour of each part in BGR order, as seen by the camera
COLORS = {
    'K': (0, 0, 0),      # Black
    'R': (0, 0, 255),    # Red
    'Y': (0, 255, 255),  # Yellow
    'G': (0, 255, 0),    # Green
    'B': (255, 0, 0),    # Blue
}

def nearestColor(bgr):
    # Returns the name of the colour that is closest to a pixel
    distances = {name: np.linalg.norm(np.array(color) - bgr) for name, color in COLORS.items()}
    return min(distances, key=distances.get)

def readRings(image, centerX, centerY, radius):
    # image is a BGR image, as in the RGB Camera tutorial
    # Returns the 5 colours from the center outwards, for example ['Y', 'B', 'R', 'K', 'G']
    rings = []
    for position in [0, 0.3, 0.5, 0.7, 0.9]:
        x = int(round(centerX + position * radius))
        y = int(round(centerY))
        rings.append(nearestColor(image[y, x].astype(float)))
    return rings

Em uma execução real, o alvo pode ser visto de lado e, nesse caso, parece uma elipse. Posicionar-se de frente para ele, usar as cores que parecem erradas como alerta ou ler vários quadros vai deixar o resultado mais confiável.

Calculando o tipo

Depois de obter as cinco cores, o código a informar vem da soma delas. Cada uma das cinco partes sempre conta, mesmo quando cores vizinhas são iguais.

Python

VALUES = {'K': -2, 'R': -1, 'Y': 0, 'G': 1, 'B': 2}
CODES = {0: 'F', 1: 'P', 2: 'C', 3: 'O'}

def targetCode(rings):
    # rings is the list of the 5 colours of the target
    # Returns the code to report, or None if the target is fake
    total = sum(VALUES[color] for color in rings)
    return CODES.get(total)

C/C++

#include <map>
#include <vector>

using namespace std;

// rings has the 5 colours of the target: 'K', 'R', 'Y', 'G' or 'B'
// Returns the code to report, or 0 if the target is fake
char targetCode(const vector<char>& rings) {
    map<char, int> values = {{'K', -2}, {'R', -1}, {'Y', 0}, {'G', 1}, {'B', 2}};
    int total = 0;
    for (char color : rings)
        total += values[color];

    switch (total) {
        case 0: return 'F';
        case 1: return 'P';
        case 2: return 'C';
        case 3: return 'O';
        default: return 0;
    }
}

Por exemplo, ['Y', 'B', 'R', 'K', 'G'] soma 0, então é F, e ['B', 'Y', 'K', 'K', 'K'] soma -4, então é falso.

Detectando vítimas falsas

As vítimas falsas (fake victims) mostram os mesmos símbolos que as reais, mas as letras são tridimensionais. De frente, uma câmera sozinha pode não conseguir diferenciá-las:

As regras dizem que a profundidade pode ser detectada com um dos sensores disponíveis no Robot Customizer. Algumas ideias para explorar:

• Compare medidas de distância tomadas ao longo do marcador, com um lidar ou com sensores de distância, para procurar uma diferença de altura.
• Olhe para o marcador de lado, onde um relevo muda a forma do símbolo.

Os mundos world3.wbt e world4.wbt têm vítimas falsas, e o World Editor pode adicioná-las aos seus próprios mapas. O Erebus também inclui o script scripts/update_maps_with_fakes.py, que transforma aleatoriamente vítimas de mundos existentes em falsas.

Informar um falso custa 5 pontos como identificação errada, enquanto uma vítima real em um ladrilho linear vale 15 pontos com o seu tipo na área 1, e mais nas outras áreas. Leve isso em conta ao decidir o quanto o seu robô precisa ter certeza antes de informar.