timofej/neuropercolation
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
19be460edc
neuropercolation/cellular_automaton/neighborhood.py
Richard Feistenauer 9b527a044f Reworked CellularAutomaton to improve API and speed 
+ Added CI
+ Restructured Project
+ Improved API Improved creation speed by factor of \~2
+ Improved execution speed by factor of \~15

- Removed multi processor since it doesn't work with the new setup and was not fast enough to matter.
2020-10-20 10:14:05 +00:00

239 lines
9.4 KiB
Python
Raw Blame History

"""
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(ci in [0, di-1] 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))
Reference in New Issue View Git Blame Copy Permalink