def __init__(self, tracking, number, size):
logger.info("Creating new Frame")
# the tracking process this frame is part of:
self.tracking = tracking
# number of this frame within the tracking process:
self.number = number
self.size = size
# state machine for this frame:
self.machine = transitions.Machine(
model=self,
states=self.module_states,
initial='created',
transitions=self.transitions,
name=self.__repr__(),
)
self.ground_truth = None
self.capture_image = None
self.previous_position = None
self.before_previous_position = None
self.roi = None
self.features = None
self.consolidated_features = None
self.predicted_position = None
self.prediction_quality = None
self.target_mask = None
self.result = None
self.lost = 0
self.updated = 'n'
self.mask_scale_factor = None
# state markers - only to be changed by state machine
self.did_reduction = False
def game(self):
game = DummyGame()
transitions.Machine(game,
states=State,
initial=State.Empty,
transitions=paulobot.game.GAME_TRANSITIONS,
send_event=True,
queued=True)
return game
def _InitStateMachine(self):
"""Initializes the internal state machine."""
self.machine = transitions.Machine(states=list(self.STATES),
initial='SPLASH',
send_event=True)
# Used to set our attributes from the Machine object
self.machine.SetEnv = self._SetEnv
self.machine.IncrementScoreIndex = self._scoreboard.IncrementIndex
self.machine.DecrementScoreIndex = self._scoreboard.DecrementIndex
self.machine.IncrementGlobalMenuIndex = self._global_menu.IncrementIndex
self.machine.DecrementGlobalMenuIndex = self._global_menu.DecrementIndex
# Transitions
# (trigger, source, destination)
self.machine.add_transition('back', '*', 'SCORE', before='SetEnv')
self.machine.add_transition('scan', '*', 'SCANNED', before='SetEnv')
self.machine.add_transition('error', '*', 'ERROR', before='SetEnv')
# TODO: check device "mode" ?
self.machine.add_transition('up',
'SCORE',
'SCORE',
after='DecrementScoreIndex')
self.machine.add_transition('down',
'SCORE',
'SCORE',
after='IncrementScoreIndex')
self.machine.add_transition('up', 'SPLASH', 'SCORE')
self.machine.add_transition('down', 'SPLASH', 'SCORE')
self.machine.add_transition('menu1', '*', 'MENUGLOBAL')
self.machine.add_transition('up',
'MENUGLOBAL',
'MENUGLOBAL',
after='DecrementGlobalMenuIndex')
self.machine.add_transition('down',
'MENUGLOBAL',
'MENUGLOBAL',
after='IncrementGlobalMenuIndex')
self.machine.add_transition('up', 'SPLASH', 'SCORE')
self.machine.add_transition('down', 'SPLASH', 'SCORE')
# Graphs
self.machine.add_transition('right', 'SCORE', 'GRAPH')
self.machine.add_transition('right', 'GRAPH', 'GRAPH')
self.machine.add_transition('left', 'GRAPH', 'SCORE')
self.machine.add_transition('up', 'ERROR', 'SCORE')
self.machine.add_transition('down', 'ERROR', 'SCORE')
self.machine.add_transition('left', 'ERROR', 'SCORE')
self.machine.add_transition('right', 'ERROR', 'SCORE')
self.machine.add_transition('menu1', 'MENUGLOBAL', 'SCORE')
self.machine.add_transition('menu2', '*', 'SCORE')
self.machine.add_transition('up', '*', '=')
self.machine.add_transition('down', '*', '=')
def __init__(self):
super().__init__()
file = QFile("mainwindow.ui")
file.open(QFile.ReadOnly)
self.ui = QUiLoader().load(file, self)
file.close()
self.machine = transitions.Machine(model=self,
states=["disconnected", "waiting", "placing", "aiming"],
initial='disconnected',
transitions=[{
"trigger": "get_aim",
"source": "waiting",
"dest": "aiming"
}, {
"trigger": "fire",
"source": "aiming",
"dest": "waiting"
}, {
"trigger": "get_place",
"source": "waiting",
"dest": "placing"
}, {
"trigger": "place",
"source": "placing",
"dest": "waiting"
}, {
"trigger": "server_connect",
"source": "disconnected",
"dest": "waiting",
"after": "on_connect"
}, {
"trigger": "server_disconnect",
"source": "*",
"dest": "disconnected",
"after": "on_disconnect"
}],
auto_transitions=False,
queued=True)
self.disconnect_event = asyncio.Event()
self.loop = asyncio.get_event_loop()
self.ui.connect_btn.clicked.connect(self.handle_connect_disconnect_btn)
self.ui.input_edit.returnPressed.connect(self.handle_input)
self.ui.execute_btn.clicked.connect(self.handle_input)
self.pusher_client = pysherasync.PusherAsyncClient(self.APP_KEY, cluster=self.CLUSTER)
self.client_task: Optional[asyncio.Task] = None
self.connection_ready = asyncio.Event()
self.pusher_socket = None
self.ui.show()
def __init__(self, light):
"""
Initialize the "left" LED in the blink1
:param light object: an instance of busylight to control the led switch
"""
self.light = light
self.colors = busyrgb()
self.machine = transitions.Machine(model=self,
states=self.states,
transitions=self.transitions,
initial='available')
def __init__(self, initial_state='starting', doctest_=False):
import dawgie.context
self.machine = transitions.Machine(model=self,
states=FSM.states,
initial=initial_state)
self.changeset = None
self.__doctest = doctest_
self.dot_file_name = "state.dot"
self.prior_state = initial_state
self.inactive_color = "white"
self.active_color = "green"
self.time_machine = None
self.__prior = None
self.priority = None
self.crew_thread = None
self.doing_thread = None
self.todo_thread = None
self.wait_on_crew = threading.Event()
self.wait_on_doing = threading.Event()
self.wait_on_todo = threading.Event()
self.reset()
self.wait_timeout = 0.001
self.nodes = {}
self.graph = pydot.graph_from_dot_file(
os.path.join(os.path.abspath(os.path.dirname(__file__)),
self.dot_file_name))
idir = os.path.abspath(
os.path.join(dawgie.context.fe_path, 'images/svg'))
if not os.path.isdir(idir): os.makedirs(idir)
fn = os.path.join(idir, 'state.svg')
self.graph.write_svg(fn)
for edge in self.graph.get_edges():
self.machine.add_transition(
**self.construct_attributes(edge.get_attributes()))
pass
for node in self.graph.get_nodes():
node.set_style("filled")
node.set_fillcolor(self.inactive_color)
self.nodes[node.get_name()] = node
pass
return
def __init__(self, metadata):
inports = {
"in": {},
"axis": {},
}
outports = {
"out": {},
}
super().__init__(inports, outports)
self.queued_data = deque()
self.machine = transitions.Machine(model=self,
states=['start', 'middle', 'end'],
initial='end')
self.machine.add_transition('begin_group',
'start',
'start',
before='pass_begin')
self.machine.add_transition('begin_group', 'end', 'start')
self.machine.add_transition('data',
'start',
'middle',
before='initialise_group')
self.machine.add_transition('data', 'middle', 'middle')
self.machine.add_transition('end_group',
'middle',
'end',
after='process_data')
self.machine.add_transition('end_group',
'end',
'end',
before='pass_end')
self.inports["in"].on("data", self.data)
self.inports["in"].on("beginGroup", self.begin_group)
self.inports["in"].on("endGroup", self.end_group)
self.inports["axis"].on("data", self.set_axis)
def __init__(self, pb, sport):
self._pb = pb
self._sport = sport
# Create the state machine
self._machine = transitions.Machine(None, states=State,
initial=State.Empty,
transitions=GAME_TRANSITIONS,
send_event=True, queued=False)
self._game_state_handlers = {
State.Empty: self._event_game_state_empty,
State.Quorate: self._event_game_state_quorate,
State.PlayerCheck: self._event_game_state_player_check,
State.PlayersNotReady: self._event_game_state_players_not_ready,
State.Rolling: self._event_game_state_rolling,
}
# Dictionary of gtime -> list of games.
# Don't use a defaultdict, to avoid bugs where code looks up
# a gtime that isn't present and ends up adding an empty list.
self._games = {}
self._reorg_in_progress = False
self._restore_in_progress = False
def fsm_runner():
# sub/pub channels in and from the GUI app
subs_channels = ['solver', 'config', 'arms_play']
pubs_channels = ['update']
subs = [
QueuePubSub(queues).subscribe(channel) for channel in subs_channels
]
# config for arms
config = {}
# finite state machine
rubiks = RubiksSolver(pubs_channels[0])
machine = transitions.Machine(model=rubiks,
states=['rest', 'reading', 'solving'],
initial='rest',
send_event=True)
# FSM's transitions
machine.add_transition(trigger='read',
source='rest',
dest='reading',
after='readcube')
machine.on_enter_reading('unblock_solve')
machine.add_transition(trigger='solve',
source='reading',
dest='solving',
conditions='is_finished',
after='solvecube')
machine.add_transition(trigger='success',
source='solving',
dest='rest',
conditions='is_finished',
after='block_solve')
machine.add_transition(trigger='stop',
source='*',
dest='rest',
after='block_solve')
machine.add_transition(trigger='command',
source='rest',
dest='=',
after='process_command')
while not stop_event.is_set():
for sub, channel in zip(subs, subs_channels):
try:
message = sub.get(block=False)
if channel == 'config':
if rubiks.state == 'rest':
config = message
logger.info(
'save/load button pressed (update solver configs)'
)
else:
logger.info(
'save/load button pressed, but not updating the solver configs because it\'s in rest state'
)
elif channel == 'solver':
msg = message.lower()
if 'read cube' == msg:
rubiks.read(config=config) # change state here
elif 'solve cube' == msg:
rubiks.solve() # change state here
elif 'stop' == msg:
rubiks.stop(hard=False) # change state here
elif 'cut power' == msg:
rubiks.stop(hard=True) # change state here
elif 'fix' == msg:
rubiks.command(
config=config, type='system',
action='fix') # reflexive state here
elif 'release' == msg:
rubiks.command(
config=config, type='system',
action='release') # reflexive state here
logger.info('\'' + msg + '\' button pressed')
elif channel == 'arms_play':
servo, pos = message
rubiks.command(config=config,
type='servo',
servo=servo,
pos=pos) # change state here
logger.info('rotate servo {} to position {}'.format(
servo, pos))
except Empty:
pass
except transitions.MachineError as error:
logger.warning(error)
# transition to rest from the solving state if the cube got solved
if rubiks.state == 'solving' and rubiks.is_finished(None):
rubiks.success()
logger.info('the rubik\'s cube got solved')
sleep(0.001)
def __init__(self, tracker, session):
Tracking._LAST_SERIAL += 1
self.serial = Tracking._LAST_SERIAL
logger.info("Creating new Tracking#%d", self.serial)
self.name = "tracking-%04d" % (self.serial)
self.tracker = tracker
self.configuration = tracker.configuration
self.initial_frame = None
self.current_frame = None
self.total_frames = 0
self.sample = None
self.tracking_log = []
# colour map function
self.cmap = matplotlib.cm.get_cmap("hot")
self.colours = {
'roi': 'cyan',
'ground_truth': 'green',
'prediction': 'yellow',
'candidate': 'magenta'
}
# size of capture image (determined on sample loading)
self.capture_size = None
# size of scaled ROI (= feature extractor input size)
self.sroi_size = tracker.sroi_size
# prediction/target mask size (=feature extractor / consolidator output
# size)
self.mask_size = tracker.mask_size
#
self.sroi_to_mask_ratio = (self.sroi_size[0] / self.mask_size[0],
self.sroi_size[1] / self.mask_size[1])
# create state machine for this tracking instance:
self.machine = transitions.Machine(
model=self,
states=self.states,
initial='created',
transitions=self.transitions,
name=self.__repr__(),
)
# timestamps
self.ts_loaded = None
self.ts_features_selected = None
self.ts_consolidator_trained = None
self.ts_tracking_completed = None
self.pursuing_total_seconds = 0.0
self.roi_calculation_total_seconds = 0.0
self.sroi_generation_total_seconds = 0.0
self.feature_extraction_total_seconds = 0.0
self.feature_reduction_total_seconds = 0.0
self.feature_consolidation_total_seconds = 0.0
self.se_total_seconds = 0.0
# updates
self.updates_max_frames = 0
self.updates_confidence = 0
# object holding module_states of tracker modules:
self.module_states = TrackerModuleStates()
if tracker.configuration['ros_node']:
from .RosPositionPublisher import RosPositionPublisher
self.publisher = RosPositionPublisher(
tracker.configuration['ros_node'])
else:
self.publisher = None
self.session = session
