com6RockAvalanche: Update variableVoellmyShapeToRaster

Update variableVoellmyShapeToRaster so that inputs are fetched automatically and no file paths are needed

Author: dwolfsch

avaframe/avaframeCfg.ini

@@ -4,7 +4,7 @@
 
 [MAIN]
 # Path to avalanche directory
-avalancheDir = data/avaParabola
+avalancheDir = 
 
 # number of CPU cores to use for the computation of com1DFA
 # possible values are:

avaframe/com6RockAvalanche/readMeVariableVoellmyShapeToRaster.txt

@@ -1,14 +1,23 @@
 The VariableVoellmyShapeToRaster.py script allows the user to define spatially different values for the voellmy Parameters mu and xsi, with the use of polygon shapefiles. For the extent of a DEM raster, all the areas that are not covered by a polygon get assigned a default mu or xsi value. The script then converts this Information into a raster mu and a raster xsi file, which can then be used in Avaframe Simulation runs, using the "spatialVoellmy" friction model. 
 
 First, set up the Config File and provide inputs:
+•Config File:
+	oIn the first step, the Config File needs to be configured and all input files have to be provided
+		Main Config (avaframeCfg.ini):
+			•Set the path to the avalanche directory 
 oInputs:
-	dem: Path to the DEM Raster that is later on used for the avaframe simulation. This is needed, because the mu and xsi output rasters need to be the 			exact same size. Usually this file lies in \AvaFrame\avaframe\data\ *yourAvalancheDir*\Inputs
-	mu_shapefile: Path to the mu shapefile, that is then converted to a raster file. Be aware, that the attribute has to be named “xsi”. 
-	xsi_shapefile: Path to the xsi shapefile, that is then converted to a raster file. Be aware, that the attribute has to be named “mu”. 
+	All the Input Files are automatically fetched through the set avalanche directory. It is not necessary to provide a file path.
+	dem: DEM Raster that is later on used for the avaframe simulation. This is needed, because the mu and xsi output rasters need to be the exact same size. Has to lie in avadir/Inputs. 
+	mu_shapefile: Mu shapefile, that is then converted to a raster file. Be aware, that the attribute has to be named “mu” and the file name has to end with “_mu”. Has to lie in avadir/Inputs/POLYGONS.
+	xsi_shapefile: Xsi shapefile, that is then converted to a raster file. Be aware, that the attribute has to be named “xsi” and the file name has to end with “_xsi”. Has to lie in avadir/Inputs/POLYGONS.
 oDefaults:
 	default_mu: this is the default mu value, that gets assigned to all areas in the raster, that are not covered by shapefile-polygons
 	default_xsi: this is the default xsi value, that gets assigned to all areas in the raster, that are not covered by shapefile-polygons
-	
-RunScript:
+oOutputs:
+	For the variable Voellmy calculations in the com1DFA algorithm to work, it is mandatory, that the files are stored in: avaframe\data\*yourAvalancheDir*\Inputs\RASTERS\
+	mu_raster: Output for the generated mu raster file stored as *_mu.asc
+	xsi_raster: Output for the generated xsi raster file stored as *_xi.asc
+
+•RunScript:
 	oOnce everything is set up, run the script “runVariableVoellmyShapeToRaster.py”
 	oIf libraries are missing use: pip install *name of missing library

avaframe/com6RockAvalanche/variableVoellmyShapeToRaster.ini

@@ -1,46 +1,48 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Jan 21 11:43:18 2025
-
-@author: Domi
-"""
-
+ 
 import rasterio
 import numpy as np
-import configparser
+import pathlib
 from rasterio.features import rasterize
 from shapely.geometry import shape, mapping
 from in2Trans.shpConversion import SHP2Array
+from in1Data.getInput import getAndCheckInputFiles
 import logging
 
 # Configure logging
 logging.basicConfig(level=logging.DEBUG)
 log = logging.getLogger(__name__)
 
-def generateMuXsiRasters(configPath):
+def generateMuXsiRasters(avadir, variableVoellmyCfg):
     """
-    Generate raster files for μ and ξ based on input DEM and shapefiles.
+    Generate raster files for \u03bc and \u03be based on input DEM and shapefiles.
 
     Parameters
     ----------
