Example #1
0
    def __init__(self, jhs_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)

        # thread lock
        self.mutex = threading.Lock()

        # db
        self.mysqlAccess = MysqlAccess() # mysql access
        self.mongofsAccess = MongofsAccess() # mongodb fs access

        # jhs queue type
        self.jhs_type = jhs_type # h:每小时, i:商品信息详情

        # appendix val
        self.a_val = a_val
        
        # activity items
        self.items = []

        # dial client
        self.dial_client = DialClient()

        # local ip
        self._ip = Common.local_ip()

        # router tag
        self._tag = 'ikuai'
        #self._tag = 'tpent'

        # give up item, retry too many times
        self.giveup_items = []
Example #2
0
 def run(self):
     MyThread.run(self)
     Object_Label=self.bridgeutil.GetParameters(self.label)
     print("Metto in ascolto l'interaccia %s su %s: %s \n" %(self.label,Object_Label.IP,Object_Label.Port)) 
     thread=TCPSimulatorThread(self.label,Object_Label.IP,Object_Label.Port)
     thread.start()
     
Example #3
0
def main():
    logger = logging.getLogger('main()')
    logger.info('server start!')
    worker_threads = 4 #定义需要启动的线程数量
    timeline = 2 #线程检查时间间隔,秒
    thread_pool = {}

    for i in range(0, worker_threads ):
        param = 'some param'
        job = MyJobs( param )
        thread = MyThread( job, i )
        thread.setDaemon = True
        thread.start()
        logger.info('start thread %s' %( thread.getName() ))
        thread_pool[i] = thread

    #干完就结束模式
    #for eachKey in thread_pool.keys():
    # thread_pool[eachKey].join()

    #保持线程数量模式
    while 1:
        time.sleep(timeline)
        # 检查每一个线程
        for eachKey in thread_pool.keys():
            if thread_pool[eachKey].isAlive():
                print ('thread alive:' + str(i))
            else:
                print ('thread down:' + str(i))
                thread_pool[eachKey].run()

    logger.info('main exist!')
    return
Example #4
0
    def __init__(self, jhs_type, thread_num = 15, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)

        # thread lock
        self.mutex      = threading.Lock()

        # db
        self.mysqlAccess = MysqlAccess() # mysql access
        self.mongofsAccess = MongofsAccess() # mongodb fs access

        # appendix val
        self.a_val = a_val

        # jhs queue type
        self.jhs_type   = jhs_type # 1:即将上线品牌团频道页, 2:检查每天还没结束的活动, 3:新增活动
        
        # activity items
        self.items      = []

        # dial client
        self.dial_client = DialClient()

        # local ip
        self._ip = Common.local_ip()

        # router tag
        self._tag = 'ikuai'
    def run(self):
        MyThread.run(self)
        #creo la socket per la comunicazione
        #PARTE SERVER
        #print("CONFIGURAZIONE SERVER")

        server = TheServer(self.m_ip, int(self.m_port))
        try:
            server.main_loop()
        except KeyboardInterrupt:
            print "Ctrl C - Stopping server"
            sys.exit(1)        
Example #6
0
    def __init__(self, jhs_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)

        # thread lock
        self.mutex = threading.Lock()

        # db
        self.mysqlAccess = MysqlAccess() # mysql access
        self.mongofsAccess = MongofsAccess() # mongodb access

        # jhs queue type
        self.jhs_type = jhs_type # m:解析json数据

        # appendix val
        self.a_val = a_val
        
        # activity items
        self.items = []

        # give up item, retry too many times
        self.giveup_items = []
Example #7
0
    def __init__(self, _q_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)

        # thread lock
        self.mutex          = threading.Lock()

        self.worker_type    = Config.JHS_Brand

        # message
        self.message        = Message()

        # db
        self.mysqlAccess    = MysqlAccess() # mysql access
        self.redisAccess    = RedisAccess()     # redis db
        self.mongofsAccess  = MongofsAccess() # mongodb fs access

        # jhs queue type
        self._q_type        = _q_type # main:新增商品, day:每天一次的商品, hour:每小时一次的商品, update:更新

        # appendix val
        self.a_val          = a_val
        
        # activity items
        self.items          = []

        # dial client
        self.dial_client    = DialClient()

        # local ip
        self._ip            = Common.local_ip()

        # router tag
        self._tag           = 'ikuai'
        #self._tag          = 'tpent'

        # give up item, retry too many times
        self.giveup_items   = []
Example #8
0
    def __init__(self, _q_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)

        # thread lock
        self.mutex          = threading.Lock()

        self.worker_type    = Config.TC_Spot

        # message
        self.message        = Message()

        # db
        self.mysqlAccess    = MysqlAccess()   # mysql access
        self.mongofsAccess  = MongofsAccess() # mongodb fs access

        # tc queue type
        self._q_type        = _q_type # new:新增商品

        # appendix val
        self.a_val          = a_val
        
        # activity items
        self.items          = []

        # dial client
        self.dial_client    = DialClient()

        # local ip
        self._ip            = Common.local_ip()

        # router tag
        self._tag           = 'ikuai'
        #self._tag          = 'tpent'

        # give up item, retry too many times
        self.giveup_items   = []
Example #9
0
    def __init__(self, key, q_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)
        # thread lock
        self.mutex          = threading.Lock()

        self.tc_type        = Config.TC_TYPE # tc type
        #self.item_type      = q_type        # item queue type

        # db
        self.mysqlAccess    = MysqlAccess() # mysql access
        self.redisQueue     = RedisQueue()  # redis queue
        self.mongofsAccess  = MongofsAccess() # mongodb fs access

        # tc queue type
        self.tc_queue_type  = q_type # new...
        self._key           = key   # redis queue key

        # appendix val
        self.a_val          = a_val

        # return items
        self.items          = []

        # dial client
        self.dial_client    = DialClient()

        # local ip
        self._ip            = Common.local_ip()

        # router tag
        self._tag           = 'ikuai'
        #self._tag          = 'tpent'

        # give up item, retry too many times
        self.giveup_items   = []
Example #10
0
    def __init__(self, itemtype, q_type, thread_num=10, a_val=None):
        # parent construct
        MyThread.__init__(self, thread_num)
        # thread lock
        self.mutex          = threading.Lock()

        self.jhs_type       = Config.JHS_TYPE # jhs type
        self.item_type      = itemtype      # item type

        # db
        self.mysqlAccess    = MysqlAccess() # mysql access
        self.redisQueue     = RedisQueue()  # redis queue
        self.mongofsAccess  = MongofsAccess() # mongodb fs access

        # jhs queue type
        self.jhs_queue_type = q_type     # h:每小时
        self._key           = '%s_%s_%s' % (self.jhs_type,self.item_type,self.jhs_queue_type)

        # appendix val
        self.a_val          = a_val

        # activity items
        self.items          = []

        # dial client
        self.dial_client    = DialClient()

        # local ip
        self._ip            = Common.local_ip()

        # router tag
        self._tag           = 'ikuai'
        #self._tag          = 'tpent'

        # give up item, retry too many times
        self.giveup_items   = []
Example #11
0
def main():
    nfuncs = len(funcs)
    print('single thread start at:', ctime())
    for i in range(nfuncs):
        print('starting', funcs[i].__name__, 'at', ctime())
        print(funcs[i](n))
        print(funcs[i].__name__, 'finished at:', ctime())
    print('single thread end at:', ctime())

    threads = []
    print('multiple threads starting at:', ctime())
    for i in range(nfuncs):
        t = MyThread(funcs[i], args=(n, ), name=funcs[i].__name__)
        threads.append(t)
    for i in range(nfuncs):
        threads[i].start()
        pass

    for i in range(nfuncs):
        threads[i].join()
        print(threads[i].getresult())
    print('multiple threads end at:', ctime())
