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)