pingmapper 5.5.3__tar.gz → 5.5.5__tar.gz

{pingmapper-5.5.3 → pingmapper-5.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.5.3
+Version: 5.5.5
 Summary: Open-source interface for processing recreation-grade side scan sonar datasets and reproducibly mapping benthic habitat
 Author: Cameron Bodine, Daniel Buscombe, Iury T Simoes-Sousa
 Author-email: bodine.cs@gmail.email

{pingmapper-5.5.3 → pingmapper-5.5.5}/pingmapper/class_rectObj.py

@@ -554,18 +554,22 @@ class rectObj(sonObj):
                 fb[lats] = fb[ylat]
 
             if es not in fb.columns:
-                if xutm in fb.columns:
-                    fb[es] = fb[xutm]
-                elif lons in fb.columns and lats in fb.columns:
+                if lons in fb.columns and lats in fb.columns:
+                    # Prefer projecting lon/lat through self.trans (the correct
+                    # target EPSG) rather than reusing a raw xutm column, which
+                    # may hold a different (e.g. Humminbird-internal Web Mercator)
+                    # coordinate system and silently corrupt downstream geometry.
                     e_fb, _ = self.trans(fb[lons].to_numpy(), fb[lats].to_numpy())
                     fb[es] = e_fb
+                elif xutm in fb.columns:
+                    fb[es] = fb[xutm]
 
             if ns not in fb.columns:
-                if yutm in fb.columns:
-                    fb[ns] = fb[yutm]
-                elif lons in fb.columns and lats in fb.columns:
+                if lons in fb.columns and lats in fb.columns:
                     _, n_fb = self.trans(fb[lons].to_numpy(), fb[lats].to_numpy())
                     fb[ns] = n_fb
+                elif yutm in fb.columns:
+                    fb[ns] = fb[yutm]
 
             if 'cog' not in fb.columns:
                 if 'instr_heading' in fb.columns:
@@ -1099,6 +1103,26 @@ class rectObj(sonObj):
                     else:
                         continue
 
+                # Guard against spline overshoot: the linear spline fit to range
+                # extent coordinates can extrapolate far beyond the sonar's actual
+                # range near gaps left by upstream filtering (time/speed/coord
+                # outlier filters). Fall back to the geometrically-derived
+                # (un-smoothed) range extent point for any ping whose smoothed
+                # point lands unreasonably far from its trackline origin.
+                if {'record_num', 'range_lon', 'range_lat', 'utm_es', 'utm_ns', 'range'}.issubset(schunkDF.columns):
+                    e_smth_chk, n_smth_chk = self.trans(smthChunk['range_lons'].to_numpy(), smthChunk['range_lats'].to_numpy())
+                    chk = schunkDF[['record_num', 'utm_es', 'utm_ns', 'range', 'range_lon', 'range_lat']].set_index('record_num')
+                    chk = chk.reindex(smthChunk['record_num'].to_numpy())
+
+                    dist = np.hypot(e_smth_chk - chk['utm_es'].to_numpy(), n_smth_chk - chk['utm_ns'].to_numpy())
+                    max_expected = np.maximum(chk['range'].to_numpy(), 1.0) * 3.0 + 50.0
+                    bad = np.isfinite(dist) & (dist > max_expected)
+                    n_bad = int(np.sum(bad))
+                    if n_bad > 0:
+                        print(f"\n  _interpRangeCoords: corrected {n_bad} spline-overshoot range extent point(s) in chunk {chunk}.")
+                        smthChunk.loc[bad, 'range_lons'] = chk['range_lon'].to_numpy()[bad]
+                        smthChunk.loc[bad, 'range_lats'] = chk['range_lat'].to_numpy()[bad]
+
                 rs_chunks.append(smthChunk.copy())
 
         ##################################################
@@ -3000,6 +3024,34 @@ class rectObj(sonObj):
         # Set output name
         f_out = f.replace('temp.tif', '.tif')
 
+        # Sanity check the georeferenced extent before warping. A corrupt/outlier
+        # coordinate upstream can produce a geotransform spanning thousands of km,
+        # which causes gdal.Warp to attempt allocating a raster with an absurd
+        # pixel count (surfacing as a misleading "free disk space" GDAL error).
+        src = gdal.Open(f)
+        if src is not None:
+            gt = src.GetGeoTransform()
+            width_m = abs(gt[1]) * src.RasterXSize
+            height_m = abs(gt[5]) * src.RasterYSize
+            src = None
+
+            est_cols = width_m / pix_res
+            est_rows = height_m / pix_res
+
+            _MAX_PIXELS = 5e8  # ~500 million pixels safety cap
+            if est_cols * est_rows > _MAX_PIXELS:
+                print(
+                    f"\nWARNING: Skipping pixel resolution resize for {os.path.basename(f)}. "
+                    f"Georeferenced extent ({width_m:.1f} x {height_m:.1f} m) at {pix_res} m resolution "
+                    f"would require ~{est_cols*est_rows:,.0f} pixels. This indicates a corrupt or outlier "
+                    f"ping coordinate in this chunk. Keeping the un-resized GeoTiff instead."
+                )
+                try:
+                    os.rename(f, f_out)
+                except OSError:
+                    pass
+                return
+
         # Reopen f and warp to pix_res
         t = gdal.Warp(f_out, f, xRes = pix_res, yRes = pix_res, targetAlignedPixels=True)
 

{pingmapper-5.5.3 → pingmapper-5.5.5}/pingmapper/class_sonObj.py

@@ -1356,6 +1356,16 @@ class sonObj(object):
         arr[~valid] = 0.0
         return arr
 
+    def _normalize_with_bounds(self, data, lo, hi):
+        arr = np.asarray(data, dtype=np.float32)
+        arr[~np.isfinite(arr)] = 0.0
+
+        if (not np.isfinite(lo)) or (not np.isfinite(hi)) or hi <= lo:
+            return np.clip(arr, 0.0, 1.0).astype(np.float32)
+
+        norm = (arr - float(lo)) / (float(hi) - float(lo))
+        return np.clip(norm, 0.0, 1.0).astype(np.float32)
+
     def _apply_display_db_transform(self, sonDat):
         arr = np.asarray(sonDat, dtype=np.float32)
         if arr.size == 0:

{pingmapper-5.5.3 → pingmapper-5.5.5}/pingmapper/funcs_rectify.py

@@ -149,11 +149,44 @@ def smoothTrackline(projDir='', x_offset='', y_offset='', nchunk ='', cog=True,
             #     filter = int(nchunk*0.1)
 
             # print('\n\n\ntransect:', name, 'filter:', filter)
+            # Snapshot raw coordinates before _interpTrack() may drop duplicates
+            # in-place, so we can validate/repair the smoothed output below.
+            raw_lon = group['lon'].copy()
+            raw_lat = group['lat'].copy()
+
             smoothed = son._interpTrack(df=group, dropDup=True, filt=filter, deg=3)
 
             # smooth trackline fit
             # if smoothed is not None:
             if len(smoothed.columns) > 4:
+                # Guard against cubic spline overshoot (Runge's phenomenon) across
+                # long or gappy transects (e.g. gaps left by time/speed/coord
+                # outlier filters). Fall back to the raw GPS fix for any ping
+                # whose smoothed position was displaced further than the
+                # transect's own spatial extent would allow.
+                raw_e, raw_n = son.trans(raw_lon.to_numpy(), raw_lat.to_numpy())
+                raw_e = pd.Series(raw_e, index=raw_lon.index).reindex(smoothed.index).to_numpy()
+                raw_n = pd.Series(raw_n, index=raw_lat.index).reindex(smoothed.index).to_numpy()
+
+                smth_e, smth_n = son.trans(smoothed['lons'].to_numpy(), smoothed['lats'].to_numpy())
+
+                dist = np.hypot(smth_e - raw_e, smth_n - raw_n)
+                span = np.hypot(np.nanmax(raw_e) - np.nanmin(raw_e), np.nanmax(raw_n) - np.nanmin(raw_n))
+                max_allowed = max(span, 50.0) * 2.0
+
+                bad = np.isfinite(dist) & (dist > max_allowed)
+                n_bad = int(np.sum(bad))
+                if n_bad > 0:
+                    print(f"\n  smoothTrackline: corrected {n_bad} spline-overshoot trackline point(s) in transect {name}.")
+                    fix_lon = pd.Series(raw_lon.to_numpy(), index=raw_lon.index).reindex(smoothed.index).to_numpy()
+                    fix_lat = pd.Series(raw_lat.to_numpy(), index=raw_lat.index).reindex(smoothed.index).to_numpy()
+                    smoothed.loc[bad, 'lons'] = fix_lon[bad]
+                    smoothed.loc[bad, 'lats'] = fix_lat[bad]
+                    if 'utm_es' in smoothed.columns and 'utm_ns' in smoothed.columns:
+                        e_fix, n_fix = son.trans(smoothed.loc[bad, 'lons'].to_numpy(), smoothed.loc[bad, 'lats'].to_numpy())
+                        smoothed.loc[bad, 'utm_es'] = e_fix
+                        smoothed.loc[bad, 'utm_ns'] = n_fix
+
                 smoothed['transect'] = int(name)
                 sDF = pd.concat([sDF, smoothed], ignore_index=False)
 
@@ -166,6 +199,7 @@ def smoothTrackline(projDir='', x_offset='', y_offset='', nchunk ='', cog=True,
 
             del smoothed
 
+
         # Save sonDF
         if len(transect_dropped) > 0:
 

pingmapper-5.5.5/pingmapper/version.py

@@ -0,0 +1 @@
+__version__ = '5.5.5'

{pingmapper-5.5.3 → pingmapper-5.5.5}/pingmapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.5.3
+Version: 5.5.5
 Summary: Open-source interface for processing recreation-grade side scan sonar datasets and reproducibly mapping benthic habitat
 Author: Cameron Bodine, Daniel Buscombe, Iury T Simoes-Sousa
 Author-email: bodine.cs@gmail.email

pingmapper-5.5.3/pingmapper/version.py

@@ -1 +0,0 @@
-__version__ = '5.5.3'