Add possibility to upload vector layer for imperviousness (sub-basins preprocessing)

Author: lorenz3tla

QTalsim/qtalsim.py

@@ -1808,6 +1808,10 @@ def createSoilLayer(self):
             self.start_operation()
             #self.dlg.progressbar.setValue(0)
             #Dissolve the layer using the talsim soil parameters
+            if not self.soilLayerIntermediate:
+                self.log_to_qtalsim_tab("Soil layer was deleted or not yet created. Please create the soil layer.", Qgis.Critical)
+                self.end_operation()
+                return
             try:
                 resultDissolve = processing.run("native:dissolve", {'INPUT':self.soilLayerIntermediate,'FIELD': self.soilFieldNames,'SEPARATE_DISJOINT':True,'OUTPUT':'TEMPORARY_OUTPUT'}, feedback=None)
                 self.soilTalsim = resultDissolve['OUTPUT']
@@ -2386,6 +2390,10 @@ def createLanduseLayer(self):
         '''
         try:
             self.start_operation()
+            if not self.landuseTalsim:
+                self.log_to_qtalsim_tab("Land use layer was deleted or not yet created. Please create the land use layer.", Qgis.Critical)
+                self.end_operation()
+                return
             #Dissolve the layer using the talsim landuse parameters
             try:
                 resultDissolve = processing.run("native:dissolve", {'INPUT':self.landuseTalsim,'FIELD': self.selected_landuse_parameters,'SEPARATE_DISJOINT':True,'OUTPUT':'TEMPORARY_OUTPUT'})

QTalsim/qtalsim_subbasin.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>789</width>
-    <height>458</height>
+    <height>489</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -182,7 +182,7 @@
           </size>
          </property>
          <property name="text">
-          <string>Select DEM Layer</string>
+          <string>Select DEM Raster Layer</string>
          </property>
         </widget>
        </item>
@@ -226,16 +226,50 @@
       </layout>
      </item>
      <item>
-      <layout class="QHBoxLayout" name="horizontalLayout_7">
+      <layout class="QVBoxLayout" name="verticalLayout_6">
        <item>
-        <widget class="QLabel" name="labelImpervious">
-         <property name="text">
-          <string>Optional: Select Imperviousness Layer [%]</string>
-         </property>
-        </widget>
+        <layout class="QHBoxLayout" name="horizontalLayout_7">
+         <item>
+          <widget class="QLabel" name="labelImpervious">
+           <property name="text">
+            <string>Optional: Select Imperviousness Layer [%]</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="comboboxImperviousness"/>
+         </item>
+        </layout>
        </item>
        <item>
-        <widget class="QComboBox" name="comboboxImperviousness"/>
+        <layout class="QHBoxLayout" name="horizontalLayout_11">
+         <item>
+          <spacer name="horizontalSpacer_4">
+           <property name="orientation">
+            <enum>Qt::Horizontal</enum>
+           </property>
+           <property name="sizeType">
+            <enum>QSizePolicy::Fixed</enum>
+           </property>
+           <property name="sizeHint" stdset="0">
+            <size>
+             <width>50</width>
+             <height>20</height>
+            </size>
+           </property>
+          </spacer>
+         </item>
+         <item>
+          <widget class="QLabel" name="labelImperviousnessField">
+           <property name="text">
+            <string>Select Imperviousness-Field</string>
+           </property>
+          </widget>
+         </item>
+         <item>
+          <widget class="QComboBox" name="comboboxImperviousnessField"/>
+         </item>
+        </layout>
        </item>
       </layout>
      </item>

QTalsim/qtalsim_subbasin_dialog.py

@@ -70,6 +70,8 @@ def initialize_parameters(self):
         #Fill Comboboxes
         self.comboboxUISubBasin.clear()
         self.comboboxNameField.clear()
+        self.comboboxImperviousnessField.setVisible(False)
+        self.labelImperviousnessField.setVisible(False)
         self.fillLayerComboboxes()
 
     def safeConnect(self, signal: pyqtSignal, slot):
@@ -146,10 +148,13 @@ def fillLayerComboboxes(self):
         self.comboboxWaterNetwork.addItem(self.noLayerSelected)
         self.comboboxWaterNetwork.addItems([layer.name() for layer in self.lineLayers])
 
-        #Imperviousness layer
+        #Imperviousness layer - raster and vector
         self.comboboxImperviousness.clear()
         self.comboboxImperviousness.addItem(self.noLayerSelected)
         self.comboboxImperviousness.addItems([layer.name() for layer in self.rasterLayers])
+        self.comboboxImperviousness.addItems([layer.name() for layer in self.polygonLayers])
+        self.safeConnect(self.comboboxImperviousness.currentIndexChanged, self.on_imperviousness_layer_changed)
+        self.comboboxImperviousnessField
 
     def on_subbasin_layer_changed(self):
         '''
@@ -169,6 +174,27 @@ def on_subbasin_layer_changed(self):
                 self.comboboxNameField.addItems(["Select Name-Field"])
                 self.comboboxNameField.addItems([str(field) for field in self.fieldsSubbasinLayer])
 