Example #12
0
def main():
    '''
    a=2
    print("a=%d" %a)
    area_test(a)
    print("a now is a= %d" %a)

    q=Queue(10);
    print("main q size %d" %q.qsize())
    queue_test(q)
    print("after function q size %d" %q.qsize())
    '''
    threads = []
    q = Queue(10)
    loop = 10
    for i in range(nfuncs):
        t = MyThread(funcs[i], (q, loop))
        threads.append(t)

    for i in range(nfuncs):
        threads[i].start()
    '''
Example #13
0
def main():
    print 'single thread...'
    for func in funcs:
        print func.__name__, 'start@', ctime()
        print func(n)
        print func.__name__, 'end@', ctime()

    threads = []

    for i in range(len(funcs)):
        mythread = MyThread(funcs[i], (n, ), funcs[i].__name__)
        threads.append(mythread)

    print 'multi-threads...'
    for th in threads:
        th.start()

    for th in threads:
        th.join()
        print th.getResult()

    print 'main--done'
Example #14
0
def pro_run(path):
    baidu_handle(path)

    data = pre_run(path)

    img = data["image"]
    # data["binarize_image"].show()
    width, height = img.size
    cuty = data["cuty"]
    print("start")

    # loop = asyncio.get_event_loop()
    tasks = []
    for i in range(1, len(cuty)):
        temp = img.crop((0, cuty[i - 1], width, cuty[i]))
        t = MyThread(tesseract_ocr, args=(temp,))
        tasks.append(t)
        # coroutine = asyncio.ensure_future(tesseract_ocr(temp))
        # task = asyncio.ensure_future(coroutine)
        # tasks.append(coroutine)
    result = runthread(tasks, 6)
    for i in result:
        print(i)
Example #15
0
def main():

    nloops = randint(2, 5)

    q = Queue(32)

    threads = []

    for i in range(nfuncs):

        t = MyThread(funcs[i], (q, nloops), funcs[i].__name__)

        threads.append(t)

    for i in range(nfuncs):

        threads[i].start()

    for i in range(nfuncs):

        threads[i].join()

    print('all Done')
Example #16
0
def main():
    nfuncs = range(len(funcs))

    print('*** SINGLE THREAD')
    for i in nfuncs:
        print('starting %s at: %s' % (funcs[i].__name__, ctime()))
        print(funcs[i](n))
        print('%s finished at: %s' % (funcs[i].__name__, ctime()))

    print('\n*** MULTIPLE THREAD')
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (n, ), funcs[i].__name__)
        threads.append(t)

    for i in nfuncs:
        threads[i].start()

    for i in nfuncs:
        threads[i].join()
        print(threads[i].getResult())

    print('all DONE')
Example #17
0
def main():
    nfuncs = range(len(funcs))

    print('*** single thread -------------')
    for i in nfuncs:
        print('starting ', funcs[i].__name__, 'at: ', ctime())
        print(funcs[i](n))
        print(funcs[i].__name__, ' finished at: ', ctime())

    print('*** multiple thread -------------')
    threads = []
    for i in nfuncs:
        t = MyThread(funcs[i], (n, ), funcs[i].__name__)
        threads.append(t)

    for i in nfuncs:
        threads[i].start()

    for i in nfuncs:
        threads[i].join()
        print(threads[i].getResult())

    print('all done')
Example #18
0
# coding:utf-8
import time

from MyThread import MyThread

__author__ = 'uv2sun'

t1 = MyThread(1, "t1")
t2 = MyThread(2, "t2")
print time.ctime()
t1.start()
t2.start()

t1.join()
t2.join()

print time.ctime()


Example #19
0
class MyVideoRecorder(object):
    def __init__(self, cam=1):

        self.ap = argparse.ArgumentParser()
        self.ap.add_argument("-v",
                             "--video",
                             default='./videos',
                             help="path to the video file")
        self.ap.add_argument("-f", "--fps", type=int, default=10, help="fps")

        self.ap.add_argument("-p",
                             "--path",
                             type=str,
                             default='./videos',
                             help="path to which to save videos")
        file_name = 'test' + str(np.random.randint(100))
        self.ap.add_argument("-n",
                             "--name",
                             type=str,
                             default=file_name,
                             help="filename")
        self.ap.add_argument("-r",
                             "--resize",
                             type=bool,
                             default=True,
                             help="filename")

        self.ap.add_argument("-c",
                             "--cam",
                             type=int,
                             default=1,
                             help="csamera number")

        self.args = vars(self.ap.parse_args())

        self.output = self.args['path'] + '/' + self.args['name']
        self.fps = self.args['fps']
        self.cam = self.args['cam']
        self.resize = self.args['resize']
        print(self.output)

        self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
        self.imH = int(360 / 2)
        self.imW = int(640 / 2)

        self.recording = False

        self.initialiseCap()
        self.initialiseWriter()
        self.recordingThread = MyThread(self.record)
        self.recordingThread.start()
        self.Timer = MyTimer()
        self.Timer.restart()

    def convert2gif(self):
        self.gif = MyGif(self.output, array, fps=self.fps, scale=1.0)

    def start(self):
        self.recording = True

    def pause(self):
        self.recording = False

    def initialiseCap(self):
        self.cap = cv2.VideoCapture(self.cam)

    def initialiseWriter(self):
        self.writer =  cv2.VideoWriter(self.output,fourcc = self.fourcc,\
                                       fps = self.fps, \
                                       frameSize = (self.imW,self.imH))
        time.sleep(1.0)

    def record(self):
        while self.recording:
            self.grabFrame()
            self.writer.write(self.frame)
            cv2.imshow("Frame", self.frame)
            self.key = cv2.waitKey(1) & 0xFF
            if self.key == ord("q"):
                self.recording = False
                self.stop()

    def grabFrame(self):
        ret, self.frame = self.cap.read()
        if ret:
            self.frame = self.frame.swapaxes(0, 1)[:, :, ::-1]
            if self.resize:
                self.frame = cv2.resize(self.frame,
                                        (self.imH, self.imW)).astype('uint8')

    def releaseCap(self):
        self.cap.release()

    def stop(self):
        self.recording = False
        self.releaseCap()
        self.writer.release()
        print('file saved at:\n{0}'.format(self.output))
        cv2.destroyAllWindows()
        self.recordingThread.stop()
Example #20
0
            a.append(int(n))
        except Exception as e:
            print(e)
    _max = max(a)
    for i in range(1, _max):
        u = str(l+"/"+str(i))
        url_list.append(u)
    return url_list



if __name__ == '__main__':
    url = "https://avmoo.asia/cn/genre"
    print("开始解析:" + url)

    html = get_html(url, 'https://avmoo.asia/cn')
    soup = get_soup(html)
    img_dirs = get_img_dirs(soup)
    threads = []
    if None == img_dirs:
        print("无法获取该网页下的相册内容...")
    else:
        for d in img_dirs:
            # print(img_dirs.get(d))
            # download_imgs((d, img_dirs.get(d), 'https://avmoo.asia/cn'))
            my_thread = MyThread(download_imgs, (d, img_dirs.get(d), 'https://avmoo.asia/cn'))
            my_thread.start()
            my_thread.join()
        #     threads.append(my_thread)
        # for my in threads:
        #     my.join()
Example #21
0
    def __init__(self, opt=1):

        ####################
        #### args
        ####################
        self.ap = argparse.ArgumentParser()
        self.default_path = '/Users/virginiarutten/Documents/deep_fish/videos'
        self.ap.add_argument("-v", "--video", \
                             default = self.default_path, help="path to the video file")
        self.ap.add_argument("-f",
                             "--fps",
                             type=str,
                             default=str(10),
                             help="fps")

        self.ap.add_argument("-p", "--path", type = str, \
                             default=self.default_path, help="path to which to save videos")
        file_name = 'test_delete'
        self.ap.add_argument("-n",
                             "--name",
                             type=str,
                             default=file_name,
                             help="filename")
        self.ap.add_argument("-r",
                             "--resize",
                             type=bool,
                             default=True,
                             help="filename")

        self.ap.add_argument("-c",
                             "--cam",
                             type=int,
                             default=1,
                             help="camera number")
        self.ap.add_argument("-t",
                             "--max_time",
                             type=int,
                             default=10,
                             help="camera number")
        self.ap.add_argument("-w",
                             "--wait_time",
                             type=int,
                             default=100,
                             help="camera number")

        if opt == 1:
            self.args = vars(self.ap.parse_args())
        else:
            self.args = vars(self.ap.parse_known_args()[0])

        self.wait_time = self.args['wait_time'] / 1000
        self.dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")[2:]
        self.output = self.args['path'] + '/' + self.args[
            'name'] + self.dt + '.avi'
        #self.fps = int(self.args['fps'])
        self.fps = np.ceil(1 / self.wait_time)
        self.cam = self.args['cam']
        self.resize = self.args['resize']
        self.max_time = self.args['max_time']
        print('output file:{0}'.format(self.output))

        #################
        ### settings
        ###############
        self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
        self.imH = int(360 / 2)
        self.imW = int(640 / 2)
        self.recording = False

        self.initialiseCap()
        self.initialiseWriter()
        time.sleep(.2)
        self.grabFrame()
        self.initialise_window()
        self.show_frame()

        self.recording = True
        self.recordingThread = MyThread(self.start_recording, self.wait_time)
        self.recordingThread.start()

        self.count = 0
        self.Timer = MyTimer()
        self.Timer.restart()
Example #22
0
            # print(info)
            print(datetime.datetime.now())
            time.sleep(5)
        except:
            pass
    os.system('say "end"')


if __name__ == "__main__":
    print('Strat Tickets')
    headers = {
        'Host': 'kyfw.12306.cn',
        'If-Modified-Since': '0',
        'Pragma': 'no-cache',
        'Referer': 'https://kyfw.12306.cn/otn/leftTicket/init',
        'User-Agent':
        'Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/55.0.2883.87 Safari/537.36',
        'X-Requested-With': 'XMLHttpRequest'
    }
    index_url = 'https://www.12306.cn/index/'
    html_index = requests.get(index_url, headers=headers, verify=False)
    print(html_index.status_code)
    queray = LeftqueryUtil(requests)
    from_station = '宿州东'
    to_station = '上海'
    date = '2019-10-07'

    thread1 = MyThread().createThread(querayThread, args={"queray": queray})
    thread1.start()
    thread1.join()
Example #23
0
class myApp(QtGui.QWidget):
   
    def __init__(self):
        super(myApp, self).__init__()
        
        # initialise gui
        self.initUI()
        
        # initialise bools
        self.measuring = False #reading from  arduino
        self.trialOn = False #trial loo
        
        ## trial thread
        self.trial_thread = MyThread(self.trial_loop)
        self.trial_thread.start()
        
        
        self.ard_thread = MyThread(self.read_ard)
        self.ard_thread.start()
        
        # try to connect to arduino
        try:
            self.get_serial()
        except:
            pass

        try:
            self.load_picture()
        except:
            pass
        
        
        
    def initUI(self):
        
        self.maxLen = 300
        # data buffer
        self.yvals = deque([0.0]*self.maxLen)


        #####################################
        ## standard buttons
        #####################################
        ## start flow button
        self.start_btn = QtGui.QPushButton('start',self)
        self.start_btn.clicked.connect(self.on_start)

        ## stop flow button
        self.stop_btn = QtGui.QPushButton('stop',self)
        self.stop_btn.clicked.connect(self.on_stop)

        ## quit app button
        self.qbtn = QtGui.QPushButton('exit',self)
        # quit threads if running **************
        self.qbtn.clicked.connect(self.on_quit)
        # quit app
        self.qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)


        #####################################
        ## set flow rate button
        #####################################
        self.slider = QtGui.QSlider(Qt.Horizontal)
        self.slider.setMinimum(0)
        self.slider.setMaximum(100)
        self.slider.setValue(50)
        self.slider.setTickPosition(QSlider.TicksBelow)
        self.slider.setTickInterval(10)
        # change value
        self.slider.valueChanged.connect(self.slidervaluechange)

        #####################################
        ## labels to show current flow rate
        #####################################
        ## text - data sent from Arduino
        self.text_ard = QtGui.QLineEdit('arduino sent:')
        self.label_ard = QLabel()
        self.label_ard.setText('arduino sent:')
        # communication signal to write to gui
        self.comm_ard = Communicate()
        self.comm_ard.signal.connect(self.text_ard.setText)
        

        #
        ## text - data written to Arduino
        self.text_rate= QtGui.QLineEdit('PC sent:')
        self.label_rate = QLabel()
        self.label_rate.setText('PC sent:')
        # communication signal to write to gui
        self.comm_rate = Communicate()
        self.comm_rate.signal.connect(self.text_rate.setText)        


        
        self.plot = pg.PlotWidget()

        
        #####################################
        ## stimulus display
        #####################################
        
        ## start trial
        self.trial_btn= QtGui.QPushButton('start trial',self)
        self.trial_btn.clicked.connect(self.on_startTrial)
        self.trialOff_btn= QtGui.QPushButton('stop trial',self)
        self.trialOff_btn.clicked.connect(self.on_stopTrial)
        # communication signal to write to gui
        self.comm_trial = Communicate()
        self.comm_trial.signal.connect(self.text_rate.setText)           
        

        self.figure = pl.Figure()
        self.canvas = FigureCanvas(self.figure)
        self.stim_btn = QtGui.QPushButton('show stimulus',self)
        self.stim_btn.clicked.connect(self.plot_picture)
        self.stimOff_btn  = QtGui.QPushButton('hide stimulus',self)
        self.stimOff_btn.clicked.connect(self.clear_picture)
        
        #####################################
        ## layout
        #####################################v
        layout = QtGui.QGridLayout()
        layout.setColumnStretch(0, 0)
        layout.setColumnStretch(1, 0)

        layout.addWidget(self.start_btn, 0, 0, 1, 1)   # button goes in upper-left
        layout.addWidget(self.stop_btn, 1, 0, 1, 1)   # button goes in upper-left
        layout.addWidget(self.qbtn, 2, 0, 1, 1)   # button goes in upper-left   

        layout.addWidget(self.label_ard, 0, 1, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.text_ard, 0, 2, 1, 1)   # button goes in upper-left 

        layout.addWidget(self.label_rate, 1, 1, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.text_rate, 1, 2, 1, 1)   # button goes in upper-left 

        layout.addWidget(self.slider, 3, 0, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.stim_btn, 2, 2, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.stimOff_btn, 2, 3, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.trial_btn, 3, 2, 1, 1)   # button goes in upper-left 
        layout.addWidget(self.trialOff_btn, 3, 3, 1, 1)   # button goes in upper-left 


        layout.addWidget(self.plot, 4, 0, 3, 5)  # plot goes on right side, spanning 3 rows
        layout.addWidget(self.canvas, 4, 5, 3, 5)


        self.setLayout(layout)
        self.setWindowTitle('DeepFish') 
        self.show()

        
    def load_picture(self):
        file_path = '../assets/pp.png'
        self.im = np.asarray(Image.open(file_path))

    def clear_picture(self): 
        try:
            ax
            ax.set_axis_off()
        except:
            ax = self.figure.add_subplot(111)
            ax.set_axis_off()
        ax.clear()
        ax.set_axis_off()
        ax.set_frame_on(False)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        self.canvas.draw()
        
    
    def plot_picture(self): 
        try:
            ax
        except:
            ax = self.figure.add_subplot(111)
            ax.axes.get_xaxis().set_visible(False)
            ax.axes.get_yaxis().set_visible(False)
            ax.set_axis_off()
        ax.clear()
        ax.imshow(self.im)
        ax.set_frame_on(False)
        self.canvas.draw()  
        
    def test_plot(self):
        tmp_data = np.arange(20)
        ax = self.figure.add_subplot(111)
        ax.set_axis_off()
        ax.clear()
        ax.imshow(self.im)
        ax.set_axis_off()
        ax.set_frame_on(False)
        ax.axes.get_xaxis().set_visible(False)
        ax.axes.get_yaxis().set_visible(False)
        #ax.plot(tmp_data, 'o-')
        self.canvas.draw()
        
    
    def slidervaluechange(self):
        rate = self.slider.value()
        self.send_ard(rate)
        
    def send_ard(self, var):
        self.ser.write(bytes(var))

    def go_cue(self):
        self.plot_picture()
        
        
    def trial_loop(self):
        self.trial_time = 10
        t = Timer(self.trial_time, self.go_cue)
        while self.trialOn:
            pass
            #t.start()
       
            #self.test_plot()
            
          
    def read_ard(self):
        while self.measuring:
            self.incoming_data = self.ser.readline().decode("utf-8")
            sleep(0.1)
            if self.incoming_data.find('ard')>-1:
                numbers = ''.join(re.findall('[0-9]',self.incoming_data))
                self.comm_ard.signal.emit(self.incoming_data)
                # add data point to plot
                self.addToBuf( self.yvals,numbers)
                
                sys.stdout.write(numbers+ '\n')
                #sys.stdout.write("ard found")
            elif self.incoming_data.find('PC')>-1:
                numbers = ''.join(re.findall('[0-9]',self.incoming_data))
                self.comm_rate.signal.emit(self.incoming_data) 
                sys.stdout.write(numbers + '\n')
        
    def get_serial(self):
        self.ser = serial.Serial('/dev/cu.usbmodem14311', 9600,timeout=.05)

    
    def startTrial(self):
        if not self.trialOn:
            self.trialOn=True

    def stopTrial(self):
        if self.trialOn:
            self.trialOn=False

       
    ##################
    ### measure rate
    ################
    
    def startMeasuring(self):
        if not self.measuring:
            self.measuring=True
            
    def stopMeasuring(self):
        if self.measuring:
            self.measuring=False
            
            
    def print_to_screen(self):
        while self.measuring:
            sleep(0.1)
            data = self.ser.readline().decode("utf-8") 
            self.comm.signal.emit(data)
          
        
    # add to buffer
    def addToBuf(self, buf, val):
        if len(buf) < self.maxLen:
            buf.append(val)
        else:
            buf.pop()
            buf.appendleft(val)
            
        
    ###################
    #### slots
    ###################
    @pyqtSlot()
    def on_startTrial(self):
        print('starting trial')
        self.startTrial()
  
    @pyqtSlot()
    def on_stopTrial(self):
        print('stop trial')
        self.stopTrial()

        
    @pyqtSlot()
    def on_start(self):
        print('start to measuring')
        self.startMeasuring()
        
    @pyqtSlot()
    def on_stop(self):
        print('stop measuring')
        self.stopMeasuring() 
        
        
    @pyqtSlot()
    def on_quit(self):
        print('kill all threads')
        self.ard_thread.stop()
        self.trial_thread.stop()
Example #24
0
    def __init__(self, general_):

        MyThread.__init__(self, -1, "main")

        self.general = general_
    application.listen(port)
    tornado.ioloop.IOLoop.instance().start()


def add_new_pic(face_recognization):
    while True:
        # 直接请求本地的服务,加入LSH Forest
        face_recognization.add_all_new_pic()
        time.sleep(10)


if __name__ == "__main__":
    sub_process_id = ''
    try:
        face_recognition = FaceRecognition()
        face_recognition.load_all_data()
        application = tornado.web.Application([(r"/", MainHandler),])

        add_new_pic_args = (face_recognition, )
        add_new_pic_thread = MyThread(func=add_new_pic, args=add_new_pic_args, name='add_new_pic')

        add_new_pic_thread.start()

        application.listen(port)
        tornado.ioloop.IOLoop.instance().start()

        add_new_pic_thread.join()
    except:
        traceback.print_exc()

Example #26
0
def get_html_data(url,url_id):
    get_url = MyThread (get_response, (url,))
    get_url2 = MyThread (get_route, (url_id,))
    get_url.start (), get_url2.start ()
    get_url.join (), get_url2.join ()
    response = get_url.get_result ()
    route = get_url2.get_result ()
    return response,route
Example #27
0
    def __init__(self,opt=1):

        ##########################
        ##### default saving directory
        ##########################
        self.default_path = '/Users/virginiarutten/Documents/deep_fish/videos'
        self.filename = 'test'
        self.ext = '.avi'

        self.dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")[2:]
        self.foldername = self.default_path +'/' +  self.dt[:6]
        self.path = self.get_path()
        self.check_dir()


        self.save = False
        self.cameraPort = 1
        self.width = 950
        self.height = 700

        self.recording = False
        self.trialOn = False
        self.flowOn = False
        self.ARD = False


        self.trialTime = 10
        self.trialSleepTime = 10

        ##########################
        ##### Arduino settings
        ##########################
        self.flowOffDelay = 1
        self.flowOnDelay = 1


        self.imW = int(640/2)
        self.imH = int(360/2)
        self.imfps = 25

        self.trialTimer = MyTimer()
        self.trialTimer.restart()

        self.frameTimer = MyTimer()
        self.frameTimer.restart()

        self.ite = 0


        self.args = self.initialise_tracking_variables()
        self.win = self.initialise_window()
        self.recorder = self.initialise_videorecorder()
        self.Tracker = self.initialise_tracker()

        ##########################
        ##### Arduino
        ##########################
        self.ARDPort = self.ArdPortComboBox.currentData()
        self.Ard = self.initialise_Ard()

        ##########################
        ##### Threads
        ##########################
        self.recordingThread = MyThread(self.start_recording, wait_time = 0.02)
        self.recordingThread.start()
        self.trialThread = MyThread(self.start_trial, wait_time = 0.001)
        self.trialThread.start()
        self.recording = True
Example #28
0
def server_main(PLAYERS_COUNT, SERVER_ADDRESS, SERVER_PORT, LEVEL_H, LEVEL_W):

    # инициализация pygame
    pygame.init()

    # создаем уровень
    level_height = LEVEL_H
    level_width = LEVEL_W
    blocks, total_level_width, total_level_height = gen_level(level_height,level_width, BLOCK_DEMAGE)

    # группы объектов
    players_yellow = pygame.sprite.Group()
    players_yellow_bullets = pygame.sprite.Group()
    players_green = pygame.sprite.Group()
    players_green_bullets = pygame.sprite.Group()

    # серверный сокет
    game_server = Game_Server_UDP(SERVER_ADDRESS, SERVER_PORT, BLOCK_SIZE, LEVEL_W, LEVEL_H, players_green, players_yellow,
                    total_level_width, total_level_height, level_width, level_height, BLOCK_DEMAGE, FRAME_RATE, blocks)
    print("Server started on %s:%d" % (SERVER_ADDRESS, SERVER_PORT))
    print("Waiting for %d players..." % PLAYERS_COUNT)

    #запускаем цикл опроса сокетов
    socket_loop_thread = MyThread(asyncore.loop, [0.01])
    socket_loop_thread.start()

    # таймер
    timer = pygame.time.Clock()

    # id пули
    bullet_id = 0

    # ждем первого клиента
    while game_server.player_count == 0:
        time.sleep(1)

    # Основной цикл программы
    while 1:

        timer.tick(FRAME_RATE)                    # таймер на 30 кадров
        print('\rserver FPS: %.2f   ' % timer.get_fps(), end='') # вывод fps

        # отключившиеся игроки
        disconnected = []

        # цикл по всем игрокам
        for player in game_server.players:

            if player.ready:

                if player.socket._closed:
                    disconnected.append(player.id)
                    print('\nDisconnected client %s:%d, team: %s, id: %d' % (player.addr[0], player.addr[1], player.team, player.id))
                    player.sprite.kill()
                    game_server.players.remove(player)
                    game_server.player_count -= 1
                    #if game_server.player_count <= 0:
                        #pygame.quit()
                        #game_server.close()
                        #print("All players disconnected")
                        #return

                # очередной пакет данных текущего игрока
                # формат:
                # input_message = {'id': my_id, 'name': player_name, 'events': event_queue}
                # event_queue = [ {'type': e.type, 'key': e.key}, ... ]


                # получаем очередной пакет данных
                l = len(player.imes)
                if l > 0:
                    input_message = player.imes.pop()
                    player.imes = []
                    player.name = input_message['name']
                else:
                    input_message = {'id': 0, 'name': "", 'events': []}

                # очередь событий текущего игрока
                event_queue = input_message['events']

                # цикл по всем событиям в очереди
                for e in event_queue:

                    type = e['type'] # тип события
                    key = e['key']   # нажатая клавиша

                    # нажатие клавиши на клавиатуре
                    if type == pygame.KEYDOWN:

                        # движение
                        if key == pygame.K_LEFT:
                            player.sprite.course = 'left'
                        elif key == pygame.K_RIGHT:
                            player.sprite.course = 'right'
                        elif key == pygame.K_UP:
                            player.sprite.course = 'up'
                        elif key == pygame.K_DOWN:
                            player.sprite.course = 'down'

                        # выстрел
                        if key == pygame.K_SPACE and not player.sprite.isBullet:
                            player_bullet = Bullet(bullet_id,player.sprite.rect.left,player.sprite.rect.top,player.sprite.shutdirection)
                            bullet_id += 1
                            player_bullet.shooter = player.sprite
                            if player.team == 'green':
                                players_green_bullets.add(player_bullet)
                            elif player.team == 'yellow':
                                players_yellow_bullets.add(player_bullet)
                            player.sprite.isBullet = True

                    # отпускание клавиши
                    if type == pygame.KEYUP:
                        if (key == pygame.K_RIGHT) and (player.sprite.course == 'right'):
                            player.sprite.course = ''
                        elif (key == pygame.K_LEFT) and (player.sprite.course == 'left'):
                            player.sprite.course = ''
                        elif (key == pygame.K_UP) and (player.sprite.course == 'up'):
                            player.sprite.course = ''
                        elif (key == pygame.K_DOWN) and (player.sprite.course == 'down'):
                            player.sprite.course = ''

        # обновление всех объектов (симуляция мира)
        players_yellow.update( blocks.sprites() + players_green.sprites() + players_yellow.sprites() )
        players_green.update( blocks.sprites() + players_yellow.sprites() + players_green.sprites() )
        players_yellow_bullets.update( blocks.sprites() + players_green.sprites() + players_green_bullets.sprites() )
        players_green_bullets.update( blocks.sprites() + players_yellow.sprites() + players_yellow_bullets.sprites() )

        # отправить очередные изменения мира
        dataframe = {}

        #блоки
        dataframe['blocks'] = []
        for b in blocks.sprites():
            if b.shooted:
                data = {'id' : b.id, 'shootdirection' : b.shootdirection}
                dataframe['blocks'].append(data)
                b.shooted = False
                b.shootdirection = ''
            if b.dead:
                b.kill()

        #игроки
        dataframe['disconnected'] = disconnected
        dataframe['players'] = []
        for player in game_server.players:
            current = {'id': player.id, 'name': player.name, 'x': player.sprite.rect.x, 'y': player.sprite.rect.y,
                        'course': player.sprite.course, 'shutdirection': player.sprite.shutdirection,
                        'dead': player.sprite.dead, 'team' : player.team, 'dead_count': player.sprite.config.dead_count,
                        'frag': player.sprite.frag}
            if player.last != current :
                dataframe['players'].append(current)
            player.last = current

        #пули
        dataframe['bullets'] = []
        for b in players_yellow_bullets.sprites() + players_green_bullets.sprites():
            data = {'id': b.id, 'x': b.rect.x, 'y': b.rect.y, 'shutdirection' : b.shutdirection, 'bum': b.bum}
            dataframe['bullets'].append(data)

        # упаковываем данные
        message = pack_data(dataframe)

        # отправляем
        for player in game_server.players:
            player.obuffer += message
Example #29
0
    conn.execute('''CREATE TABLE IF NOT EXISTS GALLERY
       (ID INTEGER PRIMARY KEY AUTOINCREMENT,
       NAME           TEXT    NOT NULL,
       URL            TEXT    NOT NULL);''')
    print "GALLERY Table created successfully"

    conn.execute('''CREATE TABLE IF NOT EXISTS PHOTO 
       (ID INTEGER PRIMARY KEY AUTOINCREMENT,
       GALLERY       INTEGER         NOT NULL,
       URL           TEXT    NOT NULL);''')
    print "PHOTO Table created successfully"

    parser = argparse.ArgumentParser()
    parser.add_argument("echo")
    # parser.add_argument("url")
    # url = int(args.url)
    args = parser.parse_args()
    url = str(args.echo)
    print("开始解析:" + url)

    html = get_html(url)
    soup = get_soup(html)
    img_dirs = get_img_dirs(soup)
    if None == img_dirs:
        print("无法获取该网页下的相册内容...")
    else:
        for d in img_dirs:
            my_thread = MyThread(fetch_imgs, (d, img_dirs.get(d)))
            my_thread.start()
            my_thread.join()
class MyLiveTracker(object):
    def __init__(self, opt=1):

        ##########################
        ##### default saving directory
        ##########################
        self.default_path = '/Users/virginiarutten/Documents/deep_fish/videos'
        self.filename = 'test'
        self.ext = '.avi'

        self.dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")[2:]
        self.foldername = self.default_path + '/' + self.dt[:6]
        self.path = self.get_path()
        self.check_dir()

        self.save = False
        self.cameraPort = 1

        self.recording = False
        self.trialOn = False
        self.flowOn = False
        self.ARD = False

        self.trialTime = 10
        self.trialSleepTime = 10

        ##########################
        ##### Arduino settings
        ##########################
        self.flowOffDelay = 1
        self.flowOnDelay = 1

        self.imW = int(640 / 2)
        self.imH = int(360 / 2)
        self.imfps = 25

        self.trialTimer = MyTimer()
        self.trialTimer.restart()

        self.ite = 0

        self.args = self.initialise_tracking_variables()
        self.win = self.initialise_window()
        self.recorder = self.initialise_videorecorder()
        self.Tracker = self.initialise_tracker()

        ##########################
        ##### Arduino
        ##########################
        self.ARDPort = self.ArdPortComboBox.currentData()
        self.Ard = self.initialise_Ard()

        ##########################
        ##### Threads
        ##########################
        self.recordingThread = MyThread(self.start_recording)
        self.recordingThread.start()
        self.trialThread = MyThread(self.start_trial)
        self.trialThread.start()

        self.recording = True

    def check_dir(self):
        ''' check that directory of the day exisits
        and that filename is unique'''
        if not os.path.isdir(self.foldername):
            print('creating directory...')
            os.mkdir(self.foldername)
        file_num = 1
        while os.path.exists(self.path):
            print('file already exisits...\nrenaming')
            print(self.path)
            self.filename = self.filename + str(file_num)
            file_num += 1
            self.path = self.get_path()

    def initialise_tracker(self):
        self.Tracker = MyRealTimeTracker(self.args)
        return self.Tracker

    def initialise_tracking_variables(self):
        ''' default values '''

        self.keypoints = {}
        self.mvAvgFrame = None
        self.fishNum = 4
        self.area_mn = 35
        ## threshold mask value
        self.pVal = 180
        self.pVal_mx = 255
        self.text = None

        self.pre_frames = 5

        self.args = {}
        self.args['pVal'] = self.pVal
        self.args['pVal_mx'] = self.pVal_mx
        self.args['fishNum'] = self.fishNum
        self.args['area_mn'] = self.area_mn
        self.args['keypoints'] = self.keypoints
        self.args['pre_frames'] = self.pre_frames
        return self.args

    def get_path(self):
        return self.foldername + '/' + self.dt + self.filename + self.ext

    def initialise_videorecorder(self):
        ''' initialises recorder'''
        self.num_saved_frame = 0
        self.cameraPort = self.cameraComboBox.currentIndex()
        self.check_dir()
        if self.path[-3:] != 'avi':
            print('please check extension')

        print('initialising recording...\noutput file:{0}'.\
             format(self.path))

        self.recorder = MyVideoRecorder(cameraport = self.cameraPort,\
                                        path = self.path,\
                                        imH = self.imH,\
                                        imW = self.imW,\
                                       fps = self.imfps)

        wasrecording = False
        if self.recording:
            wasrecording = True
            self.recording = False

        self.recorder.initialise_camera()  ### reinitialise camera
        self.camera = self.recorder.camera  ### test camera works
        if self.camera.grab() == False:
            if self.cameraPort == 1:
                self.cameraPort = 0
                self.cameraComboBox.setCurrentIndex(self.cameraPort)
                print('no camera detected... camera changed')
        if wasrecording:
            self.recording = True
        else:
            self.recording = False
            wasrecording = False

        return self.recorder

    def initialise_Ard(self):
        try:
            self.Ard = MyArduino()
            self.ARDport = self.Ard.port
            self.ARD = True
        except:
            print('no valid port found \nplease check')
            self.ARD = False
        return self.Ard

    def load_picture(self):
        file_path = '/Users/virginiarutten/Documents/deep_fish/assets/pavlov_dog.jpg'
        self.bkImage = np.array(Image.open(file_path)).T

    def initialise_window(self):
        self.load_picture()
        self.app = QApplication([])
        self.win = MyQtWidget()

        #####################################
        ## Layout
        #####################################
        self.layout = QGridLayout()
        self.win.setLayout(self.layout)

        self.createRecordGroupBox()
        self.createDefaultGroupBox()
        self.createImageGroupBox()
        self.createSwitchFormGroupBox()
        self.createCalibrationFormGroupBox()
        self.createParamGroupBox()
        self.createPumpGroupBox()
        self.createTextGroupBox()
        self.resetPath()

        self.layout.addWidget(self.imageForm, 0, 0, 1, 3)

        self.layout.addWidget(self.textForm, 0, 4, 1, 3)

        self.layout.addWidget(self.paramForm, 2, 0, 1, 1)
        self.layout.addWidget(self.calibrationForm, 2, 1, 1, 1)
        self.layout.addWidget(self.pumpForm, 2, 2, 1, 1)

        self.layout.addWidget(self.switchForm, 3, 1, 1, 1)
        self.layout.addWidget(self.defaultForm, 3, 2, 1, 1)
        self.layout.addWidget(self.recordForm, 3, 0, 1, 1)

        self.win.show()
        return self.win

    def createImageGroupBox(self):
        self.imageForm = QGroupBox('Imaging')
        self.imageLayout = QGridLayout()

        ##raw image
        self.imv1 = RawImageWidget(scaled=True)
        ## tracking
        self.imv2 = RawImageWidget(scaled=True)
        ## mask
        self.imv3 = RawImageWidget(scaled=True)
        ## avergae
        self.imv4 = RawImageWidget(scaled=True)

        ## set background image
        self.imv1.setImage(self.bkImage)

        self.imageLayout.addWidget(QLabel("Raw:"), 0, 0, 1, 1)
        self.imageLayout.addWidget(QLabel("Detection:"), 0, 1, 1, 1)
        self.imageLayout.addWidget(self.imv1, 1, 0, 1, 1)
        self.imageLayout.addWidget(self.imv2, 1, 1, 1, 1)
        self.imageLayout.addWidget(QLabel("Mask:"), 2, 0, 1, 1)
        self.imageLayout.addWidget(QLabel("Moving average:"), 2, 1, 1, 1)
        self.imageLayout.addWidget(self.imv3, 3, 0, 1, 1)
        self.imageLayout.addWidget(self.imv4, 3, 1, 1, 1)

        self.imageForm.setLayout(self.imageLayout)

    def createTextGroupBox(self):
        self.textForm = QGroupBox('Imaging')
        self.textLayout = QFormLayout()

        ## parameters
        self.maxArea_box = QtGui.QLineEdit()
        self.num_detected_box = QtGui.QLineEdit()
        self.maxArea_box.setText('0')
        self.num_detected_box.setText('0')

        hbox = QtGui.QHBoxLayout()
        hbox.addWidget(QLabel("max area:"))
        hbox.addWidget(self.maxArea_box)
        hboxD = QtGui.QHBoxLayout()
        hboxD.addWidget(QLabel("fish #:"))
        hboxD.addWidget(self.num_detected_box)

        self.textLayout.addRow(hbox)
        self.textLayout.addRow(hboxD)

        self.textForm.setLayout(self.textLayout)

    def createSwitchFormGroupBox(self):
        self.switchForm = QGroupBox("Controller")
        self.switchLayout = QFormLayout()

        ######################
        #### Trial/Lights
        #####################

        self.lightOn_btn = QtGui.QPushButton('Light On', self.win)
        self.lightOn_btn.clicked.connect(self.on_lightOn)

        self.lightOff_btn = QtGui.QPushButton('Light Off', self.win)
        self.lightOff_btn.clicked.connect(self.on_lightOff)

        self.trialOn_btn = QtGui.QPushButton('Start Trial', self.win)
        self.trialOn_btn.clicked.connect(self.on_trialOn)

        self.trialOff_btn = QtGui.QPushButton('Stop Trial', self.win)
        self.trialOff_btn.clicked.connect(self.on_trialOff)
        self.switchLayout.addRow(self.lightOn_btn, self.lightOff_btn)
        self.switchLayout.addRow(self.trialOn_btn, self.trialOff_btn)

        self.switchForm.setLayout(self.switchLayout)

    def createCalibrationFormGroupBox(self):
        self.calibrationForm = QGroupBox("Image Calibration")
        self.calibrationLayout = QFormLayout()

        self.slider = QSlider(Qt.Horizontal)
        self.slider.setMinimum(0)
        self.slider.setMaximum(255)
        self.slider.setValue(self.pVal)
        self.slider.setTickPosition(QSlider.TicksBelow)
        self.slider.setTickInterval(10)
        self.slider.valueChanged.connect(self.on_slidervaluechange)
        self.textSlider = QtGui.QLineEdit(str(self.pVal))

        hbox_mn = QtGui.QHBoxLayout()
        hbox_mn.addWidget(self.slider)
        hbox_mn.addWidget(self.textSlider)

        self.slider2 = QSlider(Qt.Horizontal)
        self.slider2.setMinimum(0)
        self.slider2.setMaximum(255)
        self.slider2.setValue(self.pVal_mx)
        self.slider2.setTickPosition(QSlider.TicksBelow)
        self.slider2.setTickInterval(10)
        self.slider2.valueChanged.connect(self.on_slider2valuechange)
        self.textSlider2 = QtGui.QLineEdit(str(self.pVal_mx), self.win)

        hbox_mx = QtGui.QHBoxLayout()
        hbox_mx.addWidget(self.slider2)
        hbox_mx.addWidget(self.textSlider2)

        self.ROIslider = QSlider(Qt.Horizontal)
        self.ROIslider.setMinimum(0)
        self.ROIslider.setMaximum(1000)
        self.ROIslider.setValue(self.area_mn)
        self.ROIslider.setTickPosition(QSlider.TicksBelow)
        self.ROIslider.setTickInterval(100)
        self.ROIslider.valueChanged.connect(self.on_ROIslidervaluechange)
        self.ROItextSlider = QLineEdit(str(self.area_mn))

        hbox = QtGui.QHBoxLayout()
        hbox.addWidget(self.ROIslider)
        hbox.addWidget(self.ROItextSlider)

        self.calibrationLayout.addRow(QLabel("ROI max area:"), hbox)
        self.calibrationLayout.addRow(QLabel("px min:"), hbox_mn)
        self.calibrationLayout.addRow(QLabel("px max:"), hbox_mx)

        self.calibrationForm.setLayout(self.calibrationLayout)

    def createPumpGroupBox(self):
        self.pumpForm = QGroupBox("Pump settings")
        self.pumpFormLayout = QFormLayout()

        self.flowOff1_btn = QtGui.QPushButton('Increase')
        self.flowOff0_btn = QtGui.QPushButton('Decrease')

        self.flowOn1_btn = QtGui.QPushButton('Increase')
        self.flowOn0_btn = QtGui.QPushButton('Decrease')

        self.flowOn1_btn.clicked.connect(self.on_flowOn1)
        self.flowOn0_btn.clicked.connect(self.on_flowOn0)
        self.flowOff1_btn.clicked.connect(self.on_flowOff1)
        self.flowOff0_btn.clicked.connect(self.on_flowOff0)

        self.ardReset_btn = QtGui.QPushButton('reset flow')
        self.ardReset_btn.clicked.connect(self.on_ARDreset)

        hbox = QtGui.QHBoxLayout()
        hbox.addWidget(self.flowOn0_btn)
        hbox.addWidget(self.flowOn1_btn)

        hboxOff = QtGui.QHBoxLayout()
        hboxOff.addWidget(self.flowOff0_btn)
        hboxOff.addWidget(self.flowOff1_btn)

        self.pumpFormLayout.addRow(QLabel("On time:"), hbox)
        self.pumpFormLayout.addRow(QLabel("Off time:"), hboxOff)
        self.pumpFormLayout.addRow(self.ardReset_btn)
        self.pumpForm.setLayout(self.pumpFormLayout)

    def createParamGroupBox(self):
        self.paramForm = QGroupBox("Trial parameters")
        self.paramFormLayout = QFormLayout()

        self.Timer_tbox = QtGui.QLineEdit()

        self.trialTime_tbox = QtGui.QLineEdit()
        self.trialTime_tbox.textChanged.connect(self.on_trialTime_changed)
        self.trialSleepTime_tbox = QtGui.QLineEdit()
        self.trialSleepTime_tbox.textChanged.connect(
            self.on_trialSleepTime_changed)
        self.trialTime_tbox.setText(str(self.trialTime))
        self.trialSleepTime_tbox.setText(str(self.trialSleepTime))
        self.Timer_tbox.setText(str(0))

        self.paramFormLayout.addRow(QLabel("Trial time:"), self.trialTime_tbox)
        self.paramFormLayout.addRow(QLabel("Stimulus time:"),
                                    self.trialSleepTime_tbox)

        self.paramFormLayout.addRow(QLabel("Time left:"), self.Timer_tbox)

        self.paramFormLayout.addRow(QLabel("Time:"), QSpinBox())
        self.paramForm.setLayout(self.paramFormLayout)

    def createDefaultGroupBox(self):
        self.defaultForm = QtGui.QGroupBox("Video capture")
        self.defaultFormLayout = QFormLayout()

        self.ArdPortComboBox = QComboBox()
        self.ArdPortComboBox.addItem("Port 14511", '/dev/cu.usbmodem14511')
        self.ArdPortComboBox.addItem("Port 14311", '/dev/cu.usbmodem14311')
        self.ArdPortComboBox.addItem("Port 1461", '/dev/cu.usbmodem1461')
        self.ArdPortComboBox.currentIndexChanged.connect(self.on_setARDport)

        self.cameraComboBox = QComboBox()
        self.cameraComboBox.addItem("0", '0')
        self.cameraComboBox.addItem("1", '1')
        self.cameraComboBox.currentIndexChanged.connect(self.on_setcameraport)

        self.start_btn = QtGui.QPushButton('start')
        self.start_btn.clicked.connect(self.on_start)

        ## stop flow button
        self.stop_btn = QtGui.QPushButton('stop')
        self.stop_btn.clicked.connect(self.on_stop)

        ## quit app button
        self.qbtn = QtGui.QPushButton('exit')
        self.qbtn.clicked.connect(self.on_quit)
        self.qbtn.clicked.connect(QtCore.QCoreApplication.instance().quit)

        hbox = QtGui.QHBoxLayout()
        hbox.addWidget(self.start_btn)
        hbox.addWidget(self.stop_btn)
        hbox.addWidget(self.qbtn)

        self.defaultFormLayout.addRow(hbox)

        self.defaultFormLayout.addRow(QLabel("Arduino Port:"),\
                                     self.ArdPortComboBox)

        self.defaultFormLayout.addRow(QLabel("camera:"),\
                                     self.cameraComboBox)

        self.defaultForm.setLayout(self.defaultFormLayout)

    def createRecordGroupBox(self):
        self.recordForm = QtGui.QGroupBox("Video capture")
        self.recordFormLayout = QFormLayout()

        self.path_bx = QtGui.QLineEdit()
        self.resetPath()

        self.file_btn = QtGui.QPushButton("save to")
        self.file_btn.clicked.connect(self.on_getfile)

        self.file_bx = QtGui.QLineEdit()
        self.file_bx.textChanged.connect(self.on_fileChange)
        self.file_bx.setText(self.filename)

        self.save_btn = QtGui.QCheckBox()
        self.save_btn.setChecked(self.save)
        self.save_btn.stateChanged.connect(self.on_saveClick)

        hbox = QtGui.QHBoxLayout()
        self.recordFormLayout.addRow(self.file_btn, self.file_bx)
        self.recordFormLayout.addRow(QLabel("path:"), self.path_bx)
        self.recordFormLayout.addRow(QLabel("save:"), self.save_btn)

        self.recordForm.setLayout(self.recordFormLayout)

    #################
    ### slots
    ################

    @pyqtSlot()
    def on_getfile(self):
        self.foldername = QtGui.QFileDialog.getExistingDirectory()
        self.resetPath()

    @pyqtSlot()
    def on_fileChange(self):
        self.filename = self.file_bx.text()
        self.resetPath()

    @pyqtSlot()
    def on_setcameraport(self):
        self.initialise_videorecorder()

    @pyqtSlot()
    def on_trialTime_changed(self):
        try:
            self.trialTime = int(self.trialTime_tbox.text())

        except:
            self.trialTime_tbox.setText(str(1))
            print('only integrs valid')

    @pyqtSlot()
    def on_trialSleepTime_changed(self):
        try:
            self.trialSleepTime = int(self.trialSleepTime_tbox.text())
        except:
            self.trialSleepTime_tbox.setText(str(1))
            print('only integrs valid')

    @pyqtSlot()
    def on_setARDport(self):
        pass

    #  if self.ARD:
    #      self.ARDPort = self.ArdPortComboBox.currentData()
    #      print('ARD port set to ={0}'.format(self.ARDPort))
    #  else:
    #      print('no ARD detected')

    @pyqtSlot()
    def on_trialOn(self):
        print('trial starting')
        self.flowOn = False
        self.resetARD()
        self.trialTimer.restart()
        self.trialOn = True

    @pyqtSlot()
    def on_trialOff(self):
        print('trial ended')
        self.trialTimer.restart()
        self.trialOn = False
        self.flowOn = False
        self.resetARD()

    @pyqtSlot()
    def on_ARDreset(self):
        print('resetting ARD')
        self.resetFlowRate()

    @pyqtSlot()
    def on_flowOn1(self):
        print('changing flow rate')
        try:
            self.Ard.sendChar('u')
            self.resetARD()
        except:
            pass

    @pyqtSlot()
    def on_flowOn0(self):
        print('changing flow rate')
        try:
            self.Ard.sendChar('d')
            self.resetARD()
        except:
            pass

    @pyqtSlot()
    def on_flowOff1(self):
        print('changing flow rate')
        try:
            self.Ard.sendChar('k')
            self.resetARD()
        except:
            pass

    @pyqtSlot()
    def on_flowOff0(self):
        print('changing flow rate')
        try:
            self.Ard.sendChar('j')
            self.resetARD()
        except:
            pass

    @pyqtSlot()
    def on_lightOn(self):
        self.flowOn = True
        self.resetARD()

    @pyqtSlot()
    def on_lightOff(self):
        self.flowOn = False
        self.resetARD()

    @pyqtSlot()
    def on_slidervaluechange(self):
        self.pVal = int(self.slider.value())
        self.Tracker.pVal = self.pVal
        self.textSlider.setText(str(self.pVal))

    @pyqtSlot()
    def on_slider2valuechange(self):
        self.pVal_mx = int(self.slider2.value())
        self.Tracker.pVal_mx = self.pVal_mx
        self.textSlider2.setText(str(self.pVal_mx))

    @pyqtSlot()
    def on_ROIslidervaluechange(self):
        self.area_mn = int(self.ROIslider.value())
        self.Tracker.area_mn = self.area_mn
        self.ROItextSlider.setText(str(self.area_mn))

    @pyqtSlot()
    def on_start(self):
        if self.recording:
            print('current recording being stopping...')
            print('number of previously saved frames:\n{0}'.\
                  format(self.num_saved_frame))

            self.recording = False
            sleep(0.02)
            try:
                self.recorder.release_writer()
            except:
                pass
            sleep(0.02)
        print('new recording starting...')
        self.initialise_videorecorder()
        self.recording = True

    @pyqtSlot()
    def on_saveClick(self):
        self.on_start()
        if self.save_btn.isChecked():
            try:
                self.recorder.initialise_writer()
                print('writer initialised')
                sleep(0.02)
                self.save = self.save_btn.isChecked()
            except:
                print('couldn\'t initialise writer')
        else:
            try:
                self.recorder.release_writer()
            except:
                print('couldn\'t release writer')
                pass

    @pyqtSlot()
    def on_stop(self):
        print('current recording being stopping...')
        print('number of previously saved frames:\n{0}'.\
                  format(self.num_saved_frame))
        self.recording = False
        self.save = False
        self.save_btn.setChecked(self.save)

        try:
            self.recorder.release_writer()
            self.num_saved_frame = 0
        except:
            pass

    @pyqtSlot()
    def on_ROIinit(self):
        print('initiliase ROI')
        self.initialise_ROI()

    @pyqtSlot()
    def on_quit(self):
        print('stopping threads...')
        self.flowOn = False
        self.resetARD()
        self.recording = False
        self.trialOn = False
        sleep(0.5)
        print('number saved frames:\n{0}'.\
                  format(self.num_saved_frame))
        try:
            self.recorder.release_writer()
        except:
            pass
        try:
            self.recorder.release_camera()
        except:
            pass

        self.recordingThread.stop()
        self.trialThread.stop()

    def resetARD(self):
        if self.flowOn == False:
            if self.ARD:
                print('0')
                self.Ard.sendChar('0')
        if self.flowOn == True:
            if self.ARD:
                self.Ard.sendChar('1')

    def resetFlowRate(self):
        if self.ARD:
            self.Ard.sendChar('r')
            self.resetARD()

    def resetPath(self):
        self.dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")[2:]
        self.path = self.get_path()
        self.path_bx.setText(self.path)

    def kill_threads(self):
        self.recording = False
        self.trialOn = False

    def start_recording(self):
        while self.recording:
            self.frame_loop()

    def start_trial(self):
        while self.trialOn:
            self.trial_loop()

    ##########################
    ##### Thread functions
    ##########################
    def trial_loop(self):
        time_ = self.trialTimer.get_time()
        self.time_left = self.trialTime - int(time_)
        self.Timer_tbox.setText(str(self.time_left))
        if time_ > self.trialTime:
            print('new trial')
            self.flowOn = True
            self.resetARD()
            sleep(int(self.trialSleepTime))
            self.flowOn = False
            self.resetARD()
            self.trialTimer.restart()

    def frame_loop(self):
        self.gray = self.grab_frame()
        self.blur = self.Tracker.blur_frame(self.gray)
        self.mvAvgFrame = self.update_avg()
        self.fD = self.Tracker.delta_frame(self.mvAvgFrame, self.blur)

        self.mask, self.masked = self.Tracker.mask_frame(self.fD,
                                                         pVal=self.pVal,
                                                         pVal_mx=self.pVal_mx)

        self.fD_, self.keypoints, self.num_fish_detected, self.max_a\
        = self.Tracker.get_frame_contours(self.masked, self.fD)

        self.maxArea_box.setText(str(self.max_a))
        self.num_detected_box.setText(str(self.num_fish_detected))

        if self.save:
            self.num_saved_frame += 1
            try:
                self.recorder.save_frame(self.gray)
            except:
                print('couldn\'t save file')
        self.show_frame()

    ##########################
    ##### detection functions
    ##########################

    def grab_frame(self):
        try:
            (grabbed, frame) = self.camera.read()
            self.frame = cv2.resize(frame, (self.imW, self.imH))
            self.gray = cv2.cvtColor(self.frame, cv2.COLOR_BGR2GRAY)
            #self.frame = cv2.cvtColor(self.frame , cv2.COLOR_BGR2HSV)[:,:,1] # saturation
        except:
            print('couldn\'t grab frame')
            pass
        return self.gray

    def update_avg(self):
        if self.mvAvgFrame is None:
            self.mvAvgFrame = self.blur
        else:
            self.ite += 1
            fr = self.ite
            if fr > 10000:
                print('reset')
                self.ite = 1
                self.mvAvgFrame = self.mvAvgFrame
            else:
                self.mvAvgFrame = self.mvAvgFrame * (
                    fr / (fr + 1)) + self.blur / (fr + 1)
        return self.mvAvgFrame

    def show_frame(self):
        if self.ite % 4 == 0:
            self.imv1.setImage(self.gray.T)
        elif self.ite % 4 == 1:
            self.imv4.setImage(self.mvAvgFrame.T.astype('uint8'))
        elif self.ite % 4 == 2:
            self.imv2.setImage(self.fD_.swapaxes(0, 1))
        elif self.ite % 4 == 3:
            self.imv3.setImage(self.mask.T)
Example #31
0
 def __init__(self, label):
     MyThread.__init__(self)
     self.label=label
     self.bridgeutil=BridgeUtils()
Example #32
0
class MyVideoRecorder(object):
    def __init__(self, opt=1):

        ####################
        #### args
        ####################
        self.ap = argparse.ArgumentParser()
        self.default_path = '/Users/virginiarutten/Documents/deep_fish/videos'
        self.ap.add_argument("-v", "--video", \
                             default = self.default_path, help="path to the video file")
        self.ap.add_argument("-f",
                             "--fps",
                             type=str,
                             default=str(10),
                             help="fps")

        self.ap.add_argument("-p", "--path", type = str, \
                             default=self.default_path, help="path to which to save videos")
        file_name = 'test_delete'
        self.ap.add_argument("-n",
                             "--name",
                             type=str,
                             default=file_name,
                             help="filename")
        self.ap.add_argument("-r",
                             "--resize",
                             type=bool,
                             default=True,
                             help="filename")

        self.ap.add_argument("-c",
                             "--cam",
                             type=int,
                             default=1,
                             help="camera number")
        self.ap.add_argument("-t",
                             "--max_time",
                             type=int,
                             default=10,
                             help="camera number")
        self.ap.add_argument("-w",
                             "--wait_time",
                             type=int,
                             default=100,
                             help="camera number")

        if opt == 1:
            self.args = vars(self.ap.parse_args())
        else:
            self.args = vars(self.ap.parse_known_args()[0])

        self.wait_time = self.args['wait_time'] / 1000
        self.dt = datetime.datetime.now().strftime("%Y%m%d-%H%M%S")[2:]
        self.output = self.args['path'] + '/' + self.args[
            'name'] + self.dt + '.avi'
        #self.fps = int(self.args['fps'])
        self.fps = np.ceil(1 / self.wait_time)
        self.cam = self.args['cam']
        self.resize = self.args['resize']
        self.max_time = self.args['max_time']
        print('output file:{0}'.format(self.output))

        #################
        ### settings
        ###############
        self.fourcc = cv2.VideoWriter_fourcc(*'XVID')
        self.imH = int(360 / 2)
        self.imW = int(640 / 2)
        self.recording = False

        self.initialiseCap()
        self.initialiseWriter()
        time.sleep(.2)
        self.grabFrame()
        self.initialise_window()
        self.show_frame()

        self.recording = True
        self.recordingThread = MyThread(self.start_recording, self.wait_time)
        self.recordingThread.start()

        self.count = 0
        self.Timer = MyTimer()
        self.Timer.restart()

    def initialise_window(self):

        self.app = QtGui.QApplication([])
        self.win = MyQtWidget()
        self.win.load_picture()
        title = 'deep fish detection'
        self.win.setWindowTitle(title)
        self.imv1 = RawImageWidget(scaled=True)
        self.imv1.setImage(self.win.bkImage)

        self.layout = QtGui.QGridLayout()
        self.win.setLayout(self.layout)
        self.layout.addWidget(self.imv1)
        self.win.show()

    def show_frame(self):
        tmp = self.frame.swapaxes(0, 1)[:, :, ::-1]
        self.imv1.setImage(tmp)

    def convert2gif(self):
        self.gif = MyGif(self.output, array, fps=self.fps, scale=1.0)

    def start_recording(self):
        while self.recording:
            self.record_loop()

    def pause(self):
        self.recording = False

    def initialiseCap(self):
        self.cap = cv2.VideoCapture(self.cam)

    def initialiseWriter(self):
        self.writer =  cv2.VideoWriter(self.output,fourcc = self.fourcc,\
                                       fps = self.fps, \
                                       frameSize = (self.imW,self.imH))

    def record_loop(self):
        tmp = self.Timer.get_time()
        if tmp > self.max_time:
            print('time limit reached')
            print(self.Timer.get_time())
            self.recording = False
            self.stop()
        else:
            self.grabFrame()
            if self.ret:
                self.count += 1
                if self.count % 100 == 0:
                    print(self.count)
                    print(self.Timer.get_time())
                self.writer.write(self.frame)
                self.show_frame()

    def grabFrame(self):
        self.ret, self.frame = self.cap.read()
        if self.ret:
            self.frame = cv2.resize(self.frame,
                                    (self.imW, self.imH)).astype('uint8')
        else:
            print('no frame captured')
            pass

    def releaseCap(self):
        self.cap.release()

    def stop(self):
        print('stop function has been called')
        print('total time = {0}'.format(self.Timer.get_time()))
        print('total frames = {0}'.format(self.count))
        print('approx fps = {0}'.format(int(self.count /
                                            self.Timer.get_time())))
        self.recording = False
        self.writer.release()
        self.releaseCap()
        print('\nfile saved at:\n{0}'.format(self.output))
Example #33
0
        h = str(link['href'])
        n = h.replace(l + "/", "")
        try:
            a.append(int(n))
        except Exception as e:
            print(e)
    _max = max(a)
    for i in range(1, _max):
        u = str(l + "/" + str(i))
        url_list.append(u)
    return url_list


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument("echo")
    args = parser.parse_args()
    url = str(args.echo)
    print("开始解析:" + url)

    html = get_html(url)
    soup = get_soup(html)
    img_dirs = get_img_dirs(soup)
    if None == img_dirs:
        print("无法获取该网页下的相册内容...")
    else:
        for d in img_dirs:
            my_thread = MyThread(download_imgs, (d, img_dirs.get(d)))
            my_thread.start()
            my_thread.join()
Example #34
0
 def startThread(self):
     #thread.Thread(target=self.recvData).start()
     thread1 = MyThread().createThread(self.startTCP)
     thread1.start()
     # thread2 =
     return thread1
Example #35
0

#/cn/actresses/page/2
if __name__ == '__main__':
    i = 7
    while i < 10000:
        url = "https://avmoo.asia/cn/actresses/page/" + str(i)
        print("开始解析:" + url)
        if 1 == i:
            refer = 'https://avmoo.asia/cn/actresses/2'
        else:
            refer = 'https://avmoo.asia/cn/actresses/' + str(i - 1)
        i = i + 1
        # 女星姓名 + 跳转链接的map表
        img_dirs = get_current_thumbs_list(url, refer)
        if None == img_dirs:
            print("无法获取该网页下的相册内容...")
            break
        else:
            for d in img_dirs:
                if consume_last(d):
                    continue
                # print(img_dirs.get(d))
                url_parser = img_dirs.get(d)
                # 爬取女星的资料
                # download_imgs((d, url_parser, refer, [1, url_parser]))
                my_thread = MyThread(download_imgs,
                                     (d, url_parser, refer, [1, url_parser]))
                my_thread.start()
                my_thread.join()
        print("[Main], " + str(i))
Example #36
0
def test_model(sess, minibatch):
    # test and validate model
    if conf.test_mode:
        run_batch(sess, mtest, test_data, tf.no_op(), minibatch)

    t_train = MyThread(run_batch, (sess, m, train_data, tf.no_op(), minibatch))
    t_test = MyThread(run_batch,
                      (sess, mtest, test_data, tf.no_op(), minibatch))
    t_val = MyThread(run_batch, (sess, mval, val_data, tf.no_op(), minibatch))

    t_train.start()
    t_test.start()
    t_val.start()

    t_train.join()
    result_train = t_train.get_result()
    t_test.join()
    result_test = t_test.get_result()
    t_val.join()
    result_val = t_val.get_result()

    result = result_train + result_test + result_val
    monitor.new(result, minibatch)
    return result
Example #37
0
def Principal_function(messagerow,soup,route,subtitle,response,movie_type,Complete):
    medium = messagerow[0]
    code = messagerow[1]
    resolving_power = messagerow[2]
    Audio_coding = messagerow[3]
    region = messagerow[4]
    Production_team = messagerow[5]
    info = vidioparme(soup)
    judge_info=''
    if info[0] ==False:
        info=str(info[1])
        judge_info = '===info错误,没用quote括起来'
    else:
        info=str(info)
    x_info = re.findall('data-cfemail="(.*)" href="/cdn-cgi/l/email-protection', info)
    if x_info:
        email_ = email_jimi(x_info[0])
        info = re.sub('<a class="__cf_email__".*>', email_, info)
    title = title_get(soup)
    title_check_ans = title_check(title)
    # 创建9个线程
    task = MyThread(medium_check_All, (route, medium, info, title, soup))
    task2 = MyThread(check_code_All, (code, info, medium, route, title))
    task3 = MyThread(check_Audio_coding_All, (Audio_coding, info, Production_team, title))
    task4 = MyThread(check_resolving_power_All, (resolving_power, info, medium, route, title,movie_type))
    task5 = MyThread(check_region_all, (soup, region))
    task6 = MyThread(team_processing, (route, medium, title,info))
    task7 = MyThread(tag_check, (title, response, medium, subtitle, info, Production_team,Complete,region))
    task8 = MyThread(link_check, (soup, response))
    task9=MyThread(movie_type_check_All,(movie_type, medium, resolving_power, title))
    #task10=MyThread(img_check,(soup,imgheaders))
    task.start(),task2.start(),task3.start(),task4.start(),task5.start(),task6.start()
    task7.start(),task8.start(),task9.start(),
    task.join()
    task2.join()
    task3.join()
    task4.join()
    task5.join()
    task6.join()
    task7.join()
    task8.join()
    task9.join()
    if title_check_ans:
        title = title + title_check_ans
    return title, subtitle, task9.get_result(), messagerow, task.get_result(),task2.get_result(),task3.get_result(),\
           task4.get_result(),task5.get_result(),task6.get_result(),task7.get_result(),task8.get_result()+judge_info
Example #38
0
       URL            TEXT    NOT NULL);''')
    print "GALLERY Table created successfully";

    conn.execute('''CREATE TABLE IF NOT EXISTS PHOTO 
       (ID INTEGER PRIMARY KEY AUTOINCREMENT,
       GALLERY       INTEGER         NOT NULL,
       URL           TEXT    NOT NULL);''')
    print "PHOTO Table created successfully";

    parser = argparse.ArgumentParser()
    parser.add_argument("echo")
    # parser.add_argument("url")
    # url = int(args.url)
    args = parser.parse_args()
    url = str(args.echo)
    print("开始解析:" + url)

    html = get_html(url)
    soup = get_soup(html)
    img_dirs = get_img_dirs(soup)
    if None == img_dirs:
        print("无法获取该网页下的相册内容...")
    else:
        for d in img_dirs:
            my_thread = MyThread(fetch_imgs, (d, img_dirs.get(d)))
            my_thread.start()
            my_thread.join()



