pytopocomplexity 0.7.2__tar.gz → 0.7.4__tar.gz

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytopocomplexity
-Version: 0.7.2
+Version: 0.7.4
 Summary: A package for topographic complexity analysis
 Home-page: https://github.com/GeoLarryLai/pyTopoComplexity
 Author: Larry Syu-Heng Lai
@@ -208,6 +208,7 @@ License:                                  Apache License
            limitations under the License.
         
 Project-URL: Homepage, https://github.com/GeoLarryLai/pyTopoComplexity
+Project-URL: Repository, https://github.com/GeoLarryLai/pyTopoComplexity.git
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -215,7 +216,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# pyTopoComlexity (v0.7.2)
+# pyTopoComlexity (v0.7.4)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11239338.svg)](https://doi.org/10.5281/zenodo.11239338)
 
 `pytopocomplexity` is an open-source Python package designed to measure the topographic complexity (i.e., surface roughness) of land surfaces using digital elevation model (DEM) data. This package includes modules for three methods commonly used in the fields of geomorphology and oceanography for measuring topographic complexity, which are not fully available in Geographic Information System (GIS) software like QGIS.
@@ -267,7 +268,6 @@ The rugosity index is determined as the ratio of the real surface area to the ge
 ## Requirements
 For `pytopocomplexity` package
 * Python >= 3.10
-* `os`
 * `numpy`
 * `scipy`
 * `rasterio`

pytopocomplexity-0.7.2/README.md → pytopocomplexity-0.7.4/README-pypi.md

@@ -1,4 +1,4 @@
-# pyTopoComlexity (v0.7.2)
+# pyTopoComlexity (v0.7.4)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11239338.svg)](https://doi.org/10.5281/zenodo.11239338)
 
 `pytopocomplexity` is an open-source Python package designed to measure the topographic complexity (i.e., surface roughness) of land surfaces using digital elevation model (DEM) data. This package includes modules for three methods commonly used in the fields of geomorphology and oceanography for measuring topographic complexity, which are not fully available in Geographic Information System (GIS) software like QGIS.
@@ -50,7 +50,6 @@ The rugosity index is determined as the ratio of the real surface area to the ge
 ## Requirements
 For `pytopocomplexity` package
 * Python >= 3.10
-* `os`
 * `numpy`
 * `scipy`
 * `rasterio`

pytopocomplexity-0.7.4/README.md

