FacePosition ¶

@staticmethod
def from_vector(vector: np.ndarray) -> 'FacePosition':
    """Converts the given vector to the corresponding face.

    Conversion is done according to the default definition: BLUE/FRONT -> x+, RED/LEFT -> y+, YELLOW/TOP -> z+

    Args:
        vector: the vector to convert to a face

    Returns:
        the corresponding face
    """
    if (vector == np.array([1, 0, 0])).all():
        return FacePosition.FRONT
    if (vector == np.array([-1, 0, 0])).all():
        return FacePosition.BACK
    if (vector == np.array([0, 1, 0])).all():
        return FacePosition.LEFT
    if (vector == np.array([0, -1, 0])).all():
        return FacePosition.RIGHT
    if (vector == np.array([0, 0, 1])).all():
        return FacePosition.TOP
    if (vector == np.array([0, 0, -1])).all():
        return FacePosition.BOTTOM

@staticmethod
def from_string_notation(string: str) -> 'FacePosition':
    """Returns the internal representation for a given character, swapping left and right because of the different models used.

    !!! note
        left and right are swapped because cuber notation uses the point of view
        of the cuber and our `FacePosition` uses the point of view of the cube

    Returns:
        the internal representation of the face
    """
    char = string[0].lower()

    if char == 'f':
        return FacePosition.FRONT
    if char == 'b':
        return FacePosition.BACK
    if char == 'r':
        # left and right are swapped because cuber notation uses the point of view
        # of the cuber and our face position uses the point of view of the cube
        return FacePosition.LEFT
    if char == 'l':
        return FacePosition.RIGHT
    if char == 'u':
        return FacePosition.TOP
    if char == 'd':
        return FacePosition.BOTTOM

    raise ValueError('Cannot infer face from string: {}'.format(repr(string)))

@staticmethod
def from_tile_color(tile_color: TileColor) -> 'FacePosition':
    """Converts the given color to the corresponding face.

    Args:
        tile_color: the color of the face

    Returns:
        the matching face
    """
    return FacePosition(tile_color.value)

def is_next_to(self, other: 'FacePosition') -> bool:
    """Checks whether the given face is next to this face.

    Args:
        other: the possibly neighboring face

    Returns:
         whether the given face is a neighbor
    """
    neighbours = {
        FacePosition.YELLOW: [FacePosition.BLUE, FacePosition.RED, FacePosition.GREEN, FacePosition.ORANGE],
        FacePosition.WHITE: [FacePosition.BLUE, FacePosition.RED, FacePosition.GREEN, FacePosition.ORANGE],
        FacePosition.GREEN: [FacePosition.YELLOW, FacePosition.WHITE, FacePosition.RED, FacePosition.ORANGE],
        FacePosition.BLUE: [FacePosition.YELLOW, FacePosition.WHITE, FacePosition.RED, FacePosition.ORANGE],
        FacePosition.RED: [FacePosition.YELLOW, FacePosition.BLUE, FacePosition.GREEN, FacePosition.WHITE],
        FacePosition.ORANGE: [FacePosition.YELLOW, FacePosition.BLUE, FacePosition.GREEN, FacePosition.WHITE]
    }
    return other in neighbours[self]

def to_vector(self) -> np.ndarray:
    """Converts the face to its vector representation.

    Conversion is done according to the default definition: BLUE/FRONT -> x+, RED/LEFT -> y+, YELLOW/TOP -> z+
    """
    if self == FacePosition.FRONT:
        return np.array([1, 0, 0])
    if self == FacePosition.BACK:
        return np.array([-1, 0, 0])
    if self == FacePosition.LEFT:
        return np.array([0, 1, 0])
    if self == FacePosition.RIGHT:
        return np.array([0, -1, 0])
    if self == FacePosition.TOP:
        return np.array([0, 0, 1])
    if self == FacePosition.BOTTOM:
        return np.array([0, 0, -1])

def to_rotation(self, degrees: float) -> transform.Rotation:
    """Returns the rotation matching this face axis and the given degrees.

    Args:
        degrees: the amount of rotation.

    Returns:
        the rotation
    """
    axis = None
    if self == FacePosition.FRONT:
        axis = 'x'
    if self == FacePosition.BACK:
        axis = 'x'
        degrees *= -1
    if self == FacePosition.LEFT:
        axis = 'y'
    if self == FacePosition.RIGHT:
        axis = 'y'
        degrees *= -1
    if self == FacePosition.TOP:
        axis = 'z'
    if self == FacePosition.BOTTOM:
        axis = 'z'
        degrees *= -1

    return transform.Rotation.from_euler(axis, degrees, degrees=True)

def to_color(self) -> TileColor:
    """Converts this face to its color.

    Returns:
        the matching color
    """
    return TileColor(self.value)

def to_string_notation(self) -> str:
    """Returns the cuber notation representation, swapping left and right because of the different models used.

    !!! note
        left and right are swapped because cuber notation uses the point of view
        of the cuber and our `FacePosition` uses the point of view of the cube

    Returns:
        the cuber notation of this face (a letter)
    """
    if self == FacePosition.FRONT:
        return 'F'
    if self == FacePosition.BACK:
        return 'B'
    if self == FacePosition.LEFT:
        # left and right are swapped because cuber notation uses the point of view
        # of the cuber and our face position uses the point of view of the cube
        return 'R'
    if self == FacePosition.RIGHT:
        return 'L'
    if self == FacePosition.TOP:
        return 'U'
    if self == FacePosition.BOTTOM:
        return 'D'