pingmapper 5.5.4__tar.gz → 5.5.6__tar.gz

{pingmapper-5.5.4 → pingmapper-5.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.5.4
+Version: 5.5.6
 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.4 → pingmapper-5.5.6}/pingmapper/class_rectObj.py

@@ -2185,13 +2185,10 @@ class rectObj(sonObj):
         )
         del trkMeta
 
-        # Save to shp
-        trkMetaShp = os.path.basename(trkMetaFile).replace('csv', 'shp')
-        trkMetaShp = os.path.join(outDir, trkMetaShp)
-        gdf.to_file(trkMetaShp)
-        del trkMetaFile        
+        gdf['project'] = os.path.basename(self.projDir)
+        gdf['beam'] = self.beamName
 
-        return
+        return gdf
 
     #===========================================================================
     def _sanitizeProjectedTrackMeta(self, trkMeta, wgs=False):
@@ -2356,7 +2353,7 @@ class rectObj(sonObj):
             del chunk_geom
 
         if 'gdf' not in locals() or len(gdf) == 0:
-            return
+            return None
 
         gdf['chunk_id'] = gdf.index
 
@@ -2371,13 +2368,10 @@ class rectObj(sonObj):
 
         # gdf['geometry'] = gdf.buffer(-10, join_style=2)
 
-        # Save to shapefile
-        projName = os.path.basename(self.projDir)
-        outFile = os.path.join(self.metaDir, 'shapefiles', projName+"_"+beam+"_coverage.shp")
-        gdf.to_file(outFile)
-        del gdf
+        gdf['project'] = os.path.basename(self.projDir)
+        gdf['side'] = 'port' if beam.startswith('ss_port') else ('star' if beam.startswith('ss_star') else beam)
 
-        return
+        return gdf
             
     ############################################################################
     # Rectify sonar imagery - Rubbersheeting                                   #

{pingmapper-5.5.4 → pingmapper-5.5.6}/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.4 → pingmapper-5.5.6}/pingmapper/main_rectify.py

