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()
