updated calculate_semivariance() function

Author: SimonMolinsky

CHANGELOG.rst

@@ -1,6 +1,15 @@
 Changes - from version >= 1.x
 =============================
 
+2025-11-0
+----------
+
+**version 1.2.0**
+
+* [enhancement] `Blocks` has the new parameters `values` and `geometries`, that might be provided instead of `ds` parameter
+* [enhancement] `calculate_semivariance()` function has the new parameters `values` and `geometries`, that might be provided instead of `ds` parameter
+* [enhancement] `interpolate_points()` function has the new parameters `values` and `geometries`, that might be provided instead of `ds` parameter
+
 2025-10-11
 ----------
 

src/pyinterpolate/core/data_models/points.py

@@ -9,6 +9,8 @@
 from pydantic import field_validator, BaseModel, ConfigDict
 from shapely.geometry import Point
 
+from transform.geo import join_geometry_and_values
+
 
 class RawPoints(BaseModel):
     """
@@ -100,9 +102,19 @@ class VariogramPoints:
     def __init__(self,
                  points: Union[
                      List, Tuple, ndarray, GeoDataFrame, GeoSeries, DataFrame
-                 ]
+                 ] = None,
+                 geometries: Union[
+                     List, Tuple, ndarray, GeoDataFrame, GeoSeries, DataFrame
+                 ] = None,
+                 values: Union[
+                     List, Tuple, ndarray, DataFrame, Series
+                 ] = None
                  ):
 
+        if points is None:
+            # Try to create points
+            points = join_geometry_and_values(geometries, values)
+
         # validate
         self.points = cast(RawPoints, points)
 
@@ -119,9 +131,14 @@ def transform(self):
             if len(cols) == 2:
                 ds = self.points.copy()
                 # geometry | values
-                ds['x'] = ds[cols[0]].x
-                ds['y'] = ds[cols[0]].y
-                self.points = ds[['x', 'y', cols[1]]].values
+                try:
+                    ds['x'] = ds[cols[0]].x
+                    ds['y'] = ds[cols[0]].y
+                    self.points = ds[['x', 'y', cols[1]]].values
+                except AttributeError:
+                    ds['x'] = ds[cols[1]].x
+                    ds['y'] = ds[cols[1]].y
+                    self.points = ds[['x', 'y', cols[0]]].values
             elif len(cols) == 3:
                 self.points = self.points.values
         elif isinstance(self.points, DataFrame):

src/pyinterpolate/semivariogram/experimental/experimental_semivariogram.py

@@ -1,5 +1,6 @@
 import warnings
 from typing import Union, List, Any, Dict
+from numpy.typing import ArrayLike
 
 import numpy as np
 
@@ -16,21 +17,32 @@
 from pyinterpolate.semivariogram.lags.lags import get_lags
 
 
-def calculate_semivariance(ds: Union[np.ndarray, VariogramPoints],
+def calculate_semivariance(ds: Union[ArrayLike, VariogramPoints] = None,
+                           values: ArrayLike = None,
+                           geometries: ArrayLike = None,
                            step_size: float = None,
                            max_range: float = None,
                            direction: float = None,
                            tolerance: float = None,
-                           custom_bins: Union[np.ndarray, Any] = None,
-                           custom_weights: np.ndarray = None) -> np.ndarray:
+                           custom_bins: Union[ArrayLike, Any] = None,
+                           custom_weights: ArrayLike = None) -> np.ndarray:
     """
     Calculates experimental semivariance.
 
     Parameters
     ----------
-    ds : numpy array
+    ds : ArrayLike, optional
         ``[x, y, value]``
 
+    values : ArrayLike, optional
+        Aggregated values of each block. Optional parameter, if not
+        given then ``ds`` must be provided.
+
+    geometries : ArrayLike, optional
+        Array or similar structure with geometries. It must have the same
+        length as ``values``. Optional parameter, if not given then ``ds``
+        must be provided. Those must be point geometries!
+
     step_size : float
         The fixed distance between lags grouping point neighbors.
 
@@ -58,17 +70,17 @@ def calculate_semivariance(ds: Union[np.ndarray, VariogramPoints],
         * The baseline point is at a center of the ellipse.
         * The ``tolerance == 1`` creates an omnidirectional semivariogram.
 
-    custom_bins : numpy array, optional
+    custom_bins : ArrayLike, optional
         Custom bins for semivariance calculation. If provided, then parameter
         ``step_size`` is ignored and ``max_range`` is set to the final bin
         distance.
 
-    custom_weights : numpy array, optional
+    custom_weights : ArrayLike, optional
         Custom weights assigned to points.
 
     Returns
     -------
-    semivariance : numpy array
+    semivariance : ArrayLike
         ``[lag, semivariance, number of point pairs]``
 
     Notes
@@ -184,10 +196,11 @@ def calculate_semivariance(ds: Union[np.ndarray, VariogramPoints],
     [ 1.     4.625 24.   ]
     """
 
-    # Validation
     # Validate points
     if not isinstance(ds, VariogramPoints):
-        ds = VariogramPoints(points=ds)
+        ds = VariogramPoints(points=ds,
+                             geometries=geometries,
+                             values=values)
 
     # Validate bins
     validate_bins(step_size, max_range, custom_bins)

tests/test_semivariogram/test_experimental_semivariance.py

@@ -168,3 +168,50 @@ def test_weighted_directional_semivariogram():
     )
 
     assert isinstance(semivariance, np.ndarray)
+
+
+def test_omnidirectional_semivariogram_values_geometry_inputs():
+    import geopandas as gpd
+
+
+    REFERENCE_INPUT = np.array([
+        [0, 0, 8],
+        [1, 0, 6],
+        [2, 0, 4],
+        [3, 0, 3],
+        [4, 0, 6],
+        [5, 0, 5],
+        [6, 0, 7],
+        [7, 0, 2],
+        [8, 0, 8],
+        [9, 0, 9],
+        [10, 0, 5],
+        [11, 0, 6],
+        [12, 0, 3]
+    ])
+    STEP_SIZE = 1
+    MAX_RANGE = 4
+
+    GEOMETRY = gpd.points_from_xy(
+        x=REFERENCE_INPUT[:, 0], y=REFERENCE_INPUT[:, 1]
+    )
+
+    semivariance = calculate_semivariance(
+        ds=None,
+        values=REFERENCE_INPUT[:, -1],
+        geometries=GEOMETRY,
+        step_size=STEP_SIZE,
+        max_range=MAX_RANGE
+    )
+
+    expected_output = np.array(
+        [
+            [1., 4.625, 24.],
+            [2., 5.22727273, 22.],
+            [3., 6., 20.]
+        ]
+    )
+
+    assert isinstance(semivariance, np.ndarray)
+    assert semivariance.shape == (3, 3)
+    assert np.allclose(semivariance, expected_output)