@@ -0,0 +1,140 @@
+# pyTopoComlexity (v0.7.4)
+[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11239338.svg)](https://doi.org/10.5281/zenodo.11239338)
+<p align="left">
+ <img src="image/pyTopoComplexity_logo.png" width="30%" height="30%""/>
+</p>
+
+`pytopocomplexity` is an open-source Python package designed to measure the topographic complexity (i.e., surface roughness) of land surfaces using digital elevation model (DEM) data. This package includes modules for three methods commonly used in the fields of geomorphology and oceanography for measuring topographic complexity, which are not fully available in Geographic Information System (GIS) software like QGIS.
+
+| Modules  | Method Descriptions |
+| ------------- | ------------- |
+| pycwtmexhat.py  | Quanitfy the wavelet-based curvature of the land surface using two-dimensional continuous wavelet transform (2D-CWT) with a Mexican Hat wevalet |
+| pyfracd.py  | Conduct fractal dimension analysis on the land surface |
+| pyrugostiy.py  | Calculate rugosity indext of the land surface |
+
+In this GitHub repository, each module has a corresponding example Jupyter Notebook file that includes detailed instructions on module usage and brief explanations of the applied theories with cited references. Example raster file data are included in the `~/example/` folder.
+
+There is also an additional Jupyter Notebook, `nonlineardiff_landlab.ipynb`, which leverages the power of [`landlab`](https://landlab.readthedocs.io/en/latest/index.html) to perform forward simulation of landscape smoothing through non-linear hillslope diffusion process.
+
+> [!CAUTION]
+> This package is under developement and has not officially released. Use it with caution.
+
+## Installation
+
+```
+pip install pytopocomplexity
+```
+
+## Citation
+
+The current version is still a pre-release. If you use the current version of `pytopocomplexity` and associated Jupyter Notebooks (including nonlinear diffusion simulation) in your work, please cite the Zenodo DOI:
+* Lai, L. S.-H. (2024). pyTopoComplexity. Zenodo. https://doi.org/10.5281/zenodo.11239338
+
+## Modules for Surface Complexity Measurement
+
+### 1. `pycwtmexhat`: 2D Continuous Wavelet Transform Method
+
+```python
+from pytopocomplexity import pycwtmexhat
+```
+
+The module `pycwtmexhat` uses two-dimensional continuous wavelet transform (2D-CWT) with a Mexican Hat wevalet to measure the topographic complexity (i.e., surface roughness) of a land surface from a Digital Elevation Model (DEM). Such method quanitfy the wavelet-based curvature of the surface, which has been proposed to be a effective geomorphic metric for identifying and estimating the ages of historical deep-seated landslide deposits.
+
+The method and early version of the code was developed by Dr. Adam M. Booth (Portland State Univeristy) in [2009](https://doi.org/10.1016/j.geomorph.2009.02.027), written in MATLAB (Source code available from [Booth's personal website](https://web.pdx.edu/~boothad/tools.html)). This MATLAB code was later revised and adapted by Dr. Sean R. LaHusen (Univeristy of Washington) and Dr. Erich N. Herzig (Univeristy of Washington) in their research ([LaHusen et al., 2020](https://doi.org/10.1126/sciadv.aba6790); [Herzig et al. (2023)](https://doi.org/10.1785/0120230079)). Dr. Larry Syu-Heng Lai (Univeristy of Washington), under the supervision of Dr. Alison R. Duvall (Univeristy of Washington), translated the code into this optimized open-source Python version in 2024.
+
+See `pycwtmexhat_example.ipynb` for detailed explanations and usage instructions.
+
+<p align="center">
+ <img src="image/pycwtmexhat.png" width="100%" height="100%""/>
+</p>
+
+### 2. `pyfracd`: Fractal Dimentsion Analysis
+
+```python
+from pytopocomplexity import pyfracd
+```
+
+The `pyfracd` module calculates local fractal dimensions to assess topographic complexity. It also computes reliability parameters such as the standard error and the coefficient of determination (R²). The development of pyfracd is made possible through the gratitude of Dr. Eulogio Pardo-Iguzquiza, who kindly shared his Fortran code used in his recent publication [Pardo-Igúzquiza and Dowd (2022)](https://doi.org/10.1016/j.icarus.2022.115109).
+
+The local fractal dimension is determined by intersecting the surface within a moving window with four vertical planes in principal geographical directions, simplifying the problem to one-dimensional topographic profiles. The fractal dimension of these profiles is estimated using the variogram method, which models the relationship between dissimilarity and distance using a power-law function. While the fractal dimension value does not directly scale with the degree of surface roughness, smoother or more regular surfaces generally have lower fractal dimension values (closer to 2), whereas surfaces with higher fractal dimension values tend to be more complex or irregular. This method has been applied in terrain analysis for understanding spatial variability in surface roughness, classifying geomorphologic features, uncovering hidden spatial structures, and supporting geomorphological and geological mapping on Earth and other planetary bodies.
+
+See `pyfracd_example.ipynb` for detailed explanations and usage instructions.
+
+<p align="center">
+ <img src="image/pyfracd.png" width="100%" height="100%""/>
+</p>
+
+### 3. `pyrugosity`: Rugosity Index
+
+```python
+from pytopocomplexity import pyrugosity
+```
+
+The module `pyrugosity` measure rugosity index of the land surface, which is widely used to assess landscape structural complexity. The development of this module is influenced by another open-source tool [`Rugosity_Calculator`](https://github.com/drk944/Rugosity_Calculator) created by [drk944](https://github.com/drk944).
+
+The rugosity index is determined as the ratio of the real surface area to the geometric surface area, highlighting smaller-scale variations in surface height. This module adapt triangulated irregular networks method ([Jenness, 2004](https://doi.org/10.2193/0091-7648(2004)032[0829:CLSAFD]2.0.CO;2)), which approximate the surface area of with within each 9 cell as the sum of 8 truncated-triangle area connecting each cell centerpoint with the centerpoints of the 8 surrounding cells. The geometric surface area is assumed to be the planimetric area of the center cell. By definition, the rugosity index is as a minimum value of one (completely flate surface). Typical valuesrange from one to three although larger values are possible in very steep terrains. Such method has been applied in classifying seafloor types by marine geologists and geomorphologist, small-scale hydrodynamics by oceanographers, and studying available habitats in the landscape by ecologists and coral biologists.
+
+See `pyrugosity_example.ipynb` for detailed explanations and usage instructions.
+
+<p align="center">
+ <img src="image/pyrugosity.png" width="100%" height="100%""/>
+</p>
+
+## Forward Simulation of Landscape Smoothing by Nonlinear Hillslope Diffusion Process
+
+In the `~/example/` folder, the Jupyter Notebook file `nonlineardiff_landlab.ipynb` demonstrates the use of [`landlab`](https://landlab.readthedocs.io/en/latest/index.html), an open-source Python framework for simulating landscape evolution, to model topographic smoothing driven by near-surface soil disturbance and downslope soil creep processes. Specifically, this notebook employs the [`TaylorNonLinearDiffuser`](https://landlab.readthedocs.io/en/latest/reference/components/taylor_nonlinear_hillslope_flux.html) component from LandLab, described as one element in the [`terrainBento`](https://github.com/TerrainBento/terrainbento) package (developed by [Barnhart et al. (2019)](https://gmd.copernicus.org/articles/12/1267/2019/), to simulate topographic smoothing over time through non-linear hillslope diffusion processes ([Roering et al., 1999](https://doi.org/10.1029/1998WR900090)).
+
+Users need to define the diffusion coefficient (K) for the simulation. The code will automatically detect the units of the XYZ directions (must be in feet or meters) of the input DEM raster file and convert the unit for K accordingly.
+
+<p align="center">
+<img src="image/NonlinearDiff_demo.gif" width="65%" height="65%" align="center"/>
+</p>
+
+> [!WARNING]
+> There is a known/unresolved stability issue when running `TaylorNonLinearDiffuser` component with a DEM with reprojected coordinate reference system (CRS) through GIS softwares. When using the example DEM, users may only use the pre-reprojected DEM with CRS: NAD83/Washington South (ftUS) (EPSG: 2286) and Z unit in US survey feet (e.g., the DEM files named with *"_f_3ftgrid"* or *"_f_6ftgrid"*).
+
+## Example DEM Raster Files
+
+Along with he example Jupyter Notebook files, this repository include example LiDAR DEM files under `~/example/ExampleDEM/` that cover the area and nearby region of a deep-seated landslide occurred in 2014 at Oso area of the North Fork Stillaguamish River (NFSR) valley, Washington State, USA. The souce LiDAR DEM files were compiled from 'Stillaguamish 2014' and 'Snohoco Hazel 2006' projects that was originally contracted by Washington State Department of Transportation (WSDOT), downloaded from the [Washington Lidar Portal](http://lidarportal.dnr.wa.gov) on April 4, 2024.
+
+A goal of this work allow users to reproduce the research by [Booth et al. (2017)](https://doi.org/10.1002/2016JF003934) and permit comparison of topographic complexity metrics derived from other regions using `pytopocomplexity` package and the `nonlineardiff_landlab.ipynb` simulation tools presented in this repository.
+
+The example DEM raster files have various grid size, coordinate reference system (CRS), and unit of grid value (elevation, Z).
+
+| LiDAR DEM Files  | CRS | XY Grid Size | Z Unit | Descriptions |
+| ------------- | ------------- | ------------- | ------------- | ------------- |
+| Ososlid2014_f_3ftgrid.tif | NAD83/Washington South (ftUS) (EPSG: 2286) | 3.0 [US survey feet] | US survey feet | 2014 Oso Landslide |
+| Ososlid2014_m_3ftgrid.tif | NAD83/Washington South (EPSG: 32149) | ~0.9144 [meters] | meters | 2014 Oso Landslide |
+| Ososlid2014_f_6ftgrid.tif | NAD83/Washington South (ftUS) (EPSG: 2286) | 6.0 [US survey feet] | US survey feet | 2014 Oso Landslide |
+| Ososlid2014_m_6ftgrid.tif | NAD83/Washington South (EPSG: 32149) | ~1.8288 [meters] | meters | 2014 Oso Landslide |
+| Osoarea2014_f_6ftgrid.tif | NAD83/Washington South (ftUS) (EPSG: 2286) | 6.0 [US survey feet] | US survey feet | 2014 Oso Landslide & nearby NFSR valley |
+
+> [!NOTE]
+> When testing the code with the example DEM files, users should place the entire `~/ExampleDEM/` subfolder in the same directory as the Jupyter Notebook files. Both the `pytopocomplexity` package and the `nonlineardiff_landlab.ipynb` land-smoothing modeling tool have the capability to automatically detect the grid spacing and the units of the XYZ directions (must be in feet or meters) of the input DEM raster and compute the results in SI units.
+
+## Requirements
+For `pytopocomplexity` package
+* Python >= 3.10
+* `numpy`
+* `scipy`
+* `rasterio`
+* `dask`
+* `matplotlib`
+* `tqdm`
+* `numba`
+
+Additional packages for Jupyter Notebook examples:
+* `glob`
+* `pandas`
+* `jupyter`
+
+for landscape smoothing simulation
+* `landlab` for landscape smoothing simulation ([User Guide](https://landlab.readthedocs.io/en/latest/index.html))
+  * Used components: `TaylorNonLinearDiffuser`, `esri_ascii`, `imshowhs`
+* `osgeo` [if imported raster is in the geotiff format]
+* `ipywidgets` [optional for interactive visualization]
+
+See also the `environment.yml` file which can be used to create a virtual environment.
+
+## License
+pyTopoComlexity is licensed under the [Apache License 2.0](LICENSE).

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/pyproject.toml

@@ -1,12 +1,12 @@
 [build-system]
-requires = ["setuptools>=42", "wheel"]
+requires = ["setuptools>=45", "wheel", "setuptools_scm[toml]>=6.2"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytopocomplexity"
-version = "0.7.2"
+dynamic = ["version"]
 description = "A package for topographic complexity analysis"
-readme = "README.md"
+readme = "README-pypi.md"
 authors = [{name = "Larry Syu-Heng Lai", email = "larrysyuhenglai@gmail.com"}]
 license = {file = "LICENSE"}
 classifiers = [
@@ -14,20 +14,25 @@ classifiers = [
     "License :: OSI Approved :: Apache Software License",
     "Operating System :: OS Independent",
 ]
+requires-python = ">=3.10"
 dependencies = [
-    "os",
-    "numpy",
-    "rasterio",
-    "matplotlib",
-    "dask",
-    "numba",
-    "scipy",
-    "tqdm",
+    "numpy>=1.20",
+    "scipy>=1.6",
+    "rasterio>=1.2",
+    "dask>=2021.0",
+    "matplotlib>=3.3",
+    "tqdm>=4.0",
+    "numba>=0.53",
+    "gdal>=3.0",
+    "statsmodels>=0.12",
 ]
-requires-python = ">=3.10"
 
 [project.urls]
 Homepage = "https://github.com/GeoLarryLai/pyTopoComplexity"
+Repository = "https://github.com/GeoLarryLai/pyTopoComplexity.git"
 
 [tool.setuptools]
 packages = ["pytopocomplexity"]
+
+[tool.setuptools_scm]
+write_to = "pytopocomplexity/_version.py"

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/pytopocomplexity/pycwtmexhat.py

@@ -1,6 +1,7 @@
 import os
 import numpy as np
 import rasterio
+import dask
 import dask.array as da
 from dask.diagnostics import ProgressBar
 from scipy.signal import fftconvolve, convolve2d
@@ -98,8 +99,21 @@ class pycwtmexhat:
         else:
             raise ValueError("The unit of elevation 'z' must be in feet or meters.")
         
-        C2 = self.conv2_mexh(Z, s, Delta)
-        result = np.abs(C2)
+        # Create a dask array from Z
+        dask_Z = da.from_array(Z, chunks=Z.shape)
+        
+        # Create a delayed version of conv2_mexh
+        delayed_conv2_mexh = dask.delayed(self.conv2_mexh)
+        
+        # Apply the convolution
+        C2 = delayed_conv2_mexh(dask_Z, s, Delta)
+        
+        # Compute the absolute value
+        result = da.abs(C2)
+        
+        # Compute the result with a progress bar
+        with ProgressBar():
+            result = result.compute()
 
         cropedge = np.ceil(s * 4)
         fringeval = int(cropedge)

pytopocomplexity-0.7.4/pytopocomplexity/pyfracd.py

@@ -0,0 +1,259 @@
+import os
+import numpy as np
+import rasterio
+import matplotlib.pyplot as plt
+from numba import jit
+from tqdm.auto import tqdm
+from multiprocessing import Pool, cpu_count
+
+class pyfracd:
+    def __init__(self, window_size=10, chunk_processing=True, chunksize=(512, 512)):
+        self.window_size = window_size
+        self.chunk_processing = chunk_processing
+        self.chunksize = chunksize
+        self.fd2_out = None
+        self.se2_out = None
+        self.r2_out = None
+        self.ft2mUS = 1200/3937  # US survey foot to meter conversion factor
+        self.ft2mInt = 0.3048    # International foot to meter conversion factor
+
+    @staticmethod
+    @jit(nopython=True, fastmath=True)
+    def vario(z, window_size, imo):
+        fac = 1.0 if imo == 1 else np.sqrt(2.0)
+        x = np.arange(1, window_size + 1) * fac
+        y = np.zeros(window_size)
+        npa = np.zeros(window_size, dtype=np.int32)
+
+        for i in range(window_size):
+            diffs = z[:-i-1] - z[i+1:]
+            y[i] = np.sum(diffs**2) / (2 * len(diffs))
+            npa[i] = len(diffs)
+
+        mask = npa > 0
+        y = y[mask]
+        x = x[mask]
+
+        if len(x) < 2:
+            return np.nan, np.nan, np.nan
+
+        x = np.log(x)
+        y = np.log(y)
+
+        n = len(x)
+        sumx = np.sum(x)
+        sumy = np.sum(y)
+        sumx2 = np.sum(x**2)
+        sumxy = np.sum(x * y)
+
+        b = (n * sumxy - sumx * sumy) / (n * sumx2 - sumx**2)
+        a = (sumy - b * sumx) / n
+
+        fd2 = 3.0 - b / 2.0
+        yfit = a + b * x
+        
+        varb = (np.sum((y - yfit)**2) / (n - 2)) / (sumx2 - sumx**2 / n)
+        se2 = np.sqrt(varb) / 2.0
+
+        sum1 = np.sum((yfit - y)**2)
+        sum2 = np.sum((y - np.mean(y))**2)
+        r2 = 1.0 - sum1 / sum2
+
+        return fd2, se2, r2
+    
+    def analyze(self, input_dir, variograms=True):
+        self.input_dir = input_dir
+        with rasterio.open(input_dir) as src:
+            meta = src.meta.copy()
+            Z = src.read(1)
+            Zunit = src.crs.linear_units
+            self.fd2_out = np.zeros((src.height, src.width), dtype=np.float32)
+            self.se2_out = np.zeros((src.height, src.width), dtype=np.float32)
+            self.r2_out = np.zeros((src.height, src.width), dtype=np.float32)
+
+            # Get the cell size
+            cell_size = src.transform[0]
+
+            if any(unit in Zunit.lower() for unit in ["metre", "meter", "meters"]):
+                pass
+            elif any(unit in Zunit.lower() for unit in ["foot", "feet", "ft"]):
+                if any(unit in Zunit.lower() for unit in ["us", "united states"]):
+                    Z = Z * self.ft2mUS
+                    cell_size = cell_size * self.ft2mUS
+                else:
+                    Z = Z * self.ft2mInt
+                    cell_size = cell_size * self.ft2mInt
+            else:
+                raise ValueError("The unit of elevation 'z' must be in feet or meters.")
+
+            if not self.chunk_processing:
+                self._process_non_chunked(Z, src.height, src.width)
+            else:
+                self._process_chunked(Z, src.height, src.width)
+
+            print(f"FD2 MIN : {np.nanmin(self.fd2_out)}")
+            print(f"FD2 MAX : {np.nanmax(self.fd2_out)}")
+            print(f"SE MIN : {np.nanmin(self.se2_out)}")
+            print(f"SE MAX : {np.nanmax(self.se2_out)}")
+            print(f"R2 MIN : {np.nanmin(self.r2_out)}")
+            print(f"R2 MAX : {np.nanmax(self.r2_out)}")
+
+        if variograms:
+            self.plot_sample_variograms(Z)
+
+        # Calculate window size in meters
+        window_size_m = cell_size * self.window_size
+
+        return Z, self.fd2_out, self.se2_out, self.r2_out, meta, window_size_m
+
+    def _process_non_chunked(self, Z, height, width):
+        for j in tqdm(range(height), desc="Analyzing rows"):
+            for i in range(width):
+                results = []
+                # Horizontal slice
+                data = Z[j, max(0, i-self.window_size):min(i+self.window_size+1, width)]
+                if len(data) > self.window_size:
+                    results.append(self.vario(data, self.window_size, 1))
+                # Vertical slice
+                data = Z[max(0, j-self.window_size):min(j+self.window_size+1, height), i]
+                if len(data) > self.window_size:
+                    results.append(self.vario(data, self.window_size, 1))
+                # Diagonal slices
+                for di, dj in [(1, 1), (1, -1)]:
+                    data = []
+                    for k in range(-self.window_size, self.window_size+1):
+                        if 0 <= j+k*dj < height and 0 <= i+k*di < width:
+                            data.append(Z[j+k*dj, i+k*di])
+                    if len(data) > self.window_size:
+                        results.append(self.vario(np.array(data), self.window_size, 2))
+                if results:
+                    fd2, se2, r2 = np.nanmean(results, axis=0)
+                    self.fd2_out[j, i] = np.clip(fd2, 2.0, 3.0)
+                    self.se2_out[j, i] = se2
+                    self.r2_out[j, i] = r2
+
+    def _process_chunked(self, Z, height, width):
+        chunk_height, chunk_width = self.chunksize
+        overlap = self.window_size // 2 + 1
+        chunks = []
+        for j in range(0, height, chunk_height - 2*overlap):
+            for i in range(0, width, chunk_width - 2*overlap):
+                chunk = Z[max(0, j-overlap):min(j+chunk_height+overlap, height),
+                          max(0, i-overlap):min(i+chunk_width+overlap, width)]
+                chunks.append((chunk, i, j))
+
+        with tqdm(total=height, desc="Analyzing rows") as pbar:
+            with Pool(cpu_count()) as pool:
+                for fd2, se2, r2, i, j in pool.imap(self._process_chunk_parallel, chunks):
+                    h, w = fd2.shape
+                    non_overlap_h = max(0, h - 2*overlap)
+                    non_overlap_w = max(0, w - 2*overlap)
+                    self.fd2_out[j:j+non_overlap_h, i:i+non_overlap_w] = fd2[overlap:overlap+non_overlap_h, overlap:overlap+non_overlap_w]
+                    self.se2_out[j:j+non_overlap_h, i:i+non_overlap_w] = se2[overlap:overlap+non_overlap_h, overlap:overlap+non_overlap_w]
+                    self.r2_out[j:j+non_overlap_h, i:i+non_overlap_w] = r2[overlap:overlap+non_overlap_h, overlap:overlap+non_overlap_w]
+                    pbar.update(non_overlap_h)
+
+    def _process_chunk_parallel(self, args):
+        Z, offset_i, offset_j = args
+        fd2_out = np.zeros(Z.shape, dtype=np.float32)
+        se2_out = np.zeros(Z.shape, dtype=np.float32)
+        r2_out = np.zeros(Z.shape, dtype=np.float32)
+
+        for j in range(Z.shape[0]):
+            for i in range(Z.shape[1]):
+                results = []
+                
+                # Horizontal slice
+                data = Z[j, max(0, i-self.window_size):min(i+self.window_size+1, Z.shape[1])]
+                if len(data) > self.window_size:
+                    results.append(self.vario(data, self.window_size, 1))
+
+                # Vertical slice
+                data = Z[max(0, j-self.window_size):min(j+self.window_size+1, Z.shape[0]), i]
+                if len(data) > self.window_size:
+                    results.append(self.vario(data, self.window_size, 1))
+
+                # Diagonal slices
+                for di, dj in [(1, 1), (1, -1)]:
+                    data = []
+                    for k in range(-self.window_size, self.window_size+1):
+                        if 0 <= j+k*dj < Z.shape[0] and 0 <= i+k*di < Z.shape[1]:
+                            data.append(Z[j+k*dj, i+k*di])
+                    if len(data) > self.window_size:
+                        results.append(self.vario(np.array(data), self.window_size, 2))
+
+                if results:
+                    fd2, se2, r2 = np.nanmean(results, axis=0)
+                    fd2_out[j, i] = np.clip(fd2, 2.0, 3.0)
+                    se2_out[j, i] = se2
+                    r2_out[j, i] = r2
+
+        return fd2_out, se2_out, r2_out, offset_i, offset_j
+
+    def plot_sample_variograms(self, Z):
+        middle_row = Z.shape[0] // 2
+        horizontal_slice = Z[middle_row, max(0, Z.shape[1]//2-self.window_size):min(Z.shape[1]//2+self.window_size+1, Z.shape[1])]
+        self.plot_variogram(horizontal_slice, imo=1, title="Horizontal Variogram (Middle Row)")
+        
+        middle_col = Z.shape[1] // 2
+        vertical_slice = Z[max(0, Z.shape[0]//2-self.window_size):min(Z.shape[0]//2+self.window_size+1, Z.shape[0]), middle_col]
+        self.plot_variogram(vertical_slice, imo=1, title="Vertical Variogram (Middle Column)")
+        
+        diagonal_slice = [Z[i, i] for i in range(max(0, Z.shape[0]//2-self.window_size), min(Z.shape[0]//2+self.window_size+1, min(Z.shape)))]
+        self.plot_variogram(diagonal_slice, imo=2, title="Diagonal Variogram")
+
+    def plot_variogram(self, z, imo, title=None):
+        z = np.array(z)
+        fac = 1.0 if imo == 1 else np.sqrt(2.0)
+        x = np.arange(1, self.window_size + 1) * fac
+        y = np.zeros(self.window_size)
+        npa = np.zeros(self.window_size, dtype=np.int32)
+
+        for i in range(self.window_size):
+            diffs = z[:-i-1] - z[i+1:]
+            y[i] = np.sum(diffs**2) / (2 * len(diffs))
+            npa[i] = len(diffs)
+
+        mask = npa > 0
+        y = y[mask]
+        x = x[mask]
+
+        if len(x) < 2:
+            print("Not enough data points for variogram plot")
+            return
+
+        plt.figure(figsize=(5, 3))
+        plt.scatter(np.log(x), np.log(y), color='blue', label='Data')
+        
+        coef = np.polyfit(np.log(x), np.log(y), 1)
+        poly1d_fn = np.poly1d(coef)
+        plt.plot(np.log(x), poly1d_fn(np.log(x)), '--r', label='Fitted Line')
+
+        plt.xlabel('Log(Lag Distance)')
+        plt.ylabel('Log(Semivariance)')
+        plt.title(title or 'Variogram Plot')
+        plt.legend()
+        plt.grid(True)
+        plt.show()
+
+        slope = coef[0]
+        fd2 = 3.0 - slope / 2.0
+        print(f"Estimated Fractal Dimension: {fd2}")
+
+    def export_results(self, fd2_output_dir, se2_output_dir, r2_output_dir, meta):
+        if meta is None:
+            raise ValueError("Metadata is missing. Cannot export the result.")
+        
+        meta.update(dtype=rasterio.float32, count=1, compress='deflate', bigtiff='IF_SAFER')
+
+        with rasterio.open(fd2_output_dir, 'w', **meta) as dst:
+            dst.write(self.fd2_out.astype(rasterio.float32), 1)
+        print(f"Processed result saved to {os.path.basename(fd2_output_dir)}")
+
+        with rasterio.open(se2_output_dir, 'w', **meta) as dst:
+            dst.write(self.se2_out.astype(rasterio.float32), 1)
+        print(f"Processed result saved to {os.path.basename(se2_output_dir)}")
+
+        with rasterio.open(r2_output_dir, 'w', **meta) as dst:
+            dst.write(self.r2_out.astype(rasterio.float32), 1)
+        print(f"Processed result saved to {os.path.basename(r2_output_dir)}")

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/pytopocomplexity/pyrugosity.py

@@ -8,7 +8,7 @@ from scipy.ndimage import generic_filter
 from tqdm.auto import tqdm
 
 class pyrugosity:
-    def __init__(self, chunk_processing=False, chunksize=(512, 512)):
+    def __init__(self, chunk_processing=True, chunksize=(512, 512)):
         self.ft2mUS = 1200/3937  # US survey foot to meter conversion factor
         self.ft2mInt = 0.3048    # International foot to meter conversion factor
         self.chunk_processing = chunk_processing

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/pytopocomplexity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: pytopocomplexity
-Version: 0.7.2
+Version: 0.7.4
 Summary: A package for topographic complexity analysis
 Home-page: https://github.com/GeoLarryLai/pyTopoComplexity
 Author: Larry Syu-Heng Lai
@@ -208,6 +208,7 @@ License:                                  Apache License
            limitations under the License.
         
 Project-URL: Homepage, https://github.com/GeoLarryLai/pyTopoComplexity
+Project-URL: Repository, https://github.com/GeoLarryLai/pyTopoComplexity.git
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Operating System :: OS Independent
@@ -215,7 +216,7 @@ Requires-Python: >=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 
-# pyTopoComlexity (v0.7.2)
+# pyTopoComlexity (v0.7.4)
 [![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.11239338.svg)](https://doi.org/10.5281/zenodo.11239338)
 
 `pytopocomplexity` is an open-source Python package designed to measure the topographic complexity (i.e., surface roughness) of land surfaces using digital elevation model (DEM) data. This package includes modules for three methods commonly used in the fields of geomorphology and oceanography for measuring topographic complexity, which are not fully available in Geographic Information System (GIS) software like QGIS.
@@ -267,7 +268,6 @@ The rugosity index is determined as the ratio of the real surface area to the ge
 ## Requirements
 For `pytopocomplexity` package
 * Python >= 3.10
-* `os`
 * `numpy`
 * `scipy`
 * `rasterio`

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/pytopocomplexity.egg-info/SOURCES.txt

@@ -1,4 +1,5 @@
 LICENSE
+README-pypi.md
 README.md
 pyproject.toml
 setup.py

pytopocomplexity-0.7.4/pytopocomplexity.egg-info/requires.txt

@@ -0,0 +1,9 @@
+numpy>=1.20
+scipy>=1.6
+rasterio>=1.2
+dask>=2021.0
+matplotlib>=3.3
+tqdm>=4.0
+numba>=0.53
+gdal>=3.0
+statsmodels>=0.12

{pytopocomplexity-0.7.2 → pytopocomplexity-0.7.4}/setup.py

@@ -1,11 +1,11 @@
 from setuptools import setup, find_packages
 
-with open("README.md", "r", encoding="utf-8") as fh:
+with open("README-pypi.md", "r", encoding="utf-8") as fh:
     long_description = fh.read()
 
 setup(
     name="pytopocomplexity",
-    version="0.7.2",
+    version="0.7.4",
     author="Larry Syu-Heng Lai",
     author_email="larrysyuhenglai@gmail.com",
     description="A package for topographic complexity analysis",
@@ -20,13 +20,15 @@ setup(
     ],
     python_requires=">=3.10",
     install_requires=[
-        "os",
-        "numpy",
-        "rasterio",
-        "matplotlib",
-        "dask",
-        "numba",
-        "scipy",
-        "tqdm",
+        "numpy>=1.20",
+        "scipy>=1.6",
+        "rasterio>=1.2",
+        "dask>=2021.0",
+        "matplotlib>=3.3",
+        "tqdm>=4.0",
+        "numba>=0.53",
+        "gdal>=3.0",
+        "statsmodels>=0.12",
     ],
-)
+    license="Apache License 2.0",
+)

pytopocomplexity-0.7.2/pytopocomplexity/pyfracd.py

@@ -1,185 +0,0 @@
-import os
-import numpy as np
-import rasterio
-import matplotlib.pyplot as plt
-from numba import jit
-from scipy.ndimage import generic_filter
-from tqdm.auto import tqdm
-
-class pyfracd:
-    def __init__(self, npas=10):
-        self.npas = npas
-        self.fd2_out = None
-        self.se2_out = None
-        self.r2_out = None
-        self.ft2mUS = 1200/3937  # US survey foot to meter conversion factor
-        self.ft2mInt = 0.3048    # International foot to meter conversion factor
-
-    @staticmethod
-    @jit(nopython=True)
-    def vario(z, npas, imo):
-        fac = 1.0 if imo == 1 else np.sqrt(2.0)
-        x = np.arange(1, npas + 1) * fac
-        y = np.zeros(npas)
-        npa = np.zeros(npas, dtype=np.int32)
-
-        for i in range(npas):
-            diffs = z[:-i-1] - z[i+1:]
-            y[i] = np.sum(diffs**2) / (2 * len(diffs))
-            npa[i] = len(diffs)
-
-        mask = npa > 0
-        y = y[mask]
-        x = x[mask]
-
-        if len(x) < 2:
-            return np.nan, np.nan, np.nan
-
-        x = np.log(x)
-        y = np.log(y)
-
-        n = len(x)
-        sumx = np.sum(x)
-        sumy = np.sum(y)
-        sumx2 = np.sum(x**2)
-        sumxy = np.sum(x * y)
-
-        b = (n * sumxy - sumx * sumy) / (n * sumx2 - sumx**2)
-        a = (sumy - b * sumx) / n
-
-        fd2 = 3.0 - b / 2.0
-        yfit = a + b * x
-        
-        varb = (np.sum((y - yfit)**2) / (n - 2)) / (sumx2 - sumx**2 / n)
-        se2 = np.sqrt(varb) / 2.0
-
-        sum1 = np.sum((yfit - y)**2)
-        sum2 = np.sum((y - np.mean(y))**2)
-        r2 = 1.0 - sum1 / sum2
-
-        return fd2, se2, r2
-    
-    def analyze(self, input_dir, variograms=True):
-        with rasterio.open(input_dir) as src:
-            meta = src.meta.copy()
-            Z = src.read(1)
-            Zunit = src.crs.linear_units
-            self.fd2_out = np.zeros((src.height, src.width), dtype=np.float32)
-            self.se2_out = np.zeros((src.height, src.width), dtype=np.float32)
-            self.r2_out = np.zeros((src.height, src.width), dtype=np.float32)
-
-            if any(unit in Zunit.lower() for unit in ["metre", "meter", "meters"]):
-                pass
-            elif any(unit in Zunit.lower() for unit in ["foot", "feet", "ft"]):
-                if any(unit in Zunit.lower() for unit in ["us", "united states"]):
-                    Z = Z * self.ft2mUS
-                else:
-                    Z = Z * self.ft2mInt
-            else:
-                raise ValueError("The unit of elevation 'z' must be in feet or meters.")
-
-            for j in tqdm(range(src.height), desc="Analyzing rows"):
-                for i in range(src.width):
-                    results = []
-                    
-                    data = Z[j, max(0, i-20):min(i+21, src.width)]
-                    if len(data) > self.npas:
-                        results.append(self.vario(data, self.npas, 1))
-
-                    data = Z[max(0, j-20):min(j+21, src.height), i]
-                    if len(data) > self.npas:
-                        results.append(self.vario(data, self.npas, 1))
-
-                    for di, dj in [(1, 1), (1, -1)]:
-                        data = []
-                        for k in range(-14, 15):
-                            if 0 <= j+k*dj < src.height and 0 <= i+k*di < src.width:
-                                data.append(Z[j+k*dj, i+k*di])
-                        if len(data) > self.npas:
-                            results.append(self.vario(np.array(data), self.npas, 2))
-
-                    if results:
-                        fd2, se2, r2 = np.nanmean(results, axis=0)
-                        self.fd2_out[j, i] = np.clip(fd2, 2.0, 3.0)
-                        self.se2_out[j, i] = se2
-                        self.r2_out[j, i] = r2
-            
-            print(f"FD2 MIN : {np.nanmin(self.fd2_out)}")
-            print(f"FD2 MAX : {np.nanmax(self.fd2_out)}")
-            print(f"SE MIN : {np.nanmin(self.se2_out)}")
-            print(f"SE MAX : {np.nanmax(self.se2_out)}")
-            print(f"R2 MIN : {np.nanmin(self.r2_out)}")
-            print(f"R2 MAX : {np.nanmax(self.r2_out)}")
-
-        if variograms:
-            self.plot_sample_variograms(Z)
-
-        return Z, self.fd2_out, self.se2_out, self.r2_out, meta
-
-    def plot_variogram(self, z, imo, title=None):
-        z = np.array(z)
-        fac = 1.0 if imo == 1 else np.sqrt(2.0)
-        x = np.arange(1, self.npas + 1) * fac
-        y = np.zeros(self.npas)
-        npa = np.zeros(self.npas, dtype=np.int32)
-
-        for i in range(self.npas):
-            diffs = z[:-i-1] - z[i+1:]
-            y[i] = np.sum(diffs**2) / (2 * len(diffs))
-            npa[i] = len(diffs)
-
-        mask = npa > 0
-        y = y[mask]
-        x = x[mask]
-
-        if len(x) < 2:
-            print("Not enough data points for variogram plot")
-            return
-
-        plt.figure(figsize=(5, 3))
-        plt.scatter(np.log(x), np.log(y), color='blue', label='Data')
-        
-        coef = np.polyfit(np.log(x), np.log(y), 1)
-        poly1d_fn = np.poly1d(coef)
-        plt.plot(np.log(x), poly1d_fn(np.log(x)), '--r', label='Fitted Line')
-
-        plt.xlabel('Log(Lag Distance)')
-        plt.ylabel('Log(Semivariance)')
-        plt.title(title or 'Variogram Plot')
-        plt.legend()
-        plt.grid(True)
-        plt.show()
-
-        slope = coef[0]
-        fd2 = 3.0 - slope / 2.0
-        print(f"Estimated Fractal Dimension: {fd2}")
-
-    def plot_sample_variograms(self, Z):
-        middle_row = Z.shape[0] // 2
-        horizontal_slice = Z[middle_row, max(0, Z.shape[1]//2-20):min(Z.shape[1]//2+21, Z.shape[1])]
-        self.plot_variogram(horizontal_slice, imo=1, title="Horizontal Variogram (Middle Row)")
-        
-        middle_col = Z.shape[1] // 2
-        vertical_slice = Z[max(0, Z.shape[0]//2-20):min(Z.shape[0]//2+21, Z.shape[0]), middle_col]
-        self.plot_variogram(vertical_slice, imo=1, title="Vertical Variogram (Middle Column)")
-        
-        diagonal_slice = [Z[i, i] for i in range(max(0, Z.shape[0]//2-14), min(Z.shape[0]//2+15, min(Z.shape)))]
-        self.plot_variogram(diagonal_slice, imo=2, title="Diagonal Variogram")
-
-    def export_results(self, fd2_output_dir, se2_output_dir, r2_output_dir, meta):
-        if meta is None:
-            raise ValueError("Metadata is missing. Cannot export the result.")
-        
-        meta.update(dtype=rasterio.float32, count=1, compress='deflate', bigtiff='IF_SAFER')
-
-        with rasterio.open(fd2_output_dir, 'w', **meta) as dst:
-            dst.write(self.fd2_out.astype(rasterio.float32), 1)
-        print(f"Processed result saved to {os.path.basename(fd2_output_dir)}")
-
-        with rasterio.open(se2_output_dir, 'w', **meta) as dst:
-            dst.write(self.se2_out.astype(rasterio.float32), 1)
-        print(f"Processed result saved to {os.path.basename(se2_output_dir)}")
-
-        with rasterio.open(r2_output_dir, 'w', **meta) as dst:
-            dst.write(self.r2_out.astype(rasterio.float32), 1)
-        print(f"Processed result saved to {os.path.basename(r2_output_dir)}")

pytopocomplexity-0.7.2/pytopocomplexity.egg-info/requires.txt

@@ -1,8 +0,0 @@
-os
-numpy
-rasterio
-matplotlib
-dask
-numba
-scipy
-tqdm