neuropercolation/cellular_automaton/neighborhood.py

"""
Copyright 2019 Richard Feistenauer

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""

import enum
import operator
import itertools
import math


class EdgeRule(enum.Enum):
    """ Enum for different possibilities to handle the edge of the automaton. """
    IGNORE_EDGE_CELLS = 0
    IGNORE_MISSING_NEIGHBORS_OF_EDGE_CELLS = 1
    FIRST_AND_LAST_CELL_OF_DIMENSION_ARE_NEIGHBORS = 2


class Neighborhood:
    """ Defines which cells should be considered to be neighbors during evolution of cellular automaton."""

    def __init__(self, edge_rule=EdgeRule.IGNORE_EDGE_CELLS, radius=1):
        """ General class for all Neighborhoods.
        :param edge_rule:   Rule to define, how cells on the edge of the grid will be handled.
        :param radius:      If radius > 1 it grows the neighborhood
                            by adding the neighbors of the neighbors radius times.
        """
        self._rel_neighbors = None
        self._grid_dimensions = []
        self._radius = radius
        self.__edge_rule = edge_rule

    def calculate_cell_neighbor_coordinates(self, cell_coordinate, grid_dimensions):
        """ Get a list of absolute coordinates for the cell neighbors.
            The EdgeRule can reduce the returned neighbor count.
        :param cell_coordinate:  The coordinate of the cell.
        :param grid_dimensions:  The dimensions of the grid, to apply the edge the rule.
        :return: list of absolute coordinates for the cells neighbors.
        """
        self.__lazy_initialize_relative_neighborhood(grid_dimensions)
        return tuple(self._neighbors_generator(cell_coordinate))

    def __lazy_initialize_relative_neighborhood(self, grid_dimensions):
        self._grid_dimensions = grid_dimensions
        if self._rel_neighbors is None:
            self._create_relative_neighborhood()

    def _create_relative_neighborhood(self):
        self._rel_neighbors = tuple(self._neighborhood_generator())

    def _neighborhood_generator(self):
        for coordinate in itertools.product(range(-self._radius, self._radius + 1), repeat=len(self._grid_dimensions)):
            if self._neighbor_rule(coordinate) and coordinate != (0, ) * len(self._grid_dimensions):
                yield tuple(reversed(coordinate))

    def _neighbor_rule(self, rel_neighbor):  # pylint: disable=no-self-use, unused-argument
        return True

    def get_neighbor_by_relative_coordinate(self, neighbors, rel_coordinate):
        return neighbors[self._rel_neighbors.index(rel_coordinate)]

    def _neighbors_generator(self, cell_coordinate):
        on_edge = self.__is_coordinate_on_an_edge(cell_coordinate)
        if self.__edge_rule != EdgeRule.IGNORE_EDGE_CELLS or not on_edge:  # pylint: disable=too-many-nested-blocks
            for rel_n in self._rel_neighbors:
                if on_edge:
                    n, n_folded = zip(*[(ni + ci, (ni + di + ci) % di)
                                        for ci, ni, di in zip(cell_coordinate, rel_n, self._grid_dimensions)])
                    if self.__edge_rule == EdgeRule.FIRST_AND_LAST_CELL_OF_DIMENSION_ARE_NEIGHBORS or n == n_folded:
                        yield n_folded
                else:
                    yield tuple(map(operator.add, rel_n, cell_coordinate))

    def __is_coordinate_on_an_edge(self, coordinate):
        return any(not(self._radius-1 < ci < di-self._radius) for ci, di in zip(coordinate, self._grid_dimensions))


class MooreNeighborhood(Neighborhood):
    """ Moore defined a neighborhood with a radius applied on a the non euclidean distance to other cells in the grid.
        Example:
            2 dimensions
            C = cell of interest
            N = neighbor of cell
            X = no neighbor of cell

                  Radius 1                     Radius 2
               X  X  X  X  X                N  N  N  N  N
               X  N  N  N  X                N  N  N  N  N
               X  N  C  N  X                N  N  C  N  N
               X  N  N  N  X                N  N  N  N  N
               X  X  X  X  X                N  N  N  N  N
    """


class VonNeumannNeighborhood(Neighborhood):
    """ Von Neumann defined a neighborhood with a radius applied to Manhatten distance
        (steps between cells without diagonal movement).
        Example:
            2 dimensions
            C = cell of interest
            N = neighbor of cell
            X = no neighbor of cell

                  Radius 1                     Radius 2
               X  X  X  X  X                X  X  N  X  X
               X  X  N  X  X                X  N  N  N  X
               X  N  C  N  X                N  N  C  N  N
               X  X  N  X  X                X  N  N  N  X
               X  X  X  X  X                X  X  N  X  X
    """

    def _neighbor_rule(self, rel_neighbor):
        cross_sum = 0
        for coordinate_i in rel_neighbor:
            cross_sum += abs(coordinate_i)
        return cross_sum <= self._radius


class RadialNeighborhood(Neighborhood):
    """ Neighborhood with a radius applied to euclidean distance + delta

        Example:
            2 dimensions
            C = cell of interest
            N = neighbor of cell
            X = no neighbor of cell

                  Radius 2                     Radius 3
            X  X  X  X  X  X  X          X  X  N  N  N  X  X
            X  X  N  N  N  X  X          X  N  N  N  N  N  X
            X  N  N  N  N  N  X          N  N  N  N  N  N  N
            X  N  N  C  N  N  X          N  N  N  C  N  N  N
            X  N  N  N  N  N  X          N  N  N  N  N  N  N
            X  X  N  N  N  X  X          X  N  N  N  N  N  X
            X  X  X  X  X  X  X          X  X  N  N  N  X  X
    """

    def __init__(self, *args, delta_=.25, **kwargs):
        self.delta = delta_
        super().__init__(*args, **kwargs)

    def _neighbor_rule(self, rel_neighbor):
        cross_sum = 0
        for coordinate_i in rel_neighbor:
            cross_sum += pow(coordinate_i, 2)
        return math.sqrt(cross_sum) <= self._radius + self.delta


class HexagonalNeighborhood(Neighborhood):
    """ Defines a Hexagonal neighborhood in a rectangular two dimensional grid:

        Example:
            Von Nexagonal neighborhood in 2 dimensions with radius 1 and 2
            C = cell of interest
            N = neighbor of cell
            X = no neighbor of cell

                  Radius 1                     Radius 2
               X   X   X   X   X           X   N   N   N   X
                 X   N   N   X               N   N   N   N
               X   N   C   N   X           N   N   C   N   N
                 X   N   N   X               N   N   N   N
               X   X   X   X   X           X   N   N   N   X


        Rectangular representation: Radius 1

          Row % 2 == 0            Row % 2 == 1
            N  N  X                 X  N  N
            N  C  N                 N  C  N
            N  N  X                 X  N  N

        Rectangular representation: Radius 2
          Row % 2 == 0            Row % 2 == 1
          X  N  N  N  X           X  N  N  N  X
          N  N  N  N  X           X  N  N  N  N
          N  N  C  N  N           N  N  C  N  N
          N  N  N  N  X           X  N  N  N  N
          X  N  N  N  X           X  N  N  N  X
    """

    def __init__(self, *args, radius=1, **kwargs):
        super().__init__(radius=radius, *args, **kwargs)
        self.__calculate_hexagonal_neighborhood(radius)

    def __calculate_hexagonal_neighborhood(self, radius):
        neighbor_lists = [[(0, 0)], [(0, 0)]]
        for radius_i in range(1, radius + 1):
            for i, neighbor in enumerate(neighbor_lists):
                neighbor = _grow_neighbours(neighbor)
                neighbor = self.__add_rectangular_neighbours(neighbor, radius_i, i % 2 == 1)
                neighbor = sorted(neighbor, key=(lambda ne: [ne[1], ne[0]]))
                neighbor.remove((0, 0))
                neighbor_lists[i] = neighbor
        self._neighbor_lists = neighbor_lists

    def get_neighbor_by_relative_coordinate(self, neighbors, rel_coordinate):  # pragma: no cover
        raise NotImplementedError

    def calculate_cell_neighbor_coordinates(self, cell_coordinate, grid_dimensions):
        self._rel_neighbors = self._neighbor_lists[cell_coordinate[1] % 2]
        return super().calculate_cell_neighbor_coordinates(cell_coordinate, grid_dimensions)

    @staticmethod
    def __add_rectangular_neighbours(neighbours, radius, is_odd):
        new_neighbours = []
        for x in range(0, radius + 1):
            if is_odd:
                x -= int(radius/2)
            else:
                x -= int((radius + 1) / 2)

            for y in range(-radius, radius + 1):
                new_neighbours.append((x, y))
        new_neighbours.extend(neighbours)
        return list(set(new_neighbours))


def _grow_neighbours(neighbours):
    new_neighbours = neighbours[:]
    for n in neighbours:
        new_neighbours.append((n[0], n[1] - 1))
        new_neighbours.append((n[0] - 1, n[1]))
        new_neighbours.append((n[0] + 1, n[1]))
        new_neighbours.append((n[0], n[1] + 1))
    return list(set(new_neighbours))