Wandmarkierungen

Was der Roboter tun muss

Wandmarkierungen (Wall tokens) bringen den Großteil deiner Punkte, und jede falsche Meldung kostet 5 Punkte. Für jede Markierung, die du findest, musst du also entscheiden:

Es ist …	Was zu tun ist
ein Buchstabenopfer (Letter victim: Φ, Ψ, Ω)	H, S oder U melden
ein gefälschtes Opfer (Fake victim: dieselben Symbole, dreidimensional)	Nicht melden und nicht in die Karte eintragen
ein kognitives Ziel (Cognitive target) mit einer Summe von 0 bis 3	F, P, C oder O melden
ein kognitives Ziel mit einer anderen Summe	Es ist eine Fälschung: nicht melden und nicht in die Karte eintragen

Die genauen Definitionen stehen in den Regeln, und wie du die Meldung sendest, steht unter Kommunikation.

Was die Kamera sieht

Die Kamera des Starter-Roboters hat 64 × 40 Pixel. Bei dieser Auflösung ist eine Markierung nur wenige Pixel groß, bis der Roboter nah dran ist. Am besten suchst du also aus der Entfernung nach Kandidaten und fährst dann näher heran, um sie zu lesen. Denk daran, dass der Roboter für eine Meldung höchstens eine halbe Kachel von der Markierung entfernt sein darf und dass eigene Kameras gegen Aufpreis eine höhere Auflösung haben können.

Buchstabenopfer sind schwarze Symbole auf einem weißen Quadrat, und sie können in jedem Winkel gedreht sein. Deine Methode darf also nicht von der Ausrichtung abhängen.

Ein kognitives Ziel lesen

Ein kognitives Ziel besteht aus fünf konzentrischen Teilen, du musst seine Form also nicht erkennen: Sobald du seinen Mittelpunkt und seinen äußeren Radius gefunden hast, kannst du die Farbe in der Mitte jedes Teils abtasten. Die Teile haben Radien von 0,5, 1, 1,5, 2 und 2,5 cm, ihre Mittelpunkte liegen also bei 0, 0,3, 0,5, 0,7 und 0,9 des äußeren Radius.

Diese Funktion macht das mit OpenCV in Python. Um Mittelpunkt und Radius zu finden, kannst du zum Beispiel die Kontur des Ziels verwenden, wie in Durch das Labyrinth navigieren.

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

In einem echten Lauf siehst du das Ziel vielleicht schräg, dann sieht es wie eine Ellipse aus. Wenn du dich davorstellst, unplausible Farben als Warnung nutzt oder mehrere Bilder liest, wird das Ergebnis zuverlässiger.

Den Typ berechnen

Sobald du die fünf Farben hast, ergibt sich der zu meldende Code aus ihrer Summe. Jeder der fünf Teile zählt immer, auch wenn benachbarte Farben gleich sind.

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;
    }
}

Zum Beispiel ergibt ['Y', 'B', 'R', 'K', 'G'] zusammen 0, also ist es F, und ['B', 'Y', 'K', 'K', 'K'] ergibt -4, also ist es eine Fälschung.

Gefälschte Opfer erkennen

Gefälschte Opfer zeigen dieselben Symbole wie echte, aber die Buchstaben sind dreidimensional. Von vorne kann eine Kamera allein sie eventuell nicht unterscheiden:

Laut den Regeln kann die Tiefe mit einem der Sensoren erkannt werden, die im Robot Customizer verfügbar sind. Einige Ideen zum Ausprobieren:

• Vergleiche Abstandsmessungen quer über die Markierung, mit einem Lidar oder mit Abstandssensoren, um einen Höhenunterschied zu finden.
• Betrachte die Markierung schräg, denn ein Relief verändert dann die Form des Symbols.

Die Welten world3.wbt und world4.wbt enthalten gefälschte Opfer, und mit dem World Editor kannst du sie zu deinen eigenen Karten hinzufügen. Erebus enthält außerdem das Skript scripts/update_maps_with_fakes.py, das Opfer bestehender Welten zufällig in Fälschungen umwandelt.

Eine Fälschung zu melden kostet als Fehlerkennung 5 Punkte, während ein echtes Opfer auf einer linearen Kachel in Bereich 1 mit richtigem Typ 15 Punkte wert ist, in anderen Bereichen sogar mehr. Behalte das im Kopf, wenn du entscheidest, wie sicher sich dein Roboter sein muss, bevor er meldet.