def iconDownloaded(self, reply):
img = QImage()
img.loadFromData(reply.readAll())
pixmap = QPixmap(img)
thumb = pixmap.scaled(48, 48, Qt.KeepAspectRatio,
Qt.SmoothTransformation)
self.iconLabel.setPixmap(thumb)
def imageFromPath(path):
if (path[:7] == 'http://' or path[:7] == 'file://'):
#fetch remote image
data = urllib2.urlopen(path).read()
image = QImage()
image.loadFromData(data)
else:
image = QImage(path)
return image
def thumbnail_downloaded(self, reply):
if reply.error() == QNetworkReply.NoError:
url = reply.url().toString()
img = QImage()
img.loadFromData(reply.readAll())
self.thumbnails[url] = img
for w in self.widgets[url]:
try:
w.set_thumbnail(img)
except Exception:
# the widget might have been deleted
pass
def display_image(self, url):
#url = 'https://ims.cr.usgs.gov/browse/landsat_8_c1/2020/195/034/LC08_L1TP_195034_20200116_20200127_01_T1.jpg'
data = urllib.request.urlopen(url).read()
image = QImage()
image.loadFromData(data)
image.scaled(100, 100)
#self.dlg.label_image.setPixmap(QPixmap(image))
pixmap = QPixmap(image)
pixmap4 = pixmap.scaled(200, 200, QtCore.Qt.KeepAspectRatio)
self.dlg.label_image.setPixmap(pixmap4)
def getCachedImage(self, project, request, key):
m = hashlib.md5()
paramMap = request.parameters()
urlParam = "&".join(
["%s=%s" % (k, paramMap[k]) for k in paramMap.keys()])
m.update(urlParam.encode('utf8'))
if not os.path.exists(
os.path.join(self._tile_cache_dir,
m.hexdigest() + ".png")):
return QByteArray()
img = QImage(m.hexdigest() + ".png")
with open(os.path.join(self._tile_cache_dir,
m.hexdigest() + ".png"), "rb") as f:
statusOK = img.loadFromData(f.read())
if not statusOK:
print(
"Could not read or find the contents document. Error at line %d, column %d:\n%s"
% (errorLine, errorColumn, errorStr))
return QByteArray()
ba = QByteArray()
buff = QBuffer(ba)
buff.open(QIODevice.WriteOnly)
img.save(buff, 'PNG')
return ba
def save_wms_image(filename, url, layer, extent):
bbox = "%f,%f,%f,%f" % (extent.xMinimum(), extent.yMinimum(),
extent.xMaximum(), extent.yMaximum())
h = int(extent.height() / extent.width() * WIDTH)
url = (
"%s/wms?request=GetMap&service=WMS&version=1.1.1&srs=EPSG:4326&layers=visualtests:%s&"
"styles=visualtests:%s&format=image/png&width=%i&height=%i&bbox=%s" %
(url, layer.name(), layer.name(), WIDTH, h, bbox))
nam = QNetworkAccessManager()
reply = nam.get(QNetworkRequest(QUrl(url)))
loop = QEventLoop()
reply.finished.connect(loop.quit)
loop.exec()
img = QImage()
img.loadFromData(reply.readAll())
img.save(filename)
def image(self):
width = (self.xmax - self.xmin + 1) * self.TILE_SIZE
height = (self.ymax - self.ymin + 1) * self.TILE_SIZE
image = QImage(width, height, QImage.Format_ARGB32_Premultiplied)
p = QPainter(image)
for tile in list(self.tiles.values()):
if not tile.data:
continue
x = tile.x - self.xmin
y = tile.y - self.ymin
rect = QRect(x * self.TILE_SIZE, y * self.TILE_SIZE, self.TILE_SIZE, self.TILE_SIZE)
timg = QImage()
timg.loadFromData(tile.data)
p.drawImage(rect, timg)
return image
def slice(self):
"""
Write a series of tiles contained within this metatile.
"""
# open the metatile
with open(self.full_path(),'rb') as f:
# load the metatile into a QImage
meta_img = QImage()
meta_img.loadFromData(f.read())
# get the tile range within this metatile (filtering outside tiles if buffered)
if self.buffer:
x_min = 1
y_min = 1
x_max = self.size['cols'] - 1
y_max = self.size['rows'] - 1
else:
x_min = 0
y_min = 0
x_max = self.size['cols']
y_max = self.size['rows']
# loop through the tiles in the metatile and crop the metatile to the tile.
for x in range(x_min, x_max):
for y in range(y_min, y_max):
# get the top-left location (in pixels) of the tile to be extracted from the metatile.
# crop the loaded metatile to the tile
new_img = meta_img.copy(x * self.parent.tile_width, y * self.parent.tile_height, self.parent.tile_width, self.parent.tile_height)
# get the tile number (x and y)
tile_x = self.extents[2] + x
tile_y = self.extents[0] + y
# create a Tile instance
tile = Tile(tile_x, tile_y ,self.zoom)
# use the selected writer to write the file
self.parent.writer.writeTile(tile, new_img, self.parent.format, self.parent.quality)
# destroy the tile in memory - just in case.
del new_img
# destroy the metatile just in case.
del meta_img
def getCachedImage(self, project, request, key):
m = hashlib.md5()
paramMap = request.parameters()
urlParam = "&".join(["%s=%s" % (k, paramMap[k]) for k in paramMap.keys()])
m.update(urlParam.encode('utf8'))
if not os.path.exists(os.path.join(self._tile_cache_dir, m.hexdigest() + ".png")):
return QByteArray()
img = QImage(m.hexdigest() + ".png")
with open(os.path.join(self._tile_cache_dir, m.hexdigest() + ".png"), "rb") as f:
statusOK = img.loadFromData(f.read())
if not statusOK:
print("Could not read or find the contents document. Error at line %d, column %d:\n%s" % (errorLine, errorColumn, errorStr))
return QByteArray()
ba = QByteArray()
buff = QBuffer(ba)
buff.open(QIODevice.WriteOnly)
img.save(buff, 'PNG')
return ba
def image(self):
width = (self.xmax - self.xmin + 1) * self.TILE_SIZE
height = (self.ymax - self.ymin + 1) * self.TILE_SIZE
image = QImage(width, height, QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
p = QPainter(image)
for tile in self.tiles.values():
if not tile.data:
continue
x = tile.x - self.xmin
y = tile.y - self.ymin
rect = QRect(x * self.TILE_SIZE, y * self.TILE_SIZE,
self.TILE_SIZE, self.TILE_SIZE)
timg = QImage()
res = timg.loadFromData(tile.data)
if res:
p.drawImage(rect, timg)
if debug_mode:
p.setPen(Qt.black)
p.drawText(
rect,
Qt.AlignBottom | Qt.AlignRight,
# "x: %s, y:%s\nz: %s, data: %s" % (x, y, tile.zoom, tile.data.size())
"z: %s, data: %s" % (tile.zoom, tile.data.size()))
if not res:
p.setPen(Qt.darkRed)
p.drawText(rect, Qt.AlignCenter, "Bad tile")
p.setPen(Qt.black)
p.drawRect(rect)
return image
def image(self):
width = (self.xmax - self.xmin + 1) * self.TILE_SIZE
height = (self.ymax - self.ymin + 1) * self.TILE_SIZE
image = QImage(width, height, QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
p = QPainter(image)
for tile in self.tiles.values():
if not tile.data:
continue
x = tile.x - self.xmin
y = tile.y - self.ymin
rect = QRect(x * self.TILE_SIZE, y * self.TILE_SIZE, self.TILE_SIZE, self.TILE_SIZE)
timg = QImage()
res = timg.loadFromData(tile.data)
if res:
p.drawImage(rect, timg)
if debug_mode:
p.setPen(Qt.black)
p.drawText(
rect,
Qt.AlignBottom | Qt.AlignRight,
# "x: %s, y:%s\nz: %s, data: %s" % (x, y, tile.zoom, tile.data.size())
"z: %s, data: %s" % (tile.zoom, tile.data.size())
)
if not res:
p.setPen(Qt.darkRed)
p.drawText(rect, Qt.AlignCenter, "Bad tile")
p.setPen(Qt.black)
p.drawRect(rect)
return image
class LinzDataImporter: # pylint: disable=too-many-instance-attributes,too-many-public-methods
"""
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
self.iface = iface
self.canvas = self.iface.mapCanvas()
self.services_loaded = False
self.cache_updated = False
self.update_cache = True # Skip cache updates. Useful for testing.
# initialise 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",
"linz-data-importer{}.qm".format(locale))
if os.path.exists(locale_path):
translator = QTranslator()
translator.load(locale_path)
if qVersion() > "4.3.3":
QCoreApplication.installTranslator(translator)
self.actions = []
self.toolbar = self.iface.addToolBar(u"LINZ Data Importer")
self.toolbar.setObjectName(u"LINZ Data Importer")
self.menu = self.translate(u"&linz-data-importer")
# Track data reading
self.data_feeds = {}
self.domains = []
self.row = None
self.service = None
self.object_id = None
self.layer_title = None
self.selected_crs = None
self.selected_crs_int = None
self.curr_list_wid_index = None
self.layers_loaded = False
self.service_versions = {"wfs": "2.0.0", "wmts": "1.0.0"}
# Instances
self.api_key_instance = ApiKey()
self.local_store = Localstore()
self.dlg = ServiceDialog()
self.qimage = QImage
self.domain: str
self.data_type: str
self.proxy_model: CustomSortFilterProxyModel
self.table_model: TableModel
self.selection_model: QItemSelectionModel
self.qimage = QImage
self.data_type: str
self.proxy_model: CustomSortFilterProxyModel
self.table_model: TableModel
self.selection_model: QItemSelectionModel
# noinspection PyMethodMayBeStatic
def translate(self, message): # pylint:disable=no-self-use
"""
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("LinzDataImporter", message)
def add_action( # pylint:disable=too-many-arguments
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 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 index1=self.sourceModel().index(sourceRow, 1, sourceParent)
index2=self.sourceModel().index(sourceRow, 2, sourceParent)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: boloadWMSol
:param add_to_menu: Flag incdicating 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 show 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.addPluginToWebMenu(self.menu, action)
self.actions.append(action)
return action
def initGui(self): # pylint:disable=invalid-name
"""
Create the menu entries and toolbar icons inside the QGIS GUI.
"""
icon_path = os.path.join(self.plugin_dir, "icons")
self.add_action(
os.path.join(icon_path, "icon.png"),
text=self.translate(u"Load Data"),
callback=self.run,
parent=self.iface.mainWindow(),
)
# Plugin Dialog
self.dlg.uListOptions.itemClicked.connect(self.show_selected_option)
self.dlg.uListOptions.itemClicked.emit(self.dlg.uListOptions.item(0))
model = QStandardItemModel()
self.dlg.uCRSCombo.setModel(model)
self.dlg.uCRSCombo.currentIndexChanged.connect(self.layer_crs_selected)
self.dlg.uLabelWarning.setStyleSheet("color:red")
self.dlg.uWarningSettings.setStyleSheet("color:red")
self.add_item(title="ALL", icon=os.path.join(icon_path, "all.png"))
self.add_item(title="WFS", icon=os.path.join(icon_path, "wfs.png"))
self.add_item(title="WMTS", icon=os.path.join(icon_path, "wmts.png"))
self.add_item(title="Settings",
icon=os.path.join(icon_path, "settings.png"))
self.add_item(title="Help", icon=os.path.join(icon_path, "help.png"))
self.add_item(title="About", icon=os.path.join(icon_path, "about.png"))
# set table model
self.set_table_model_view()
# set help html
self.dlg.hHelpHtml.setOpenExternalLinks(True)
help_file = os.path.join(self.plugin_dir, "help.html")
with open(help_file, "r", encoding="utf-8") as file:
help_html = file.read()
help_html.format(self.plugin_dir)
self.dlg.hHelpHtml.setHtml(help_html.format(icon_path))
# set about html
self.dlg.hAboutHtml.setOpenExternalLinks(True)
about_file = os.path.join(self.plugin_dir, "about.html")
with open(about_file, "r", encoding="utf-8") as file:
about_html = file.read()
about_html.format(self.plugin_dir)
self.dlg.hAboutHtml.setHtml(about_html.format(icon_path))
# populate settings
# default data services to combo
self.dlg.uComboBoxDomain.addItems(SER)
# settings signals
self.dlg.uBtnAddDomain.clicked.connect(self.add_new_domain)
for entry in range(1, 11):
getattr(self.dlg,
"uBtnSaveDomain{0}".format(entry)).clicked.connect(
self.save_domain)
getattr(self.dlg,
"uBtnRemoveDomain{0}".format(entry)).clicked.connect(
self.save_domain)
self.load_settings()
def add_item(self, title, icon):
"""
Add item to the dialog's list of options
"""
item = QListWidgetItem(title)
item.setIcon(QIcon(icon))
self.dlg.uListOptions.addItem(item)
def clear_settings(self):
"""
Removes text from settings QLineEdits
"""
for entry in range(1, 11):
getattr(self.dlg, "uTextDomain{0}".format(entry)).setText("")
getattr(self.dlg, "uTextAPIKey{0}".format(entry)).setText("")
def load_settings(self):
"""
1. Populate settings QLineEdits with domain /
API keys as stored via service_data.ApiKey().
2. Hide all the settings QLineEdits that do not
have text.
"""
self.domains = []
self.clear_settings()
api_keys = self.api_key_instance.get_api_keys()
if api_keys:
for domain, api_key in list(api_keys.items()):
self.domains.append(domain)
getattr(self.dlg, "uTextDomain{0}".format(len(
self.domains))).setText(domain)
getattr(self.dlg, "uTextAPIKey{0}".format(len(
self.domains))).setText(api_key)
# Hide un-populated domain rows
for entry in range(len(self.domains) + 1, 11):
getattr(self.dlg, "uTextDomain{0}".format(entry)).hide()
getattr(self.dlg, "uTextAPIKey{0}".format(entry)).hide()
getattr(self.dlg, "uBtnRemoveDomain{0}".format(entry)).hide()
getattr(self.dlg, "uBtnSaveDomain{0}".format(entry)).hide()
def save_domain(self):
"""
Save all domain / API combinations as entered by the user.
If the calling button was a remove button do not save
the text in the associated QLineEdits.
"""
del_domain = 0
save_domain = 0
sending_btn = self.dlg.sender().objectName()
if sending_btn[:-1] == "uBtnRemoveDomain":
del_domain = sending_btn[-1]
if sending_btn[:-1] == "uBtnSaveDomain":
save_domain = sending_btn[-1]
keys = {}
for entry in range(1, len(self.domains) + 2):
if int(del_domain) == entry:
continue
domain = getattr(self.dlg, "uTextDomain{0}".format(entry)).text()
key = getattr(self.dlg,
"uTextAPIKey{0}".format(entry)).text().strip()
if domain and key:
keys[domain] = key
self.api_key_instance.set_api_keys(keys)
# remove store capability docs for the removed or add domain/key
# if they already exits .i.e these will be reloaded
if save_domain:
ui_elem_num = save_domain
else:
ui_elem_num = del_domain
domain = getattr(self.dlg, "uTextDomain{0}".format(ui_elem_num)).text()
self.local_store.del_domains_xml(domain)
# load / Reload service data
self.load_settings()
self.dlg.uWarningSettings.hide()
self.dlg.uLabelWarning.hide()
if self.curr_list_wid_index is not None:
self.dlg.uListOptions.setCurrentItem(self.curr_list_wid_index)
else:
self.dlg.uListOptions.setCurrentRow(0)
self.dlg.uStackedWidget.setCurrentIndex(0)
self.services_loaded = False # key change, load data again
self.load_ui()
def add_new_domain(self):
"""
Connected to the dialogs uBtnAddDomain button.
When the button is clicked add a new row
domain and API QLineEdits
"""
domain = self.dlg.uComboBoxDomain.currentText()
if domain in self.domains:
self.dlg.uWarningSettings.show()
self.dlg.uWarningSettings.setText(
"Warning: Domains must be unique. "
"Please edit the domain below")
return
if len(self.domains) >= 10:
self.dlg.uWarningSettings.show()
self.dlg.uWarningSettings.setText(
"Warning: You can only store up to . "
"10 domain entries")
return
if domain == "OTHER":
domain = ""
getattr(self.dlg,
"uTextDomain{0}".format(len(self.domains) + 1)).setText(domain)
getattr(self.dlg,
"uTextDomain{0}".format(len(self.domains) + 1)).show()
getattr(self.dlg,
"uTextAPIKey{0}".format(len(self.domains) + 1)).show()
getattr(self.dlg,
"uBtnRemoveDomain{0}".format(len(self.domains) + 1)).show()
getattr(self.dlg,
"uBtnSaveDomain{0}".format(len(self.domains) + 1)).show()
self.dlg.uWarningSettings.hide()
def unload(self):
"""
Removes the plugin menu item and icon from QGIS GUI.
"""
for action in self.actions:
self.iface.removePluginWebMenu(
self.translate(u"&linz-data-importer"), action)
self.iface.removeToolBarIcon(action)
del self.toolbar
def run(self):
"""
Connected to the plugins tool bar icon.
load the table data and show the main UI.
"""
if not self.services_loaded:
if not self.api_key_instance.get_api_keys():
self.dlg.uLabelWarning.setText(
"Access the “Settings” tab to configure a service domain and API key."
)
self.dlg.uLabelWarning.show()
else:
self.load_ui()
if not self.cache_updated and self.update_cache:
self.update_service_data_cache()
self.dlg.show()
def purge_cache(self):
"""
Delete any cache files that are not the most current
"""
self.local_store.purge_cache()
def update_service_data_cache(self):
"""
Update the local cache by deleting the locally stored capability
documents and then re-fetching from the associated web resource
"""
self.services_loaded = False
thread = threading.Thread(target=self.load_all_services, args=(True, ))
thread.start()
self.cache_updated = True
def load_ui(self):
"""
Wrapper for loadAllServices() to handle any errors
"""
load_data_err = self.load_all_services()
if load_data_err:
self.dlg.uLabelWarning.setText(load_data_err)
self.dlg.uLabelWarning.show()
self.update_cache = False
else:
self.dlg.uLabelWarning.hide()
def set_section_size(self):
"""
Set tableview col width based on contents
"""
self.dlg.uTableView.horizontalHeader().setSectionResizeMode(
0, QHeaderView.ResizeToContents)
self.dlg.uTableView.horizontalHeader().setSectionResizeMode(
1, QHeaderView.ResizeToContents)
self.dlg.uTableView.horizontalHeader().setSectionResizeMode(
2, QHeaderView.ResizeToContents)
self.dlg.uTableView.horizontalHeader().setSectionResizeMode(
3, QHeaderView.ResizeToContents)
def load_all_services(self, update_cache=False):
"""
Iterate over all domains and service types (WMTS, WFS).
Request, process, store and format capability documents
"""
all_data = []
for domain in self.api_key_instance.get_api_keys():
for service in SER_TYPES:
if domain in SER_TYPES_SKIP:
if service in SER_TYPES_SKIP[domain]:
continue
# set service_data obj e.g self.linz_wms=service_data obj
data_feed = "{0}_{1}".format(domain, service) # eg linz_wms
setattr(
self,
data_feed,
ServiceData(
domain,
service,
self.service_versions,
self.api_key_instance,
update_cache,
),
)
service_data_instance = getattr(self, data_feed)
self.data_feeds[
data_feed] = service_data_instance # keep record of ser data insts
service_data_instance.process_service_data()
if service_data_instance.disabled:
continue
if service_data_instance.err:
return service_data_instance.err
all_data.extend(service_data_instance.info)
self.table_model.setData(all_data)
self.set_section_size()
self.services_loaded = True
if update_cache:
self.purge_cache()
return None
def show_selected_option(self, item):
"""
Connected to left pane QListWidget TOC. When items in the QListWidget
are clicked, display the associated Tab. If 'WMTS',
'WFS' or 'ALL' apply the filter to the tables proxy model
:param item: The item in the QListWidget that was clicked
:type item: QListWidgetItem
"""
if item:
if item.text() == "ALL":
self.dlg.uStackedWidget.setCurrentIndex(0)
self.curr_list_wid_index = self.dlg.uListOptions.findItems(
item.text(), Qt.MatchExactly)[0]
self.proxy_model.set_service_type(("WMTS", "WFS"))
elif item.text() == "WFS":
self.proxy_model.set_service_type((item.text()))
self.curr_list_wid_index = self.dlg.uListOptions.findItems(
item.text(), Qt.MatchExactly)[0]
self.dlg.uStackedWidget.setCurrentIndex(0)
elif item.text() == "WMTS":
self.proxy_model.set_service_type((item.text()))
self.curr_list_wid_index = self.dlg.uListOptions.findItems(
item.text(), Qt.MatchExactly)[0]
self.dlg.uStackedWidget.setCurrentIndex(0)
elif item.text() == "Settings":
self.dlg.uStackedWidget.setCurrentIndex(1)
elif item.text() == "Help":
self.dlg.uStackedWidget.setCurrentIndex(2)
elif item.text() == "About":
self.dlg.uStackedWidget.setCurrentIndex(3)
def layer_crs_selected(self):
"""
Track the user selected crs. Check validity to
ensure only well formed crs are provided.
"""
valid = re.compile(r"^EPSG:\d+")
crs_text = self.dlg.uCRSCombo.currentText()
if valid.match(crs_text):
self.selected_crs = str(self.dlg.uCRSCombo.currentText())
if self.selected_crs:
self.selected_crs_int = int(self.selected_crs.strip("EPSG:"))
def get_preview(self, res, res_timeout):
"""
Fetch the preview image from the internet
:param res: The resolution of the image to be fetched
:type res: str
:param res_timeout: How long the request should wait for a response
:type res_timeout: int
"""
self.qimage = QImage()
url = (
"http://koordinates-tiles-d.global.ssl.fastly.net"
"/services/tiles/v4/thumbnail/layer={0},style=auto/{1}.png".format(
self.object_id, res))
try:
img_data = urllib.request.urlopen(url, timeout=res_timeout).read()
except URLError:
return False
except timeout:
return False
self.qimage.loadFromData(img_data)
if res == "300x200":
self.dlg.uLabelImgPreview.setPixmap(QPixmap(self.qimage))
else:
self.dlg.uLabelImgPreview.setPixmap(
QPixmap(self.qimage).scaledToHeight(200))
return True
def upd_preview(self):
"""
On the tableviews rowChanged fetch the datasets preview image
"""
if self.data_type != "layer":
self.dlg.uLabelImgPreview.clear()
self.dlg.uLabelImgPreview.setText("No preview available")
return
if self.get_preview("300x200", 0.5):
return
if self.get_preview("150x100", 5):
return
self.dlg.uLabelImgPreview.clear()
self.dlg.uLabelImgPreview.setText("No preview available")
def curr_selection(self):
"""
On the tableviews currentRowChanged store the details of the current
record Also, update the abstract as shown in the UI
"""
self.domain = self.row[0]
abstract = self.row[5]
self.data_type = self.row[1]
self.object_id = self.row[3]
self.service = self.row[2]
self.layer_title = self.row[4]
crs_options = self.row[6]
self.dlg.uCRSCombo.clear()
if self.data_type != "table":
self.dlg.uCRSCombo.addItems(crs_options)
curr_crs = self.map_crs()
if curr_crs in crs_options:
idx = self.dlg.uCRSCombo.findText(curr_crs)
self.dlg.uCRSCombo.setCurrentIndex(idx)
self.dlg.uTextDescription.setText(abstract)
def user_selection(self, selected):
"""
wrapper for methods required when the tableviews currentRowChanged
:param res: Current item tableView item
:type res: QModelIndex
"""
source_index = self.proxy_model.mapToSource(selected)
self.row = self.table_model.selectedRow(source_index.row())
self.curr_selection()
self.upd_preview()
def filter_table(self):
"""
Filter the table data when uTextFilter.textChanged
"""
filter_text = self.dlg.uTextFilter.text()
self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive)
self.proxy_model.setFilterKeyColumn(2)
self.proxy_model.setFilterFixedString(filter_text)
def set_table_model_view(self):
"""
Connect the tableView to the proxy model to the table model
"""
# Set Table Model
data = [["", "", "", "", ""]]
headers = [
"domain", "type", "service", "id", "layer name", "_desc", "_crs"
]
self.proxy_model = CustomSortFilterProxyModel()
self.table_model = TableModel(data, headers)
self.proxy_model.setSourceModel(self.table_model)
self.dlg.uTableView.setModel(self.proxy_model)
self.dlg.uTableView.setSortingEnabled(True)
self.dlg.uTableView.horizontalHeader().setStretchLastSection(True)
# Trigger updating of data abstract on user selection
self.selection_model = self.dlg.uTableView.selectionModel()
self.selection_model.currentRowChanged.connect(self.user_selection)
# Table filtering trigger
self.dlg.uTextFilter.textChanged.connect(self.filter_table)
# Import Button Clicked
self.dlg.uBtnImport.clicked.connect(self.import_dataset)
def map_crs(self):
"""
Return the current mapCanvas CRS
@return: crs reference (e.g EPSG:3857)
@rtype: str
"""
crs = self.canvas.mapSettings().destinationCrs().authid()
return crs
def set_project_srid(self):
"""
Set the projects projection. This is only done when a layer
is imported and no others have been already.
"""
crs = QgsCoordinateReferenceSystem(
self.selected_crs_int, QgsCoordinateReferenceSystem.EpsgCrsId)
self.canvas.setDestinationCrs(crs)
self.iface.messageBar().pushMessage(
"Info",
"""The LINZ Data Importer Plugin has changed the projects
projection to that of the imported layer""",
level=Qgis.Info,
duration=6,
)
def zoom_to(self):
"""zoom to newly imported"""
# Will seek user feedback. QGIS will
# Pan to first layer loaded
def import_dataset(self):
"""
Import the selected dataset to QGIS
"""
if not self.layers_loaded and not self.data_type == "table":
self.set_project_srid()
if self.service == "WFS":
uri = ("pagingEnabled='true' "
"preferCoordinatesForWfsT11='false' "
"restrictToRequestBBOX='1' "
"typename='{0}:{4}-{5}' "
"url='https://{0}/services;key={1}/{2}/{4}-{5}' "
"version='{3}'").format(
self.domain,
self.api_key_instance.get_api_key(self.domain),
self.service.lower(),
self.service_versions[self.service.lower()],
self.data_type,
self.object_id,
)
layer = QgsVectorLayer(uri, self.layer_title, self.service.upper())
elif self.service == "WMTS":
if self.domain == "basemaps.linz.govt.nz":
uri = (
"contextualWMSLegend=0"
"&crs={1}" # EPSG:2193
"&dpiMode=7&featureCount=10"
"&format=image/png"
"&layers={2}"
"&styles=default"
"&tileMatrixSet={1}" # EPSG:2193
"&url=https://{0}/v1/tiles/aerial/WMTSCapabilities.xml?api={3}"
).format(
self.domain,
self.selected_crs,
self.object_id,
self.api_key_instance.get_api_key(self.domain),
)
else:
uri = ("SmoothPixmapTransform=1"
"&contextualWMSLegend=0"
"&crs={1}&dpiMode=7&format=image/png"
"&layers={2}-{3}&styles=style%3Dauto&tileMatrixSet={1}"
"&url=https://{0}/services;"
"key={4}/{5}/{6}/{2}/{3}/"
"WMTSCapabilities.xml").format(
self.domain,
self.selected_crs,
self.data_type,
self.object_id,
self.api_key_instance.get_api_key(self.domain),
self.service.lower(),
self.service_versions[self.service.lower()],
)
layer = QgsRasterLayer(uri, self.layer_title, "wms")
else:
pass # ERROR not supported
QgsProject.instance().addMapLayer(layer)
self.layers_loaded = True
self.dlg.close()
