def run_program(repository): """ This method parses the repository, extracting human and fly files as it does so. It then computes alignment scores between pairings, and deposits information into the Recorder for later use (plotting). It will then compute the average length-normalized alignment score. For more information, read the # comments below! :param repository: The filepath of the collection of human and fly fasta files. :return: nothing. """ # Step 1 We need sequences! To save time, we'll keep the first sequence in each file. What are the files? human_files, fly_files = sc.get_filenames(repository) # Step 2 construct the full filepaths, and get the FIRST sequences only and store them in a dictionary. # Key = filename, Value = String seq. human_seqs_dict = {} fly_seqs_dict = {} # Getting seqs from the DataBank. for human_file, fly_file in zip(human_files, fly_files): human_seqs_dict[human_file] = sc.get_first_seq(repository + human_file) fly_seqs_dict[fly_file] = sc.get_first_seq(repository + fly_file) # At this stage, we have two dictionaries that should be in alphabetical order each, with filenames corresponding # to sequences. # The next step is to compute the needleman-wunsch score between them needle_scores = {} for human_key, fly_key in zip(human_seqs_dict, fly_seqs_dict): print("Computing alignment score between: " + human_key + " and " + fly_key) needle_scores[human_key + " vs " + fly_key] = sc.compare_seqs(human_seqs_dict[human_key], fly_seqs_dict[fly_key]) # Now I'm recording this new addition! # This might get a little confusing so I'm gonna explain # The first statement below will give me data for a histogram. # The second statement computes the average length of the two seqs and passes it as well as the score rec.add_pair_score(human_key, fly_key, needle_scores[human_key + " vs " + fly_key]) rec.add_length_data(len(human_seqs_dict[human_key]) + len(fly_seqs_dict[fly_key]) / 2, needle_scores[human_key + " vs " + fly_key]) # Now we need to compute the average normalized scores for each pairing average_per_pair = sc.average_score(list(needle_scores.values()), list(human_seqs_dict.values()), list(fly_seqs_dict.values())) # Now we need to compute the grand average global benchmark_average benchmark_average = sc.grand_average(average_per_pair) print("\nBenchmark Average Alignment Score: " + str(benchmark_average) + " points per base.")
def __init__(self): super().__init__() # Set up recorder class self.rec = rcd.Recorder(device_name = 'Line (U24XL with SPDIF I/O)') # Set up window parameter Window.size = (500,500) # Initialise root widget passing recorder class self.rootwidget = RootWidget(rec = self.rec);
def runrecordingtest(): recording = rec.Record() rtime=datetime.datetime.now() result=findmostaccuraterec(recording) #runtime = datetime.datetime.now() - rtime #print("Proccess completed in", str(runtime.seconds + (round(100 * runtime.microseconds / 1000000) / 100)), "seconds") print('Currently playing "'+result["name"]+" current")
def main(argv=None): logging.info("\n" * 3 + "="*100) logging.info("starting recorder ") if argv is None: argv = sys.argv helpText = ''' Please enter the following argumets [1] name of the channel [2] directory to store recordings [3] time to record (optional) otherwise recording will continue till 0:00h the next day like: "./runner.py Br_Klassik /User/Data" ''' #too little arguments if len(argv) < 3 or len(argv) > 4: print(helpText) sys.exit() channel_name = argv[1] directory = argv[2] if len(argv) == 4: time_to_record = 10 * int(argv[3]) #make minutes else: time_to_record = None today = datetime.date.today() # date = time.strftime('%Y-%m-%d', time.localtime()) start_time = time.strftime('%H-%M-%S', time.localtime()) db = Database.Database(directory) db.init_RadioDB() channel = db.find_channel_by_name(channel_name) if channel is None: print("There is no channel with that name") sys.exit() else: try: # start recording process recorder = Recorder.Recorder(today, start_time, channel, directory, time_to_record) recording = recorder.capture() except RuntimeError as e: exit("ERROR: {}".format(e.message)) # start audio processing and feature analysis # digester = home + "/rrs/digesting_runner.py" # Popen(["/usr/local/bin/python3", digester, directory, str(today), channel_name]) logging.info("Crawling process finished") sys.exit(0)
def __init__(self): self.exp_parameters = ExpParameters() self.RESOURCES = sdl2.ext.Resources('.', 'resources') self.display = Display.Display(self.RESOURCES, self.exp_parameters) self.recorder = Recorder.Recorder(self.exp_parameters) self.pID = 999 self.session = 99 self._setupSessions() self._getPIDNSession()
def __init__(self, loadfile=None): self.rec = Recorder.Recorder() self.keyboard = Keyboard() self.done = 0 self.last_display = None self.peak_meter = PeakMeter() self.last_update = 0 if loadfile: print 'Loading', loadfile self.rec.load(loadfile)
def ivw_wakeup(): try: msc_load_library = r'.\au\sdk\bin\msc_x64.dll' app_id = '30cd05ef' # 填写自己的app_id ivw_threshold = '0:1450' jet_path = os.getcwd() + r'.\au\sdk\bin\msc\res\ivw\wakeupresource.jet' work_dir = 'fo|' + jet_path except Exception as e: return e # ret 成功码 MSP_SUCCESS = 0 dll = cdll.LoadLibrary(msc_load_library) errorCode = c_int64() sessionID = c_voidp() # MSPLogin Login_params = "appid={},engine_start=ivw".format(app_id) Login_params = bytes(Login_params, encoding="utf8") ret = dll.MSPLogin(None, None, Login_params) if MSP_SUCCESS != ret: logger.info("MSPLogin failed, error code is: %d", ret) return # QIVWSessionBegin Begin_params = "sst=wakeup,ivw_threshold={},ivw_res_path={}".format( ivw_threshold, work_dir) Begin_params = bytes(Begin_params, encoding="utf8") dll.QIVWSessionBegin.restype = c_char_p sessionID = dll.QIVWSessionBegin(None, Begin_params, byref(errorCode)) if MSP_SUCCESS != errorCode.value: logger.info("QIVWSessionBegin failed, error code is: {}".format( errorCode.value)) return # QIVWRegisterNotify dll.QIVWRegisterNotify.argtypes = [c_char_p, c_voidp, c_voidp] ret = dll.QIVWRegisterNotify(sessionID, pCallbackFunc, None) if MSP_SUCCESS != ret: logger.info("QIVWRegisterNotify failed, error code is: {}".format(ret)) return # QIVWAudioWrite recorder = Recorder.Recorder() dll.QIVWAudioWrite.argtypes = [c_char_p, c_voidp, c_uint64, c_int64] ret = MSP_SUCCESS logger.info("* start recording") while ret == MSP_SUCCESS: audio_data = b''.join(recorder.get_record_audio()) audio_len = len(audio_data) ret = dll.QIVWAudioWrite(sessionID, audio_data, audio_len, 2) logger.info('QIVWAudioWrite ret =>{}', ret) logger.info("* done recording") recorder.__del__()
def update(self): now = time.time() if now - self.last_update < 0.03: # Not time for a redraw yet return self.last_update = now peak = self.peak_meter.get_string(30) mode = self.rec.mode.ljust(len('recording')) if self.rec.get_undoable(): undo = '(undo)' else: undo = ' ' text = '\r %s at %s of %s %s [%s]' % ( mode, Recorder.format_time(self.rec.get_time()), Recorder.format_time(self.rec.get_total()), undo, peak, ) # Nah! if len(self.rec.record_buffer): undo = '*' else: undo = ' ' if self.rec.get_undoable(): undo += '+' else: undo += ' ' text = '\r[%s] %s %s ' % (peak, undo, mode) if text != self.last_display: sys.stdout.write(text) sys.stdout.flush() self.last_display = text
def __init__(self, parent, title, size): wx.Frame.__init__(self, parent, title=title, size=size) self.Centre() self.dataDirectory = os.getcwd() + '/Data/' self.recorder = Recorder(self, port='/dev/ttyACM0', baud=115200) self.lastFile = None self.currentFile = None self.hasData = False self.Menus() self.panel = Main_Panel(self) self.Show()
def createUI(self, urls): self.widget = QtGui.QWidget(self) # self.setContentsMargins(0, 0, 10, 5) self.urls = urls # Main Horizontal Container self.hbox = QtGui.QHBoxLayout() self.hbox.setContentsMargins(0, 0, 0, 0) # Create the VLC video widgets self.videos = self.createVLCWidgets(urls) self.recorder = Recorder.VLCRecorder(urls) for i in range(0, len(urls)): # Vertical box will hold the video and its corresponding record button vbox = QtGui.QVBoxLayout() vbox.setContentsMargins(0, 0, 0, 0) label = QtGui.QLabel() label.setFixedHeight(15) label.setText("URL: " + urls[i]) vbox.addWidget(label) # Add video widget to layout container vbox.addWidget(self.videos[i]) # Create record button then add to layout container recordButton = CustomWidgets.Button( "Record Feed " + str(self.videos[i].id + 1), self.videos[i].id, self.recorder) vbox.addWidget(recordButton) # Add all vertical layout containers to a horizontal container self.hbox.addLayout(vbox) # Add all layouts to main container self.setLayout(self.hbox) # Give VLC the window to play in then tell it to play the video for i in range(0, len(urls)): self.videos[i].assignWindowId() self.videos[i].play()
def startRec(self): """ Start recording """ rec = rc.Recorder(rate=22050, channels=1) filePath = "rec" with rec.open(filePath + ".wav", "wb") as recfile: recfile.record(duration=5.0) audioAnalyzer = aa.AudioAnalyzer() if self._recognition: voice = audioAnalyzer.checkAudio(filePath + ".wav") bestUsers = audioAnalyzer.getBestUsers(voice) print "Best users: {}".format(bestUsers) print "_userId: " + self._userId if self._userId in bestUsers: msgBox = QtGui.QMessageBox() msgBox.setText( "Welcome {}! You have been authenticated.".format( self._userId)) msgBox.setStandardButtons(QtGui.QMessageBox.Close) msgBox.exec_() else: msgBox = QtGui.QMessageBox() msgBox.setText("Two step authentication failed.") msgBox.setStandardButtons(QtGui.QMessageBox.Close) msgBox.exec_() else: print "Adding new user " + self._userId + " with file " + filePath try: success = audioAnalyzer.addUser(self._userId, filePath) except IOError, e: success = False print "Error adding user: "******"rm -R " + filePath + "*") # remove all temp file if success: self.close() return msgBox = QtGui.QMessageBox() msgBox.setText("Please speak more loudly.") msgBox.setStandardButtons(QtGui.QMessageBox.Close) msgBox.exec_()
def __record_video(self): current_thread = threading.currentThread() frames_per_second = \ RESOURCE_PROVIDER.get_string_table(RESOURCE_PROVIDER.CAMERA_FRAMERATE) duration = RESOURCE_PROVIDER.get_string_table(RESOURCE_PROVIDER.CAMERA_DURATION) while getattr(current_thread, 'is_running', True): self.__record_video_enabled_lock.acquire() condition = self.__record_video_enabled self.__record_video_enabled_lock.release() if bool(condition) is True: file_name = self.__get_file_name() self.__video_camera = Recorder.Recorder(\ file_name, False, str(duration), ["-fps", str(frames_per_second)]) self.__video_camera.start() self.__thread_timer = time.time() while self.__video_camera.isAlive(): if time.time() - self.__thread_timer > 300.0 / 1000.0: if getattr(current_thread, 'is_running', False): break self.__thread_timer = time.time() self.__video_camera.stop() self.__video_camera.join() print '[Video Manager] video_camera stopped ' while getattr(current_thread, 'is_running', True): try: self.__raw_files_queue.put(file_name, False) except Queue.Full: time.sleep(0.1) continue break
import numpy as np import torch import torch.nn as nn import torchvision.transforms as transforms # Other Library from datetime import datetime # Self-Defined Files import Utils import Config import Recorder # Models import AlexNet, ResNet, LeNet5, MobileNet, NiNet import SqueezeNet, myNet # Recorder Instantiate myRecorder = Recorder.Recorder() torch.cuda.empty_cache() # Fetch Models, Init & Copy # model = ResNet.Fetch_ResNet('ResNet8v1') # model = AlexNet.AlexNet() # model = LeNet5.LeNet5() # model = MobileNet.MobileNetv1() # model = NiNet.NetworkInNetwork() # model = SqueezeNet.Fetch_SqueezeNet('Bypass_Simple') # model = SqueezeNet.SqueezeNet('Basic') model = myNet.myNet(ResidualDepth = 2, DepthShrink = 0.5) # print(model)
def writetofile(key): keydata =str(key) print(keydata) if keydata=="Key.esc": Listener.stop() if Mode.ChooseMode(keydata): return elif Mode.getRecordMode(): #如果处于录音模式 if not Mode.getRecording(): Mode.setRecording(True) a=recorder.Recorder(keydata) Mode.setKeySet(keydata,a) #没有开始录音 a.start() #录音开始 elif Mode.getRecording() : print("Recording mode On\nrecording stopped") Mode.setRecording(False) Mode.KeyToTrack[keydata].stop() Mode.setPlayMode() #退出录音模式 elif Mode.getPlayMode(): #如果处于播放模式 if Mode.getLoopMode(): if keydata in Mode.KeyToTrack: if Mode.KeyToTrack[keydata].getLooping(): Mode.KeyToTrack[keydata].stoploop() else : Mode.KeyToTrack[keydata].loop() else: return else : if keydata in Mode.KeyToTrack: print(Mode.KeyToTrack[keydata].getLength()) Mode.KeyToTrack[keydata].play() elif Mode.getSyncMode(): if Mode.ChoosingSyncMode: Mode.ChosenTrackTime=Mode.KeyToTrack[keydata].getLength() Mode.ChoosingSyncMode=False print("Choose A Track To Record\n") else: if not Mode.getRecording(): Mode.setRecording(True) a=recorder.Recorder(keydata) Mode.setKeySet(keydata,a) #没有开始录音 a.startSync(Mode.ChosenTrackTime) #录音开始 print("Recording Start\n") elif Mode.getRecording() : print("recording stopped\n") Mode.setRecording(False) Mode.KeyToTrack[keydata].stop() Mode.ChoosingSyncMode=True Mode.setPlayMode() #退出录音模式 elif Mode.getFXMode(): if Mode.ChoosingFXMode: Mode.ChosenFX=Mode.ChooseFX(keydata) #选择完效果 Mode.ChoosingFXMode=False #选择完效果 Mode.ChoosingTrackMode=True #选择完效果 print("Choose Your Tracks") elif Mode.ChoosingTrackMode: Mode.ChosenTrack.append(Mode.KeyToTrack[keydata]) if len(Mode.ChosenTrack)>=Mode.ChosenFX.getNumber(): Mode.ChoosingTrackMode=False Mode.ChoosingKeyMode=True print("Choose A Key For The New Track\n") elif Mode.ChoosingKeyMode: Mode.NewTrack=recorder.Recorder(keydata) Mode.KeyToTrack[keydata]=Mode.NewTrack Mode.giveFXtoTrack(Mode.ChosenTrack,Mode.NewTrack) Mode.ChoosingKeyMode=False Mode.ChoosingFXMode=True Mode.ChosenTrack=[] Mode.setPlayMode()
import Control import pyttsx3 import requests import json from tkinter import messagebox # pip install jsonpath # import jsonpath def action(): data = entry1.get().strip() control = Control.Order() control.run(data) rec = Recorder.Recorder() def ok(event): print('开始录音') rec.start() def no(): print('结束录音') # 结束录音 rec.stop() # 保存音频 file = rec.save('audio') # 调用百度aip语音识别转义成文字 APP_ID = 'your APP_ID'
import Recorder import sys sys.path.insert( 0, 'C:\Users\Thomas\Desktop\Leap_Motion_SDK_Windows_2.3.1\LeapDeveloperKit_2.3.1+31549_win\LeapSDK/lib' ) sys.path.insert( 0, 'C:\Users\Thomas\Desktop\Leap_Motion_SDK_Windows_2.3.1\LeapDeveloperKit_2.3.1+31549_win\LeapSDK/lib/x64' ) import Leap from pygameWindow_Del03 import PYGAME_WINDOW recorder = Recorder.RECORDER(Leap.Controller(), PYGAME_WINDOW(), 500, 600, -100.0, 100.0, 0.0, 700.0, 0, 0, 0, 1000) Recorder.RECORDER.Run_Forever(recorder)
sendPCLock=sendPCLock) exoClient.start() # Initialize Recorder name = input('Please input the name of this experiment:') senName = 'Time,LHipPos,LKnePos,LAnkPos,SyncPin,RHipPos,RKnePos,RAnkPos,Test,Test' conRecName = [] for val in valveCon.valveList: conRecName.append(val.name) pwmRecName = [] for pwmVal in valveCon.pwmValList: pwmRecName.append(pwmVal.name) recorder = Recorder.Recorder(name=name, senRecQue=senRecQue, senName=senName, conRecQue=valveRecQue, conRecName=conRecName, syncTime=syncTimeQue, pwmRecQue1=pwmRecQue1, pwmRecQue2=pwmRecQue2, pwmRecName=pwmRecName, stateQue=stateQue) def readCmd(cmdStr, cmdList): startI = 0 endI = 0 while endI != len(cmdStr): endI = cmdStr.find(',', startI) if endI == -1: endI = len(cmdStr) cmdList.append(cmdStr[startI:endI]) startI = endI + 1
# -*- coding: utf-8 -*- from Recorder import * from module309 import * if __name__ == '__main__': frame = 13 * [0] s = createSignal(frame) rec = Recorder(channels=2) with rec.open('sine.wav', 'wb') as recfile: recfile.record(duration=5.0) playSignal(s)
from __future__ import division import sys sys.path.insert(0, '..') import Leap from pygameWindow_Del03 import PYGAME_WINDOW import random import constants import Recorder obj = Recorder.RECORDER() obj.Run_Forever()
elif worldname == 'straight_6lane': Track.append(seg.Segment('straight', (0, -75, pi / 2), 50)) Track.append(seg.Segment('straight', (0, -25, pi / 2), 50)) Track.append(seg.Segment('straight', (0, 25, pi / 2), 50)) Track.append(seg.Segment('straight', (0, 75, pi / 2), 50)) Track.append(seg.Segment('straight', (0, 125, pi / 2), 50)) Track.append(seg.Segment('straight', (0, 175, pi / 2), 50)) else: print('no information about world:' + worldname + '! check out typo ') trackinfo = Trackinfo.Trackinfo() trackinfo.set_world(Track) # 생성한 segment list를 trackinfo에게 알려준다. recorder = Recorder.Recorder(worldname, hz) print 'data will be saved at ' + recorder.directory print 'data file name : ' + recorder.filename state = RUN i = 0 while True: if state == RUN: trackinfo.current_segment = trackinfo.findSegment( trackinfo.my_car.pose[0:2]) trackinfo.lane_number = trackinfo.findLane( trackinfo.my_car.pose[0:2]) trackinfo.findSidelines(trackinfo.my_car.pose[0:2]) trackinfo.findDeviation(trackinfo.my_car.pose) trackinfo.findHeading(trackinfo.my_car.pose)
class Main_Frame(wx.Frame): """Main Window of the data logger application""" def __init__(self, parent, title, size): wx.Frame.__init__(self, parent, title=title, size=size) self.Centre() self.dataDirectory = os.getcwd() + '/Data/' self.recorder = Recorder(self, port='/dev/ttyACM0', baud=115200) self.lastFile = None self.currentFile = None self.hasData = False self.Menus() self.panel = Main_Panel(self) self.Show() def Menus(self): self.menubar = wx.MenuBar() self.fileMenu = wx.Menu() self.openMenu = wx.Menu() self.viewMenu = wx.Menu() self.recordMenu = wx.Menu() for i, file in enumerate(os.listdir(self.dataDirectory)): added = self.openMenu.Append(201+i, file, file) self.Bind(wx.EVT_MENU, self.selectFile, added) self.fileMenu.AppendMenu(101, 'Open', self.openMenu) #Add the open submenu to the file menu of the menubar self.fileNew = self.fileMenu.Append(wx.ID_NEW, 'New') self.fileView = self.viewMenu.Append(wx.ID_PASTE, 'View') self.fileRecord = self.recordMenu.Append(wx.ID_OPEN, 'Record') self.Bind(wx.EVT_MENU, self.newFile, self.fileNew) self.Bind(wx.EVT_MENU, self.viewFile, self.fileView) self.Bind(wx.EVT_MENU, self.recordFile, self.fileRecord) self.menubar.Append(self.fileMenu, 'File') #Add the file menu to menubar self.menubar.Append(self.viewMenu, 'View') self.menubar.Append(self.recordMenu, 'Record') self.SetMenuBar(self.menubar) def newFile(self, evt): #File > New NewFile_Window(self) def addFile(self, file): #When a new file is created and saved, it is then added to the file list labels = [] for i in range(self.openMenu.GetMenuItemCount()): labels.append(self.openMenu.FindItemByPosition(i).GetLabel()) if file not in labels: added = self.openMenu.Append(201+self.openMenu.GetMenuItemCount(), file) self.Bind(wx.EVT_MENU, self.selectFile, added) self.panel.Labels.setAxes(self.currentFile.columns) def selectFile(self, evt): #Selects the current file from the menu fileName = self.GetMenuBar().FindItemById(evt.GetId()).GetLabel() path = self.dataDirectory + fileName self.updateFiles(File(path)) #Sets the current file type None, Data, New self.panel.Labels.setAxes(self.currentFile.columns) self.panel.updateStatus("File", str(self.currentFile.name)) self.panel.updateStatus("Data", str(self.hasData)) self.hasData = self.currentFile.hasData() self.panel.updateGraphParameters() #Update graph file def updateFiles(self, file): assert (isinstance(file, File)), "File must be file object of NoneType" self.lastFile = self.currentFile self.currentFile = file self.recorder.setFile(file) self.hasData = file.hasData() if hasattr(self.currentFile, "name"): self.hasData = self.currentFile.hasData() self.panel.updateStatus("File", str(self.currentFile.name)) self.panel.updateStatus("Data", str(self.hasData)) def viewFile(self, evt): if self.currentFile != None: if self.currentFile.hasData(): view = View(self) view.giveData(self.currentFile.data) def recordFile(self, evt): if isinstance(self.currentFile, File): record = RecordCtrl(self) def getFile(self): return self.currentFile
title = "Operational Map Alpha 2.71828" if __name__ == "__main__": root = tk.Tk() root.title(title) # root.geometry("1280x750") main_panel = ttk.PanedWindow(root, orient=tk.HORIZONTAL) main_panel.pack(expand=True) left_part = tk.Canvas(main_panel, width=350) left_part.image = Image.open('./icons/annri.jpg') left_part.image = ImageTk.PhotoImage(left_part.image) left_part.create_image(0, 0, image=left_part.image, anchor="nw", tags='icon') main_panel.add(left_part) Notebook = ttk.Notebook(root) Notebook.pack(expand=True) recorder_widget = Recorder.RecorderFrame(root) Notebook.add(recorder_widget.main_container, text='Recorder') map_widget = Map.MapFrame(root) Notebook.add(map_widget.main_container, text='Operational Map') main_panel.add(Notebook) root.mainloop()
def __init__(self, filename, options): gr.top_block.__init__(self, "MULTIRX2") config = configuration.Configuration(filename) self.center_freq = config.center() self.save_dir = config.save_dir() print("Starting Multirx ...") print("low=%d center=%d high=%d span=%d" % (config.lower(), config.center(), config.upper(), (config.upper() - config.lower()))) self.samp_rate = samp_rate = 1E6 dev_args = "numchan=" + str(1) + " rtl=" + config.serial() print("Device Args: %s" % dev_args) self.osmosdr_source = osmosdr.source(args=dev_args) self.osmosdr_source.set_sample_rate(samp_rate) self.osmosdr_source.set_center_freq(self.center_freq, 0) self.osmosdr_source.set_freq_corr(config.freq_corr(), 0) self.osmosdr_source.set_dc_offset_mode(0, 0) self.osmosdr_source.set_iq_balance_mode(0, 0) if config.gain() == 0: self.osmosdr_source.set_gain_mode(True, 0) else: self.osmosdr_source.set_gain_mode(False, 0) self.osmosdr_source.set_gain(config.gain(), 0) self.osmosdr_source.set_if_gain(20, 0) self.osmosdr_source.set_bb_gain(20, 0) self.osmosdr_source.set_antenna("", 0) self.osmosdr_source.set_bandwidth(0, 0) self.blocks_adder = blocks.add_vss(1) for self.i, self.entry in enumerate(config.channel): self.demod_bb_freq = self.entry[1] - self.center_freq self.ctcss_freq = self.entry[3] self.postscript = self.entry[4] self.squelch = self.entry[5] self.demod = Demodulator.Demodulator(self.samp_rate, \ self.demod_bb_freq, self.squelch, self.ctcss_freq) self.fname = self.setup_upstream_pipe(self.entry[0], self.entry[2], config) self.file_sink = blocks.file_sink(gr.sizeof_short * 1, self.fname, True) self.connect((self.osmosdr_source, 0), (self.demod, 0), (self.file_sink, 0)) self.connect((self.demod, 0), (self.blocks_adder, self.i)) self.rec = Recorder.Recorder(16000, self.entry[0], self.save_dir, self.postscript) self.connect((self.demod, 0), (blocks.short_to_float(1, 32768), 0), (self.rec, 0)) time.sleep(1) #space things out a bit if options.multiplex: self.fname = self.setup_upstream_pipe("multiplex", "Multiplex Channel") self.file_sink = blocks.file_sink(gr.sizeof_short * 1, self.fname, True) self.connect((self.blocks_adder, 0), (self.file_sink, 0)) if options.local: self.audio_sink = audio.sink(16000, "", True) self.blocks_short_to_float = blocks.short_to_float(1, 32768) self.connect((self.blocks_adder, 0), (self.blocks_short_to_float, 0), (self.audio_sink, 0)) if not options.multiplex and not options.local: self.connect((self.blocks_adder, 0), (blocks.null_sink(gr.sizeof_short * 1), 0))
def run(self): self.__is_running_lock.acquire() self.__is_running = True self.__is_running_lock.release() self.__controller = Controller.Controller() self.__recorder = Recorder.Recorder() self.__communicator_server = CommunicatorServer.CommunicatorServer(self.get_ip_address()) self.__streamer_server = StreamerServer.StreamerServer(self.get_ip_address()) self.__data_provider_server = DataProviderServer.DataProviderServer(self.get_ip_address()) # control car motors thread self.__controller_thread = \ threading.Thread(target=Controller.Controller.send_commands, \ args=(self.__controller, COMMANDS_QUEUE)) self.__controller_thread.setDaemon(True) self.__controller_thread.start() # get car data thread self.__car_data_thread = \ threading.Thread(target=Controller.Controller.get_car_data, \ args=(self.__controller, CAR_DATA_QUEUE)) self.__car_data_thread.setDaemon(True) self.__car_data_thread.start() # video capture thread self.__recorder_thread = \ threading.Thread(target=Recorder.Recorder.record, args=(self.__recorder, FRAME_QUEUE)) self.__recorder_thread.setDaemon(True) self.__recorder_thread.start() # streamer server thread self.__streamer_thread = \ threading.Thread(target=self.__streamer_server.stream, \ args=(FRAME_QUEUE,)) self.__streamer_thread.setDaemon(True) self.__streamer_thread.start() # comunicator server thread self.__communicator_thread = \ threading.Thread(target=self.__communicator_server.update_user_commands, \ args=(USER_COMMANDS_QUEUE,)) self.__communicator_thread.setDaemon(True) self.__communicator_thread.start() # data provider server thread self.__data_provider_thread = \ threading.Thread(target=self.__data_provider_server.provide, \ args=(CAR_DATA_QUEUE,)) self.__data_provider_thread.setDaemon(True) self.__data_provider_thread.start() # user commands thread self.__process_user_commands_thread = \ threading.Thread(target=self.__process_user_commands, \ args=(USER_COMMANDS_QUEUE, COMMANDS_QUEUE,)) self.__process_user_commands_thread.setDaemon(True) self.__process_user_commands_thread.start() print '[CarManager] Am startat tot' while True: self.__is_running_lock.acquire() condition = self.__is_running self.__is_running_lock.release() if bool(condition) is False: self.stop() break time.sleep(1)
def createListItem(title, banner, description, duration, date, channel, videourl, playable, folder, backdrop, pluginhandle, subtitles=None, blacklist=False, contextMenuItems=None): contextMenuItems = contextMenuItems or [] liz = xbmcgui.ListItem(title) liz.setIconImage(banner) liz.setThumbnailImage(banner) liz.setInfo(type="Video", infoLabels={"Title": title}) liz.setInfo(type="Video", infoLabels={"Tvshowtitle": title}) liz.setInfo(type="Video", infoLabels={"Sorttitle": title}) liz.setInfo(type="Video", infoLabels={"Plot": description}) liz.setInfo(type="Video", infoLabels={"Plotoutline": description}) liz.setInfo(type="Video", infoLabels={"Aired": date}) liz.setInfo(type="Video", infoLabels={"Studio": channel}) liz.setProperty('fanart_image', backdrop) if playable and not folder: liz.setProperty('IsPlayable', 'true') videourl = "plugin://%s/?mode=play&videourl=%s" % ( xbmcaddon.Addon().getAddonInfo('id'), videourl) debugLog("Videourl: %s" % videourl, "ListItem") if not folder: liz.setInfo(type="Video", infoLabels={"mediatype": 'video'}) videoStreamInfo = {'codec': 'h264', 'aspect': 1.78} try: videoStreamInfo.update({'duration': int(duration)}) except (TypeError, ValueError): debugLog("No Duration found in Video", 'Info') if videourl.lower().endswith('_q8c.mp4') or '_q8c' in videourl.lower(): videoStreamInfo.update({'width': 1280, 'height': 720}) elif videourl.lower().endswith( '_q6a.mp4') or '_q6a' in videourl.lower(): videoStreamInfo.update({'width': 960, 'height': 540}) elif videourl.lower().endswith( '_q4a.mp4') or '_q4a' in videourl.lower(): videoStreamInfo.update({'width': 640, 'height': 360}) else: videoStreamInfo.update({'width': 320, 'height': 180}) liz.addStreamInfo('video', videoStreamInfo) liz.addStreamInfo('audio', { "codec": "aac", "language": "de", "channels": 2 }) if subtitles != None and Settings.subtitles(): if len(subtitles) > 0 and subtitles[0].endswith('.srt'): subtitles.pop(0) liz.addStreamInfo('subtitle', {"language": "de"}) try: liz.setSubtitles(subtitles) except AttributeError: # setSubtitles was introduced in Helix (v14) # catch the error in Gotham (v13) pass contextMenuItems.append( Recorder.recContextMenuItem(sys.argv[0], title, videourl, description, date, duration, channel, banner)) if blacklist: match = re.search(r'( - \w\w, \d\d.\d\d.\d\d\d\d)', title) if match != None: bltitle = title.split(" - ") bltitle = bltitle[0].split(": ") bl_title = bltitle[0].replace("+", " ").strip() else: bl_title = title.replace("+", " ").strip() blparameters = {"mode": "blacklistShow", "link": bl_title} blurl = sys.argv[0] + '?' + urllib.urlencode(blparameters) contextMenuItems.append( ('%s %s %s' % (Settings.localizedString(30038).encode("utf-8"), bl_title, Settings.localizedString(30042).encode("utf-8")), 'XBMC.RunPlugin(%s)' % blurl)) if checkBlacklist(bl_title): return liz.addContextMenuItems(contextMenuItems) xbmcplugin.addDirectoryItem(pluginhandle, url=videourl, listitem=liz, isFolder=folder) return liz
plot_frame2 = tk.Frame(root) # plot_frame.pack_propagate(0) plot_frame2.pack(fill='both', side='top', expand='True') x_plot = Plot.Plot(plot_frame1, "both", "left", "True") y_plot = Plot.Plot(plot_frame1, "both", "right", "True") z_plot = Plot.Plot(plot_frame2, "both", "left", "True") throttle_plot = Plot.Plot(plot_frame2, "both", "right", "True") config = Config.Config("config.ini") controller = Controller.Controller(root, "x", "bottom", "False", sender, config) plot_handler = PlotHandler.PlotHandler(x_plot, y_plot, z_plot, throttle_plot) recorder = Recorder.Recorder(args.recordpath) def d(event): plot_handler.redraw() root.bind('<Configure>', d) if args.mode == 0: recorder.start_recording() receiver = Receiver.Receiver(client_socket, plot_handler, recorder, controller) elif args.mode == 1: receiver = Receiver.Receiver(client_socket, plot_handler, None, controller) recorder.playback_recording(receiver, args.recordpath) else:
def record_benchmark_average(): """ Records the Gene Deviation Score into the recorder. :return: Nothing. """ rec.set_gene_dev_score(benchmark_average)
import Recorder as rec from random import randint ''' -NOT TO BE USED! Filepaths and nonsense are hard coded here for testing purposes. This is a tester that I used to test the recorder module. Recorder is my custom module that writes out to a PDF file. Random was used to generate nonsense data for testing purposes. Oooo weee, this was fun! ''' # Setting filepaths/names. rec.report_dest = "/Users/chrismatthewcyril/Downloads/GeneBank/Needleman-Version5.0/venv/" rec.report_filename = "1" rec.BMAL_filepath = "/Users/chrismatthewcyril/Downloads/GeneBank/Needleman-Version5.0/venv/BMAL_CYC_FILES/BMAL.fasta" rec.CYC_filepath = "/Users/chrismatthewcyril/Downloads/GeneBank/Needleman-Version5.0/venv/BMAL_CYC_FILES/CYCLE.fasta" rec.DataBank_source = "/Users/chrismatthewcyril/Downloads/GeneBank/Needleman-Version5.0/venv/DataBank" # Testing out the add_pair_score function, as well as feeding nonsense data. rec.add_pair_score("bmal", "cycle", 2000) rec.add_pair_score("askdfj", "aslkdj", 1500) rec.add_pair_score("asd", "123", 500) rec.add_pair_score("adlkjhads", "123", 12) rec.add_pair_score("bmajskndsaal", "cycle", 250) for x in range(50): rec.add_length_data(x, randint(1,2500)) # Asking for report to check it. rec.prepare_report()
import sys sys.path.append('../x64') sys.path.insert(0, '..') import Recorder deliverable = Recorder.DELIVERABLE() while True: deliverable.Run_Once()
def __init__(self): self.rec = Recorder.Recorder() # with default params self.make_gui() every(self.tk, 100, self.update_display)