Example #39
0
def test_model(sess, minibatch):
    # test and validate model
    if conf.test_mode:
        run_batch(sess, mtest, test_data, tf.no_op(), minibatch)

    t_train = MyThread(run_batch, (sess, m, train_data, tf.no_op(), minibatch))
    t_test = MyThread(run_batch,
                      (sess, mtest, test_data, tf.no_op(), minibatch))
    t_val = MyThread(run_batch, (sess, mval, val_data, tf.no_op(), minibatch))

    t_train.start()
    t_test.start()
    t_val.start()

    t_train.join()
    result_train = t_train.get_result()
    t_test.join()
    result_test = t_test.get_result()
    t_val.join()
    result_val = t_val.get_result()

    print("Train cost {0:0.3f}, Acc {1:0.3f}".format(result_train[0],
                                                     result_train[1]))
    print("Valid cost {0:0.3f}, Acc {1:0.3f}".format(result_val[0],
                                                     result_val[1]))
    print("Test  cost {0:0.3f}, Acc {1:0.3f}".format(result_test[0],
                                                     result_test[1]))

    return result_train + result_test + result_val
def add_new_pic(face_recognization):
    while True:
        # 直接请求本地的服务,加入LSH Forest
        face_recognization.add_all_new_pic()
        time.sleep(10)


