def help(self):
try:
import pymantidplot
pymantidplot.proxies.showCustomInterfaceHelp('DGS Planner')
except ImportError:
self.assistantProcess.close()
self.assistantProcess.waitForFinished()
helpapp = QtCore.QLibraryInfo.location(
QtCore.QLibraryInfo.BinariesPath) + QtCore.QDir.separator()
helpapp += 'assistant'
args = [
'-enableRemoteControl', '-collectionFile', self.collectionFile,
'-showUrl', self.qtUrl
]
if os.path.isfile(helpapp) and os.path.isfile(self.collectionFile):
self.assistantProcess.close()
self.assistantProcess.waitForFinished()
self.assistantProcess.start(helpapp, args)
else:
try:
from mantidqtpython.MantidQt.API.MantidDesktopServices import openUrl
except ImportError:
openUrl = QtGui.QDesktopServices.openUrl
sysenv = QtCore.QProcessEnvironment.systemEnvironment()
ldp = sysenv.value('LD_PRELOAD')
if ldp:
del os.environ['LD_PRELOAD']
openUrl(QtCore.QUrl(self.externalUrl))
if ldp:
os.environ['LD_PRELOAD'] = ldp
def get_qt_web_widget(url):
web = TimeSeriesWebEngineView()
page = TimeSeriesWebEnginePage()
page.setView(web)
web.setPage(page)
web.setUrl(QtCore.QUrl(url))
return web, page
def __to_external_url(interface_name: str, section: str,
external_url: str) -> QtCore.QUrl:
if not external_url:
template = 'http://docs.mantidproject.org/nightly/interfaces/{}/{}.html'
external_url = template.format(section, interface_name)
return QtCore.QUrl(external_url)
def _get_image(self, name):
""" Returns the QImage stored as the ImageResource with 'name'.
"""
document = self._control.document()
image = document.resource(QtGui.QTextDocument.ImageResource,
QtCore.QUrl(name))
return image
def sendBugReport(self):
if not self._excInfoSet():
exctype, excvalue, tracebackobj = sys.exc_info()
else:
exctype = self.exctype
excvalue = self.excvalue
tracebackobj = self.tracebackobj
error = traceback.format_exception_only(exctype, excvalue)[-1].strip()
appname = QtWidgets.QApplication.applicationName()
if appname:
subject = f'[{appname}] Bug report - {error}'
else:
subject = 'Bug report - %s' % error
body = '[Please insert your comments and additional info here.]'
body += '\n\n' + '-' * 80 + '\n'
body += ''.join(
utils.format_bugreport(exctype,
excvalue,
tracebackobj,
extra_info=qtsupport.format_qt_info()))
url = QtCore.QUrl(f'mailto:{info.author} <{info.author_email}>')
url.addQueryItem('subject', subject)
url.addQueryItem('body', body)
ret = QtGui.QDesktopServices.openUrl(url)
if not ret:
msg = self.tr('Unable to send the bug-report.\n'
'Please save the bug-report on file and send it '
'manually.')
QtWidgets.QMessageBox.warning(self, self.tr('WARNING'), msg)
def createHelpWindow(self):
# http://www.walletfox.com/course/qhelpengineexample.php
help_path = (Path(__file__).parent / 'TimeView.qhc').resolve()
assert help_path.exists()
help_engine = QtHelp.QHelpEngine(str(help_path))
help_engine.setupData()
tab_widget = QtWidgets.QTabWidget()
tab_widget.setMaximumWidth(400)
tab_widget.addTab(help_engine.contentWidget(), "Contents")
tab_widget.addTab(help_engine.indexWidget(), "Index")
text_viewer = HelpBrowser(help_engine)
url = "qthelp://org.sphinx.timeview.1.0/doc/index.html"
text_viewer.setSource(QtCore.QUrl(url))
help_engine.contentWidget()\
.linkActivated['QUrl'].connect(text_viewer.setSource)
help_engine.indexWidget()\
.linkActivated['QUrl', str].connect(text_viewer.setSource)
horiz_splitter = QtWidgets.QSplitter(QtCore.Qt.Horizontal)
horiz_splitter.insertWidget(0, tab_widget)
horiz_splitter.insertWidget(1, text_viewer)
help_window = QtWidgets.QDockWidget('Help', self)
help_window.setWidget(horiz_splitter)
help_window.hide()
self.addDockWidget(QtCore.Qt.BottomDockWidgetArea, help_window)
return help_window
def show_interface_help(mantidplot_name, assistant_process, collection_file,
qt_url, external_url):
''' Shows the help page for a custom interface
@param mantidplot_name: used by showCustomInterfaceHelp
@param assistant_process: needs to be started/closed from outside (see example below)
@param collection_file: qth file containing the help in format used by qtassistant
@param qt_url: location of the help in the qth file
@param external_url: location of external page to be displayed in the default browser
Example:
#in the __init__ function of the GUI add:
self.assistant_process = QtCore.QProcess(self)
self.mantidplot_name='DGS Planner'
self.collection_file = os.path.join(mantid._bindir, '../docs/qthelp/MantidProject.qhc')
version = ".".join(mantid.__version__.split(".")[:2])
self.qt_url = 'qthelp://org.sphinx.mantidproject.' + version + '/doc/interfaces/DGS Planner.html'
self.external_url = 'http://docs.mantidproject.org/nightly/interfaces/DGS Planner.html'
#add a help function in the GUI
def help(self):
show_interface_help(self.mantidplot_name,
self.assistant_process,
self.collection_file,
self.qt_url,
self.external_url)
#make sure you close the qtassistant when the GUI is closed
def closeEvent(self, event):
self.assistant_process.close()
self.assistant_process.waitForFinished()
event.accept()
'''
try:
import pymantidplot
pymantidplot.proxies.showCustomInterfaceHelp(mantidplot_name)
except: #(ImportError, ModuleNotFoundError) raises the wrong type of error
assistant_process.close()
assistant_process.waitForFinished()
helpapp = QtCore.QLibraryInfo.location(
QtCore.QLibraryInfo.BinariesPath) + QtCore.QDir.separator()
helpapp += 'assistant'
args = [
'-enableRemoteControl', '-collectionFile', collection_file,
'-showUrl', qt_url
]
if os.path.isfile(helpapp) and os.path.isfile(collection_file):
assistant_process.close()
assistant_process.waitForFinished()
assistant_process.start(helpapp, args)
else:
openUrl = QtGui.QDesktopServices.openUrl
sysenv = QtCore.QProcessEnvironment.systemEnvironment()
ldp = sysenv.value('LD_PRELOAD')
if ldp:
del os.environ['LD_PRELOAD']
openUrl(QtCore.QUrl(external_url))
if ldp:
os.environ['LD_PRELOAD'] = ldp
def test_drop_load_data(self):
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.fits')])
e = MagicMock()
e.mimeData.return_value = m
load = MagicMock()
self.app.load_data = load
self.app.dropEvent(e)
assert load.call_count == 1
def setup_ui(self):
dash_url = self.config.get('dashboard_url')
if dash_url:
self.ui.webbrowser.load(QtCore.QUrl(dash_url))
self.ui.btn_open_browser.clicked.connect(self.handle_open_browser)
self.setup_ev_range_labels()
self.setup_tabs()
def _add_image(self, image):
""" Adds the specified QImage to the document and returns a
QTextImageFormat that references it.
"""
document = self._control.document()
name = str(image.cacheKey())
document.addResource(QtGui.QTextDocument.ImageResource,
QtCore.QUrl(name), image)
format = QtGui.QTextImageFormat()
format.setName(name)
return format
def api_reference(self):
"""
Opens the API reference documentation of the GUI in a webbrowser.
%(qt_slot)s
"""
# Open webbrowser
QG.QDesktopServices.openUrl(QC.QUrl(
"https://prism-tool.readthedocs.io/en/latest/api/prism._gui.html"))
def addSoftwareVersion(self, sw, version, link=''):
tablewidget = self.versionsTableWidget
index = tablewidget.rowCount()
tablewidget.setRowCount(index + 1)
tablewidget.setItem(index, 0, QtWidgets.QTableWidgetItem(sw))
tablewidget.setItem(index, 1, QtWidgets.QTableWidgetItem(version))
# tablewidget.setItem(row, 2, QtWidgets.QTableWidgetItem(link))
linkLabel = QtWidgets.QLabel('<a href="{0}">{0}</a>'.format(link))
linkLabel.linkActivated.connect(
lambda text: QtGui.QDesktopServices.openUrl(QtCore.QUrl(text)))
tablewidget.setCellWidget(index, 2, linkLabel)
def copyURL(self):
if not self.targetSceneNode:
return
cameraState = self.canvas.callMethod('view', 'saveCameraStateToString')
path = self.targetSceneNode.getPath()
url = self.getApp().makeURL('scene', path=path, camera=cameraState)
#TODO: position
mime = QtCore.QMimeData()
mime.setUrls([QtCore.QUrl(url)])
mime.setText(url)
clipboard = QtWidgets.QApplication.clipboard()
clipboard.setMimeData(mime)
def _help(self):
helpfile = os.sep.join((os.path.dirname(__file__) or '.', "help.html"))
self.help_window = QtWidgets.QTextBrowser()
self.help_window.resize(600, 400)
self.help_window.setAttribute(QtCore.Qt.WA_QuitOnClose, False)
self.help_window.setWindowTitle("Help")
self.help_window.setSource(QtCore.QUrl(helpfile))
self.help_window.setOpenLinks(False)
self.help_window.anchorClicked.connect(self._help_open_external)
self.help_window.show()
def __init__(self, url, parent=None):
super(WWTQtWidget, self).__init__(parent=parent)
self.web = WWTWebEngineView()
self.page = WWTQWebEnginePage()
self.page.setView(self.web)
self.web.setPage(self.page)
self.web.setUrl(QtCore.QUrl(url))
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
layout.addWidget(self.web)
def CreatWebTab(self):#穿件一个TAB 用于网络 现在占时定义为百度
if self.webTabFlag == False:
self.BaiduView = QWebEngineView(self.centralwidget)
self.BaiduView.setMinimumSize(QtCore.QSize(500, 400))
self.BaiduView.setUrl(QtCore.QUrl("https://www.baidu.com/"))
self.BaiduView.setObjectName("search")
self.WebTab=self.GraphTab.addTab(self.BaiduView,'百度 view')
self.setPlanEditor('打开web 信息')
self.webTabFlag = True
elif self.webTabFlag == True:
self.WebTab=self.GraphTab.removeTab(1)
self.setPlanEditor('关闭web 信息')
self.webTabFlag = False
def __init__(self, backend=None, tokenCallback=None):
super(LoginWindow, self).__init__()
self.state = None
self.session = backend.session
self.backend = backend
auth_url, state = self.session.authorization_url(self.backend.auth_url)
self.urlChanged.connect(self.check_URL)
self.callback = tokenCallback
self.load(QtCore.QUrl(auth_url))
self.set_state(state)
def openInGoogleMaps(self):
"""Open google-maps centering the map on scene centre.
.. seealso:: http://mapki.com/wiki/Google_Map_Parameters
"""
item = self._currentDatasetItem()
if item is None:
_log.info('no item selected.')
QtWidgets.QMessageBox.information(
self.app, self.tr('Information'),
self.tr('No item selected.'))
return
try:
cmapper = item.cmapper
except AttributeError:
_log.error(
'item "%s" seems to have no geographic info.', item.filename)
return
lon, lat = cmapper.imgToGeoGrid([0.5, item.RasterXSize - 0.5],
[0.5, item.RasterYSize - 0.5])
deltalon = np.max(lon) - np.min(lon)
deltalat = np.max(lat) - np.min(lat)
zoomlon = np.floor(np.log2(360 / deltalon))
zoomlat = np.floor(np.log2(180 / deltalat))
zoomlevel = min(zoomlon, zoomlat) + 1
pixel, line = item.RasterXSize / 2., item.RasterYSize / 2.
lon, lat = cmapper.imgToGeoPoints(pixel, line)
url = QtCore.QUrl('http://maps.google.com/maps')
query = QtCore.QUrlQuery()
query.addQueryItem('q', f'{float(lat):f}N,{float(lon):f}E') # coords
query.addQueryItem('t', 'h') # map type (hybrid)
query.addQueryItem('z', str(zoomlevel)) # zoom level (1, 20)
url.setQuery(query)
success = QtGui.QDesktopServices.openUrl(url)
if not success:
_log.warning('unable to open URL: "%s"', url)
# @TODO: check
QtWidgets.QMessageBox.warning(
self.app, self.tr('Warning'),
self.tr('Unable to open URL: "%s"') % str(url))
def on_activate(self, e):
""" Initializes all needed UI files and establishes the connectors.
@param object e: Fysom.event object from Fysom class.
An object created by the state machine module Fysom,
which is connected to a specific event (have a look in
the Base Class). This object contains the passed event,
the state before the event happened and the destination
of the state which should be reached after the event
had happened.
"""
self._mw = NotebookMainWindow()
url = QtCore.QUrl('http://localhost:8888')
tw = self._mw.newTab()
tw.load(url)
self.restoreWindowPos(self._mw)
self._mw.show()
def __init__(self, url=None, parent=None):
super(WWTQtWidget, self).__init__(parent=parent)
self.web = WWTWebEngineView()
self.page = WWTQWebEnginePage()
self.page.setView(self.web)
self.web.setPage(self.page)
self.web.setUrl(QtCore.QUrl(url))
layout = QtWidgets.QVBoxLayout()
layout.setContentsMargins(0, 0, 0, 0)
self.setLayout(layout)
layout.addWidget(self.web)
self._wwt_ready = False
self._js_queue = ""
self.page.wwt_ready.connect(self._on_wwt_ready)
def load_markdown(self, md, url=None, tmpl=None):
"""
desc:
Loads a Markdown text string.
arguments:
md: A Markdown text string.
url: The url to load.
tmpl: A template to be wrapped around the html.
"""
if url is None:
url = u'untitled'
url = QtCore.QUrl(u'http://opensesame.app.cogsci.nl/%s' % url)
self.ui.top_widget.hide()
html = self.markdown_parser.to_html(md)
if tmpl is not None:
html = tmpl % {u'body': html}
self.ui.webview.setHtml(html, baseUrl=url)
def event_startup(self):
wv = WebView(self.main_window)
wv.setHtml(
HTML,
QtCore.QUrl(u'http://opensesame.app.cogsci.nl/%s' %
metadata.__version__))
wv.hide()
if not QtNetwork.QNetworkConfigurationManager().isOnline() or \
not cfg.analytics_show_notification:
return
self.extension_manager.fire(
u'notify',
message=
_('Anonymous usage data is collected. You can disable this by disabling the <i>analytics</i> extension.'
),
category=u'info',
timeout=10000,
buttontext=_(u'Got it!'))
cfg.analytics_show_notification = False
def test_drop_load_data(self):
load_data = MagicMock()
load_session = MagicMock()
self.app.load_data = load_data
self.app.restore_session_and_close = load_session
e = MagicMock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.fits')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.called_once_with('test.fits')
assert load_session.call_count == 0
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test1.fits'), QtCore.QUrl('test2.fits')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.called_once_with(['test1.fits', 'test2.fits'])
assert load_session.call_count == 0
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.glu')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.call_count == 0
assert load_session.called_once_with(['test.glu'])
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.glu'), QtCore.QUrl('test.fits')])
e.mimeData.return_value = m
with patch('qtpy.QtWidgets.QMessageBox') as mb:
self.app.dropEvent(e)
assert mb.call_count == 1
assert "When dragging and dropping files" in mb.call_args[0][2]
mb.reset_mock()
load_data.reset_mock()
def default(self):
if self.window is None:
self.window = ExToolWindow(self.ui)
self.window.setWindowTitle("EELSDB")
vbox = QtWidgets.QVBoxLayout()
self.window.setLayout(vbox)
view = QtWebEngineWidgets.QWebEngineView(self.ui)
self.view = view
vbox.addWidget(view)
self.window.resize(self.view.sizeHint())
# Load spectra browser
browse_url = QtCore.QUrl("https://eelsdb.eu/spectra")
self.load_blocking(self.view, browse_url)
# Remove header/footer
frame = self.view.page().mainFrame()
frame.findFirstElement(".footer").removeFromDocument()
for el in frame.findAllElements(".navbar"):
el.removeFromDocument()
self.view.page().setLinkDelegationPolicy(
QtWebEngineWidgets.QWebEnginePage.DelegateAllLinks)
self.view.linkClicked.connect(self._on_link)
self.window.show()
def default(self):
if self.window is None:
self.window = ExToolWindow(self.ui)
self.window.setWindowTitle("EELSDB")
vbox = QtWidgets.QVBoxLayout()
self.window.setLayout(vbox)
view = QWebEngineView(self.ui)
self.view = view
vbox.addWidget(view)
self.window.resize(self.view.sizeHint())
# Load spectra browser
browse_url = QtCore.QUrl("https://eelsdb.eu/spectra")
self.load_blocking(self.view, browse_url)
if not WEBENGINE:
self.view.page().setLinkDelegationPolicy(
QWebEnginePage.DelegateAllLinks)
try:
# TODO: downloading spectra is currently broken
self.view.linkClicked.connect(self._on_link)
except AttributeError:
pass
self.window.show()
def test_drop_load_data(self):
load_data = MagicMock()
load_session = MagicMock()
self.app.load_data = load_data
self.app.restore_session_and_close = load_session
e = MagicMock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.fits')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.called_once_with('test.fits')
assert load_session.call_count == 0
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test1.fits'), QtCore.QUrl('test2.fits')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.called_once_with(['test1.fits', 'test2.fits'])
assert load_session.call_count == 0
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.glu')])
e.mimeData.return_value = m
self.app.dropEvent(e)
assert load_data.call_count == 0
assert load_session.called_once_with(['test.glu'])
load_data.reset_mock()
m = QtCore.QMimeData()
m.setUrls([QtCore.QUrl('test.glu'), QtCore.QUrl('test.fits')])
e.mimeData.return_value = m
with pytest.raises(Exception) as exc:
self.app.dropEvent(e)
assert exc.value.args[0].startswith("When dragging and dropping files")
load_data.reset_mock()
def displaySrc(self, src=False):
"""
Displays a document in the `HelpBrowser` window.
This slot is called when:
- :meth:
`vitables.docbrowser.bookmarksdlg.BookmarksDlg.displayBookmark`
is launched
- a new item is activated in the `History` combo
- an entry is selected in the `Bookmarks` menu
:Parameter src: the path of the file being displayed
"""
if src is False: # entry selected in the Bookmarks menu
action = self.gui.sender()
src = action.data()
src = QtCore.QDir(src).dirName()
src = QtCore.QDir().fromNativeSeparators(src)
url = QtCore.QUrl(src)
self.gui.text_browser.setSource(url)
def load(self, url, tmpl=None):
"""
desc:
Loads a webpage.
arguments:
url: The url to load.
tmpl: A template to be wrapped around the html in the case of
Markdown files.
"""
if isinstance(url, QtCore.QUrl):
url = url.toString()
if url.endswith(u'.md') and not url.startswith(u'http://') \
and not url.startswith(u'https://'):
self.ui.top_widget.hide()
self.load_markdown(safe_read(url),
url=os.path.basename(url),
tmpl=tmpl)
return
self.ui.top_widget.show()
self._current_url = url
self.ui.webview.load(QtCore.QUrl(url))
def _restoreFileDialogState(self, settings=None):
if settings is None:
settings = self.settings
settings.beginGroup('filedialog')
try:
# state
state = settings.value('state')
if state is not None:
try:
# QFileDialog.restoreState is new in Qt 4.3
self.filedialog.restoreState(state)
except AttributeError:
_log.debug('unable to restore the file dialog state')
# workdir
workdir = settings.value('workdir', utils.default_workdir())
workdir = os.path.expanduser(os.path.expandvars(workdir))
self.filedialog.setDirectory(workdir)
# history
# history = settings.value('history')
# if history:
# self.filedialog.setHistory(history)
# sidebar urls
try:
# QFileDialog.setSidebarUrls is new in Qt 4.3
sidebarurls = settings.value('sidebarurls')
if sidebarurls:
sidebarurls = [QtCore.QUrl(item) for item in sidebarurls]
self.filedialog.setSidebarUrls(sidebarurls)
except AttributeError:
_log.debug('unable to restore sidebar URLs of the file dialog')
finally:
settings.endGroup()
def Go(self):
if len(self.gpxselectedlist) > 0:
# Temporarily change cursor
QApplication.setOverrideCursor(QtCore.Qt.WaitCursor)
# Clear up global variables
self.proc_coords = []
self.proc_measurements = []
self.proc_state_means = []
self.proc_state_vars = []
self.proc_new_coords = []
self.proc_new_gpx = []
self.proc_coords_to_plot = []
self.proc_coords_to_plot2 = []
self.proc_balloondata = []
# For every GPX file that is selected
self.textWarningConsole.clear()
for i, currentgpx in enumerate(self.gpxselectedlist):
# Parse the GPX file
gpx, coords, dinfos_before, warnings = bombo.ParseGPX(
currentgpx,
track_nr=0,
segment_nr=0,
use_srtm_elevation=bool(self.checkUseSRTM.isChecked()))
self.textWarningConsole.append(warnings)
# Kalman processing
coords, measurements, state_means, state_vars, dinfos_during = bombo.ApplyKalmanFilter(
coords,
gpx,
method=self.comboBoxProcessingMethod.currentIndex(),
use_acceleration=self.checkUseAcceleration.isChecked(),
extra_smooth=self.checkExtraSmooth.isChecked(),
debug_plot=False)
# Save data in GPX structure to compute speed and elevations
new_coords, new_gpx, dinfos_after = bombo.SaveDataToCoordsAndGPX(
coords, state_means)
# Update GUI with the computed stats
parent = QtGui.QStandardItem(self.gpxselectednamelist[i])
parent_beforeprocessing = QtGui.QStandardItem("Raw GPX stats")
parent_beforeprocessing.appendRow([
QtGui.QStandardItem("Total distance"),
QtGui.QStandardItem(dinfos_before['total_distance'])
])
parent_beforeprocessing_moving = QtGui.QStandardItem("Moving")
parent_beforeprocessing_moving.appendRow([
QtGui.QStandardItem("Time"),
QtGui.QStandardItem(dinfos_before['moving_time'])
])
parent_beforeprocessing_moving.appendRow([
QtGui.QStandardItem("Distance"),
QtGui.QStandardItem(dinfos_before['moving_distance'])
])
parent_beforeprocessing.appendRow(
parent_beforeprocessing_moving)
parent_beforeprocessing_idle = QtGui.QStandardItem("Idle")
parent_beforeprocessing_idle.appendRow([
QtGui.QStandardItem("Time"),
QtGui.QStandardItem(dinfos_before['idle_time'])
])
parent_beforeprocessing_idle.appendRow([
QtGui.QStandardItem("Distance"),
QtGui.QStandardItem(dinfos_before['idle_distance'])
])
parent_beforeprocessing.appendRow(parent_beforeprocessing_idle)
parent_beforeprocessing.appendRow([
QtGui.QStandardItem("Elevation"),
QtGui.QStandardItem(dinfos_before['elevation'])
])
parent_beforeprocessing.appendRow([
QtGui.QStandardItem("Climb"),
QtGui.QStandardItem(dinfos_before['climb'])
])
parent.appendRow(parent_beforeprocessing)
parent.appendRow([
QtGui.QStandardItem("Samples"),
QtGui.QStandardItem(dinfos_during['nsamples'])
])
parent.appendRow([
QtGui.QStandardItem("Total distance"),
QtGui.QStandardItem(dinfos_after['total_distance'])
])
parent_moving = QtGui.QStandardItem("Moving")
parent_moving.appendRow([
QtGui.QStandardItem("Time"),
QtGui.QStandardItem(dinfos_after['moving_time'])
])
parent_moving.appendRow([
QtGui.QStandardItem("Distance"),
QtGui.QStandardItem(dinfos_after['moving_distance'])
])
parent.appendRow(parent_moving)
parent_idle = QtGui.QStandardItem("Idle")
parent_idle.appendRow([
QtGui.QStandardItem("Time"),
QtGui.QStandardItem(dinfos_after['idle_time'])
])
parent_idle.appendRow([
QtGui.QStandardItem("Distance"),
QtGui.QStandardItem(dinfos_after['idle_distance'])
])
parent.appendRow(parent_idle)
parent.appendRow([
QtGui.QStandardItem("Elevation"),
QtGui.QStandardItem(dinfos_after['elevation'])
])
parent.appendRow([
QtGui.QStandardItem("Climb"),
QtGui.QStandardItem(dinfos_after['climb'])
])
self.treemodel.appendRow(parent)
# Create balloondata for the html plot
balloondata = {
'distance':
np.cumsum(
bombo.HaversineDistance(np.asarray(new_coords['lat']),
np.asarray(
new_coords['lon']))),
'elevation':
np.asarray(new_coords['ele']),
'speed':
None
}
# Create extra data for the html plot (fully implemented in bombo, not here)
"""
data = np.ones((len(lat_cleaned),2))
data[:,0] = h_filtered / np.max(h_filtered) * 0.0004
data[:,1] = np.hstack((np.asarray([0]), speed_h)) / np.max(np.hstack((np.asarray([0]), speed_h))) * 0.0004
tangentdata = {'data': data,
'sides': (0, 1),
'palette': ('blue','red')}
"""
# Save relevant output in global variables
self.proc_coords.append(coords)
self.proc_measurements.append(measurements)
self.proc_state_means.append(state_means)
self.proc_state_vars.append(state_vars)
self.proc_new_coords.append(new_coords)
self.proc_new_gpx.append(new_gpx)
self.proc_coords_to_plot.append(
np.vstack((new_coords['lat'], new_coords['lon'])).T)
self.proc_coords_to_plot2.append(
np.vstack((coords['lat'], coords['lon'])).T)
self.proc_balloondata.append(balloondata)
# Restore original cursor
QApplication.restoreOverrideCursor()
# Generate embedded plots
if len(self.gpxselectedlist) == 1:
self.plotEmbeddedElevationAndSpeed.update_figure(
measurements, state_means, new_gpx.tracks[0].segments[0])
self.plotEmbeddedDetails.update_figure(
measurements, state_means, state_vars,
new_gpx.tracks[0].segments[0])
else:
# Commentato per adesso
# self.plotEmbeddedElevationAndSpeed.update_figure_multiple_tracks(self.proc_measurements, self.proc_state_means, self.proc_new_gpx)
self.plotEmbeddedElevationAndSpeed.clear_figure()
self.plotEmbeddedDetails.clear_figure()
# Generate html plot, if only one track is selected, proceed with the complete output, otherwise just plot the traces
if len(self.gpxselectedlist) is 1:
bombo.PlotOnMap(
coords_array_list=self.proc_coords_to_plot,
coords_array2_list=self.proc_coords_to_plot2,
coords_palette=self.selectedpalette,
tangentdata=None,
balloondata_list=self.proc_balloondata,
rdp_reduction=self.checkUseRDP.isChecked(),
showmap=bool(self.check2DMapInExternalBrowser.isChecked()))
else:
bombo.PlotOnMap(
coords_array_list=self.proc_coords_to_plot,
coords_array2_list=None,
coords_palette=self.selectedpalette,
tangentdata=None,
balloondata_list=self.proc_balloondata,
rdp_reduction=self.checkUseRDP.isChecked(),
showmap=bool(self.check2DMapInExternalBrowser.isChecked()))
self.map2d.load(QtCore.QUrl(bombo.MAP_2D_FILENAME))
self.map2d.show()
# Generate 3D plot, only with one track for the moment
if len(self.gpxselectedlist) == 1:
if self.check3DMapSelection.isChecked():
tile_selection = 'auto'
else:
tile_selection = self.text3DMapName.text()
terrain, track, warnings = bombo.Generate3DMap(
new_coords['lat'],
new_coords['lon'],
tile_selection=tile_selection,
margin=self.spinbox3DMargin.value(),
elevation_scale=self.spinbox3DElevationScale.value(),
mapping='coords',
use_osm_texture=True,
texture_type='osm',
texture_zoom=self.spinbox3DOSMZoom.value(),
texture_invert=self.check3DOSMInvert.isChecked(),
use_proxy=self.use_proxy,
proxy_data=self.proxy_config,
verbose=False)
self.textWarningConsole.append(warnings)
if terrain is not None:
self.map3d.update_plot(terrain, track)
else:
self.textWarningConsole.setText(
"You need to open a .gpx file before!")
return
