コード例 #1
0
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.")
コード例 #2
0
 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);
コード例 #3
0
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")
コード例 #4
0
ファイル: runner.py プロジェクト: raulhammerl/rrs
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)
コード例 #5
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()
コード例 #6
0
    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)
コード例 #7
0
ファイル: aumain.py プロジェクト: douwings/assistant
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__()
コード例 #8
0
    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
コード例 #9
0
	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()
コード例 #10
0
ファイル: UI.py プロジェクト: briand27/2016-17
    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()
コード例 #11
0
 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_()
コード例 #12
0
ファイル: VideoManager.py プロジェクト: AlexandruRusu23/Rufus
    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
コード例 #13
0
ファイル: main.py プロジェクト: ChengyaoWang/PlayGround
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)
コード例 #14
0
ファイル: pyrec.py プロジェクト: Wangmerlyn/PyRecord
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()
コード例 #15
0
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'
コード例 #16
0
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)
コード例 #17
0
ファイル: ExoPi.py プロジェクト: haolee21/Exoskeleton
                          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
コード例 #18
0
# -*- 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)
コード例 #19
0
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()
コード例 #20
0
    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)
コード例 #21
0
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
コード例 #22
0
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()
コード例 #23
0
    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))
コード例 #24
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)
コード例 #25
0
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
コード例 #26
0
    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:
コード例 #27
0
def record_benchmark_average():
    """
    Records the Gene Deviation Score into the recorder.
    :return: Nothing.
    """
    rec.set_gene_dev_score(benchmark_average)
コード例 #28
0
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()
コード例 #29
0
import sys

sys.path.append('../x64')
sys.path.insert(0, '..')
import Recorder

deliverable = Recorder.DELIVERABLE()

while True:
    deliverable.Run_Once()
コード例 #30
0
    def __init__(self):
        self.rec = Recorder.Recorder()  # with default params
        self.make_gui()

        every(self.tk, 100, self.update_display)