if __name__ == "__main__":
    sub_process_id = ''
    try:
        face_recognition = FaceRecognition()
        face_recognition.load_all_data()
        application = tornado.web.Application([
            (r"/", MainHandler),
        ])

        add_new_pic_args = (face_recognition, )
        add_new_pic_thread = MyThread(func=add_new_pic,
                                      args=add_new_pic_args,
                                      name='add_new_pic')

        add_new_pic_thread.start()

        application.listen(port)
        tornado.ioloop.IOLoop.instance().start()

        add_new_pic_thread.join()
    except:
        traceback.print_exc()
Example #41
0
class MyApp:
    def __init__(self):
        ## 변수
        self.key = ""
        self.apiGetter = LolApiGetter()
        self.popupMaker = PopupMaker()
        self.nickname = ""

        ## 쓰레드
        self.t = MyThread()
        self.t.daemon = True  # 부모 종료 시 같이 종료
        self.t.setApiGetter(self.apiGetter)
        self.t.setPopupMaker(self.popupMaker)

        ## UI
        self.root = Tk()
        self.main_frame = Frame(self.root)
        self.main_frame.pack()

        self.label = Label(self.main_frame, text="API KEY")
        self.label.pack()
        self.txt_key = Entry(self.main_frame)
        self.txt_key.pack()

        self.label2 = Label(self.main_frame, text="소환사 이름")
        self.label2.pack()
        self.txt = Entry(self.main_frame)
        self.txt.pack()

        self.btn_ok = Button(self.main_frame,
                             text="OK",
                             command=self.setNicknameByBtn)
        self.btn_ok.pack()

        self.txt.focus_force()
        self.root.mainloop()

    def setNicknameByBtn(self):
        self.nickname = self.txt.get()
        self.apiGetter.setApiKey(self.txt_key.get())

        if self.nickname == "":
            messagebox.showinfo("알림", "닉네임을 입력해주세요")
        else:
            messagebox.showinfo("이름", self.nickname)
            self.main_frame.destroy()
            self.main_frame = Frame(self.root)
            self.main_frame.pack()
            new_label = Label(self.main_frame, text="실행중")
            new_label.pack()

            self.t.setNickname(self.nickname)
            self.t.start()

    def tt(self):
        toplevel = Toplevel()

        frame = Frame(toplevel, background="white")
        frame.pack(side=LEFT)
        name_label = Label(frame, text="name", background="white")
        name_label.pack()
        tier_label = Label(frame, text="tier", background="white")
        tier_label.pack()

        toplevel.attributes('-topmost', 'true')
        toplevel.after(3000, lambda: toplevel.destroy())
