[enh] Blocks object may use separate geometry and values as input parameters + tests

Author: SimonMolinsky

src/pyinterpolate/core/data_models/blocks.py

@@ -22,21 +22,32 @@
 
 from pyinterpolate.distance.angular import calc_angles
 from pyinterpolate.distance.point import point_distance
-from pyinterpolate.transform.geo import points_to_lon_lat, largest_geometry
+from pyinterpolate.transform.geo import points_to_lon_lat, largest_geometry, \
+    join_geometry_and_values
 
 
-# TODO: if multipolygon then get coordinates /
-#       representative points from the largest block - as an option
 class Blocks:
     """Class represents aggregated blocks data.
 
     Parameters
     ----------
-    ds : gpd.GeoDataFrame
-        Dataset with block values.
+    ds : gpd.GeoDataFrame, optional
+        Dataset with block values. Must be provided if ``values`` and
+        ``geometry`` parameters are not given.
 
-    value_column_name : Any
-        Name of the column with block rates.
+    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.
+
+    value_column_name : Any, optional
+        Name of the column with block rates. Must be provided when
+        the ``ds`` parameter is given, otherwise it is set to 'values' if
+        not provided.
 
     geometry_column_name : Any, default = 'geometry'
         Name of the column with a block geometry.
@@ -177,16 +188,18 @@ class Blocks:
     """
 
     def __init__(self,
-                 ds: gpd.GeoDataFrame,
-                 value_column_name,
-                 geometry_column_name='geometry',
-                 index_column_name=None,
-                 representative_points_column_name=None,
-                 representative_points_from_centroid=False,
-                 representative_points_from_random_sample=False,
-                 representative_points_from_largest_area=True,
-                 distances_between_representative_points=True,
-                 angles_between_representative_points=False):
+                 ds: gpd.GeoDataFrame = None,
+                 values: ArrayLike = None,
+                 geometries: ArrayLike = None,
+                 value_column_name: str = None,
+                 geometry_column_name = 'geometry',
+                 index_column_name = None,
+                 representative_points_column_name = None,
+                 representative_points_from_centroid = False,
+                 representative_points_from_random_sample = False,
+                 representative_points_from_largest_area = True,
+                 distances_between_representative_points = True,
+                 angles_between_representative_points = False):
 
         # Helper params
         self._lon_col_name = 'lon'
@@ -202,7 +215,15 @@ def __init__(self,
         self._rep_ps_sample = representative_points_from_random_sample
         self._rep_ps_largest_area = representative_points_from_largest_area
 
-        self.ds = ds.copy(deep=True)
+        if ds is not None:
+            self.ds = ds.copy(deep=True)
+        else:
+            if value_column_name is None:
+                value_column_name = 'values'
+            self.ds = join_geometry_and_values(geometry=geometries,
+                                               values=values,
+                                               values_column_name=value_column_name)
+
         self.value_column_name = value_column_name
         self.index_column_name = index_column_name
         self.geometry_column_name = geometry_column_name

src/pyinterpolate/transform/geo.py

@@ -1,4 +1,5 @@
 from typing import Tuple, Union
+from numpy.typing import ArrayLike
 
 import geopandas as gpd
 import numpy as np
@@ -34,6 +35,55 @@ def largest_geometry(geometry: MultiPolygon) -> Polygon:
     return poly
 
 
+def join_geometry_and_values(geometry,
+                             values,
+                             geometry_column_name: str = 'geometry',
+                             values_column_name: str = 'values') -> gpd.GeoDataFrame:
+    """
+    Function creates single object from geometries and aggregated values.
+
+    Parameters
+    ----------
+    geometry : ArrayLike
+
+    values : ArrayLike
+
+    geometry_column_name : str, default = 'geometry'
+
+    values_column_name : str, default = 'value'
+
+    Returns
+    -------
+    : gpd.GeoDataFrame
+    """
+
+    if len(geometry) != len(values):
+        raise ValueError(
+            'Number of geometries must be equal to number of values'
+        )
+
+    if isinstance(values, pd.Series):
+        values = values.values
+    elif isinstance(values, pd.DataFrame):
+        val_column_name = values.columns[0]
+        values = values[val_column_name].values
+
+    if isinstance(geometry, pd.DataFrame):
+        geom_column_name = geometry.columns[0]
+        geometry = geometry[geom_column_name].values
+
+    if isinstance(geometry, gpd.GeoDataFrame):
+        gdf = geometry.copy(deep=True)
+        gdf[values_column_name] = values
+    else:
+        gdf = gpd.GeoDataFrame(
+            values, columns=[values_column_name], geometry=geometry
+        )
+        gdf.columns = [values_column_name, geometry_column_name]
+
+    return gdf
+
+
 def points_to_lon_lat(points: gpd.GeoSeries) -> Tuple:
     """
     Function transform GeoSeries to lon / lat series.

tests/test_core/test_blocks_model.py

@@ -206,3 +206,39 @@ def test_block_index_outputs():
 
     real_value = block.block_real_value(block_id=block_id)
     assert isinstance(real_value, float)
+
+
+def test_geometry_values_separated():
+
+    # Pass as two Series
+    geometries = CANCER_DATA['ds'][CANCER_DATA['geometry_column_name']]
+    values = CANCER_DATA['ds'][CANCER_DATA['value_column_name']]
+    block = Blocks(
+        geometries=geometries,
+        values=values
+    )
+    assert isinstance(block.block_data, np.ndarray)
+    assert block.block_data.shape[0] == len(values)
+    assert block.block_data.shape[1] == 3
+
+    # Pass as two DataFrames
+    geometries = pd.DataFrame(CANCER_DATA['ds'][CANCER_DATA['geometry_column_name']])
+    values = pd.DataFrame(CANCER_DATA['ds'][CANCER_DATA['value_column_name']])
+    block = Blocks(
+        geometries=geometries,
+        values=values
+    )
+    assert isinstance(block.block_data, np.ndarray)
+    assert block.block_data.shape[0] == len(values)
+    assert block.block_data.shape[1] == 3
+
+    # Pass as two arrays
+    geometries = CANCER_DATA['ds'][CANCER_DATA['geometry_column_name']].values
+    values = CANCER_DATA['ds'][CANCER_DATA['value_column_name']].values
+    block = Blocks(
+        geometries=geometries,
+        values=values
+    )
+    assert isinstance(block.block_data, np.ndarray)
+    assert block.block_data.shape[0] == len(values)
+    assert block.block_data.shape[1] == 3