def handleFormofLayer(self):
"""Calls all important functions in the plugin.
First, if the selected layer is valid, the plugin checks whether it has
any foreign keys which reference another table. If this is the case
then those tables are loaded into the project and a ValueRelation
widget type is created in the appropriate field. Then, all other fields
have their widgets altered based on their fieldType and length. Next,
all empty groups are removed from the MapLayerRegistry. This is in case
the plugin added an empty group for the referenced tables but none were
added.
"""
selected_layer = self.iface.activeLayer()
if selected_layer:
if selected_layer.dataProvider().name() != 'postgres':
self.iface.messageBar().pushMessage(
"Autoform",
"Please select a PostGIS layer before running the plugin.",
level=Qgis.MessageLevel(1))
return
self.identifyRelations(selected_layer)
self.alterForm(selected_layer)
self.filterEmptyGroups()
self.iface.messageBar().pushMessage(
"Autoform",
"Form widgets were successfully changed!.",
level=Qgis.MessageLevel(0))
else:
self.iface.messageBar().pushMessage(
"Autoform",
"Please select a PostGIS layer before running the plugin.",
level=Qgis.MessageLevel(2))
def settingProcessParams(self, full_filename, outPath):
self.pixel_size = self.pixelSizeDoubleSpinBox.value()
self.inter_method = self.interpolatingMethodComboBox.currentText()
self.load_result = self.addResultsCheckBox.isChecked()
self.partials_create_load = self.createAndLoadIntermCheckBox.isChecked()
_, filename = os.path.split(full_filename)
base_name, ext = os.path.splitext(filename)
start_index = 1
out_path = os.path.join(
outPath, (base_name + '_r' + str(start_index)))
if os.path.exists(out_path):
import glob
key_for_glob = os.path.join(outPath, (base_name + '_r*' ))
dirs_list = glob.glob(key_for_glob)
indexes = []
for directory in dirs_list:
try:
fn_index = int(directory[-3:])
except ValueError:
try:
fn_index = int(directory[-2:])
except ValueError:
fn_index = int(directory[-1])
indexes.append(fn_index)
max_index = max(indexes)
next_index = max_index + 1
out_path = os.path.join(outPath,
(base_name + '_r' + str(next_index)))
self.dir_fns = dir_fns.DirAndPaths(filename, out_path)
self.showMessage(u'Starting processing LiDAR data {}'.format(base_name),
Qgis.MessageLevel(0))
try:
self.process = plugin_process.Process(full_filename,
out_path,
self.pixel_size,
self.inter_method,
self.partials_create_load)
except (ValueError, OSError) as message:
self.showQMessage(str(message))
self.showMessage('LiDAR Forestry Height stopped process',
Qgis.MessageLevel(1))
return
if self.partials_create_load:
self.load_raster_layer(self.process.dirs.out_paths['dtm'])
self.load_raster_layer(self.process.dirs.out_paths['dsm'])
if self.load_result:
self.load_raster_layer(self.process.dirs.out_paths['height'])
def _log_output(self, output, lines_per_msg=None):
if lines_per_msg is None:
QgsApplication.messageLog().logMessage(output, "Interlis",
Qgis.MessageLevel(0))
else:
lines = output.splitlines()
for i in range(0, len(lines), lines_per_msg):
msg = "\n".join(lines[i:i + lines_per_msg])
QgsApplication.messageLog().logMessage(msg, "Interlis",
Qgis.MessageLevel(0))
def readXml(self, node):
# early read of custom properties
self.readCustomProperties(node)
# get layer type
ol_layer_type = None
ol_layer_type_name = self.customProperty(
OpenlayersLayer.LAYER_PROPERTY, "")
if ol_layer_type_name != "":
ol_layer_type = self.olLayerTypeRegistry.getByName(
ol_layer_type_name)
else:
# handle ol_layer_type idx stored in layer node
# (OL plugin <= 1.1.2)
ol_layer_type_idx = int(node.toElement().attribute(
"ol_layer_type", "-1"))
if ol_layer_type_idx != -1:
ol_layer_type = self.olLayerTypeRegistry.getById(
ol_layer_type_idx)
if ol_layer_type is not None:
self.setLayerType(ol_layer_type)
else:
# Set default layer type
self.setLayerType(
self.olLayerTypeRegistry.getByName("OpenStreetMap"))
msg = "Obsolete or unknown layer type '%s', using OpenStreetMap\
instead" % ol_layer_type_name
self.iface.messageBar().pushMessage("OpenLayers Plugin",
msg,
level=Qgis.MessageLevel(1))
QgsMessageLog.logMessage(msg, "OpenLayers Plugin",
QgsMessageLog.WARNING)
return True
def replaceLayer(self, group, oldLayer, newLayer):
index = 0
for child in group.children():
if QgsLayerTree.isLayer(child):
if child.layerId() == oldLayer.id():
# insert new layer
QgsProject.instance().addMapLayer(newLayer, False)
newLayerNode = group.insertLayer(index, newLayer)
newLayerNode.setVisible(child.isVisible())
# remove old layer
QgsProject.instance().removeMapLayer(oldLayer.id())
msg = "Updated layer '%s' from old OpenLayers Plugin version" % newLayer.name(
)
self.iface.messageBar().pushMessage(
"OpenLayers Plugin", msg, level=Qgis.MessageLevel(0))
QgsMessageLog.logMessage(msg, "OpenLayers Plugin",
QgsMessageLog.INFO)
# layer replaced
return True
else:
if self.replaceLayer(child, oldLayer, newLayer):
# layer replaced in child group
return True
index += 1
# layer not in this group
return False
def importtoqgis(self):
# QGIS OGR provider only supports one geometry column per table
# We create a VRT with separate layers for each geometry
# This is also a workaround for a random sublayer order
# in QGIS 2.18 using "file.xtf,model.imd" as dataSourceUri.
__, vrt_tmp = tempfile.mkstemp('.vrt', 'tmp_')
ogr2vrt(self.iliDs(), vrt_tmp)
dataSourceUri = vrt_tmp
# QGIS 1.8:
# subLayerVectorLayer = QgsVectorLayer(
# dataSourceUri, "interlis_sublayers", "ogr")
# subLayerProvider = subLayerVectorLayer.dataProvider()
# if not subLayerProvider:
# QMessageBox.critical(None, "Error accessing interlis sublayers",
# "A problem occured during access of the sublayers")
# return
# subLayerList = subLayerProvider.subLayers()
# subLayerDialog = SublayersDialog()
# subLayerDialog.setupSublayerList(subLayerList)
# if subLayerDialog.exec_() == QDialog.Accepted:
# for layername in subLayerDialog.subLayerNames():
# add a new ogr layer for each selected sublayer
# self._plugin.iface.addVectorLayer(
# dataSourceUri + "|layername=" + layername, layername, "ogr")
# QGIS 2: Sublayer dialog opens automatically
self._plugin.iface.addVectorLayer(dataSourceUri, "Interlis layer",
"ogr")
self.accept()
self._plugin.iface.messageBar().pushMessage("Interlis",
"Import finished",
level=Qgis.MessageLevel(0),
duration=2)
def loadModel(self):
imd = None
try:
loader = ModelLoader(self.ui.mDataLineEdit.text())
models = loader.detect_models()
model_names = map(lambda m: m.name, models)
self._log_output("Looking up models: " + ', '.join(model_names))
ili = loader.gen_lookup_ili()
qDebug(ili)
wpsreq = self._create_wps_request(ili)
url = self.ui.mIlisMetaUrlLineEdit.text()
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader, 'application/xml')
data = QByteArray()
data.append(wpsreq)
reply = QgsNetworkAccessManager.instance().blockingPost(req, data)
if reply.error() == QNetworkReply.NoError:
result = reply.content()
imd = self._parse_wps_response(result)
except Exception as e:
qDebug("Exception during IlisModel download")
if imd is None:
self._show_log_window()
QgsApplication.messageLog().logMessage(
"Couldn't download Ilismeta model", "Interlis",
Qgis.MessageLevel(1))
self.ui.mModelLineEdit.setText("")
else:
fh, imdfn = tempfile.mkstemp(suffix='.imd')
os.close(fh)
with codecs.open(imdfn, "w", encoding='utf-8') as file:
file.write(imd)
self.ui.mModelLineEdit.setText(imdfn)
def runShellCmd(args):
loglines = []
loglines.append("Ili execution console output")
if isWindows():
command = ["cmd.exe", "/C ", '""' + args[0] + '"'
] + args[1:] + ['"']
else:
command = [none_typ for none_typ in args if none_typ is not None]
QgsMessageLog.logMessage(' '.join(command), level=Qgis.MessageLevel(0))
# java doesn't find quoted file on Win with: ''.join(['"%s" ' % c for c
# in command])
fused_command = ' '.join(command)
proc = subprocess.Popen(fused_command,
shell=True,
stdout=subprocess.PIPE,
stdin=subprocess.PIPE,
stderr=subprocess.STDOUT,
universal_newlines=True).stdout
for line in iter(proc.readline, ""):
loglines.append(line)
QgsMessageLog.logMessage(line, level=Qgis.MessageLevel(0))
IliUtils.consoleOutput = loglines
def __init__(self, maximum=100, message_title=""):
self.maximum = maximum
self.message_bar = iface.messageBar().createMessage(message_title, "")
self.progress_bar = QProgressBar()
self.progress_bar.setMaximum(maximum)
self.progress_bar.setAlignment(Qt.AlignLeft | Qt.AlignVCenter)
self.message_bar.layout().addWidget(self.progress_bar)
if iface is not None:
iface.messageBar().pushWidget(self.message_bar,
Qgis.MessageLevel())
self.step_size = 1
self.progress = 0
def addLayer(self, layerType):
if layerType.hasXYZUrl():
# create XYZ layer
layer, url = self.createXYZLayer(layerType, layerType.displayName)
else:
# create OpenlayersLayer
layer = OpenlayersLayer(self.iface, self._olLayerTypeRegistry)
layer.setName(layerType.displayName)
layer.setLayerType(layerType)
if layer.isValid():
coordRefSys = layerType.coordRefSys(self.canvasCrs())
self.setMapCrs(coordRefSys)
QgsProject.instance().addMapLayer(layer)
# store xyz config into qgis settings
if layerType.hasXYZUrl():
settings = QSettings()
settings.beginGroup('qgis/connections-xyz')
settings.setValue("%s/authcfg" % (layer.name()), '')
settings.setValue("%s/password" % (layer.name()), '')
settings.setValue("%s/referer" % (layer.name()), '')
settings.setValue("%s/url" % (layer.name()), url)
settings.setValue("%s/username" % (layer.name()), '')
# specify max/min or else only a picture of the map is saved
# in settings
settings.setValue("%s/zmax" % (layer.name()), '18')
settings.setValue("%s/zmin" % (layer.name()), '0')
settings.endGroup()
# reload connections to update Browser Panel content
self.iface.reloadConnections()
self._ol_layers += [layer]
# last added layer is new reference
self.setReferenceLayer(layer)
if not layerType.hasXYZUrl():
msg = "Printing and rotating of Javascript API " \
"based layers is currently not supported!"
self.iface.messageBar().pushMessage("OpenLayers Plugin",
msg,
level=Qgis.MessageLevel(1),
duration=5)
def loadModel(self):
imd = None
try:
loader = ModelLoader(self.ui.mDataLineEdit.text())
models = loader.detect_models()
model_names = map(lambda m: m.name, models)
self._log_output("Looking up models: " + ', '.join(model_names))
ili = loader.gen_lookup_ili()
qDebug(ili)
wpsreq = self._create_wps_request(ili)
url = self.ui.mIlisMetaUrlLineEdit.text()
req = QNetworkRequest(QUrl(url))
req.setHeader(QNetworkRequest.ContentTypeHeader, 'application/xml')
reply = QgsNetworkAccessManager.instance().post(req, wpsreq)
# Wait for reply or timeout
loop = QEventLoop()
reply.finished.connect(loop.quit)
QTimer.singleShot(15000, reply.abort)
loop.exec_()
if reply.isFinished() and reply.error() == QNetworkReply.NoError:
result = reply.readAll()
imd = self._parse_wps_response(result)
except:
qDebug("Exception during IlisModel download")
if imd is None:
self._show_log_window()
QgsApplication.messageLog().logMessage(
"Couldn't download Ilismeta model", "Interlis",
Qgis.MessageLevel(1))
self.ui.mModelLineEdit.setText("")
else:
fh, imdfn = tempfile.mkstemp(suffix='.imd')
os.close(fh)
with codecs.open(imdfn, "w", encoding='utf-8') as file:
file.write(imd)
self.ui.mModelLineEdit.setText(imdfn)
def importtodb(self):
self._log_output("Import data from %s" % self.iliDs())
cfg = self._ogr_config_tmp(self.iliDs())
ogroutput = cfg.transform(
dest=self.pgDs(),
skipfailures=self.ui.cbSkipFailures.isChecked(),
debug=True)
self._remove_ogrconfig_tmp()
self._plugin.messageLogWidget().show()
self._log_output(ogroutput)
self._log_output("Import finished")
uri = self.pgUri()
layer_infos = cfg.layer_infos()
layer_names = cfg.layer_names()
# if self.ui.cbImportEnums.isChecked():
# layer_infos += cfg.enum_infos()
# layer_names += cfg.enum_names()
subLayerDialog = SublayersDialog()
subLayerDialog.setupLayerList(layer_names)
if subLayerDialog.exec_() == QDialog.Accepted:
for layer_id in subLayerDialog.layerNames():
# add a new layer for each selected row
for layer in layer_infos:
if layer['name'] == layer_id:
geom_column = layer['geom_field'] if (
'geom_field' in layer) else None
uri.setDataSource("", layer['name'], geom_column)
self._plugin.iface.addVectorLayer(
uri.uri(), layer['name'], 'postgres')
self.accept()
self._plugin.iface.messageBar().pushMessage(
"Interlis",
"Import finished",
level=Qgis.MessageLevel(0),
duration=2)
def errfunc(text):
QgsMessageLog.logMessage(text, level=Qgis.MessageLevel(2))
def settingProcessParams(self, full_filename, outPath):
"""Set the params that are used in the process and call to the
process module
"""
self.createDictParams()
partialsCreateAndLoad = self.loadPartialsCheckBox.isChecked()
sombrasOutResults = self.loadHillShadeCheckBox.isChecked()
if self.InputFilesOptions.currentIndex() == 0:
sizeDEM = self.laspyPixelSizeDoubleSpinBox.value()
_, filename = os.path.split(full_filename)
base_name, ext = os.path.splitext(filename)
start_index = 1
out_path = os.path.join(
outPath, (base_name + '_r' + str(start_index)))
if os.path.exists(out_path):
import glob
key_for_glob = os.path.join(outPath, (base_name + '_r*' ))
dirs_list = glob.glob(key_for_glob)
indexes = []
for directory in dirs_list:
fn_index = int(directory[-1])
indexes.append(fn_index)
max_index = max(indexes)
next_index = max_index + 1
out_path = os.path.join(outPath,
(base_name + '_r' + str(next_index)))
self.dir_funs = dir_fns.DirAndPaths()
if self.InputFilesOptions.currentIndex() == 0:
self.showMessage('Starting processing LiDAR data {}'.format(
base_name) +
u' with LasPy Library', MESSAGE_LEVEL)
self.inter_method = self.interpolatingMethodComboBox.currentText()
# TODO
if self.process_option == 'Surfaces':
terrain = False
surfaces = True
elif self.process_option == 'Terrain':
terrain = True
surfaces = False
#TODO: User can select both results
# elif self.process_option == 'Both (Surfaces and Terrain)':
# terrain = True
# surfaces = True
if not os.path.exists(out_path):
os.makedirs(out_path)
self.laspyLidar = laspy_utils.LiDAR(full_filename,
out_path,
partialsCreateAndLoad,
terrain, surfaces)
try:
self.lidar_arrays_list, self.las_file_extent, self.density =\
self.laspyLidar.process()
except ValueError as message:
self.showQMessage(str(message))
self.showMessage('Batch Hillshader stoped process',
Qgis.MessageLevel(1))
return
self.lidar_results = [self.lidar_arrays_list,
self.las_file_extent,
self.density]
self.laspyRasterize = laspy_utils.RasterizeLiDAR(
full_filename,
self.lidar_results,
out_path,
terrain, surfaces,
self.inter_method,
sizeDEM)
self.interpolated_grid = self.laspyRasterize.interpolate_grid()
dem_full_path = self.laspyRasterize.array_2_raster(
self.interpolated_grid)
self.dem_array, self.no_data_value = raster_funs.raster_2_array(
dem_full_path)
if partialsCreateAndLoad:
dem_filename, _ = os.path.splitext(
os.path.split(dem_full_path)[-1])
raster_funs.load_raster_layer(
dem_full_path,
dem_filename)
self.showMessage('Processing data... {}'.format(base_name),
MESSAGE_LEVEL)
self.HillDEM = hillshader_process.HillshaderDEM(
dem_full_path,
self.dem_array,
self.no_data_value,
partialsCreateAndLoad,
sombrasOutResults,
self.hill_params,
out_path)
if not partialsCreateAndLoad:
self.dir_funs.remove_temp_file(dem_full_path)
intermediate_folder = os.path.split(
self.laspyRasterize.dirs['dem'])[0]
self.dir_funs.remove_temp_dir(self.laspyRasterize.dirs['dem'])
self.dir_funs.remove_temp_dir(intermediate_folder)
self.showMessage('Process finisehd: {} file created'.format(
self.HillDEM.file_templates['composed_hillshade'].format(
base_name)), MESSAGE_LEVEL)
else:
self.showMessage('Starting processing DEM data {}'.format(
base_name), MESSAGE_LEVEL)
self.dem_array, self.no_data_value = raster_funs.raster_2_array(
full_filename)
self.HillDEM = hillshader_process.HillshaderDEM(
full_filename,
self.dem_array,
self.no_data_value,
partialsCreateAndLoad,
sombrasOutResults,
self.hill_params,
out_path)
self.showMessage('Process finisehd: {} file created'.format(
self.HillDEM.file_templates['composed_hillshade'].format(
base_name)), MESSAGE_LEVEL)
* You should have received a copy of the GNU General Public License *
* along with this program. If not, see <https://www.gnu.org/licenses/> *
***************************************************************************/
"""
import os
from osgeo import gdal
from qgis.PyQt import QtWidgets, uic
from qgis.gui import QgsMessageBar
from . import hillshader_process
from .plugin_utils import raster_funs
from .plugin_utils import files_and_dirs_funs as dir_fns
try:
from qgis.core import Qgis
MESSAGE_LEVEL = Qgis.MessageLevel(0)
except ImportError:
MESSAGE_LEVEL = QgsMessageBar.INFO
from .bh_errors import LasPyNotFoundError
try:
from . import laspy_utils
HAS_LASPY = True
except LasPyNotFoundError as e:
HAS_LASPY = False
try:
from . import version
except ImportError:
class version(object):
