pygeotools 1.1.2__py3-none-any.whl

pygeotools/__init__.py

@@ -0,0 +1,8 @@
+#! /usr/bin/env python
+
+#This allows the user to call libraries directly
+
+#For example:
+#from pygeotools import malib
+
+#from .lib import *

pygeotools/apply_mask.py

@@ -0,0 +1,116 @@
+#! /usr/bin/env python
+
+#David Shean
+#dshean@gmail.com
+
+#Utility to mask input raster using the mask from another raster 
+#Mask dataset can be a standard raster with nodata value specified or a binary mask
+#If a binary mask, values should be:
+#True (1) for masked, False (0) for valid - consistent with np.ma
+
+import sys, os
+import argparse
+
+import numpy as np
+from osgeo import gdal
+
+from pygeotools.lib import iolib
+from pygeotools.lib import warplib
+
+def getparser():
+    parser = argparse.ArgumentParser(description="Apply existing mask to input raster")
+    #Should add support for similar arguments as in warplib - arbitrary extent, res, etc
+    parser.add_argument('-extent', type=str, default='raster', \
+            choices=['raster','mask','intersection','union'], help='Desired output extent')
+    parser.add_argument('-invert', action='store_true', help='Invert input mask')
+    parser.add_argument('-mask_val', type=float, default=None, \
+            help='If input mask_fn is classified raster, specify value to use as mask')
+    parser.add_argument('-out_fn', type=str, default=None, help='Output filename')
+    parser.add_argument('src_fn', type=str, help='Input raster filename')
+    parser.add_argument('mask_fn', type=str, help='Input mask filename (can be existing raster with ndv, or binary mask)')
+    return parser
+
+def main():
+    parser = getparser()
+    args = parser.parse_args()
+
+    src_fn = args.src_fn
+    if not iolib.fn_check(src_fn):
+        sys.exit("Unable to find src_fn: %s" % src_fn)
+
+    mask_fn = args.mask_fn
+    if not iolib.fn_check(mask_fn):
+        sys.exit("Unable to find mask_fn: %s" % mask_fn)
+
+    #Determine output extent, default is input raster extent 
+    extent = args.extent 
+    if extent == 'raster':
+        extent = src_fn
+    elif extent == 'mask':
+        extent = mask_fn
+    else:
+        #This is a hack for intersection computation
+        src_ds_list = [gdal.Open(fn, gdal.GA_ReadOnly) for fn in [src_fn, mask_fn]]
+        #t_srs = geolib.get_ds_srs(src_ds_list[0])
+        extent = warplib.parse_extent(extent, src_ds_list, src_fn)
+
+    #Set resampling algorithm appropriately
+    r='cubic'
+    mask_val=args.mask_val
+    if mask_val is not None:
+        r='near'
+
+    print("Warping mask_fn")
+    mask_ds = warplib.memwarp_multi_fn([mask_fn,], res=src_fn, extent=extent, t_srs=src_fn, r=r)[0]
+
+    print("Loading mask array")
+    mask_ma_full = iolib.ds_getma(mask_ds)
+    mask_ds = None
+
+    print("Extracting mask")
+    if mask_val is not None:
+        #Use specified value
+        mask = ~((mask_ma_full == mask_val).data)
+    elif mask_ma_full.std() != 0:
+        #Input mask filename is a raster, or other masked array
+        #Just need to extract mask
+        mask = np.ma.getmaskarray(mask_ma_full)
+    else:
+        #Input mask filename is a mask, use directly
+        #If input mask values are zero, valid values are nonzero
+        #Bool True == 1, so need to invert
+        if mask_ma_full.fill_value == 0:
+            mask = ~((mask_ma_full.data).astype(bool))
+        else:
+            mask = (mask_ma_full.data).astype(bool)
+
+    #Free up memory
+    mask_ma_full = None
+
+    #Add dilation step for buffer
+
+    #newmask = np.logical_or(np.ma.getmaskarray(src_ma_full), mask)
+
+    if args.invert:
+        print("Inverting mask")
+        mask = ~(mask)
+
+    print("Loading src array and applying updated mask")
+    if extent == src_fn:
+        src_ds = gdal.Open(src_fn)
+    else:
+        src_ds = warplib.memwarp_multi_fn([src_fn,], res=src_fn, extent=extent, t_srs=src_fn)[0]
+
+    #Now load source array with new mask
+    src_ma_full = np.ma.array(iolib.ds_getma(src_ds), mask=mask)
+    mask = None
+
+    if args.out_fn is not None:
+        src_fn_masked = args.out_fn
+    else:
+        src_fn_masked = os.path.splitext(src_fn)[0]+'_masked.tif'
+    print("Writing out masked version of input raster: %s" % src_fn_masked )
+    iolib.writeGTiff(src_ma_full, src_fn_masked, src_ds, create=True)
+
+if __name__ == '__main__':
+    main()

