pingmapper 5.3.0__tar.gz → 5.3.2__tar.gz

{pingmapper-5.3.0 → pingmapper-5.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.3.0
+Version: 5.3.2
 Summary: Open-source interface for processing recreation-grade side scan sonar datasets and reproducibly mapping benthic habitat
 Author: Daniel Buscombe
 Author-email: Cameron Bodine <bodine.cs@gmail.email>

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/class_mapSubstrateObj.py

@@ -119,7 +119,7 @@ class mapSubObj(rectObj):
         # Save predictions to npz
         self._saveSubstrateNpz(substratePred, i, MY_CLASS_NAMES)
 
-        del self.substrateModel, substratePred
+        del substratePred
         gc.collect()
 
         return
@@ -198,8 +198,20 @@ class mapSubObj(rectObj):
             del sonWin, wStart, wEnd, softmax_score, est_label
 
         # Take mean across all windows to get one final softmax_score array
-        fSoftmax = np.nanmean(np.stack(winSoftMax, axis=0), axis=0)
+        # Compute nan-mean incrementally to avoid allocating a large stacked array
+        _first = winSoftMax[0]
+        fSum = np.where(~np.isnan(_first), _first, 0.0)
+        fCount = (~np.isnan(_first)).astype(np.float32)
+        del _first
+        for _arr in winSoftMax[1:]:
+            _valid = ~np.isnan(_arr)
+            fSum += np.where(_valid, _arr, 0.0)
+            fCount += _valid
+            del _arr, _valid
         del winSoftMax
+        with np.errstate(invalid='ignore'):
+            fSoftmax = np.where(fCount > 0, fSum / fCount, np.nan)
+        del fSum, fCount
 
         # Crop center chunk predictions and recover original dims
         h, w = origDims # Center chunks original dims

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/class_portstarObj.py

@@ -1349,7 +1349,7 @@ class portstarObj(object):
         del son3bnd, init_label, init_prob, crop_label, crop_prob, sonCrop
         del maxDepths, minDepths, avgDepths, Wp, portDepPixCrop, starDepPixCrop
         del portDepPix, starDepPix
-        del model, self.bedpickModel ######## Not sure about this one...
+        del model
 
         # return #self
         return portDepPixFinal, starDepPixFinal, i
@@ -2052,7 +2052,7 @@ class portstarObj(object):
         port_pix = self._getShadowPix(port_label, remShadow)
         star_pix = self._getShadowPix(star_label, remShadow)
 
-        del self.shadowModel, model
+        del model
         gc.collect()
         return i, port_pix, star_pix
 
@@ -2101,48 +2101,24 @@ class portstarObj(object):
             del son.sonDat
 
             # Get rid of zeros along water column area
+            # Vectorized: replace class-8 (water column) labels in non-WC area with 0
+            dep_arr = np.asarray(son.bedPick, dtype=int)  # (W,)
+            row_idx = np.arange(label.shape[0])[:, np.newaxis]  # (H, 1)
+            below_wc = row_idx >= dep_arr[np.newaxis, :]  # (H, W)
+            label = np.where(below_wc & (label == 8), 0, label)
+
+            # Zero-fill per ping: propagate the class at the edge of any zero region
+            # into that region. Zeros should form at most one contiguous block per ping
+            # (the comment in the original confirms this). Skip pings with no zeros.
             for p in range(label.shape[1]):
-                # Get depth
-                d = son.bedPick[p]
-
-                # Get ping classification
-                ping = label[:, p]
-
-                # Get water column
-                wc = ping[:d]
-
-                # Remove water column
-                ping = ping[d:]
-
-                # If any water column pics remain, set to zero
-                ping = np.where(ping==8, 0, ping)
-
-                ##############
-                # Remove zeros
-                # Find zeros. Should be grouped in contiguous arrays (array[0, 1, 2], array[100, 101, 102], ...
-                zero = np.where(ping==0)
-
-                if len(zero[0])>0:
-                    for z in zero:
-                        # Get index of first and last zero
-                        f, l = z[0], z[-1]
-
-                        # Don't fall off edge
-                        if l+1 < ping.shape[0]:
-
-                            # Get classification of next pixel
-                            c = ping[l+1]
-
-                            # Fill zero region with c
-                            ping[f:l+1] = c
-
-                    # Add water column back in
-                    ping = list(wc)+list(ping)
-
-                    # Update objects filled with ping
-                    label[:, p] = ping
-
-                del ping
+                d = int(son.bedPick[p])
+                ping_below = label[d:, p]
+                zero_idx = np.where(ping_below == 0)[0]
+                if len(zero_idx) == 0:
+                    continue
+                f, l = int(zero_idx[0]), int(zero_idx[-1])
+                if d + l + 1 < label.shape[0]:
+                    label[d + f : d + l + 1, p] = ping_below[l + 1]
 
             son.sonDat = label
 
@@ -2299,30 +2275,58 @@ class portstarObj(object):
             # # Do shadow and water column removal
 
             # Store pred stack in variable
-            predStack = son.sonDat
-
-            # Iterate each classification layer
-            for c in range(classes):
-                # Get class prediction
-                son.sonDat = predStack[:,:,c]
-
-                # Remove shadows
-                # Get mask
-                son._SHW_mask(chunk, son=False)
+            predStack = son.sonDat  # (H, W, C)
+            H_pred, W_pred, C_pred = predStack.shape
 
-                # Mask out shadows
-                son.sonDat = son.sonDat*son.shadowMask
-
-                # Remove Water Column
-                son._WCR_SRC(sonMeta, son=False)
-
-                # Update predStack
-                predStack[:,:,c] = son.sonDat
-
-                del son.sonDat
+            # Compute shadow mask ONCE — geometry depends only on son.shadow[chunk],
+            # not on which class band we are processing.
+            son.sonDat = predStack[:, :, 0]
+            son._SHW_mask(chunk, son=False)
+            shw_mask = son.shadowMask  # (H, W)
+            del son.shadowMask
 
-            # Store in son.sonDat
-            son.sonDat = predStack
+            # Apply shadow mask to all classes in a single vectorised broadcast
+            predStack = predStack * shw_mask[:, :, np.newaxis]
+
+            # Apply slant range correction (SRC) to all classes in one pass.
+            # Original _WCR_SRC ran an O(H) Python inner loop for every (class, ping)
+            # pair.  Here we vectorise the H dimension with numpy and process all C
+            # classes simultaneously, reducing Python iterations from C×W×H → W×C.
+            bedPick = round(sonMeta['dep_m'] / sonMeta['pixM'], 0).astype(int).reset_index(drop=True)
+            srcStack = np.zeros((H_pred, W_pred, C_pred), dtype=np.float32)
+            for j in range(W_pred):
+                depth = int(bedPick[j])
+                if depth >= H_pred:
+                    continue
+                dd = float(depth * depth)
+                row_arr = np.arange(depth, H_pred)
+                src_idx = np.round(
+                    np.sqrt(row_arr.astype(np.float64) ** 2 - dd)
+                ).astype(int)
+                valid = src_idx < H_pred
+                rows_v = row_arr[valid]
+                sidx_v = src_idx[valid]
+                if len(sidx_v) == 0:
+                    continue
+                data_extent = int(sidx_v[-1])
+
+                # Scatter all C classes at once, then zero past range extent
+                pingStack = np.full((H_pred, C_pred), np.nan, dtype=np.float32)
+                pingStack[sidx_v, :] = predStack[rows_v, j, :].astype(np.float32)
+                pingStack[data_extent:, :] = 0
+
+                # Interpolate gaps — NaN pattern is geometry-driven, same for all classes
+                nans = np.isnan(pingStack[:, 0])
+                if nans.any():
+                    x = np.arange(H_pred)
+                    xnans, xvalid = x[nans], x[~nans]
+                    for c in range(C_pred):
+                        pingStack[nans, c] = np.interp(
+                            xnans, xvalid, pingStack[~nans, c]
+                        )
+                srcStack[:, j, :] = pingStack
+
+            son.sonDat = srcStack
 
         # Iterate each class again and:
         for c in range(classes):
@@ -2411,6 +2415,20 @@ class portstarObj(object):
 
 
 
+    #=======================================================================
+    def _preloadRectifyCache(self):
+        '''
+        Pre-load the trackline and sonar-metadata CSVs that _rectify reads
+        on every chunk call.  Call this ONCE on the portstarObj in the main
+        process before Parallel dispatch so that each serialised copy of the
+        object already has the data, avoiding per-chunk disk reads.
+        '''
+        portTrkMetaFile = os.path.join(self.port.metaDir, "Trackline_Smth_"+self.port.beamName+".csv")
+        starTrkMetaFile = os.path.join(self.star.metaDir, "Trackline_Smth_"+self.star.beamName+".csv")
+        self.port._trkMetaDF = pd.read_csv(portTrkMetaFile)
+        self.star._trkMetaDF = pd.read_csv(starTrkMetaFile)
+        self.port._loadSonMeta()   # populates self.port.sonMetaDF
+
     #=======================================================================
     def _rectify(self, dat, chunk, imgOutPrefix, filt=50, wgs=False, return_rect=False):
         '''
@@ -2473,8 +2491,11 @@ class portstarObj(object):
 
         ###
         # Get top (port range) coordinates
-        trkMeta = pd.read_csv(portTrkMetaFile)
-        trkMeta = trkMeta[trkMeta['chunk_id']==chunk].reset_index(drop=False) # Filter df by chunk_id
+        # Cache the full CSV on self.port so we only read from disk once per portstarObj
+        if not hasattr(self.port, '_trkMetaDF') or self.port._trkMetaDF is None:
+            self.port._trkMetaDF = pd.read_csv(portTrkMetaFile)
+        portTrkFull = self.port._trkMetaDF
+        trkMeta = portTrkFull[portTrkFull['chunk_id']==chunk].reset_index(drop=False)
 
         # Get range (outer extent) coordinates [xR, yR] to transposed numpy arrays
         xTop, yTop = trkMeta[xRange].to_numpy().T, trkMeta[yRange].to_numpy().T
@@ -2482,8 +2503,11 @@ class portstarObj(object):
 
         ###
         # Get bottom (star range) coordinates
-        trkMeta = pd.read_csv(starTrkMetaFile)
-        trkMeta = trkMeta[trkMeta['chunk_id']==chunk].reset_index(drop=False) # Filter df by chunk_id
+        # Cache the full CSV on self.star so we only read from disk once per portstarObj
+        if not hasattr(self.star, '_trkMetaDF') or self.star._trkMetaDF is None:
+            self.star._trkMetaDF = pd.read_csv(starTrkMetaFile)
+        starTrkFull = self.star._trkMetaDF
+        trkMeta = starTrkFull[starTrkFull['chunk_id']==chunk].reset_index(drop=False)
 
         # Get range (outer extent) coordinates [xR, yR] to transposed numpy arrays
         xBot, yBot = trkMeta[xRange].to_numpy().T, trkMeta[yRange].to_numpy().T
@@ -2507,7 +2531,9 @@ class portstarObj(object):
 
         # Get pixel size
         # pix_m = self.port.pixM
-        self.port._loadSonMeta()
+        # Cache sonMetaDF — _loadSonMeta reads the same CSV every call
+        if not hasattr(self.port, 'sonMetaDF') or self.port.sonMetaDF is None:
+            self.port._loadSonMeta()
         isChunk = self.port.sonMetaDF['chunk_id']==chunk
         sonMeta = self.port.sonMetaDF[isChunk].reset_index()
 

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/class_sonObj.py

@@ -1310,43 +1310,55 @@ class sonObj(object):
         # bedPick = round(sonMeta['dep_m'] / sonMeta['pix_m'], 0).astype(int)
         bedPick = round(sonMeta['dep_m'] / sonMeta['pixM'], 0).astype(int).reset_index(drop=True)
 
+        H, W = self.sonDat.shape[0], self.sonDat.shape[1]
+
         # Initialize 2d array to store relocated sonar records
-        srcDat = np.zeros((self.sonDat.shape[0], self.sonDat.shape[1])).astype(np.float32)#.astype(int)
+        srcDat = np.zeros((H, W), dtype=np.float32)
+
+        # Iterate each ping.  The inner row-loop is replaced with numpy vector
+        # ops: compute all slant→horizontal index mappings at once, scatter
+        # intensities, then interpolate gaps.
+        for j in range(W):
+            depth = int(bedPick[j])  # depth at nadir (pixels)
+            if depth >= H:
+                continue
+            dd = float(depth * depth)
+
+            # Rows at or beyond the water column boundary
+            row_arr = np.arange(depth, H)
+            # Horizontal range index via Pythagorean theorem (vectorised)
+            src_idx = np.round(
+                np.sqrt(row_arr.astype(np.float64) ** 2 - dd)
+            ).astype(int)
+
+            # Discard out-of-bounds indices
+            valid = src_idx < H
+            rows_v = row_arr[valid]
+            sidx_v = src_idx[valid]
+            if len(sidx_v) == 0:
+                continue
 
-        #Iterate each ping
-        for j in range(self.sonDat.shape[1]):
-            depth = bedPick[j] # Get depth (in pixels) at nadir
-            dd = depth**2
-            # Create 1d array to store relocated bed pixels.  Set to nan so we
-            ## can later interpolate over gaps.
-            pingDat = (np.ones((self.sonDat.shape[0])).astype(np.float32)) * np.nan
-            dataExtent = 0
-            #Iterate each sonar/ping return
-            for i in range(self.sonDat.shape[0]):
-                if i >= depth:
-                    intensity = self.sonDat[i,j] # Get the intensity value
-                    srcIndex = int(round(math.sqrt(i**2 - dd),0)) #Calculate horizontal range (in pixels) using pathagorean theorem
-                    pingDat[srcIndex] = intensity # Store intensity at appropriate horizontal range
-                    dataExtent = srcIndex # Store range extent (max range) of ping
-                else:
-                    pass
-            pingDat[dataExtent:]=0 # Zero out values past range extent so we don't interpolate past this
+            data_extent = int(sidx_v[-1])
 
-            # Process of relocating bed pixels will introduce across track gaps
-            ## in the array so we will interpolate over gaps to fill them.
-            nans, x = np.isnan(pingDat), lambda z: z.nonzero()[0]
-            pingDat[nans] = np.interp(x(nans), x(~nans), pingDat[~nans])
+            # Scatter intensities; duplicate src_idx writes keep last value
+            pingDat = np.full(H, np.nan, dtype=np.float32)
+            pingDat[sidx_v] = self.sonDat[rows_v, j].astype(np.float32)
+            pingDat[data_extent:] = 0  # zero past range extent
+
+            # Interpolate across-track gaps introduced by SRC
+            nans = np.isnan(pingDat)
+            if nans.any():
+                x = np.arange(H)
+                pingDat[nans] = np.interp(x[nans], x[~nans], pingDat[~nans])
 
             # Store relocated ping in output array
             if son:
-                srcDat[:,j] = np.around(pingDat, 0)
+                srcDat[:, j] = np.around(pingDat, 0)
             else:
-                srcDat[:,j] = pingDat
-
-            del pingDat
+                srcDat[:, j] = pingDat
 
         if son:
-            self.sonDat = srcDat.astype(int) # Store in class attribute for later use
+            self.sonDat = srcDat.astype(int)  # Store in class attribute for later use
         else:
             self.sonDat = srcDat
         del srcDat

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/class_sonObj_nadirgaptest.py

@@ -934,75 +934,64 @@ class sonObj(object):
         # bedPick = round(sonMeta['dep_m'] / sonMeta['pix_m'], 0).astype(int)
         bedPick = round(sonMeta['dep_m'] / sonMeta['pixM'], 0).astype(int).reset_index(drop=True)
 
+        H, W = self.sonDat.shape[0], self.sonDat.shape[1]
+
         # Get max depth
         maxDep = max(bedPick)
         maxGap = int(round(np.tan(np.deg2rad(4)) * maxDep, 0)) # Max nadir gap (assume 4 degrees)
 
-        # Initialize 2d array to store relocated sonar records
-        srcDat = np.zeros((self.sonDat.shape[0]+maxGap, self.sonDat.shape[1])).astype(np.float32)#.astype(int)
+        H_out = H + maxGap
 
-        print(srcDat.shape, maxGap, self.sonDat.shape)
+        # Initialize 2d array to store relocated sonar records
+        srcDat = np.zeros((H_out, W), dtype=np.float32)
 
-        #Iterate each ping
-        for j in range(self.sonDat.shape[1]):
-            depth = bedPick[j] # Get depth (in pixels) at nadir
-            dd = depth**2
+        #Iterate each ping (inner row-loop replaced with numpy vector ops)
+        for j in range(W):
+            depth = int(bedPick[j])  # Get depth (in pixels) at nadir
+            dd = float(depth * depth)
 
-            # Calculate gap at nadir (assume 4 degrees)
+            # Calculate nadir gap (assume 4 degrees) for this ping
             nadirGap = int(round(np.tan(np.deg2rad(4)) * depth, 0))
 
-            print(depth, nadirGap)
-
-            # Create 1d array to store relocated bed pixels.  Set to nan so we
-            ## can later interpolate over gaps.
-            pingDat = (np.ones((self.sonDat.shape[0]+maxGap)).astype(np.float32)) * np.nan
-            dataExtent = 0
-
-            # # Calculate nadir gap (assume 4 degrees)
-            # nadirGap = int(round(np.tan(np.deg2rad(4)) * depth, 0))
+            # Rows at or beyond the water column boundary
+            row_arr = np.arange(depth, H)
+            # Horizontal range via Pythagorean theorem, plus nadir gap offset
+            src_idx = np.round(
+                np.sqrt(row_arr.astype(np.float64) ** 2 - dd)
+            ).astype(int) + nadirGap
 
-            #Iterate each sonar/ping return
-            for i in range(self.sonDat.shape[0]):
-                if i >= depth:
-                    intensity = self.sonDat[i,j] # Get the intensity value
-                    srcIndex = int(round(math.sqrt((i)**2 - dd),0)) #Calculate horizontal range (in pixels) using pathagorean theorem
+            # Discard out-of-bounds indices
+            valid = src_idx < H_out
+            rows_v = row_arr[valid]
+            sidx_v = src_idx[valid]
 
-                    srcIndex = srcIndex + nadirGap # Add nadir gap to horizontal range
+            pingDat = np.full(H_out, np.nan, dtype=np.float32)
+            if len(sidx_v) > 0:
+                data_extent = int(sidx_v[-1])
+                pingDat[sidx_v] = self.sonDat[rows_v, j].astype(np.float32)
+                pingDat[data_extent:] = 0  # Zero out values past range extent
 
-                    pingDat[srcIndex] = intensity # Store intensity at appropriate horizontal range
-                    dataExtent = srcIndex # Store range extent (max range) of ping
-                else:
-                    pass
-            pingDat[dataExtent:]=0 # Zero out values past range extent so we don't interpolate past this
-
-            # # Process of relocating bed pixels will introduce across track gaps
-            # ## in the array so we will interpolate over gaps to fill them.
-            # nans, x = np.isnan(pingDat), lambda z: z.nonzero()[0]
-            # pingDat[nans] = np.interp(x(nans), x(~nans), pingDat[~nans])
+            pingDat[:nadirGap] = np.nan  # Remove relocated water column
 
-            pingDat[:nadirGap] = np.nan # Zero out top maxGap pixels to remove relocated water column
-            print(pingDat)
-
-            # Find where firs non-zero pixel is
-            nonZero = np.where(pingDat>0)[0]
-            print(pingDat[nonZero])
-            
-            # Interpolate over gaps past nonZero
+            # Interpolate over gaps starting from first non-zero pixel
+            nonZero = np.where(pingDat > 0)[0]
             if len(nonZero) > 0:
                 firstNonZero = nonZero[0]
-                nans, x = np.isnan(pingDat[firstNonZero:]), lambda z: z.nonzero()[0]
-                pingDat[firstNonZero:][nans] = np.interp(x(nans), x(~nans), pingDat[firstNonZero:][~nans])
+                tail = pingDat[firstNonZero:]
+                nans = np.isnan(tail)
+                if nans.any():
+                    x = np.arange(len(tail))
+                    tail[nans] = np.interp(x[nans], x[~nans], tail[~nans])
+                    pingDat[firstNonZero:] = tail
 
             # Store relocated ping in output array
             if son:
-                srcDat[:,j] = np.around(pingDat, 0)
+                srcDat[:, j] = np.around(pingDat, 0)
             else:
-                srcDat[:,j] = pingDat
-
-            del pingDat
+                srcDat[:, j] = pingDat
 
         if son:
-            self.sonDat = srcDat.astype(int) # Store in class attribute for later use
+            self.sonDat = srcDat.astype(int)  # Store in class attribute for later use
         else:
             self.sonDat = srcDat
         del srcDat

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/doWork.py

@@ -266,6 +266,7 @@ def doWork(
                 'inFile': in_file,
                 'sonFiles': son_files,
                 'projDir': proj_dir,
+                'return_context': True,
             })
 
             print('\n\n', '***User Parameters***')
@@ -281,7 +282,13 @@ def doWork(
             print('\n===========================================')
             print('===========================================')
             print('***** READING *****')
-            ss_chan_avail = read_master_func(**run_params)
+            read_ctx = read_master_func(**run_params)
+            if isinstance(read_ctx, dict):
+                ss_chan_avail = bool(read_ctx.get('has_sidescan', False))
+                nav_available = bool(read_ctx.get('has_nav', True))
+            else:
+                ss_chan_avail = bool(read_ctx)
+                nav_available = True
 
             if ss_chan_avail:
                 rect_wcp = run_params.get('rect_wcp', False)
@@ -293,6 +300,19 @@ def doWork(
                 export_poly = run_params.get('export_poly', False)
                 plt_subclass = run_params.get('pltSubClass', False)
 
+                if not nav_available:
+                    if rect_wcp or rect_wcr or banklines or coverage or pred_sub or map_sub or export_poly or plt_subclass:
+                        print('\nWARNING: Navigation info is unavailable for this recording.')
+                        print('Skipping rectification and substrate mapping workflows (non-georeferenced sonogram-only processing).')
+                    rect_wcp = False
+                    rect_wcr = False
+                    banklines = False
+                    coverage = False
+                    pred_sub = False
+                    map_sub = False
+                    export_poly = False
+                    plt_subclass = False
+
                 if rect_wcp or rect_wcr or banklines or coverage or pred_sub or map_sub or export_poly:
                     print('\n===========================================')
                     print('===========================================')

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/funcs_common.py

@@ -162,6 +162,12 @@ def quiet_tensorflow_warnings():
             tf.autograph.set_verbosity(0)
         except Exception:
             pass
+        try:
+            # Suppress Keras per-batch/per-step progress bar output
+            # (e.g. "1/1 [==============================] - 1s 1s/step")
+            tf.keras.utils.disable_interactive_logging()
+        except Exception:
+            pass
     except Exception:
         pass
 

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/funcs_model.py

@@ -42,6 +42,14 @@ from pingmapper.funcs_common import *
 quiet_tensorflow_warnings()
 import json
 import numpy as np
+
+# Prevent the transformers/huggingface_hub libraries from making network calls
+# to huggingface.co to check for model updates. The model weights are stored
+# locally, so no internet access is needed. These flags can also be set as
+# system environment variables (TRANSFORMERS_OFFLINE=1, HF_HUB_OFFLINE=1)
+# before launching PINGMapper to achieve the same effect without a code change.
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
 # import tensorflow as tf
 # import tensorflow.keras.backend as K
 # from tensorflow.python.client import device_lib
@@ -114,6 +122,47 @@ Utilities provided courtesy Dr. Dan Buscombe from segmentation_gym
 https://github.com/Doodleverse/segmentation_gym
 '''
 
+#=======================================================================
+def _build_segformer_from_config(id2label, num_classes, num_channels=3):
+    '''
+    Construct a SegFormer model (nvidia/mit-b0 backbone architecture) entirely
+    from a hardcoded local config, without contacting HuggingFace Hub.
+
+    The config values below are the canonical mit-b0 architecture spec.
+    The backbone weights loaded here are random initialisation — they are
+    immediately overwritten by model.load_weights() with the Zenodo-hosted
+    fine-tuned weights, so no HF-sourced weights are ever used.
+    '''
+    from transformers import TFSegformerForSemanticSegmentation, SegformerConfig
+
+    label2id = {label: id for id, label in id2label.items()}
+
+    config = SegformerConfig(
+        num_channels=num_channels,
+        num_encoder_blocks=4,
+        depths=[2, 2, 2, 2],
+        sr_ratios=[8, 4, 2, 1],
+        hidden_sizes=[32, 64, 160, 256],
+        patch_sizes=[7, 3, 3, 3],
+        strides=[4, 2, 2, 2],
+        num_attention_heads=[1, 2, 5, 8],
+        mlp_ratios=[4, 4, 4, 4],
+        hidden_act='gelu',
+        hidden_dropout_prob=0.0,
+        attention_probs_dropout_prob=0.0,
+        classifier_dropout_prob=0.1,
+        initializer_range=0.02,
+        drop_path_rate=0.1,
+        layer_norm_eps=1e-06,
+        decoder_hidden_size=256,
+        semantic_loss_ignore_index=255,
+        num_labels=num_classes,
+        id2label=id2label,
+        label2id=label2id,
+    )
+
+    return TFSegformerForSemanticSegmentation(config)
+
 #=======================================================================
 def initModel(weights, configfile, USE_GPU=False):
     '''
@@ -192,10 +241,21 @@ def initModel(weights, configfile, USE_GPU=False):
         id2label = {}
         for k in range(NCLASSES):
             id2label[k]=str(k)
-        model = segformer(id2label,num_classes=NCLASSES)
+        # SegFormer always uses 3 input channels: seg_file2tensor() converts
+        # single-channel images to 3-channel via np.dstack before inference,
+        # so the Zenodo weights are always saved with num_channels=3.
+        model = _build_segformer_from_config(id2label, NCLASSES, num_channels=3)
+        # Subclassed Keras models are lazy — variables don't exist until the
+        # first forward pass. Do a dummy call to build them so load_weights()
+        # can match the saved HDF5 file's variable names.
+        # Input to TFSegformer is NCHW: (batch, channels, height, width)
+        dummy = tf.zeros((1, 3, TARGET_SIZE[0], TARGET_SIZE[1]))
+        model(dummy, training=False)
 
     model.load_weights(weights)
-    # model = compile_models([model[0]], MODEL)
+    # Compile once here so doPredict never needs to recompile between chunks.
+    # compile_models mutates the model in-place; we discard the returned list.
+    compile_models([model], MODEL)
 
     return model, MODEL, N_DATA_BANDS
 
@@ -209,7 +269,8 @@ def doPredict(model, MODEL, arr, N_DATA_BANDS, NCLASSES, TARGET_SIZE, OTSU_THRES
     '''
     '''
 
-    model = compile_models([model[0]], MODEL)
+    # Model is compiled once in initModel; just normalise to a list here.
+    model = [model[0]]
 
     # Read array into a cropped and resized tensor
     image, w, h, bigimage = seg_file2tensor(arr, N_DATA_BANDS, TARGET_SIZE, MODEL)

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/main_mapSubstrate.py

@@ -107,7 +107,10 @@ def map_master_func(logfilename='',
                     mosaic_nchunk=50,
                     mosaic=False,
                     map_mosaic=0,
-                    banklines=False):
+                    banklines=False,
+                    export_16bit=False,
+                    export_16bit_colormap=False,
+                    export_colormap_uint8=True):
 
     '''
     Main script to map substrates from side scan sonar imagery.
@@ -182,6 +185,15 @@ def map_master_func(logfilename='',
             pass # Don't add non-port/star objects since they can't be rectified
     del son, beam, sonObjs
 
+    if len(mapObjs) == 0:
+        print("\nNo side-scan channels available for substrate mapping. Skipping mapping.")
+        return
+
+    nav_available = all(getattr(son, 'trans', None) is not None for son in mapObjs)
+    if not nav_available:
+        print("\nNavigation info unavailable for side-scan channels. Skipping substrate mapping.")
+        return
+
     ################################################
     # Prepare output directory and update attributes
     for son in mapObjs:
@@ -399,6 +411,9 @@ def map_master_func(logfilename='',
         # Create portstarObj
         psObj = portstarObj(mapObjs)
 
+        # Pre-load CSVs once so each joblib-serialised copy already has the data
+        psObj._preloadRectifyCache()
+
         Parallel(n_jobs=safe_n_jobs(len(toMap), threadCnt))(delayed(psObj._mapSubstrate)(map_class_method, c, f) for c, f in tqdm(toMap.items()))
 
         del toMap

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/main_readFiles.py

@@ -157,7 +157,8 @@ def read_master_func(logfilename='',
                      mosaic_nchunk=50,
                      mosaic=False,
                      map_mosaic=0,
-                     banklines=False):
+                     banklines=False,
+                     return_context=False):
 
     '''
     Main script to read data from Humminbird sonar recordings. Scripts have been
@@ -303,28 +304,7 @@ def read_master_func(logfilename='',
     modelDir = get_segmentation_model_dir()
     if not os.path.exists(modelDir):
         downloadSegmentationModelsv1_0(modelDir)
-        getSegformer = True
-    else:
-        getSegformer = False
-
-    ###############
-    # Get segformer
-    if getSegformer:
-        NCLASSES = 8
-        id2label = {}
-        for k in range(NCLASSES):
-            id2label[k] = str(k)
-        
-        # try downloading segformer pretrained model
-        try:
-            _ = segformer(id2label, NCLASSES)
-        except:
-            print('\n\n\n\n')
-            print('ERROR! Unable to download pretrained SegFormer model!')
-            print('Your network settings are blocking the download.')
-            print('Please try running on a different network.')
-            print('Once the script has been run successfully, you should be able')
-            print('to run PING-Mapper on the current network.')
+
 
 
     ###############################################
@@ -393,6 +373,27 @@ def read_master_func(logfilename='',
         print('\n\nERROR!\n\nFile type {} not supported at this time.'.format(file_type))
         sys.exit()
 
+    nav_available = bool(getattr(sonar_obj, 'has_position', True))
+
+    # Sonar-only fallback for sources without navigation fields (e.g., some Cerulean logs).
+    # Disable filters that rely on geospatial motion/position so processing can continue.
+    if getattr(sonar_obj, 'has_position', True) is False:
+        nav_filters_requested = (
+            (max_heading_deviation > 0) or
+            (min_speed > 0) or
+            (max_speed > 0) or
+            bool(aoi)
+        )
+
+        if nav_filters_requested:
+            print('\nWARNING: Navigation fields are unavailable for this recording (sonar-only mode).')
+            print('Disabling nav-dependent filters: max_heading_deviation, min_speed, max_speed, aoi.')
+
+        max_heading_deviation = 0
+        min_speed = 0
+        max_speed = 0
+        aoi = False
+
     ####################
     # Create son objects
     ####################
@@ -1102,29 +1103,41 @@ def read_master_func(logfilename='',
         if _is_sidescan_beam(beam):
             portstar.append(son)
 
-    # Create portstarObj
-    psObj = portstarObj(portstar)
-
-    chunks = []
-    for son in portstar:
-        # Get chunk id's, ignoring those with nodata
-        c = son._getChunkID()
-
-        chunks.extend(c)
-        del c
-    del son
-
-    chunks = np.unique(chunks).astype(int)
+    psObj = None
+    chunks = np.array([], dtype=int)
 
-    if len(chunks) == 0:
+    if len(portstar) == 0:
         print(
-            '\n\nNo valid side-scan chunks available for depth processing. '\
+            '\n\nNo recognized side-scan channels available for depth processing. '\
             'Continuing with down-looking beams only.'
         )
         print('Disabling side-scan-only operations (auto depth, bedpick plot, shadow removal).')
         detectDep = 0
         pltBedPick = False
         remShadow = 0
+    else:
+        # Create portstarObj
+        psObj = portstarObj(portstar)
+
+        chunks = []
+        for son in portstar:
+            # Get chunk id's, ignoring those with nodata
+            c = son._getChunkID()
+
+            chunks.extend(c)
+            del c
+
+        chunks = np.unique(chunks).astype(int)
+
+        if len(chunks) == 0:
+            print(
+                '\n\nNo valid side-scan chunks available for depth processing. '\
+                'Continuing with down-looking beams only.'
+            )
+            print('Disabling side-scan-only operations (auto depth, bedpick plot, shadow removal).')
+            detectDep = 0
+            pltBedPick = False
+            remShadow = 0
 
     # # Automatically estimate depth
     if detectDep > 0:
@@ -1187,7 +1200,7 @@ def read_master_func(logfilename='',
 
     if saveDepth:
 
-        if ss_chan_avail:
+        if ss_chan_avail and psObj is not None:
             # Save detected depth to csv
             depDF = psObj._saveDepth(chunks, detectDep, smthDep, adjDep, instDepAvail)
         else:
@@ -1246,14 +1259,15 @@ def read_master_func(logfilename='',
         del depDF
 
         # Cleanup
-        psObj._cleanup()
+        if psObj is not None:
+            psObj._cleanup()
 
         print("\nDone!")
         print("Time (s):", round(time.time() - start_time, ndigits=1))
         printUsage()
 
     # Plot sonar depth and auto depth estimate (if available) on sonogram
-    if pltBedPick:
+    if pltBedPick and psObj is not None and len(chunks) > 0:
         start_time = time.time()
 
         print("\n\nExporting bedpick plots to {}...".format(tileFile))
@@ -1264,7 +1278,8 @@ def read_master_func(logfilename='',
         printUsage()
 
     # Cleanup
-    psObj._cleanup()
+    if psObj is not None:
+        psObj._cleanup()
     del psObj, portstar
 
     for son in sonObjs:
@@ -1638,8 +1653,13 @@ def read_master_func(logfilename='',
     gc.collect()
     printUsage()
 
-    if len(ss_chan_avail) == 0:
-        return False
-    else:
-        return True
+    has_sidescan = len(ss_chan_avail) > 0
+
+    if return_context:
+        return {
+            'has_sidescan': has_sidescan,
+            'has_nav': nav_available,
+        }
+
+    return has_sidescan
 

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper/main_rectify.py

@@ -307,6 +307,15 @@ def rectify_master_func(logfilename='',
             pass # Don't add non-port/star objects since they can't be rectified
     del son, beam, rectObjs
 
+    if len(portstar) == 0:
+        print("\nNo side-scan channels available for rectification. Skipping rectification.")
+        return
+
+    nav_available = all(getattr(son, 'trans', None) is not None for son in portstar)
+    if not nav_available:
+        print("\nNavigation info unavailable for side-scan channels. Skipping rectification.")
+        return
+
     ############################################################################
     # Smooth Trackline                                                         #
     ############################################################################

pingmapper-5.3.2/pingmapper/version.py

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

{pingmapper-5.3.0 → pingmapper-5.3.2}/pingmapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.3.0
+Version: 5.3.2
 Summary: Open-source interface for processing recreation-grade side scan sonar datasets and reproducibly mapping benthic habitat
 Author: Daniel Buscombe
 Author-email: Cameron Bodine <bodine.cs@gmail.email>

pingmapper-5.3.0/pingmapper/version.py

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