def make_west_door(self, next_screen):
"""Creates and places a trigger for the west door
that loads the next screen at the connecting east door"""
screen_trigger = Trigger(3, 0, 288)
screen_trigger.image = self.sprites_utu.sprites[1096].image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
screen_trigger = Trigger(3, 0, 320)
screen_trigger.image = self.sprites_utu.sprites[1096].image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
def make_north_door(self, next_screen):
"""Creates and places a trigger for the north door
that loads the next screen at the connecting south door"""
screen_trigger = Trigger(3, 352, 0)
screen_trigger.image = self.sprites_utu.sprites[1094].image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
screen_trigger = Trigger(3, 384, 0)
screen_trigger.image = self.sprites_utu.sprites[1094].image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
def make_south_door(self, next_screen):
"""Creates and places a trigger for the south door
that loads the next screen at the connecting north door"""
screen_trigger = Trigger(3, 352, 608)
screen_trigger.image = self.south_door_image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
screen_trigger = Trigger(3, 384, 608)
screen_trigger.image = self.south_door_image
self.drawables.append(screen_trigger)
self.collisions.append((screen_trigger, next_screen))
def __init__(self):
""" connect hardware, initialize state dir """
self.trigger = Trigger()
self.display = Display()
self.current_address = None
self.cost = 0
self.set_state(Vend.STARTUP)
def execute(bot, data, forward=True):
args = {
"peer_id": data['peer_id'],
"v": "5.60",
}
if forward:
args.update({"forward_messages": data['message_id']})
atts = data['attachments']
try:
photo = bot.GetBiggesPic(atts[0], data['message_id'])
except:
return False
req = urllib.request.Request(photo, headers=HDR)
img = urlopen(req).read()
Tmp = TempFile(img, 'jpg', NoCache=True)
args['message'] = 'Список фильтров:\n'
FArr = dict(enumerate(bot.MODULES.FILTERS))
for filter_ in FArr:
Fname = bot.MODULES.FILTERS[FArr[filter_]].desc
args['message'] += "{}. {}\n".format(filter_ + 1, Fname)
bot.Replyqueue.put(args)
print(data['user_id'], data['peer_id'])
t = Trigger(
cond=lambda Tdata: Tdata['user_id'] == data['user_id'] and Tdata[
'peer_id'] == data['peer_id'] and Tdata['message'].isnumeric(),
callback=Command_Filter.Render,
Tmp=Tmp,
bot=bot,
args=args,
FArr=FArr)
bot.TRIGGERS.addTrigger(t)
def main (args, app):
new_trigger = Trigger(name=args.name, then=' '.join(args.then))
if not args.preview:
new_trigger.store(app.config)
app.config.save( )
print "added", new_trigger.format_url( )
def read_map(game, m: str = 'map'):
with open(m, 'r') as m:
m = json.loads(m.read())
if 'Start' in m:
game.start = m['Start']
if 'Platforms' in m:
game.platforms.clear()
for p in m['Platforms']:
game.platforms.append(
Platform(*x_to_pixels(game, p['x1'], p['x2']),
*y_to_pixels(game, p['y1'], p['y2'])))
if 'Triggers' in m:
game.triggers.clear()
for t in m['Triggers']:
game.triggers.append(
Trigger(*x_to_pixels(game, t['x1'], t['x2']),
*y_to_pixels(game, t['y1'], t['y2']), t['enter'],
t['stay'], t['leave']))
if 'Windows' in m:
for w in game.windows.values():
w.close()
game.windows = {}
for w in m['Windows']:
win = Window(
w['name'],
w['effect'],
w['function'],
game,
style=pyglet.window.Window.WINDOW_STYLE_BORDERLESS,
width=x_to_pixels(game, w['width']),
height=y_to_pixels(game, w['height']),
visible=w['visible'])
game.windows[w['name']] = win
def _configure_triggers(self, data):
for trig in self._triggers:
trig.reset_configuration()
self._triggers.clear()
for elem in data:
# print(elem)
simvar = elem.get('simvar')
trigger_type = elem.get('trigger_type', None)
trigger_index = elem.get('trigger_index', None)
condition = elem.get('condition', None)
object_to_trigger = None
trigger = Trigger()
trigger.bind_to_simvar(simvar)
if trigger_type == "encoder":
object_to_trigger = self._encoders[trigger_index - 1]
trigger.bind_to_event(object_to_trigger.on_alternate)
elif trigger_type == "button":
object_to_trigger = self._buttons[trigger_index - 1]
elif trigger_type == "condition":
trigger.bind_to_event(ConditionalRunner(condition))
elif trigger_type == "condition-file":
trigger.bind_to_event(ConditionalRunner("", condition))
else:
raise ValueError(f"Unknown trigger type: {trigger_type}")
self._triggers.append(trigger)
def process(start_url):
u = url_manage(start_url)
w = Website()
process_func = w.qq_news_process
t = Trigger(slot)
trigger_func = t.url_trigger
p = post_proc("../data/result.csv")
post_proc_func = p.save_result_process
conf = SparkConf().setMaster("local[8]").setAppName("Crawler")
sc = SparkContext(conf=conf)
while 1:
if trigger_func(u):
urls = sc.parallelize(u.get_url_queue())
results = urls.map(process_func)
print results.collect()
for res, url in zip(results.collect(), urls.collect()):
print res, url
post_proc_func(res, url, u)
time.sleep(1)
sc.stop()
def decorator(trigger_function):
"""This takes the trigger's associated function as the only argument
It defines the decorator and wrapper, as well as setting up the 'Trigger' object and associating it with the decorated function.
"""
if 'name' not in t_kwargs: # No name for this trigger was provided; use trigger's function name
t_kwargs['name'] = trigger_function.__name__
# Create an instance of the 'Trigger' class
new_trigger = Trigger(
*t_args, **t_kwargs
) # provide all wrapper arguments to this 'trigger' instance
def wrapper(*args, **kwargs):
"""This function is what will be called in place of the decorated function;
It takes the arguments given to it and passes them on.
It needs to run said function and return what it does or (if it doesn't return anything), return the value of the stop_processing flag in the trigger class
"""
r = trigger_function(
*args, **kwargs) # call the original trigger function
return r or new_trigger.stop_processing
new_trigger.add_function(
wrapper) # Associate the wrapper with the trigger object
# add the trigger to an internal list
self.triggers.append(new_trigger)
return wrapper
def make_switch_collision(self, switch_group, image, starting_x, x_copies, starting_y, y_copies, function):
for x in range(x_copies):
for y in range(y_copies):
path_piece = Trigger(4, (starting_x*32) + (x*32), (starting_y*32) +(y*32))
path_piece.image = image
switch_group[0].add(path_piece)
switch_group[1].append((path_piece, function))
def make_collision(self, image, starting_x, x_copies, starting_y, y_copies, function):
for x in range(x_copies):
for y in range(y_copies):
collision = Trigger(3, (starting_x*32) + (32*x), (starting_y*32) + (32*y))
collision.image = image
self.drawables.append(collision)
self.collisions.append((collision, function))
def load_triggers(self):
logging.info("Loading triggers")
self.triggers = {}
n = 0
cn = 0
ec = [(c.name, c.id) for c in AlarmClass.objects.all()]
for t in AlarmTrigger.objects.filter(is_enabled=True):
logging.debug("Trigger '%s' for classes:" % t.name)
for c_name, c_id in ec:
if re.search(t.alarm_class_re, c_name, re.IGNORECASE):
try:
self.triggers[c_id] += [Trigger(t)]
except KeyError:
self.triggers[c_id] = [Trigger(t)]
cn += 1
logging.debug(" %s" % c_name)
n += 1
logging.info("%d triggers has been loaded to %d classes" % (n, cn))
def main():
'''
Test LED
Blink Red
Solid Red
Blink Green
Solid Green
Test Trigger
Push trigger
Hold trigger
Test Send fake IR code
Listen for callback
'''
led = LED()
print("Testing LEDs.\n")
eventOne = threading.Event()
threadOne = threading.Thread(name='ledOnRed', target=setLED, args=(eventOne, 'red', led, 1))
threadOne.start()
answer = input("Is the Red LED on? y/n: ")
eventOne.set()
if not answer.lower() == 'y': return False
eventTwo = threading.Event()
threadTwo = threading.Thread(name='ledBlinkRed', target=toggleLED, args=(eventTwo, 'red', led, 1))
threadTwo.start()
answer = input("Is the Red LED blinking? y/n: ")
# Get user input.
eventTwo.set()
if not answer.lower() == 'y': return False
eventThree = threading.Event()
threadThree = threading.Thread(name='ledOnGreen', target=setLED, args=(eventThree, 'green', led, 1))
threadThree.start()
answer = input("Is the Green LED on? y/n: ")
eventThree.set()
if not answer.lower() == 'y': return False
eventFour = threading.Event()
threadFour = threading.Thread(name='ledBlinkGreen', target=toggleLED, args=(eventFour, 'green', led, 1))
threadFour.start()
answer = input("Is the Green LED blinking? y/n: ")
# Get user input.
eventFour.set()
if not answer.lower() == 'y': return False
trigger = Trigger()
print("Push and hold the trigger for 10 events.")
i = 0
while i < 10:
if GPIO.input(trigger.TRIGGER) == GPIO.HIGH:
time.sleep(0.1)
print(("{}: Trigger detected.").format(datetime.datetime.now()))
i += 1
time.sleep(1)
print("LaserPi programmed remote codes:")
call(["irsend", "LIST", "laserpi", ""])
return True
def make_bridge(self):
"Creates the bridge once the player triggers it"
self.now = pygame.time.get_ticks()
if self.now - self.last_switch > 1000:
self.add_flag = True
bridge = []
for i in range(3):
for j in range(6):
bridge.append(league.DUGameObject)
bridge[i + j] = Trigger(3, 352 + (32 * i), 160 + (32 * j))
bridge[i + j].image = self.sprites_base.sprites[248].image
self.drawables.append(bridge[i+j])
self.last_switch = pygame.time.get_ticks()
def main():
trigger = Trigger(TriggerType.PROC_NAME, 'notepad.exe', custom)
# port_action = Action(TriggerType.CON_PORT, 443, custom)
# ip_action = Action(TriggerType.CON_IP, '23.213.175.172', custom)
lock = Locker(panic=False, panic_pass='******', debug=True) #set up your Locker
# lock.actions = port_action
# lock.actions = ip_action
# lock.private_exes = 'secret.exe' #append more exes
# lock.private_exes = ['slack.exe', 'excel.exe'] #lists are ok too
# lock.private_paths = '/user'
lock.triggers = trigger
lock.run()
def set_screen_cliffs(self):
"""Creates 'cliffs' screen"""
self.background = league.Tilemap('../assets/cliffs_background.lvl', self.sprites_utu, layer=1)
self.terrain = league.Tilemap('../assets/cliffs_terrain.lvl', self.sprites_base, layer=2)
self.details = league.Tilemap('../assets/cliffs_details.lvl', self.sprites_utu, layer=3)
self.drawables.append(self.background.passable.sprites())
self.drawables.append(self.terrain.passable.sprites())
self.drawables.append(self.details.passable.sprites())
"Loads north door sprites leading to 'lost woods entrance' south door"
self.make_north_door(self.lost_woods_entrance_door_south)
"Loads south door sprites leading to 'hills' north door"
self.make_south_door(self.grassland_door_north)
"Loads the switch sprite for the bridge"
bridge_switch = Trigger(3, 500, 480)
bridge_switch.image = self.sprites_base.sprites[70].image
self.drawables.append(bridge_switch)
self.collisions.append((bridge_switch, self.make_bridge))
bridge_switch = Trigger(3, 500, 50)
bridge_switch.image = self.sprites_base.sprites[70].image
self.drawables.append(bridge_switch)
self.collisions.append((bridge_switch, self.make_bridge))
"Makes the area where the bridge will be impassable. Removed by make_bridge to make passable"
bridge_block = []
for i in range(3):
for j in range(7):
bridge_block.append(league.DUGameObject)
bridge_block[i + j] = Trigger(1, 352 + (32 * i), 128 + (32 * j))
bridge_block[i + j].image = self.sprites_base.sprites[97].image
self.drawables.append(bridge_block[i + j])
self.blocking_object.add(bridge_block[i+j])
"Sets update() to change screens"
self.change_flag = True
def __init__(self, useRPi):
"""
:param useRPi: Flag for using Raspberry pi or pc
"""
threading.Thread.__init__(self)
self._useRPi = useRPi
# Instantiates subsystems
self._camera = Camera(self._useRPi)
self._processor = Processor(self)
self._trigger = Trigger(self._useRPi)
self._imageregister = Imageregister()
# Mask handling flags
self._applymask = False
self._invertedmask = False
self._binarymask = False
self.savemaskedon = False
def create_room(self, x=1, y=1):
room = Room(self.room_size)
for i in range(self.room_size):
block_width = self.width
block_height = self.height
block_x = (x * self.room_size + i * i) * block_width
block_y = round((i * math.sin(y * self.room_size + i) *
block_width) +
(y * self.room_size + 0) * block_height)
room.blocks.append(
Block(block_x, block_y, block_width, block_height,
'/images/ground.png').convert_to_json())
block_x = (x * self.room_size + i) * block_width
block_y = round((random.randint(0, self.room_size) *
math.sin(y * self.room_size + i) * block_width) +
(y * self.room_size + 0) * block_height)
room.blocks.append(
Block(block_x, block_y, block_width, block_height,
'/images/ground.png').convert_to_json())
block_x = random.randint(x * block_width,
x * self.room_size * block_width)
block_y = random.randint(y * block_width,
y * self.room_size * block_width)
room.blocks.append(
Bonus(block_x, block_y, block_width,
block_height).convert_to_json())
block_x = random.randint(x * block_width,
x * self.room_size * block_width)
block_y = random.randint(y * block_width,
y * self.room_size * block_width)
teleport = Trigger(block_x, block_y, block_width, block_height,
"teleport")
room.blocks.append(teleport.convert_to_json())
return {'blocks': room.blocks}
def __init__(self,
name: str,
effect,
fcn: Union[str, None],
game,
*args,
visible=True,
**kwargs):
super().__init__(*args, **kwargs)
self.game = game
self.set_visible(visible)
self.set_caption(name)
self.set_location(0, 0)
self.x1 = self.get_location()[0]
self.x2 = self.get_location()[0] + self.width
self.y1 = self.get_location()[1]
self.y2 = self.get_location()[1] + self.height
self.name = name
self.color = effects[effect[0]][1]
self.effect = lambda game, obj, state: effects[effect[0]][0](
game, obj, state, **effect[1])
self.trigger = Trigger(self.x1,
self.x2,
self.y1,
self.y2,
enter=('effect', {
'effect': self.effect,
'state': 'enter'
}),
stay=('effect', {
'effect': self.effect,
'state': 'stay'
}),
leave=('effect', {
'effect': self.effect,
'state': 'leave'
}))
if effect != 'None': self.game.triggers.append(self.trigger)
self.moving = False
self.on_close = lambda: None
self.fcn = lambda game: movements[fcn[0]](game, **fcn[1]) if fcn[
0] else movements['static'](game)
def execute(bot, data, forward=True):
args = {
"peer_id": data['peer_id'],
"v": "5.60",
}
if forward:
args.update({"forward_messages": data['message_id']})
atts = data['attachments']
if 'size' in data['custom']:
x = int(data['custom']['size'])
if x > 3000:
args['message'] = "Неее, слишком жирно"
bot.Replyqueue.put(args)
return False
else:
args['message'] = "Размер не указан"
bot.Replyqueue.put(args)
return False
Topost = []
for att in atts:
try:
photo = bot.GetBiggesPic(att, data['message_id'])
except:
return False
req = urllib.request.Request(photo, headers=HDR)
img = urlopen(req).read()
Tmp = TempFile(img, 'jpg', NoCache=True)
args['message'] = 'Поднимать резкость?\n Да\Нет'
bot.Replyqueue.put(args)
ans = bot.WaitForMSG(5, data)
t = Trigger(cond=lambda Tdata: Tdata['user_id'] == data[
'user_id'] and Tdata['peer_id'] == data['peer_id'] and
(re.match(r'(Д|д)а', Tdata['message']) or re.match(
r'(Н|н)ет', Tdata['message'])),
callback=Command_Resize.resize,
Tmp=Tmp,
bot=bot,
args=args)
bot.TRIGGERS.addTrigger(t)
def set_attack_enemy_stepping_next_to_me(entity):
trigger_effect = Composite("set_attack_enemy_stepping_next_to_me")
trigger_effect.set_child(Trigger([ENEMY_STEPPING_NEXT_TO_ME_TRIGGER_TAG]))
trigger_effect.set_child(AttackEnemyTriggeredEffect(DataTypes.DEFENCIVE_ATTACK_CHANCE))
entity.set_child(trigger_effect)
def set_attack_enemy_i_step_next_to(entity):
trigger_effect = Composite("attack_enemy_i_step_next_to")
trigger_effect.set_child(Trigger([STEP_NEXT_TO_ENEMY_TRIGGER_TAG]))
trigger_effect.set_child(AttackEnemyTriggeredEffect(DataTypes.OFFENCIVE_ATTACK_CHANCE))
entity.set_child(trigger_effect)
def set_counter_attack(entity):
trigger_effect = Composite("counter_attack")
trigger_effect.set_child(Trigger([ON_ATTACKED_TRIGGER_TAG]))
trigger_effect.set_child(AttackEnemyTriggeredEffect(DataTypes.COUNTER_ATTACK_CHANCE))
entity.set_child(trigger_effect)
PHOTOBOOTH_HTML_ROOT = Path("/var/www/html")
PHOTOBOOTH_IMG_FOLDER = PHOTOBOOTH_HTML_ROOT / Path("data/images")
PHOTOBOOTH_AI_FOLDER = PHOTOBOOTH_HTML_ROOT / Path("data/ai")
logger = Logger(__name__, level="DEBUG")
logger.addFileHandler(filename='/var/log/flask/api.log', level="DEBUG")
log = logger.getLogger()
socketio = SocketIO(async_mode='eventlet')
login_manager = LoginManager()
event_pool = eventlet.GreenPool(5)
# photobooth controller
ledpanel = LEDpanelControl()
trigger = Trigger(ledpanel=ledpanel, logger=log)
facerecognition = FaceRecognition()
# photobooth globals
GLOBALS = {'trigger_lock': None}
def create_app(debug=False):
# create the app
app = Flask(__name__)
app.config.from_object(__name__)
# enable CORS
CORS(app, resources={r'/*': {'origins': '*'}})
# register blueprints
PUNCH = 'punch'
TRANSLATE = 'translate'
SKIP = 'skip'
FACT = 'fact'
FIGHT = 'fight'
PING = 'ping'
SAY_HI = 'say_hi_albert'
COMPANY = 'company'
DEBUG = 'debug'
messages: Dict[MessagesType, Trigger] = {
MessagesType.PUNCH:
Trigger(chance=50,
command='punch',
condition=[only_user(['eromanoskij']),
timer_minutes(2880)],
text=lambda: random.choice(config.phrases),
bot_type='reply'),
MessagesType.FACT:
Trigger(chance=50,
command='fact',
condition=[
only_user(['eromanoskij']),
text_contains([
'беларус', 'минск', 'лукашенк', 'картош', 'картоха',
'мiнск', 'минcк', 'минсk'
]),
timer_minutes(1440),
],
text=get_fact,
bot_type='reply'),
#imports
import os, datetime, time
from gun import Gun
from trigger import Trigger
from led import LED
import lirc
from time import sleep
#prog defined in ~/.lircrc
prog = "guns"
try:
sockid = lirc.init(prog, blocking=False)
trigger = Trigger()
trigger.addTrigger()
gun = Gun()
led = LED()
hp = 3
if (not gun.readIDFile()): quit()
inGame = False
while True:
while not inGame:
joined = gun.joinGame()
if joined:
inGame = True
hp = 3
led.toggleLED('red')
sleep(0.5)
while inGame:
if hp == 3:
led.toggleLED('green')
#########################################################################
######################################
# Initialize screen, logger and inputs
logging.basicConfig(
level=CONF["loggingLevel"],
format='%(asctime)s-%(levelname)s-%(message)s',
) # This is a log for debugging the script, and prints messages to the terminal
# needs to be first, so that if it doesn't succeed, it doesn't freeze everything
eyetracker = PupilCore(ip=CONF["pupillometry"]["ip"],
port=CONF["pupillometry"]["port"],
shouldRecord=CONF["recordEyetracking"])
trigger = Trigger(CONF["trigger"]["serial_device"], CONF["sendTriggers"],
CONF["trigger"]["labels"])
screen = Screen(CONF)
datalog = Datalog(OUTPUT_FOLDER=os.path.join(
'output', CONF["participant"] + "_" + CONF["session"],
datetime.datetime.now().strftime("%Y-%m-%d")),
CONF=CONF) # This is for saving data
kb = keyboard.Keyboard()
mainClock = core.MonotonicClock() # starts clock for timestamping events
alarm = sound.Sound(os.path.join('sounds', CONF["instructions"]["alarm"]),
stereo=True)
def execute_lines(line_mgr,
env,
executing_constructor=False,
supplied_hooks=None):
"""
Executes lines of code in a given environment.
"""
prgm_counter = 0
cond_flag = False
env.line_mgr = line_mgr
line_mgr.classify_statements()
while prgm_counter < len(line_mgr):
env.prgm_counter = prgm_counter
line = line_mgr[prgm_counter]
directive = execute_statement(line_mgr.get_line_data(prgm_counter),
executing_constructor, env)
if directive is not None:
if directive[0] == ':cond':
cond_flag = eval_parentheses(directive[1], env)
prgm_counter += 1
elif directive[0] == ':j':
prgm_counter = int(directive[1])
elif (cond_flag and directive[0] == ':jt') or \
((not cond_flag) and directive[0] == ':jf'):
prgm_counter = int(directive[1])
elif directive[0] == ':inc':
var_name = directive[1]
env.update_numeric(var_name, 1)
prgm_counter += 1
elif directive[0] == ':dec':
var_name = directive[1]
env.update_numeric(var_name, -1)
prgm_counter += 1
elif directive[0] == ':skiptoelse':
# Nothing was thrown in this try clause
_, j = find_next_end_else(line_mgr, prgm_counter + 1, False)
prgm_counter = j + 1
elif directive[0] == ':hook':
env.activate_hook(directive[1], supplied_hooks)
prgm_counter += 1
elif directive[0] == 'return':
if directive[1] == 'this':
# Create a user-defined object.
# Do not use env.pop() because the function
# will automatically remove the stack frame
# upon completion.
obj = env.last()
# Allow the object to refer to itself
# TODO : assign the 'this' variable at the start
# of scope creation, not when it is returned.
obj['this'] = obj
for key, method in obj.items():
if key == '$eq' and method.__class__ is function.Function and env.has_hook(
method):
# Methods must remember the environment of the object
# where they were defined.
obj[key] = method.supply(env)
return obj
else:
value = eval_parentheses(directive[1], env)
# Functions that were defined in the current scope
# using a 'sub' statement or 'func' statement
# must be supplied with the current environment,
# so that closures work correctly.
# This does not apply to functions that were passed
# in as an argument, or functions produced by other means.
# In other words, existing function objects should not
# be re-supplied with the current environment, only newly
# created ones.
if function.is_function(value) and env.has_hook(value):
# TODO : instead of supplying an environment when a defined
# function is returned, supply it when the function is first
# defined. This will allow for more complex return values,
# such as a list of functions, to operate correctly as closures.
value = value.supply(env)
return value
elif directive[0] == 'try':
env.exception_push(prgm_counter)
prgm_counter += 1
elif directive[0] == 'throw':
mirage = 'mirage'
if len(directive) == 2 and (directive[1].startswith(mirage + ' ') or \
directive[1].startswith(mirage + '\t')):
constructor_call = directive[1][len(mirage) + 1:].lstrip()
directive[1] = constructor_call
i = constructor_call.find('(')
if i == -1:
throw_exception_with_line(
'InvalidSyntax',
'mirage keyword must be followed by a constructor call',
line_mgr, prgm_counter)
class_name = constructor_call[:i]
new_class = None
class_body = [
'$type="{0}"'.format(class_name), 'return this'
]
if i + 1 < len(constructor_call) and constructor_call[
i + 1] == ')':
# No arguments
new_class = function.Function(class_name, [],
class_body)
else:
# 1 argument
new_class = function.Function(class_name, ['message'],
class_body)
env.frames[0][class_name] = new_class
# TODO : this class should inherit from Exception, not Object.
env.new_type(['Object'], class_name)
last_prgm_counter = prgm_counter
prgm_counter = env.exception_pop()
if prgm_counter is None:
throw_exception_with_line(
'UncaughtException',
'Thrown value ' + str(directive[1:]), line_mgr,
last_prgm_counter)
else:
original_counter = prgm_counter
# Look for a matching catch statement
prgm_counter = find_catch(directive, line_mgr,
prgm_counter, env)
if prgm_counter is None:
# We can't find a catch statement.
# Let the exception bubble up from its current scope.
env.exception_push(original_counter)
return Trigger(directive[1])
elif directive[0] in ['catch', 'else']:
kind, j = find_next_end_else(line_mgr, prgm_counter + 1, True)
# Travel to the next end
prgm_counter = j + 1
elif directive[0] == 'end':
# This is an isolated end statement. Ignore it.
prgm_counter += 1
else:
prgm_counter += 1
else:
prgm_counter += 1
# All functions should return something,
# which is null for 'void' functions.
return None
# Autor: Albert Schürer
"""Main Programm, welches alle Bauteile (Trigger, Kamera, Bildverarbeitung) vereint"""
import ctypes as C
import cv2
import time
import serial
from isCamera import ISCamera
import tisgrabber as IC
import numpy as np
from trigger import Trigger
import datetime
print('#########################',datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S'),'################################')
#Trigger
trig = Trigger()
trig.resetSettings()
trig.singleTriggerSettings()
trig.settingsShutterClosed()
#Kamera hier erstellen und Einstellungen vornehmen
icCam = ISCamera()
icCam.printParams()
#Einstellung der Dateipfae zum Laden und Abspeichern von Bildern
imagePath = 'O:\\ou-mt\\Mitarbeiter\\Albert\\Pictures\\'
filecounter = 0
#Callbackfunction for Trackbars:
def setGain(x):
gain=cv2.getTrackbarPos('Gain','OptionWindow')
icCam.setGain(gain)