pygeotools/clip_raster_by_shp.py

@@ -0,0 +1,64 @@
+#! /usr/bin/env python
+
+#David Shean
+#dshean@gmail.com
+
+#Clip input raster to polygons in input shapefile
+#Finally ported clip_raster_by_shp.sh to Python
+
+#TODO: Handle same arbitrary res/extent/t_srs as in warplib (isolate/generalize those functions)
+
+import os
+import sys
+import argparse
+
+import numpy as np  
+from osgeo import ogr
+
+from pygeotools.lib import iolib
+from pygeotools.lib import geolib
+
+def getparser():
+    parser = argparse.ArgumentParser(description="Clip input raster by input shp polygons")
+    #Should add support for similar arguments as in warplib - arbitrary extent, res, etc
+    parser.add_argument('-extent', type=str, default='raster', choices=['raster','shp','intersection','union'], 
+                        help='Desired output extent')
+    parser.add_argument('-bbox', action='store_true', help='Clip raster to shp bounding box, but dont mask')
+    parser.add_argument('-pad', type=float, default=None, help='Padding around shp extent, in raster units')
+    parser.add_argument('-invert', action='store_true', help='Invert the input polygons before clipping')
+    parser.add_argument('-out_fn', type=str, default=None, help='Output raster filename (default: *_shpclip.tif)')
+    parser.add_argument('r_fn', type=str, help='Input raster filename')
+    parser.add_argument('shp_fn', type=str, help='Input shp filename')
+    return parser
+
+def main():
+    parser = getparser()
+    args = parser.parse_args()
+
+    r_fn = args.r_fn
+    if not os.path.exists(r_fn):
+        sys.exit("Unable to find r_fn: %s" % r_fn)
+        
+    shp_fn = args.shp_fn
+    #Convenience shortcut to clip to glacier polygons (global shp)
+    #Requires demcoreg package: https://github.com/dshean/demcoreg
+    if shp_fn == 'RGI' or shp_fn == 'rgi':
+        from demcoreg.dem_mask import get_glacier_poly
+        rgi_fn = get_glacier_poly() 
+        shp_fn = rgi_fn
+
+    if not os.path.exists(shp_fn):
+        sys.exit("Unable to find shp_fn: %s" % shp_fn)
+
+    #Do the clipping
+    r, r_ds = geolib.raster_shpclip(r_fn, shp_fn, extent=args.extent, bbox=args.bbox, pad=args.pad, invert=args.invert)
+
+    #Write out
+    out_fn = args.out_fn
+    if out_fn is None:
+        out_fn = os.path.splitext(r_fn)[0]+'_shpclip.tif'
+    #Note: passing r_fn here as the src_ds
+    iolib.writeGTiff(r, out_fn, r_ds) 
+
+if __name__ == "__main__":
+    main()

pygeotools/copyproj.py

@@ -0,0 +1,9 @@
+#! /usr/bin/env python
+
+import sys
+from pygeotools.lib import geolib
+
+src_fn = sys.argv[1]
+dst_fn = sys.argv[2]
+
+geolib.copyproj(src_fn, dst_fn)

pygeotools/filter.py

