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

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.0b3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: openforis-whisp
-Version: 2.0.0b1
+Version: 2.0.0b3
 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.0b3.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=hb8Y35vTcQQNUH_z2_l8Pu6Sjn_E8BzSow1-qAfs9bQ,50194
+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=1ikeV8UYpL8O5HZJY8lPXrhQwZ9D1IglbOsagZHCYdA,54000
+openforis_whisp/utils.py,sha256=5HHtbK62Swn4-jnlSe1Jc-hVnJhLKMuDW0_ayHY7mIg,17130
+openforis_whisp-2.0.0b3.dist-info/LICENSE,sha256=nqyqICO95iw_iwzP1t_IIAf7ZX3DPbL_M9WyQfh2q1k,1085
+openforis_whisp-2.0.0b3.dist-info/METADATA,sha256=Opn73PWlsOQWTiwZ-HYvLkrPh4jYQELtSIIqDf4MsoQ,16684
+openforis_whisp-2.0.0b3.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+openforis_whisp-2.0.0b3.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,,