def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.iface.attributesToolBar().removeAction(self.toolboxAction)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.toolbox.deleteLater()
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
self.iface.unregisterCustomDropHandler(self.drop_handler)
QgsApplication.dataItemProviderRegistry().removeProvider(self.item_provider)
removeMenus()
Processing.deinitialize()
def unload(self):
self.toolbox.setVisible(False)
self.iface.removeDockWidget(self.toolbox)
self.resultsDock.setVisible(False)
self.iface.removeDockWidget(self.resultsDock)
self.menu.deleteLater()
# delete temporary output files
folder = QgsProcessingUtils.tempFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
# also delete temporary help files
folder = tempHelpFolder()
if QDir(folder).exists():
shutil.rmtree(folder, True)
self.iface.unregisterMainWindowAction(self.toolboxAction)
self.iface.unregisterMainWindowAction(self.modelerAction)
self.iface.unregisterMainWindowAction(self.historyAction)
self.iface.unregisterMainWindowAction(self.resultsAction)
self.iface.unregisterOptionsWidgetFactory(self.options_factory)
self.iface.deregisterLocatorFilter(self.locator_filter)
removeMenus()
Processing.deinitialize()
def getConsoleCommands(self, parameters, context, feedback):
arguments = []
arguments.append('-resolution')
arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(parameters, self.RESOLUTION, context)])
if self.parameterAsBool(parameters, buildvrt.SEPARATE, context):
arguments.append('-separate')
if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context):
arguments.append('-allow_projection_difference')
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt')
with open(listFile, 'w') as f:
layers = []
for l in self.parameterAsLayerList(parameters, self.INPUT, context):
layers.append(l.source())
f.write('\n'.join(layers))
arguments.append('-input_file_list')
arguments.append(listFile)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
# Ideally the file extensions should be limited to just .vrt but I'm not sure how
# to do it simply so instead a check is performed.
_, ext = os.path.splitext(out)
if not ext.lower() == '.vrt':
out = out[:-len(ext)] + '.vrt'
if isinstance(parameters[self.OUTPUT], QgsProcessingOutputLayerDefinition):
output_def = QgsProcessingOutputLayerDefinition(parameters[self.OUTPUT])
output_def.sink = QgsProperty.fromValue(out)
self.setOutputValue(self.OUTPUT, output_def)
else:
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters):
arguments = []
arguments.append('-resolution')
arguments.append(self.RESOLUTION_OPTIONS[self.getParameterValue(self.RESOLUTION)])
if self.getParameterValue(buildvrt.SEPARATE):
arguments.append('-separate')
if self.getParameterValue(buildvrt.PROJ_DIFFERENCE):
arguments.append('-allow_projection_difference')
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt')
with open(listFile, 'w') as f:
f.write(self.getParameterValue(buildvrt.INPUT).replace(';', '\n'))
arguments.append('-input_file_list')
arguments.append(listFile)
out = self.getOutputValue(buildvrt.OUTPUT)
# Ideally the file extensions should be limited to just .vrt but I'm not sure how
# to do it simply so instead a check is performed.
_, ext = os.path.splitext(out)
if not ext.lower() == '.vrt':
out = out.replace(ext, '.vrt')
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def grassDataFolder():
"""
Creates and returns the GRASS temporary DB directory.
"""
tempfolder = os.path.normpath(
os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata'))
mkdir(tempfolder)
return tempfolder
def grassDataFolder():
"""
Creates and returns the GRASS temporary DB directory.
"""
tempfolder = os.path.normpath(
os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata'))
mkdir(tempfolder)
return tempfolder
def getTempDirInTempFolder():
"""Returns a temporary directory, putting it into a temp folder.
"""
path = QgsProcessingUtils.tempFolder()
path = os.path.join(path, uuid.uuid4().hex)
mkdir(path)
return path
def getTempDirInTempFolder():
"""Returns a temporary directory, putting it into a temp folder.
"""
path = QgsProcessingUtils.tempFolder()
path = os.path.join(path, uuid.uuid4().hex)
mkdir(path)
return path
def getTempFilename(ext=None):
tmpPath = QgsProcessingUtils.tempFolder()
t = time.time()
m = math.floor(t)
uid = '{:8x}{:05x}'.format(m, int((t - m) * 1000000))
if ext is None:
filename = os.path.join(tmpPath, '{}{}'.format(uid, getNumExportedLayers()))
else:
filename = os.path.join(tmpPath, '{}{}.{}'.format(uid, getNumExportedLayers(), ext))
return filename
def getTempFilename(ext=None):
tmpPath = QgsProcessingUtils.tempFolder()
t = time.time()
m = math.floor(t)
uid = '{:8x}{:05x}'.format(m, int((t - m) * 1000000))
if ext is None:
filename = os.path.join(tmpPath, '{}{}'.format(uid, getNumExportedLayers()))
else:
filename = os.path.join(tmpPath, '{}{}.{}'.format(uid, getNumExportedLayers(), ext))
return filename
def writeLayerParameterToTextFile(filename, alg, parameters, parameter_name, context, quote=True, executing=False):
listFile = os.path.join(QgsProcessingUtils.tempFolder(), filename)
with open(listFile, 'w') as f:
if executing:
layers = []
for l in alg.parameterAsLayerList(parameters, parameter_name, context):
if quote:
layers.append('"' + l.source() + '"')
else:
layers.append(l.source())
f.write('\n'.join(layers))
return listFile
def writeLayerParameterToTextFile(filename, alg, parameters, parameter_name, context, quote=True, executing=False):
listFile = os.path.join(QgsProcessingUtils.tempFolder(), filename)
with open(listFile, 'w') as f:
if executing:
layers = []
for l in alg.parameterAsLayerList(parameters, parameter_name, context):
if quote:
layers.append('"' + l.source() + '"')
else:
layers.append(l.source())
f.write('\n'.join(layers))
return listFile
def initAlgorithm(self, config):
''' Here we define the inputs and output of the algorithm. '''
#
self._define_params()
for param in sorted(self.the_params, key=self.the_params.__getitem__):
b = self.the_params[param][0]
qparam = set_param(param, self.the_params)
if qparam != None:
if b < 100:
self.addParameter(qparam)
elif b < 1000:
self.addParameter((qparam))
else:
self.addParameter(qparam, True)
# Other variables
self._error = ''
self.tmpDir = QgsProcessingUtils.tempFolder()
def getConsoleCommands(self,
parameters,
context,
feedback,
executing=True):
arguments = []
arguments.append('-resolution')
arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(
parameters, self.RESOLUTION, context)])
if self.parameterAsBool(parameters, buildvrt.SEPARATE, context):
arguments.append('-separate')
if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context):
arguments.append('-allow_projection_difference')
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
listFile = os.path.join(QgsProcessingUtils.tempFolder(),
'buildvrtInputFiles.txt')
with open(listFile, 'w') as f:
layers = []
for l in self.parameterAsLayerList(parameters, self.INPUT,
context):
layers.append(l.source())
f.write('\n'.join(layers))
arguments.append('-input_file_list')
arguments.append(listFile)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
# Ideally the file extensions should be limited to just .vrt but I'm not sure how
# to do it simply so instead a check is performed.
_, ext = os.path.splitext(out)
if not ext.lower() == '.vrt':
out = out[:-len(ext)] + '.vrt'
if isinstance(parameters[self.OUTPUT],
QgsProcessingOutputLayerDefinition):
output_def = QgsProcessingOutputLayerDefinition(
parameters[self.OUTPUT])
output_def.sink = QgsProperty.fromValue(out)
self.setOutputValue(self.OUTPUT, output_def)
else:
self.setOutputValue(self.OUTPUT, out)
arguments.append(out)
return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def getConsoleCommands(self, parameters, context, feedback, executing=True):
arguments = []
arguments.append('-resolution')
arguments.append(self.RESOLUTION_OPTIONS[self.parameterAsEnum(parameters, self.RESOLUTION, context)])
if self.parameterAsBool(parameters, buildvrt.SEPARATE, context):
arguments.append('-separate')
if self.parameterAsBool(parameters, buildvrt.PROJ_DIFFERENCE, context):
arguments.append('-allow_projection_difference')
# Always write input files to a text file in case there are many of them and the
# length of the command will be longer then allowed in command prompt
listFile = os.path.join(QgsProcessingUtils.tempFolder(), 'buildvrtInputFiles.txt')
with open(listFile, 'w') as f:
layers = []
for l in self.parameterAsLayerList(parameters, self.INPUT, context):
layers.append(l.source())
f.write('\n'.join(layers))
arguments.append('-input_file_list')
arguments.append(listFile)
out = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
arguments.append(out)
return ['gdalbuildvrt', GdalUtils.escapeAndJoin(arguments)]
def initAlgorithm(self, config):
''' Here we define the inputs and output of the algorithm. '''
#
self._define_params()
if is_dependencies_satisfied:
# Prepare all parameters needed for plotting the colour bar
for param in sorted(self.the_params,
key=self.the_params.__getitem__):
b = self.the_params[param][0]
qparam = set_param(param, self.the_params)
if qparam != None:
if b < 100:
self.addParameter(qparam)
elif b < 1000:
self.addParameter((qparam))
else:
self.addParameter(qparam, True)
else:
qparam = set_param(self.DEP, self._err_param)
self.addParameter(qparam)
self.tmpDir = QgsProcessingUtils.tempFolder()
self._error = ''
def processAlgorithm(self, parameters, context, feedback):
# get inputs
inputTab = self.parameterAsVectorLayer(parameters, self.inputTab, context)
colApply = self.parameterAsFields(parameters, self.colApply, context)
thresh = self.parameterAsString(parameters, self.thresh, context)
maxIter = self.parameterAsString(parameters, self.maxIter, context)
outPath = self.parameterAsString(parameters, self.OUTPUT, context)
# create output layer from input data
outTab = QgsVectorLayer('Polygon', 'outTab', 'memory')
CRS = inputTab.crs()
outTab.setCrs(CRS)
outTab.dataProvider().addAttributes(inputTab.dataProvider().fields().toList())
outTab.updateFields()
feats = [feat for feat in inputTab.getFeatures()]
outTab.dataProvider().addFeatures(feats)
outTab.updateExtents()
# redefine data types
thresh = float(thresh)
maxIter = int(maxIter)
# generate temp folder
QgsMessageLog.logMessage('Creating temporary output directory...', 'User notification', 0)
tempDir = QgsProcessingUtils.tempFolder()
if not os.path.exists(tempDir):
os.makedirs(tempDir)
# get field indices of interest
QgsMessageLog.logMessage('Getting field names and indeces...', 'User notification', 0)
fieldIdx = []
fieldNames = outTab.fields().names()
for f in list(range(0, len(fieldNames))):
if fieldNames[f] in colApply:
fieldIdx.append(fieldNames.index(fieldNames[f]))
def abideMinCases_func():
# create container for information about processed features
allProc = []
# iterate over each feature
feats = outTab.getFeatures()
feat_iter_count = 0
n_feats = outTab.featureCount()
for feat in feats:
feat_iter_count += 1
QgsMessageLog.logMessage('Processing feature...(' + str(feat_iter_count) + '/' + str(n_feats) + ')', 'User notification', 0)
# get attributes
atts = feat.attributes()
# iterate over fields of interest
for a in list(range(0, len(atts))):
QgsMessageLog.logMessage('Processing field...(' + str(a+1) + '/' + str(len(atts)) + ')', 'User notification', 0)
# get active if current field is within the fields of interest
if a in fieldIdx:
# extract value in question and area size for the respective features
to_val = atts[a]
# get active if attribute value is lower than defined threshold
if atts[a] < thresh:
# select current feature and create new layer
outTab.selectByIds([feat.id()])
temp_fileName = tempDir + '/temp_selected_' + str(feat_iter_count) + '_' + str(a) + '.gpkg'
QgsVectorFileWriter.writeAsVectorFormat(outTab, temp_fileName, 'ANSI', outTab.crs(), 'GPKG', 1)
# get adjacent features
params = {'INPUT' : outTab,
'INTERSECT' : QgsProcessingFeatureSourceDefinition(temp_fileName, False),
'METHOD' : 0,
'PREDICATE' : [4] }
adjSel = processing.run('native:selectbylocation', params)['OUTPUT']
adj_feats = adjSel.selectedFeatures()
adjSel.removeSelection()
# get attribute values of adjacent features
adjIdx = []
adjAtts = []
for adj_feat in adj_feats:
adjIdx.append(adj_feat.id())
adjAtts.append(adj_feat[a])
QgsMessageLog.logMessage('Feature comparison with ' + str(len(adjIdx)) + ' adjacent features...', 'User notification', 0)
# sort adjacent features by attribute values
adjIdx = [x for _, x in sorted(zip(adjAtts, adjIdx))]
adjAtts = sorted(adjAtts)
# iterate over each appropriate adjacent feature pair as long as the threshold is not reached
new_val = to_val
for p in list(range(0, len(adjIdx))):
# collect information about current feature pair
pair1 = str(feat.id()) + '_' + str(adjIdx[p])
pair2 = str(adjIdx[p]) + '_' + str(feat.id())
# get active if this feature pair has not been processed before
if (pair1 not in allProc) and (pair2 not in allProc) and (new_val < thresh):
# get values of adjacent polygon
outTab.selectByIds([adjIdx[p]])
comp_val = outTab.selectedFeatures()[0].attributes()[a]
outTab.removeSelection()
# calculate new value as mean
new_val = (to_val + comp_val) / 2
# update attribute values in respective features
outTab.startEditing()
outTab.changeAttributeValue(adjIdx[p], a, new_val)
outTab.changeAttributeValue(feat.id(), a, new_val)
outTab.commitChanges()
# collect information about this processed feature pair
allProc.append(pair1)
# update value in question
to_val = new_val
return outTab
# execute function
for l in list(range(0, maxIter)):
QgsMessageLog.logMessage('Start iterative processing...(' + str(l+1) + '/' + str(maxIter) + ')', 'User notification', 0)
outTab = abideMinCases_func()
# write to file
QgsMessageLog.logMessage('Writing results to file...', 'User notification', 0)
QgsVectorFileWriter.writeAsVectorFormat(outTab, outPath, 'ANSI', CRS, 'GPKG')
# add the new layer to canvas
QgsProject.instance().addMapLayer(outTab)
QgsMapCanvas().setExtent(outTab.extent())
QgsMapCanvas().setLayers([outTab])
return {self.OUTPUT: outTab}
def grassDataFolder():
tempfolder = os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata')
mkdir(tempfolder)
return tempfolder
def processAlgorithm(self, parameters, context, feedback):
# get input variables
raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT,
context)
band_number = self.parameterAsInt(parameters, self.BAND, context)
z_pos_down = self.parameterAsBoolean(parameters, self.Z_POS_DOWN,
context)
interval = self.parameterAsInt(parameters, self.INTERVAL, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
# set new default values in config
feedback.pushConsoleInfo(
self.tr(f'Storing new default settings in config...'))
self.config.set(self.module, 'interval', interval)
# 5% done
feedback.setProgress(5)
# get output file extension (.gpkg or .shp)
base_path, base_name, ext = utils.get_info_from_path(output)
# get CRS from raster file (for some reasons gdal:contour is assigning a false CRS otherwise...)
crs = raster_layer.crs()
# get temporary folder
temp_folder = QgsProcessingUtils.tempFolder()
# temp file for raw contours
contours_raw = os.path.join(temp_folder, f'contours_raw.{ext}')
# parameters for contour algortihm
params_contour = {
'INPUT': raster_layer,
'BAND': band_number,
'INTERVAL': interval,
'FIELD_NAME': 'ELEV',
'CREATE_3D': True,
'IGNORE_NODATA': False,
'NODATA':
raster_layer.dataProvider().sourceNoDataValue(band_number),
'OFFSET': 0,
'OUTPUT': contours_raw
}
# create raw contours
feedback.pushConsoleInfo(
self.tr(f'Creating raw contours with {interval} m interval...'))
processing.run('gdal:contour', params_contour)
# 35% done
feedback.setProgress(35)
# temp file for raw contours
contours_smooth = os.path.join(temp_folder, f'contours_smooth.{ext}')
# parameters for smoothing
params_smooth = {
'INPUT': contours_raw,
'ITERATIONS': 3,
'MAX_ANGLE': 180,
'OFFSET': 0.25,
'OUTPUT': contours_smooth
}
# smooth contours
feedback.pushConsoleInfo(self.tr(f'Smoothing contours...'))
processing.run('native:smoothgeometry', params_smooth)
# 55% done
feedback.setProgress(55)
# parameters for fixing projection
params_prj = {
'INPUT': contours_smooth,
'TARGET_CRS': crs,
'OUTPUT': output
}
# smooth contours
feedback.pushConsoleInfo(self.tr(f'Fixing CRS...'))
processing.run('native:reprojectlayer', params_prj)
# 60% done
feedback.setProgress(60)
# make variables accessible for post processing
self.output = output
self.z_pos_down = z_pos_down
result = {self.OUTPUT: output}
return result
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsVectorLayer(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(
self.invalidSourceError(parameters, self.INPUT))
max_distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE,
context)
raster_type = self.RASTER_TYPES[self.parameterAsEnum(
parameters, self.RASTER_TYPE, context)]
extent = self.parameterAsExtent(parameters, self.EXTENT, context,
source.sourceCrs())
if extent is None or extent.width() == 0 or extent.height() == 0:
extent = source.sourceExtent()
cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context)
if cell_size <= 0:
cell_size = int(min(extent.width(), extent.height()) / 250.0)
output_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
# open ogr vector layer from qgs map layer
ogrLayer, layerName = self.getOgrCompatibleSource(
self.INPUT, parameters, context, feedback, True)
if ogrLayer is None:
raise QgsProcessingException('Cannot connect OGR driver!')
ogr_vector_datasource = ogr.Open(ogrLayer)
ogr_vector_layer = ogr_vector_datasource.GetLayer(layerName)
feedback.pushInfo('Raster Type = {0}'.format(raster_type))
feedback.pushInfo('Cell Size = {0}'.format(cell_size))
feedback.pushInfo('Extent = {0}'.format(extent))
nodata = -9999
srs = osr.SpatialReference()
srs.ImportFromWkt(source.crs().toWkt())
transform = [
extent.xMinimum(), cell_size, 0.0,
extent.yMaximum(), 0.0, -cell_size
]
raster_width = int(
math.ceil(abs(extent.xMaximum() - extent.xMinimum()) / cell_size))
raster_height = int(
math.ceil(abs(extent.yMaximum() - extent.yMinimum()) / cell_size))
# rasterize temporary raterdataset from vector layer, extent, cellsize
temporary_path = os.path.join(
QgsProcessingUtils.tempFolder(),
'euc_distance_{}.tif'.format(uuid.uuid4().hex))
feedback.pushInfo('Temporary path = {0}'.format(temporary_path))
driver = gdal.GetDriverByName('GTiff')
rasterizedDS = driver.Create(temporary_path, raster_width,
raster_height, 1, gdal.GDT_Byte)
rasterizedDS.GetRasterBand(1).SetNoDataValue(nodata)
rasterizedDS.SetGeoTransform(transform)
rasterizedDS.SetProjection(srs.ExportToWkt())
rasterizedDS.GetRasterBand(1).Fill(nodata)
gdal.RasterizeLayer(rasterizedDS, [1],
ogr_vector_layer,
burn_values=[1])
# compute proximity from rasterized dataset
options = ['DISTUNITS=GEO']
if max_distance > 0:
options.append('MAXDIST=' + str(max_distance))
proximityDs = driver.Create(output_raster, raster_width, raster_height,
1, gdal.GetDataTypeByName(raster_type))
proximityDs.GetRasterBand(1).SetNoDataValue(nodata)
proximityDs.SetGeoTransform(transform)
proximityDs.SetProjection(srs.ExportToWkt())
proximityDs.GetRasterBand(1).Fill(nodata)
gdal.ComputeProximity(rasterizedDS.GetRasterBand(1),
proximityDs.GetRasterBand(1),
options,
callback=None)
# cleanup
rasterizedDS = None
proximityDs = None
ogr_vector_datasource = None
return {self.OUTPUT: output_raster}
def shade(self, rgb, b, c, syntax, output, crs, options):
'''Create shaded RGB grid from plain color grid and up to two additional shading grids
Parameters
----------
rgb : str
file path to RGB raster
b : str
file path to grey raster for calculation
c : str
file path to grey raster for calculation
syntax : str
raster calculator syntax
output : str
file path to shaded raster output
crs : QgsCoordinateReferenceSystem
target CRS for output raster
options : str
GDAL create options
Returns
-------
output : str
file path to shaded raster output
'''
# create temporary folder
tmp_folder = QgsProcessingUtils.tempFolder()
tmp_file = os.path.join(tmp_folder, f'shade.{self.ext}')
# raster calculator parameters
calc_params = {
'INPUT_A': rgb,
'BAND_A': 1,
'INPUT_B': b,
'BAND_B': 1,
'INPUT_C': c,
'BAND_C': 1,
'FORMULA': syntax,
'NO_DATA': 0,
'RTYPE': 0,
'OPTIONS': options,
'EXTRA': '--allBands=A --overwrite',
'OUTPUT': tmp_file
}
# run raster calculation
processing.run('gdal:rastercalculator', calc_params)
# translate parameters
translate_params = {
'INPUT': tmp_file,
'TARGET_CRS': crs,
'NO_DATA': 0,
'RTYPE': 0,
'OPTIONS': options,
'EXTRA': '-b 1 -b 2 -b 3 -r bilinear -a_nodata "0 0 0"',
'OUTPUT': output
}
# run translate
processing.run('gdal:translate', translate_params)
# remove tmp file
if os.path.isfile(tmp_file):
os.remove(tmp_file)
return output
def __toNextPage(self):
#check every input layer is exist
#----------------------------------------------------------------------
checker = 0
self.__nextButton.setEnabled(False)
# ckeckDem
if self.__demComboBox.currentText == "":
Exception("splitLine could not be null")
checker = 1
self.__nextButton.setEnabled(True)
# turn to next page
if checker == 0:
# get crossSection json file
crossSectionTemptPath = QgsProcessingUtils.tempFolder() + str("\\crossSection.json")
try:
# save crossSection json to file
# request = requests.get("https://h2-demo.pointing.tw/api/cross-sections/" + self.__countyComboBox.currentData())
# temptJson = json.loads(request.text)
# test
temptJson = None
temptPath = os.path.dirname(__file__)
with open(temptPath + "/testCrossSection.json") as temptText:
temptJson = json.load(temptText)
self.__editCounty = self.__countyComboBox.currentData()
# make the geometry only has start and endPoint in it
for feature in temptJson["features"]:
temptGeometryPoints = feature["geometry"]["coordinates"]
# outList, add a buffer to start-end point (each side for 3m)
outGeometryPoints =[]
startPoint = temptGeometryPoints[0]
endPoint = temptGeometryPoints[-1]
geometryLength = pow(pow(startPoint[0] - endPoint[0] ,2) + pow(startPoint[1] - endPoint[1] ,2),0.5)
startDirection = [(startPoint[0]-endPoint[0])*(3.0/geometryLength) , (startPoint[1]-endPoint[1])*(3.0/geometryLength)]
endDirection = [startDirection[0]*-1 , startDirection[1]*-1]
outGeometryPoints.append([startPoint[0]+startDirection[0] , startPoint[1]+startDirection[1]])
outGeometryPoints.append([endPoint[0]+endDirection[0] , endPoint[1]+endDirection[1]])
feature["geometry"]["coordinates"] = outGeometryPoints
# remove not necessary feild
try:
del feature["properties"]["originalId"]
except:
pass
try:
del feature["properties"]["node_py"]
except:
pass
try:
del feature["properties"]["node_px"]
except:
pass
try:
del feature["properties"]["node_nm"]
except:
pass
# write json to temptFile
writer = AtFileWriter(json.dumps(temptJson), crossSectionTemptPath).textWriter("")
# load tempt jsonFile as layer
self.__splitLineLayer = QgsVectorLayer(crossSectionTemptPath,"crossSection" , "ogr")
self.__splitLineLayer.setCrs(QgsCoordinateReferenceSystem(3826),True)
self.__splitLineLayer.loadNamedStyle(temptPath + '/style/crossSectionStyle.qml')
QgsProject.instance().addMapLayer(self.__splitLineLayer)
except:
traceback.print_exc()
# setting output paramter
self.__demLayer = self.__demComboBox.currentData()
# disconnect
self.__nextButton.disconnect()
self.__demComboBox.disconnect()
# close dlg and open another
self.__dlg.done(0)
self.__isClose = True
self.__dlg = PlotPage()
self.__dlg.show()
# create plotPageClass
PlotPageClass(self.__dlg , self)
def processAlgorithm(self, parameters, context, feedback):
''' Here is where the processing itself takes place. '''
#
if not is_dependencies_satisfied:
return {}
# Get get input raster and check its one-band
the_layer = self.parameterAsRasterLayer(parameters, self.THE_LAYER, context)
#
if not self._check_oneband(the_layer):
self._error = self._the_strings["ERR_ONEB"]
return {}
# Get .clr file and check it
clr = self.parameterAsFile(parameters, self.THE_CLR, context)
if not self._check_clr(clr):
self._error = self._the_strings["ERR_NOCLR"]
return {}
# Get raster min/max values
provider = the_layer.dataProvider()
ext1 = the_layer.extent()
stats = provider.bandStatistics(1, QgsRasterBandStats.All, ext1, 0)
minv = stats.minimumValue
maxv = stats.maximumValue
d = (maxv - minv) / 100.
# Scale percentages to raster values
with codecs.open(clr, 'r', 'utf-8') as fi:
buff = fi.readlines()
# 0.00000000000000000 200 215 133 255
ar = []
for e in buff[2:]:
br = e[:-1].split()
v = float(br[0]) * d + minv
ar.append([v, int(br[1]), int(br[2]), int(br[3]), int(br[4])])
if br[0][:3] == '100':
# end of colour ramp
break
# Style raster
fcn = qRS()
fcn.setColorRampType(qRS.Interpolated)
lst = []
for e in ar:
lst.append(qRS.ColorRampItem(e[0],QColor(int(e[1]), int(e[2]), int(e[3]),
int(e[4])),str(e[0])))
fcn.setColorRampItemList(lst)
try:
shader = QgsRasterShader()
shader.setRasterShaderFunction(fcn)
renderer = QgsSingleBandPseudoColorRenderer(the_layer.dataProvider(),
the_layer.type(), shader)
the_layer.setRenderer(renderer)
the_layer.triggerRepaint()
except:
pass
# Get output file name
output_file = self.parameterAsFileOutput(parameters, self.OUTPUT, context)
if output_file == '':
output_file = os.path.join(QgsProcessingUtils.tempFolder(), the_layer.name())
# Save QGIS colour ramp file
with codecs.open(output_file, 'w', 'utf-8') as fo:
fo.write('# bcclr2tbl Generated Color Map Export File\n')
fo.write('INTERPOLATION:INTERPOLATED\n')
# 614,46,124,228,255,614
for e in ar:
fo.write('%.3f,%d,%d,%d,%d,%.1f\n' % (e[0], int(e[1]), int(e[2]),
int(e[3]), int(e[4]), e[0]))
return {self.OUTPUT:output_file}
def grassDataFolder():
tempfolder = os.path.join(QgsProcessingUtils.tempFolder(), 'grassdata')
mkdir(tempfolder)
return tempfolder
def processAlgorithm(self, parameters, context, feedback):
# get input variables
raster_layer = self.parameterAsRasterLayer(parameters, self.INPUT,
context)
shade_by = self.parameterAsEnum(parameters, self.SHADE_BY, context)
options = self.parameterAsString(parameters, self.OPTIONS, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
z_pos_down = self.parameterAsBoolean(parameters, self.Z_POS_DOWN,
context)
feedback.pushConsoleInfo(
self.tr(f'Shading by {self.shaders[shade_by]}\n'))
# set new default values in config
feedback.pushConsoleInfo(
self.tr(f'Storing new default settings in config...'))
self.config.set(self.module, 'shader', shade_by)
# create empty temp file variables
rgb_file, hs_file, slope_file, slope_stretch_file, slope_inv_file = None, None, None, None, None
# create switches for shade_by
hillshade, slope, combo = False, False, False
# set settings by shade_by
if shade_by == 0:
hillshade = True
syntax = 'uint8(((A/255.)*(((B*0.5)+(255.*0.5))/255.))*255)'
elif shade_by == 1:
slope = True
syntax = 'uint8(((A/255.)*(((C*0.5)+(255.*0.5))/255.))*255)'
elif shade_by == 2:
combo = True
syntax = 'uint8(((A/255.)*(((B*0.3)+(255.*0.7))/255.)*(((C*0.3)+(255.*0.7))/255.))*255)'
# create temporary folder
tmp_folder = QgsProcessingUtils.tempFolder()
# render selected layer with defined symbology as rgb raster
feedback.pushConsoleInfo(self.tr(f'Rendering layer to RGB...'))
rgb_file = os.path.join(tmp_folder, f'rgb.{self.ext}')
error, result = self.create_rgb(raster_layer, rgb_file)
if error:
feedback.reportError(self.tr(result), fatalError=True)
return {}
# 20% done
feedback.setProgress(20)
# get crs from layer
crs_raster = raster_layer.crs()
# get scale for vertical units
scale = self.get_scale(crs_raster)
if hillshade or combo:
# create hillshade
feedback.pushConsoleInfo(self.tr(f'Creating hillshade grid...'))
# if raster is z positive down flip illumination direction
if z_pos_down:
self.azimuth = (self.azimuth - 180.) % 360.
hs_file = os.path.join(tmp_folder, f'hs.{self.ext}')
self.create_hs(raster_layer, self.hs_z_factor, scale, self.azimuth,
self.altitude, hs_file, options)
# 40% done
feedback.setProgress(40)
if slope or combo:
# create slope
feedback.pushConsoleInfo(self.tr(f'Creating slope grid...'))
slope_file = os.path.join(tmp_folder, f'slope.{self.ext}')
self.create_slope(raster_layer, self.slope_z_factor, scale,
slope_file, options)
# 60% done
feedback.setProgress(60)
# stretch slope to min max
feedback.pushConsoleInfo(self.tr(f'Stretching slope grid...'))
slope_stretch_file = os.path.join(tmp_folder,
f'slope_stretch.{self.ext}')
self.stretch_min_max(slope_file, slope_stretch_file, options)
# 70% done
feedback.setProgress(70)
# invert slope (White to Black instead of Black to White)
feedback.pushConsoleInfo(
self.tr(f'Inverting stretched slope grid...'))
slope_inv_file = os.path.join(tmp_folder, f'slope_inv.{self.ext}')
self.invert(slope_stretch_file, slope_inv_file, options)
# 80% done
feedback.setProgress(80)
# shading computation
feedback.pushConsoleInfo(self.tr(f'Calculating output raster...\n'))
self.shade(rgb_file, hs_file, slope_inv_file, syntax, output,
crs_raster, options)
# 99% done
feedback.setProgress(99)
# delete temp files
for file in [
rgb_file, hs_file, slope_file, slope_stretch_file,
slope_inv_file
]:
if os.path.isfile(str(file)):
os.remove(file)
# 100% done
feedback.setProgress(100)
feedback.pushInfo(
self.
tr(f'{utils.return_success()}! Shaded bathymetry file is created!\n'
))
result = {self.OUTPUT: output}
return result
def processAlgorithm(self, parameters, context, feedback):
source = self.parameterAsVectorLayer(parameters, self.INPUT, context)
if source is None:
raise QgsProcessingException(self.invalidSourceError(parameters, self.INPUT))
max_distance = self.parameterAsDouble(parameters, self.MAX_DISTANCE, context)
raster_type = self.RASTER_TYPES[self.parameterAsEnum(parameters, self.RASTER_TYPE, context)]
extent = self.parameterAsExtent(parameters, self.EXTENT, context, source.sourceCrs())
if extent is None or extent.width() == 0 or extent.height() == 0:
extent = source.sourceExtent()
cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context)
if cell_size <= 0:
cell_size = int(min(extent.width(), extent.height()) / 250.0)
output_raster = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
# open ogr vector layer from qgs map layer
ogrLayer, layerName = self.getOgrCompatibleSource(self.INPUT, parameters, context, feedback, True)
if ogrLayer is None:
raise QgsProcessingException('Cannot connect OGR driver!')
ogr_vector_datasource = ogr.Open(ogrLayer)
ogr_vector_layer = ogr_vector_datasource.GetLayer(layerName)
feedback.pushInfo('Raster Type = {0}'.format(raster_type))
feedback.pushInfo('Cell Size = {0}'.format(cell_size))
feedback.pushInfo('Extent = {0}'.format(extent))
nodata = -9999
srs = osr.SpatialReference()
srs.ImportFromWkt(source.crs().toWkt())
transform = [extent.xMinimum(), cell_size, 0.0, extent.yMaximum(), 0.0, -cell_size]
raster_width = int(math.ceil(abs(extent.xMaximum() - extent.xMinimum()) / cell_size))
raster_height = int(math.ceil(abs(extent.yMaximum() - extent.yMinimum()) / cell_size))
# rasterize temporary raterdataset from vector layer, extent, cellsize
temporary_path = os.path.join(QgsProcessingUtils.tempFolder(),
'euc_distance_{}.tif'.format(uuid.uuid4().hex))
feedback.pushInfo('Temporary path = {0}'.format(temporary_path))
driver = gdal.GetDriverByName('GTiff')
rasterizedDS = driver.Create(temporary_path, raster_width, raster_height, 1, gdal.GDT_Byte)
rasterizedDS.GetRasterBand(1).SetNoDataValue(nodata)
rasterizedDS.SetGeoTransform(transform)
rasterizedDS.SetProjection(srs.ExportToWkt())
rasterizedDS.GetRasterBand(1).Fill(nodata)
gdal.RasterizeLayer(rasterizedDS, [1], ogr_vector_layer, burn_values=[1])
# compute proximity from rasterized dataset
options = ['DISTUNITS=GEO']
if max_distance > 0:
options.append('MAXDIST=' + str(max_distance))
proximityDs = driver.Create(output_raster, raster_width, raster_height, 1, gdal.GetDataTypeByName(raster_type))
proximityDs.GetRasterBand(1).SetNoDataValue(nodata)
proximityDs.SetGeoTransform(transform)
proximityDs.SetProjection(srs.ExportToWkt())
proximityDs.GetRasterBand(1).Fill(nodata)
gdal.ComputeProximity(rasterizedDS.GetRasterBand(1), proximityDs.GetRasterBand(1), options, callback = None)
# cleanup
rasterizedDS = None
proximityDs = None
ogr_vector_datasource = None
return {self.OUTPUT: output_raster}
def initialize():
icon = QgsApplication.getThemeIcon("/processingAlgorithm.svg")
ProcessingConfig.settingIcons['General'] = icon
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.KEEP_DIALOG_OPEN,
ProcessingConfig.tr(
'Keep dialog open after running an algorithm'), True))
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.PREFER_FILENAME_AS_LAYER_NAME,
ProcessingConfig.tr('Prefer output filename for layer names'),
True))
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.SHOW_PROVIDERS_TOOLTIP,
ProcessingConfig.tr(
'Show tooltip when there are disabled providers'), True))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.OUTPUT_FOLDER,
ProcessingConfig.tr('Output folder'),
defaultOutputFolder(),
valuetype=Setting.FOLDER))
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'), ProcessingConfig.SHOW_CRS_DEF,
ProcessingConfig.tr(
'Show layer CRS definition in selection boxes'), True))
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.WARN_UNMATCHING_CRS,
ProcessingConfig.tr(
"Warn before executing if parameter CRS's do not match"),
True))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.SHOW_ALGORITHMS_KNOWN_ISSUES,
ProcessingConfig.tr("Show algorithms with known issues"),
False))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.RASTER_STYLE,
ProcessingConfig.tr('Style for raster layers'),
'',
valuetype=Setting.FILE))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.VECTOR_POINT_STYLE,
ProcessingConfig.tr('Style for point layers'),
'',
valuetype=Setting.FILE))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.VECTOR_LINE_STYLE,
ProcessingConfig.tr('Style for line layers'),
'',
valuetype=Setting.FILE))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.VECTOR_POLYGON_STYLE,
ProcessingConfig.tr('Style for polygon layers'),
'',
valuetype=Setting.FILE))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.PRE_EXECUTION_SCRIPT,
ProcessingConfig.tr('Pre-execution script'),
'',
valuetype=Setting.FILE))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.POST_EXECUTION_SCRIPT,
ProcessingConfig.tr('Post-execution script'),
'',
valuetype=Setting.FILE))
invalidFeaturesOptions = [
ProcessingConfig.tr('Do not filter (better performance)'),
ProcessingConfig.tr(
'Skip (ignore) features with invalid geometries'),
ProcessingConfig.tr(
'Stop algorithm execution when a geometry is invalid')
]
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.FILTER_INVALID_GEOMETRIES,
ProcessingConfig.tr('Invalid features filtering'),
invalidFeaturesOptions[2],
valuetype=Setting.SELECTION,
options=invalidFeaturesOptions))
threads = QgsApplication.maxThreads(
) # if user specified limit for rendering, lets keep that as default here, otherwise max
threads = cpu_count(
) if threads == -1 else threads # if unset, maxThreads() returns -1
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.MAX_THREADS,
ProcessingConfig.tr('Max Threads'),
threads,
valuetype=Setting.INT))
extensions = QgsVectorFileWriter.supportedFormatExtensions()
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.DEFAULT_OUTPUT_VECTOR_LAYER_EXT,
ProcessingConfig.tr('Default output vector layer extension'),
QgsVectorFileWriter.supportedFormatExtensions()[0],
valuetype=Setting.SELECTION,
options=extensions))
extensions = QgsRasterFileWriter.supportedFormatExtensions()
ProcessingConfig.addSetting(
Setting(
ProcessingConfig.tr('General'),
ProcessingConfig.DEFAULT_OUTPUT_RASTER_LAYER_EXT,
ProcessingConfig.tr('Default output raster layer extension'),
'tif',
valuetype=Setting.SELECTION,
options=extensions))
ProcessingConfig.addSetting(
Setting(ProcessingConfig.tr('General'),
ProcessingConfig.TEMP_PATH,
ProcessingConfig.tr('Temporary output folder path'),
QgsProcessingUtils.tempFolder(),
valuetype=Setting.FOLDER))