@@ -0,0 +1,143 @@
+#! /usr/bin/env python
+"""
+Command-line wrapper around raster filters in filtlib
+"""
+
+#Note: currently need to specify fn first, as -param accepts arbitrary number of arguments
+#Need better way to record params than in filename - write history to header?
+#Precision on float
+
+import sys
+import os
+import argparse
+
+import numpy as np
+
+from pygeotools.lib import iolib
+from pygeotools.lib import malib
+from pygeotools.lib import filtlib
+from pygeotools.lib import warplib
+
+def getparser():
+    filter_choices = ['range', 'absrange', 'perc', 'gauss', 'med', 'highpass', 'sigma', 'mad', 'dz']
+    parser = argparse.ArgumentParser(description='Filter input raster')
+    parser.add_argument('fn', help='Input filename (img1.tif)')
+    parser.add_argument('--stats', action='store_true', help='Print stats before and after filtering')
+    parser.add_argument('-outdir', default=None, help='Output directory')
+    #Should implement subparser here to handle different number of args for different filter types
+    #https://docs.python.org/2/library/argparse.html#sub-commands
+    #Can call functions directly
+    #Could specify sequence of filters here
+    #Should accept arbitrary number of ordered filter operations as cli argument
+    parser.add_argument('-filt', nargs=1, default='gauss', choices=filter_choices, help='Filter type (default: %(default)s)')
+    #size is a param
+    #parser.add_argument('-size', type=int, default=7, help='Filter size in pixels (default: %(default)s)')
+    parser.add_argument('-param', nargs='+', default=None, help='Filter parameter list (e.g., size, min max, ref_fn min max)')
+    return parser
+
+def main():
+    parser = getparser()
+    args = parser.parse_args()
+
+    fn = args.fn
+    if not iolib.fn_check(fn):
+        sys.exit("Unable to locate input file: %s" % fn)
+
+    #Need some checks on these
+    param = args.param
+
+    print("Loading input raster into masked array")
+    ds = iolib.fn_getds(fn)
+    #Currently supports only single band operations
+    r = iolib.ds_getma(ds, 1)
+
+    #May need to cast input ma as float32 so np.nan filling works
+    #r = r.astype(np.float32)
+    #Want function that checks and returns float32 if necessary 
+    #Should filter, then return original dtype
+
+    r_fltr = r 
+
+    #Loop through all specified input filters
+    #for filt in args.filt:
+    filt = args.filt[0]
+
+    if len(param) == 1:
+        param = param[0]
+    param_str = ''
+
+    if filt == 'range':
+        #Range filter
+        param = [float(i) for i in param[1:]]
+        r_fltr = filtlib.range_fltr(r_fltr, param)
+        param_str = '_{0:0.2f}-{1:0.2f}'.format(*param)
+    elif filt == 'absrange':
+        #Range filter of absolute values
+        param = [float(i) for i in param[1:]]
+        r_fltr = filtlib.absrange_fltr(r_fltr, param)
+        param_str = '_{0:0.2f}-{1:0.2f}'.format(*param)
+    elif filt == 'perc':
+        #Percentile filter
+        param = [float(i) for i in param[1:]]
+        r_fltr = filtlib.perc_fltr(r, perc=param)
+        param_str = '_{0:0.2f}-{1:0.2f}'.format(*param)
+    elif filt == 'med':
+        #Median filter
+        param = int(param)
+        r_fltr = filtlib.rolling_fltr(r_fltr, f=np.nanmedian, size=param)
+        #r_fltr = filtlib.median_fltr(r_fltr, fsize=param, origmask=True)
+        #r_fltr = filtlib.median_fltr_skimage(r_fltr, radius=4, origmask=True)
+        param_str = '_%ipx' % param
+    elif filt == 'gauss':
+        #Gaussian filter (default)
+        param = int(param)
+        r_fltr = filtlib.gauss_fltr_astropy(r_fltr, size=param, origmask=False, fill_interior=False)
+        param_str = '_%ipx' % param
+    elif filt == 'highpass':
+        #High pass filter
+        param = int(param)
+        r_fltr = filtlib.highpass(r_fltr, size=param)
+        param_str = '_%ipx' % param
+    elif filt == 'sigma':
+        #n*sigma filter, remove outliers
+        param = int(param)
+        r_fltr = filtlib.sigma_fltr(r_fltr, n=param)
+        param_str = '_n%i' % param
+    elif filt == 'mad':
+        #n*mad filter, remove outliers
+        #Maybe better to use a percentile filter
+        param = int(param)
+        r_fltr = filtlib.mad_fltr(r_fltr, n=param)
+        param_str = '_n%i' % param
+    elif filt == 'dz':
+        #Difference filter, need to specify ref_fn and range
+        #Could let the user compute their own dz, then just run a standard range or absrange filter
+        ref_fn = param[0]
+        ref_ds = warplib.memwarp_multi_fn([ref_fn,], res=ds, extent=ds, t_srs=ds)[0]
+        ref = iolib.ds_getma(ref_ds)
+        param = [float(i) for i in param[1:]]
+        r_fltr = filtlib.dz_fltr_ma(r, ref, rangelim=param)
+        #param_str = '_{0:0.2f}-{1:0.2f}'.format(*param)
+        param_str = '_{0:0.0f}_{1:0.0f}'.format(*param)
+    else:
+        sys.exit("No filter type specified")
+
+    #Compute and print stats before/after
+    if args.stats:
+        print("Input stats:")
+        malib.print_stats(r)
+        print("Filtered stats:")
+        malib.print_stats(r_fltr)
+    
+    #Write out
+    dst_fn = os.path.splitext(fn)[0]+'_%sfilt%s.tif' % (filt, param_str)
+    if args.outdir is not None:
+        outdir = args.outdir
+        if not os.path.exists(outdir):
+            os.makedirs(outdir)
+        dst_fn = os.path.join(outdir, os.path.split(dst_fn)[-1])
+    print("Writing out filtered raster: %s" % dst_fn)
+    iolib.writeGTiff(r_fltr, dst_fn, ds) 
+
+if __name__ == '__main__':
+    main()

pygeotools/lib/__init__.py

@@ -0,0 +1,3 @@
+#! /usr/bin/env python
+
+__all__=['geolib','malib','timelib','warplib','iolib','filtlib']