def get(self, meigen_id): # 名言個別ページを表示する if meigen_id: PortalMeigenHandler.individual(self, meigen_id) # 名言一覧ページを表示する else: Viewer.generate(Viewer(), self.response, LIST_TEMPLATE_PATH, { 'meigens': Meigen.all().order('-created_on') })
def get(self): # 編集確認 person_id = self.request.get("id") person_obj = '' if (person_id): person_obj = Person.get( person_id ) # 所有しない発言者IDを指定された場合は一覧へリダイレクトする if person_obj and person_obj.owner != users.get_current_user(): self.redirect(urls.APP_PERSON_URL) return # 所有する発言者を取得します query = Person.all() query.filter( 'owner = ', users.get_current_user() ) query.order('-created_on') owned_persons = query.fetch(limit = 1000) # 所有する発言者の名言を取得する meigens = '' if person_obj: query = Meigen.all() query.filter( 'owner = ', users.get_current_user() ) query.filter( 'person = ', person_obj ) meigens = query.fetch(limit = 1000) # 画面を表示する Viewer.generate(Viewer(), self.response, TEMPLATE_PATH, { 'persons': owned_persons, 'current_person': person_obj, 'meigens': meigens } )
class Scheduler(object): ''' Schedules the content in the playlist to be displayed. The scheduling occurs in its own thread. To ensure thread safety, the play list should be modified using the modify_playlist_atomically() method. ''' def __init__(self): self.logger = logging.getLogger(__name__) self.logger.debug('Initializing scheduler') self.viewer = Viewer() self._playlist = [] self._playlist_lock = Lock() self.running = False def start(self): self.logger.debug('Starting scheduling') self.running = True def is_interrupted_func(content): return content not in self._playlist def schedule_worker(scheduler): self.logger.debug('Scheduling thread started') index = 0 while scheduler.running: lock = scheduler._playlist_lock lock.acquire() try: playlist = scheduler._playlist content_index = index % len(playlist) content = playlist[content_index] finally: lock.release() self.logger.debug('Scheduler began displaying %s', content) scheduler.viewer.display_content(content, is_interrupted_func) index += 1 scheduler.viewer.shutdown() self.logger.debug('Exiting scheduler worker thread') self.work_thread = Thread(target=schedule_worker, args=(self,)) self.work_thread.daemon = True self.work_thread.start() def shutdown(self): self.logger.debug('Scheduler shutdown called') self.running = False self.viewer.shutdown() self.logger.debug('Scheduler waiting for worker thread to stop') self.work_thread.join() self.logger.debug('Scheduler shut down complete') def modify_playlist_atomically(self, modifier_function): self.logger.debug('Modifying scheduler playlist atomically') self._playlist_lock.acquire() try: modifier_function(self._playlist) finally: self._playlist_lock.release()
class StateView(QtGui.QMainWindow): def __init__(self, window): QtGui.QMainWindow.__init__(self) self.ui = Ui_StateView() self.ui.setupUi(self) self.viewer = Viewer("pydot") self.connect(self.ui.btShowSingleState, SIGNAL("clicked()"), self.showSingleState) self.connect(self.ui.btShowWholeGraph, SIGNAL("clicked()"), self.showWholeGraph) self.window = window def showWholeGraph(self): editor = self.window.getEditor() self.viewer.create_pydot_graph(editor.tm.get_mainparser().graph) self.showImage(self.ui.gvStategraph, self.viewer.image) def showSingleState(self): editor = self.window.getEditor() self.viewer.show_single_state(editor.tm.get_mainparser().graph, int(self.ui.leSingleState.text())) self.showImage(self.ui.gvStategraph, self.viewer.image) def showImage(self, graphicsview, imagefile): scene = QGraphicsScene() item = QGraphicsPixmapItem(QPixmap(imagefile)) scene.addItem(item); graphicsview.setScene(scene) graphicsview.resetMatrix()
def get(self): # パラメータ取得 twitter_id = self.request.get("id") # パラメータがなければ一覧へ if not twitter_id: self.redirect(urls.APP_INDEX_URL) return # データ取得 twitter_obj = Twitter.get( twitter_id ) # データがない! if not twitter_obj: # 無言で一覧へいかせるのさ self.redirect(urls.APP_INDEX_URL) return # 画面を表示する Viewer.generate( Viewer(), self.response, TEMPLATE_APP_INDEX_PATH, { 'current_twitter': twitter_obj, 'owned_twitters': models.get_owned_twitters( users.get_current_user() ) })
def test_execution_fail(self, mock_call, mock_exists): mock_call.side_effect = OSError("mock execution failed") v = Viewer(self.prog) deleted_pics = v.show(self.pics) self.assertListEqual(deleted_pics, []) self.assertTrue(self.viewer_err_logger.called)
def test_execution_error(self, mock_call, mock_exists): mock_call.return_value = 5 v = Viewer(self.prog) deleted_pics = v.show(self.pics) self.assertListEqual(deleted_pics, []) self.assertTrue(self.viewer_err_logger.called)
def get(arg): """defines get command""" if arg != "dashboard": args = arg.split(' ') if args[0] == "avatar": viewer = Viewer(client) viewer.viewAvatar(args[1])
def get(self): # 新着名言を指定数取得する query = Meigen.all().order('-created_on') meigens = query.fetch( limit = DISPLAY_NUMBER ) # 画面を表示する # http://morchin.sakura.ne.jp/effective_python/method.html Viewer.generate(Viewer(), self.response, TEMPLATE_PATH, { 'meigens': meigens })
def get(self): # 所有する新着名言を指定数取得する query = Meigen.all() query.filter( 'owner = ', users.get_current_user() ) query.order('-created_on') owned_meigens = query.fetch( limit = DISPLAY_NUMBER ) # 画面を表示する Viewer.generate(Viewer(), self.response, TEMPLATE_PATH, { 'meigens': owned_meigens } )
def get(self): # Userモデルに未登録だったら登録する user_obj = users.get_current_user() account = Account.get_or_insert( user_obj.user_id(), owner = user_obj, user_id = user_obj.user_id() ) # 画面表示 Viewer.generate(Viewer(), self.response, TEMPLATE_PATH, {} )
def get(self): # 画面を表示する # http://morchin.sakura.ne.jp/effective_python/method.html Viewer.generate( Viewer(), self.response, TEMPLATE_APP_INDEX_PATH, { 'owned_twitters': models.get_owned_twitters( users.get_current_user() ) })
def view_pics(rep, prog): """ Launch external viewer and keep track of pictures deleted within. Arguments: rep -- View pictures from this repository. """ if not prog: prog = rep.config['viewer.prog'] v = Viewer(prog) deleted_pics = v.show(rep.index.pics()) remove_pics(rep, [pic.filename for pic in deleted_pics])
def test_execution_sucess(self, mock_call, mock_exists): mock_call.return_value = 0 mock_exists.return_value = True v = Viewer(self.prog) deleted_pics = v.show(self.pics) actual_call_args = mock_call.call_args_list[0][0][0] expected_call_args = self.prog.split() + sorted(self.thumbs) self.assertItemsEqual(expected_call_args, actual_call_args) self.assertListEqual(deleted_pics, []) self.assertFalse(self.viewer_err_logger.called)
def _refresh(self, pillow, path): if self._path is None: return try: # selection changed! if path == self._path + ".*": try: idx = PathHelper.getValue(self._document.selection, path + '._selection') if self._delegate: self._ignoreSelect = True self._delegate.selectRow(idx) except: pass elif Viewer.matchPath(self._path, path, mode=Viewer.OUTER): value = None if self._document: if self._isList: value = self._document.get(self._path, asList=True, wrap=self._wrapInList) else: value = self._document.get(self._path, asDict=True) if value and self._credentials: credential = self._credentials.getFlat(self._path) if credential == None or 'view' in credential or self._path == '_id': if self._delegate: self._delegate.dataCB(value) if not self._resolved: if self._document.hasConflicts(): d = self._document.loadConflicts() d.addCallback(self._conflictsArrived) else: self._noConflict() if self._delegate and self._inserted != None: self._delegate.editRow(self._inserted) else: if self._delegate: self._delegate.dataCB(None) if self._document != None and self._document.selection != None: # FIXME: Should we clear the selection here # if "*" in self._path: # self._document.select(self._path, None) sel = PathHelper.getValue(self._document.selection, self._path + '.*._selection') if sel != None and self._delegate != None: self._delegate.selectRow(sel) elif Viewer.matchPath(self._path, path, mode=Viewer.INNER): if self._delegate: self._delegate.changedCB() except SelectionNotSpecified as e: self._delegate.dataCB(None) self._inserted = None
def _refresh(self, pillow, path): if self.destroyed: return if path == None or self._readonly: self._setReadOnly(True) self._noConflict() return if self._document: try: if Viewer.matchPath(self._path, path, mode=Viewer.OUTER): self._document.get(self._path) if self._credentials: credential = self._credentials.getFlat(self._path) if self._path == '_id' or credential == None or 'edit' in credential: #Hide whole widget self._setReadOnly(self._readonly) if not self._resolved: if self._document.hasConflicts(): d = self._document.loadConflicts() d.addCallback(self._conflictsArrived) else: self._noConflict() except SelectionNotSpecified as e: self._setReadOnly(True) else: self._setReadOnly(True)
def test_deleted_pics(self, mock_call, mock_exists): mock_call.return_value = 0 deleted_thumbs = [pic.get_thumbnail_filenames()[0] for pic in self.pics[4:15:2]] def pic_exists(path): if path in deleted_thumbs: return False else: return True mock_exists.side_effect = pic_exists v = Viewer(self.prog) deleted_pics = v.show(self.pics) self.assertItemsEqual(deleted_pics, self.pics[4:15:2]) self.assertFalse(self.viewer_err_logger.called)
def _refresh(self, pillow, path): from wallaby.common.pathHelper import SelectionNotSpecified from twisted.internet import defer if self._path and Viewer.matchPath(self._path, path, mode=Viewer.OUTER): d = None try: if self._document: name = self._document.get(self._path) if name == None: name = self._path if name != None: d = defer.maybeDeferred(self._document.deferredGetAttachment, name) if d and self._credentials: credential = self._credentials.getFlat(self._path) if credential == None or 'view' in credential: self._cb(d, name) else: d = defer.Deferred() d.callback(None) self._cb(d, None) except SelectionNotSpecified as e: d = defer.Deferred() d.callback(None) self._cb(d, None)
def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ":/icons/settings" self.add_action( icon_path, text=self.tr(u"Show Settings"), callback=self.show_settings, parent=self.iface.mainWindow() ) icon_path = ":/icons/viewer" self.add_action( icon_path, text=self.tr(u"Earthmine Viewer"), callback=self.open_viewer, parent=self.iface.mainWindow() ) self.marker = PostionMarker(self.canvas) self.marker.hide() self.viewer = Viewer(callbackobject=self) self.viewer.trackingChanged.connect(self.marker.setTracking) self.viewer.setLocationTriggered.connect(partial(self.canvas.setMapTool, self.pointtool)) self.viewer.updateFeatures.connect(self.update_earthmine_features) self.viewer.layerChanged.connect(self.iface.setActiveLayer) self.viewer.clearLine.connect(self.clear_bands) self.viewer.closed.connect(self.remove_items) self.iface.currentLayerChanged.connect(self.viewer.update_current_layer) cursor = QCursor(QPixmap(":/icons/location")) self.pointtool.setCursor(cursor) self.pointtool.setAction(self.viewer.setlocationaction)
def __init__(self, root, robotx=0, roboty=0, robota=0, **kwargs): self.robot = RobotView( front=0.15, rear=0.15, left=0.15, right=0.15, wheeldistance=0.315, wheeldiam=0.25, wheelwidth=0.05, x=robotx, y=roboty, a=robota, ) self.llines = [] Viewer.__init__(self, root, **kwargs) self.reset()
def __init__(self, app): self.app = app self.view = Viewer(self) self.model = Model() self.view.show() self.refreshGui()
def __init__(self): self.logger = logging.getLogger(__name__) self.logger.debug('Initializing scheduler') self.viewer = Viewer() self._playlist = [] self._playlist_lock = Lock() self.running = False
class AttachmentAdder(Peer): Add = Pillow.In def __init__(self, room, directAdd=True): Peer.__init__(self, room) self._viewer = Viewer(room, self._setID, '_id') self._directAdd = directAdd self._id = None self._catch(AttachmentAdder.In.Add, self._add) def _setID(self, value): self._id = value @defer.inlineCallbacks def _add(self, pillow, feather): if self._id != None: dialog = QtGui.QFileDialog() dialog.setDirectory(QtCore.QDir.homePath()) dialog.setFileMode(QtGui.QFileDialog.ExistingFiles) if dialog.exec_(): fileNames = dialog.selectedFiles() from twisted.internet import threads import os.path, mimetypes if self._directAdd and self._viewer.document().database() != None: import copy doc = copy.deepcopy(self._viewer.document()._data) db = self._viewer.document().database() else: doc = db = None for f in fileNames: content = yield threads.deferToThread(self.__readFile, f) name = os.path.basename(f) if self._directAdd and db is not None: (t, encoding) = mimetypes.guess_type(name) if t != None: yield db.put_attachment(doc, name, content, t) else: yield db.put_attachment(doc, name, content) else: self._viewer.document().setAttachment(name, content) def __readFile(self, f): return open(f, "rb").read()
def individual(self, person_id): # 発言者取得 person_obj = Person.get(person_id) message = '' if (not person_obj): message = '指定された発言者は登録されていません' # 発言者の名言を取得 query = Meigen.all().order('-created_on') query.filter( 'person = ', person_obj ) meigens_of_person = query.fetch( limit = 1000 ) Viewer.generate(Viewer(), self.response, INDIVIDUAL_TEMPLATE_PATH, { 'current_person': person_obj, 'current_meigens': meigens_of_person, 'persons': Person.all().order('-created_on'), 'message': message })
class Controller: def __init__(self, app): self.app = app self.view = Viewer(self) self.model = Model() self.view.show() self.refreshGui() def event(self, event): print 'Handing event', event try: if event == 'PROJ_SELECT': self._selectProject() elif event == 'LIST_SELECTION_CHANGED': self._listSelectionChanged() self._refreshButtons() elif event == 'ABOUT_MENU_ITEM': self._aboutMenuItem() elif event == 'QUIT_MENU_ITEM': self._quitMenuItem() #these events need a project to be specified already else: if not self.model.project: return if event == 'NEW_BUTTON': self._newButton() elif event == 'OPEN_BUTTON': self._openButton() elif event == 'CHECKIN_BUTTON': self._checkinButton() elif event == 'CHECKOUT_BUTTON': self._checkoutButton() elif event == 'DELETE_BUTTON': self._deleteButton() elif event == 'REFRESH_BUTTON': self._refreshButton() elif event == 'NEW_FILE_MENU_ITEM': self._newFileMenuItem() except UIAbortException, e: pass
def __init__(self, room, directAdd=True): Peer.__init__(self, room) self._viewer = Viewer(room, self._setID, '_id') self._directAdd = directAdd self._id = None self._catch(AttachmentAdder.In.Add, self._add)
def individual(self, meigen_id): meigen_obj = Meigen.get(meigen_id) message = '' if (not meigen_obj): message = '指定された名言は登録されていません' # 発言者の名言を取得 query = Meigen.all().order('-created_on') query.filter( 'person = ', meigen_obj.person ) meigens_of_person = query.fetch( limit = 6 ) Viewer.generate(Viewer(), self.response, INDIVIDUA_TEMPLATE_PATH, { 'current_meigen': meigen_obj, 'meigens_of_person': meigens_of_person, 'meigens': Meigen.all().order('-created_on'), 'message': message })
def __init__(self, window): QtGui.QMainWindow.__init__(self) self.ui = Ui_StateView() self.ui.setupUi(self) self.viewer = Viewer("pydot") self.connect(self.ui.btShowSingleState, SIGNAL("clicked()"), self.showSingleState) self.connect(self.ui.btShowWholeGraph, SIGNAL("clicked()"), self.showWholeGraph) self.window = window
def post(self): # パラメータを取得する twitter_id = self.request.get("twitter_id") consumer_key = self.request.get("consumer_key") consumer_secret = self.request.get("consumer_secret") access_token = self.request.get("access_token") access_token_secret = self.request.get("access_token_secret") mailaddress = self.request.get("mailaddress") # パラメータチェック if (twitter_id == '' or consumer_key == '' or consumer_secret == ''): self.redirect(urls.APP_INDEX_URL) return # データ登録 or 更新 and 取得 twitter_obj = Twitter.get_or_insert( users.get_current_user().user_id() + twitter_id, owner = users.get_current_user(), twitter_id = twitter_id, consumer_key = consumer_key, consumer_secret = consumer_secret, access_token = access_token, access_token_secret = access_token_secret, mailaddress = mailaddress ) twitter_obj.consumer_key = consumer_key twitter_obj.consumer_secret = consumer_secret twitter_obj.access_token = access_token twitter_obj.access_token_secret = access_token_secret twitter_obj.mailaddress = mailaddress twitter_obj.put() # 画面を表示する Viewer.generate( Viewer(), self.response, TEMPLATE_APP_INDEX_PATH, { 'current_twitter': twitter_obj, 'owned_twitters': models.get_owned_twitters( users.get_current_user() ) })
def __init__(self,filename): self.filename = filename self.workfolder = os.path.split(filename)[0] info = os.path.join(os.path.split(filename)[0],os.path.join(self.workfolder,"info.json")) if not os.path.exists(info): os.makedirs(info) image = im.open(filename) width,height = image.size tileSize = 1024 levels = self.levels(width,height,tileSize) tmpinfo = json.dumps({ "width": width, "height" : height, "levels": levels, "tileSize":tileSize }) file(info,'w').write(tmpinfo) Diced = dice(filename) theViewer = Viewer(self.workfolder+'/',5) theViewer.show() coords = [[260, 1185], [609, 1183], [971, 1185], [17418, 1260], [259, 1195], [267, 1544], [277, 1906], [192, 17650]] grid = GridMaker(coords,filename,theViewer.Ti) grid.showWell(20,20)
from viewer import Viewer import auth import dcrator import uuid from time import time from datetime import datetime, timedelta import mantis import json ''' Author: Chen Jiliang Core ID: b099 ''' app = Bottle() viewer = Viewer() ######################################################################Reporter API################################################################### ###########API for add data################### @app.route('/report', method='GET') # Only for test def report_test(): return 'BugReporter Server Works!' @app.route('/report', method='POST') def report_post(): ''' HTTP POST to upload a report string or data file '''
def add_viewer_and_resize(self, data_dict, channel_name=''): visualisers = [] settings = {} for data_type in data_dict.keys(): settings[data_type] = {} if data_type == 'dvs': visualiser = VisualiserDvs(data_dict[data_type]) settings[data_type] = { 'polarised': {}, 'contrast': {}, 'pol_to_show': {} } settings[data_type]['polarised'] = { 'type': 'boolean', 'default': True } settings[data_type]['contrast'] = { 'type': 'range', 'default': 3, 'min': 1, 'max': 20, 'step': 1 } settings[data_type]['pol_to_show'] = { 'type': 'value_list', 'default': 'Both', 'values': ['Pos', 'Neg', 'Both'] } elif data_type == 'frame': visualiser = VisualiserFrame(data_dict[data_type]) elif data_type == 'pose6q': visualiser = VisualiserPose6q(data_dict[data_type]) settings[data_type] = {'interpolate': {}, 'perspective': {}} settings[data_type]['interpolate'] = { 'type': 'boolean', 'default': True } settings[data_type]['perspective'] = { 'type': 'boolean', 'default': True } channel_name = channel_name + '\nred=x green=y, blue=z' elif data_type == 'point3': visualiser = VisualiserPoint3(data_dict[data_type]) settings[data_type] = { 'perspective': {}, 'yaw': {}, 'pitch': {} } settings[data_type]['perspective'] = { 'type': 'boolean', 'default': True } settings[data_type]['yaw'] = { 'type': 'range', 'default': 0, 'min': -90, 'max': 90, 'step': 1 } settings[data_type]['pitch'] = { 'type': 'range', 'default': 0, 'min': -90, 'max': 90, 'step': 1 } elif data_type == 'boundingBoxes': visualiser = VisualiserBoundingBoxes(data_dict[data_type]) settings[data_type] = {'with_labels': {}} settings[data_type]['with_labels'] = { 'type': 'boolean', 'default': True } elif data_type == 'flowMap': visualiser = VisualiserOpticFlow(data_dict[data_type]) else: print("Warning! {} is not a recognized data type. Ignoring.". format(data_type)) continue visualisers.append(visualiser) if visualisers: new_viewer = Viewer() new_viewer.title = channel_name new_viewer.visualisers = visualisers new_viewer.settings = settings self.add_widget(new_viewer) self.cols = int(np.ceil(np.sqrt(len(self.children))))
#np.random.seed(0) # creating players num_creators = 15 num_advertisers = 10 num_viewers = 40 creators = [Creator(i, 5, 1000) for i in range(num_creators)] creators[0].max_p = 30 creators[1].max_p = 20 creators[2].max_p = 8 advertisers = [ Advertiser(i, 1000, num_creators) for i in range(num_advertisers) ] viewers = [Viewer(i, 100, num_creators) for i in range(num_viewers)] rounds = 20 prev_bids = None prev_prices = [None] * num_creators creator_values = [[i] for i in range(num_creators)] advertiser_values = [[i] for i in range(num_advertisers)] viewer_values = [[i] for i in range(num_viewers)] for c in creators: creator_values[c.id].append(c.approx_val(prev_bids, advertisers)) for a in advertisers: advertiser_values[a.id].append(a.budget)
from viewer import Viewer, FilledPolygon, Transform, RAD2DEG viewer = Viewer(600, 400) cart_w = 50.0 cart_h = 30.0 l, r, t, b = -cart_w / 2, cart_w / 2, cart_h / 2, -cart_h / 2 cart = FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) cart.set_color(.0, .8, .8) carttrans = Transform() cart.add_attr(carttrans) viewer.geoms.append(cart) pole_w = 10.0 pole_l = 125.0 l, r, t, b = -pole_w / 2, pole_w / 2, pole_l - pole_w / 2, -pole_w / 2 pole = FilledPolygon([(l, b), (l, t), (r, t), (r, b)]) pole.set_color(.8, .6, .4) poletrans = Transform(translation=(0, cart_h / 4.0)) pole.add_attr(poletrans) pole.add_attr(carttrans) viewer.geoms.append(pole) for i in range(100): carttrans.set_translation(i + 300, 100) poletrans.set_rotation(-(100 - i) / 100 * 45 / RAD2DEG) viewer.render() print(i) viewer.close()
from viewer import Viewer from match import Match viewer = Viewer() player_1_name = viewer.get_player_name(1) player_2_name = viewer.get_player_name(2) sets = viewer.get_number_of_sets() legs_per_set = viewer.get_number_of_legs_per_set() start_score = viewer.get_start_score() match = Match(player_1_name, player_2_name, sets, legs_per_set, start_score) match.play_match()
class Match(object): def __init__(self, player_1_name, player_2_name, sets, legs_per_set, start_score): self.viewer = Viewer() player1 = Player(player_1_name, start_score) player2 = Player(player_2_name, start_score) self.start_score = start_score self.players = [ player1, player2 ] self.sets = sets self.legs_per_set = legs_per_set self.game = Game(start_score, self.players, sets, legs_per_set) self.set_thrower = player1 self.leg_thrower = player1 def turn(self, player): self.viewer.check_if_on_a_finish(player) player_throw = self.viewer.get_throw(player) self.viewer.check_if_bust(player, player_throw) self.viewer.check_for_winning_throw(player, player_throw) player.throw_darts(player_throw) def legs_needed_to_win_set(self): return (self.legs_per_set / 2) + 1 def sets_needed_to_win(self): return (self.sets / 2) + 1 def set_won(self): if ((self.game.player1.legs_won == self.legs_needed_to_win_set()) or (self.game.player2.legs_won == self.legs_needed_to_win_set())): self.game.winner().sets_won += 1 return True else: return False def match_won(self): return ((self.game.player1.sets_won == self.sets_needed_to_win()) or (self.game.player2.sets_won == self.sets_needed_to_win())) def play_match(self): while not(self.match_won()): self.play_leg() print self.leg_won() def leg_won(self): self.game.winner().legs_won += 1 if (self.set_won()): if (self.match_won()): self.display_winner("match") return else: self.display_winner("set") self.new_set() else: self.display_winner("leg") self.new_leg() def new_leg(self): self.new_game() self.game.thrower = self.switch_thrower(self.leg_thrower) self.leg_thrower = self.game.thrower def new_set(self): self.game.player1.legs_won = 0 self.game.player2.legs_won = 0 self.new_game() self.game.thrower = self.switch_thrower(self.set_thrower) self.set_thrower = self.game.thrower def new_game(self): self.game.player1.reset(self.start_score) self.game.player2.reset(self.start_score) self.game = Game(self.start_score, self.players, self.sets, self.legs_per_set) def switch_thrower(self,thrower): if (thrower == self.game.player1): thrower = self.game.player2 else: thrower = self.game.player1 return thrower def play_leg(self): self.viewer.print_scoreboard(self.game) while not(self.game.won()): self.turn(self.game.thrower) self.viewer.print_scoreboard(self.game) self.game.switch_thrower(); def display_winner(self,game): winner = self.game.winner().name print "Game shot, and the %s to %s" %(game, winner)
from model import Game from viewer import Viewer RANDOM_SEED = 1 WIDTH = 600 HEIGHT = 400 SHIPS = 5 SHIP_SIZE = 8 SHIP_SPEED = 6 if __name__ == '__main__': game = Game(RANDOM_SEED, WIDTH, HEIGHT, SHIPS, SHIP_SIZE, SHIP_SPEED) game.run() game.save('/tmp/game_{}.json'.format(RANDOM_SEED)) viewer = Viewer(game) viewer.run()
ext = "bspline" # filename filename = TP + "data/" + dataname + "." + ext # check if valid datafile if not os.path.isfile(filename): print(" error : invalid dataname '" + dataname + "'") print(" usage : tp7.py [simple,torus] [sampling_density]") print(" example : python tp7.py torus 20") print(" usage : tp7.py [torus, hemi] [sampling_density] nurbs") print(" example : python tp7.py torus 22 nurbs") else: # init Viewer viewer = Viewer("TP7 : B-spline surfaces [" + dataname + "]", [1200, 800]) # open the datafile datafile = open(filename, 'r') # read control points and knot sequences M, U, V = ReadBSplineMeshWithKnots(datafile, nurbs) # coordinate matrices Mx = M[0, :, :] My = M[1, :, :] Mz = M[2, :, :] # add wireframe : control net viewer.add_patch(Mx, My, Mz, wireframe=True)
# check if valid datafile if not os.path.isfile(filename): print " error : invalid dataname '" + dataname + "'" print " usage : tp6.py [simple,wave,sphere,heart,teapot,teacup,teaspoon] [density=10]" print " example : python tp6.py wave 20" else: # open the datafile datafile = open(filename, 'r') # get first line = number of patches numpatch = np.fromstring(datafile.readline(), sep=' ', dtype=int)[0] # init Viewer viewer = Viewer("TP6 : Bezier surfaces [" + dataname + "]", [1200, 800]) # read and compute each patch for p in range(numpatch): # print patch id print " patch", p + 1, "/", numpatch # read Bezier control points Mx, My, Mz = ReadBezierMesh(datafile) # compute surface points Sx = BezierSurf(Mx, density) Sy = BezierSurf(My, density) Sz = BezierSurf(Mz, density)
class App: def __init__(self, root, machine, files, mach_dir): self.root = root self.machine = machine self.files = files self.mach_dir = mach_dir self.step = 0 self.step_text = 'Step: %s' self.control_panel = ControlPanel(root, self) self.main_viewer = Viewer(self) self.update_all() def get_step_text(self): return self.step_text % self.step def do_render(self, data): self.main_viewer.update_machine(json.loads(data)) def prev(self): if self.step == 0: return self.step -= 1 self.update_all() def next(self): self.step += 1 self.update_all() def quit(self): res = messagebox.askyesno(title='Quit', message='Are you sure you want to quit?', default=messagebox.YES) if res: self.root.quit() def update_all(self): self.control_panel.step_lab.configure(text=self.get_step_text()) self.run_mgen() def run_mgen(self): cmdline = ['mgen', self.machine, str(self.step)] cmdline += self.files cmdline += ['--format', 'json', '-d', self.mach_dir] cmdline += ['-t', '2', '-e', '2', '-w', '2', '-r', '1'] try: p = Popen(cmdline, stdout=PIPE, stderr=PIPE) p_stdout, p_stderr = p.communicate() p.wait() except OSError: logging.critical('error executing %s' % cmdline) exit(1) p_stdout = p_stdout.decode() p_stderr = p_stderr.decode() if p.returncode == 0: logging.info('success in running mgen, return code 0') self.do_render(p_stdout) elif p.returncode == 2: logging.warning('simulator premature finish, return code 2') res = messagebox.askyesno( title='Simulator finished', message='Simulator finished, restart from step 0?', default=messagebox.YES) if res: self.step = 0 self.update_all() else: self.step -= 1 self.update_all() else: logging.error('simulator error, return code %s' % p.returncode) logging.error('\n%s\n' % p_stderr) messagebox.showerror( title='Simulator error', message='Simulator error, will restart from step 0', default=messagebox.OK)
def run(self, u_info): # self, mojo_dir, tmp_dir, /// out_dir, dojoserver # register two data sources self.__segmentation = Segmentation(u_info.files_path, u_info.tmpdir, self) self.__image = Image(u_info.files_path, u_info.tmpdir) # and the controller self.__controller = Controller(u_info, self.__segmentation.get_database(), self) #### # and the viewer self.__viewer = Viewer(u_info) # and the controller if self.__segmentation: db = self.__segmentation.get_database() else: db = None self.__controller = Controller(u_info, db, self) # and the setup self.__setup = Setup(self, u_info.files_path, u_info.tmpdir) print('path_gfx: ', u_info.gfx_path) # running live #### ev_loop = asyncio.new_event_loop() asyncio.set_event_loop(ev_loop) dojo = tornado.web.Application( [(r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, { 'path': u_info.gfx_path }), (r'/ws', Websockets, dict(controller=self.__controller)), (r'/(.*)', DojoHandler, dict(logic=self))], debug=True, autoreload=True ) # (r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': '/dojo/gfx'}) # dojo.listen(u_info.port, max_buffer_size=1024*1024*150000) server = tornado.httpserver.HTTPServer(dojo) server.listen(u_info.port) print('*' * 80) print('*', 'DOJO RUNNING') print('*') print('*', 'open', '[ http://' + u_info.ip + ':' + str(u_info.port) + '/dojo/ ] ') print('*' * 80) tornado.ioloop.IOLoop.instance().start() ev_loop.stop() ev_loop.close() server.stop() # def sig_handler(signum, frame): # IOLoop.current().add_callback_from_signal(receiver.shutdown) print("Tornado web server stops.") return
nargs='?', help='The source, defaults to webcame, else filepath to a video.', default=0) parser.add_argument('--custom', action='store_true', help='use my custom KTL implementation.') args = parser.parse_args() return args if __name__ == '__main__': args = parse_args() # Get test video stream = StreamIterator(args.source) for i in range(2): # Skip first 2 frames to "warm up" the webcam next(stream) if args.custom: tracker = KLTTracker() else: tracker = Tracker() viewer = Viewer(stream, tracker) viewer.launch_viewer() cap.release() cv2.destroyAllWindows()
with ARGS_FILE.open() as f: try: PARSER_ARGUMENTS = json.load(f) except json.JSONDecodeError: print_exc() PARSER_ARGUMENTS = None if PARSER_ARGUMENTS: for arg in PARSER_ARGUMENTS: parser.add_argument(*arg[0], **arg[1]) ARGS = parser.parse_args(sys.argv[1:]) else: ARGS = None print(f"{ARGS=}") if ARGS: GLOBAL_OPTS = GLOBAL_OPTS.new_child(vars(ARGS)) print(f"{GLOBAL_OPTS=}") DEBUG = GLOBAL_OPTS['debug'] VERBOSE = GLOBAL_OPTS['verbose'] PROGRAM = GLOBAL_OPTS['program'] if VERBOSE: print(f"SETTINGS: {GLOBAL_OPTS=}") if DEBUG: log.debug(f' module loaded') if __name__ == '__main__': log.debug(f' running {__name__}') print("Hello gcv") Viewer(GLOBAL_OPTS).run()
from wireframe import Model from viewer import Viewer if __name__ == '__main__': cube_nodes = [(50, 50, 50), (100, 50, 50), (50, 100, 50), (100, 100, 50), (100, 50, 100), (50, 100, 100), (100, 100, 100), (100, 100, 100)] cube_edges = [(0, 7), (2, 5), (1, 4), (3, 6), (7, 4), (5, 6), (0, 1), (2, 3), (0, 2), (1, 3), (4, 6), (5, 7)] cube = Model(cube_nodes, cube_edges) viewer = Viewer([cube]) viewer.run()
class Application(tk.Frame): def __init__(self, master=None): super().__init__(master) self.master = master self.pack(fill="both", expand=True) self.viewer = Viewer(600,400,p_radius=2) center = NamedNode3D(0,0,0, pname="center") x_axis = NamedNode3D(1,0,0, pname="x_axis") y_axis = NamedNode3D(0,1,0, pname="y_axis") z_axis = NamedNode3D(0,0,1, pname="z_axis") self.viewer.add_node(center) self.viewer.add_node(x_axis) self.viewer.add_node(y_axis) self.viewer.add_node(z_axis) self.node_radius = 4 self.rot_handler = RotationHandler(self, self.viewer, 1) self.move_handler = MovementHandler(self, self.viewer, 0.1) self.zoom_handler = ZoomHandler(self, self.viewer, 0.5) self.resize_handler = ResizeHandler(self, self.viewer) # Player Mode : origin-centered (1) or player-centered (2) self.player_mode = IntVar() self.create_widgets() self.init_keypress() self.draw() def init_keypress(self): self.master.bind('z', self.move_handler.move_up) self.master.bind('q', self.move_handler.move_left) self.master.bind('s', self.move_handler.move_down) self.master.bind('d', self.move_handler.move_right) self.master.bind('<Left>', self.handle_arrows) self.master.bind('<Right>', self.handle_arrows) self.master.bind('<Up>', self.handle_arrows) self.master.bind('<Down>', self.handle_arrows) self.canvas.bind('<MouseWheel>', self.zoom_handler.zoom) self.canvas.bind('<Configure>', self.resize_handler.resize) def create_widgets(self): self.main_frame = tk.Frame(self) self.main_frame.pack(side="left", fill="both") #Canvas where we draw the dots self.canvas = tk.Canvas(self.main_frame, bg="#d0d0d0", height=400, width=600) self.canvas.pack(side="top", fill="both", expand=True) #Frame displaying the dots and buttons to add more self.right_frame = tk.Frame(self, bg="#ffffc5") self.right_frame.pack(side="right", fill="y") self.create_button = tk.Button(self.right_frame, bg="#00ff00", padx=5, pady=2, text="Create a node", command=self.create_node) self.create_button.pack(side="top", pady=(10,0)) self.nodes_frame = tk.Frame(self.right_frame) self.nodes_frame.pack(side="top", fill="both", pady=10) self.scroll_bar = tk.Scrollbar(self.nodes_frame) self.scroll_bar.pack(side="right", fill="y") self.list_of_nodes = tk.Listbox(self.nodes_frame, yscrollcommand = self.scroll_bar.set) self.list_of_nodes.pack(side="left", fill="both") self.scroll_bar.config(command=self.list_of_nodes.yview) #Mode selection frame self.bottom_frame = tk.Frame(self.main_frame, bg="#ffffc5") self.bottom_frame.pack(side="bottom", fill="x") self.mode_label = tk.Label(self.bottom_frame, padx=7, pady=5, text="Player Mode selection", bg="#08aaff") self.mode_label.pack(side="left", fill="y", padx=10) self.radio_origin = tk.Radiobutton(self.bottom_frame, text="Origin centered", variable=self.player_mode, value=1, bg="#ffffc5") self.radio_origin.pack(side="left") self.radio_origin.select() self.radio_player = tk.Radiobutton(self.bottom_frame, text="Player centered", variable=self.player_mode, value=2, bg="#ffffc5") self.radio_player.pack(side="left") self.reset_button = tk.Button(self.bottom_frame, bg="red", padx=5, pady=2, text="Reset", command=self.reset_viewers) self.reset_button.pack(side="left", padx=10) def handle_arrows(self, event): key = event.keysym if self.player_mode.get() == 1: if key == "Left": self.rot_handler.rotate_left(event) elif key == "Right": self.rot_handler.rotate_right(event) elif key == "Up": self.rot_handler.rotate_up(event) elif key == "Down": self.rot_handler.rotate_down(event) elif self.player_mode.get() == 2: if key == "Left": self.rot_handler.rotate_camera_left(event) elif key == "Right": self.rot_handler.rotate_camera_right(event) elif key == "Up": self.rot_handler.rotate_camera_up(event) elif key == "Down": self.rot_handler.rotate_camera_down(event) def reset_viewers(self): self.viewer.reset_transform_matrix() self.draw() def create_node(self): x = simpledialog.askfloat("X", "Rentrez la valeur de X") y = simpledialog.askfloat("Y", "Rentrez la valeur de Y") z = simpledialog.askfloat("Z", "Rentrez la valeur de Z") name = simpledialog.askstring("Nom du point", "Rentrez un nom pour le point") if x is None or y is None or z is None or name is None: raise BaseException("Missing field ! All fields have to be filled.") else: new_node = NamedNode3D(x, y, z, pname=name) self.viewer.add_node(new_node) self.list_of_nodes.insert("end", new_node) self.draw() def draw(self): self.canvas.delete("all") """# Central point self.canvas.create_oval( int(self.canvas.cget("width")) / 2. - self.node_radius, int(self.canvas.cget("height")) / 2. - self.node_radius, int(self.canvas.cget("width")) / 2. + self.node_radius, int(self.canvas.cget("height")) / 2. + self.node_radius, fill="#00ff00" )""" self.viewer.calc_nodes_2d() self.draw_axes() for n in self.viewer.nodes_2d: displayed_radius = self.node_radius * n.w / n.z fill_color = "red" if n.name in ("center", "x_axis", "y_axis", "z_axis"): fill_color = "blue" self.canvas.create_oval( n.x / n.w - displayed_radius, n.y / n.w - displayed_radius, n.x / n.w + displayed_radius, n.y / n.w + displayed_radius, fill=fill_color ) def draw_axes(self): calc_center = self.viewer.find("center") calc_x = self.viewer.find("x_axis") calc_y = self.viewer.find("y_axis") calc_z = self.viewer.find("z_axis") self.draw_axis(calc_center, calc_x) self.draw_axis(calc_center, calc_y) self.draw_axis(calc_center, calc_z) def draw_axis(self, point_a, point_b): if point_a is not None and point_b is not None: self.canvas.create_line( point_a.x / point_a.w, point_a.y / point_a.w, point_b.x / point_b.w, point_b.y / point_b.w, fill="black" )
""" Fil som starter programmet """ if __name__ == "__main__": from viewer import Viewer from game import Game # Initialiser spil klasse GAME = Game() # Indlæs bane GAME.load_map('default.png') # Initialiser viewer klasse VIEWER = Viewer(GAME) # Start loop VIEWER.start_clock()
def main(): downloader = Downloader(parseargs(sys.argv)) downloader.download() viewer = Viewer(downloader.page_arr, 400) viewer.start()
def main(): v = Viewer() m1 = MovementModel() while True: #this while loop replaces v.mainloop() v.pointsAndPath(m1.randomWalk(), 'r') time.sleep(0.5)
def main(): """ create a window, add scene objects, then run rendering loop """ viewer = Viewer() # environment node environment = Node() # set skybox shader = Shader("./shaders/skybox.vert", "./shaders/skybox.frag") environment.add(Skybox(shader, "./../assets/skybox/underwater/")) # set seabed shader = Shader("./shaders/texture.vert", "./shaders/texture.frag") src = './../assets/models/seabed/seabed.fbx' texFile = './../assets/models/seabed/seabed.jpg' seabed = Node(transform=scale(0.008, 0.01, 0.008) @ translate(0, -100, 0)) model = Model(src, shader) for m in model.load_phong_textured_skinned(texFile): seabed.add(m) # plants node plants = Node() # add seaweed shader = Shader("./shaders/texture.vert", "./shaders/texture.frag") src = './../assets/models/plants/seaweed/seaweed.fbx' texFile = './../assets/models/plants/seaweed/seaweed.png' seaweed = Node(transform=scale(2, 2, 2)) seaweed_density = 80 for i in range(seaweed_density): model = Model(src, shader) temp = Node( transform=translate(randrange(-50, 50), 3.5, randrange(-50, 50))) temp2 = Node( transform=translate(randrange(-20, 20), 15, randrange(-20, 0))) for m in model.load_textured(texFile): temp.add(m) if (i % 2 == 0): temp2.add(m) seaweed.add(temp) if (i % 2 == 0): seaweed.add(temp2) plants.add(seaweed) # add coral coral_count = 7 src = './../assets/models/plants/coral/coral.obj' texFile = './../assets/models/plants/coral/coral.jpg' coral = Node(transform=scale(0.1, 0.1, 0.1)) for i in range(coral_count): model = Model(src, shader) temp = Node(transform=translate(randrange(-300, 300), 350, randrange(-300, -100))) for m in model.load_textured(texFile): temp.add(m) coral.add(temp) plants.add(coral) seabed.add(plants) environment.add(seabed) # add fish models shader = Shader("./shaders/phong_texture_skinning.vert", "./shaders/phong_texture_skinning.frag") fishes = [] fish_count = 20 fish_no = randint(1, 24) src = './../assets/models/fish/%d/model.fbx' % fish_no texFile = './../assets/models/fish/%d/texture.png' % fish_no fish = Node(transform=scale(0.0001, 0.0001, 0.0001)) model = Model(src, shader) control_node = ControlNode(KEY_UP, KEY_DOWN, KEY_LEFT, KEY_RIGHT, 30) for m in model.load_phong_textured_skinned(texFile): control_node.add(m) fish.add(control_node) fishes.append(fish) for i in range(0, fish_count + 1): fish_no = randint(1, 24) src = './../assets/models/fish/%d/model.fbx' % fish_no texFile = './../assets/models/fish/%d/texture.png' % fish_no fish = Node(transform=scale(0.0001, 0.0001, 0.0001)) model = Model(src, shader) for m in model.load_phong_textured_skinned(texFile): fish.add(m) fishanimation = FishAnimation() animated_node = KeyFrameControlNode(fishanimation.get_translate_keys(), fishanimation.get_rotate_keys(), { 0: 1, 2: 1, 4: 1 }, loop=True) animated_node.add(fish) fishes.append(animated_node) for fish in fishes: environment.add(fish) scene = Node() scene.add(environment) viewer.add(scene) print( "Controls : Use the mouse to change the scene view. Press spacebar to restart the scene animations. Press W to see polygons and ESC or Q to Quit." ) # start rendering loop viewer.run()
class EarthMineQGIS(QObject): """QGIS Plugin Implementation.""" def __init__(self, iface): """Constructor. :param iface: An interface instance that will be passed to this class which provides the hook by which you can manipulate the QGIS application at run time. :type iface: QgsInterface """ # Save reference to the QGIS interface super(EarthMineQGIS, self).__init__() self.movingfeature = None self.iface = iface self.viewer = None self.canvas = self.iface.mapCanvas() self.settings = QSettings() # initialize plugin directory self.plugin_dir = os.path.dirname(__file__) # initialize locale locale = QSettings().value('locale/userLocale')[0:2] locale_path = os.path.join(self.plugin_dir, 'i18n', 'EarthMineQGIS_{}.qm'.format(locale)) if os.path.exists(locale_path): self.translator = QTranslator() self.translator.load(locale_path) if qVersion() > '4.3.3': QCoreApplication.installTranslator(self.translator) self.pointtool = QgsMapToolEmitPoint(self.canvas) self.pointtool.canvasClicked.connect(self.set_viewer_location) self.settingsdialog = SettingsDialog(self.iface.mainWindow()) self.actions = [] self.menu = self.tr(u'&Earthmine') self.toolbar = self.iface.addToolBar(u'EarthMineQGIS') self.toolbar.setObjectName(u'EarthMineQGIS') self.legend = self.iface.legendInterface() emcolor = QColor(1, 150, 51) self.tempband = QgsRubberBand(self.canvas, QGis.Line) self.tempband.setWidth(5) self.tempband.setColor(emcolor) self.tempbandpoints = QgsRubberBand(self.canvas, QGis.Point) self.tempbandpoints.setWidth(7) self.tempbandpoints.setColor(emcolor) self.movingband = QgsRubberBand(self.canvas, QGis.Point) self.movingband.setWidth(5) self.movingband.setColor(emcolor) self.layersignals = [] self.marker = None def initGui(self): """Create the menu entries and toolbar icons inside the QGIS GUI.""" icon_path = ':/icons/settings' self.add_action(icon_path, text=self.tr(u'Show Settings'), callback=self.show_settings, parent=self.iface.mainWindow()) icon_path = ':/icons/viewer' self.add_action(icon_path, text=self.tr(u'Earthmine Viewer'), callback=self.open_viewer, parent=self.iface.mainWindow()) self.marker = PostionMarker(self.canvas) self.marker.hide() self.viewer = Viewer(callbackobject=self) self.viewer.trackingChanged.connect(self.marker.setTracking) self.viewer.setLocationTriggered.connect( partial(self.canvas.setMapTool, self.pointtool)) self.viewer.updateFeatures.connect(self.update_earthmine_features) self.viewer.layerChanged.connect(self.iface.setActiveLayer) self.viewer.clearLine.connect(self.clear_bands) self.viewer.closed.connect(self.remove_items) self.iface.currentLayerChanged.connect( self.viewer.update_current_layer) cursor = QCursor(QPixmap(":/icons/location")) self.pointtool.setCursor(cursor) self.pointtool.setAction(self.viewer.setlocationaction) def remove_items(self): self.marker.setTracking(False) self.disconnect_projectsignals() self.iface.actionPan().trigger() def unload(self): """Removes the plugin menu item and icon from QGIS GUI.""" self.canvas.scene().removeItem(self.marker) del self.marker self.disconnect_projectsignals() for action in self.actions: self.iface.removePluginMenu(self.tr(u'&Earthmine'), action) self.iface.removeToolBarIcon(action) del self.toolbar self.iface.removeDockWidget(self.viewer) self.viewer.deleteLater() def disconnect_projectsignals(self): safe_disconnect(QgsMapLayerRegistry.instance().layerWasAdded, self.connect_layer_signals) safe_disconnect(QgsMapLayerRegistry.instance().layersRemoved, self.layers_removed) safe_disconnect(self.canvas.layersChanged, self.layers_changed) safe_disconnect(self.iface.projectRead, self.connect_signals) safe_disconnect(self.canvas.selectionChanged, self.selection_changed) safe_disconnect(self.canvas.selectionChanged, self.viewer.selection_changed) def clear_bands(self): self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) def visible_layers(self): """ Return the visible layers shown in the map canvas :return: """ return (layer for layer, visible in self.layers_with_states() if visible) def layers_with_states(self): for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: continue if not layer.geometryType() in [QGis.Point, QGis.Line]: continue yield layer, self.legend.isLayerVisible(layer) def _layer_feature_added(self, featureid): layer = self.sender() if not layer: return self.layer_feature_added(layer, featureid) def layer_feature_added(self, layer, featureid): if not self.viewer: return feature = layer.getFeatures(QgsFeatureRequest(featureid)).next() renderer = layer.rendererV2() transform = self.coordinatetransform(layer) featuredata = to_feature_data(layer.id(), feature, renderer, transform) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, featuredata) def _layer_feature_delete(self, featureid): layer = self.sender() if not layer: return self.layer_feature_delete(layer, featureid) def layer_feature_delete(self, layer, featureid): if not self.viewer: return self.viewer.remove_feature(layer.id(), featureid) def _layer_geometry_changed(self, featureid, geometry): layer = self.sender() if not layer: return self.layer_geometry_changed(layer, featureid, geometry) def layer_geometry_changed(self, layer, featureid, geometry): if not self.viewer: return geomtype = layer.geometryType() if geomtype == QGis.Point: geom = geometry.asPoint() transform = self.coordinatetransform(layer) point = transform.transform( geom, QgsCoordinateTransform.ReverseTransform) location = dict(lat=point.y(), lng=point.x()) self.viewer.edit_feature(layer.id(), featureid, [location]) elif geomtype == QGis.Line: self.layer_feature_delete(layer, featureid) self.layer_feature_added(layer, featureid) def connect_layer_signals(self, layer): if not layer.type() == QgsMapLayer.VectorLayer: return layer.featureAdded.connect(self._layer_feature_added) layer.featureDeleted.connect(self._layer_feature_delete) layer.editingStarted.connect(self.layer_editstate_changed) layer.editingStopped.connect(self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.connect(layer, signal, self._layer_geometry_changed) self.load_layer_features(layers=[layer]) def layer_editstate_changed(self): layer = self.sender() if layer == self.iface.activeLayer(): self.viewer.layer_changed(layer) def disconnect_signals(self): self.disconnect_projectsignals() for layer in maplayers(): if not layer.type() == QgsMapLayer.VectorLayer: return safe_disconnect(layer.featureAdded, self._layer_feature_added) safe_disconnect(layer.featureDeleted, self._layer_feature_delete) safe_disconnect(layer.editingStarted, self.layer_editstate_changed) safe_disconnect(layer.editingStopped, self.layer_editstate_changed) # HACK The new style doesn't work here # http://hub.qgis.org/issues/6573 signal = SIGNAL("geometryChanged(QgsFeatureId, QgsGeometry&)") self.disconnect(layer, signal, self._layer_geometry_changed) def connect_signals(self): for layer in maplayers(): self.connect_layer_signals(layer) self.center_on_canvas() def set_viewer_location(self, point, mousebutton): transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) def distancearea(self): area = QgsDistanceArea() dest = self.canvas.mapRenderer().destinationCrs() area.setSourceCrs(dest) return area, dest.mapUnits() def coordinatetransform(self, layer=None): """ Return the transform for WGS84 -> QGIS projection. """ source = QgsCoordinateReferenceSystem() source.createFromWkt( 'GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]]' ) if not layer: dest = self.canvas.mapRenderer().destinationCrs() else: dest = layer.crs() transform = QgsCoordinateTransform(source, dest) return transform def earthmine_settings(self): settings = {} with settinggroup(self.settings, "plugins/Earthmine"): for key in [ 'serviceUrl', 'baseDataUrl', "apiKey", 'secretKey', 'viewerUrl' ]: if not self.settings.contains(key): raise EarthmineSettingsError("{} not set".format(key)) value = self.settings.value(key, type=str) if value is None: raise EarthmineSettingsError("{} not set".format(key)) settings[key] = value return settings @pyqtSlot() def ready(self): """ Called when the viewer is ready to be started. At this point the viewer hasn't been loaded so no other methods apart from startViewer will be handled. """ settings = self.earthmine_settings() self.viewer.startViewer(settings) @pyqtSlot() def viewerReady(self): """ Called once the viewer is loaded and ready to get location events. """ self.disconnect_signals() self.connect_signals() self.iface.projectRead.connect(self.connect_signals) self.canvas.layersChanged.connect(self.layers_changed) self.canvas.selectionChanged.connect(self.selection_changed) self.canvas.selectionChanged.connect(self.viewer.selection_changed) QgsMapLayerRegistry.instance().layersRemoved.connect( self.layers_removed) QgsMapLayerRegistry.instance().layerWasAdded.connect( self.connect_layer_signals) self.center_on_canvas() self.viewer.activelayercombo.setLayer(self.iface.activeLayer()) def center_on_canvas(self): point = self.canvas.extent().center() transform = self.coordinatetransform() point = transform.transform(point, QgsCoordinateTransform.ReverseTransform) self.viewer.set_location(point) self.viewer.infoaction.toggle() def selection_changed(self, layer): ids = [feature.id() for feature in layer.selectedFeatures()] if not ids: self.viewer.clear_selection(layer.id()) else: self.viewer.set_selection(layer.id(), ids) def layers_changed(self): layerstates = self.layers_with_states() for layer, visible in layerstates: layerid = layer.id() viewerloaded = self.viewer.layer_loaded(layerid) QgsMessageLog.instance().logMessage(layerid, "Earthmine") QgsMessageLog.instance().logMessage( "Viewer State:" + str(viewerloaded), "Earthmine") QgsMessageLog.instance().logMessage("QGIS State:" + str(visible), "Earthmine") if (viewerloaded and visible) or (not viewerloaded and not visible): QgsMessageLog.instance().logMessage("Ignoring as states match", "Earthmine") continue if viewerloaded and not visible: QgsMessageLog.instance().logMessage( "Clearing layer because viewer loaded and disabled in QGIS", "Earthmine") self.viewer.clear_layer_features(layerid) continue if not viewerloaded and visible: QgsMessageLog.instance().logMessage("Loading layer", "Earthmine") self.load_layer_features(layers=[layer]) continue def layers_removed(self, layers): for layerid in layers: self.viewer.clear_layer_features(layerid) @pyqtSlot(str, float, float) def viewChanged(self, event, yaw, angle): self.marker.setAngle(angle) self.marker.setYaw(yaw) @pyqtSlot(str, str) def getInfo(self, layerid, featureid): featureid = int(featureid) activelayer = self.iface.activeLayer() if not activelayer: return activetool = self.viewer.active_tool() if not activetool in ["Info", "Select"]: return # Only show information for the active layer if not layerid == activelayer.id(): return layer = layer_by_id(layerid) if activetool == "Select": layer.setSelectedFeatures([featureid]) elif activetool == "Info": rq = QgsFeatureRequest(featureid) feature = layer.getFeatures(rq).next() dlg = get_feature_form(layer, feature) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, str, float, float, bool) def featureMoved(self, layerid, featureid, lat, lng, end): layer = layer_by_id(layerid) transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) if not end: self.movingband.show() self.movingband.setToGeometry(QgsGeometry.fromPoint(point), layer) self.movingband.updatePosition() self.movingband.update() else: self.movingband.hide() feature = feature_by_id(layer, featureid) startpoint = feature.geometry().asPoint() dx = point.x() - startpoint.x() dy = point.y() - startpoint.y() layer.beginEditCommand("Feature Moved") # Block signals for this move as the geometry changed signal will re add the geometry on use. layer.blockSignals(True) layer.translateFeature(feature.id(), dx, dy) layer.blockSignals(False) self.canvas.refresh() layer.endEditCommand() @pyqtSlot(str, str) def onError(self, message, stacktrace=None): self.iface.messageBar().pushMessage("Earthmine", message, QgsMessageBar.WARNING) QgsMessageLog.logMessage(stacktrace, "Earthmine") @pyqtSlot(float, float, float) def addPoint(self, lat, lng, z): layer = self.viewer.active_layer if not layer.isEditable(): self.iface.messageBar().pushMessage( "Earthmine", "Selected layer isn't editable. Please enable edit mode to add features", duration=3, level=QgsMessageBar.WARNING) return transform = self.coordinatetransform(layer) point = transform.transform(lng, lat) geom = QgsGeometry.fromPoint(point) self.add_feature(layer, geom, z) def add_feature(self, layer, geom, z=None): feature = QgsFeature(layer.pendingFields()) if z and self.viewer.copyZvalue: try: feature['Z'] = z except KeyError: QgsMessageLog.log("No Z found on layer {}".format( layer.name())) pass feature.setGeometry(geom) dlg = get_feature_form(layer, feature, isadd=True) if dlg.dialog().exec_(): self.canvas.refresh() @pyqtSlot(str, bool, str) def drawLine(self, points, end, stats): points = json.loads(points) stats = json.loads(stats) QgsMessageLog.logMessage(str(stats), "Earthmine") self.tempband.reset(QGis.Line) self.tempbandpoints.reset(QGis.Point) color = QColor(self.viewer.current_action_color) self.tempband.setColor(color) self.tempbandpoints.setColor(color) layer = self.viewer.active_layer transform = self.coordinatetransform(layer) earthminepoints = [] for point in points: newpoint = transform.transform(point['lng'], point['lat']) self.tempband.addPoint(newpoint) self.tempbandpoints.addPoint(newpoint) empoint = EarthminePoint(newpoint, point) earthminepoints.append(empoint) if end and not self.viewer.mode == "Vertical": geom = self.tempband.asGeometry() self.add_feature(layer, geom) self.clear_bands() self.viewer.geom = EarthmineLine(earthminepoints, stats) self.tempband.show() self.tempbandpoints.show() @pyqtSlot(str, str, str, float) def locationChanged(self, lat, lng, yaw, angle): transform = self.coordinatetransform() point = transform.transform(float(lng), float(lat)) self.marker.setCenter(point) yaw = float(yaw) self.marker.setAngle(angle) self.marker.setYaw(yaw) self.marker.setTracking(self.viewer.tracking) if self.marker.tracking: rect = QgsRectangle(point, point) extentlimt = QgsRectangle(self.canvas.extent()) extentlimt.scale(0.95) if not extentlimt.contains(point): self.canvas.setExtent(rect) self.canvas.refresh() # Clear old features self.viewer.clear_features() self.load_layer_features(point) def update_earthmine_features(self, viewfeatures): self.viewer.clear_features() if viewfeatures: self.load_layer_features() def load_layer_features(self, point=None, layers=None): # TODO Move this logic into the viewer and let it track it's position if point is None and self.marker.map_pos is None: return if point is None: point = self.marker.map_pos area, units = self.distancearea() rect = search_area(units, area, point) if layers is None: layers = self.visible_layers() for layer in layers: transform = self.coordinatetransform(layer) # Transform the rect source = self.canvas.mapRenderer().destinationCrs() dest = layer.crs() recttransform = QgsCoordinateTransform(source, dest) rect = recttransform.transformBoundingBox(rect) features = list( get_features_in_area(layer, rect, transform, self.canvas.mapSettings())) geomtype = layer.geometryType() layerdata = dict(id=layer.id(), geomtype=QGis.vectorGeometryType(geomtype)) self.viewer.load_features(layerdata, features) # noinspection PyMethodMayBeStatic def tr(self, message): """Get the translation for a string using Qt translation API. We implement this ourselves since we do not inherit QObject. :param message: String for translation. :type message: str, QString :returns: Translated version of message. :rtype: QString """ # noinspection PyTypeChecker,PyArgumentList,PyCallByClass return QCoreApplication.translate('EarthMineQGIS', message) def add_action(self, icon_path, text, callback, enabled_flag=True, add_to_menu=True, add_to_toolbar=True, status_tip=None, whats_this=None, parent=None): """Add a toolbar icon to the InaSAFE toolbar. :param icon_path: Path to the icon for this action. Can be a resource path (e.g. ':/plugins/foo/bar.png') or a normal file system path. :type icon_path: str :param text: Text that should be shown in menu items for this action. :type text: str :param callback: Function to be called when the action is triggered. :type callback: function :param enabled_flag: A flag indicating if the action should be enabled by default. Defaults to True. :type enabled_flag: bool :param add_to_menu: Flag indicating whether the action should also be added to the menu. Defaults to True. :type add_to_menu: bool :param add_to_toolbar: Flag indicating whether the action should also be added to the toolbar. Defaults to True. :type add_to_toolbar: bool :param status_tip: Optional text to s, "Earhtmine"how in a popup when mouse pointer hovers over the action. :type status_tip: str :param parent: Parent widget for the new action. Defaults None. :type parent: QWidget :param whats_this: Optional text to show in the status bar when the mouse pointer hovers over the action. :returns: The action that was created. Note that the action is also added to self.actions list. :rtype: QAction """ icon = QIcon(icon_path) action = QAction(icon, text, parent) action.triggered.connect(callback) action.setEnabled(enabled_flag) if status_tip is not None: action.setStatusTip(status_tip) if whats_this is not None: action.setWhatsThis(whats_this) if add_to_toolbar: self.toolbar.addAction(action) if add_to_menu: self.iface.addPluginToMenu(self.menu, action) self.actions.append(action) return action def open_viewer(self): """Run method that performs all the real work""" try: settings = self.earthmine_settings() except EarthmineSettingsError as ex: self.onError(ex.message) self.show_settings() return url = settings["viewerUrl"] if not url.startswith("http"): url = url.replace("\\\\", "\\") url = QUrl.fromLocalFile(url) else: url = QUrl(url) if not self.viewer.isVisible(): self.iface.addDockWidget(Qt.RightDockWidgetArea, self.viewer) self.viewer.loadviewer(url) def show_settings(self): self.settingsdialog.show()
depth = int(sys.argv[2]) else: depth = 1 # filename filename = TP + "data/" + dataname + ".net" # check if valid datafile if not os.path.isfile(filename): print " error : invalid dataname '" + dataname + "'" print " usage : tp8.py [torus,cylinder,grid,terrain] [subdivision_depth=1]" print " example : python tp8.py torus 3" else: # init Viewer viewer = Viewer("TP8 : Uniform B-spline SubSurf[" + dataname + "]", [1200, 800]) # open the datafile datafile = open(filename, 'r') # read control points and u_closed, v_closed M, u_closed, v_closed = ReadPoints(datafile) # add wireframe : control net viewer.add_patch(M[0, :, :], M[1, :, :], M[2, :, :], wireframe=True) # iterative subdivision for d in range(depth): M = Subdivide(M, u_closed, v_closed) # u_closed : make rows periodic
class ShipEnv(Env): def __init__(self, type='continuous', action_dim=1): self.type = type self.action_dim = action_dim self.observation_space = spaces.Box( low=np.array([0, -np.pi / 2, 0, -4, -0.2]), high=np.array([150, np.pi / 2, 5.0, 4.0, 0.2])) self.init_space = spaces.Box( low=np.array([0, -np.pi / 15, 1.0, 0.2, -0.01]), high=np.array([30, np.pi / 15, 1.5, 0.3, 0.01])) self.ship_data = None self.last_pos = np.zeros(3) self.last_action = np.zeros(self.action_dim) self.simulator = Simulator() self.point_a = (0.0, 0.0) self.point_b = (2000, 0.0) self.max_x_episode = (5000, 0) self.guideline = LineString([self.point_a, self.max_x_episode]) self.start_pos = np.zeros(1) self.number_loop = 0 # loops in the screen -> used to plot self.borders = [[0, 150], [2000, 150], [2000, -150], [0, -150]] self.viewer = None def step(self, action): side = np.sign(self.last_pos[1]) angle_action = action[0] * side rot_action = 0.2 state_prime = self.simulator.step(angle_level=angle_action, rot_level=rot_action) # convert simulator states into obervable states obs = self.convert_state(state_prime) # print('Observed state: ', obs) dn = self.end(state_prime=state_prime, obs=obs) rew = self.calculate_reward(obs=obs) self.last_pos = [state_prime[0], state_prime[1], state_prime[2]] self.last_action = np.array([angle_action, rot_action]) info = dict() return obs, rew, dn, info def convert_state(self, state): """ This method generated the features used to build the reward function :param state: Global state of the ship """ ship_point = Point((state[0], state[1])) side = np.sign(state[1] - self.point_a[1]) d = ship_point.distance(self.guideline) # meters theta = side * state[2] # radians vx = state[3] # m/s vy = side * state[4] # m/s thetadot = side * state[5] # graus/min obs = np.array([d, theta, vx, vy, thetadot]) return obs def calculate_reward(self, obs): d, theta, vx, vy, thetadot = obs[0], obs[1] * 180 / np.pi, obs[2], obs[ 3], obs[4] * 180 / np.pi if not self.observation_space.contains(obs): print( "\n Action: %f, State[%f %f %f], Velocidade [%f , %f] , Theta: %f, Distance: %f thetadot: %f \n" % (self.last_action[0], self.last_pos[0], self.last_pos[1], self.last_pos[2], vx, vy, theta, d, thetadot)) return -1000 else: return 1 - 8 * np.abs(theta / 90) - np.abs( thetadot / 20) - 5 * np.abs(d) / 150 - np.abs( vy / 4) - np.abs(vx - 2) / 2 def end(self, state_prime, obs): if not self.observation_space.contains(obs) or -1 > state_prime[ 0] or state_prime[0] > self.max_x_episode[ 0] or 160 < state_prime[1] or state_prime[1] < -160: if not self.observation_space.contains(obs): print("\n Smashed") if self.viewer is not None: self.viewer.end_episode() if self.ship_data is not None: if self.ship_data.iterations > 0: self.ship_data.save_experiment(self.name_experiment) return True else: return False def set_init_space(self, low, high): self.init_space = spaces.Box(low=np.array(low), high=np.array(high)) def reset(self): init = list(map(float, self.init_space.sample())) init_states = np.array([ self.start_pos[0], init[0], init[1], init[2] * np.cos(init[1]), init[2] * np.sin(init[1]), 0 ]) self.simulator.reset_start_pos(init_states) self.last_pos = np.array([self.start_pos[0], init[0], init[1]]) print('Reseting position') state = self.simulator.get_state() if self.viewer is not None: self.viewer.end_episode() return self.convert_state(state) def render(self, mode='human'): if self.viewer is None: self.viewer = Viewer() self.viewer.plot_boundary(self.borders) self.viewer.plot_guidance_line(self.point_a, self.point_b) img_x_pos = self.last_pos[0] - self.point_b[0] * (self.last_pos[0] // self.point_b[0]) if self.last_pos[0] // self.point_b[0] > self.number_loop: self.viewer.end_episode() self.viewer.plot_position(img_x_pos, self.last_pos[1], self.last_pos[2], 20 * self.last_action[0]) self.viewer.restart_plot() self.number_loop += 1 else: self.viewer.plot_position(img_x_pos, self.last_pos[1], self.last_pos[2], 20 * self.last_action[0]) def close(self, ): self.viewer.freeze_scream()
from editor.render import imdraw, puregl from OpenGL.GL import * import numpy as np import glm from viewer import Viewer import time import sys positions = np.random.uniform(-1, 1, (10, 3)).astype(np.float32) viewer = Viewer() @viewer.event def on_setup(): vendor = glGetString(GL_VENDOR) renderer = glGetString(GL_RENDERER) print(sys.executable) print(vendor, renderer) global prog prog = puregl.program.create( """#version 330 core layout (location=0) in vec3 position; uniform mat4 projection; uniform mat4 view; uniform mat4 model; void main(){ gl_Position = projection * view * model * vec4(position, 1); } """, """#version 330 core
class ServerLogic: def func(self, loop): loop.stop() def __init__(self): pass def run(self, u_info): # self, mojo_dir, tmp_dir, /// out_dir, dojoserver # register two data sources self.__segmentation = Segmentation(u_info.files_path, u_info.tmpdir, self) self.__image = Image(u_info.files_path, u_info.tmpdir) # and the controller self.__controller = Controller(u_info, self.__segmentation.get_database(), self) #### # and the viewer self.__viewer = Viewer(u_info) # and the controller if self.__segmentation: db = self.__segmentation.get_database() else: db = None self.__controller = Controller(u_info, db, self) # and the setup self.__setup = Setup(self, u_info.files_path, u_info.tmpdir) print('path_gfx: ', u_info.gfx_path) # running live #### ev_loop = asyncio.new_event_loop() asyncio.set_event_loop(ev_loop) dojo = tornado.web.Application( [(r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, { 'path': u_info.gfx_path }), (r'/ws', Websockets, dict(controller=self.__controller)), (r'/(.*)', DojoHandler, dict(logic=self))], debug=True, autoreload=True ) # (r'/dojo/gfx/(.*)', tornado.web.StaticFileHandler, {'path': '/dojo/gfx'}) # dojo.listen(u_info.port, max_buffer_size=1024*1024*150000) server = tornado.httpserver.HTTPServer(dojo) server.listen(u_info.port) print('*' * 80) print('*', 'DOJO RUNNING') print('*') print('*', 'open', '[ http://' + u_info.ip + ':' + str(u_info.port) + '/dojo/ ] ') print('*' * 80) tornado.ioloop.IOLoop.instance().start() ev_loop.stop() ev_loop.close() server.stop() # def sig_handler(signum, frame): # IOLoop.current().add_callback_from_signal(receiver.shutdown) print("Tornado web server stops.") return ## ## IOLoop.instance().stop() ## return ## def stop(): asyncio.asyncio_loop.stop() server.stop() # thread.join() def get_image(self): return self.__image def get_segmentation(self): return self.__segmentation def get_controller(self): return self.__controller def handle(self, r): content = None # the access to the viewer #if not self.__configured: # content, content_type = self.__setup.handle(r.request) #else: # viewer is ready content, content_type = self.__viewer.handle(r.request) # let the data sources handle the request if not content: content, content_type = self.__segmentation.handle(r.request) if not content: content, content_type = self.__image.handle(r.request) # invalid request if not content: content = 'Error 404' content_type = 'text/html' # print 'IP',r.request.remote_ip r.set_header('Access-Control-Allow-Origin', '*') r.set_header('Content-Type', content_type) r.write(content) def close(self, signal, frame): print('Sayonara..!!') output = {} output['origin'] = 'SERVER' sys.exit(0)
import time import argparse from dataset import EuRoCDataset, DataPublisher from viewer import Viewer parser = argparse.ArgumentParser() parser.add_argument('--path', type=str, default='path/to/your/EuRoC_MAV_dataset/MH_01_easy', help='Path of EuRoC MAV dataset.') parser.add_argument('--view', action='store_true', help='Show trajectory.') args = parser.parse_args() if args.view: viewer = Viewer() else: viewer = None dataset = EuRoCDataset(args.path) dataset.set_starttime(offset=40.) # start from static state img_queue = Queue() imu_queue = Queue() # gt_queue = Queue() config = ConfigEuRoC() msckf_vio = VIO(config, img_queue, imu_queue, viewer=viewer) duration = float('inf') ratio = 0.4 # make it smaller if image processing and MSCKF computation is slow
mV, mF = ReadMesh(datafile) # init subdivided mesh V = mV F = mF # use Warren's weights? Warren = False print "Loop subdivision..." print " #V #F" # iterative subdivision for d in range(depth): print "%3d %7d %7d" % (d, V.shape[0], F.shape[0]) V, F = LoopSubdivision(V, F, Warren) print "%3d %7d %7d" % (depth, V.shape[0], F.shape[0]) print "Done." # init Viewer viewer = Viewer("TP9 : Subdivision Surfaces [" + dataname + "]", [1200, 800]) # display control mesh #viewer.add_mesh(mV,mF,E=None,wireframe=True); # display subdivision surface viewer.add_mesh(V, F, E=None, wireframe=False) # display the viewer viewer.render()
def collect_trajectories(): with tf.device('/cpu:0'): reward_mapping.set_goal(goal, goal_heading_e_ccw, goal_vel_lon) viewer = Viewer() viewer.plot_boundary(buoys) viewer.plot_goal(goal, 1000) agents = ['agents/agent_20180727160449Sequential_r____disc_0.8it20.h5'] starting_points = [[11000, 5320, -105.5, 3, 0, 0], [11000, 5320, -104.5, 3, 0, 0], [11000, 5320, -105.5, 3, 0, 0], [11000, 5300, -103.5, 3, 0, 0], [11000, 5300, -102.5, 3, 0, 0], [11000, 5300, -101.5, 3, 0, 0]] for agent_obj in agents: viewer agent = learner.Learner(load_saved_regression=agent_obj, nn_=True) ret_tuples = list() results = list() num_steps = list() env = environment.Environment(rw_mapper=reward_mapping) env.set_up() for start_pos in starting_points: final_flag = 0 transitions_list = list() compact_state_list = list() total_steps = 0 env.set_single_start_pos_mode(start_pos) env.move_to_next_start() steps_inside = 0 for step in range(evaluation_steps): state = env.get_state() print('Value for yaw_p :', state[5]) viewer.plot_position(state[0], state[1], state[2]) state_r = utils.convert_to_simple_state(state, geom_helper) compact_state_list.append(state_r) print('Value for yaw_p :', state_r[3]) print('Value for vlon:', state_r[0]) action = agent.select_action(state_r) state_prime, reward = env.step(action[0], action[1]) transition = (state, (action[0], action[1]), state_prime, reward) if abs(state_r[2]) < 50: steps_inside += 1 final_flag = env.is_final() print("***Evaluation step " + str(step + 1) + " Completed") transitions_list.append(transition) ret_tuples += transitions_list total_steps = step if final_flag != 0: break results.append(final_flag) num_steps.append(total_steps) with open( agent_obj + '_' + str(start_pos[1]) + '_' + str(start_pos[2]) + str(final_flag) + '.csv', 'wt') as out: csv_out = csv.writer(out) csv_out.writerow( ['x', 'y', 'heading', 'rudder_lvl', 'balance']) for tr, compact_state in zip(transitions_list, compact_state_list): pos = (tr[0][0], tr[0][1], tr[0][2], tr[1][0], compact_state[2]) csv_out.writerow(pos)
class Controller(object): def __init__(self, env, video_device): try: self.API_ENDPOINT = env['ApiEndpoint'] self.FACE_AREA_THRESHOLD = env['FaceAreaThreshold'] self.NAME_TTL_SEC = env['NameTtlSec'] self.FACE_SIMILARITY_THRESHOLD = env['FaceSimilarityThreshold'] self.COGNITO_USERPOOL_ID = env['CognitoUserPoolId'] self.COGNITO_USERPOOL_CLIENT_ID = env['CognitoUserPoolClientId'] self.REGION = env['Region'] except KeyError: print('Invalid config file') raise self.recent_name_list = [] self.registered_name_set = set() self.video_capture = VideoCapture(env, video_device) self.detector = Detector(env) self.viewer = Viewer(env) def _update_name_list(self): limit_time = datetime.datetime.now() - datetime.timedelta( seconds=self.NAME_TTL_SEC) for d in self.recent_name_list[:]: if d.get('timestamp') < limit_time: self.recent_name_list.remove(d) def _sign(self, key, msg): return hmac.new(key, msg.encode("utf-8"), hashlib.sha256).digest() def _get_signature_key(self, key, date_stamp, region_name, service_name): date = self._sign(('AWS4' + key).encode('utf-8'), date_stamp) region = self._sign(date, region_name) service = self._sign(region, service_name) signing = self._sign(service, 'aws4_request') return signing def _get_id_token_by_cognito(self, username, password): client = boto3.client('cognito-idp', self.REGION) response = client.initiate_auth( ClientId=self.COGNITO_USERPOOL_CLIENT_ID, AuthFlow='USER_PASSWORD_AUTH', AuthParameters={ 'USERNAME': username, 'PASSWORD': password }) return response['AuthenticationResult']['IdToken'] def run(self): # input username and password username = input("Enter username: "******"key 'q' is pressed")
self.imgname = os.path.basename(img_path) self.raw_img = mx.img.imdecode( open(img_path, 'rb').read() ) self.raw_img = mx.img.fixed_crop(self.raw_img, xy[0], xy[1], hw[1], hw[0]) H0,W0 = self.raw_img.shape[:2] self._predict(H0, W0, re_size_HW) def save_rawfeat(self, savename): plt.close() plt.matshow(self.raw_out) #plt.show() plt.savefig(savename) if __name__ == '__main__': from viewer import Viewer import mxnet as mx import matplotlib.pyplot as plt v= Viewer('vgg16',0, mean=[123.68, 116.28, 103.53]) v.load_layers('prob',bind_size=(224,224)) v.predict('1.jpg',re_size_HW=(224, 224)) v.view() s=raw_input('press any key to exit') """ v.crop_predict('1.jpg',(1114,18), (2457, 862 ),re_size_HW=(224, 224)) v.view() v= Viewer('vgg16',0) v.load_layers('relu5_3',bind_size=(224,224)) v.predict('1.jpg', re_size_HW=(800,800)) v.view() v.predict('1.jpg',re_size_HW=(800,800)) v.view()
class PypePlayer(QMainWindow): def __init__(self, parent=None): super(PypePlayer, self).__init__(parent) QCoreApplication.setOrganizationName('Ted') QCoreApplication.setApplicationName('PypePlayer') self.setting_dialog = settings_widget() self.setting_dialog.settings_saved.connect(self.read_settings) self.player = Player(parent=self) self.setCentralWidget(self.player) self.viewer = Viewer(parent=self) self.menu_controller = MenuController(self, self.menuBar()) self._create_menu() self.update_actions() self.player.media_loaded.connect(self.set_window_title) self.player.stopped.connect(self.set_window_title) self.read_settings() self.set_window_title('') self.show() self.adjust_header_act.trigger() def _create_menu(self): # Player forward_short = createAction(self.player, 'Short Forward', self.player.forward_short, 'Right') forward_medium = createAction(self.player, 'Forward', self.player.forward_medium, 'Shift+Right') forward_long = createAction(self.player, 'Long Forward', self.player.forward_long, 'Ctrl+Right') backward_short = createAction(self.player, 'Short Backward', self.player.backward_short, 'Left') backward_medium = createAction(self.player, 'Backward', self.player.backward_medium, 'Shift+Left') backward_long = createAction(self.player, 'Long Backward', self.player.backward_long, 'Ctrl+Left') play_and_pause = createAction(self.player, 'Play', self.player.optimal_play, 'Space') stop = createAction(self.player, 'Stop', self.player.stop, 'Ctrl+.') self.menu_controller.add_action_list('Playback', [play_and_pause, stop]) self.menu_controller.add_action_list( 'Playback/Jump', [forward_short, forward_medium, forward_long]) self.menu_controller.add_separator('Playback/Jump') self.menu_controller.add_action_list( 'Playback/Jump', [backward_short, backward_medium, backward_long]) load_and_play = createAction(self.player, 'Load and Play', self.player.load_and_play, 'Return') self.player.addAction(load_and_play) self.player.context_menu.addActions([play_and_pause, stop]) # Playlist playlist = self.player.playlist add_file = createAction(playlist, 'Add file(s)', playlist.open, 'Ctrl+o') open_directory = createAction(playlist, 'Open directory', playlist.open_directory, 'Ctrl+Shift+o') open_preferences = createAction(self, 'Preferences...', self.open_preferences) add_playlist = createAction(playlist, 'New', playlist.widget.add_playlist, 'Ctrl+N') load_playlist = createAction(playlist, 'Load', playlist.widget.load_playlist, 'Ctrl+l') save_playlist = createAction(playlist, 'Save Current', playlist.widget.save_current, 'Ctrl+s') rename_playlist = createAction(playlist, 'Rename', playlist.widget.rename_playlist) remove_playlist = createAction(playlist, 'Remove Current', playlist.widget.remove_playlist) next_tab_act = createAction(playlist, 'Next Tab', playlist.widget.next_tab, 'Meta+tab') previous_tab_act = createAction(playlist, 'Previous Tab', playlist.widget.previous_tab, 'Meta+Shift+tab') self.adjust_header_act = createAction( playlist, 'Auto Adjust Header', playlist.widget.adjust_header_size) # self.adjust_header_act.setCheckable(True) self.menu_controller.add_action_list('', [open_preferences]) self.menu_controller.add_action_list('File', [add_file, open_directory]) self.menu_controller.add_separator('File') self.menu_controller.add_action_list('Playlist', [ add_playlist, load_playlist, rename_playlist, save_playlist, remove_playlist ]) self.menu_controller.add_separator('Playlist') self.menu_controller.add_action_list( 'Playlist', [next_tab_act, previous_tab_act, self.adjust_header_act]) # Viewer set_reference_act = createAction(self.viewer, 'Set Reference', self.viewer.set_reference) next_act = createAction(self.viewer, 'next', self.viewer.next, 'Alt+Right') previous_act = createAction(self.viewer, 'previous', self.viewer.previous, 'Alt+Left') zoom_in_act = createAction(self.viewer, 'Zoom In', self.viewer.zoom_in, 'Ctrl++') zoom_out_act = createAction(self.viewer, 'Zoom Out', self.viewer.zoom_out, 'Ctrl+-') normal_size_act = createAction(self.viewer, 'Normal size', self.viewer.normal_size, 'Ctrl+0') fit_to_window_act = createAction(self.viewer, 'Fit to window', self.viewer.fit_to_window) fit_to_window_act.setCheckable(True) show_act = createAction(self.viewer, 'Show', self.viewer.show) close_window_act = createAction(self.viewer, 'Close', self.viewer.hide, 'Ctrl+c') self.viewer_act = [ set_reference_act, next_act, previous_act, zoom_in_act, zoom_out_act, normal_size_act, fit_to_window_act, show_act, close_window_act ] self.viewer.context_menu.addActions(self.viewer_act) self.menu_controller.add_action_list('Viewer', self.viewer_act) def set_window_title(self, str=''): if str: self.setWindowTitle('{0} - Pype Player'.format(str)) else: self.setWindowTitle('Pype Player') def closeEvent(self, event): self.player.playlist.save_all() self.write_settings() super(PypePlayer, self).closeEvent(event) def update_actions(self): for a in self.viewer_act[1:]: a.setEnabled(self.viewer.isReady()) def open_preferences(self): self.setting_dialog.show() def write_settings(self): settings = QSettings() if settings.value('window/remember'): settings.setValue('window/size', self.size()) else: settings.setValue('window/size', QSize(600, 360)) settings.beginGroup('player') settings.setValue('order_list', self.player.order_list.currentIndex()) settings.setValue('splitter_sizes', self.player.display_splitter.saveState()) settings.endGroup() def read_settings(self): settings = QSettings() self.resize(settings.value('window/size', QSize(600, 360))) self.player.read_settings()