-    configPath : str
-        Path to the configuration file.
+    avadir : str
+        Path to the avalanche directory.
+    variableVoellmyCfg : Config Parser Object
+        variableVoellmyCfg Configuration File
 
     Returns
     -------
     None
     """
-    # Load configuration
-    config = configparser.ConfigParser()
-    config.read(configPath)
+    avadir = pathlib.Path(avadir)
+    
+    config = variableVoellmyCfg  # Directly use the ConfigParser object
+    
+    inputDir = avadir / "Inputs"
+    outputDir = avadir / "Inputs" # Output directory is Inputs, because Outputs of this Script will be used as Inputs for AvaFrame
+
+    demPath, _ = getAndCheckInputFiles(inputDir, '', 'DEM', fileExt='asc')
+    muShapefile, _ = getAndCheckInputFiles(inputDir, 'POLYGONS', '\u03bc Shapefile', fileExt='shp', fileSuffix='_mu')
+    xsiShapefile, _ = getAndCheckInputFiles(inputDir, 'POLYGONS', '\u03be Shapefile', fileExt='shp', fileSuffix='_xsi')
+
+    muOutputPath = outputDir / "RASTERS" / "raster_mu.asc"
+    xsiOutputPath = outputDir / "RASTERS" /"raster_xi.asc"
 
-    demPath = config['INPUT']['dem']
-    muShapefile = config['INPUT']['mu_shapefile']
-    xsiShapefile = config['INPUT']['xsi_shapefile']
     defaultMu = float(config['DEFAULTS']['default_mu'])
     defaultXsi = float(config['DEFAULTS']['default_xsi'])
-    muOutputPath = config['OUTPUT']['mu_raster']
-    xsiOutputPath = config['OUTPUT']['xsi_raster']
 
     # Read DEM
     with rasterio.open(demPath) as demSrc:
@@ -49,7 +51,6 @@ def generateMuXsiRasters(configPath):
         demCrs = demSrc.crs
         demShape = demData.shape
 
-    # Helper function to rasterize shapefiles
     def rasterizeShapefile(shapefilePath, defaultValue, attributeName):
         if not shapefilePath:
             return np.full(demShape, defaultValue, dtype=np.float32)
@@ -61,45 +62,25 @@ def rasterizeShapefile(shapefilePath, defaultValue, attributeName):
             length = int(shpData['Length'][i])
             coords = [(shpData['x'][j], shpData['y'][j]) for j in range(start, start + length)]
             poly = shape({'type': 'Polygon', 'coordinates': [coords]})
-            value = shpData['attributes'][i][attributeName]  # Extract the attribute value
+            value = shpData['attributes'][i][attributeName]
             shapes.append((mapping(poly), value))
 
-        rasterData = rasterize(
-            shapes,
-            out_shape=demShape,
-            transform=demTransform,
-            fill=defaultValue,
-            all_touched=True,
-            dtype=np.float32
-        )
-        return rasterData
-
-    # Generate μ and ξ rasters
-    log.info("Rasterizing μ shapefile.")
+        return rasterize(shapes, out_shape=demShape, transform=demTransform, fill=defaultValue, all_touched=True, dtype=np.float32)
+
+    log.info("Rasterizing \u03bc shapefile.")
     muRaster = rasterizeShapefile(muShapefile, defaultMu, "mu")
 
-    log.info("Rasterizing ξ shapefile.")
+    log.info("Rasterizing \u03be shapefile.")
     xsiRaster = rasterizeShapefile(xsiShapefile, defaultXsi, "xsi")
 
-    # Save output rasters
     def saveRaster(outputPath, data):
-        with rasterio.open(
-            outputPath,
-            'w',
-            driver='GTiff',
-            height=data.shape[0],
-            width=data.shape[1],
-            count=1,
-            dtype=data.dtype,
-            crs=demCrs,
-            transform=demTransform,
-        ) as dst:
+        with rasterio.open(outputPath, 'w', driver='GTiff', height=data.shape[0], width=data.shape[1], count=1, dtype=data.dtype, crs=demCrs, transform=demTransform) as dst:
             dst.write(data, 1)
 
-    log.info("Saving μ raster to %s", muOutputPath)
+    log.info("Saving \u03bc raster to %s", muOutputPath)
     saveRaster(muOutputPath, muRaster)
 
-    log.info("Saving ξ raster to %s", xsiOutputPath)
+    log.info("Saving \u03be raster to %s", xsiOutputPath)
     saveRaster(xsiOutputPath, xsiRaster)
 
     log.info("Raster generation completed.")

avaframe/com6RockAvalanche/variableVoellmyShapeToRaster.py

@@ -0,0 +1,6 @@
+[DEFAULTS]
+# Default \u03bc value for areas not covered by shapefiles
+default_mu = 0.1
+
+# Default \u03be value for areas not covered by shapefiles
+default_xsi = 300.0

avaframe/com6RockAvalanche/variableVoellmyShapeToRasterCfg.ini

@@ -1,60 +1,60 @@
-# -*- coding: utf-8 -*-
-"""
-Created on Tue Jan 21 11:49:44 2025
-
-@author: Domi
-"""
 
 import argparse
 import pathlib
-from com6RockAvalanche.variableVoellmyShapeToRaster import generateMuXsiRasters
+import time
 from avaframe.in3Utils import cfgUtils
 from avaframe.in3Utils import logUtils
-from avaframe.in3Utils import initializeProject as initProj
+import avaframe.in3Utils.initializeProject as initProj
+from com6RockAvalanche import variableVoellmyShapeToRaster
+from com6RockAvalanche.variableVoellmyShapeToRaster import generateMuXsiRasters
 
-def runMuXsiWorkflow(configPath=''):
+def runMuXsiWorkflow(avadir=''):
     """
     Run the workflow to generate \u03bc and \u03be rasters.
 
     Parameters
     ----------