@@ -346,17 +346,25 @@ def rectify_master_func(logfilename='',
     if coverage:
         start_time = time.time()
         print("\nExporting coverage and trackline shapefiles:\n")
-        portstar[0]._exportTrkShp()
+        projName = os.path.basename(projDir)
+        shpDir = os.path.join(projDir, 'meta', 'shapefiles')
+        os.makedirs(shpDir, exist_ok=True)
 
-        trk_files = []
-        for son in portstar:
-            # trk_files.append(son.smthTrkFile)
-
-            son._exportCovShp()
+        trk_gdf = portstar[0]._exportTrkShp()
+        trk_gdf.to_file(os.path.join(shpDir, projName+'_trackline.shp'))
+        del trk_gdf
 
-        # print(trk_files)
-
-        # portstar[0]._exportCovShp(trk_files)
+        cov_gdfs = []
+        for son in portstar:
+            cov = son._exportCovShp()
+            if cov is not None:
+                cov_gdfs.append(cov)
+
+        if len(cov_gdfs) > 0:
+            cov_gdf = pd.concat(cov_gdfs, ignore_index=True)
+            cov_gdf.to_file(os.path.join(shpDir, projName+'_coverage.shp'))
+            del cov_gdf
+        del cov_gdfs
 
         print("Done!")
         print("Time (s):", round(time.time() - start_time, ndigits=1))

pingmapper-5.5.6/pingmapper/utils/kml2mosaic.py

@@ -0,0 +1,203 @@
+'''
+Create georeferenced GeoTIFF mosaics from SonarTRX-style KML files.
+
+The KML supplies each image tile's WGS84 LatLonBox. A VRT is generated
+directly from that information, referencing the original image tiles, and
+GDAL translates the VRT once to the final GeoTIFF. No per-tile conversion or
+Python pixel compositing is performed.
+'''
+
+import os
+import xml.etree.ElementTree as ET
+from glob import glob
+
+from osgeo import gdal
+from joblib import Parallel, delayed
+from tqdm import tqdm
+
+
+inKmlDir = r"D:\scratch\USGS_CERC_CarpSchools_All_Tiles\All_Tiles"
+inTileDir = inKmlDir
+outMosaicDir = r"D:\scratch\USGS_CERC_CarpSchools_All_Mosaics"
+outputFormat = 'tif'
+threadCnt = 16
+
+_KML_NS = '{http://www.opengis.net/kml/2.2}'
+
+
+def _findKmls(inKmlDir: str):
+    return sorted(glob(os.path.join(inKmlDir, '**', '*.kml'), recursive=True))
+
+
+def _parseKmlTiles(kmlPath: str, tileDir: str):
+    tree = ET.parse(kmlPath)
+    root = tree.getroot()
+    tiles = []
+
+    for overlay in root.iter('{}GroundOverlay'.format(_KML_NS)):
+        icon = overlay.find('{}Icon'.format(_KML_NS))
+        box = overlay.find('{}LatLonBox'.format(_KML_NS))
+        if icon is None or box is None:
+            continue
+
+        href = icon.find('{}href'.format(_KML_NS))
+        if href is None or not href.text:
+            continue
+
+        fileName = os.path.basename(href.text.replace('\\', '/'))
+        tilePath = os.path.join(tileDir, fileName)
+        if not os.path.isfile(tilePath):
+            continue
+
+        try:
+            north = float(box.find('{}north'.format(_KML_NS)).text)
+            south = float(box.find('{}south'.format(_KML_NS)).text)
+            east = float(box.find('{}east'.format(_KML_NS)).text)
+            west = float(box.find('{}west'.format(_KML_NS)).text)
+        except (AttributeError, TypeError, ValueError):
+            continue
+
+        if east <= west or north <= south:
+            continue
+
+        tiles.append({
+            'path': os.path.abspath(tilePath),
+            'north': north,
+            'south': south,
+            'east': east,
+            'west': west,
+        })
+
+    return tiles
+
+
+def _sourceInfo(tiles):
+    sources = []
+    for tile in tiles:
+        source = gdal.Open(tile['path'], gdal.GA_ReadOnly)
+        if source is None:
+            raise RuntimeError('GDAL could not open {}'.format(tile['path']))
+
+        sources.append({
+            **tile,
+            'width': source.RasterXSize,
+            'height': source.RasterYSize,
+            'bands': source.RasterCount,
+            'dataType': gdal.GetDataTypeName(source.GetRasterBand(1).DataType),
+        })
+        source = None
+
+    return sources
+
+
+def _sourceElement(source, bandNumber, colOff, rowOff):
+    sourceElement = ET.Element('ComplexSource')
+    ET.SubElement(sourceElement, 'SourceFilename', {'relativeToVRT': '0'}).text = source['path']
+    ET.SubElement(sourceElement, 'SourceBand').text = str(bandNumber)
+    ET.SubElement(sourceElement, 'SourceProperties', {
+        'RasterXSize': str(source['width']),
+        'RasterYSize': str(source['height']),
+        'DataType': source['dataType'],
+        'BlockXSize': str(source['width']),
+        'BlockYSize': '1',
+    })
+    ET.SubElement(sourceElement, 'SrcRect', {
+        'xOff': '0',
+        'yOff': '0',
+        'xSize': str(source['width']),
+        'ySize': str(source['height']),
+    })
+    ET.SubElement(sourceElement, 'DstRect', {
+        'xOff': str(colOff),
+        'yOff': str(rowOff),
+        'xSize': str(source['width']),
+        'ySize': str(source['height']),
+    })
+    ET.SubElement(sourceElement, 'NODATA').text = '0'
+    return sourceElement
+
+
+def _writeVrt(vrtPath: str, sources):
+    minx = min(source['west'] for source in sources)
+    maxx = max(source['east'] for source in sources)
+    miny = min(source['south'] for source in sources)
+    maxy = max(source['north'] for source in sources)
+
+    resX = (sources[0]['east'] - sources[0]['west']) / sources[0]['width']
+    resY = (sources[0]['north'] - sources[0]['south']) / sources[0]['height']
+    width = max(1, int(round((maxx - minx) / resX)))
+    height = max(1, int(round((maxy - miny) / resY)))
+    bandCount = max(source['bands'] for source in sources)
+
+    vrt = ET.Element('VRTDataset', {
+        'rasterXSize': str(width),
+        'rasterYSize': str(height),
+    })
+    ET.SubElement(vrt, 'SRS').text = 'EPSG:4326'
+    ET.SubElement(vrt, 'GeoTransform').text = '{}, {}, 0, {}, 0, -{}'.format(minx, resX, maxy, resY)
+
+    for bandNumber in range(1, bandCount + 1):
+        band = ET.SubElement(vrt, 'VRTRasterBand', {
+            'dataType': sources[0]['dataType'],
+            'band': str(bandNumber),
+        })
+        ET.SubElement(band, 'NoDataValue').text = '0'
+        if bandCount == 4 and bandNumber == 4:
+            ET.SubElement(band, 'ColorInterp').text = 'Alpha'
+
+        for source in sources:
+            if bandNumber > source['bands']:
+                continue
+            colOff = int(round((source['west'] - minx) / resX))
+            rowOff = int(round((maxy - source['north']) / resY))
+            band.append(_sourceElement(source, bandNumber, colOff, rowOff))
+
+    ET.ElementTree(vrt).write(vrtPath, encoding='UTF-8', xml_declaration=True)
+
+
+def buildMosaicFromKml(kmlPath: str, tileDir: str, outDir: str, outputFormat: str = 'tif'):
+    if outputFormat.lower().lstrip('.') not in ('tif', 'tiff'):
+        raise ValueError('Only GeoTIFF output is supported')
+
+    tiles = _parseKmlTiles(kmlPath, tileDir)
+    if not tiles:
+        return None
+
+    sources = _sourceInfo(tiles)
+    os.makedirs(outDir, exist_ok=True)
+    outPath = os.path.join(outDir, os.path.splitext(os.path.basename(kmlPath))[0] + '.tif')
+    vrtPath = os.path.splitext(outPath)[0] + '.vrt'
+
+    gdal.UseExceptions()
+    try:
+        _writeVrt(vrtPath, sources)
+        translated = gdal.Translate(
+            outPath,
+            vrtPath,
+            format='GTiff',
+            creationOptions=['TILED=YES', 'COMPRESS=LZW', 'BIGTIFF=IF_SAFER', 'NUM_THREADS=ALL_CPUS'],
+        )
+        if translated is None:
+            raise RuntimeError('GDAL failed to translate {}'.format(vrtPath))
+        translated = None
+        return outPath
+    finally:
+        if os.path.exists(vrtPath):
+            os.remove(vrtPath)
+
+
+def doWork():
+    os.makedirs(outMosaicDir, exist_ok=True)
+    kmlFiles = _findKmls(inKmlDir)
+    print('Found {} KML(s) under {}'.format(len(kmlFiles), inKmlDir))
+    results = list(Parallel(n_jobs=threadCnt)(
+        delayed(buildMosaicFromKml)(kmlPath, inTileDir, outMosaicDir, outputFormat)
+        for kmlPath in tqdm(kmlFiles)
+    ))
+    results = [result for result in results if result]
+    print('Wrote {} mosaic(s) to {}'.format(len(results), outMosaicDir))
+    return results
+
+
+if __name__ == '__main__':
+    doWork()

pingmapper-5.5.6/pingmapper/utils/tile2mosaic.py

@@ -0,0 +1,335 @@
+'''
+Group tiles (recursively found under inTileDir) into mosaics by matching
+components of their filenames, and combine overlapping pixels using
+overlap_method ('average', 'max', or 'min').
+
+Mosaicking uses rasterio + numpy in fixed-size blocks instead of GDAL's
+BuildVRT + Python VRT pixel-function approach. VRT pixel functions invoke a
+Python callback per raster block during gdal.Translate (slow), and naively
+accumulating whole-mosaic numpy arrays in memory can OOM on large mosaics.
+Processing/writing one block at a time keeps peak memory bounded by
+blockSize regardless of mosaic extent.
+'''
+
+#########
+# Imports
+
+import os
+import re
+import warnings
+from glob import glob
+
+import numpy as np
+import rasterio
+from rasterio.windows import Window
+from rasterio.transform import from_origin
+from joblib import Parallel, delayed, cpu_count
+from tqdm import tqdm
+
+
+############
+# Parameters
+
+inTileDir = r"D:\scratch\USGS_CERC_CarpSchools_All_Tiles\All_Tiles"
+
+# File pattern with delimiter
+delimiter = "-"
+filePattern = delimiter.join(["{recording}", "{tile}"]) + ".png"
+mosaicMatchPattern = delimiter.join(["{recording}"]) + ".png"
+
+outMosaicDir = r"D:\scratch\USGS_CERC_CarpSchools_All_Mosaics"
+overlap_method = "average"  # Options: 'average', 'max', 'min'
+
+outputFormat = "tif"  # Output mosaic file extension/format; independent of input tile extension
+
+force_greyscale = True  # Force output to be greyscale (single band) if True, else keep original bands
+tiles_overlap = True  # Set False when tile footprints are guaranteed not to overlap
+
+threadCnt = cpu_count()  # Number of mosaics to build in parallel
+
+blockSize = 2048  # Block edge (px) processed/written at a time; bounds peak memory use
+
+
+###########
+# Functions
+
+# GDAL driver for each supported output extension; GTiff is the only one
+# validated for windowed/blockwise writes used by buildMosaic.
+_DRIVER_BY_EXT = {
+    'tif': 'GTiff',
+    'tiff': 'GTiff',
+}
+
+
+def _driverForFormat(outputFormat: str):
+    ext = outputFormat.lower().lstrip('.')
+    if ext not in _DRIVER_BY_EXT:
+        raise ValueError("Unsupported outputFormat '{}'; supported: {}".format(outputFormat, sorted(_DRIVER_BY_EXT)))
+    return ext, _DRIVER_BY_EXT[ext]
+
+
+def _build_pattern_regex(filePattern: str, delimiter: str):
+    '''
+    Convert a delimiter-based file pattern (e.g. "{recording}_{tile}.tif")
+    into a compiled regex with named capture groups.
+    '''
+
+    fieldNames = re.findall(r'\{(\w+)\}', filePattern)
+
+    escaped = re.escape(filePattern)
+    for name in fieldNames:
+        placeholder = re.escape('{' + name + '}')
+        group = '(?P<{}>[^{}]+)'.format(name, re.escape(delimiter))
+        escaped = escaped.replace(placeholder, group)
+
+    return re.compile('^' + escaped + '$'), fieldNames
+
+
+def _findTiles(inTileDir: str, ext: str):
+    '''Recursively find all tile files under inTileDir with extension ext.'''
+
+    return sorted(glob(os.path.join(inTileDir, '**', '*' + ext), recursive=True))
+
+
+def _groupTiles(tileFiles: list, regex, mosaicMatchPattern: str):
+    '''
+    Group tile file paths by the mosaic key derived from mosaicMatchPattern,
+    using the named fields extracted from each filename via regex.
+    '''
+
+    groups = {}
+    skipped = []
+
+    for f in tileFiles:
+        m = regex.match(os.path.basename(f))
+        if not m:
+            skipped.append(f)
+            continue
+
+        fields = m.groupdict()
+        mosaicName = mosaicMatchPattern.format(**fields)
+        groups.setdefault(mosaicName, []).append(f)
+
+    return groups, skipped
+
+
+def _toGrey(arr: np.ndarray) -> np.ndarray:
+    '''Convert a (bands, H, W) array to single-band greyscale using luma weights.'''
+
+    if arr.shape[0] == 1:
+        return arr[0:1]
+
+    if arr.shape[0] >= 3:
+        r = arr[0].astype(np.float64)
+        g = arr[1].astype(np.float64)
+        b = arr[2].astype(np.float64)
+        grey = 0.299 * r + 0.587 * g + 0.114 * b
+        return grey[np.newaxis, ...]
+
+    # 2-band fallback
+    return arr.mean(axis=0, keepdims=True)
+
+
+def buildMosaic(mosaicName: str,
+                 tileList: list,
+                 outDir: str,
+                 overlap_method: str,
+                 force_greyscale: bool,
+                 outputFormat: str = 'tif',
+                 blockSize: int = 2048,
+                 tiles_overlap: bool = True):
+    '''
+    Merge tileList into a single mosaic GeoTIFF, combining overlapping
+    pixels per overlap_method. Processed and written one block at a time
+    (rasterio/numpy only, no GDAL VRT/pixel functions) so peak memory is
+    bounded by blockSize instead of the full mosaic extent.
+    '''
+
+    with warnings.catch_warnings():
+        warnings.filterwarnings('ignore', category=rasterio.errors.NotGeoreferencedWarning)
+        srcs = [rasterio.open(f) for f in tileList]
+
+    try:
+        ref = srcs[0]
+        resX, resY = ref.res
+        crs = ref.crs
+        dtype = ref.dtypes[0]
+        nodata = ref.nodata if ref.nodata is not None else 0
+        bandCnt = 1 if force_greyscale else ref.count
+
+        lefts, bottoms, rights, tops = zip(*(s.bounds for s in srcs))
+        minx, miny, maxx, maxy = min(lefts), min(bottoms), max(rights), max(tops)
+
+        width = max(1, int(round((maxx - minx) / resX)))
+        height = max(1, int(round((maxy - miny) / resY)))
+        outTransform = from_origin(minx, maxy, resX, resY)
+
+        if overlap_method not in ('average', 'max', 'min'):
+            raise ValueError("overlap_method must be 'average', 'max', or 'min'; got '{}'".format(overlap_method))
+
+        # Precompute each src's pixel offset/size within the full output grid
+        srcInfo = []
+        for s in srcs:
+            colOff = int(round((s.bounds.left - minx) / resX))
+            rowOff = int(round((maxy - s.bounds.top) / resY))
+            srcInfo.append((s, colOff, rowOff, s.width, s.height))
+
+        blockCols = (width + blockSize - 1) // blockSize
+        blockRows = (height + blockSize - 1) // blockSize
+        blockSources = [[] for _ in range(blockRows * blockCols)]
+        for sourceIndex, (_, colOff, rowOff, sWidth, sHeight) in enumerate(srcInfo):
+            firstBlockRow = max(0, rowOff // blockSize)
+            lastBlockRow = min(blockRows - 1, (rowOff + sHeight - 1) // blockSize)
+            firstBlockCol = max(0, colOff // blockSize)
+            lastBlockCol = min(blockCols - 1, (colOff + sWidth - 1) // blockSize)
+            for blockRow in range(firstBlockRow, lastBlockRow + 1):
+                for blockCol in range(firstBlockCol, lastBlockCol + 1):
+                    blockSources[blockRow * blockCols + blockCol].append(sourceIndex)
+
+        # Internal GTiff block size must be a multiple of 16 and not exceed raster dims
+        def _tiffBlockDim(dimSize):
+            dim = min(blockSize, dimSize)
+            dim = max(16, (dim // 16) * 16)
+            return dim
+
+        outExt, outDriver = _driverForFormat(outputFormat)
+        outName = os.path.splitext(mosaicName)[0] + '.' + outExt
+        outPath = os.path.join(outDir, outName)
+        profile = {
+            'driver': outDriver,
+            'height': height,
+            'width': width,
+            'count': bandCnt,
+            'dtype': dtype,
+            'crs': crs,
+            'transform': outTransform,
+            'nodata': nodata,
+            'compress': 'lzw',
+            'tiled': True,
+            'blockxsize': _tiffBlockDim(width),
+            'blockysize': _tiffBlockDim(height),
+            'BIGTIFF': 'IF_SAFER',
+        }
+
+        with rasterio.open(outPath, 'w', **profile) as dst:
+            if not tiles_overlap:
+                for s, colOff, rowOff, sWidth, sHeight in srcInfo:
+                    data = s.read()
+                    if force_greyscale:
+                        data = _toGrey(data.astype(np.float64))
+                    dst.write(
+                        data.astype(dtype),
+                        window=Window(col_off=colOff, row_off=rowOff, width=sWidth, height=sHeight),
+                    )
+                return outPath
+
+            for rowStart in range(0, height, blockSize):
+                bh = min(blockSize, height - rowStart)
+                for colStart in range(0, width, blockSize):
+                    bw = min(blockSize, width - colStart)
+
+                    if overlap_method == 'average':
+                        sumBlock = np.zeros((bandCnt, bh, bw), dtype=np.float64)
+                        cntBlock = np.zeros((bandCnt, bh, bw), dtype=np.uint32)
+                    else:
+                        outBlock = np.full((bandCnt, bh, bw), nodata, dtype=np.float64)
+                        hasBlock = np.zeros((bandCnt, bh, bw), dtype=bool)
+
+                    blockIndex = (rowStart // blockSize) * blockCols + (colStart // blockSize)
+                    for sourceIndex in blockSources[blockIndex]:
+                        s, colOff, rowOff, sWidth, sHeight = srcInfo[sourceIndex]
+                        # Intersection of this output block with the src's footprint
+                        interRow0 = max(rowStart, rowOff)
+                        interRow1 = min(rowStart + bh, rowOff + sHeight)
+                        interCol0 = max(colStart, colOff)
+                        interCol1 = min(colStart + bw, colOff + sWidth)
+
+                        if interRow0 >= interRow1 or interCol0 >= interCol1:
+                            continue
+
+                        srcWin = Window(
+                            col_off=interCol0 - colOff,
+                            row_off=interRow0 - rowOff,
+                            width=interCol1 - interCol0,
+                            height=interRow1 - interRow0,
+                        )
+                        data = s.read(window=srcWin, masked=True)
+
+                        if force_greyscale:
+                            filled = data.filled(nodata).astype(np.float64)
+                            grey = _toGrey(filled)
+                            validMask = np.any(~np.ma.getmaskarray(data), axis=0, keepdims=True)
+                            validMask &= np.any(data.data != nodata, axis=0, keepdims=True)
+                            filled = grey
+                            valid = np.broadcast_to(validMask, grey.shape)
+                        else:
+                            filled = data.filled(nodata).astype(np.float64)
+                            valid = (~np.ma.getmaskarray(data) & (data.data != nodata))
+
+                        bRow0 = interRow0 - rowStart
+                        bCol0 = interCol0 - colStart
+                        h, w = filled.shape[1], filled.shape[2]
+
+                        if overlap_method == 'average':
+                            sumBlock[:, bRow0:bRow0 + h, bCol0:bCol0 + w] += np.where(valid, filled, 0)
+                            cntBlock[:, bRow0:bRow0 + h, bCol0:bCol0 + w] += valid.astype(np.uint32)
+                        else:
+                            region = outBlock[:, bRow0:bRow0 + h, bCol0:bCol0 + w]
+                            regionHas = hasBlock[:, bRow0:bRow0 + h, bCol0:bCol0 + w]
+
+                            if overlap_method == 'max':
+                                take = valid & (~regionHas | (filled > region))
+                            else:  # min
+                                take = valid & (~regionHas | (filled < region))
+
+                            region[take] = filled[take]
+                            regionHas |= valid
+
+                    if overlap_method == 'average':
+                        with np.errstate(invalid='ignore', divide='ignore'):
+                            outBlock = np.where(cntBlock > 0, sumBlock / np.maximum(cntBlock, 1), nodata)
+
+                    dst.write(
+                        outBlock.astype(dtype),
+                        window=Window(col_off=colStart, row_off=rowStart, width=bw, height=bh),
+                    )
+
+        return outPath
+
+    finally:
+        for s in srcs:
+            if not s.closed:
+                s.close()
+
+
+def doWork():
+
+    os.makedirs(outMosaicDir, exist_ok=True)
+
+    ext = os.path.splitext(filePattern)[-1]
+    regex, _ = _build_pattern_regex(filePattern, delimiter)
+
+    tileFiles = _findTiles(inTileDir, ext)
+    print('Found {} tile(s) under {}'.format(len(tileFiles), inTileDir))
+
+    groups, skipped = _groupTiles(tileFiles, regex, mosaicMatchPattern)
+    if skipped:
+        print('Skipped {} file(s) not matching filePattern.'.format(len(skipped)))
+
+    print('Grouped into {} mosaic(s).'.format(len(groups)))
+
+    results = list(Parallel(n_jobs=threadCnt)(
+        delayed(buildMosaic)(mosaicName, tileList, outMosaicDir, overlap_method, force_greyscale, outputFormat, blockSize, tiles_overlap)
+        for mosaicName, tileList in tqdm(groups.items(), total=len(groups))
+    ))
+
+    print('Wrote {} mosaic(s) to {}'.format(len(results), outMosaicDir))
+
+    return results
+
+
+#########
+# Do Work
+
+if __name__ == '__main__':
+    doWork()

pingmapper-5.5.6/pingmapper/version.py

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

{pingmapper-5.5.4 → pingmapper-5.5.6}/pingmapper.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pingmapper
-Version: 5.5.4
+Version: 5.5.6
 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.4 → pingmapper-5.5.6}/pingmapper.egg-info/SOURCES.txt

@@ -38,7 +38,9 @@ pingmapper/scratch/main.py
 pingmapper/scratch/main_batchDirectory.py
 pingmapper/utils/RawEGN_avg_predictions.py
 pingmapper/utils/export_coverage.py
+pingmapper/utils/kml2mosaic.py
 pingmapper/utils/main_mosaic_transects.py
+pingmapper/utils/tile2mosaic.py
 pingmapper/utils/DRAFT_Workflows/avg_predictions_Mussel_WBL.py
 pingmapper/utils/DRAFT_Workflows/gen_centerline.py
 pingmapper/utils/DRAFT_Workflows/gen_centerline_from_bankline.py

pingmapper-5.5.4/pingmapper/version.py

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