1.1.2 - fix issue with interactive tools not opening properly after closing
1.1.1
- simplify inner working of GUI tools
diff --git a/los_tools/processing/doc/tool_extract_horizon_lines_by_distances.help b/los_tools/processing/doc/tool_extract_horizon_lines_by_distances.help
new file mode 100644
index 0000000..38607c6
--- /dev/null
+++ b/los_tools/processing/doc/tool_extract_horizon_lines_by_distances.help
@@ -0,0 +1,9 @@
+{
+ "ALG_DESC": "This tool extracts horizon lines from LoS without a target. For other types of LoS, this operation is not applicable. Maximal horizon till specified distance is created. So horizon lines for several distances can be created at once.",
+ "ALG_CREATOR": "Jan Caha",
+ "LoSLayer": "LoS layer to analyze.",
+ "Distances": "Table of distance limits for which horizon lines should be extracted.",
+ "CurvatureCorrections": "Should curvature and refraction corrections be applied?",
+ "RefractionCoefficient": "Value of the refraction coefficient. Default value: 0.13.",
+ "OutputLayer": "Output layer containing the extracted horizon lines."
+}
\ No newline at end of file
diff --git a/los_tools/processing/horizons/tool_extract_horizon_lines_by_distances.py b/los_tools/processing/horizons/tool_extract_horizon_lines_by_distances.py
new file mode 100644
index 0000000..78278ef
--- /dev/null
+++ b/los_tools/processing/horizons/tool_extract_horizon_lines_by_distances.py
@@ -0,0 +1,238 @@
+import typing
+
+from qgis.core import (
+ QgsFeature,
+ QgsFeatureRequest,
+ QgsField,
+ QgsFields,
+ QgsLineString,
+ QgsPoint,
+ QgsProcessing,
+ QgsProcessingAlgorithm,
+ QgsProcessingException,
+ QgsProcessingFeedback,
+ QgsProcessingParameterBoolean,
+ QgsProcessingParameterFeatureSink,
+ QgsProcessingParameterFeatureSource,
+ QgsProcessingParameterMatrix,
+ QgsProcessingParameterNumber,
+ QgsProcessingUtils,
+ QgsVectorLayer,
+ QgsWkbTypes,
+)
+
+from los_tools.classes.classes_los import LoSWithoutTarget
+from los_tools.constants.field_names import FieldNames
+from los_tools.constants.names_constants import NamesConstants
+from los_tools.processing.tools.util_functions import get_los_type
+from los_tools.utils import COLUMN_TYPE, COLUMN_TYPE_STRING, get_doc_file
+
+
+class ExtractHorizonLinesByDistanceAlgorithm(QgsProcessingAlgorithm):
+ LOS_LAYER = "LoSLayer"
+ OUTPUT_LAYER = "OutputLayer"
+ CURVATURE_CORRECTIONS = "CurvatureCorrections"
+ REFRACTION_COEFFICIENT = "RefractionCoefficient"
+ DISTANCES = "Distances"
+
+ horizons_types = [NamesConstants.HORIZON_MAX_LOCAL, NamesConstants.HORIZON_GLOBAL]
+
+ def initAlgorithm(self, config=None):
+ self.addParameter(
+ QgsProcessingParameterFeatureSource(self.LOS_LAYER, "LoS layer", [QgsProcessing.TypeVectorLine])
+ )
+
+ self.addParameter(
+ QgsProcessingParameterMatrix(
+ self.DISTANCES,
+ "Distance limits for horizon lines",
+ numberRows=1,
+ headers=["Distance"],
+ )
+ )
+
+ self.addParameter(QgsProcessingParameterFeatureSink(self.OUTPUT_LAYER, "Output layer"))
+
+ self.addParameter(
+ QgsProcessingParameterBoolean(
+ self.CURVATURE_CORRECTIONS,
+ "Use curvature corrections?",
+ defaultValue=True,
+ )
+ )
+
+ self.addParameter(
+ QgsProcessingParameterNumber(
+ self.REFRACTION_COEFFICIENT,
+ "Refraction coefficient value",
+ type=QgsProcessingParameterNumber.Double,
+ defaultValue=0.13,
+ )
+ )
+
+ def checkParameterValues(self, parameters, context):
+ los_layer = self.parameterAsVectorLayer(parameters, self.LOS_LAYER, context)
+
+ field_names = los_layer.fields().names()
+
+ if FieldNames.LOS_TYPE not in field_names:
+ msg = (
+ "Fields specific for LoS not found in current layer ({0}). "
+ "Cannot extract horizon lines from this layer.".format(FieldNames.LOS_TYPE)
+ )
+
+ return False, msg
+
+ los_type = get_los_type(los_layer, field_names)
+
+ if los_type != NamesConstants.LOS_NO_TARGET:
+ msg = "LoS must be of type `{0}` to extract horizon lines but type `{1}` found.".format(
+ NamesConstants.LOS_NO_TARGET, los_type
+ )
+
+ return False, msg
+
+ distances = self.parameterAsMatrix(parameters, self.DISTANCES, context)
+
+ if len(distances) < 1:
+ msg = f"Length of distances must be at least 1. It is {len(distances)}."
+
+ return False, msg
+
+ return super().checkParameterValues(parameters, context)
+
+ def processAlgorithm(self, parameters, context, feedback: QgsProcessingFeedback):
+ los_layer: QgsVectorLayer = self.parameterAsVectorLayer(parameters, self.LOS_LAYER, context)
+
+ if los_layer is None:
+ raise QgsProcessingException(self.invalidSourceError(parameters, self.LOS_LAYER))
+
+ distances_matrix = self.parameterAsMatrix(parameters, self.DISTANCES, context)
+
+ distances: typing.List[float] = []
+
+ for distance in distances_matrix:
+ try:
+ distances.append(float(distance))
+ except ValueError:
+ raise QgsProcessingException(f"Cannot convert value `{distance}` to float number.")
+
+ curvature_corrections = self.parameterAsBool(parameters, self.CURVATURE_CORRECTIONS, context)
+ ref_coeff = self.parameterAsDouble(parameters, self.REFRACTION_COEFFICIENT, context)
+
+ fields = QgsFields()
+ fields.append(QgsField(FieldNames.HORIZON_DISTANCE, COLUMN_TYPE.Double))
+ fields.append(QgsField(FieldNames.ID_OBSERVER, COLUMN_TYPE.Int))
+ fields.append(QgsField(FieldNames.OBSERVER_X, COLUMN_TYPE.Double))
+ fields.append(QgsField(FieldNames.OBSERVER_Y, COLUMN_TYPE.Double))
+
+ horizon_distance_field_index = fields.indexFromName(FieldNames.HORIZON_DISTANCE)
+ id_observer_field_index = fields.indexFromName(FieldNames.ID_OBSERVER)
+ observer_x_field_index = fields.indexFromName(FieldNames.OBSERVER_X)
+ observer_y_field_index = fields.indexFromName(FieldNames.OBSERVER_Y)
+
+ sink, dest_id = self.parameterAsSink(
+ parameters,
+ self.OUTPUT_LAYER,
+ context,
+ fields,
+ QgsWkbTypes.LineStringZM,
+ los_layer.sourceCrs(),
+ )
+
+ if sink is None:
+ raise QgsProcessingException(self.invalidSinkError(parameters, self.OUTPUT_LAYER))
+
+ id_values = list(los_layer.uniqueValues(los_layer.fields().indexFromName(FieldNames.ID_OBSERVER)))
+
+ total = 100 / (los_layer.featureCount()) if los_layer.featureCount() else 0
+
+ i = 0
+
+ for id_value in id_values:
+ request = QgsFeatureRequest()
+ request.setFilterExpression("{} = '{}'".format(FieldNames.ID_OBSERVER, id_value))
+ order_by_clause = QgsFeatureRequest.OrderByClause(FieldNames.AZIMUTH, ascending=True)
+ request.setOrderBy(QgsFeatureRequest.OrderBy([order_by_clause]))
+
+ features = los_layer.getFeatures(request)
+
+ line_points: typing.Dict[float, typing.List[QgsPoint]] = {}
+ values: typing.Dict[float, typing.List[float]] = {}
+
+ for distance in distances:
+ line_points[distance] = []
+ values[distance] = []
+
+ for los_feature in features:
+ if feedback.isCanceled():
+ break
+
+ full_los = LoSWithoutTarget(
+ los_feature.geometry(),
+ observer_offset=los_feature.attribute(FieldNames.OBSERVER_OFFSET),
+ use_curvature_corrections=curvature_corrections,
+ refraction_coefficient=ref_coeff,
+ )
+
+ for distance in distances:
+ los_limited = LoSWithoutTarget.from_another(full_los, distance_limit=distance)
+
+ line_points[distance].append(los_limited.get_global_horizon())
+ values[distance].append(los_limited.get_global_horizon_angle())
+
+ i += 1
+
+ feedback.setProgress(int(i * total))
+
+ for distance in distances:
+
+ points = line_points[distance]
+ m_values = values[distance]
+
+ if 1 < len(points):
+ line = QgsLineString(points)
+ line.addMValue()
+
+ for i in range(0, line.numPoints()):
+ line.setMAt(i, m_values[i])
+
+ f = QgsFeature(fields)
+ f.setGeometry(line)
+ f.setAttribute(id_observer_field_index, id_value)
+ f.setAttribute(
+ observer_x_field_index,
+ los_feature.attribute(FieldNames.OBSERVER_X),
+ )
+ f.setAttribute(
+ observer_y_field_index,
+ los_feature.attribute(FieldNames.OBSERVER_Y),
+ )
+ f.setAttribute(horizon_distance_field_index, distance)
+
+ sink.addFeature(f)
+
+ return {self.OUTPUT_LAYER: dest_id}
+
+ def name(self):
+ return "extracthorizonlinesbydistace"
+
+ def displayName(self):
+ return "Extract Horizon Lines By Distance"
+
+ def group(self):
+ return "Horizons"
+
+ def groupId(self):
+ return "horizons"
+
+ def createInstance(self):
+ return ExtractHorizonLinesByDistanceAlgorithm()
+
+ def helpUrl(self):
+ # TODO FIXME
+ return "https://jancaha.github.io/qgis_los_tools/tools/Horizons/tool_extract_horizon_lines/"
+
+ # def shortHelpString(self):
+ # # TODO FIXME
+ # return QgsProcessingUtils.formatHelpMapAsHtml(get_doc_file(__file__), self)
diff --git a/los_tools/processing/los_tools_provider.py b/los_tools/processing/los_tools_provider.py
index 1db70b5..d295722 100755
--- a/los_tools/processing/los_tools_provider.py
+++ b/los_tools/processing/los_tools_provider.py
@@ -18,6 +18,7 @@
from los_tools.processing.create_points.tool_points_by_azimuths import CreatePointsInAzimuthsAlgorithm
from los_tools.processing.create_points.tool_points_in_direction import CreatePointsInDirectionAlgorithm
from los_tools.processing.horizons.tool_extract_horizon_lines import ExtractHorizonLinesAlgorithm
+from los_tools.processing.horizons.tool_extract_horizon_lines_by_distances import ExtractHorizonLinesByDistanceAlgorithm
from los_tools.processing.horizons.tool_extract_horizons import ExtractHorizonsAlgorithm
from los_tools.processing.parameter_settings.tool_angle_at_distance_for_size import ObjectDetectionAngleAlgorithm
from los_tools.processing.parameter_settings.tool_distances_for_sizes import ObjectDistancesAlgorithm
@@ -77,6 +78,7 @@ def loadAlgorithms(self):
self.addAlgorithm(ExtractLoSVisibilityPolygonsAlgorithm())
self.addAlgorithm(ObjectDetectionAngleAlgorithm())
self.addAlgorithm(CreatePointsInAzimuthsAlgorithm())
+ self.addAlgorithm(ExtractHorizonLinesByDistanceAlgorithm())
def id(self):
return PluginConstants.provider_id
diff --git a/los_tools/processing/parameter_settings/tool_sizes_at_distances.py b/los_tools/processing/parameter_settings/tool_sizes_at_distances.py
index 47b7167..4a5fe16 100755
--- a/los_tools/processing/parameter_settings/tool_sizes_at_distances.py
+++ b/los_tools/processing/parameter_settings/tool_sizes_at_distances.py
@@ -73,7 +73,7 @@ def checkParameterValues(self, parameters, context):
distances = self.parameterAsMatrix(parameters, self.DISTANCES, context)
if len(distances) < 1:
- msg = f"Legth of distances must be at least 1. It is {len(distances)}."
+ msg = f"Length of distances must be at least 1. It is {len(distances)}."
return False, msg
diff --git a/los_tools/processing/tools/util_functions.py b/los_tools/processing/tools/util_functions.py
index 05c4a57..1accb07 100644
--- a/los_tools/processing/tools/util_functions.py
+++ b/los_tools/processing/tools/util_functions.py
@@ -92,7 +92,7 @@ def check_existence_los_fields(field_names: List[str]) -> None:
def wkt_to_array_points(wkt: str) -> List[List[float]]:
- reg = re.compile("(LINESTRING |LineStringZ |MULTILINESTRING |MultiLineStringZ )")
+ reg = re.compile(r"(LineString\s?Z |LINESTRING |MULTILINESTRING |MultiLineString\s?Z )", re.IGNORECASE)
wkt = reg.sub("", wkt)
diff --git a/tests/processing/horizons/tool_extract_horizon_lines_by_distances.py b/tests/processing/horizons/tool_extract_horizon_lines_by_distances.py
new file mode 100644
index 0000000..7436969
--- /dev/null
+++ b/tests/processing/horizons/tool_extract_horizon_lines_by_distances.py
@@ -0,0 +1,92 @@
+import typing
+
+import pytest
+from qgis.core import Qgis, QgsVectorLayer
+
+from los_tools.constants.field_names import FieldNames
+from los_tools.processing.horizons.tool_extract_horizon_lines_by_distances import ExtractHorizonLinesByDistanceAlgorithm
+from tests.custom_assertions import (
+ assert_algorithm,
+ assert_check_parameter_values,
+ assert_field_names_exist,
+ assert_layer,
+ assert_parameter,
+ assert_run,
+)
+from tests.utils import result_filename
+
+
+def test_parameters() -> None:
+ alg = ExtractHorizonLinesByDistanceAlgorithm()
+ alg.initAlgorithm()
+
+ assert_parameter(alg.parameterDefinition("LoSLayer"), parameter_type="source")
+ assert_parameter(alg.parameterDefinition("OutputLayer"), parameter_type="sink")
+ assert_parameter(alg.parameterDefinition("CurvatureCorrections"), parameter_type="boolean", default_value=True)
+ assert_parameter(alg.parameterDefinition("RefractionCoefficient"), parameter_type="number", default_value=0.13)
+ assert_parameter(alg.parameterDefinition("Distances"), parameter_type="matrix")
+
+
+def test_alg_settings() -> None:
+ alg = ExtractHorizonLinesByDistanceAlgorithm()
+ alg.initAlgorithm()
+
+ assert_algorithm(alg)
+
+
+def test_wrong_params(
+ los_no_target_wrong: QgsVectorLayer, los_local: QgsVectorLayer, los_global: QgsVectorLayer
+) -> None:
+ alg = ExtractHorizonLinesByDistanceAlgorithm()
+ alg.initAlgorithm()
+
+ # use layer that is not corrently constructed LoS layer
+ params = {"LoSLayer": los_no_target_wrong}
+
+ with pytest.raises(AssertionError, match="Fields specific for LoS not found in current layer"):
+ assert_check_parameter_values(alg, params)
+
+ params = {"LoSLayer": los_local, "HorizonType": 0}
+
+ with pytest.raises(
+ AssertionError, match="LoS must be of type `without target` to extract horizon lines but type `local` found"
+ ):
+ assert_check_parameter_values(alg, params)
+
+ params = {"LoSLayer": los_global, "HorizonType": 0}
+
+ with pytest.raises(
+ AssertionError, match="LoS must be of type `without target` to extract horizon lines but type `global` found"
+ ):
+ assert_check_parameter_values(alg, params)
+
+
+def test_run_alg(los_no_target: QgsVectorLayer) -> None:
+ alg = ExtractHorizonLinesByDistanceAlgorithm()
+ alg.initAlgorithm()
+
+ output_path = result_filename("horizon_lines.gpkg")
+
+ distances = [10, 30, 50, 100, 200]
+ params = {
+ "LoSLayer": los_no_target,
+ "Distances": distances,
+ "OutputLayer": output_path,
+ "CurvatureCorrections": True,
+ "RefractionCoefficient": 0.13,
+ }
+
+ assert_run(alg, params)
+
+ horizon_lines_layer = QgsVectorLayer(output_path)
+
+ assert_layer(horizon_lines_layer, geom_type=Qgis.WkbType.LineStringZM, crs=los_no_target.sourceCrs())
+
+ assert_field_names_exist(
+ [FieldNames.HORIZON_DISTANCE, FieldNames.ID_OBSERVER, FieldNames.OBSERVER_X, FieldNames.OBSERVER_Y],
+ horizon_lines_layer,
+ )
+
+ unique_ids = list(los_no_target.uniqueValues(los_no_target.fields().lookupField(FieldNames.ID_OBSERVER)))
+
+ assert horizon_lines_layer.featureCount() == len(unique_ids) * len(distances)
diff --git a/website/pages/images/tool_extract_horizon_lines_by_distances.png b/website/pages/images/tool_extract_horizon_lines_by_distances.png
new file mode 100644
index 0000000..4e2b91e
Binary files /dev/null and b/website/pages/images/tool_extract_horizon_lines_by_distances.png differ
diff --git a/website/pages/tools/Horizons/tool_extract_horizon_lines_by_distances.md b/website/pages/tools/Horizons/tool_extract_horizon_lines_by_distances.md
new file mode 100644
index 0000000..9baeb29
--- /dev/null
+++ b/website/pages/tools/Horizons/tool_extract_horizon_lines_by_distances.md
@@ -0,0 +1,32 @@
+# Extract Horizon Lines
+
+Tool that extracts horizon lines from LoS without target (created using tool [Create no target LoS](../LoS Creation/tool_create_notarget_los.md)). For other types of LoS this operation does not make sense.
+
+The horizon lines are extracted for a set of distances from the observer. The distances are provided in the table. The horizon line is extracted for each observer and distance separately, only horizons that are closer to the observer than the given distance are consider for each horizon line.
+
+## Parameters
+
+| Label | Name | Type | Description |
+| --------------------------------- | ----------------------- | ----------------------------------------- | --------------------------------------------------------------------- |
+| LoS layer | `LoSLayer` | [vector: line] | LoS layer to analyse. |
+| Distance limits for horizon lines | `Distances` | [matrix] | Table of distance limits for which horizon lines should be extracted. |
+| Output layer | `OutputLayer` | [vector: line] | Output layer horizon lines. |
+| Use curvature corrections? | `CurvatureCorrections` | [boolean]
Default: `True` | Should the curvarture and refraction corrections be used? |
+| Refraction coefficient value | `RefractionCoefficient` | [number]
Default:
`0.13` | Value of refraction coefficient. |
+
+## Outputs
+
+| Label | Name | Type | Description |
+| ------------ | ------------- | -------------- | --------------------------- |
+| Output layer | `OutputLayer` | [vector: line] | Output layer horizon lines. |
+
+### Fields in the output layer
+
+* __horizon_distance__ - double - maximal distance of the horizon line from observer
+* __id_observer__ - integer - value from expected field (`id_observer`) in `LoSLayer`
+* __observer_x__ - double - X coordinate of observer point, to be used later in analyses
+* __observer_y__ - double - Y coordinate of observer point, to be used later in analyses
+
+## Tool screenshot
+
+