def processAlgorithm(self, feedback):
interpolationData = self.getParameterValue(self.INTERPOLATION_DATA)
method = self.getParameterValue(self.METHOD)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
triangulation = self.getOutputValue(self.TRIANULATION_FILE)
if interpolationData is None:
raise GeoAlgorithmExecutionException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise GeoAlgorithmExecutionException(
self.tr('Cellsize should be greater than 0.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
data.vectorLayer = dataobjects.getObjectFromUri(v[0])
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
interpolator = QgsTINInterpolator(layerData, interpolationMethod)
interpolator.setExportTriangulationToFile(True)
interpolator.setTriangulationFilePath(triangulation)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
if not crs.isValid():
crs = layer.sourceCrs()
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
if method == 0:
interpolationMethod = QgsTinInterpolator.Linear
else:
interpolationMethod = QgsTinInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTinInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTinInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, feedback):
interpolationData = self.getParameterValue(self.INTERPOLATION_DATA)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
if interpolationData is None:
raise GeoAlgorithmExecutionException(
self.tr('You need to specify at least one input layer.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = dataobjects.getLayerFromString(v[0])
data.vectorLayer = layer
layers.append(layer)
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
layerType = self.getParameterValue(self.LAYER_TYPE)
method = self.getParameterValue(self.METHOD)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
triangulation = self.getOutputValue(self.TRIANULATION_FILE)
if not QgsWkbTypes.hasZ(layer.wkbType()):
raise GeoAlgorithmExecutionException(
self.tr('Geometries in input layer does not have Z coordinates.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = True
layerData.interpolationAttribute = -1
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
interpolator = QgsTINInterpolator([layerData], interpolationMethod)
interpolator.setExportTriangulationToFile(True)
interpolator.setTriangulationFilePath(triangulation)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.ATTRIBUTE)
layerType = self.getParameterValue(self.LAYER_TYPE)
method = self.getParameterValue(self.METHOD)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
triangulation = self.getOutputValue(self.TRIANULATION_FILE)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = False
layerData.interpolationAttribute = layer.dataProvider().fieldNameIndex(fieldName)
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
interpolator = QgsTINInterpolator([layerData], interpolationMethod)
interpolator.setExportTriangulationToFile(True)
interpolator.setTriangulationFilePath(triangulation)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
coefficient = self.parameterAsDouble(parameters, self.DISTANCE_COEFFICIENT, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
if columns == 0:
columns = max(round(bbox.width() / pixel_size) + 1, 1)
if rows == 0:
rows = max(round(bbox.height() / pixel_size) + 1, 1)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
for row in interpolationData.split('::|::'):
v = row.split('::~::')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows)
writer.writeFile(feedback)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
coefficient = self.parameterAsDouble(parameters, self.DISTANCE_COEFFICIENT, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = self.getParameterValue(self.INTERPOLATION_DATA)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
if interpolationData is None:
raise GeoAlgorithmExecutionException(
self.tr('You need to specify at least one input layer.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator, output, bbox, columns, rows,
cellsizeX, cellsizeY)
writer.writeFile()
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
coefficient = self.parameterAsDouble(parameters, self.DISTANCE_COEFFICIENT, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
layerType = self.getParameterValue(self.LAYER_TYPE)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
if not QgsWkbTypes.hasZ(layer.wkbType()):
raise GeoAlgorithmExecutionException(
self.tr('Geometries in input layer does not have Z coordinates.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = True
layerData.interpolationAttribute = -1
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
interpolator = QgsIDWInterpolator([layerData])
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
layerType = self.getParameterValue(self.LAYER_TYPE)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
if not QgsWkbTypes.hasZ(layer.wkbType()):
raise GeoAlgorithmExecutionException(
self.tr('Geometries in input layer does not have Z coordinates.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = True
layerData.interpolationAttribute = -1
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
interpolator = QgsIDWInterpolator([layerData])
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def calcIsoInterpolation(self, iso_point_layer, resolution, interpolation_raster_path):
layer_data = QgsInterpolator.LayerData()
layer_data.source = iso_point_layer #in QGIS2: vectorLayer
layer_data.valueSource = QgsInterpolator.ValueAttribute
layer_data.interpolationAttribute = 1 #take second field to get costs
layer_data.sourceType = QgsInterpolator.SourcePoints
tin_interpolator = QgsTinInterpolator([layer_data], QgsTinInterpolator.Linear)
rect = iso_point_layer.extent()
ncol = int((rect.xMaximum() - rect.xMinimum()) / resolution)
nrows = int((rect.yMaximum() - rect.yMinimum()) / resolution)
writer = QgsGridFileWriter(tin_interpolator, self.interpolation_raster_path, rect, ncol, nrows, resolution, resolution)
writer.writeFile(self.feedback) # Creating .asc raste
return QgsRasterLayer(self.interpolation_raster_path, "temp_qneat3_interpolation_raster", True)
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.ATTRIBUTE)
layerType = self.getParameterValue(self.LAYER_TYPE)
method = self.getParameterValue(self.METHOD)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
triangulation = self.getOutputValue(self.TRIANULATION_FILE)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = False
layerData.interpolationAttribute = layer.dataProvider().fieldNameIndex(
fieldName)
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
interpolator = QgsTINInterpolator([layerData], interpolationMethod)
interpolator.setExportTriangulationToFile(True)
interpolator.setTriangulationFilePath(triangulation)
writer = QgsGridFileWriter(interpolator, output, bbox, columns, rows,
cellsizeX, cellsizeY)
writer.writeFile()
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
coefficient = self.parameterAsDouble(parameters, self.DISTANCE_COEFFICIENT, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split('::~::')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
interpolator = QgsIDWInterpolator(layerData)
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows)
writer.writeFile(feedback)
return {self.OUTPUT: output}
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.ATTRIBUTE)
layerType = self.getParameterValue(self.LAYER_TYPE)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = False
layerData.interpolationAttribute = layer.dataProvider().fieldNameIndex(fieldName)
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
interpolator = QgsIDWInterpolator([layerData])
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def processAlgorithm(self, progress):
layer = dataobjects.getObjectFromUri(
self.getParameterValue(self.INPUT_LAYER))
fieldName = self.getParameterValue(self.ATTRIBUTE)
layerType = self.getParameterValue(self.LAYER_TYPE)
coefficient = self.getParameterValue(self.DISTANCE_COEFFICIENT)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = QgsInterpolator.LayerData()
layerData.vectorLayer = layer
layerData.zCoordInterpolation = False
layerData.interpolationAttribute = layer.dataProvider().fieldNameIndex(fieldName)
if layerType == 0:
layerData.mInputType = QgsInterpolator.POINTS
elif layerType == 1:
layerData.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
layerData.mInputType = QgsInterpolator.BREAK_LINES
interpolator = QgsIDWInterpolator([layerData])
interpolator.setDistanceCoefficient(coefficient)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
def calcIsoTinInterpolation(self, iso_point_layer, resolution, interpolation_raster_path):
if self.AnalysisCrs.isGeographic():
raise QgsProcessingException('The TIN-Interpolation algorithm in QGIS is designed to work with projected coordinate systems.Please use a projected coordinate system (eg. UTM zones) instead of geographic coordinate systems (eg. WGS84)!')
layer_data = QgsInterpolator.LayerData()
QgsInterpolator.LayerData
layer_data.source = iso_point_layer #in QGIS2: vectorLayer
layer_data.valueSource = QgsInterpolator.ValueAttribute
layer_data.interpolationAttribute = 1 #take second field to get costs
layer_data.sourceType = QgsInterpolator.SourcePoints
tin_interpolator = QgsTinInterpolator([layer_data], QgsTinInterpolator.Linear)
rect = iso_point_layer.extent()
ncol = int((rect.xMaximum() - rect.xMinimum()) / resolution)
nrows = int((rect.yMaximum() - rect.yMinimum()) / resolution)
writer = QgsGridFileWriter(tin_interpolator, interpolation_raster_path, rect, ncol, nrows)
writer.writeFile(self.feedback) # Creating .asc raste
return QgsRasterLayer(interpolation_raster_path, "temp_qneat3_interpolation_raster")
def run(self):
"""Run method that performs all the real work"""
# Add items to Management Practices & Soil Type
k_lists = []
m_lists = []
k_lists = self.k_list()
m_lists = self.m_list()
self.dlg.comboBox.addItems(k_lists)
self.dlg.comboBox_2.addItems(m_lists)
# show dialog box
self.dlg.show()
# Run the dialog event loop
result = self.dlg.exec_()
# See if OK was pressed
if result:
# Save paths of input directories
selectedBoundary = self.dlg.lineEdit.text()
selectedDEM = self.dlg.lineEdit_2.text()
selectedRLayer = self.dlg.lineEdit_3.text()
selectedOutput = self.dlg.lineEdit_4.text()
for letter in selectedOutput:
if letter == "\\":
selectedOutput = selectedOutput.replace(letter, "/")
print(selectedBoundary)
print(selectedDEM)
print(selectedRLayer)
print(selectedOutput)
# Save indices for K and M
selectedKLayer = self.dlg.comboBox.currentIndex()
selectedMLayer = self.dlg.comboBox_2.currentIndex()
boundary = QgsVectorLayer(selectedBoundary, 'Boundary', 'ogr')
QgsMapLayerRegistry.instance().addMapLayer(boundary)
entries = []
# Retrieve K and M values
k_value = self.k_index(selectedKLayer)
m_value = self.m_index(selectedMLayer)
km_value = k_value * m_value
km_value = str(km_value)
# Process R index
## CSV to Layer
uri = 'file:///' + selectedRLayer + '?delimiter=%s&xField=%s&yField=%s&crs=%s' % (
",", "x", "y", "EPSG:4326")
rainfall_unedited = QgsVectorLayer(uri, "rainfall",
"delimitedtext")
QgsMapLayerRegistry.instance().addMapLayer(rainfall_unedited)
spatRef = QgsCoordinateReferenceSystem(
4326, QgsCoordinateReferenceSystem.EpsgCrsId)
## CSV points to editable shapefile
rainfall_edited = QgsVectorFileWriter(
selectedOutput + '/rainfall_edited.shp', None,
rainfall_unedited.pendingFields(), QGis.WKBPoint, spatRef)
pt = QgsPoint()
outFeature = QgsFeature()
for feat in rainfall_unedited.getFeatures():
attrs = feat.attributes()
pt.setX(feat['x'])
pt.setY(feat['y'])
outFeature.setAttributes(attrs)
outFeature.setGeometry(QgsGeometry.fromPoint(pt))
rainfall_edited.addFeature(outFeature)
del rainfall_edited
rainfall_edited2 = QgsVectorLayer(
selectedOutput + '/rainfall_edited.shp', 'rainfall_edited',
'ogr')
## Add and calculate average field
rainfall_edited2.startEditing()
avgField = QgsField('average', QVariant.Double)
rainfall_edited2.dataProvider().addAttributes([avgField])
rainfall_edited2.updateFields()
idx = rainfall_edited2.fieldNameIndex('average')
time_count = idx - 2
str_output = ''
for i in range(1, time_count + 1):
if i == 1:
a = str(i)
str_output += 'time' + a
else:
a = str(i)
str_output += '+ time' + a
e = QgsExpression(str_output)
e.prepare(rainfall_edited2.pendingFields())
for f in rainfall_edited2.getFeatures():
f[idx] = e.evaluate(f) / time_count
rainfall_edited2.updateFeature(f)
rainfall_edited2.commitChanges()
rainfall_edited3 = QgsVectorLayer(
selectedOutput + '/rainfall_edited.shp', 'rainfall_edited',
'ogr')
QgsMapLayerRegistry.instance().addMapLayer(rainfall_edited3)
## Interpolating average using IDW
### Parameters for interpolation
idx = rainfall_edited3.fieldNameIndex('average')
layer_data = qgis.analysis.QgsInterpolator.LayerData()
layer_data.vectorLayer = rainfall_edited3
layer_data.zCoordInterpolation = False
layer_data.interpolationAttribute = idx
layer_data.mInputType = 1
idw_interpolator = QgsIDWInterpolator([layer_data])
### Output parameter
export_path = selectedOutput + "/interpolated_r_{}.asc".format(idx)
rect = boundary.extent()
res = 0.0001
ncol = (rect.xMaximum() - rect.xMinimum()) / res
nrows = (rect.yMaximum() - rect.yMinimum()) / res
interpolated_r = QgsGridFileWriter(idw_interpolator,
export_path, rect, int(ncol),
int(nrows), res, res)
interpolated_r.writeFile(True)
interpolated_r2 = QgsRasterLayer(export_path, "interpolated_r")
## Clip output to boundary
clippedR = processing.runandload(
'gdalogr:cliprasterbymasklayer',
interpolated_r2, #INPUT <ParameterRaster>
boundary, #MASK <ParameterVector>
"-9999", #NO_DATA <ParameterString>
False, #ALPHA_BAND <ParameterBoolean>
False, #CROP_TO_CUTLINE <ParameterBoolean>
False, #KEEP_RESOLUTION <ParameterBoolean>
5, #RTYPE <ParameterSelection>
4, #COMPRESS <ParameterSelection>
1, #JPEGCOMPRESSION <ParameterNumber>
6, #ZLEVEL <ParameterNumber>
1, #PREDICTOR <ParameterNumber>
False, #TILED <ParameterBoolean>
2, #BIGTIFF <ParameterSelection>
False, #TFW <ParameterBoolean>
"", #EXTRA <ParameterString>
selectedOutput +
'/clip_interpolated_r.tif') #OUTPUT <OutputRaster>
r_layer = QgsRasterLayer(
selectedOutput + '/clip_interpolated_r.tif', "R-index")
boh4 = QgsRasterCalculatorEntry()
boh4.ref = 'boh4@1'
boh4.raster = r_layer
boh4.bandNumber = 1
entries.append(boh4)
# Process S index
## Load DEM
bohLayer1 = QgsRasterLayer(selectedDEM, "DEM")
boh2 = QgsRasterCalculatorEntry()
boh2.ref = 'boh2@1'
boh2.raster = bohLayer1
boh2.bandNumber = 1
entries.append(boh2)
## Clip output to boundary
clippedOutput2 = processing.runandload(
'gdalogr:cliprasterbymasklayer',
bohLayer1, # INPUT <ParameterRaster>
boundary, # MASK <ParameterVector>
"-9999", # NO_DATA <ParameterString>
False, # ALPHA_BAND <ParameterBoolean>
False, # CROP_TO_CUTLINE <ParameterBoolean>
False, # KEEP_RESOLUTION <ParameterBoolean>
5, # RTYPE <ParameterSelection>
4, # COMPRESS <ParameterSelection>
1, # JPEGCOMPRESSION <ParameterNumber>
6, # ZLEVEL <ParameterNumber>
1, # PREDICTOR <ParameterNumber>
False, # TILED <ParameterBoolean>
2, # BIGTIFF <ParameterSelection>
False, # TFW <ParameterBoolean>
"", # EXTRA <ParameterString>
selectedOutput + '/clip_dem.tif') # OUTPUT <OutputRaster>
bohLayer5 = QgsRasterLayer(selectedOutput + '/clip_dem.tif',
"DEM-clipped")
boh5 = QgsRasterCalculatorEntry()
boh5.ref = 'boh5@1'
boh5.raster = bohLayer5
boh5.bandNumber = 1
entries.append(boh5)
## GDAL algorithm for slope
processing.runalg('gdalogr:slope', bohLayer5, 1, False, True, True,
111120, selectedOutput + '/slope(percent).tif')
bohLayer6 = QgsRasterLayer(selectedOutput + '/slope(percent).tif',
"slope(percent)")
QgsMapLayerRegistry.instance().addMapLayer(bohLayer6)
boh6 = QgsRasterCalculatorEntry()
boh6.ref = 'boh6@1'
boh6.raster = bohLayer6
boh6.bandNumber = 1
entries.append(boh6)
# Process calculation with input extent and resolution
calc = QgsRasterCalculator('(boh4@1 * boh6@1) *' + km_value,
selectedOutput + '/soil_risk.tif',
'GTiff', bohLayer6.extent(),
bohLayer6.width(), bohLayer6.height(),
entries)
calc.processCalculation()
bohLayer4 = QgsRasterLayer(selectedOutput + '/soil_risk.tif',
"Soil_Risk")
QgsMapLayerRegistry.instance().addMapLayer(bohLayer4)
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise QgsProcessingException(
self.tr('Cellsize should be greater than 0.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
if not crs.isValid():
crs = layer.crs()
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTINInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTINInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(
parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
pixel_size = self.parameterAsDouble(parameters, self.PIXEL_SIZE,
context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
if columns == 0:
columns = max(round(bbox.width() / pixel_size) + 1, 1)
if rows == 0:
rows = max(round(bbox.height() / pixel_size) + 1, 1)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split('::~::')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.variantToSource(v[0], context)
data.source = layer
layers.append(layer)
if not crs.isValid():
crs = layer.sourceCrs()
data.valueSource = int(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.sourceType = QgsInterpolator.SourcePoints
elif v[3] == '1':
data.sourceType = QgsInterpolator.SourceStructureLines
else:
data.sourceType = QgsInterpolator.SourceBreakLines
layerData.append(data)
if method == 0:
interpolationMethod = QgsTinInterpolator.Linear
else:
interpolationMethod = QgsTinInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(
parameters, self.TRIANGULATION, context,
QgsTinInterpolator.triangulationFields(), QgsWkbTypes.LineString,
crs)
interpolator = QgsTinInterpolator(layerData, interpolationMethod,
feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator, output, bbox, columns, rows)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, parameters, context, feedback):
interpolationData = ParameterInterpolationData.parseValue(parameters[self.INTERPOLATION_DATA])
method = self.parameterAsEnum(parameters, self.METHOD, context)
columns = self.parameterAsInt(parameters, self.COLUMNS, context)
rows = self.parameterAsInt(parameters, self.ROWS, context)
cellsizeX = self.parameterAsDouble(parameters, self.CELLSIZE_X, context)
cellsizeY = self.parameterAsDouble(parameters, self.CELLSIZE_Y, context)
bbox = self.parameterAsExtent(parameters, self.EXTENT, context)
output = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
if interpolationData is None:
raise QgsProcessingException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise QgsProcessingException(
self.tr('Cellsize should be greater than 0.'))
layerData = []
layers = []
crs = QgsCoordinateReferenceSystem()
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
if not crs.isValid():
crs = layer.crs()
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
(triangulation_sink, triangulation_dest_id) = self.parameterAsSink(parameters, self.TRIANGULATION, context,
QgsTINInterpolator.triangulationFields(), QgsWkbTypes.LineString, crs)
interpolator = QgsTINInterpolator(layerData, interpolationMethod, feedback)
if triangulation_sink is not None:
interpolator.setTriangulationSink(triangulation_sink)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile(feedback)
return {self.OUTPUT: output, self.TRIANGULATION: triangulation_dest_id}
def processAlgorithm(self, context, feedback):
interpolationData = self.getParameterValue(self.INTERPOLATION_DATA)
method = self.getParameterValue(self.METHOD)
columns = self.getParameterValue(self.COLUMNS)
rows = self.getParameterValue(self.ROWS)
cellsizeX = self.getParameterValue(self.CELLSIZE_X)
cellsizeY = self.getParameterValue(self.CELLSIZE_Y)
extent = self.getParameterValue(self.EXTENT).split(',')
output = self.getOutputValue(self.OUTPUT_LAYER)
triangulation = self.getOutputValue(self.TRIANULATION_FILE)
if interpolationData is None:
raise GeoAlgorithmExecutionException(
self.tr('You need to specify at least one input layer.'))
if cellsizeX == 0.0 or cellsizeY == 0.0:
raise GeoAlgorithmExecutionException(
self.tr('Cellsize should be greater than 0.'))
xMin = float(extent[0])
xMax = float(extent[1])
yMin = float(extent[2])
yMax = float(extent[3])
bbox = QgsRectangle(xMin, yMin, xMax, yMax)
layerData = []
layers = []
for row in interpolationData.split(';'):
v = row.split(',')
data = QgsInterpolator.LayerData()
# need to keep a reference until interpolation is complete
layer = QgsProcessingUtils.mapLayerFromString(v[0], context)
data.vectorLayer = layer
layers.append(layer)
data.zCoordInterpolation = bool(v[1])
data.interpolationAttribute = int(v[2])
if v[3] == '0':
data.mInputType = QgsInterpolator.POINTS
elif v[3] == '1':
data.mInputType = QgsInterpolator.STRUCTURE_LINES
else:
data.mInputType = QgsInterpolator.BREAK_LINES
layerData.append(data)
if method == 0:
interpolationMethod = QgsTINInterpolator.Linear
else:
interpolationMethod = QgsTINInterpolator.CloughTocher
interpolator = QgsTINInterpolator(layerData, interpolationMethod)
interpolator.setExportTriangulationToFile(True)
interpolator.setTriangulationFilePath(triangulation)
writer = QgsGridFileWriter(interpolator,
output,
bbox,
columns,
rows,
cellsizeX,
cellsizeY)
writer.writeFile()