Example #42
0
def client_main(bg, screen, WINDOW_W, WINDOW_H, SERVER_ADDR, SERVER_PORT_DISP, player_name):

    # Инициация PyGame, обязательная строчка
    #pygame.init()
    #pygame.event.set_allowed([pygame.QUIT, pygame.KEYDOWN, pygame.KEYUP])

    #  инициализация окна
    #bg, screen = window_init(WINDOW_W, WINDOW_H, "#000000", "PyTanks")

    label_bg = Surface((WINDOW_W,WINDOW_H))
    label_bg.fill((54,64,74))

    # группы объектов
    players = pygame.sprite.Group()
    players_bullets = pygame.sprite.Group()

    # создаем асинхронный клиент
    game_client = Client((SERVER_ADDR, SERVER_PORT_DISP))

    # запускаем цикл опроса сокетов
    socket_loop_thread = MyThread(asyncore.loop, [0.01])
    socket_loop_thread.start()

    # отправляем серверу свое имя
    #message = pack_data(player_name)
    #game_client.obuffer = message

    # получаем собственный идентификатор
    #while len(game_client.imes) <= 0:
        #time.sleep(1)

    #my_id = player_name
    my_id = game_client.addr[1]

    # получаем первоначальную инфу
    flag = True
    while flag:
        if len(game_client.imes) > 0:
            data = game_client.imes.pop(0)
            if 'params' in data.keys():
                init_data = data
                flag = False

    #print(game_client.imes)
    #init_data = game_client.imes.pop(0)

    FRAME_RATE = init_data['params']['frame_rate']
    #['params'] = {'total_width': total_level_width, 'total_height': total_level_height, 'width': level_width,
    #                      'height': level_height, 'block_demage': BLOCK_DEMAGE}

    # генерируем уровень
    total_level_width = init_data['params']['total_width']
    total_level_height = init_data['params']['total_height']

    blocks = gen_client_level(init_data['blocks'], init_data['params']['block_demage'])

    # создаем героев
    # {'id' : player.addr[0], 'x' : player.sprite.rect.x, 'y' : player.sprite.rect.y,
    # 'team' : player.team, 'dead_count': player.config.dead_count}
    players_list = init_data['players']
    for player_item in players_list:
        x = player_item['x']
        y = player_item['y']
        id = player_item['id']
        team = player_item['team']
        dead_count = player_item['dead_count']
        tank_config = Tank_config(x, y, dead_count)
        player = Tank(tank_config, id, team, 0)
        players.add(player)
        if id == my_id:
            i_am = player

    #создаем камеру
    camera = Camera(camera_configure, total_level_width, total_level_height, WINDOW_W, WINDOW_H)

    # таймер
    timer = pygame.time.Clock()

    # надпись
    font = pygame.font.Font('freesansbold.ttf', 12)

    dropped_frames = 0
    empty_queue = 0

    # Основной цикл программы
    while 1:

        if game_client.socket._closed:
            #pygame.quit()
            return

        timer.tick(FRAME_RATE) # таймер на 30 кадров

        # отправляем произошедшие события на сервер
        event_queue = []
        for e in pygame.event.get():
            # выход
            if e.type == pygame.QUIT or (e.type == pygame.KEYDOWN and e.key == pygame.K_ESCAPE):
                #pygame.quit()
                # упаковываем данные
                message = pack_data("exit")
                game_client.obuffer = message
                game_client.close()
                return

            # нажатие клавиши на клавиатуре
            if (e.type == pygame.KEYDOWN) or (e.type == pygame.KEYUP):
                event_item = {'type': e.type, 'key': e.key}
                event_queue.append(event_item)

        # упаковываем данные
        out_data = {'id': my_id, 'name': player_name, 'events': event_queue}
        message = pack_data(out_data)
        game_client.obuffer = message

        # получаем очередной пакет данных
        l = len(game_client.imes)
        if l > 0:
            if l > MAX_LEN_QUEUE:
                game_client.imes = game_client.imes[-MAX_LEN_QUEUE:]
                dropped_frames += (l - 3)
            dataframe = game_client.imes.pop(0)
        else:
            dataframe = {'blocks': [], 'players': [], 'bullets': [], 'disconnected': []}
            empty_queue += 1

        #блоки dataframe["blocks"] = {"id" : b.id, "shootdirection" : b.shootdirection}
        blocks_list = dataframe['blocks']
        for block_data in blocks_list:
            for block in blocks.sprites():
                if block.id == block_data['id']:
                    block.die(block_data['shootdirection'])
                    break

        # dataframe['disconnected'] - отключившиеся игроки
        disconnected = dataframe['disconnected']
        for player in players.sprites():
            if player.id in disconnected:
                player.kill()

        # игроки dataframe["players"] = {'id': player.id, 'name': player.name, 'x': player.sprite.rect.x, 'y': player.sprite.rect.y,
        #                'course': player.sprite.course, 'shutdirection': player.sprite.shutdirection,
        #                'dead': player.sprite.dead, 'team' : player.team, 'dead_count': player.sprite.config.dead_count,
        #                'frag': player.sprite.frag}
        players_list = dataframe['players']
        for player_item in players_list:
            found = False
            for player in players.sprites():
                if player.id == player_item['id']:
                    player.name = player_item['name']
                    player.update(player_item['x'], player_item['y'],
                                  player_item['course'], player_item['shutdirection'], player_item['dead'],
                                  player_item['frag'])
                    found = True
                    break
            if not found:
                x = player_item['x']
                y = player_item['y']
                id = player_item['id']
                team = player_item['team']
                dead_count = player_item['dead_count']
                frag = player_item['frag']
                tank_config = Tank_config(x, y, dead_count)
                new_player = Tank(tank_config, id, team, frag)
                players.add(new_player)

        # пули
        #{'id': b.id, 'x': b.rect.x, 'y': b.rect.y, 'shutdirection' : b.shutdirection, 'bum': b.bum}
        bullets_list = dataframe['bullets']
        for bullet_item in bullets_list:
            id = bullet_item['id']
            x = bullet_item['x']
            y = bullet_item['y']
            shutdirection = bullet_item['shutdirection']
            bum = bullet_item['bum']
            found = False
            for b in players_bullets.sprites():
                if b.id == id:
                    found = True
                    b.update(x, y, bum)
                    break
            if not found:
                b = Bullet(id, x, y, shutdirection)
                players_bullets.add(b)

        camera.update(i_am, WINDOW_W, WINDOW_H) # центризируем камеру относительно персонажа

        # Каждую итерацию необходимо всё перерисовывать
        screen.blit(bg, (0,0))

        # рисование блоков
        entities = blocks.sprites()
        for e in entities:
            screen.blit(e.image, camera.apply(e))

        # рисование танков
        entities = players.sprites()
        for e in entities:
            topleft = camera.apply(e)
            screen.blit(e.image, topleft)
            if e.team == "green":
                label = font.render(e.name, True, Color("green"))
            else:
                label = font.render(e.name, True, Color("yellow"))
            screen.blit(label, (topleft[0], topleft[1]+28))

        # рисование пуль
        entities = players_bullets.sprites()
        for e in entities:
            screen.blit(e.image, camera.apply(e))

        # выводим списки игроков
        screen.blit(label_bg, (WINDOW_W,0))

        i = 30
        team_count = 0
        for player in players:
            if player.team == "yellow":
                team_count += player.frag
                label = font.render("     " + player.name + " ["+str(player.frag)+"]", True, Color("yellow"))
                screen.blit(label, (WINDOW_W, i))
                i+=20
        i += 20
        label = font.render(' YELLOW team: '+ str(team_count), True, Color("yellow"))
        screen.blit(label, (WINDOW_W, 10))

        team_count = 0
        l_x = i
        i += 20
        for player in players:
            if player.team == "green":
                team_count += player.frag
                label = font.render("     " + player.name + " ["+str(player.frag)+"]", True, Color("green"))
                screen.blit(label, (WINDOW_W, i))
                i+=20
        label = font.render(' GREEN team: '+ str(team_count), True, Color("green"))
        screen.blit(label, (WINDOW_W, l_x))

        # выводим строчки со служебной инфой
        label = font.render(' fps=%.2f ' % timer.get_fps(), True, (255,255,255))
        screen.blit(label, (WINDOW_W, WINDOW_H - 60))
        label = font.render(' len_queue=%d ' % len(game_client.imes), True, (255,255,255))
        screen.blit(label, (WINDOW_W, WINDOW_H - 45))
        label = font.render(' dropped_frames=%d ' % dropped_frames, True, (255,255,255))
        screen.blit(label, (WINDOW_W, WINDOW_H - 30))
        label = font.render(' empty_queue=%d ' % empty_queue, True, (255,255,255))
        screen.blit(label, (WINDOW_W, WINDOW_H - 15))

        # обновление и вывод всех изменений на экран
        pygame.display.update()
Example #43
0
 def __init__(self, label,ip,port):
     MyThread.__init__(self)
     self.m_label=label
     self.m_ip=ip
     self.m_port=port