openforis-whisp 2.0.0b1__py3-none-any.whl → 2.0.0b2__py3-none-any.whl

openforis_whisp/__init__.py

@@ -43,6 +43,7 @@ from openforis_whisp.stats import (
     whisp_formatted_stats_ee_to_geojson,
     whisp_formatted_stats_geojson_to_df,
     whisp_formatted_stats_geojson_to_geojson,
+    set_point_geometry_area_to_zero,
     convert_iso3_to_iso2,
 )
 
@@ -71,4 +72,4 @@ from openforis_whisp.data_conversion import (
 
 from openforis_whisp.risk import whisp_risk, detect_unit_type
 
-from openforis_whisp.utils import get_example_data_path
+from openforis_whisp.utils import get_example_data_path, generate_test_polygons

openforis_whisp/data_conversion.py

@@ -42,6 +42,17 @@ def convert_geojson_to_ee(
         # Use GeoPandas to read the file and handle CRS
         gdf = gpd.read_file(file_path)
 
+        # NEW: Handle problematic data types before JSON conversion
+        for col in gdf.columns:
+            if col != gdf.geometry.name:  # Skip geometry column
+                # Handle datetime/timestamp columns
+                if pd.api.types.is_datetime64_any_dtype(gdf[col]):
+                    gdf[col] = gdf[col].dt.strftime("%Y-%m-%d %H:%M:%S").fillna("")
+                # Handle other problematic types
+                elif gdf[col].dtype == "object":
+                    # Convert any remaining non-serializable objects to strings
+                    gdf[col] = gdf[col].astype(str)
+
         # Check and convert CRS if needed
         if enforce_wgs84:
             if gdf.crs is None:

openforis_whisp/datasets.py

@@ -340,45 +340,20 @@ def g_esri_2023_tc_prep():
 
 
 # ESRI 2023 - Crop
-def g_esri_2023_crop_prep():
+def g_esri_2020_2023_crop_prep():
     esri_lulc10_raw = ee.ImageCollection(
         "projects/sat-io/open-datasets/landcover/ESRI_Global-LULC_10m_TS"
     )
-    esri_lulc10_crop = (
-        esri_lulc10_raw.filterDate("2023-01-01", "2023-12-31").mosaic().eq(5)
+    esri_lulc10_crop_2020 = (
+        esri_lulc10_raw.filterDate("2020-01-01", "2020-12-31").mosaic().eq(5)
     )
-    return esri_lulc10_crop.rename("ESRI_2023_crop")
-
-
-# GLC_FCS30D 2022
-
-# GLC_FCS30D Tree Cover
-# forest classes + swamp + mangrove / what to do with shrubland?
-def g_glc_fcs30d_tc_2022_prep():
-    GLC_FCS30D = (
-        ee.ImageCollection("projects/sat-io/open-datasets/GLC-FCS30D/annual")
-        .mosaic()
-        .select(22)
-    )
-    GLC_FCS30D_TC = (
-        (GLC_FCS30D.gte(51))
-        .And(GLC_FCS30D.lte(92))
-        .Or(GLC_FCS30D.eq(181))
-        .Or(GLC_FCS30D.eq(185))
+    esri_lulc10_crop_2023 = (
+        esri_lulc10_raw.filterDate("2023-01-01", "2023-12-31").mosaic().eq(5)
     )
-    return GLC_FCS30D_TC.rename("GLC_FCS30D_TC_2022")
 
+    newCrop = esri_lulc10_crop_2023.And(esri_lulc10_crop_2020.Not())
 
-# GLC_FCS30D crop
-# 10	Rainfed cropland; 11	Herbaceous cover; 12	Tree or shrub cover (Orchard); 20	Irrigated cropland
-def g_glc_fcs30d_crop_2022_prep():
-    GLC_FCS30D = (
-        ee.ImageCollection("projects/sat-io/open-datasets/GLC-FCS30D/annual")
-        .mosaic()
-        .select(22)
-    )
-    GLC_FCS30D_crop = GLC_FCS30D.gte(10).And(GLC_FCS30D.lte(20))
-    return GLC_FCS30D_crop.rename("GLC_FCS30D_crop_2022")
+    return newCrop.rename("ESRI_crop_gain_2020_2023")
 
 
 #### disturbances by year

openforis_whisp/parameters/lookup_gee_datasets.csv

@@ -2,7 +2,7 @@ name,order,ISO2_code,theme,theme_timber,use_for_risk,use_for_risk_timber,exclude
 EUFO_2020,10,,treecover,naturally_reg_2020,1,1,0,float32,1,0,g_jrc_gfc_2020_prep
 GLAD_Primary,20,,treecover,primary,1,1,0,float32,1,0,g_glad_pht_prep
 TMF_undist,30,,treecover,primary,1,1,0,float32,1,0,g_jrc_tmf_undisturbed_prep
-GFC_TC_2020,50,,treecover,naturally_reg_2020,1,1,0,float32,1,0,g_gfc_tc_2020_prep
+GFC_TC_2020,50,,treecover,naturally_reg_2020,1,1,0,float32,1,0,g_glad_gfc_10pc_prep
 Forest_FDaP,60,,treecover,naturally_reg_2020,1,1,0,float32,1,0,g_glad_gfc_10pc_prep
 ESA_TC_2020,70,,treecover,naturally_reg_2020,1,1,0,float32,1,0,g_esa_worldcover_trees_prep
 TMF_plant,80,,commodities,NA,1,1,0,float32,1,0,g_jrc_tmf_plantation_prep
@@ -163,13 +163,11 @@ GFT_planted_plantation,1900,,NA,planted_plantation_2020,0,1,0,float32,1,0,g_gft_
 IIASA_planted_plantation,1910,,NA,planted_plantation_2020,0,1,0,float32,1,0,g_iiasa_planted_prep
 TMF_regrowth_2023,2000,,NA,treecover_after_2020,0,1,0,float32,1,0,g_tmf_regrowth_prep
 ESRI_2023_TC,2010,,NA,treecover_after_2020,0,1,0,float32,1,0,g_esri_2023_tc_prep
-GLC_FCS30D_TC_2022,2020,,NA,treecover_after_2020,0,1,0,float32,1,0,g_glc_fcs30d_tc_2022_prep
 Oil_palm_2023_FDaP,2100,,NA,agri_after_2020,0,1,0,float32,1,0,g_fdap_palm_2023_prep
 Rubber_2023_FDaP,2110,,NA,agri_after_2020,0,1,0,float32,1,0,g_fdap_rubber_2023_prep
 Coffee_FDaP_2023,2111,,NA,agri_after_2020,0,1,0,float32,1,0,g_fdap_coffee_2023_prep
 Cocoa_2023_FDaP,2120,,NA,agri_after_2020,0,1,0,float32,1,0,g_fdap_cocoa_2023_prep
-ESRI_2023_crop,2130,,NA,agri_after_2020,0,1,0,float32,1,0,g_esri_2023_crop_prep
-GLC_FCS30D_crop_2022,2140,,NA,agri_after_2020,0,1,0,float32,1,0,g_glc_fcs30d_crop_2022_prep
+ESRI_crop_gain_2020_2023,2130,,NA,agri_after_2020,0,1,0,float32,1,0,g_esri_2020_2023_crop_prep
 GFW_logging_before_2020,2200,,NA,logging_concession,0,1,0,float32,1,0,g_logging_concessions_prep
 nCO_ideam_forest_2020,2310,CO,treecover,NA,1,1,0,float32,1,0,nco_ideam_forest_2020_prep
 nCO_ideam_eufo_commission_2020,2320,CO,commodities,NA,1,1,0,float32,1,0,nco_ideam_eufo_commission_2020_prep
@@ -199,4 +197,3 @@ nBR_INPE_TCamz_pasture_2020,2422,BR,commodities,NA,1,1,0,float32,1,0,nbr_terracl
 nBR_INPE_TCcer_pasture_2020,2423,BR,commodities,NA,1,1,0,float32,1,0,nbr_terraclass_cer20_ac_prep
 nBR_MapBiomas_col9_pasture_2020,2424,BR,commodities,NA,1,1,0,float32,1,0,nbr_mapbiomasc9_pasture_prep
 nCI_Cocoa_bnetd,3000,CI,commodities,NA,1,1,0,float32,1,0,nci_ocs2020_prep
-

openforis_whisp/risk.py

@@ -161,9 +161,8 @@ def whisp_risk(
             lookup_df_copy, custom_bands_info, df.columns
         )
         print(f"Including custom bands: {list(custom_bands_info.keys())}")
-        # print(f"appended custom bands info to lookup table")
     if national_codes:
-        print(f"Filtering by national codes: {national_codes}")
+        print(f"Including additional national data for: {national_codes}")
     # Filter by national codes
     filtered_lookup_gee_datasets_df = filter_lookup_by_country_codes(
         lookup_df=lookup_df_copy,
@@ -473,7 +472,6 @@ def add_indicators(
     return df
 
 
-# Update add_indicator_column to use the unit_type parameter
 def add_indicator_column(
     df: data_lookup_type,
     input_columns: list[str],
@@ -482,49 +480,51 @@ def add_indicator_column(
     low_name: str = "no",
     high_name: str = "yes",
     sum_comparison: bool = False,
-    unit_type: str = None,  # unit_type parameter
+    unit_type: str = None,
 ) -> data_lookup_type:
-    """
-    Add a new column to the DataFrame based on the specified columns, threshold, and comparison sign.
+    """Add a new column to the DataFrame based on the specified columns, threshold, and comparison sign."""
 
-    Parameters:
-        df (data_lookup_type): The pandas DataFrame to which the column will be added.
-        input_columns (list): List of column names to check for threshold.
-        threshold (float): The threshold value to compare against.
-        new_column_name (str): The name of the new column to be added.
-        The '>' sign is used for comparisons.
-        When 'sum comparison' == True, then the threshold is compared to the sum of all those listed in 'input_columns', as opposed to when Flalse, when each column in the list is compared to the threshold individually
-        low_name (str): The name for the value when below or equal to threshold (default is 'no').
-        high_name (str): The name for the value when above threshold (default is 'yes').
-        sum_comparison (bool): If True, sum all values in input_columns and compare to threshold (default is False).
-        unit_type (str): Whether values are in "ha" or "percent".
-
-    Returns:
-        data_lookup_type: The DataFrame with the new column added.
-    """
     # Create a new column and initialize with low_name
     new_column = pd.Series(low_name, index=df.index, name=new_column_name)
 
-    # Default behavior: use '>' for single column comparison
     if sum_comparison:
         # Sum all values in specified columns and compare to threshold
         sum_values = df[input_columns].sum(axis=1)
         new_column[sum_values > threshold] = high_name
     else:
-        # Check if any values in specified columns are above the threshold and update the new column accordingly
+        # Check if any values in specified columns are above the threshold
         for col in input_columns:
-            # So that threshold is always in percent, if outputs are in ha, the code converts to percent (based on dividing by the geometry_area_column column.
-            # Clamping is needed due to differences in decimal places (meaning input values may go just over 100)
             if unit_type == "ha":
                 df[geometry_area_column] = pd.to_numeric(
                     df[geometry_area_column], errors="coerce"
                 )
-                val_to_check = clamp(
-                    ((df[col] / df[geometry_area_column]) * 100), 0, 100
-                )
+
+                # Handle points (Area = 0) separately
+                is_point = df[geometry_area_column] == 0
+
+                # For points: any value > 0 exceeds threshold
+                point_mask = is_point & (df[col] > 0)
+                new_column[point_mask] = high_name
+
+                # For polygons: convert to percentage and check threshold
+                polygon_mask = ~is_point
+                if polygon_mask.any():
+                    val_to_check = clamp(
+                        (
+                            (
+                                df.loc[polygon_mask, col]
+                                / df.loc[polygon_mask, geometry_area_column]
+                            )
+                            * 100
+                        ),
+                        0,
+                        100,
+                    )
+                    new_column[polygon_mask & (val_to_check > threshold)] = high_name
             else:
+                # For percentage values, use direct comparison
                 val_to_check = df[col]
-            new_column[val_to_check > threshold] = high_name
+                new_column[val_to_check > threshold] = high_name
 
     # Concatenate the new column to the DataFrame
     df = pd.concat([df, new_column], axis=1)

openforis_whisp/stats.py

@@ -592,9 +592,58 @@ def whisp_stats_ee_to_df(
         print(f"An error occurred during the ISO3 to ISO2 conversion: {e}")
         return pd.DataFrame()  # Return an empty DataFrame in case of error
 
+    # NEW: Set area to 0 for point geometries
+    try:
+        df_stats = set_point_geometry_area_to_zero(df_stats)
+    except Exception as e:
+        print(f"An error occurred during point geometry area adjustment: {e}")
+        # Continue without the adjustment rather than failing completely
+
     return df_stats
 
 
+def set_point_geometry_area_to_zero(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Set the geometry area column to 0 for features with Point geometry type.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing geometry type and area columns
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with area set to 0 for Point geometries
+    """
+    # Check if required columns exist
+    if geometry_type_column not in df.columns:
+        print(
+            f"Warning: {geometry_type_column} column not found. Skipping area adjustment for points."
+        )
+        return df
+
+    if geometry_area_column not in df.columns:
+        print(
+            f"Warning: {geometry_area_column} column not found. Skipping area adjustment for points."
+        )
+        return df
+
+    # Create a copy to avoid modifying the original
+    df_modified = df.copy()
+
+    # Set area to 0 where geometry type is Point
+    point_mask = df_modified[geometry_type_column] == "Point"
+    df_modified.loc[point_mask, geometry_area_column] = 0.0
+
+    # Log the changes
+    num_points = point_mask.sum()
+    if num_points > 0:
+        print(f"Set area to 0 for {num_points} Point geometries")
+
+    return df_modified
+
+
 def whisp_stats_ee_to_drive(
     feature_collection: ee.FeatureCollection,
     external_id_column=None,
@@ -1226,3 +1275,46 @@ def debug_feature_collection_properties(feature_collection, max_features=5):
 
     except Exception as e:
         return {"error": f"Error during debugging: {str(e)}"}
+
+
+# helper function to set area to 0 for point geometries
+def set_point_geometry_area_to_zero(df: pd.DataFrame) -> pd.DataFrame:
+    """
+    Set the geometry area column to 0 for features with Point geometry type.
+
+    Parameters
+    ----------
+    df : pd.DataFrame
+        DataFrame containing geometry type and area columns
+
+    Returns
+    -------
+    pd.DataFrame
+        DataFrame with area set to 0 for Point geometries
+    """
+    # Check if required columns exist
+    if geometry_type_column not in df.columns:
+        print(
+            f"Warning: {geometry_type_column} column not found. Skipping area adjustment for points."
+        )
+        return df
+
+    if geometry_area_column not in df.columns:
+        print(
+            f"Warning: {geometry_area_column} column not found. Skipping area adjustment for points."
+        )
+        return df
+
+    # Create a copy to avoid modifying the original
+    df_modified = df.copy()
+
+    # Set area to 0 where geometry type is Point
+    point_mask = df_modified[geometry_type_column] == "Point"
+    df_modified.loc[point_mask, geometry_area_column] = 0.0
+
+    # Log the changes
+    num_points = point_mask.sum()
+    # if num_points > 0:
+    #     print(f"Set area to 0 for {num_points} Point geometries")
+
+    return df_modified

openforis_whisp/utils.py

@@ -3,6 +3,8 @@ import ee
 import math
 import os
 import pandas as pd
+import random
+import numpy as np
 
 import urllib.request
 import os
@@ -12,6 +14,9 @@ import importlib.resources as pkg_resources
 from dotenv import load_dotenv
 from pathlib import Path
 
+from shapely.geometry import Polygon, Point, mapping
+from shapely.validation import make_valid
+
 from .logger import StdoutLogger
 
 
@@ -160,31 +165,31 @@ class DotEnvNotFoundError(FileNotFoundError):
 def get_example_geojson(filename="geojson_example.geojson", cache=True):
     """
     Download example geojson file for testing whisp functionality.
-    
+
     Parameters:
     -----------
     filename : str
         Local filename to save the geojson
     cache : bool
         If True, cache file in user directory to avoid re-downloading
-        
+
     Returns:
     --------
     str
         Path to the downloaded geojson file
     """
     url = "https://raw.githubusercontent.com/forestdatapartnership/whisp/main/tests/fixtures/geojson_example.geojson"
-    
+
     if cache:
         cache_dir = os.path.join(os.path.expanduser("~"), ".whisp_cache")
         os.makedirs(cache_dir, exist_ok=True)
         filepath = os.path.join(cache_dir, filename)
-        
+
         if os.path.exists(filepath):
             return filepath
     else:
         filepath = filename
-    
+
     try:
         urllib.request.urlretrieve(url, filepath)
         return filepath
@@ -192,3 +197,291 @@ def get_example_geojson(filename="geojson_example.geojson", cache=True):
         raise RuntimeError(f"Failed to download example geojson: {e}")
 
 
+def generate_random_polygon(
+    min_lon, min_lat, max_lon, max_lat, min_area_ha=1, max_area_ha=10, vertex_count=20
+):
+    """
+    Generate a random polygon with exact vertex count control.
+
+    Parameters
+    ----------
+    min_lon : float
+        Minimum longitude
+    min_lat : float
+        Minimum latitude
+    max_lon : float
+        Maximum longitude
+    max_lat : float
+        Maximum latitude
+    min_area_ha : float
+        Minimum area in hectares
+    max_area_ha : float
+        Maximum area in hectares
+    vertex_count : int
+        Exact number of vertices for the polygon
+
+    Returns
+    -------
+    tuple
+        (Polygon, actual_area_ha)
+    """
+    target_area_ha = random.uniform(min_area_ha, max_area_ha)
+    center_lon = random.uniform(min_lon, max_lon)
+    center_lat = random.uniform(min_lat, max_lat)
+
+    # Estimate radius for target area
+    target_area_m2 = target_area_ha * 10000  # hectares to square meters
+    radius_meters = math.sqrt(target_area_m2 / math.pi)
+    radius_degrees = radius_meters / (111320 * math.cos(math.radians(center_lat)))
+
+    # Create center point
+    center_point = Point(center_lon, center_lat)
+
+    # Use buffer with resolution to control vertices for smaller vertex counts
+    if vertex_count <= 50:
+        poly = center_point.buffer(radius_degrees, resolution=vertex_count // 4)
+
+    # Manual vertex creation for higher vertex counts
+    if vertex_count > 50:
+        angles = np.linspace(0, 2 * math.pi, vertex_count, endpoint=False)
+
+        base_radius = radius_degrees
+
+        # Smooth sine wave variations for natural look
+        freq1 = random.uniform(2, 5)
+        amp1 = random.uniform(0.08, 0.15)
+        freq2 = random.uniform(8, 15)
+        amp2 = random.uniform(0.03, 0.08)
+
+        radius_variation = amp1 * np.sin(
+            freq1 * angles + random.uniform(0, 2 * math.pi)
+        ) + amp2 * np.sin(freq2 * angles + random.uniform(0, 2 * math.pi))
+
+        radii = base_radius * (1.0 + radius_variation)
+        radii = np.maximum(radii, base_radius * 0.6)
+
+        xs = center_lon + radii * np.cos(angles)
+        ys = center_lat + radii * np.sin(angles)
+
+        xs = np.clip(xs, min_lon, max_lon)
+        ys = np.clip(ys, min_lat, max_lat)
+
+        vertices = list(zip(xs, ys))
+        vertices.append(vertices[0])
+
+        poly = Polygon(vertices)
+
+        if not poly.is_valid:
+            poly = make_valid(poly)
+            if hasattr(poly, "geoms"):
+                poly = max(poly.geoms, key=lambda p: p.area)
+
+    else:
+        # Resample to get exact vertex count for buffered circles
+        coords = list(poly.exterior.coords)
+
+        if len(coords) - 1 != vertex_count:
+            angles = np.linspace(0, 2 * math.pi, vertex_count, endpoint=False)
+
+            new_coords = []
+            for angle in angles:
+                x = center_lon + radius_degrees * math.cos(angle)
+                y = center_lat + radius_degrees * math.sin(angle)
+
+                dx = random.uniform(-radius_degrees * 0.08, radius_degrees * 0.08)
+                dy = random.uniform(-radius_degrees * 0.08, radius_degrees * 0.08)
+
+                new_x = np.clip(x + dx, min_lon, max_lon)
+                new_y = np.clip(y + dy, min_lat, max_lat)
+                new_coords.append((new_x, new_y))
+
+            new_coords.append(new_coords[0])
+            poly = Polygon(new_coords)
+
+    # Calculate actual area
+    area_sq_degrees = poly.area
+    area_sq_meters = (
+        area_sq_degrees * (111320 * math.cos(math.radians(center_lat))) ** 2
+    )
+    actual_area_ha = area_sq_meters / 10000
+
+    return poly, actual_area_ha
+
+
+def generate_test_polygons(
+    bounds,
+    num_polygons=25,
+    min_area_ha=1,
+    max_area_ha=10,
+    min_number_vert=10,
+    max_number_vert=20,
+):
+    """
+    Generate synthetic test polygons with exact vertex count control.
+
+    This utility is useful for testing WHISP processing with controlled test data,
+    especially when you need polygons with specific characteristics (area, complexity).
+
+    Parameters
+    ----------
+    bounds : list or ee.Geometry
+        Either a list of [min_lon, min_lat, max_lon, max_lat] or an Earth Engine Geometry.
+        Examples:
+            - Simple bounds: [-81.0, -19.3, -31.5, 9.6]
+            - EE Geometry: ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017').filter(
+                              ee.Filter.eq('country_na', 'Brazil')).first().geometry()
+    num_polygons : int, optional
+        Number of polygons to generate (default: 25)
+    min_area_ha : float, optional
+        Minimum area in hectares (default: 1)
+    max_area_ha : float, optional
+        Maximum area in hectares (default: 10)
+    min_number_vert : int, optional
+        Minimum number of vertices per polygon (default: 10)
+    max_number_vert : int, optional
+        Maximum number of vertices per polygon (default: 20)
+
+    Returns
+    -------
+    dict
+        GeoJSON FeatureCollection with generated polygons. Each feature includes:
+        - internal_id: Sequential ID starting from 1
+        - requested_vertices: Number of vertices requested
+        - actual_vertices: Actual number of vertices created
+        - requested_area_ha: Target area in hectares
+        - actual_area_ha: Actual area in hectares
+
+    Examples
+    --------
+    >>> import openforis_whisp as whisp
+    >>> import ee
+    >>>
+    >>> # Using simple bounds (list)
+    >>> bounds_list = [-81.0, -19.3, -31.5, 9.6]
+    >>> geojson = whisp.generate_test_polygons(bounds_list, num_polygons=100)
+    >>>
+    >>> # Using Earth Engine Geometry
+    >>> brazil = ee.FeatureCollection('USDOS/LSIB_SIMPLE/2017').filter(
+    ...     ee.Filter.eq('country_na', 'Brazil')
+    ... ).first().geometry()
+    >>> geojson = whisp.generate_test_polygons(brazil, num_polygons=100,
+    ...                                        min_area_ha=100, max_area_ha=1000)
+    >>>
+    >>> # Save to file
+    >>> import json
+    >>> with open('test_polygons.geojson', 'w') as f:
+    ...     json.dump(geojson, f)
+    """
+
+    # Handle Earth Engine Geometry or simple bounds
+    if hasattr(bounds, "bounds"):  # It's an ee.Geometry
+        logger.logger.info("Extracting bounds from Earth Engine Geometry...")
+        try:
+            bounds_geom = (
+                bounds.bounds()
+                if not hasattr(bounds, "coordinates")
+                or bounds.type().getInfo() != "Rectangle"
+                else bounds
+            )
+            bounds_coords = bounds_geom.coordinates().getInfo()[0]
+            min_lon = min(coord[0] for coord in bounds_coords)
+            max_lon = max(coord[0] for coord in bounds_coords)
+            min_lat = min(coord[1] for coord in bounds_coords)
+            max_lat = max(coord[1] for coord in bounds_coords)
+            logger.logger.info(
+                f"Bounds: [{min_lon:.2f}, {min_lat:.2f}, {max_lon:.2f}, {max_lat:.2f}]"
+            )
+        except Exception as e:
+            raise ValueError(
+                f"Failed to extract bounds from Earth Engine Geometry: {e}"
+            )
+    elif isinstance(bounds, (list, tuple)) and len(bounds) == 4:
+        min_lon, min_lat, max_lon, max_lat = bounds
+    else:
+        raise ValueError(
+            "bounds must be either:\n"
+            "  - A list of [min_lon, min_lat, max_lon, max_lat]\n"
+            "  - An Earth Engine Geometry (ee.Geometry, ee.Feature.geometry(), etc.)"
+        )
+
+    # Validate parameters
+    if min_number_vert > max_number_vert:
+        raise ValueError(
+            f"min_number_vert ({min_number_vert}) cannot be greater than max_number_vert ({max_number_vert})"
+        )
+    if min_area_ha > max_area_ha:
+        raise ValueError(
+            f"min_area_ha ({min_area_ha}) cannot be greater than max_area_ha ({max_area_ha})"
+        )
+    if num_polygons < 1:
+        raise ValueError(f"num_polygons must be at least 1 (got {num_polygons})")
+
+    logger.logger.info(
+        f"Generating {num_polygons} test polygons with {min_number_vert}-{max_number_vert} vertices..."
+    )
+
+    features = []
+
+    # Pre-generate all random values
+    vertex_counts = np.random.randint(
+        min_number_vert, max_number_vert + 1, num_polygons
+    )
+    target_areas = np.random.uniform(min_area_ha, max_area_ha, num_polygons)
+
+    for i in range(num_polygons):
+        if i > 0 and i % 250 == 0:
+            logger.logger.info(
+                f"Generated {i}/{num_polygons} polygons ({i/num_polygons*100:.0f}%)..."
+            )
+
+        requested_vertices = vertex_counts[i]
+
+        polygon, actual_area = generate_random_polygon(
+            min_lon,
+            min_lat,
+            max_lon,
+            max_lat,
+            min_area_ha=target_areas[i] * 0.9,
+            max_area_ha=target_areas[i] * 1.1,
+            vertex_count=requested_vertices,
+        )
+
+        actual_vertex_count = len(list(polygon.exterior.coords)) - 1
+
+        properties = {
+            "internal_id": i + 1,
+            "requested_vertices": int(requested_vertices),
+            "actual_vertices": int(actual_vertex_count),
+            "requested_area_ha": round(target_areas[i], 2),
+            "actual_area_ha": round(actual_area, 2),
+        }
+
+        feature = {
+            "type": "Feature",
+            "properties": properties,
+            "geometry": mapping(polygon),
+        }
+
+        features.append(feature)
+
+    logger.logger.info(f"Generated {num_polygons} polygons!")
+
+    # Print summary statistics
+    actual_vertex_counts = [f["properties"]["actual_vertices"] for f in features]
+    requested_vertex_counts = [f["properties"]["requested_vertices"] for f in features]
+
+    logger.logger.info(
+        f"Vertex count - Requested: {min(requested_vertex_counts)}-{max(requested_vertex_counts)}, "
+        f"Actual: {min(actual_vertex_counts)}-{max(actual_vertex_counts)}"
+    )
+
+    actual_area_counts = [f["properties"]["actual_area_ha"] for f in features]
+    requested_area_counts = [f["properties"]["requested_area_ha"] for f in features]
+
+    logger.logger.info(
+        f"Area (ha) - Requested: {min(requested_area_counts):.1f}-{max(requested_area_counts):.1f}, "
+        f"Actual: {min(actual_area_counts):.1f}-{max(actual_area_counts):.1f}"
+    )
+
+    geojson = {"type": "FeatureCollection", "features": features}
+    return geojson

{openforis_whisp-2.0.0b1.dist-info → openforis_whisp-2.0.0b2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openforis-whisp
-Version: 2.0.0b1
+Version: 2.0.0b2
 Summary: Whisp (What is in that plot) is an open-source solution which helps to produce relevant forest monitoring information and support compliance with deforestation-related regulations.
 License: MIT
 Keywords: whisp,geospatial,data-processing

openforis_whisp-2.0.0b2.dist-info/RECORD

@@ -0,0 +1,16 @@
+openforis_whisp/__init__.py,sha256=bnEZ4_X-mJInltSKVI0STfvrb09Df-z21buIVFDif5w,2524
+openforis_whisp/data_conversion.py,sha256=Mc6dXbvoHBeRzl3o83pyKeI5_sPC8Yc90Tj4bN6_Bv8,17519
+openforis_whisp/datasets.py,sha256=TNIj3yffQkf_QvfOo0cwKOqIvhd_AVcEf0bz3QGsy3Q,50776
+openforis_whisp/logger.py,sha256=n9k0EhAZYZKesnfskv8KyWnkGbjqRqk84ulx9-u_Jsc,2308
+openforis_whisp/parameters/config_runtime.py,sha256=NOo39MAi60XCwEx5pwkS0EHKJBh0XY1q06y4j0HAABg,1421
+openforis_whisp/parameters/lookup_context_and_metadata.csv,sha256=KgK0ik_Gd4t_Nq5cUkGPT4ZFZVO93HWSG82jRrOukt4,1298
+openforis_whisp/parameters/lookup_gee_datasets.csv,sha256=UDvZrQsL5rXJn6CW6P3wofUrPLRmUFZWt6ETbXaxBMs,17454
+openforis_whisp/pd_schemas.py,sha256=W_ocS773LHfc05dJqvWRa-bRdX0wKFoNp0lMxgFx94Y,2681
+openforis_whisp/reformat.py,sha256=rtkKs8z1mJd5JD9rXuMk1tbbbTvQxCCh68tA4hIQAv8,25445
+openforis_whisp/risk.py,sha256=d_Di5XB8BnHdVXG56xdHTcpB4-CIF5vo2ZRMQRG7Pek,34420
+openforis_whisp/stats.py,sha256=_emqJ2xW6fgGevX8Dt1kRvLDL2vBgPyS4idrAuO_BDY,48124
+openforis_whisp/utils.py,sha256=5HHtbK62Swn4-jnlSe1Jc-hVnJhLKMuDW0_ayHY7mIg,17130
+openforis_whisp-2.0.0b2.dist-info/LICENSE,sha256=nqyqICO95iw_iwzP1t_IIAf7ZX3DPbL_M9WyQfh2q1k,1085
+openforis_whisp-2.0.0b2.dist-info/METADATA,sha256=Y1a-63w6UrU--JDvbR5eJzlPPNmf6mJT3xrOWtcSJ3c,16684
+openforis_whisp-2.0.0b2.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+openforis_whisp-2.0.0b2.dist-info/RECORD,,

openforis_whisp/parameters/__init__.py

@@ -1,15 +0,0 @@
-"""
-!!! BAD PRACTICE, ALWAYS IMPORT YOUR MODULES EXPLICITELY !!!
-
-Module to gather all parameters.
-
-If you use a module import all the functions here you only have 1 call to make
-"""
-
-# from .config_runtime import *
-
-# from .config_asr_url_info import *
-
-# from .config_asr_credentials import *
-
-# from parameters.config_ceo import *

openforis_whisp-2.0.0b1.dist-info/RECORD

@@ -1,17 +0,0 @@
-openforis_whisp/__init__.py,sha256=W-uMGp87DCuqJWY31fyYkzDXXZp3g1HOXZoHThJqvJU,2462
-openforis_whisp/data_conversion.py,sha256=_HSjYozNO1xAOAk-uGmzTVCTOc3W7x3GDlvEUgrnj_Q,16909
-openforis_whisp/datasets.py,sha256=gQg-JjcZuCd8-4_J2CN4oNwo-2qwNmKpwS_JV6zf-Jc,51516
-openforis_whisp/logger.py,sha256=n9k0EhAZYZKesnfskv8KyWnkGbjqRqk84ulx9-u_Jsc,2308
-openforis_whisp/parameters/__init__.py,sha256=KL7iORJVjSpZatYjoyWckcmQJnE89_DBC8R6_0_eR6o,349
-openforis_whisp/parameters/config_runtime.py,sha256=NOo39MAi60XCwEx5pwkS0EHKJBh0XY1q06y4j0HAABg,1421
-openforis_whisp/parameters/lookup_context_and_metadata.csv,sha256=KgK0ik_Gd4t_Nq5cUkGPT4ZFZVO93HWSG82jRrOukt4,1298
-openforis_whisp/parameters/lookup_gee_datasets.csv,sha256=rYAMwbd1kwakgucdXrDicJfu4Nvjk8LWBYN7FuIpdDY,17626
-openforis_whisp/pd_schemas.py,sha256=W_ocS773LHfc05dJqvWRa-bRdX0wKFoNp0lMxgFx94Y,2681
-openforis_whisp/reformat.py,sha256=rtkKs8z1mJd5JD9rXuMk1tbbbTvQxCCh68tA4hIQAv8,25445
-openforis_whisp/risk.py,sha256=_YMF-2X1OZXrNMFdNPuJicnG8ktAhlFToJfthWwiRHE,35111
-openforis_whisp/stats.py,sha256=uwyiPXVptpCFSviz-_otXCpHeHnY2IwE2dPwvI7tAAM,45226
-openforis_whisp/utils.py,sha256=ywOl-Hd2FzSYrOVIjtqGaNoZqkI34UChkZMbdjgXWZ0,6492
-openforis_whisp-2.0.0b1.dist-info/LICENSE,sha256=nqyqICO95iw_iwzP1t_IIAf7ZX3DPbL_M9WyQfh2q1k,1085
-openforis_whisp-2.0.0b1.dist-info/METADATA,sha256=NDh_KnflmxTUaA2-w3yTCrZYKFcbgvH8NJu5soe7doc,16684
-openforis_whisp-2.0.0b1.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-openforis_whisp-2.0.0b1.dist-info/RECORD,,