ccfx 1.0.8__py3-none-any.whl → 1.1.0__py3-none-any.whl

ccfx/ccfx.py

@@ -22,7 +22,6 @@ import platform
 import zipfile
 import pickle
 import time
-from shapely.geometry import box, Point
 import geopandas, pandas
 from collections import defaultdict
 import py7zr
@@ -38,6 +37,12 @@ import yt_dlp
 from typing import Optional, Any
 from datetime import datetime, timedelta
 from PIL import Image
+import scipy as scipy
+from shapely.geometry import LineString, Polygon, MultiPolygon, box, Point
+from shapely.ops import polygonize, unary_union
+import rasterio
+from rasterio import features
+from rasterio.transform import from_bounds
 
 # functions
 def listFiles(path: str, ext: Optional[str] = None) -> list:
@@ -479,9 +484,9 @@ def alert(message:str, server:str = "http://ntfy.sh", topic:str = "pythonAlerts"
     return: True if the alert was sent successfully, False otherwise
     '''
     print(message) if printIt else None; header_data = {}
-    if not messageTitle is None: header_data["Title"] = messageTitle
-    if not priority is None: header_data["Priority"] = priority
-    if not len(tags) == 0: header_data["Tags"] = ",".join(tags)
+    if not messageTitle is None: header_data["Title"] = str(messageTitle).replace("\r"," ").replace("\n"," ")
+    if not priority is None: header_data["Priority"] = str(int(priority))
+    if not len(tags) == 0: header_data["Tags"] = ",".join(map(str, tags))
 
     try:
         if v: print(f"sending alert to {server}/{topic}")
@@ -517,6 +522,7 @@ def deletePath(path:str, v:bool = False) -> bool:
         if v:
             print(f'! {path} does not exist')
         deleted = False
+    return deleted
 
 
 def downloadChunk(url: str, start: int, end: int, path: str) -> None:
@@ -528,6 +534,54 @@ def downloadChunk(url: str, start: int, end: int, path: str) -> None:
                 f.write(chunk)
 
 
+def correctFisheye(inputFile: str, outputFile: str = '',
+                        k1: float = -0.1, k2: float = 0.05,
+                        cx: float = 0.5, cy: float = 0.5,
+                        crf: int = 20) -> str:
+    """
+    Correct fisheye distortion in a video and save as MP4.
+
+    Args:
+        inputFile (str): Path to the input video (any format).
+        outputFile (str, optional): Path for the corrected MP4. If None, auto-creates.
+        k1, k2 (float): Lens distortion coefficients.
+        cx, cy (float): Optical center (0.5 = image center).
+        crf (int): Constant Rate Factor (lower = better quality, larger file).
+
+    Returns:
+        str: Path to the corrected MP4 file.
+    """
+    if not os.path.exists(inputFile):
+        raise FileNotFoundError(f"Input file not found: {inputFile}")
+
+    # Default output path
+    if outputFile == '':
+        base, _ = os.path.splitext(inputFile)
+        outputFile = f"{base}_corrected.mp4"
+
+    cmd = [
+        "ffmpeg", "-hide_banner", "-loglevel", "error", "-stats",
+        "-i", inputFile,
+        "-vf", f"lenscorrection=cx={cx}:cy={cy}:k1={k1}:k2={k2}",
+        "-c:v", "libx264", "-preset", "slow", f"-crf", str(crf),
+        "-pix_fmt", "yuv420p",
+        "-c:a", "aac", "-b:a", "192k",
+        "-movflags", "+faststart",
+        outputFile
+    ]
+
+    subprocess.run(cmd, check=True)
+    return outputFile
+
+def correctLens(inputFile: str, outputFile: str = '',
+                        k1: float = -0.1, k2: float = 0.05,
+                        cx: float = 0.5, cy: float = 0.5,
+                        crf: int = 20) -> str:
+    """
+    Alias for correctFisheye
+    """
+    return correctFisheye(inputFile, outputFile, k1, k2, cx, cy, crf)
+
 def formatStringBlock(input_str: str, max_chars: int = 70) -> str:
     '''
     This function takes a string and formats it into a block of text
@@ -558,7 +612,6 @@ def formatStringBlock(input_str: str, max_chars: int = 70) -> str:
 
 
 
-
 def downloadFile(url: str, save_path: str, exists_action: str = 'resume', num_connections: int = 5, v: bool = False) -> None:
     if v:
         print(f"\ndownloading {url}")
@@ -573,13 +626,17 @@ def downloadFile(url: str, save_path: str, exists_action: str = 'resume', num_co
     if os.path.exists(save_fname):
         if exists_action == 'skip':
             if v:
-                print(f"File exists, skipping: {save_fname}")
+                print(f"file exists, skipping: {save_fname}")
             return
         elif exists_action == 'overwrite':
             os.remove(save_fname)
         # 'resume' is handled below
 
-    # Get file size
+    # Get file size (suppress urllib3 warnings when v=False)
+    import urllib3
+    if not v:
+        urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
+        
     response = requests.head(url)
     file_size = int(response.headers.get('content-length', 0))
 
@@ -589,7 +646,7 @@ def downloadFile(url: str, save_path: str, exists_action: str = 'resume', num_co
         initial_pos = os.path.getsize(save_fname)
         if initial_pos >= file_size:
             if v:
-                print(f"File already completed: {save_fname}")
+                print(f"file already completed: {save_fname}")
             return
 
     # Calculate chunk sizes
@@ -609,14 +666,22 @@ def downloadFile(url: str, save_path: str, exists_action: str = 'resume', num_co
                 executor.submit(downloadChunk, url, start, end, temp_files[i])
             )
         
-        # Wait for all downloads to complete with progress bar
-        with tqdm(total=file_size-initial_pos, initial=initial_pos, unit='B', 
-                 unit_scale=True, desc=fname) as pbar:
-            completed = initial_pos
-            while completed < file_size:
+        # Wait for all downloads to complete with progress bar (conditionally show progress)
+        if v:
+            with tqdm(total=file_size-initial_pos, initial=initial_pos, unit='B', 
+                     unit_scale=True, desc=fname) as pbar:
+                completed = initial_pos
+                while completed < file_size:
+                    current = sum(os.path.getsize(f) for f in temp_files if os.path.exists(f))
+                    pbar.update(current - completed)
+                    completed = current
+        else:
+            # Wait silently without progress bar
+            while True:
                 current = sum(os.path.getsize(f) for f in temp_files if os.path.exists(f))
-                pbar.update(current - completed)
-                completed = current
+                if current >= file_size - initial_pos:
+                    break
+                time.sleep(0.1)
 
     # Merge chunks
     with open(save_fname, 'ab' if initial_pos > 0 else 'wb') as outfile:
@@ -627,6 +692,77 @@ def downloadFile(url: str, save_path: str, exists_action: str = 'resume', num_co
                 os.remove(temp_file)
 
 
+
+
+def createPolygonFromOuterPoints(pointsGdf: geopandas.GeoDataFrame, alpha: float = 1.6, keepHoles: bool = False) -> geopandas.GeoDataFrame:
+    """
+    Concave hull (alpha-shape) from points.
+    alpha: larger -> tighter/more detailed; too large can fragment.
+    keepHoles: keep interior holes if True, otherwise drop them.
+    """
+
+    pointsGdf = pointsGdf[pointsGdf.geometry.type.eq("Point") & pointsGdf.geometry.notna()]
+    if pointsGdf.empty or pointsGdf.geometry.nunique() < 3:
+        raise ValueError("need at least three distinct points")
+
+    # coordinates (N, 2)
+    coords = numpy.array([(g.x, g.y) for g in pointsGdf.geometry])
+
+    tri = scipy.spatial.Delaunay(coords)
+    simplices = tri.simplices  # (M, 3) indices into coords
+    triPts = coords[simplices] # (M, 3, 2)
+
+    # side lengths
+    a = numpy.linalg.norm(triPts[:, 1] - triPts[:, 2], axis=1)
+    b = numpy.linalg.norm(triPts[:, 0] - triPts[:, 2], axis=1)
+    c = numpy.linalg.norm(triPts[:, 0] - triPts[:, 1], axis=1)
+
+    s = (a + b + c) / 2.0
+    # heron area, guard against tiny/negative due to fp error
+    areaSq = numpy.maximum(s * (s - a) * (s - b) * (s - c), 0.0)
+    area = numpy.sqrt(areaSq)
+    valid = area > 0.0
+    if not numpy.any(valid):
+        hull = pointsGdf.unary_union.convex_hull
+        return geopandas.GeoDataFrame({"name": ["outerBoundary"]}, geometry=[hull], crs=pointsGdf.crs)
+
+    circumradius = (a * b * c) / (4.0 * area)
+    keep = valid & (circumradius < (1.0 / alpha))
+    keptSimplices = simplices[keep]
+    if keptSimplices.size == 0:
+        hull = pointsGdf.unary_union.convex_hull
+        return geopandas.GeoDataFrame({"name": ["outerBoundary"]}, geometry=[hull], crs=pointsGdf.crs)
+
+    # count triangle edges; boundary edges appear exactly once
+    edgeCounts: dict[tuple[int, int], int] = {}
+    for i0, i1, i2 in keptSimplices:
+        for e in ((i0, i1), (i1, i2), (i2, i0)):
+            key = (e[0], e[1]) if e[0] < e[1] else (e[1], e[0])
+            edgeCounts[key] = edgeCounts.get(key, 0) + 1
+
+    boundaryLines = [
+        LineString([coords[i], coords[j]])
+        for (i, j), count in edgeCounts.items()
+        if count == 1
+    ]
+    if not boundaryLines:
+        hull = pointsGdf.unary_union.convex_hull
+        return geopandas.GeoDataFrame({"name": ["outerBoundary"]}, geometry=[hull], crs=pointsGdf.crs)
+
+    polygons = list(polygonize(boundaryLines))
+    if not polygons:
+        hull = pointsGdf.unary_union.convex_hull
+        return geopandas.GeoDataFrame({"name": ["outerBoundary"]}, geometry=[hull], crs=pointsGdf.crs)
+
+    merged = unary_union(polygons)
+    if isinstance(merged, MultiPolygon):
+        merged = max(merged.geoms, key=lambda g: g.area)
+    if not keepHoles and isinstance(merged, Polygon):
+        merged = Polygon(merged.exterior)
+
+    return geopandas.GeoDataFrame({"name": ["outerBoundary"]}, geometry=[merged], crs=pointsGdf.crs)
+
+
 def mergeRasterTiles(tileList:list, outFile:str) -> str:
     '''
     Merge raster tiles into one raster file
@@ -977,6 +1113,116 @@ def extractCompressedFile(inputFile: str, outputDir: str, v: bool = False) -> No
     """
     uncompress(inputFile, outputDir, v)
 
+
+
+def rasterizeGDF(gdf: geopandas.GeoDataFrame, valueField: str, outRasterFN: str, resolution: float, isCOG: bool = True, allTouched: bool = False, profileOverrides: dict | None = None) -> str:
+    """
+    Rasterize a GeoDataFrame to GeoTIFF/COG.
+
+    Parameters
+    ----------
+    gdf : geopandas.GeoDataFrame
+    valueField : str
+        Column to burn as pixel values.
+    outRasterFN : str
+    resolution : float
+        Pixel size in CRS units (assumes a projected CRS).
+    isCOG : bool, default True
+        If True, writes Cloud-Optimized GeoTIFF. Otherwise plain GeoTIFF.
+    allTouched : bool, default False
+        Pass-through to rasterio.features.rasterize.
+    profileOverrides : dict | None
+        Extra GDAL profile options (e.g., {"compress": "LZW"}). Overrides defaults.
+
+    Returns
+    -------
+    str
+        The path written to (outRasterFN).
+    """
+    # basic checks
+    if gdf is None or len(gdf) == 0 or gdf.geometry.isna().all():
+        raise ValueError("gdf is empty or has no valid geometries.")
+    if gdf.crs is None:
+        raise ValueError("gdf must have a defined CRS.")
+    if resolution <= 0:
+        raise ValueError("resolution must be > 0.")
+    if valueField not in gdf.columns:
+        raise ValueError(f"valueField '{valueField}' not found in gdf.")
+
+    # compute raster shape + transform
+    bounds = gdf.total_bounds  # (minx, miny, maxx, maxy)
+    width = int(numpy.ceil((bounds[2] - bounds[0]) / float(resolution)))
+    height = int(numpy.ceil((bounds[3] - bounds[1]) / float(resolution)))
+    if width < 1 or height < 1:
+        raise ValueError("computed raster dimensions are invalid (check resolution and bounds).")
+
+    transform = from_bounds(bounds[0], bounds[1], bounds[2], bounds[3], width, height)
+
+    # infer dtype + nodata
+    pandasDtype = gdf[valueField].dtype
+    if numpy.issubdtype(pandasDtype, numpy.floating):
+        dtype = numpy.float32
+        nodata = numpy.nan
+        fillValue = numpy.nan
+    elif numpy.issubdtype(pandasDtype, numpy.bool_):
+        dtype = numpy.uint8
+        nodata = 255  # sentinel for bool raster
+        fillValue = nodata
+    else:
+        dtype = numpy.int32
+        nodata = -9999
+        fillValue = nodata
+
+    # prefill target array
+    raster = numpy.full((height, width), fillValue, dtype=dtype)
+
+    # build shapes generator (ensure python scalars)
+    shapes = ((geom, (None if numpy.isnan(val) else val) if isinstance(val, float) else int(val) if numpy.issubdtype(type(val), numpy.integer) else float(val))
+              for geom, val in zip(gdf.geometry, gdf[valueField]))
+
+    # burn
+    features.rasterize(
+        shapes=shapes,
+        out_shape=raster.shape,
+        transform=transform,
+        fill=fillValue,
+        out=raster,
+        all_touched=allTouched,
+        dtype=dtype
+    )
+
+    # default profile settings
+    profile = {
+        "driver": "COG" if isCOG else "GTiff",
+        "height": raster.shape[0],
+        "width": raster.shape[1],
+        "count": 1,
+        "dtype": raster.dtype,
+        "crs": gdf.crs,
+        "transform": transform,
+        "nodata": nodata,
+    }
+    # sane compression defaults
+    if isCOG:
+        profile.setdefault("compress", "LZW")
+        profile.setdefault("blocksize", 512)  # GDAL COG option via rasterio
+        # overviews are handled by the COG driver
+    else:
+        profile.setdefault("compress", "LZW"),
+        profile.setdefault("tiled", True)
+        profile.setdefault("blockxsize", 512)
+        profile.setdefault("blockysize", 512)
+
+    if profileOverrides:
+        profile.update(profileOverrides)
+
+    # write
+    with rasterio.open(outRasterFN, "w", **profile) as dst:
+        dst.write(raster, 1)
+
+    return outRasterFN
+
+
 def moveDirectory(srcDir:str, destDir:str, v:bool = False) -> bool:
     '''
     this function moves all files from srcDir to destDir
@@ -1588,9 +1834,9 @@ def showProgress(count: int, end: int, message: str, barLength: int = 100) -> No
     percentStr = f'{percent:03.1f}'
     filled = int(barLength * count / end)
     bar = '█' * filled + '░' * (barLength - filled)
-    print(f'\r{message} |{bar}| {percent}% [{count}/{end}]', end='', flush=True)
+    print(f'\r{message} |{bar}| {percentStr}% [{count}/{end}]', end='', flush=True)
     if count == end:
-        print(f'\r{message} |{bar}| {percent}% [{count}/{end}]                          ', end='', flush=True)
+        print(f'\r{message} |{bar}| {percentStr}% [{count}/{end}]                          ', end='', flush=True)
         print()
 
 
@@ -2023,7 +2269,7 @@ def getTimeseriesStats(data:pandas.DataFrame, observed:Optional[str] = None, sim
 
     return stats
 
-def readSWATPlusOutputs(filePath: str, column: Optional[str] = None, unit: Optional[int] = None, gis_id: Optional[int] = None, name: Optional[str] = None) -> Optional[pandas.DataFrame]:
+def readSWATPlusOutputs(filePath: str, column: Optional[str] = None, unit: Optional[int] = None, gis_id: Optional[int] = None, name: Optional[str] = None, coerceNumeric: bool = True) -> Optional[pandas.DataFrame]:
     '''
     Read SWAT+ output files and return a pandas DataFrame with proper date handling
     and optional filtering capabilities.
@@ -2085,8 +2331,15 @@ def readSWATPlusOutputs(filePath: str, column: Optional[str] = None, unit: Optio
     # Convert all columns to numeric except 'name' (which is string)
     for col in df.columns:
         if col != 'name':
-            df[col] = pandas.to_numeric(df[col], errors='coerce')
+            if coerceNumeric:
+                df[col] = pandas.to_numeric(df[col], errors='coerce')
     
+    if not coerceNumeric:
+        # If not coercing to numeric, ensure date columns are numeric
+        for mandatoryCol in ['yr', 'mon', 'day', 'gis_id']:
+            if mandatoryCol in df.columns:
+                df[mandatoryCol] = pandas.to_numeric(df[mandatoryCol], errors='coerce')
+
     # Create date column from yr, mon, day
     try:
         df['date'] = pandas.to_datetime(pandas.DataFrame({'year': df.yr, 'month': df.mon, 'day': df.day}))
@@ -2126,4 +2379,5 @@ def readSWATPlusOutputs(filePath: str, column: Optional[str] = None, unit: Optio
     
     return df
 
+
 ignoreWarnings()

{ccfx-1.0.8.dist-info → ccfx-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ccfx
-Version: 1.0.8
+Version: 1.1.0
 Summary: This package simplifies regular common actions for quick prototyping in a user friendly way
 Author-email: Celray James CHAWANDA <celray@chawanda.com>
 License-Expression: MIT
@@ -26,6 +26,9 @@ Requires-Dist: mutagen
 Requires-Dist: requests
 Requires-Dist: tqdm
 Requires-Dist: pillow
+Requires-Dist: scipy
+Requires-Dist: rasterio
+Requires-Dist: matplotlib
 Dynamic: license-file
 
 # ccfx

{ccfx-1.0.8.dist-info → ccfx-1.1.0.dist-info}/RECORD

@@ -1,11 +1,11 @@
 ccfx/__init__.py,sha256=UK62VcGS84SJyGVg1bK4FltZj7OkpdoyhoFWeXcKsX0,144
-ccfx/ccfx.py,sha256=0i4XemdSzj3HY-kfSZ26qeDjnNyyNpIKlp0tvcE6vP4,76939
+ccfx/ccfx.py,sha256=st_zG-KXcqM9K2HjyontOwrR8FpZGbSZyHz0OvPHjoU,86682
 ccfx/excel.py,sha256=vm_cm4huKKx4_Nstr5neJzhBLmoZjg8qxjzz4hcF5hg,4754
 ccfx/mssqlConnection.py,sha256=C3HxzgZHmHy_de9EbMaXzR8NrkJxwHc8a00qzxQu_gs,8984
 ccfx/sqliteConnection.py,sha256=pOT9BBEAcm2kmoS0yBkUi4m9srQVe62J4xG5bnddvis,16207
 ccfx/word.py,sha256=AGa64jX5Zl5qotZh5L0QmrsjTnktIBhmj_ByRKZ88vw,3061
-ccfx-1.0.8.dist-info/licenses/LICENSE,sha256=EuxaawJg_OOCLfikkCGgfXPZmxR-x_5PH7_2e9M-3eA,1099
-ccfx-1.0.8.dist-info/METADATA,sha256=5OweW94ia3GPVjjHmZd8nzklqRtX5oC9uS4Tokr375E,11282
-ccfx-1.0.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-ccfx-1.0.8.dist-info/top_level.txt,sha256=_cSvSA1WX2K8TgoV3iBJUdUZZqMKJbOPLNnKLYSLHaw,5
-ccfx-1.0.8.dist-info/RECORD,,
+ccfx-1.1.0.dist-info/licenses/LICENSE,sha256=EuxaawJg_OOCLfikkCGgfXPZmxR-x_5PH7_2e9M-3eA,1099
+ccfx-1.1.0.dist-info/METADATA,sha256=hi23r9sqTM-JPXyRrkuGG-0yamVxPCZeJ1qNCPMB5I0,11353
+ccfx-1.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+ccfx-1.1.0.dist-info/top_level.txt,sha256=_cSvSA1WX2K8TgoV3iBJUdUZZqMKJbOPLNnKLYSLHaw,5
+ccfx-1.1.0.dist-info/RECORD,,