122 lines
4.9 KiB
Python
122 lines
4.9 KiB
Python
from multiprocessing import RawArray, RawValue
|
|
from ctypes import c_float, c_bool
|
|
|
|
|
|
class CellState:
|
|
"""
|
|
This is the base class for all cell states.
|
|
When using the cellular automaton display, inherit this class and implement get_state_draw_color.
|
|
"""
|
|
|
|
_state_save_slot_count = 2
|
|
|
|
def __init__(self, initial_state=(0., ), draw_first_state=True):
|
|
self._state_slots = [list(initial_state) for i in range(self.__class__._state_save_slot_count)]
|
|
self._active = [False for i in range(self.__class__._state_save_slot_count)]
|
|
self._active[0] = True
|
|
self._dirty = draw_first_state
|
|
|
|
def is_active(self, current_evolution_step):
|
|
""" Returns the active status for the requested evolution_step
|
|
:param current_evolution_step: The evolution_step of interest.
|
|
:return: True if the cell state is set active for this evolution_step.
|
|
"""
|
|
return self._active[self._calculate_slot(current_evolution_step)]
|
|
|
|
def set_active_for_next_evolution_step(self, current_evolution_step):
|
|
""" Sets the cell active for the next evolution_step, so it will be evolved.
|
|
:param current_evolution_step: The current evolution_step index.
|
|
:return:
|
|
"""
|
|
self._active[self._calculate_slot(current_evolution_step + 1)] = True
|
|
|
|
def is_set_for_redraw(self):
|
|
""" States if this state should be redrawn.
|
|
:return: True if redraw is needed.
|
|
"""
|
|
return self._dirty
|
|
|
|
def was_redrawn(self):
|
|
""" Remove the state from redraw cycle until next state change """
|
|
self._dirty = False
|
|
|
|
def get_state_of_last_evolution_step(self, current_evolution_step):
|
|
return self.get_state_of_evolution_step(current_evolution_step - 1)
|
|
|
|
def get_state_of_evolution_step(self, evolution_step):
|
|
""" Returns the state of the evolution_step.
|
|
:param evolution_step: Uses the evolution_step index, to differ between concurrent states.
|
|
:return The state of this evolution_step.
|
|
"""
|
|
return self._state_slots[self._calculate_slot(evolution_step)]
|
|
|
|
def set_state_of_evolution_step(self, new_state, evolution_step):
|
|
""" Sets the new state for the evolution_step.
|
|
:param new_state: The new state to set.
|
|
:param evolution_step: The evolution_step index, to differ between concurrent states.
|
|
:return True if the state really changed.
|
|
"""
|
|
changed = self._set_new_state_if_valid(new_state, evolution_step)
|
|
self._dirty |= changed
|
|
self._active[self._calculate_slot(evolution_step)] = False
|
|
return changed
|
|
|
|
def _set_new_state_if_valid(self, new_state, evolution_step):
|
|
current_state = self.get_state_of_evolution_step(evolution_step)
|
|
if len(new_state) != len(current_state):
|
|
raise IndexError("State length may not change!")
|
|
|
|
self.__change_current_state_values(current_state, new_state)
|
|
return self.__did_state_change(evolution_step)
|
|
|
|
@staticmethod
|
|
def __change_current_state_values(current_state, new_state):
|
|
for i, ns in enumerate(new_state):
|
|
if current_state[i] != ns:
|
|
current_state[i] = ns
|
|
|
|
def __did_state_change(self, evolution_step):
|
|
for a, b in zip(self.get_state_of_evolution_step(evolution_step),
|
|
self.get_state_of_last_evolution_step(evolution_step)):
|
|
if a != b:
|
|
return True
|
|
return False
|
|
|
|
def get_state_draw_color(self, evolution_step):
|
|
""" When implemented should return the color representing the requested state.
|
|
:param evolution_step: Requested evolution_step.
|
|
:return: Color of the state as rgb tuple
|
|
"""
|
|
raise NotImplementedError
|
|
|
|
@classmethod
|
|
def _calculate_slot(cls, evolution_step):
|
|
return evolution_step % cls._state_save_slot_count
|
|
|
|
|
|
class SynchronousCellState(CellState):
|
|
"""
|
|
CellState version using shared values for multi processing purpose.
|
|
"""
|
|
def __init__(self, initial_state=(0., ), draw_first_state=True):
|
|
super().__init__(initial_state, draw_first_state)
|
|
self._state_slots = [RawArray(c_float, initial_state) for i in range(self.__class__._state_save_slot_count)]
|
|
self._active = [RawValue(c_bool, False) for i in range(self.__class__._state_save_slot_count)]
|
|
self._active[0].value = True
|
|
self._dirty = RawValue(c_bool, draw_first_state)
|
|
|
|
def set_active_for_next_evolution_step(self, current_evolution_step):
|
|
self._active[self._calculate_slot(current_evolution_step + 1)].value = True
|
|
|
|
def is_set_for_redraw(self):
|
|
return self._dirty.value
|
|
|
|
def was_redrawn(self):
|
|
self._dirty.value = False
|
|
|
|
def set_state_of_evolution_step(self, new_state, evolution_step):
|
|
changed = self._set_new_state_if_valid(new_state, evolution_step)
|
|
self._dirty.value |= changed
|
|
self._active[self._calculate_slot(evolution_step)].value = False
|
|
return changed
|