+    def on_imperviousness_layer_changed(self):
+        '''
+            If the imperviousness layer is a vector layer, fill the field-combobox with the fields of this layer.
+        '''
+        selected_layer_name = self.comboboxImperviousness.currentText() #Get the selected layer name
+            
+        if selected_layer_name is not None and selected_layer_name != self.noLayerSelected: #imperviousness is optional
+            self.imperviousnessLayer = QgsProject.instance().mapLayersByName(selected_layer_name)[0]
+            if self.imperviousnessLayer.type() == QgsMapLayer.RasterLayer: #check if raster
+                self.comboboxImperviousnessField.setVisible(False)
+                self.labelImperviousnessField.setVisible(False)
+            elif self.imperviousnessLayer.type() == QgsMapLayer.VectorLayer:
+                self.comboboxImperviousnessField.setVisible(True)
+                self.labelImperviousnessField.setVisible(True)
+                self.comboboxImperviousnessField.clear()
+                field_names = [field.name() for field in self.imperviousnessLayer.fields()]
+                self.comboboxImperviousnessField.addItems(field_names)
+        else:
+            self.comboboxImperviousnessField.setVisible(False)
+            self.labelImperviousnessField.setVisible(False)
+
     def runSubBasinPreprocessing(self):
         '''
             Core function to run all processing-steps of the sub-basins layer.
@@ -334,7 +360,85 @@ def calculateImperviousness(self, sub_basins_layer, imperviousness_layer):
         '''
             Calculates average impervious area per sub-basin.
         '''
-        self.subBasinLayerProcessed = processing.run("native:zonalstatisticsfb", {'INPUT': sub_basins_layer,'INPUT_RASTER': imperviousness_layer,'RASTER_BAND':1,'COLUMN_PREFIX':'Imp_','STATISTICS':[2],'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']            
+        if imperviousness_layer.type() == QgsMapLayer.VectorLayer:
+            fieldNameImperviousness = self.comboboxImperviousnessField.currentText()
+            intersection_result = processing.run(
+                "native:intersection",
+                {
+                    "INPUT": sub_basins_layer,
+                    "OVERLAY": imperviousness_layer,
+                    "INPUT_FIELDS": [],
+                    "OUTPUT": "memory:"
+                }
+            )
+            intersection_layer = intersection_result["OUTPUT"]
+
+            #Calculate area & weighted imperviousness for each polygon
+            intersection_layer.startEditing()
+            if "weighted_imp" not in [f.name() for f in intersection_layer.fields()]:
+                intersection_layer.dataProvider().addAttributes([
+                    QgsField("weighted_imp", QVariant.Double),
+                    QgsField("area_m2", QVariant.Double)
+                ])
+                intersection_layer.updateFields()
+
+            for feature in intersection_layer.getFeatures():
+                geom = feature.geometry()
+                area = geom.area()
+                imperv_val = feature[fieldNameImperviousness]
+                if imperv_val is None:
+                    imperv_val = 0
+                feature["area_m2"] = area
+                feature["weighted_imp"] = area * float(imperv_val)
+                intersection_layer.updateFeature(feature)
+            intersection_layer.commitChanges()
+
+            #Aggregate by sub-basin ID 
+            aggregate_result = processing.run(
+                "native:aggregate",
+                {
+                    "INPUT": intersection_layer,
+                    "GROUP_BY": self.subbasinUIField,
+                    "AGGREGATES": [
+                        {"aggregate": "first_value", "delimiter": ",", "input": self.subbasinUIField, "length": 50, "precision": 0, "name": self.subbasinUIField, 'type': 10, 'type_name': 'text', "sub_type": 0},
+                        {"aggregate": "sum", "delimiter": ",", "input": "weighted_imp", "length": 10, "precision": 3, "name": "sum_weighted", "type": 6, "type_name": "double precision", "sub_type": 0},
+                        {"aggregate": "sum", "delimiter": ",", "input": "area_m2", "length": 10, "precision": 3, "name": "sum_area", "type": 6, "type_name": "double precision", "sub_type": 0}
+                    ],
+                    "OUTPUT": "TEMPORARY_OUTPUT"
+                }
+            )
+            aggregate_layer = aggregate_result["OUTPUT"]
+            #Calculate mean imperviousness and join to sub-basins
+            aggregate_layer.startEditing()
+            if self.imperviousFieldName not in [f.name() for f in aggregate_layer.fields()]:
+                aggregate_layer.dataProvider().addAttributes([QgsField(self.imperviousFieldName, QVariant.Double)])
+                aggregate_layer.updateFields()
+
+            for feature in aggregate_layer.getFeatures():
+                sum_area = feature["sum_area"]
+                sum_weighted = feature["sum_weighted"]
+                if sum_area and sum_area > 0:
+                    feature[self.imperviousFieldName] = sum_weighted / sum_area
+                else:
+                    feature[self.imperviousFieldName] = 0
+                aggregate_layer.updateFeature(feature)
+            aggregate_layer.commitChanges()
+
+            joinResult = processing.run(
+                "native:joinattributestable",
+                {
+                    "INPUT": sub_basins_layer,
+                    "FIELD": self.subbasinUIField,
+                    "INPUT_2": aggregate_layer,
+                    "FIELD_2": self.subbasinUIField,
+                    "FIELDS_TO_COPY": [self.imperviousFieldName],
+                    "METHOD": 1, 
+                    "OUTPUT": 'TEMPORARY_OUTPUT'
+                }
+            )
+            self.subBasinLayerProcessed = joinResult['OUTPUT']
+        elif imperviousness_layer.type() == QgsMapLayer.RasterLayer:
+            self.subBasinLayerProcessed = processing.run("native:zonalstatisticsfb", {'INPUT': sub_basins_layer,'INPUT_RASTER': imperviousness_layer,'RASTER_BAND':1,'COLUMN_PREFIX':'Imp_','STATISTICS':[2],'OUTPUT':'TEMPORARY_OUTPUT'})['OUTPUT']            
 
         return self.subBasinLayerProcessed