def get_distance_raster(self,
base_layer,
output_path=None,
create_raster=True):
if self.distance == 'proximity':
with rasterio.open(base_layer) as src:
bounds = src.bounds
width = src.width
height = src.height
crs = src.crs
transform = src.transform
data, meta = self.rasterize(value=1,
width=width,
height=height,
transform=transform)
drv = gdal.GetDriverByName('MEM')
src_ds = drv.Create('', width, height, 1,
gdal.GetDataTypeByName('Float32'))
src_ds.SetGeoTransform(transform.to_gdal())
src_ds.SetProjection(crs.wkt)
src_ds.WriteArray(data)
srcband = src_ds.GetRasterBand(1)
drv = gdal.GetDriverByName('MEM')
dst_ds = drv.Create('', width, height, 1,
gdal.GetDataTypeByName('Float32'))
dst_ds.SetGeoTransform(transform.to_gdal())
dst_ds.SetProjection(crs.wkt)
dstband = dst_ds.GetRasterBand(1)
gdal.ComputeProximity(srcband, dstband,
["VALUES=1", "DISTUNITS=GEO"])
data = dstband.ReadAsArray()
meta.update(nodata=np.nan, dtype='float32')
if create_raster:
self.distance_raster = RasterLayer(
self.category,
self.name + '_dist',
distance_limit=self.distance_limit,
inverse=self.inverse,
normalization=self.normalization)
self.distance_raster.layer = data
self.distance_raster.meta = meta
self.distance_raster.bounds = bounds
if output_path:
self.distance_raster.save(output_path)
else:
return data, meta
elif self.distance == 'travel_time':
self.travel_time(output_path)
def geoimwrite(filename, imdata, geoTransform, proj, drv_name):
# Get the image Driver by its short name
driver = gdal.GetDriverByName(drv_name)
# Get image dimensions from array
cols = np.size(imdata, 1)
rows = np.size(imdata, 0)
dims = np.shape(imdata.shape)[0]
if dims == 2:
bands = 1
elif dims == 3:
bands = np.size(imdata, 2)
else:
raise Exception('Error x01: Invalid image dimensions.')
# Image datatype
dt = imdata.dtype
datatype = gdal.GetDataTypeByName(dt.name)
# Prepare the output dataset
if datatype == 0:
# Unknown datatype, try to use uint8 code
datatype = 1
outDataset = driver.Create(filename, cols, rows, bands, datatype)
# Set the Georeference first
outDataset.SetGeoTransform(geoTransform)
outDataset.SetProjection(proj)
if bands == 1:
outBand = outDataset.GetRasterBand(1)
outBand.WriteArray(imdata, 0, 0)
else:
# Iterate the bands and write them to the file
for b_idx in range(1, bands + 1):
outBand = outDataset.GetRasterBand(b_idx)
outBand.WriteArray(imdata[:, :, b_idx - 1], 0, 0)
# Clear variables and close the file
outBand = None
outDataset = None
def fillNodata(self):
#if not self.noData in self.data:
if not np.ma.is_masked(self.data):
#do not process it if its not necessary
return
if self.IFACE == 'GDAL':
# gdal.FillNodata need a band object to apply on
# so we create a memory datasource (1 band, float)
height, width = self.data.shape
ds = gdal.GetDriverByName('MEM').Create(
'', width, height, 1, gdal.GetDataTypeByName('float32'))
b = ds.GetRasterBand(1)
b.SetNoDataValue(self.noData)
self.data = np.ma.filled(
self.data, self.noData) # Fill mask with nodata value
b.WriteArray(self.data)
gdal.FillNodata(targetBand=b,
maskBand=None,
maxSearchDist=max(self.size.xy),
smoothingIterations=0)
self.data = b.ReadAsArray()
ds, b = None, None
else: #Call the inpainting function
# Cast to float
self.cast2float()
# Fill mask with NaN (warning NaN is a special value for float arrays only)
self.data = np.ma.filled(self.data, np.NaN)
# Inpainting
self.data = replace_nans(self.data,
max_iter=5,
tolerance=0.5,
kernel_size=2,
method='localmean')
def proximity_raster(src_filename, dst_filename, values, compression):
src_ds = gdal.Open(src_filename)
srcband = src_ds.GetRasterBand(1)
dst_filename = dst_filename
drv = gdal.GetDriverByName('GTiff')
dst_ds = drv.Create(dst_filename,
src_ds.RasterXSize,
src_ds.RasterYSize,
1,
gdal.GetDataTypeByName('Float32'),
options=['COMPRESS={}'.format(compression)])
dst_ds.SetGeoTransform(src_ds.GetGeoTransform())
dst_ds.SetProjection(src_ds.GetProjectionRef())
dstband = dst_ds.GetRasterBand(1)
gdal.ComputeProximity(srcband, dstband, [
"VALUES={}".format(','.join([str(i) for i in values])), "DISTUNITS=GEO"
])
srcband = None
dstband = None
src_ds = None
dst_ds = None
def loadGDALImage(fname):
'''
Similar to loadImage but only returns metadata.
'''
from osgeo import gdal
class Dummy(object):
pass
ds = gdal.Open(fname, gdal.GA_ReadOnly)
drv = ds.GetDriver()
bnd = ds.GetRasterBand(1)
img = Dummy()
img.bands = ds.RasterCount
img.width = ds.RasterXSize
img.length = ds.RasterYSize
img.scheme = drv.GetDescription()
img.dataType = gdal.GetDataTypeByName(bnd.DataType)
bnd = None
drv = None
ds = None
return img
def write_geotiff(raster_path, data, dtype, shape, nodata, gt, sr, chunks):
"""Create a raster dataset"""
driver = gdal.GetDriverByName("GTiff")
options = [
"TILED=YES",
"COPY_SRC_OVERVIEWS=YES",
"COMPRESS=LZW",
"BLOCKXSIZE=256",
"BLOCKYSIZE=256",
]
ds = driver.Create(
raster_path,
int(shape[1]),
int(shape[0]),
1,
gdal.GetDataTypeByName(dtype_to_gdal(dtype)),
options,
)
if ds is None:
raise TypeError("GDAL error while creating new raster")
ds.SetGeoTransform(gt)
ds.SetProjection(sr)
band = ds.GetRasterBand(1)
band.WriteArray(data)
band.SetNoDataValue(nodata)
band.FlushCache()
band = None
ds = None
def rasterize_vector(ds_name, field, outfile, resolution, dtype, no_data, of='GTiff', co=None, overwrite=False):
# type: (str, str, str, int, str, int or float, str, list, bool) -> None
"""
Rasterize a vector layer
:param ds_name: Input vector file name
:param field: Attribute field that shall be converted to raster values
:param outfile: Output file name
:param resolution: Output resolution
:param dtype: Output data type. One of (Byte, UInt16, Int16, UInt32, Int32, Float32, Float64, CInt16, CInt32,
CFloat32, CFloat64)
:param no_data: NoData value for output raster
:param of: Output format as defined at http://www.gdal.org/formats_list.html
:param co: Advanced raster creation options such as band interleave or compression. <br<>
Example: co=['compress=lzw']
:param overwrite: Overwrite output file if it already exists
:return: --
"""
ds_shp = ogr.Open(ds_name)
lyr = ds_shp.GetLayer()
proj = lyr.GetSpatialRef()
lyr = None
ds_shp = None
xmin, ymin, xmax, ymax = get_extent(ds_name)
geotrans = (xmin, resolution, 0, ymax, 0, -resolution)
cols = int((xmax - xmin) / resolution)
rows = int((ymax - ymin) / resolution)
ds = raster_tools.create_ds(outfile, cols, rows, 1, gdal.GetDataTypeByName(dtype), of=of, co=co, overwrite=overwrite)
ds.SetGeoTransform(geotrans)
ds.SetProjection(proj.ExportToWkt())
gdal.RasterizeLayer(ds, [1], lyr, options=['ALL_TOUCHED=TRUE', 'ATTRIBUTE={f}'.format(f=field)])
ds.GetRasterBand(1).SetNoDataValue(no_data)
ds = None
return
def write_raster_output(strata,
cols,
rows,
map_ds,
output,
gdal_frmt='GTiff',
ndv=255):
"""
"""
# Init and fill output array with samples
raster = np.ones(
(map_ds.RasterYSize, map_ds.RasterXSize), dtype=np.uint8) * ndv
raster[rows, cols] = strata
# Get output driver
driver = gdal.GetDriverByName(gdal_frmt)
# Create output dataset
sample_ds = driver.Create(output, map_ds.RasterXSize, map_ds.RasterYSize,
1, gdal.GetDataTypeByName('Byte'))
# Write out band
sample_ds.GetRasterBand(1).SetNoDataValue(ndv)
sample_ds.GetRasterBand(1).WriteArray(raster)
# Port over metadata, projection, geotransform, etc
sample_ds.SetProjection(map_ds.GetProjection())
sample_ds.SetGeoTransform(map_ds.GetGeoTransform())
sample_ds.SetMetadata(map_ds.GetMetadata())
# Close
sample_ds = None
def get_data_type(data_type: Optional[DataTypeOrStr]):
if data_type is None:
return None
if isinstance(data_type, str):
return gdal.GetDataTypeByName(data_type)
else:
return data_type
def CreateBILRawRasterVRT(filename,
nbands,
cols,
rows,
datatype,
nbits,
nodata=None,
headeroffset=0,
byteorder=None,
relativeToVRT=0):
'''Create RawRaster VRT from a BIL
BIL = Band-Interleaved-by-Line or Row-Interleaved
For further info on VRT's, see the U{GDAL VRT Tutorial<http://www.gdal.org/gdal_vrttut.html>}
@type filename: C{str}
@param filename: File name
@type nbands: C{int}
@param nbands: The number of bands in the output VRT (<= nbands in input file)
@type cols: C{int}
@param cols: The number of columns in the output VRT
@type rows: C{int}
@param rows: The number of rows in the output VRT
@type datatype: C{str}
@param datatype: GDAL datatype name. Eg. Byte, Int32, UInt16
@type nodata: C{float}
@param nodata: No data/Null value
@type headeroffset: C{int}
@param headeroffset: Number of bytes to skip at the start of the file
@type byteorder: C{str}
@param byteorder: Byte order of the file (MSB or LSB)
@rtype: C{xml}
@return: VRT XML string
'''
try:
vrt = []
nbits = gdal.GetDataTypeSize(gdal.GetDataTypeByName(datatype))
for i in range(nbands):
vrt.append(
' <VRTRasterBand dataType="%s" band="%s" subClass="VRTRawRasterBand">'
% (datatype, i + 1))
vrt.append(
' <SourceFilename relativeToVRT="%s">%s</SourceFilename>' %
(relativeToVRT, filename))
if nodata is not None:
vrt.append(' <NoDataValue>%s</NoDataValue>' %
(nodata)) #Fix for Issue 17
vrt.append(' <ImageOffset>%s</ImageOffset>' %
(headeroffset + nbits / 8 * i * cols))
vrt.append(' <PixelOffset>%s</PixelOffset>' % (nbits / 8))
vrt.append(' <LineOffset>%s</LineOffset>' % (nbits / 8 * cols))
if byteorder:
vrt.append(' <ByteOrder>%s</ByteOrder>' % (byteorder))
vrt.append(' </VRTRasterBand>')
return CreateCustomVRT('\n'.join(vrt), cols, rows)
except:
return None
return '\n'.join(vrt)
def _get_metadata(reference, dataset):
with h5py.File(reference, "r") as h5f_open:
ds = h5f_open.get(dataset)
assert ds
attrs = dict(h5f_open.get("data").attrs)
attrs["dataset_shape"] = ds.shape
attrs["nodata"] = ds.fillvalue
attrs["dtype"] = gdal.GetDataTypeByName(ds.dtype.name)
return attrs
def writeRGB(self, outPath):
'''Write FOTO results to a new RGB geotiff'''
print('Write output raster ' + outPath)
if self.RGB is None:
raise ValueError('FOTO not yet computed')
#build output dataset
if os.path.isfile(outPath):
os.remove(outPath)
driver = gdal.GetDriverByName("GTiff")
outNbBand = 3
outDtype = gdal.GetDataTypeByName('Float32')
outDataset = driver.Create(outPath, self.nbBlkx, self.nbBlky,
outNbBand,
outDtype) #, ['TFW=YES', 'COMPRESS=LZW'])
if self.method == 'BLOCK':
topleftx, pxsizex, rotx, toplefty, roty, pxsizey = self.inDataset.GetGeoTransform(
)
outResx = pxsizex * self.blockSize
outResy = pxsizey * self.blockSize
outDataset.SetGeoTransform(
(topleftx, outResx, rotx, toplefty, roty, outResy))
elif self.method == 'MW':
outDataset.SetGeoTransform(self.inDataset.GetGeoTransform())
outDataset.SetProjection(self.inDataset.GetProjection())
'''
for i in range(outNbBand):
outDataset.GetRasterBand(i+1).WriteArray(self.RGB[:,:,i])
'''
#write by block to avoid memory overflow
blockSize = 512
width, height = self.nbBlkx, self.nbBlky
#Loop over blocks
for j in range(0, height, blockSize):
if j + blockSize < height:
yBlockSize = blockSize
else:
yBlockSize = height - j
for i in range(0, width, blockSize):
if i + blockSize < width:
xBlockSize = blockSize
else:
xBlockSize = width - i
for b in range(outNbBand):
outBand = outDataset.GetRasterBand(b + 1)
data = self.RGB[j:j + yBlockSize, i:i + xBlockSize, b]
outBand.WriteArray(data, i, j)
# Close
outDataset = None #needed to validate the modifications
def from_array(data, path, xsize, ysize, nodata=-9999, trans='', proj=''):
geotiff = gdal.GetDriverByName("GTiff")
dst_ds = geotiff.Create(path, xsize, ysize, 1,
gdal.GetDataTypeByName('Float32'),
['COMPRESS=lzw', 'PREDICTOR=2'])
if dst_ds is None:
raise RuntimeError("failed to create output raster '%s'" % oname)
dst_ds.SetProjection(proj)
dst_ds.SetGeoTransform(trans)
dst_ds.GetRasterBand(1).SetNoDataValue(nodata)
dst_ds.GetRasterBand(1).WriteArray(data)
return dst_ds
def proximity_rast_ds(ds_raster_in, val=1):
drv = gdal.GetDriverByName('MEM')
proxy_ds = drv.Create('', ds_raster_in.RasterXSize,
ds_raster_in.RasterYSize, 1,
gdal.GetDataTypeByName('Float32'))
gdal.ComputeProximity(ds_raster_in.GetRasterBand(1),
proxy_ds.GetRasterBand(1),
["VALUES=" + str(val), "DISTUNITS=GEO"])
return proxy_ds
def CreateRawRasterVRT(bands,
cols,
rows,
datatype,
headeroffset=0,
byteorder=None,
relativeToVRT=0,
nodata=None):
''' Create RawRaster VRT from one or more _single_ band files
For further info on VRT's, see the U{GDAL VRT Tutorial<http://www.gdal.org/gdal_vrttut.html>}
@type bands: C{[str,...,str]}
@param bands: List of files. The first file becomes the first band and so forth.
@type cols: C{int}
@param cols: The number of columns in the output VRT
@type rows: C{int}
@param rows: The number of rows in the output VRT
@type datatype: C{str}
@param datatype: GDAL datatype name. Eg. Byte, Int32, UInt16
@type headeroffset: C{int}
@param headeroffset: Number of bytes to skip at the start of the file
@type byteorder: C{str}
@param byteorder: Byte order of the file (MSB or LSB)
@rtype: C{xml}
@return: VRT XML string
'''
try:
vrt = []
nbits = gdal.GetDataTypeSize(gdal.GetDataTypeByName(datatype))
for i, band in enumerate(bands):
vrt.append(
' <VRTRasterBand dataType="%s" band="%s" subClass="VRTRawRasterBand">'
% (datatype, i + 1))
vrt.append(
' <SourceFilename relativeToVRT="%s">%s</SourceFilename>' %
(relativeToVRT, band))
vrt.append(' <ImageOffset>%s</ImageOffset>' % (headeroffset))
vrt.append(' <PixelOffset>%s</PixelOffset>' % (nbits / 8))
vrt.append(' <LineOffset>%s</LineOffset>' % (nbits / 8 * cols))
if nodata is not None:
vrt.append(' <NoDataValue>%s</NoDataValue>' %
(nodata)) #Fix for Issue 17
if byteorder:
vrt.append(' <ByteOrder>%s</ByteOrder>' % (byteorder))
vrt.append(' </VRTRasterBand>')
return CreateCustomVRT('\n'.join(vrt), cols, rows)
except:
return None
return '\n'.join(vrt)
def fillNodata(self, data):
'''
Call gdal fillnodata function on an given np array
return an array with nodata filled
'''
# gdal.FillNodata need a band object to apply on
# so we create a memory datasource (1 band, float)
height, width = data.shape
ds = gdal.GetDriverByName('MEM').Create('', width, height, 1, gdal.GetDataTypeByName('float32'))
b = ds.GetRasterBand(1)
b.SetNoDataValue(self.noData)
b.WriteArray(data)
gdal.FillNodata(targetBand=b, maskBand=None, maxSearchDist=max(self.size.xy), smoothingIterations=0)
data = b.ReadAsArray()
ds, b = None, None
return data
def create_vrt_stack(file_list, outfile="slcs_base.vrt"):
# Use the first file in the stack to get size, transform info
ds = gdal.Open(file_list[0])
geotrans = ds.GetGeoTransform()
proj = ds.GetProjection()
xsize = ds.RasterXSize
ysize = ds.RasterYSize
ds = None
# Start with the empty VRT, and add 1 band at a time per file
vrt_driver = gdal.GetDriverByName("VRT")
out_raster = vrt_driver.Create(outfile, xsize=xsize, ysize=ysize, bands=0)
out_raster.SetGeoTransform(geotrans)
out_raster.SetProjection(proj)
# Options for all VRT bands:
gdal_dtype = gdal.GetDataTypeByName("CFloat32")
bytes_per_pixel = 8 # complex float32
image_offset = 0
pixel_offset = bytes_per_pixel
line_offset = xsize * bytes_per_pixel
print(f"Writing VRT to {outfile}")
for band_num, filename in enumerate(file_list, start=1):
source_filename = os.path.abspath(filename)
print(f"Adding {source_filename}")
options = [
"subClass=VRTRawRasterBand",
f"SourceFilename={source_filename}",
f"ImageOffset={image_offset}",
f"PixelOffset={pixel_offset}",
f"LineOffset={line_offset}",
]
out_raster.AddBand(gdal_dtype, options)
# Set the metada on the newly created bands
date = _get_date(filename)
metadata = {
"Date": date,
"AcquisitionTime": date,
"Wavelength": str(SENTINEL_WAVELENGTH),
}
band = out_raster.GetRasterBand(band_num)
metadata_domain = "slc"
band.SetMetadata(metadata, metadata_domain)
out_raster = None # Force write
def __getmetadata__(self):
'''Read Metadata for a ENVI image as GDAL doesn't work if you pass the header file...'''
try:__default__.Dataset.__getmetadata__(self, self._datafile) #autopopulate basic metadata
except IOError,err: #Handle the odd ENVI files held by SSD
hdr=self.__parseheader__() #"file type = ENVI" instead of "file type = ENVI standard"
if hdr['file type']=='ENVI': #I assume they were generated by some external software
#make a dummy hdr with a dummy 1 byte image file
import tempfile,geometry,shutil
tmpd=tempfile.mkdtemp(prefix='gdal')
tmph=open(tmpd+'/dummy.hdr','w')
tmpf=open(tmpd+'/dummy','wb')
hdr['file type']+=' Standard'
tmph.write('ENVI\n')
for key in hdr:
if '\n' in hdr[key]:tmph.write(key+' = {'+hdr[key]+'}\n')
else: tmph.write(key+' = '+hdr[key]+'\n')
tmph.close()
tmpf.write('\x00\x00')
tmpf.close()
__default__.Dataset.__getmetadata__(self, tmpd+'/dummy')
del self._gdaldataset
shutil.rmtree(tmpd, ignore_errors=True)
#Make a VRT
md=self.metadata
byteorder={'':None,'0':'LSB','1':'MSB'}
byteorder=byteorder[hdr.get('byte order','')]
min=GetDataTypeRange(gdal.GetDataTypeByName(md['datatype']))[0]
nodata=hdr.get('data ignore value',str(min))
if hdr.get('interleave','').upper()=='BSQ':
vrt=geometry.CreateBSQRawRasterVRT(self._datafile,md['nbands'],md['cols'],md['rows'],md['datatype'],nodata,headeroffset=0,byteorder=byteorder,relativeToVRT=0)
elif hdr.get('interleave','').upper()=='BIP':
vrt=geometry.CreateBIPRawRasterVRT(self._datafile,md['nbands'],md['cols'],md['rows'],md['datatype'],nodata,headeroffset=0,byteorder=byteorder,relativeToVRT=0)
else:#Assume bil
vrt=geometry.CreateBILRawRasterVRT(self._datafile,md['nbands'],md['cols'],md['rows'],md['datatype'],nodata,headeroffset=0,byteorder=byteorder,relativeToVRT=0)
self._gdaldataset=geometry.OpenDataset(vrt)
#Fix for Issue 17
for i in range(1,self._gdaldataset.RasterCount+1):
self._gdaldataset.GetRasterBand(i).SetNoDataValue(nodata)
pass
else:raise #not the dodgy SSD files, re-raise the orig. error
def run(self):
#delete our output if it exists
outputFName = os.path.join(self.outDir, self.outName)
gdal.Unlink(outputFName)
rasterProcessor.run(self)
outputRaster = SpatialUtilities.SAHMRaster(outputFName)
outputRaster.pullParamsFromRaster(self.inputFname)
outputRaster.pixelType = gdal.GetDataTypeByName("int32")
outputRaster.NoData = SpatialUtilities.defaultNoData(
outputRaster.pixelType)
outputRaster.createNewRaster()
if self.templateFName != "":
pass
#TODO: what we're going to have to do here is first PARC the input to match the template
#with nearest neighbor, majority
#Then use this use this tmpPARC output as our input
for blockData in self.inputRaster.iterBlocks():
# print blockData
# print SpatialUtilities.GDALToNPDataType(outputRaster.pixelType)
outBlock = np.ma.asarray(blockData.copy(),
dtype=SpatialUtilities.GDALToNPDataType(
outputRaster.pixelType))
for k, v in self.reclassDict.iteritems():
if v == "NoData":
v = outputRaster.NoData
if k[0] == "NoData":
outBlock = np.where(np.ma.getmask(blockData), v, outBlock)
elif len(k) == 1:
outBlock[(blockData == k[0]).filled(False)] = v
# outBlock = np.where(blockData == k[0], v, outBlock)
elif len(k) == 2:
outBlock[((blockData >= k[0]) &
(blockData < k[1])).filled(False)] = v
## outBlock = np.where((blockData >= k[0]) & (blockData < k[1]), v, outBlock)
# print outBlock
outputRaster.putBlock(outBlock, self.inputRaster.curCol,
self.inputRaster.curRow)
outputRaster.calcStats()
outputRaster.band.FlushCache()
outputRaster = None
def array2image(Array,
outFile,
Rast=None,
ncols=None,
nrows=None,
Xll=None,
Yll=None,
cellsize=None,
nodata=None,
proj=None,
dr='GTiff',
dataType='float32'):
'''Writes an array to an image with or without a raster as a reference'''
driver = gdal.GetDriverByName(dr)
if Rast != None:
if ncols == None:
ncols = Rast.ncols
if nrows == None:
nrows = Rast.nrows
if Xll == None:
Xll = Rast.Xll
if Yll == None:
Yll = Rast.Yll
if cellsize == None:
cellsize = Rast.cellsize
if nodata == None:
nodata = Rast.nodata
if proj == None:
proj = Rast.proj
output = driver.Create(outFile, ncols, nrows, 1,
gdal.GetDataTypeByName(dataType))
geo = [Xll, cellsize, 0, Yll + cellsize * nrows, 0, cellsize * (-1)]
output.SetGeoTransform(geo)
output.SetProjection(proj)
output.GetRasterBand(1).WriteArray(Array)
output.GetRasterBand(1).SetNoDataValue(nodata)
# output.GetRasterBand(1).SetStatistics(Rast.stat['min'], Rast.stat['max'], Rast.stat['mean'], Rast.stat['std'])
output = None
def proximity_raster(src_raster_path: str,
out_raster_path: str,
dist_units="PIXEL",
preserve_nodata=True):
"""Create a proximity raster
Args:
src_raster_path ([type]): [description]
out_raster_path ([type]): [description]
dist_units (str, optional): set to "GEO" for distance in length . Defaults to "PIXEL".
"""
log = Logger('proximity_raster')
tmr = Timer()
src_ds = gdal.Open(src_raster_path)
srcband = src_ds.GetRasterBand(1)
drv = gdal.GetDriverByName('GTiff')
with TempRaster('vbet_proximity_raster') as tempfile:
dst_ds = drv.Create(tempfile.filepath, src_ds.RasterXSize,
src_ds.RasterYSize, 1,
gdal.GetDataTypeByName('Float32'))
dst_ds.SetGeoTransform(src_ds.GetGeoTransform())
dst_ds.SetProjection(src_ds.GetProjectionRef())
dstband = dst_ds.GetRasterBand(1)
log.info('Creating proximity raster')
gdal.ComputeProximity(
srcband, dstband,
["VALUES=1", f"DISTUNITS={dist_units}", "COMPRESS=DEFLATE"])
srcband = None
dstband = None
src_ds = None
dst_ds = None
# Preserve the nodata from the source
if preserve_nodata:
mask_rasters_nodata(tempfile.filepath, src_raster_path,
out_raster_path)
else:
shutil.copyfile(tempfile.filepath, out_raster_path)
log.info('completed in {}'.format(tmr.toString()))
def from_pd(df, path, nodata=-9999, trans='', proj=''):
if isinstance(df, pd.Series):
arr = df.as_matrix().reshape(df.ysize, df.xsize)
return from_array(arr, path, df.xsize, df.ysize, nodata, trans, proj)
if isinstance(df, pd.DataFrame):
geotiff = gdal.GetDriverByName("GTiff")
dst_ds = geotiff.Create(path, df.xsize, df.ysize, len(df.columns),
gdal.GetDataTypeByName('Float32'),
['COMPRESS=lzw', 'PREDICTOR=2'])
if dst_ds is None:
raise RuntimeError("failed to create output raster '%s'" % oname)
dst_ds.SetProjection(proj)
dst_ds.SetGeoTransform(trans)
for idx, col in enumerate(df.columns):
arr = df[col].as_matrix().reshape(df.ysize, df.xsize)
dst_ds.GetRasterBand(idx + 1).SetNoDataValue(nodata)
dst_ds.GetRasterBand(idx + 1).WriteArray(arr)
return dst_ds
def regularize(src_fn, dst_fn, src_band=1, offset=1.0, low=0.0, high=1):
src_ds = gdal.Open(src_fn)
if src_ds is None:
raise RuntimeError("Error: could not open raster file '%s'" % src_fn)
if dst_fn is not None:
geotiff = gdal.GetDriverByName("GTiff")
if geotiff is None:
raise RuntimeError('could not open GeoTiff gdal driver')
dst_ds = geotiff.Create(
dst_fn,
src_ds.RasterXSize,
src_ds.RasterYSize,
2, # Store the unscaled (but log-ed) value in band 2
gdal.GetDataTypeByName('Float32'),
['COMPRESS=lzw', 'PREDICTOR=2'])
if dst_ds is None:
raise RuntimeError("Error: could not open raster file '%s'" %
dst_fn)
dst_ds.SetProjection(src_ds.GetProjection())
dst_ds.SetGeoTransform(src_ds.GetGeoTransform())
src_nodata = src_ds.GetRasterBand(src_band).GetNoDataValue()
src_data = src_ds.GetRasterBand(src_band).ReadAsArray()
src_mask = src_data == src_nodata
# This is a bit awkward. A masked_array (ma) seemed like the ideal
# way to compute the log of a raster with NoData values.
# Unfortunately, ma performs the operation on *all* elements of the
# array and then does the masking. So resorting to this goofiness.
#
# Need to be careful not to introduce an artificial minimum, i.e. can
# simply use 1.0 for NoData cells because the minimum in the unmasked
# portion of the array may be > 1.0.
src_min = np.min(ma.masked_where(src_mask, src_data))
X = np.log(np.where(src_mask, src_min + offset, src_data + offset))
X_min = X.min()
X_std = (X - X_min) / (X.max() - X_min)
scaled = X_std * (high - low) + low
masked = np.where(src_mask, src_nodata, scaled)
if dst_fn is None:
return masked
dst_ds.GetRasterBand(1).WriteArray(masked)
dst_ds.GetRasterBand(1).SetNoDataValue(src_nodata)
dst_ds.GetRasterBand(2).WriteArray(np.where(src_mask, src_nodata, X))
dst_ds.GetRasterBand(2).SetNoDataValue(src_nodata)
def writeGeoTiff(arrayData, extent, pixelFormat, path, layer):
format = "GTiff"
driver = gdal.GetDriverByName(format)
metadata = driver.GetMetadata()
if metadata.has_key(
gdal.DCAP_CREATE) and metadata[gdal.DCAP_CREATE] == "YES":
pass
else:
print "Driver %s does not support Create() method." % format
return False
# get rows and columns
dims = arrayData.shape
if len(dims) == 2:
rows = dims[0]
cols = dims[1]
nbands = 1
else:
rows = dims[1]
cols = dims[2]
nbands = dims[0]
pixFormat = gdal.GetDataTypeByName(pixelFormat)
proj = projection(layer)
trans = geotransform(layer)
# could possible to use CreateCopy from one of the input rasters
dst_ds = driver.Create(path, cols, rows, nbands, pixFormat)
dst_ds.SetGeoTransform([
extent[0], (extent[2] - extent[0]) / cols, 0, extent[3], 0,
(extent[1] - extent[3]) / rows
])
dst_ds.SetProjection(proj)
if nbands > 1:
for i in range(nbands):
dst_ds.GetRasterBand(i + 1).WriteArray(arrayData[i])
else:
dst_ds.GetRasterBand(1).WriteArray(arrayData)
dst_ds = None
return True
def outDataset( path, pixelFormat, layer, x, y ):
format = "GTiff"
driver = gdal.GetDriverByName( format )
metadata = driver.GetMetadata()
if metadata.has_key( gdal.DCAP_CREATE ) and metadata[ gdal.DCAP_CREATE ] == "YES":
pass
else:
print "Driver %s does not support Create() method." % format
return False
pixFormat = gdal.GetDataTypeByName( pixelFormat )
proj = projection( layer )
trans = geotransform( layer )
dst_ds = driver.Create( path, x, y, 1, pixFormat )
#dst_ds.SetGeoTransform( [ extent[ 0 ], ( extent[ 2 ] - extent[ 0 ] ) / cols, 0,
# extent[ 3 ], 0, ( extent[ 1 ] - extent[ 3 ] ) / rows ] )
dst_ds.SetProjection( proj )
dst_ds.SetGeoTransform( trans )
return dst_ds
def writeImage(Rast, outFile, dr='GTiff', dataType='float32'):
'''Writes a raster image from Raster'''
driver = gdal.GetDriverByName(dr)
output = driver.Create(outFile, Rast.ncols, Rast.nrows,\
1, gdal.GetDataTypeByName(dataType))
geo = [
Rast.Xll, Rast.cellsize, 0, Rast.Yll + Rast.cellsize * Rast.nrows, 0,
Rast.cellsize * (-1)
]
output.SetGeoTransform(geo)
output.SetProjection(Rast.proj)
output.GetRasterBand(1).WriteArray(Rast.elements.data)
output.GetRasterBand(1).SetNoDataValue(Rast.nodata)
# output.GetRasterBand(1).SetStatistics(Rast.stat['min'], Rast.stat['max'], Rast.stat['mean'], Rast.stat['std'])
output = None
def writeToFile(self, rasterOb, filepath, gdal_output_format='GTiff'):
ro = rasterOb
filepath = os.path.splitext(filepath)[0]
# Need to create a RasterBAnd object and write to that
driver = gdal.GetDriverByName(gdal_output_format)
metadata = driver.GetMetadata()
suffix = metadata.get(gdal.DMD_EXTENSION, '')
create_data_types = metadata[gdal.DMD_CREATIONDATATYPES].split()
if suffix:
outfilepath = filepath + '.' + suffix
else:
outfilepath = filepath
# Create(<filename>, <xsize>, <ysize>, [<bands>], [<GDALDataType>])
output_gdt = None
if ro.gdt in create_data_types:
output_gdt = ro.gdt
else:
for dfmt in self.dmap_data_formats[ro.gdt]:
if dfmt in create_data_types:
output_gdt = dfmt
break
try:
ds_out = driver.Create(outfilepath, ro.width, ro.height, 1,
gdal.GetDataTypeByName(output_gdt))
except RuntimeError:
# print('\tOUTPUT DATA_FORMAT:', output_gdt)
# print('\tro.width:', ro.width)
# print('\tro.height:', ro.height)
# print('\toutfilepath:', outfilepath)
raise MCEliteError("Results file %s cannot be written. \
\nMake sure that it is not opened or write-protected, and that the format is supported."
% (outfilepath))
ds_out.SetGeoTransform(ro.geotransform)
ds_out.SetProjection(ro.projection)
# Writes as many bands as we have
for band_id in ro.datad:
ds_out.GetRasterBand(band_id).WriteArray(rasterOb.datad[band_id])
ds_out.GetRasterBand(band_id).SetNoDataValue(0.0)
return outfilepath
def toGDAL(self):
'''Get GDAL memory driver dataset'''
w, h = self.size
n = self.nbBands
dtype = str(self.dtype)
if dtype == 'uint8': dtype = 'byte'
dtype = gdal.GetDataTypeByName(dtype)
mem = gdal.GetDriverByName('MEM').Create('', w, h, n, dtype)
#writearray is available only at band level
if self.isOneBand:
mem.GetRasterBand(1).WriteArray(self.data)
else:
for bandIdx in range(n):
bandArray = self.data[:, :, bandIdx]
mem.GetRasterBand(bandIdx + 1).WriteArray(bandArray)
#write georef
if self.isGeoref:
mem.SetGeoTransform(self.georef.toGDAL())
if self.georef.crs is not None:
mem.SetProjection(
self.georef.crs.getOgrSpatialRef().ExportToWkt())
return mem
def manual(image, pct=None, minmax=None, out_datatype='uint8'):
""" Manual scaling of image from minmax to range of datatype specified """
# Get output datatype as np & GDAL
try:
np_dt = np.dtype(out_datatype.lower())
gdal_dt = gdal.GetDataTypeByName(out_datatype)
except:
print('Error: could not understand datatype {dt}'.format(
dt=out_datatype))
sys.exit(1)
# Get data type min/max
try:
dt_max = np.iinfo(np_dt).max
dt_min = np.iinfo(np_dt).min
except:
dt_max = np.finfo(np_dt).max
dt_min = np.finfo(np.dt).min
# Calculate scale factor & offset
scale = (dt_max - dt_min) / (minmax[1] - minmax[0])
offset = dt_max - (scale * minmax[1])
return image * scale + offset
def ParseType(type):
gdal_dt = gdal.GetDataTypeByName(type)
if gdal_dt is GDT_Unknown:
gdal_dt = GDT_Byte
return gdal_dt
