idw - known_values and known_geometries parameters, tests

Author: SimonMolinsky

CHANGELOG.rst

@@ -8,10 +8,10 @@ Changes - from version >= 1.x
 
 * [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
-* [enhancement] `validate_kriging()` function has the new parameters `values` and `geometries`, that might be provided instead of `ds` parameter
+* [enhancement] `interpolate_points()` function has the new parameters `known_values` and `known_geometries`, that might be provided instead of the `known_locations` parameter
+* [enhancement] `validate_kriging()` function has the new parameters `known_values` and `known_geometries`, that might be provided instead of the `known_locations` parameter
 * [enhancement] `validate_kriging()` has new parameter: `progress_bar` that controls `tqdm` progress bar
-* 
+* [enhancement] `inverse_distance_weighting()` function has the new parameters `known_values` and `known_geometries`, that might be provided instead of the `known_locations` parameter
 
 2025-10-11
 ----------

src/pyinterpolate/idw/idw.py

@@ -8,16 +8,19 @@
 TODO
 - eval with IDW
 """
-from typing import Iterable
+from numpy.typing import ArrayLike
 
 import numpy as np
 
 from pyinterpolate.core.data_models.points import VariogramPoints
 from pyinterpolate.distance.point import point_distance
+from transform.geo import geometry_and_values_array
 
 
-def inverse_distance_weighting(known_locations: np.ndarray,
-                               unknown_location: Iterable,
+def inverse_distance_weighting(unknown_location: ArrayLike,
+                               known_locations: ArrayLike = None,
+                               known_values: ArrayLike = None,
+                               known_geometries: ArrayLike = None,
                                no_neighbors=-1,
                                power=2.) -> float:
     """
@@ -26,11 +29,6 @@ def inverse_distance_weighting(known_locations: np.ndarray,
 
     Parameters
     ----------
-    known_locations : numpy array
-        The MxN array, where **M** is a number of rows (points) and **N**
-        is the number of columns, where the last column represents a value
-        observed in a known point. (It could be **(N-1)**-dimensional data).
-
     unknown_location : Iterable
         Array or list with coordinates of the unknown point.
         Its length is N-1 (number of dimensions). The unknown
@@ -39,6 +37,18 @@ def inverse_distance_weighting(known_locations: np.ndarray,
         is added once - vector of points ``[x, y]``
         becomes ``[[x, y]]`` for 2-dimensional data.
 
+    known_locations : numpy array, optional
+        The known locations: ``[x, y, value]``.
+
+    known_values : ArrayLike, optional
+        Observation in the i-th geometry (from ``known_geometries``). Optional
+        parameter, if not given then ``known_locations`` must be provided.
+
+    known_geometries : ArrayLike, optional
+        Array or similar structure with geometries. It must have the same
+        length as ``known_values``. Optional parameter, if not given then
+        ``known_locations`` must be provided. Point type geometry.
+
     no_neighbors : int, default = -1
         If default value **(-1)** then all known points will be used to
         estimate value at the unknown location.
@@ -68,6 +78,13 @@ def inverse_distance_weighting(known_locations: np.ndarray,
     if power < 0:
         raise ValueError('Power cannot be smaller than 0')
 
+    # Get known locations
+    if known_locations is None:
+        known_locations = geometry_and_values_array(
+            geometry=known_geometries,
+            values=known_values
+        )
+
     # Check known points parameter
     # Check if known locations are in the right format
     known_locations = VariogramPoints(known_locations).points

src/pyinterpolate/transform/geo.py

@@ -32,17 +32,25 @@ def geometry_and_values_array(geometry,
     arr = []
 
     is_point = isinstance(geometry[0], Point)
+    greater_than_2_dims = len(geometry[0]) > 2
 
-    if is_point:
+    if greater_than_2_dims:
         for idx, rec in enumerate(geometry):
-            arr.append(
-                [rec.x, rec.y, values[idx]]
-            )
+            rlist = rec.tolist()
+            rlist.append(values[idx])
+            arr.append(rlist)
     else:
-        for idx, rec in enumerate(geometry):
-            arr.append(
-                [rec[0], rec[1], values[idx]]
-            )
+        if is_point:
+            for idx, rec in enumerate(geometry):
+                arr.append(
+                    [rec.x, rec.y, values[idx]]
+                )
+        else:
+            for idx, rec in enumerate(geometry):
+                arr.append(
+                    [rec[0], rec[1], values[idx]]
+                )
+
     return np.array(arr)
 
 
@@ -217,5 +225,3 @@ def reproject_flat(ds: Union[pd.DataFrame, np.ndarray],
     mpol = MultiPolygon([pol1, pol2])
 
     assert largest_geometry(mpol) == pol2
-
-

tests/test_idw/test_idw.py

@@ -8,17 +8,18 @@ def test_idw_2d():
     pos1 = [[11, 1, 1], [23, 2, 2], [33, 3, 3], [14, 44, 4], [13, 10, 9], [12, 55, 35], [11, 9, 7]]
     pos2 = [[11, 1, 1], [23, 2, 2], [33, 3, 3], [14, 44, 4], [10, 10, 999], [12, 55, 35], [11, 9, 7]]
 
-    u_val1 = inverse_distance_weighting(np.array(pos1),
-                                        unknown_pos,
-                                        -1, 0.5)
+    u_val1 = inverse_distance_weighting(unknown_pos,
+                                        known_locations=np.array(pos1),
+                                        no_neighbors=-1,
+                                        power=0.5)
 
-    u_val2 = inverse_distance_weighting(np.array(pos1),
-                                        np.array(unknown_pos),
-                                        3)
+    u_val2 = inverse_distance_weighting(np.array(unknown_pos),
+                                        known_locations=np.array(pos1),
+                                        no_neighbors=3)
 
-    u_val3 = inverse_distance_weighting(np.array(pos2),
-                                        np.array(unknown_pos),
-                                        3)
+    u_val3 = inverse_distance_weighting(np.array(unknown_pos),
+                                        known_locations=np.array(pos2),
+                                        no_neighbors=3)
 
     # Test case 1: u_val1 > u_val2 > 7
 
@@ -39,6 +40,27 @@ def test_multidimensional_idw():
     coords = np.array(coords)
     u_coords = [[0, 1, 2]]
 
-    res = inverse_distance_weighting(coords, u_coords, 2, 10)
+    res = inverse_distance_weighting(u_coords,
+                                     known_locations=coords,
+                                     no_neighbors=2,
+                                     power=10)
+
+    assert res == 1
+
+
+def test_separate_geometry_idw():
+    coords = [[0, 0, 0, 1],
+              [1, 1, 1, 1],
+              [2, 2, 2, 1],
+              [5, 5, 5, 1]]
+
+    coords = np.array(coords)
+    u_coords = [[0, 1, 2]]
+
+    res = inverse_distance_weighting(u_coords,
+                                     known_values=coords[:, -1],
+                                     known_geometries=coords[:, :-1],
+                                     no_neighbors=2,
+                                     power=10)
 
     assert res == 1