def handle_new_player_msg(self, msg): self.his_id = int(msg[1]) if self.his_id == 0: self.his_head = Head(self.his_id, self.game_path.p0path, self.width, self.height, self.my_head) elif self.his_id == 1: self.his_head = Head(self.his_id, self.game_path.p1path, self.width, self.height, self.my_head) self.my_head.stranger = self.his_head self.head_group.add(self.his_head)
def handle_id_msg(self, msg): self.id = int(msg[1]) if self.id == 0: self.my_head = Head(self.id, self.game_path.p0path, self.width, self.height, self.his_head) elif self.id == 1: self.my_head = Head(self.id, self.game_path.p1path, self.width, self.height, self.his_head) self.head_group.add(self.my_head) msg_out = ('balls ' + ' '.join( str(self.my_head.ball_list[i]) for i in range(len(self.my_head.ball_list))) + '\n') self.send_msg(msg_out)
def reset(): global data, score, snakeHead, isPlaying, isApple score = 0 for i in range(48): data[i] = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0] isApple = False snakeHead = Head((0, 149, 238),(mapWidth/2, mapHeight/2), pps)
def __init__(self, color=colors.skins_snake, name=0): ''' Создает новую змею в случайном месте, длиной 50 шариков. Координатой змеи считаются координаты центра головы. ''' ''' Не готово: 1) Имя змеи ''' if color == colors.skins_snake: self.colors = random.choice(colors.skins_snake) else: self.colors = color self.num = len(self.colors) self.name = name self.energy = 0 self.x = 500 self.y = 500 self.coords = Vector2d(self.x, self.y) self.r = 5 config.snake_radius = self.r self.length = 0 self.life = 1 self.balls = [] head = Head(color=self.colors[0], x=self.x, y=self.y) self.balls += [head] self.length += 1 for i in range(9): color = self.colors[(i + 1) % self.num] new_ball = Ball(x=self.x, y=self.y, color=color, r=5) self.balls += [new_ball] self.length += 1 self.energy = self.length self.speed_timer = 0
def testParseBytesToBytes(self): # b'DB\x04\x00\x00\x00\x00\x00\x00\x00ABCD1997' parser = Parser(BYTES_ENCODED) parser_test_function(self, parser=parser, code="D", dtype="B", length=4, payload=b'ABCD', remaining=0) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head=head, code="D", dtype="B", length=4, remaining=0) payload = Payload(data=parser.payload, dtype=parser.dtype, length=parser.length) payload_test_function(self, payload=payload, data=b'ABCD', dtype="B", length=4)
def testParseBytesToInt(self): parser = Parser(INT_ENCODED) parser_test_function(self, parser=parser, code="D", dtype="I", length=2, payload=257, remaining=256) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head=head, code="D", dtype="I", length=2, remaining=256) payload = Payload(data=parser.payload, dtype=parser.dtype, length=parser.length) payload_test_function(self, payload=payload, data=257, dtype="I", length=2)
def testParseBytesToStr(self): # b'DS\x04\x00\x00\x00\x00\x00\x00\x00ABCD1997' parser = Parser(data=STR_ENCODED) parser_test_function(self, parser=parser, code="D", dtype="S", length=4, payload="ABCD", remaining=0) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head=head, code="D", dtype="S", length=4, remaining=0) payload = Payload(data=parser.payload, dtype=parser.dtype, length=parser.length) payload_test_function(self, payload=payload, data="ABCD", dtype="S", length=4)
def testParseHandshakeToBytes(self): parser = Parser(HANDSHAKE_ENCODED) parser_test_function(self, parser=parser, code="H", dtype="B", length=0, payload=b"", remaining=0) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head=head, code="H", dtype="B", length=0, remaining=0) payload = Payload(data=parser.payload, dtype=parser.dtype, length=parser.length) payload_test_function(self, payload=payload, data=b"", dtype="B", length=0)
def __init__(self, simulation=True): """Initializes various aspects of the Fetch. TODOs: get things working, also use `simulation` flag to change ROS topic names if necessary (especially for the cameras!). UPDATE: actually I don't think this is necessary now, they have the same topic names. """ rospy.init_node("fetch") self.arm = Arm() self.arm_joints = ArmJoints() self.base = Base() self.camera = RGBD() self.head = Head() self.gripper = Gripper(self.camera) self.torso = Torso() self.joint_reader = JointStateReader() # Tucked arm starting joint angle configuration self.names = ArmJoints().names() self.tucked = [1.3200, 1.3999, -0.1998, 1.7199, 0.0, 1.6600, 0.0] self.tucked_list = [(x, y) for (x, y) in zip(self.names, self.tucked)] # Initial (x,y,yaw) position of the robot wrt map origin. We keep this # fixed so that we can reset to this position as needed. The HSR's # `omni_base.pose` (i.e., the start pose) returns (x,y,yaw) where yaw is # the rotation about that axis (intuitively, the z axis). For the base, # `base.odom` supplies both `position` and `orientation` attributes. start = copy.deepcopy(self.base.odom.position) yaw = Base._yaw_from_quaternion(self.base.odom.orientation) self.start_pose = np.array([start.x, start.y, yaw]) self.TURN_SPEED = 0.3 self.num_restarts = 0
def __init__(self, simulation=True): """Initializes various aspects of the Fetch.""" rospy.init_node("fetch") rospy.loginfo("initializing the Fetch...") self.arm = Arm() self.arm_joints = ArmJoints() self.base = Base() self.camera = RGBD() self.head = Head() self.gripper = Gripper(self.camera) self.torso = Torso() self.joint_reader = JointStateReader() # Tucked arm starting joint angle configuration self.names = ArmJoints().names() self.tucked = [1.3200, 1.3999, -0.1998, 1.7199, 0.0, 1.6600, 0.0] self.tucked_list = [(x,y) for (x,y) in zip(self.names, self.tucked)] # Initial (x,y,yaw) position of the robot wrt map origin. We keep this # fixed so that we can reset to this position as needed. The HSR's # `omni_base.pose` (i.e., the start pose) returns (x,y,yaw) where yaw is # the rotation about that axis (intuitively, the z axis). For the base, # `base.odom` supplies both `position` and `orientation` attributes. start = copy.deepcopy(self.base.odom.position) yaw = Base._yaw_from_quaternion(self.base.odom.orientation) self.start_pose = np.array([start.x, start.y, yaw]) rospy.loginfo("...finished initialization!")
def __init__(self, config): self.replica_count = config.replica_count self.head = Head(config.init_object) self.tail = Tail(config.init_object) # create inner_replicas with chains inner_replicas = [Replica(config.init_object) * self.replica_count] self.replicas = [head] + inner_replicas + [tail] pass
def __init__(self, N, M, in_size, out_size, batch_size, lstm=False): super(NTM, self).__init__() if lstm: self.controller = LSTMController(in_size, out_size, M, batch_size) else: self.controller = FeedForwardController(in_size, out_size, M, batch_size) self.read_head = Head(batch_size, N, M) self.write_head = Head(batch_size, N, M) self.batch_size = batch_size self.N = N self.M = M self.eps = 1e-8 self.memory = None self.register_parameter('memory_bias', nn.Parameter(torch.randn(1, N, M) / math.sqrt(N)))
def instantiate_objects(): """After connection has been made, instatiate the various robot objects """ global perm_dir_path global dir_path logger.debug('instantiate_objects called') #get default json file def_start_protocol = FileIO.get_dict_from_json( os.path.join(dir_path, 'data/default_startup_protocol.json')) #FileIO.get_dict_from_json('/home/pi/PythonProject/default_startup_protocol.json') #instantiate the head head = Head(def_start_protocol['head'], publisher, perm_dir_path) logger.debug('head string: ') logger.debug(str(head)) logger.debug('head representation: ') logger.debug(repr(head)) #use the head data to configure the head head_data = {} head_data = prot_dict['head'] #extract the head section from prot_dict logger.debug("Head configured!") #instantiate the script keeper (sk) #instantiate the deck deck = Deck(def_start_protocol['deck'], publisher, perm_dir_path) logger.debug('deck string: ') logger.debug(str(deck)) logger.debug('deck representation: ') logger.debug(repr(deck)) runner = ProtocolRunner(head, publisher) #use the deck data to configure the deck deck_data = {} deck_data = prot_dict['deck'] #extract the deck section from prot_dict # deck = RobotLib.Deck({}) #instantiate an empty deck deck.configure_deck(deck_data) #configure the deck from prot_dict data logger.debug("Deck configured!") #do something with the Ingredient data ingr_data = {} ingr_data = prot_dict[ 'ingredients'] #extract the ingredient section from prot_dict ingr = Ingredients({}) ingr.configure_ingredients( ingr_data) #configure the ingredienets from prot_dict data logger.debug('Ingredients imported!') publisher.set_head(head) publisher.set_runner(runner) subscriber.set_deck(deck) subscriber.set_head(head) subscriber.set_runner(runner)
def init(self): self.tray = Tray(self) self.head = Head(self) self.agenda = Agenda(self) self.set = Set(self) # qss with open('style.QSS', 'r') as fp: self.setStyleSheet(fp.read()) fp.close()
def __init__ (self): rospy.Subscriber("/head_camera/rgb/image_raw",Image,self.RGBImageCallback) rospy.Subscriber("/head_camera/depth_registered/image_raw",Image,self.DepthImageCallback) rospy.Subscriber("/ar_pose_marker",AlvarMarkers,self.GetArPosesCallBack) self.bridge = CvBridge() self.Arm = Arm() self.Gripper = Gripper() self.Head = Head() self.PoseProcessing = PoseProcessing()
def init(self): PlayState.TICK_LENGTH = 0.1 self.tick_time = 0 self.head = Head(PlayState.GRID_SIZE) self.body = [] for i in range(PlayState.INITIAL_BODY_SIZE): self.__add_body__() self.food = Food(PlayState.GRID_SIZE, self.head.pos) self.hud = HUD() pass
def webControl(x, y): x = int(x) y = int(y) usrMsgLogger = DataLogger() evobot = EvoBot("/dev/tty.usbmodemfa131", usrMsgLogger) head = Head(evobot) syringe = Syringe(evobot, 9) syringe.plungerSetConversion(1) evobot.home() head.move(x, y)
def __init__(self, content: Union[bytes, str, int] = b'', code: str = "default", remaining: int = 0, encoded: bytes = None): if encoded: self.parser = Parser(encoded) self.head = Head(code=self.parser.code, dtype=self.parser.dtype, length=self.parser.length, remaining=self.parser.remaining) self.payload = Payload(data=self.parser.payload, dtype=self.parser.dtype, length=self.parser.length) self.end_of_package = self.parser.eop else: self.payload = Payload(content) self.head = Head(code=code, dtype=self.payload.dtype, length=self.payload.length, remaining=remaining) self.end_of_package = self.get_end_of_package() self.encoded = self.get_encoded()
def testParseCorruptedStreamToBytes(self): parser = Parser(CORRUPTED_STREAM) parser_test_function(self, parser=parser, code="E", dtype="B", length=0, payload=b"", remaining=0) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head, "E", "B", 0, 0, b'EB\00\00\00\00\00\00\00\00')
def testParseBytesToError(self): parser = Parser(ERROR_ENCODED) parser_test_function(self, parser=parser, code="E", dtype="B", length=0, payload=b"", remaining=0) head = Head(code=parser.code, dtype=parser.dtype, length=parser.length, remaining=parser.remaining) head_test_function(self, head, "E", "B", 0, 0, b'EB\00\00\00\00\00\00\00\00')
def run_game(): # initiate game pygame.init() ai_settings = Settings() screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption("Snake") # set up the original images of all necessary body parts image_source = ImageSource() # the bodies already attached to the head bodies = Group() # the bodies NOT attached to the snake and to be eaten by the snake foods = Group() # generate a head head = Head(screen, ai_settings, image_source, bodies) # record game statistics filename = 'high_score.txt' stats = GameStats(filename) # record a list of messages that will be shown at the beginning and end of game msgs = [] gf.create_msgs(msgs, stats) # use clock to control fps clock = time.Clock() # main game loop while True: gf.check_events(screen, ai_settings, image_source, bodies, head, foods, stats, filename) if ai_settings.game_active: gf.update_head(head, foods, bodies, screen, ai_settings, image_source, stats) # update the location of snake body bodies.update() # update msgs that will show when game ends gf.update_msgs(msgs, stats) # snake speed will be controlled by frame rate clock.tick(ai_settings.fps) else: if head.dead: # show msg when game ends button = Button(screen, ai_settings, msgs, True) else: # show msg before game starts button = Button(screen, ai_settings, msgs, False) gf.update_screen(bodies, foods, ai_settings, screen, head, button)
def main(): '''Main function of Snake.''' pygame.init() ai_settings = Settings() screen = pygame.display.set_mode((ai_settings.screen_width, ai_settings.screen_height)) pygame.display.set_caption('Snake') head = Head(ai_settings, screen) while True: # Check events gf.check_events() # head.update() # Update the items drawn on the screen screen.fill(ai_settings.bg_color) head.draw_head() pygame.display.flip()
def __init__(self, torso_center, lower_body_flag): self._body_center = torso_center self._lower_body_flag = lower_body_flag self.head = Head( Point(torso_center.x, torso_center.y + 15, torso_center.z)) self.torso = Torso( Point(torso_center.x, torso_center.y, torso_center.z)) self.left_arm = Arm( Point(torso_center.x + 6.6, torso_center.y + 8, torso_center.z)) self.right_arm = Arm( Point(torso_center.x - 6.6, torso_center.y + 8, torso_center.z)) self.right_arm.set_slocal_rotate_angle(180, 0, 0) if self._lower_body_flag: self.left_leg = Leg( Point(torso_center.x + 4, torso_center.y - 10.6, torso_center.z)) self.right_leg = Leg( Point(torso_center.x - 4, torso_center.y - 10.6, torso_center.z)) self.right_leg.set_hlocal_rotate_angle(180, 0, 0)
def build(self, robot_type): """Builds a robot object. Returns: Robot. A robot object. """ # Interface interface = Interface(robot_type) # Navigation tf_listener = tf.TransformListener() location_db = LocationDb('location_db', tf_listener) navigation = Navigation(robot_type, location_db, tf_listener) # Speech and sounds sound_db = SoundDb('sound_db') for i in range(10): sound_db.set('sound' + str(i + 1)) voice = Voice(sound_db) command_db = CommandDb('command_db') speech_monitor = SpeechMonitor(command_db) # Head # TODO: Head action database? if robot_type == RobotType.PR2: head = Head() else: head = None # Arms # TODO: Arm action database? # TODO: Arm action execution #arms = Arms() robot = Robot(robot_type, interface, navigation, voice, head, speech_monitor, tf_listener) return robot
def __init__(self): # Set up logger to log to screen self.log = createLogger() # Construction self.numLegs = 0 # number of legs - start with none self.legPairs = [] # start with no legs (they will be added later) self.head = Head(self.interrupt, self.log) self.leftAntenna = Button(6) self.rightAntenna = Button(12) self.voicePin = 16 GPIO.setup(self.voicePin, GPIO.OUT) self.pwm = GPIO.PWM(self.voicePin, 1000) # Robot health (not used at the moment) # Can use these to determine behaviour, e.g. slowing down as energy drops self.alertness = 120 self.energy = 1000 self.age = 0 # Helper objects, to idenntify legs and threads self._legs = {} # dictionary to quickly find legs self._threads = {} # dictionary to quickly find threads # Actions will run on a thread self._actionThread = None # thread on which current action is running self._threadCount = 0 # so we can track threads self._stopped = False # flag to indicate if we want the animal to stop what it is doing (i.e. stop current thread) # Antennae handlers - called when antenna triggered self.leftAntenna.when_pressed = self._leftAntennaPressed self.rightAntenna.when_pressed = self._rightAntennaPressed # Caller can register a callback to receive messages (for display purposes) self.messageCallback = None self.log.info("Created Animal")
def callback(msg): global avatars msg_json = json.loads(msg) if "hasAvatar" in msg_json: user = extract_user_id(msg_json["object_id"]) if msg_json["hasAvatar"]: if user not in avatars: avatars[user] = Head(user) avatars[user].rig_on() else: if user in avatars: avatars[user].rig_off() del avatars[user] elif "hasFace" in msg_json and msg_json["hasFace"]: user = extract_user_id(msg_json["object_id"]) if user in avatars and avatars[user].rig_enabled: if not avatars[user].has_face: avatars[user].add_face(msg_json) else: avatars[user].update_face(msg_json)
def __init__(self, head, structure, morphology={}): if (sys.version_info > (3, 0)): # Python 3 self.new_python = True else: # Python 2 self.new_python = False self.parent = None self.head = Head(head, structure["head"]) self.components = copy.deepcopy(structure["components"]) if self.components is None: self.components = {} self.order = ["head"] else: self.order = copy.deepcopy(structure["order"]) if "agreement" in structure: self.agreement = copy.deepcopy(structure["agreement"]) else: self.agreement = {} if "governance" in structure: self.governance = copy.deepcopy(structure["governance"]) else: self.governance = {} self.morphology = copy.deepcopy(morphology)
if __name__ == '__main__': sleep_time = 20 if len(sys.argv) > 2: _TOKEN_ = sys.argv[1] _MASTER_ID_ = sys.argv[2] if len(sys.argv) > 3 and sys.argv[3] == 'no-wait': sleep_time = 0 time.sleep(sleep_time) if _MASTER_ID_ and _TOKEN_: bot = None while True: try: bot = telepot.Bot(_TOKEN_) _HEAD_ = Head(bot) bot.message_loop(handle) print('Listening ...') say_hi() break except: print("error... retrying in {0} seconds".format(sleep_time)) time.sleep(sleep_time) # Keep the program running. while True: pass print('exiting...')
def __init__(self, root, sizeX, sizeY, title): super().__init__(root) # self.pack(expand='no', fill='both') self.root = root self.state_ = False root.wm_title(title) root.focus_force() self.img_ = create_img() self.pack(expand=True, fill=tk.BOTH) set_application_icons(root, 'ico') # imgdir self.path = pathlib.Path(cwddir) path_ = self.path.joinpath( 'Проекты') # каталог для файлов конвертора 'project' if not path_.exists(): os.mkdir(path_) self.b = {} # контейнер для виджетов self.dir_cvt = path_ self._zona = config.getfloat('System', 'vzona') self._opgl = 0 self.mb = config.getboolean('Amplituda', 'mb') # 1 - RGB # fxen = dict(fill=tk.X, expand=False) (self.glub_var, self.stop_var, self.time_var, self.numstr_var, self.ampl_var, self.skale_var, self.porog_var, self.frek_var) = (tk.StringVar() for _ in range(8)) self.tol_bar = Toolbar(self, bso_) # объект tolbar self.tol_bar.pack(fill=tk.X, expand=False) # ttk.Separator(self).pack(**fxen) self.head = Head(self) # объект этикетки head self.head.pack(fill=tk.X, expand=False) self.stbar = Footer(self, bso_) # объект строки состояния self.stbar.pack(side=tk.BOTTOM, fill=tk.X) self.sep = ttk.Separator(self) self.sep.pack(side=tk.BOTTOM, fill=tk.X, pady=1) self.frame_upr = ttk.Frame(self) # фрейм для управления self.frame_upr.pack(side=tk.BOTTOM, fill=tk.X) self.infobar = InfoBar(self) # объект Info self.infobar.pack(side=tk.BOTTOM, fill=tk.X) self.board = CanvasT(self, sizeX, sizeY, bso_) # объект CanvasT self.board.pack(side=tk.TOP, fill=tk.BOTH, expand=True) self.ser = RS232(trace) # объект Serial self.gser = Gps(trace) # объект Gps self.gser.tty.baudrate = 4800 self.gser.tty.timeout = 0.01 self._zg = config.getfloat('System', 'zagl') self.head.set_z(self.zg) # zg - свойство self.d0 = { 'L': 'МГ', 'M': 'СГ', 'H': 'БГ', 'C': 'B8', 'D': 'B10', 'B': 'Б6' } self.fil_ametka = 'DodgerBlue2' self.stringfile = 0 # число строк записанных в файл self.txt_opmetka = 0 # счётчик оперативных отметок ручн. self.y_g = 0 # self.error = 0 # занулить ошибки при старте проги self.file_gals = None # нет файла для записи галса self.man_metkawriteok = (False, False) self.avto_metkawriteok = False self.yold_ = 0.0 # для перемещен текста врем. меток self.hide_metka = False # Показывать метки self.hide_grid = False # Показывать гор. линии self.gl_0 = 0 self.d_gps = None self.last_d_gps = None self.tavto_ = None self.tbname = None self.view_db = None # self.count_gps = 0 self.ida = None self.ida_ = True self.last_sec = -1 self.count_tmetka = 1 self.vz_last = self.rej_last = 0 self.diap_last = self.old_depth = 'МГ' self.helpDialog = None self.color_ch = True self.t_pausa = 0 self.y_metka = self.board.y_top self.flag_gals = False self.vzvuk = 1500 if bso_: self.gui_main() self.sep.pack_forget()
def capture_action(pred_path, cb, debug=False, log=False): """Facial detection and real time processing credit goes to: https://www.pyimagesearch.com/2017/04/17/real-time-facial-landmark-detection-opencv-python-dlib/ """ action_handler = ActionHandler() detector = dlib.get_frontal_face_detector() predictor = dlib.shape_predictor(pred_path) camera = cv2.VideoCapture(0) while True: _, frame = camera.read() if frame is None: continue _, w_original, _ = frame.shape frame = resize_frame(frame) h, w, _ = frame.shape display_bounds(frame) gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY) rects = detector(gray, 0) for rect in rects: shape = predictor(gray, rect) shape = face_utils.shape_to_np(shape) cur_head = Head(shape, w) cur_eyes = Eyes(shape, frame) eye_action = detect_eyes(shape, cur_eyes) head_action = detect_head(shape, cur_head) COUNTER_LOG[eye_action] += 1 COUNTER_LOG[head_action] += 1 perform, action = action_handler.get_next(eye_action, head_action) if log: display_decisions(frame, head_action, eye_action) display_counters(frame, COUNTER_LOG) if perform: COUNTER_LOG[action] += 1 cb(action) if debug: cur_head.debug(frame) cur_eyes.debug(frame) cv2.imshow("Frame", frame) key = cv2.waitKey(1) & 0xFF if key == ord("q"): break cv2.destroyAllWindows()