-    configPath : str
-        Path to the configuration file.
+    avadir : str
+        Path to the avalanche directory containing input and output folders.
 
     Returns
     -------
     None
     """
+    startTime = time.time()
     logName = 'runMuXsi'
 
     # Load general configuration file
     cfgMain = cfgUtils.getGeneralConfig()
-
-    # Load configuration file path from general config if not provided
-    if configPath:
-        cfgMain['MAIN']['configFile'] = configPath
+    if avadir:
+        cfgMain['MAIN']['avalancheDir'] = avadir
     else:
-        configPath = cfgMain['MAIN']['configFile']
+        avadir = cfgMain['MAIN']['avalancheDir']
 
-    configPath = pathlib.Path(configPath)
+    avadir = pathlib.Path(avadir)
 
     # Start logging
-    log = logUtils.initiateLogger(configPath.parent, logName)
+    log = logUtils.initiateLogger(avadir, logName)
     log.info('MAIN SCRIPT')
-    log.info('Using configuration file: %s', configPath)
+    log.info('Using avalanche directory: %s', avadir)
 
     # Clean input directory(ies) of old work files
-    initProj.cleanSingleAvaDir(configPath.parent, deleteOutput=False)
+    initProj.cleanSingleAvaDir(avadir, deleteOutput=False)
+
+    # Load module-specific configuration for Variable Voellmy
+    variableVoellmyCfg = cfgUtils.getModuleConfig(variableVoellmyShapeToRaster)
 
     # Run the raster generation process
-    generateMuXsiRasters(str(configPath))
+    generateMuXsiRasters(avadir, variableVoellmyCfg)
 
+    endTime = time.time()
+    log.info("Took %6.1f seconds to calculate.", (endTime - startTime))
     log.info('Workflow completed successfully.')
 
 if __name__ == '__main__':
     parser = argparse.ArgumentParser(description='Run \u03bc and \u03be raster generation workflow')
-    parser.add_argument('configPath', metavar='c', type=str, nargs='?', default='',
-                        help='Path to the configuration file')
+    parser.add_argument('avadir', metavar='a', type=str, nargs='?', default='',
+                        help='Path to the avalanche directory')
 
     args = parser.parse_args()
-    runMuXsiWorkflow(str(args.configPath))
+    runMuXsiWorkflow(str(args.avadir))