wolfhece 2.0.3__tar.gz → 2.0.4__tar.gz

{wolfhece-2.0.3 → wolfhece-2.0.4}/PKG-INFO

@@ -1,17 +1,15 @@
 Metadata-Version: 2.1
 Name: wolfhece
-Version: 2.0.3
-Summary: WOLF package
-Home-page: https://uee.uliege.be/hece
-Author: Pierre Archambeau
-Author-email: pierre.archambeau@uliege.be
-Project-URL: Bug Tracker, https://uee.uliege.be/hece
-Classifier: Programming Language :: Python :: 3
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Operating System :: OS Independent
+Version: 2.0.4
+Author-email: Stéphane Champailler <stephane.champailler@uliege.be>, Pierre Archambeau <pierre.archambeau@uliege.be>
+Project-URL: Homepage, https://uee.uliege.be/hece
+Project-URL: Issues, https://uee.uliege.be/hece
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Operating System :: Microsoft :: Windows :: Windows 10
+Classifier: Operating System :: Microsoft :: Windows :: Windows 11
+Classifier: Topic :: Scientific/Engineering :: Physics
 Requires-Python: <3.11,>=3.9
 Description-Content-Type: text/markdown
-License-File: LICENCE
 Requires-Dist: wxpython
 Requires-Dist: numpy
 Requires-Dist: pyopengl
@@ -49,6 +47,7 @@ Requires-Dist: osmnx
 Requires-Dist: tifffile
 Requires-Dist: numba
 Requires-Dist: xmltodict
+Requires-Dist: opencv-python
 
 Ce paquet contient l'interface graphique Python du logiciel WOLF (HECE - ULiège) de même que plusieurs outils de traitements topographique, hydraulique et hydrologique.
 

wolfhece-2.0.4/README.md

