def processAlgorithm(self, parameters, context, feedback):
source_lyr = self.parameterAsVectorLayer(parameters, self.INPUT, context)
line_lyr = self.parameterAsVectorLayer(parameters, self.LINE, context)
cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context)
search_radius = self.parameterAsDouble(parameters,
self.SEARCH_RADIUS,
context)
area_unit = self.area_unit[self.parameterAsEnum(parameters,
self.AREA_UNIT,
context)][0]
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN, context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
source_gdf = LUCISOpenQGISUtils.vector_to_gdf(source_lyr)
line_gdf = LUCISOpenQGISUtils.vector_to_gdf(line_lyr)
if search_radius:
search_radius = (
f'{search_radius} '
f'{base.GeoDataFrameManager(source_gdf).geom_unit_name}'
)
source_gdf[output_clm] = density.of_line(source_gdf, line_gdf, cell_size,
search_radius, area_unit)
source_gdf.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
point_lyr = self.parameterAsVectorLayer(parameters, self.POINT,
context)
pop_clm = parameters[self.POP_COLUMN]
search_radius = self.parameterAsDouble(parameters, self.SEARCH_RADIUS,
context)
area_unit = self.area_unit[self.parameterAsEnum(
parameters, self.AREA_UNIT, context)][0]
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN,
context)
output_shp = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
point_gdf = LUCISOpenQGISUtils.vector_to_gdf(point_lyr)
if search_radius:
search_radius = (
f'{search_radius} '
f'{base.GeoDataFrameManager(input_gdf).geom_unit_name}')
input_gdf[output_clm] = density.of_point(input_gdf, point_gdf, pop_clm,
search_radius, area_unit)
input_gdf.to_file(output_shp)
return {self.OUTPUT: output_shp}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
line_lyr = self.parameterAsVectorLayer(parameters, self.LINE, context)
cell_size = self.parameterAsDouble(parameters, self.CELL_SIZE, context)
method = self.method[self.parameterAsEnum(parameters, self.METHOD,
context)][0]
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN,
context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
line_gdf = LUCISOpenQGISUtils.vector_to_gdf(line_lyr)
data_type = int if data_type == 0 else float
input_gdf[output_clm] = distance.to_line(input_gdf, line_gdf,
cell_size,
method).astype(data_type)
input_gdf.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT, context)
interpolate_lyr = self.parameterAsVectorLayer(parameters,
self.INTERPOLATE,
context)
interpolate_clm = self.parameterAsString(parameters,
self.INTERPOLATE_FIELD,
context)
power = self.parameterAsDouble(parameters, self.POWER, context)
n_neighbor = self.parameterAsInt(parameters, self.NUMBER_NEIGHBOR,
context)
search_radius = self.parameterAsDouble(parameters, self.SEARCH_RADIUS,
context)
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
output_clm = self.parameterAsString(parameters, self.OUTPUT_FIELD, context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
feedback.pushInfo(str(search_radius))
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
interpolate_gdf = LUCISOpenQGISUtils.vector_to_gdf(interpolate_lyr)
data_type = int if data_type == 0 else float
input_gdf[output_clm] = interpolate.idw(input_gdf, interpolate_gdf,
interpolate_clm, power,
n_neighbor, search_radius,
dtype=data_type)
input_gdf.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(
parameters, self.INPUT, context
)
raster_lyr = self.parameterAsRasterLayer(
parameters, self.RASTER, context
)
value = self.parameterAsInt(parameters, self.VALUE, context)
nodata = parameters[self.NODATA]
method = self.method[self.parameterAsEnum(
parameters, self.METHOD, context)
][0]
data_type = self.parameterAsEnum(
parameters, self.DATA_TYPE, context
)
output_clm = self.parameterAsString(
parameters, self.OUTPUT_COLUMN, context
)
output_file = self.parameterAsOutputLayer(
parameters, self.OUTPUT, context
)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
raster_path = raster_lyr.dataProvider().dataSourceUri()
data_type = int if data_type == 0 else float
input_gdf[output_clm] = distance.to_cell(
input_gdf, raster_path, value, nodata, method, data_type
)
output = input_gdf.to_file(output_file)
return {self.OUTPUT: output}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
erase_lyr = self.parameterAsVectorLayer(parameters, self.ERASE,
context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
erase_gdf = LUCISOpenQGISUtils.vector_to_gdf(erase_lyr)
output = geotools.erase(input_gdf, erase_gdf)
output.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
target = self.parameterAsVectorLayer(parameters, self.TARGET, context)
join = self.parameterAsVectorLayer(parameters, self.JOIN, context)
op = self.op[self.parameterAsEnum(parameters, self.OP, context)][0]
columns_agg = self.parameterAsString(parameters, self.COLUMNS_AGG,
context)
how = self.how[self.parameterAsEnum(parameters, self.HOW, context)][0]
keep_all = self.parameterAsBoolean(parameters, self.KEEP_ALL, context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
process_util = LUCISOpenQGISUtils()
aggs = (tuple(item.strip().split()) for item in columns_agg.split(";"))
for column, statistic in aggs:
process_util.to_agg_dict(column, statistic)
target_gdf = LUCISOpenQGISUtils.vector_to_gdf(target)
join_gdf = LUCISOpenQGISUtils.vector_to_gdf(join)
output = geotools.spatial_join(target_gdf, join_gdf, op,
process_util.agg_dict, how, keep_all)
output.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
select_lyr = self.parameterAsVectorLayer(parameters, self.SELECT,
context)
op = self.op_option[self.parameterAsEnum(parameters, self.OP,
context)][0].lower()
within_dist = self.parameterAsDouble(parameters, self.DIST, context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
select_gdf = LUCISOpenQGISUtils.vector_to_gdf(select_lyr)
output = geotools.select_by_location(input_gdf, select_gdf, op,
within_dist)
if not output.empty:
output.to_file(output_file)
return {self.OUTPUT: output_file}
else:
feedback.pushInfo('No features in input layer met the specified '
'spatial relationship. No output generated.')
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
point_lyr = self.parameterAsVectorLayer(parameters, self.POINT,
context)
method = self.method[self.parameterAsEnum(parameters, self.METHOD,
context)][0]
data_type = self.parameterAsEnum(parameters, self.DATA_TYPE, context)
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN,
context)
output_shp = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
point_gdf = LUCISOpenQGISUtils.vector_to_gdf(point_lyr)
data_type = int if data_type == 0 else float
input_gdf[output_clm] = distance.to_point(input_gdf, point_gdf, method,
data_type)
input_gdf.to_file(output_shp)
return {self.OUTPUT: output_shp}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT, context)
input_clm = self.parameterAsString(parameters, self.INPUT_FIELD, context)
old_val = self.parameterAsString(parameters, self.OLD_VALUE, context)
new_val = self.parameterAsString(parameters, self.NEW_VALUE, context)
nodata = parameters[self.NODATA]
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN, context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT, context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import (LUCISOpenQGISUtils,
StringParameterNumberList,
StringParameterIntervalList,
StringParameterCategoryList)
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
try:
re_key = StringParameterIntervalList(input_clm,
old_val).as_tuple_list
except ValueError:
try:
re_key = StringParameterNumberList(input_clm,
old_val).as_number_list
except ValueError:
re_key = StringParameterCategoryList(input_clm,
old_val).as_category_list
try:
re_val = StringParameterNumberList(input_clm,
new_val).as_number_list
except ValueError:
re_val = StringParameterCategoryList(input_clm,
new_val).as_category_list
re_dict = dict(zip(re_key, re_val))
if nodata:
nodata = float(nodata)
output = rescale.reclassify(input_gdf, input_clm, re_dict,
output_clm, nodata)
output.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
fields = self.parameterAsFields(parameters, self.FIELDS, context)
weights = self.parameterAsString(parameters, self.WEIGHTS, context)
output_clm = self.parameterAsString(parameters, self.OUTPUT_COLUMN,
context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils, StringParameterNumberList
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
weights = StringParameterNumberList('weights', weights).as_number_list
if len(fields) != len(weights):
raise ValueError('Number of fields does not match the number of '
'weights provided.')
fields_weights = dict(zip(fields, weights))
input_gdf[output_clm] = utils.weighted_sum(input_gdf, fields_weights)
input_gdf.to_file(output_file)
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
raster_lyr = self.parameterAsRasterLayer(parameters, self.RASTER,
context)
stats = self.parameterAsString(parameters, self.STATS, context)
output_clm_prefix = self.parameterAsString(parameters,
self.OUTPUT_COLUMN_PREFIX,
context)
nodata = parameters[self.NODATA]
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
raster_path = raster_lyr.dataProvider().dataSourceUri()
output = zonal.zonal_stats_raster(input_gdf, raster_path, stats,
output_clm_prefix, nodata)
output.to_file(output_file, driver="GPKG")
return {self.OUTPUT: output_file}
def processAlgorithm(self, parameters, context, feedback):
input_lyr = self.parameterAsVectorLayer(parameters, self.INPUT,
context)
input_clm = self.parameterAsString(parameters, self.INPUT_FIELD,
context)
start = parameters[self.START]
end = parameters[self.END]
output_min = self.parameterAsDouble(parameters, self.NEW_MIN, context)
output_max = self.parameterAsDouble(parameters, self.NEW_MAX, context)
output_clm = self.parameterAsString(parameters, self.OUTPUT_FIELD,
context)
output_file = self.parameterAsOutputLayer(parameters, self.OUTPUT,
context)
sys.path.insert(1, os.path.dirname(os.path.realpath(__file__)))
from loqlib import LUCISOpenQGISUtils
input_gdf = LUCISOpenQGISUtils.vector_to_gdf(input_lyr)
output = rescale.linear(input_gdf, input_clm, output_clm, start, end,
output_min, output_max)
output.to_file(output_file)
return {self.OUTPUT: output_file}