@@ -0,0 +1,99 @@
+As someone who develops real applications or one off programs as well as new functionalities in WolfHECE:
+	
+- I fork the *HECEPython* repository with git branch so that my developments don't pollute the main branch
+- I install Wolf's dependencies with "pip install -r requirements.txt" and "pip install GDAL-3.4.3-cp39-cp39-win_amd64.whl"
+- I get an issue in GitLab to track my work (I create it or it is given to me)
+- I can use my local copy of WolfHECE (for *.py files; *lib files via the add_path)  (possibly instead of the one installed with pip) with:
+    - import sys
+    - sys.path.insert(0, r"pathfiletolib")
+
+<h1> Organisation générale - General Structure</h1>
+<h2>Fr</h2>
+
+Ce repository Gitlab est destiné à contenir tous les codes Python du HECE.
+ 
+Pour le moment, sa structure est la suivante :
+	
+- BlenderCityGML : Blenger plugin pour impoter des bâtiments depuis un fichier 3DML
+- BlenderGIS : Blender plugin pour traiter des maillages comme des informations SIG (-> petites corrections "nécessaire" par rapport au projet GitHub pour gérer les palettes de couleurs)
+- data : répertoire de données (utile notamment pour l'import de valeurs hydrométriques depuis le web)
+- debug : code de développement d'une fonctionnalité spécifique
+- dike breaching : rupture de digue (cf thèse Vincent Schmitz)
+- doc : permet d'y stocker des exemples utiles pour la doc
+- doxygen : pages web résultat du traitement automatique du code via Doxygen
+- f2py : outil de compilation d'une librairie d'interaction avec le Fortran via Numpy/f2py --> devrait être remplacé par une interaction DLL+CTypes
+- pypi_config : fichiers de paramétrisation pour le paquet Pypi.org
+- real_apps : applications plus complètes exploitant le paquet wolfhece
+- wolfhece : paquet d'outils dans lequel les développements de base doivent se trouver
+   - des sous-répertoires thématiques existent déjà, d'autres peuvent être ajoutés	
+   - les outils "communs" sont actuellement dans le sous-répertoire principal
+
+Vous pouvez créer des répertoires supplémentaires pour des applications particulières.
+
+La méthode de travail souhaitée est la suivante pour une nouvelle idée/fonctionnalité :
+ - créer un ticket
+ - créer une branche associée
+ - développer
+ - demander la fusion
+
+<h2>En</h2>
+
+This Gitlab repository is intended to contain all the HECE Python code.
+ 
+For the moment, its structure is as follows:
+	
+ - BlenderCityGML: Blender plugin for importing buildings from a 3DML file
+ - BlenderGIS: Blender plugin for processing meshes as GIS data (-> some "necessary" corrections compared to the GitHub project for managing colormap).
+ - data: data directory (useful especially for importing hydrometric values from the web).
+ - debug: development code for a specific functionality.
+ - dike breaching: evolution of a breach in a dike (see Vincent Schmitz's PhD).
+ - doc: used to store useful examples for documentation.
+ - doxygen: web pages resulting from automatic code processing via Doxygen.
+ - f2py: tool for compiling a library for interaction with Fortran using Numpy/f2py --> should be replaced by DLL+CTypes interaction.
+ - pypi_config: parameterization files for the Pypi.org package.
+ - real_apps: more comprehensive applications that utilize the wolfhece package.
+ - wolfhece: tools package
+   - thematic subdirectories already exist, others can be added.
+   - most "common" tools are currently in the main subdirectory.
+
+You can create additional directories for particular applications.
+
+The desired way of working is as follows for a new idea/feature:
+ - create an issue
+ - create an associated branch
+ - code
+ - create merge request
+
+ More information on Gitlab (token, ...): https://moodle.hece.uliege.be/mod/wiki/view.php?pageid=298
+
+ <h1>Interaction Fortran-Python - How to Call Fortran from Python </h1>
+
+<h2>Fr</h2>
+Il est possible de faire interagir Fortran et Python.
+
+Une voie possible est f2py (https://numpy.org/doc/stable/f2py/). C'est d'ailleurs exploité pour certaines fonctions dans la librairie "wolfpy.pyd", mais cela offre peu de souplesse.
+
+Une autre voie est le module "ctypes" qui est dédié à de l'interaction avec le C, ce que peut faire également nativement le Fortran. 
+
+Comme pour toute interaction multilanguages, le débogage devient cependant plus complexe. Il est en effet nécessaire de disposer d'un outil de débogage en Python (-> VSCode) mais également en Fortran (-> VisualStudio). Le Python doit être tout d'abord lancé et il faut récupérer le PID du process (cd fonction "getpid()" du module "os"). Ce PID est nécessaire pour attacher le débuggeur de Visual Studio au process en cours afin de capter l'appel aux fonctions de la DLL (cf https://stackoverflow.com/questions/27154325/how-to-debug-a-windows-dll-used-inside-python). Il faut bien faire attention à ce que les 2 codes utilisent la même DLL, autrement dit soit adapter le répertoire de sortie de VisualStudio, soit utiliser un chemin absolu vers la librairie compilée dans VSCode.
+
+Dans VSCode, pour que la lecture de la DLL depuis un chemin absolu soit possible, il est utile d'explicitement passer le paramètre "winmode" et de lui imposer une valeur de "0" (source : https://stackoverflow.com/questions/59330863/cant-import-dll-module-in-python).
+
+Un autre problème peut venir du besoin de mémoire de pile (Memory Stack), mémoire notamment exploitée pour les variables locales des routines/fonctions. Comme c'est le Python qui gère le process de base, le paramétrage du projet VisualStudio ne semble pas fonctionner. Il est donc nécessaire de passer par le module "Threading" de Python, seul moyen semble-t-il, d'augmenter la mémoire de pile d'un thread spécifique (cf https://stackoverflow.com/questions/2067637/how-do-i-increase-the-stack-size-in-python).
+
+Une autre approche est de forcer l'allocation de toutes les variables dans la Heap et non dans la Stack. Cela peut se faire via les paramètres du projet Fortran dans "Fortran/Optimization/Heap Arrays" en mettant "0". La conséquence sur le temps de calcul n'a cependant jamais été étudiée.
+
+<h2>En</h2>
+Interfacing Fortran and Python is possible.
+
+One viable approach is through the use of f2py (https://numpy.org/doc/stable/f2py/). This technique is actually employed in certain functions within the 'wolfpy.pyd' library, although it provides limited flexibility.
+
+Another way is the 'ctypes' module, specifically designed for interacting with C, which Fortran can naturally interface with as well.
+
+As is customary in multilingual interaction scenarios, debugging becomes significantly more intricate. It is essential to have debugging tools available for both Python (e.g., VSCode) and Fortran (e.g., Visual Studio). Initially, Python must be launched, and the Process ID (PID) of the running instance must be retrieved (accomplished using the 'getpid()' function from the 'os' module). This PID is necessary for attaching the Visual Studio debugger to the running process to capture calls to functions within the DLL (see https://stackoverflow.com/questions/27154325/how-to-debug-a-windows-dll-used-inside-python). Ensuring that both codes utilize the same DLL is crucial, either by adjusting the Visual Studio output directory or specifying an absolute path to the compiled library within VSCode.
+
+In VSCode, to allow for DLL access from an absolute path, it proves advantageous to explicitly set the 'winmode' parameter and set its value to '0' (source: https://stackoverflow.com/questions/59330863/cant-import-dll-module-in-python).
+
+Another potential complication may stem from the necessity for stack memory, typically employed for local variables within routines/functions. Since Python governs the primary process, configuring the Visual Studio project settings may prove ineffective. Therefore, employing Python's 'Threading' module appears to be the sole method of augmenting stack memory for a specific thread (refer to https://stackoverflow.com/questions/2067637/how-do-i-increase-the-stack-size-in-python).
+
+Alternatively, one may opt to force the allocation of all variables in the Heap rather than the Stack. This can be achieved through the Fortran project settings under 'Fortran/Optimization/Heap Arrays' by setting it to '0'. However, it is worth noting that the impact on computation time resulting from this change has not been extensively studied.

wolfhece-2.0.4/pyproject.toml

@@ -0,0 +1,148 @@
+# Build the release with `python -m build`
+# Test with:  pip install --force-reinstall --no-deps dist\wolfgpu-2.0.xx-py3-none-any.whl
+# This will install a script called wolf
+# Upload to Pypi with python -m twine upload --repository pypi dist/wolfgpu-2.0.xx-py3-none-any.whl
+#  __token__
+#  pypi-AgEIcHlwaS5vcmcCJDM3MDAyYjBlLWUwZDQtNDg1Yy1hM2E3LTljNGU0NzNkOGM0NAACEFsxLFsid29sZmhlY2UiXV0AAixbMixbImNlMDg1NDZjLTk0NjEtNGQ0OS1iMDY2LWNlMjExNmQyNTM1OCJdXQAABiCUZc7TVTde5cz6ONY759JZRZH75ooavff6EFGWtESIig
+#  pypi-AgEIcHlwaS5vcmcCJGY2YTkwMTY2LWU3Y2MtNGU1OS1hODc4LTgxYzJjZmM4NjIzYgACEFsxLFsid29sZmhlY2UiXV0AAixbMixbImNlMDg1NDZjLTk0NjEtNGQ0OS1iMDY2LWNlMjExNmQyNTM1OCJdXQAABiBLxP4zjGXvSNwtNkg_xVjnA-86zSK_-wImRB9_ELAYMw# 
+#
+# Upload to Gitlab with python -m twine upload --repository gitlab \dist\*
+#
+# update version : python update_cfg.py
+
+[build-system]
+requires = [
+    "setuptools>=61.0",
+    "wheel"
+]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "wolfhece"
+version = "2.0.4"
+readme = "README-package.md"
+authors = [
+  { name="Stéphane Champailler", email="stephane.champailler@uliege.be" },
+  { name="Pierre Archambeau", email="pierre.archambeau@uliege.be" },
+]
+requires-python = ">=3.9,<3.11"
+classifiers = [
+    "Programming Language :: Python :: 3.9",
+    "Operating System :: Microsoft :: Windows :: Windows 10",
+    "Operating System :: Microsoft :: Windows :: Windows 11",
+#    "Environment :: CPU",
+    "Topic :: Scientific/Engineering :: Physics"
+]
+dependencies = [
+    'wxpython',
+    'numpy',
+    'pyopengl',
+    'pandas',
+    'geopandas',
+    'scipy',
+    'owslib',
+    'pillow',
+    'cython',
+    'pyproj',
+    'dbfread',
+    'graphviz',
+    'owslib',
+    'beautifulsoup4',
+    'requests',
+    'notebook',
+    'matplotlib',
+    'mkl',
+    'python-gettext',
+    'shapely',
+    'openpyxl',
+    'xlrd',
+    'openkmi',
+    'lxml',
+    'laspy',
+    'laszip',
+    'sympy',
+    'python-pptx',
+    'python-docx',
+    'pygltflib',
+    'ezdxf',
+    'pyvista',
+    'tqdm',
+    'osmnx',
+    'tifffile',
+    'numba',
+    'xmltodict',
+    'opencv-python'  ]
+
+
+[project.urls]
+Homepage = "https://uee.uliege.be/hece"
+Issues = "https://uee.uliege.be/hece"
+
+[tool.setuptools]
+include-package-data = false
+
+
+[project.gui-scripts]
+wolf = "wolfhece.cli:wolf"
+wolfoptimhydro = "wolfhece.cli:optihydro"
+wolfhydro = "wolfhece.cli:hydro"
+wolf2d = "wolfhece.cli:wolf2d"
+wolfdigitizer = "wolfhece.cli:digitizer"
+wolfparam = "wolfhece.cli:params"
+wolfcompare = "wolfhece.cli:compare"
+
+[tool.setuptools.packages.find]
+exclude = ["wolfhece.hydrometry_hece"]
+
+include = [
+    "wolfhece",
+    "wolfhece.apps",
+    "wolfhece.bernoulli",
+    "wolfhece.eva",
+    "wolfhece.fonts",
+    "wolfhece.ftp",
+    "wolfhece.hydrology",
+    "wolfhece.hydrometry",
+    "wolfhece.icons",
+    "wolfhece.lagrangian",
+    "wolfhece.lazviewer",
+    "wolfhece.lazviewer.points",
+    "wolfhece.lazviewer.processing",
+    "wolfhece.lazviewer.processing.estimate_normals",
+    "wolfhece.lazviewer.vfuncs",
+    "wolfhece.lazviewer.viewer",
+    "wolfhece.libs/*",
+    "wolfhece.links",
+    "wolfhece.locales",
+    "wolfhece.mar",
+    "wolfhece.mesh2d",
+    "wolfhece.models",
+    "wolfhece.pythonfortran",
+    "wolfhece.radar",
+    "wolfhece.rem",
+    "wolfhece.scenario",
+    "wolfhece.sounds",
+    "wolfhece.ui"
+    ]
+
+[tool.setuptools.package-data]
+# For package wolfhece, you have to include  
+wolfhece = [
+    "libs/*.dll",
+    "libs/*.c",
+    "libs/*.pyx",
+    "libs/GL/*.h",
+    "libs/*.pyd",
+    "locales/*.po*",
+    "locales/*/*.po",
+    "locales/*/*.mo",
+    "models/*.*",
+    "sounds/*.wav",
+    "fonts/*.ttf",
+    "icons/*.png",
+    "lazviewer/qt_plugins/*.dll",
+    "lazviewer/libs/*.dll",
+    "lazviewer/processing/estimate_normals/*.pyd",
+    "lazviewer/vfuncs/*.pyd",
+    "lazviewer/viewer/*.exe"
+    ]

wolfhece-2.0.4/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

wolfhece-2.0.4/tests/test_laz_viewer.py

@@ -0,0 +1,19 @@
+import _add_path
+import unittest
+import tempfile
+
+from wolfhece.lazviewer import viewer
+from wolfhece.lazviewer.laz_viewer import myviewer, xyz_laz_grids, Colors_Lazviewer
+
+class LazViewer(unittest.TestCase):
+
+    def test_viewer_Theux_2023(self):
+
+        mygrids = xyz_laz_grids(r'D:\OneDrive\OneDrive - Universite de Liege\Crues\2021-07 Vesdre\CSC - Convention - ARNE\Data\LAZ_Vesdre\2023\grids')
+        xyz = mygrids.scan([[252500, 252700],[136400,136500]])
+        newview_code = myviewer(xyz,Colors_Lazviewer.CODE_2023)
+        newview = myviewer(xyz,Colors_Lazviewer.ORTHO_2021)
+
+        self.assertTrue(isinstance(newview, viewer), 'Bad type viewer')
+        self.assertTrue(isinstance(newview_code, viewer), 'Bad type viewer')
+        self.assertTrue(xyz.shape==(2220375,4), 'badv shape in xyz')

wolfhece-2.0.4/tests/test_link.py

@@ -0,0 +1,27 @@
+import _add_path
+import unittest
+import os
+import sys
+from pathlib import Path
+from tempfile import TemporaryDirectory
+
+from wolfhece.links import link
+
+class TestLink(unittest.TestCase):
+
+    def test_create_link(self):
+
+        with TemporaryDirectory() as tempdir:
+            directory = os.path.join(tempdir, "directory")
+            os.mkdir(directory)
+            link_path = os.path.join(tempdir, "link")
+
+            # Act
+            link.create_link(directory, link_path)
+
+            # Assert
+            if not sys.platform == "win32":
+                self.assertTrue(os.path.islink(Path(link_path)), 'link not created')
+            else:
+                self.assertTrue(os.path.exists(link_path), 'link not created')
+            self.assertTrue((directory in str(os.readlink(link_path))), 'link not readable')

wolfhece-2.0.4/tests/test_myfirsttest.py

@@ -0,0 +1,19 @@
+import _add_path
+import unittest
+
+
+class MyFirstTest(unittest.TestCase):
+
+    def test_helloworld(self):
+
+        a = "Hello World !"
+
+        self.assertEqual(a, 'Hello World !', 'Bad chain with case')
+        self.assertEqual(a.lower(), 'hello world !', 'Bad chain lower case')
+        self.assertEqual(a.upper(), 'HELLO WORLD !', 'Bad chain lower case')
+
+    def firstfunc(a):
+        return a+1
+
+    def test_firstfunc(self):
+        self.assertEqual(MyFirstTest.firstfunc(3), 4, 'Bad result')

wolfhece-2.0.4/tests/test_numpy_reshape.py

@@ -0,0 +1,63 @@
+import _add_path
+import unittest
+import numpy as np
+from wolfhece.wolf_array import WolfArray, WOLF_ARRAY_FULL_SINGLE
+from tempfile import TemporaryDirectory, TemporaryFile
+from os.path import join
+
+
+class NumpyTests(unittest.TestCase):
+
+    def test_reshape(self):
+        
+        a = np.zeros((4,4))
+        a[0:2,0:2] = 0
+        a[0:2,2:]  = 1
+        a[2:,0:2]  = 2
+        a[2:,2:]   = 3
+
+        b = np.mean(a.reshape((2,2,2,2)), axis=(1,3))
+        # b = a.reshape((2,2,2,2))
+        c = np.asarray([[0,1],[2,3]])
+        d=np.sum(np.abs(b-c))
+        
+        self.assertEqual(d, 0., 'bad reshape and mean')
+        
+
+    def test_wolf2Numpy(self):
+
+        # Create wolfarray
+        w_array = WolfArray()
+        # set sizes/shape
+        w_array.nbx, w_array.nby = 100,200
+        # allocate memory space
+        w_array.allocate_ressources()     
+
+        # fill-in with data
+        w_array.array.data[:,:] = np.arange(100*200, dtype=np.float32).reshape(w_array.array.shape, order='F')
+
+        with TemporaryDirectory() as tmpdir:
+            # write on disk
+            w_array.write_all(join(tmpdir, 'test.bin'))
+            # read in another array
+            r_array = WolfArray(join(tmpdir, 'test.bin'))
+
+            # binary read
+            with open(join(tmpdir, 'test.bin'), 'rb') as f:
+                # numpy from buffer
+                locarray = np.frombuffer(f.read(100*200 * 4), dtype=np.float32)
+
+                # copy buffer in numpy array alive after "with open"
+                np_array_F = np.asarray(locarray.copy(), dtype=np.float32)
+                # using order "F", data is aligned/ordered as Fortran (first indice most rapid)                 
+                np_array_F = np_array_F.reshape(100, 200, order='F')
+
+                # using order "C", data is aligned/ordered as C (last indice most rapid)                 
+                # the array is 'transposed' --> like numpy default definition
+                np_array_C = np.asarray(locarray.copy(), dtype=np.float32)                
+                np_array_C = np_array_C.reshape(200, 100, order='C')
+
+            self.assertEqual(np.all(w_array.array-r_array.array == 0.), True)
+            self.assertEqual(np.all(w_array.array-np_array_F == 0.), True)
+            self.assertEqual(np.all(w_array.array-np_array_C.T == 0.), True)
+            self.assertEqual(np.all(w_array.array.T-np_array_C == 0.), True)