def reproject(self, src_fn, match_fn, dst_fn, lidar=False):
src_filename = src_fn
src = gdal.Open(src_filename, gdalconst.GA_ReadOnly)
src_proj = src.GetProjection()
src_geotrans = src.GetGeoTransform()
# We want a section of source that matches this:
match_filename = match_fn
match_ds = gdal.Open(match_filename, gdalconst.GA_ReadOnly)
match_proj = match_ds.GetProjection()
match_geotrans = match_ds.GetGeoTransform()
wide = match_ds.RasterXSize
high = match_ds.RasterYSize
# Output / destination
dst_filename = dst_fn
dst = gdal.GetDriverByName('GTiff').Create(dst_filename, wide, high, 1, gdalconst.GDT_Float32)
dst.SetGeoTransform( match_geotrans )
dst.SetProjection( match_proj)
dst.GetRasterBand(1).SetNoDataValue(-9999.0)
a = np.ndarray(shape=(high, wide))
a.fill(-9999.0)
dst.GetRasterBand(1).WriteArray(a)
if not lidar:
gdal.ReprojectImage(src, dst, src_proj, match_proj, gdalconst.GRA_Bilinear)
else:
gdal.ReprojectImage(src, dst, src_proj, match_proj, gdalconst.GRA_Average)
del dst
def reproject_dataset_example(dataset, dataset_example, method=1):
# open dataset that must be transformed
try:
if dataset.split('.')[-1] == 'tif':
g = gdal.Open(dataset)
else:
g = dataset
except:
g = dataset
epsg_from = Get_epsg(g)
# open dataset that is used for transforming the dataset
try:
if dataset_example.split('.')[-1] == 'tif':
gland = gdal.Open(dataset_example)
else:
gland = dataset_example
except:
gland = dataset_example
epsg_to = Get_epsg(gland)
# Set the EPSG codes
osng = osr.SpatialReference()
osng.ImportFromEPSG(epsg_to)
wgs84 = osr.SpatialReference()
wgs84.ImportFromEPSG(epsg_from)
# Get shape and geo transform from example
geo_land = gland.GetGeoTransform()
col = gland.RasterXSize
rows = gland.RasterYSize
# Create new raster
mem_drv = gdal.GetDriverByName('MEM')
dest1 = mem_drv.Create('', col, rows, 1, gdal.GDT_Float32)
dest1.SetGeoTransform(geo_land)
dest1.SetProjection(osng.ExportToWkt())
# Perform the projection/resampling
if method is 1:
gdal.ReprojectImage(g, dest1, wgs84.ExportToWkt(), osng.ExportToWkt(),
gdal.GRA_NearestNeighbour)
if method is 2:
gdal.ReprojectImage(g, dest1, wgs84.ExportToWkt(), osng.ExportToWkt(),
gdal.GRA_Bilinear)
if method is 3:
gdal.ReprojectImage(g, dest1, wgs84.ExportToWkt(), osng.ExportToWkt(),
gdal.GRA_Lanczos)
if method is 4:
gdal.ReprojectImage(g, dest1, wgs84.ExportToWkt(), osng.ExportToWkt(),
gdal.GRA_Average)
return (dest1)
def reproject_clip_sca_abo(src_fn, match_fn, dst_fn, src_proj_boolean=False):
# Source
src_filename = src_fn
src = gdal.Open(src_filename, GA_ReadOnly)
src_proj = src.GetProjection()
src_geotrans = src.GetGeoTransform()
abo_20120101 = gdal.Open("SCA/2012/abo2012_rs/abo20120101/hdr.adf")
proj = abo_20120101.GetProjection()
if src_proj_boolean == True:
proj = src_proj
# We want a section of source that matches this:
match_filename = match_fn
match_ds = gdal.Open(match_filename, GA_ReadOnly)
match_proj = match_ds.GetProjection()
match_geotrans = match_ds.GetGeoTransform()
wide = match_ds.RasterXSize
high = match_ds.RasterYSize
# Output / destination
dst_filename = dst_fn
dst = gdal.GetDriverByName('GTiff').Create(dst_filename, wide, high, 1,
GDT_Float32)
dst.SetGeoTransform(match_geotrans)
dst.SetProjection(match_proj)
# Do the work
gdal.ReprojectImage(src, dst, proj, match_proj, GRA_Bilinear)
def resample_raster(src_name, to_name, dst):
"""
Resamples and reprojects raster 'src_name' to match raster 'to_name'.
It stores the resulting raster in 'dst'.
All the parameters are filepaths.
"""
src = gdal.Open(src_name, gdalconst.GA_ReadOnly)
src_proj = src.GetProjection()
src_geotrans = src.GetGeoTransform()
match_ds = gdal.Open(to_name, gdalconst.GA_ReadOnly)
match_proj = match_ds.GetProjection()
match_geotrans = match_ds.GetGeoTransform()
wide = match_ds.RasterXSize
high = match_ds.RasterYSize
dst_filename = dst
dst = gdal.GetDriverByName('GTiff').Create(dst_filename, wide, high, 1,
gdalconst.GDT_Float32)
dst.SetGeoTransform(match_geotrans)
dst.SetProjection(match_proj)
gdal.ReprojectImage(src, dst, src_proj, match_proj, gdalconst.GRA_Bilinear)
dst = None # Flush
return dst_filename
def reproject_file(input_file_path,
gt_out = None,
prj_out = None,
shape_out = None,
outname = 'MEM',
resampling = gdal.gdalconst.GRA_NearestNeighbour):
infid = gdal.Open(input_file_path, gdal.GA_ReadOnly)
prj_in = infid.GetProjection()
gt_in = infid. GetGeoTransform()
data = infid.GetRasterBand(1).ReadAsArray().astype(np.uint8)
if not gt_out:
gt_out = gt_in
if not prj_out:
prj_out = prj_in
if not shape_out:
shape_out = data.shape
outfid = save_img(np.empty(shape_out)*np.nan,
gt_out,
prj_out,
outname,
dtype = gdal.GDT_UInt16)
gdal.ReprojectImage(infid, outfid, prj_in, prj_out, resampling)
del infid
del outfid
def gdal_resize(raster, dimensions, projection, transform):
"""
Transform a dataset to the specified dimensions and projection/bounds
:param dataset: Dataset to be resized
:param dimensions: dimensions to resize to (X, Y)
:param projection: Projection of of resized dataset
:param transform: Geotransform of resized dataset
:return: Resized dataset
"""
dataset = get_dataset(raster)
datatype = dataset.GetRasterBand(1).DataType
resized_ds = gdal.GetDriverByName('MEM').Create('', dimensions[0],
dimensions[1],
dataset.RasterCount,
datatype)
for i in range(1, resized_ds.RasterCount + 1):
nodatavalue = dataset.GetRasterBand(i).GetNoDataValue()
resized_band = resized_ds.GetRasterBand(i)
resized_arr = resized_band.ReadAsArray()
if nodatavalue:
resized_arr[resized_arr == 0] = nodatavalue
resized_band.SetNoDataValue(nodatavalue)
resized_band.WriteArray(resized_arr)
resized_ds.SetGeoTransform(transform)
resized_ds.SetProjection(projection)
gdal.ReprojectImage(dataset, resized_ds)
return resized_ds
def reproject_raster(inputRaster,
outFilename,
srs_or_refRas=None,
px_size=None,
driver='GTiff',
resampling=None):
'''
Raster reprojection. Use Spatial Reference object and provide pixel size or reference raster. If reference raster is
provided, the output raster will have exactly the same GT.
:param inputRaster: gdal.Datasource
:param outFilename: filename of reprojected raster
:param srs_or_refRas: osr.SpatialReference or gdal.Datasource
:param px_size: int - Pixel Size in unit of target projection
:param driver: char
:param resampling: gdal.GRA resampling method
:return: None - writes raster dataset to disk
'''
import gdal
from geotools.vector import reproject_xy_coords
import osr
if resampling is None:
resampling = gdal.GRA_Bilinear
in_srs = get_srs_ras(inputRaster)
in_gt = inputRaster.GetGeoTransform()
# use reference gdal.Dataset to extract SRS, GT, pixel size - output extent will match reference
if isinstance(srs_or_refRas, gdal.Dataset):
refRas = srs_or_refRas
out_srs = get_srs_ras(refRas)
out_gt = refRas.GetGeoTransform()
xSize = refRas.RasterXSize
ySize = refRas.RasterYSize
# use spatial reference and reproject whole image - create GeoTransform values and x-/y-size for reprojected raster
if isinstance(srs_or_refRas, osr.SpatialReference):
out_srs = srs_or_refRas
in_gt = inputRaster.GetGeoTransform()
ul_x, ul_y = reproject_xy_coords(in_gt[0], in_gt[3], in_srs, out_srs)
lr_x, lr_y = reproject_xy_coords(
in_gt[0] + in_gt[1] * inputRaster.RasterXSize,
in_gt[3] + in_gt[5] * inputRaster.RasterYSize, in_srs, out_srs)
out_gt = (ul_x, px_size, in_gt[2], ul_y, in_gt[4], -px_size)
xSize = int((lr_x - ul_x) / px_size)
ySize = int((ul_y - lr_y) / px_size)
in_dtype = inputRaster.GetRasterBand(1).DataType
n_bands = inputRaster.RasterCount
out_ras = gdal.GetDriverByName(driver).Create(outFilename, xSize, ySize,
n_bands, in_dtype)
out_ras.SetGeoTransform(out_gt)
out_ras.SetProjection(out_srs.ExportToWkt())
gdal.ReprojectImage(inputRaster, out_ras, in_srs.ExportToWkt(),
out_srs.ExportToWkt(), resampling)
del out_ras
return gdal.Open(outFilename)
def ReprojectRaster(inRaster, refProj):
drvMemR = gdal.GetDriverByName('MEM')
# (1) Build the coordinate transformation for the geotransform
inPR = osr.SpatialReference()
inPR.ImportFromWkt(inRaster.GetProjection())
outPR = osr.SpatialReference()
outPR.ImportFromWkt(refProj)
transform = osr.CoordinateTransformation(inPR, outPR)
# (2) Build the output Geotransform, pixelsize and imagesize
inGT = inRaster.GetGeoTransform()
cols = inRaster.RasterXSize
rows = inRaster.RasterYSize
ulx, uly, ulz = transform.TransformPoint(inGT[0], inGT[3])
lrx, lry, lrz = transform.TransformPoint(inGT[0] + inGT[1] * cols, inGT[3] + inGT[5] * rows)
pxSize = int(lrx - ulx) / cols
newcols = int((lrx - ulx)/ pxSize)
newrows = int((uly - lry)/ pxSize)
outGT = (ulx, pxSize, inGT[2], uly, inGT[4], -pxSize)
# (3) Create the new file and reproject
dtype = inRaster.GetRasterBand(1).DataType
outfile = drvMemR.Create('', newcols, newrows, 1, dtype)
outfile.SetProjection(refProj)
outfile.SetGeoTransform(outGT)
res = gdal.ReprojectImage(inRaster, outfile, inPR.ExportToWkt(), refProj, gdal.GRA_NearestNeighbour)
return outfile
def reproject_image_to_master(master, slave, res=None):
slave_ds = gdal.Open(slave)
if slave_ds is None:
raise IOError
slave_proj = slave_ds.GetProjection()
slave_geotrans = slave_ds.GetGeoTransform()
data_type = slave_ds.GetRasterBand(1).DataType
n_bands = slave_ds.RasterCount
master_ds = gdal.Open(master)
if master_ds is None:
raise IOError
master_proj = master_ds.GetProjection()
master_geotrans = master_ds.GetGeoTransform()
w = master_ds.RasterXSize
h = master_ds.RasterYSize
if res is not None:
master_geotrans[1] = float(res)
master_geotrans[-1] = -float(res)
dst_filename = slave.replace(".tif", "_crop.tif")
dst_ds = gdal.GetDriverByName('GTiff').Create(dst_filename, w, h, n_bands,
data_type)
dst_ds.SetGeoTransform(master_geotrans)
dst_ds.SetProjection(master_proj)
gdal.ReprojectImage(slave_ds, dst_ds, slave_proj, master_proj,
gdal.GRA_NearestNeighbour)
dst_ds = None # Flush to disk
return dst_filename
def reproject_resample_scaled(src_filename,
match_filename,
scale,
dst_dirc=None):
src = gdal.Open(src_filename, gdalconst.GA_ReadOnly)
src_proj = src.GetProjection()
src_geotrans = src.GetGeoTransform()
# We want a section of source that matches this:
match_ds = gdal.Open(match_filename, gdalconst.GA_ReadOnly)
match_proj = match_ds.GetProjection()
match_geotrans = match_ds.GetGeoTransform()
# match_ds is the naip at 1 m resolution.
wide = int(np.floor(match_ds.RasterXSize / scale))
high = int(np.floor(match_ds.RasterYSize / scale))
bands = src.RasterCount
# Output / destination
# include the match file index
index = match_filename.split('_')[4]
dst_filename = '%s/%s_%s' % (dst_dirc, index,
os.path.basename(src_filename))
dst = gdal.GetDriverByName('GTiff').Create(dst_filename, wide, high, bands, \
gdalconst.GDT_Float32)
dst.SetGeoTransform(
[match_geotrans[0], scale, 0, match_geotrans[3], 0, -scale])
dst.SetProjection(match_proj)
#dst.GetRasterBand(1).WriteArray()
# Do the work
gdal.ReprojectImage(src, dst, src_proj, match_proj,
gdalconst.GRA_NearestNeighbour)
del dst
return (print('wrote %s' % dst_filename))
def _warpTo(source, target, func, max_error=0.125):
if func is None:
raise TypeError(
"Resampling method {} not available in your GDAL version".format(
func))
target = np.atleast_2d(target)
if target.ndim < source.ndim:
target = np.broadcast_to(target,
source.shape[:-len(target.shape)] +
target.shape,
subok=True)
target = np.ma.array(target,
mask=target == target.fill_value,
dtype=source.dtype,
copy=True,
subok=True)
target[target.mask] = source.fill_value
target.fill_value = source.fill_value
out = _getDataset(target, True)
gdal.ReprojectImage(_getDataset(source), out, None, None,
_RESAMPLING[func], 0.0, max_error)
return _fromDataset(out)
def resample( src_ds, target_ds, resolution=True, projection=False):
src_ds = 'HDF4_EOS:EOS_GRID:%s:MOD_Grid_BRDF:BRDF_Albedo_Parameters_shortwave'%src_ds
if type(src_ds) != gdal.Dataset:
src_ds = gdal.Open(src_ds)
if src_ds is None:
raise ValueError
src_proj = src_ds.GetProjection()
src_geoT = src_ds.GetGeoTransform()
if type(target_ds) != gdal.Dataset:
target_ds = gdal.Open(target_ds)
if target_ds is None:
raise ValueError
target_proj = target_ds.GetProjection()
target_geoT = target_ds.GetGeoTransform()
dst = gdal.GetDriverByName("MEM").Create("", src_ds.RasterXSize,
src_ds.RasterYSize, target_ds.RasterCount, gdal.GDT_UInt16)
dst.SetGeoTransform(src_geoT)
dst.SetProjection(src_proj)
gdal.ReprojectImage(target_ds, dst, src_proj,
src_proj, gdal.GRA_NearestNeighbour)
data = dst.ReadAsArray()
return data
def copy_resolution(self, refobj, resampling=3):
"""
Copy resolution and projection from other GridObj
Results are saved in a virtual raster
INPUTS
refobj [instance] reference GridObj
resampling [int] resampling method
[0] Nearest Neighbour
[1] Averange
[2] Bilinear
[3] Cubic (default)
[4] Cubic Spline
OUTPUTS
newobj [GridObj] resampled and reprojected new GridObj
"""
if type(self.driver) is not _gdal.Dataset: # it is a valid gdal dataset?
raise TypeError('You must connect with a raster file!')
if type(refobj.driver) is not _gdal.Dataset: # it is a valid gdal dataset?
raise TypeError('refobj is not a gdal Dataset!')
# Default resampling methods
methods = [
_gdalconst.GRA_NearestNeighbour,
_gdalconst.GRA_Average,
_gdalconst.GRA_Bilinear,
_gdalconst.GRA_Cubic,
_gdalconst.GRA_CubicSpline
]
resampling = int(resampling)
assert 0 <= resampling <= 4
method = methods[resampling]
# Create memory layer
band_data = self.driver.GetRasterBand(1)
driver = _gdal.GetDriverByName('MEM')
dest = driver.Create('', refobj.xsize, refobj.ysize, self.bands,
band_data.DataType)
dest.SetGeoTransform(refobj.geotransform)
dest.SetProjection(refobj.projectionref)
# Reproject image
_gdal.ReprojectImage(self.driver, dest, self.projectionref,
refobj.projectionref, method)
# Create new grid obj
newobj = GridObj() # create new grid object
newobj.driver = dest # set connection
newobj.filename = ''
newobj.divername = 'MEM'
newobj.bands = dest.RasterCount
newobj.geotransform = dest.GetGeoTransform()
newobj.projectionref = dest.GetProjectionRef()
newobj.xsize = dest.RasterXSize
newobj.ysize = dest.RasterYSize
# Close files
del (dest)
band_data = None
return(newobj) # copy_resolution()
def reproject_resample_tif(in_raster, out_raster, ref_raster):
''' Reprojects the inout raster to match the CRS and cell size of the reference raster.'''
''' Resampling method: Nearest Neighbour.'''
print('Reprojecting and resampling tif...')
theinput = gdal.Open(in_raster, gdal.GA_ReadOnly)
inputProj = theinput.GetProjection()
inputTrans = theinput.GetGeoTransform()
reference = gdal.Open(ref_raster, gdal.GA_ReadOnly)
referenceProj = reference.GetProjection()
referenceTrans = reference.GetGeoTransform()
bandreference = reference.GetRasterBand(1)
x = reference.RasterXSize
y = reference.RasterYSize
# Chceck if raster exists. If yes, delete.
if os.path.exists(out_raster):
print('Raster exists, deleting')
os.remove(out_raster)
driver = gdal.GetDriverByName('GTiff')
output = driver.Create(out_raster, x, y, 1, bandreference.DataType)
output.SetGeoTransform(referenceTrans)
output.SetProjection(referenceProj)
gdal.ReprojectImage(theinput, output, inputProj, referenceProj,
gdal.GRA_NearestNeighbour)
print('Tif reprojected and resampled')
del theinput, output, reference
def resample_array (data,
gt_in,
prj_in,
gt_out = None,
prj_out = None,
shape_out = None,
outname = 'MEM',
resampling = gdal.gdalconst.GRA_Bilinear):
infid = save_img (data,
gt_in,
prj_in,
'MEM',
noDataValue = np.nan,
dtype=gdal.GDT_Float32)
if not gt_out:
gt_out = gt_in
if not prj_out:
prj_out = prj_in
if not shape_out:
shape_out = data.shape
outfid = save_img(np.empty(shape_out)*np.nan, gt_out, prj_out, outname)
gdal.ReprojectImage(infid, outfid, prj_in, prj_out, resampling)
infid = None
data = outfid.GetRasterBand(1).ReadAsArray()
return data
def convertProjection(data, filename):
landsatData = gdal.Open(filename, GA_ReadOnly)
oldRef = osr.SpatialReference()
oldRef.ImportFromWkt(data.GetProjectionRef())
newRef = osr.SpatialReference()
newRef.ImportFromWkt(landsatData.GetProjectionRef())
transform = osr.CoordinateTransformation(oldRef, newRef)
tVect = data.GetGeoTransform()
nx, ny = data.RasterXSize, data.RasterYSize
(ulx, uly, ulz) = transform.TransformPoint(tVect[0], tVect[3])
(lrx, lry, lrz) = transform.TransformPoint(tVect[0] + tVect[1] * nx,
tVect[3] + tVect[5] * ny)
memDrv = gdal.GetDriverByName('MEM')
dataOut = memDrv.Create('name', int((lrx - ulx) / dx), int(
(uly - lry) / dx), 1, gdal.GDT_Float32)
newtVect = (ulx, dx, tVect[2], uly, tVect[4], -dx)
dataOut.SetGeoTransform(newtVect)
dataOut.SetProjection(newRef.ExportToWkt())
# Perform the projection/resampling
res = gdal.ReprojectImage(data, dataOut, oldRef.ExportToWkt(),
newRef.ExportToWkt(), gdal.GRA_Cubic)
return dataOut
def prep_calc(filename, path_to_ortho, path_to_slope, path_to_aspect,
path_to_output):
#open orthophoto and extract information
ortho = gdal.Open(path_to_ortho, gdalconst.GA_ReadOnly)
ortho_proj = ortho.GetProjection()
#########################################################################################################################
#open aspect raster and extract information
aspect = gdal.Open(path_to_aspect, gdalconst.GA_ReadOnly)
aspect_XSize = aspect.RasterXSize
aspect_YSize = aspect.RasterYSize
aspect_proj = aspect.GetProjection()
aspect_geotransform = aspect.GetGeoTransform()
###########################################################################################################################
#Preform resampling on orthophoto to match extent and resolution of aspect and slope rasters
# Create Output / destination
dst_filename = path_to_output + filename[:-4] + '_warped.tif'
dst = gdal.GetDriverByName('GTiff').Create(dst_filename, aspect_XSize,
aspect_YSize, 1,
gdalconst.GDT_Float32)
dst.SetGeoTransform(aspect_geotransform)
dst.SetProjection(aspect_proj)
# Do the work
gdal.ReprojectImage(ortho, dst, ortho_proj, aspect_proj)
del dst
del aspect
del ortho # Flush
return dst_filename
def resample_raster(inputfile_path,
referencefile_path,
outputfile_path,
band_num=1):
input_raster = gdal.Open(inputfile_path, gdalconst.GA_ReadOnly)
input_band = input_raster.GetRasterBand(band_num)
inputProj = input_raster.GetProjection()
inputTrans = input_raster.GetGeoTransform()
reference = gdal.Open(referencefile_path, gdalconst.GA_ReadOnly)
referenceProj = reference.GetProjection()
referenceTrans = reference.GetGeoTransform()
bandreference = reference.GetRasterBand(1)
x = reference.RasterXSize
y = reference.RasterYSize
driver = gdal.GetDriverByName('GTiff')
output = driver.Create(outputfile_path, x, y, 1, bandreference.DataType)
output.SetGeoTransform(referenceTrans)
output.SetProjection(referenceProj)
gdal.ReprojectImage(input_raster, output, inputProj, referenceProj,
gdalconst.GRA_Bilinear)
del output
def egm96_to_wgs84_heights(dem, geoid):
"""
Convert heights above the EGM96 geoid to heights above the WGS84 ellipsoid,
for example, as required to use the RADARSAT-2 rational function model.
"""
dem_ds = gdal.Open(dem, gdal.GA_Update)
# Load the EGM96 dataset (DEM ds is passed as an argument)
#egm96_ds = gdal.Open(os.path.join(os.path.dirname(ag.__file__), "etc", "WW15MGH_copy.tif")) # File is located in the software directory
egm96_ds = gdal.Open(geoid)
# Setup an in-memory raster using the DEM as a template
driver = gdal.GetDriverByName("MEM")
resamp_ds = driver.Create("", dem_ds.RasterXSize, dem_ds.RasterYSize, 1,
gdal.GDT_Float32)
resamp_ds.SetProjection(dem_ds.GetProjection())
resamp_ds.SetGeoTransform(dem_ds.GetGeoTransform())
# Reproject / resample the EGM96 data to the DEM resolution / space.
gdal.ReprojectImage(egm96_ds, resamp_ds, egm96_ds.GetProjection(),
dem_ds.GetProjection(), gdal.GRA_Cubic)
# Add (subtract) the difference between EGM96 and WGS84 and return the resulting DEM.
egm96 = resamp_ds.ReadAsArray()
dem = dem_ds.ReadAsArray().astype(np.float32)
dem[dem != -32768] += egm96[dem != -32768]
# re-write DEM
dem_ds.GetRasterBand(1).WriteArray(dem)
del dem_ds
def reproject_dataset(self,
dataset,
pixel_spacing=None,
epsg_from=None,
epsg_to=None):
"""
A sample function to reproject and resample a GDAL dataset from within
Python. The idea here is to reproject from one system to another, as well
as to change the pixel size. The procedure is slightly long-winded, but
goes like this:
1. Set up the two Spatial Reference systems.
2. Open the original dataset, and get the geotransform
3. Calculate bounds of new geotransform by projecting the UL corners
4. Calculate the number of pixels with the new projection & spacing
5. Create an in-memory raster dataset
6. Perform the projection
"""
# Define the UK OSNG, see <http://spatialreference.org/ref/epsg/27700/>
out = osr.SpatialReference()
out.ImportFromEPSG(epsg_to)
sinu = osr.SpatialReference()
# wgs84.ImportFromEPSG ( epsg_from )
sinu.ImportFromWkt(epsg_from)
tx = osr.CoordinateTransformation(sinu, out)
# Up to here, all the projection have been defined, as well as a
# transformation from the from to the to :)
# We now open the dataset
# g = gdal.Open ( dataset )
# Get the Geotransform vector
geo_t = dataset.GetGeoTransform()
x_size = dataset.RasterXSize # Raster xsize
y_size = dataset.RasterYSize # Raster ysize
# Work out the boundaries of the new dataset in the target projection
(ulx, uly, ulz) = tx.TransformPoint(geo_t[0], geo_t[3])
(lrx, lry, lrz) = tx.TransformPoint(geo_t[0] + geo_t[1] * x_size,
geo_t[3] + geo_t[5] * y_size)
# print ulx, uly, ulz
# print lrx, lry, lrz
# See how using 27700 and WGS84 introduces a z-value!
# Now, we create an in-memory raster
mem_drv = gdal.GetDriverByName('MEM')
# The size of the raster is given the new projection and pixel spacing
# Using the values we calculated above. Also, setting it to store one band
# and to use Float32 data type.
dest = mem_drv.Create('', int((lrx - ulx) / pixel_spacing),
int((uly - lry) / pixel_spacing), 1,
gdal.GDT_Float32)
# Calculate the new geotransform
new_geo = (ulx, pixel_spacing, geo_t[2], uly, geo_t[4], -pixel_spacing)
# Set the geotransform
dest.SetGeoTransform(new_geo)
dest.SetProjection(out.ExportToWkt())
# Perform the projection/resampling
res = gdal.ReprojectImage(dataset, dest, sinu.ExportToWkt(),
out.ExportToWkt(), gdal.GRA_NearestNeighbour)
return dest
def rasterReproject():
# 获取源数据及栅格信息
gdal.AllRegister()
src_data = gdal.Open("smallaster.img")
# 获取源的坐标信息
srcSRS_wkt = src_data.GetProjection()
srcSRS = osr.SpatialReference()
srcSRS.ImportFromWkt(srcSRS_wkt)
# 获取栅格尺寸
src_width = src_data.RasterXSize
src_height = src_data.RasterYSize
src_count = src_data.RasterCount
# 获取源图像的仿射变换参数
src_trans = src_data.GetGeoTransform()
OriginLX_src = src_trans[0]
OriginTY_src = src_trans[3]
pixl_w_src = src_trans[1]
pixl_h_src = src_trans[5]
OriginRX_src = OriginLX_src + pixl_w_src * src_width
OriginBY_src = OriginTY_src + pixl_h_src * src_height
# 创建输出图像
driver = gdal.GetDriverByName("GTiff")
driver.Register()
dst_data = driver.Create("tpix1.tif", src_width, src_height, src_count)
# 设置输出图像的坐标
dstSRS = osr.SpatialReference()
dstSRS.ImportFromEPSG(4326)
# 投影转换
ct = osr.CoordinateTransformation(srcSRS, dstSRS)
# 计算目标影像的左上和右下坐标,即目标影像的仿射变换参数
OriginLX_dst, OriginTY_dst, temp = ct.TransformPoint(
OriginLX_src, OriginTY_src)
OriginRX_dst, OriginBY_dst, temp = ct.TransformPoint(
OriginRX_src, OriginBY_src)
pixl_w_dst = (OriginRX_dst - OriginLX_dst) / src_width
pixl_h_dst = (OriginBY_dst - OriginTY_dst) / src_height
dst_trans = [OriginLX_dst, pixl_w_dst, 0, OriginTY_dst, 0, pixl_h_dst]
# print outTrans
dstSRS_wkt = dstSRS.ExportToWkt()
# 设置仿射变换系数及投影
dst_data.SetGeoTransform(dst_trans)
dst_data.SetProjection(dstSRS_wkt)
# 重新投影
gdal.ReprojectImage(src_data, dst_data, srcSRS_wkt, dstSRS_wkt,
GRA_Bilinear)
# 创建四级金字塔
gdal.SetConfigOption('HFA_USE_RRD', 'YES')
dst_data.BuildOverviews(overviewlist=[2, 4, 8, 16])
# 计算统计值
for i in range(0, src_count):
band = dst_data.GetRasterBand(i + 1)
band.SetNoDataValue(-99)
print
band.GetStatistics(0, 1)
def reprojectMatch(self, referenceFile, reduce_zone=True):
""" Permet de reprojeter, découper, aligner et rééchantillonner une image à partir d'une image de référence.
Args:
referenceFile (str): Path du fichier de l'image de référence à utiliser.
reduce_zone (bool): Indicateur permettant de choisir si on souhaite réduire la zone d'étude
sur laquelle les images sont "matchées". Ceci est utile pour éviter des
problèmes avec des valeurs nulles sur les bords des images qui s'alignent
sur le referenceFile. Par défaut, cette option est égale à True (donc, on
effectue le rétrécissement de zone).
Returns:
outputfile (str): Path du fichier de l'image reprojetée.
"""
inputFile = self.filename # path de l'image à reprojeter
# Ouvrir l'image de référence et obtenir sa projection ses paramètres de transformation affine
reference = gdal.Open(referenceFile, gdalconst.GA_ReadOnly)
referenceProj = reference.GetProjection()
referenceTrans = reference.GetGeoTransform()
bandreference = reference.GetRasterBand(1)
# Transformer les paramètres de la transformation de tuples vers list afin de pouvoir les modifier.
# On additionne la résolution des pixels aux coordonnées du coin en haut à gauche du pixel en haut à gauche
# afin d'avoir une zone de référence plus petite que la zone de l'input file
referenceTrans = list(referenceTrans)
referenceTrans[0] = referenceTrans[0] + referenceTrans[1]
referenceTrans[3] = referenceTrans[3] + referenceTrans[5]
referenceTrans = tuple(referenceTrans)
# on réduit la zone de 2 lignes et 2 colonnes (au bords de l'image) si reduce_zone = True
if reduce_zone:
x = reference.RasterXSize - 2
y = reference.RasterYSize - 2
else:
x = reference.RasterXSize
y = reference.RasterYSize
# Créer le outputfile avec le format de l'image de référence
if inputFile.endswith(".TIF"): # .TIF si l'image provient de earthdata
outputfile = inputFile.replace(".TIF", "_reproject.TIF")
else:
outputfile = inputFile.replace(".tif", "_reproject.tif")
driver = gdal.GetDriverByName('GTiff')
output = driver.Create(
outputfile, x, y, 1, gdal.GDT_Float32
) # originalement bandreference.DataType au lieu de GDT_Float32
output.SetGeoTransform(referenceTrans)
output.SetProjection(referenceProj)
# Reprojeter l'image
gdal.ReprojectImage(self.dataset, output, self.proj, referenceProj,
gdalconst.GRA_Average)
del output
return outputfile
def coarsen(self, pixel_size, func='average'):
"""
Constructs new field with lower granularity.
NOTES:
* Resampling seems unnecessarily complicated using the GDAL python wrapper.
The command-line 'gdalwarp' is the C++ option, but there is no similar function in
python. This approach is inspired by:
http://gis.stackexchange.com/questions/139906/replicating-result-of-gdalwarp-using-gdal-python-bindings
@param pixel_size - the desired pixel size (use FieldGranularity in future?)
@param func - the name of the function used t aggergate
@return - a new coarser field
"""
if func in ('average', 'mean'):
func = gdal.GRA_Average
elif func == 'bilinear':
func = gdal.GRA_Bilinear
elif func == 'cubic':
func = gdal.GRA_Cubic
elif func == 'cubic_spline':
func = gdal.GRA_CubicSpline
elif func == 'lanczos':
func = gdal.GRA_Lanczos
elif func == 'mode':
func = gdal.GRA_Mode
elif func == 'nearest_neighbor':
func = gdal.GRA_NearestNeighbour
else:
raise ValueError("@func not a valid value.")
#get bounds of current raster
minx, miny, maxx, maxy = self.bounds()
dest_nrows = abs(int((maxx - minx) / float(pixel_size)))
dest_ncols = abs(int((maxy - miny) / float(pixel_size)))
#note: seems like there is a maximum number of rows X columns (if exceeded, will return None)
driver = gdal.GetDriverByName('MEM').Create('', dest_nrows, dest_ncols,
1, gdal.GDT_Byte)
dest_transform = (minx, pixel_size, 0, maxy, 0, -pixel_size)
dest.SetGeoTransform(dest_transform)
dest.SetProjection(self.projection)
orig_dataset = self.to_gdal_dataset()
gdal.ReprojectImage(orig_dataset, dst, self.projection,
self.projection, func)
return from_gdal_dataset(dst)
def aggregate_grid(input_file, scale, year):
""" Create grid that land cover data is saved in when aggregating from smaller scale to larger scale
:param input_file: Full path and filename of input land cover
:type input_file: String
:param scale: Resolution to aggregate data to in meters, suggested at 1000 or 3000
:type scale: Int
:param year: Year that land cover is being initialized from
:type year: Int
:return: New land cover raster at a specified resolution
:type: Tiff
"""
# Open the GeoTiff based on the input path and file
src_ds = gdal.Open(input_file)
# Create the name of the output file by modifying the input file
gcam_write_file = 'gcam_' + str(int(scale)) + '_domain_' + str(
int(year)) + '.tiff'
# Get key info on the source data set
src_ncols = src_ds.RasterXSize
src_nrows = src_ds.RasterYSize
src_geot = src_ds.GetGeoTransform()
src_proj = src_ds.GetProjection()
src_res = src_ds.GetGeoTransform()[1]
agg_factor = scale / src_res
dst_ncols = int(src_ncols / agg_factor)
dst_nrows = int(src_nrows / agg_factor)
dst_driver = gdal.GetDriverByName('Gtiff')
output = os.path.join(os.path.dirname(input_file), gcam_write_file)
dst_ds = dst_driver.Create(output, dst_ncols, dst_nrows, 1,
gdal.GDT_Float32)
dst_geot = (src_geot[0], src_geot[1] * agg_factor, src_geot[2],
src_geot[3], src_geot[4], src_geot[5] * agg_factor)
dst_ds.SetGeoTransform(dst_geot)
dst_ds.SetProjection(src_proj)
gdal.ReprojectImage(src_ds, dst_ds, src_proj, src_proj, gdal.GRA_Mode)
src_ds = None
dst_ds = None
return
def ReprojectRaster(valRaster, GEOMraster):
vasRaster_sub = drvMemR.Create('', GEOMraster.RasterXSize,
GEOMraster.RasterYSize, 1,
gdal.GDT_Float32)
vasRaster_sub.SetGeoTransform(GEOMraster.GetGeoTransform())
vasRaster_sub.SetProjection(GEOMraster.GetProjection())
gdal.ReprojectImage(valRaster, vasRaster_sub,
valRaster.GetProjection(),
GEOMraster.GetProjection(),
gdal.GRA_NearestNeighbour)
return vasRaster_sub
def reproject_image_to_master(master, src, dst):
"""This function reprojects an image (``src``) to
match the extent, resolution and projection of another
(``master``) using GDAL. The newly reprojected image
is a GDAL VRT file for efficiency. A different spatial
resolution can be chosen by specifyign the optional
``res`` parameter. The function returns the new file's
name.
*Parameters*
master: str
A filename (with full path if required) with the
master image (that that will be taken as a reference)
src: str
A filename (with path if needed) with the image
that will be reprojected
res: float, optional
The desired output spatial resolution, if different
to the one in ``master``.
*Returns*
The reprojected filename
code credit: https://github.com/jgomezdans/eoldas_ng_observations
"""
src_ds = gdal.Open(src)
if src_ds is None:
raise IOError("GDAL could not open src file {}".format(src))
src_proj = src_ds.GetProjection()
src_geotrans = src_ds.GetGeoTransform()
data_type = src_ds.GetRasterBand(1).DataType
n_bands = src_ds.RasterCount
master_ds = gdal.Open(master)
if master_ds is None:
raise IOError("GDAL could not open master file {}".format(master))
master_proj = master_ds.GetProjection()
master_geotrans = master_ds.GetGeoTransform()
w = master_ds.RasterXSize
h = master_ds.RasterYSize
dst_filename = dst
dst_ds = gdal.GetDriverByName('GTiff').Create(dst_filename, w, h, n_bands,
data_type)
dst_ds.SetGeoTransform(master_geotrans)
dst_ds.SetProjection(master_proj)
gdal.ReprojectImage(src_ds, dst_ds, src_proj, master_proj,
gdal.GRA_NearestNeighbour)
dst_ds = None # Flush to disk
return dst_filename
def align_raster(self, raster2align_path):
gdal.AllRegister()
logging.info(' *** -- aligning raster ... ')
input = gdal.Open(raster2align_path, gdalconst.GA_ReadOnly)
input_proj = input.GetProjection()
try:
if not self.reference_set:
logging.info(' -- setting up reference raster ... ')
self.set_reference_raster()
logging.info(' > OK -- cooling down ... ')
time.sleep(60)
except:
logging.info(
'WARNING: Could not set reference raster for alignment.')
try:
outputfile = raster2align_path.split(
'.tif')[0] + 'a.tif' # Path to output file
except:
logging.info('WARNING: Invalid raster path for alignment: ' +
str(raster2align_path))
try:
if os.path.exists(outputfile):
try:
logging.info(' -- removing existing file (' +
outputfile + ') ... ')
os.remove(outputfile)
except:
logging.info('WARNING: Cannot write aligned output (' +
outputfile + ' is locked).')
logging.info(' -- set driver ...')
driver = gdal.GetDriverByName('GTiff')
driver.Register()
output = driver.Create(outputfile, self.x_ref, self.y_ref, 1,
self.band_ref.DataType)
logging.info(' -- apply transformation ...')
output.SetGeoTransform(self.reference_trans)
logging.info(' -- apply projection ...')
output.SetProjection(self.reference_proj)
logging.info(' -- project image ..')
gdal.ReprojectImage(input, output, input_proj, self.reference_proj,
gdalconst.GRA_Bilinear)
# dst_ds = driver.CreateCopy(destFile, output, 0)
new_path = outputfile
logging.info(' *** -- OK - aligned raster path: ' + new_path +
'... cooling down ...')
time.sleep(5)
except:
logging.info('ERROR: Alignment failed.')
new_path = 'none'
return new_path
def Raster_to_Array(input_tiff,
ll_corner,
x_ncells,
y_ncells,
values_type='float32'):
"""
Loads a raster into a numpy array
"""
# Input
inp_lyr = gdal.Open(input_tiff)
inp_srs = inp_lyr.GetProjection()
inp_transform = inp_lyr.GetGeoTransform()
inp_band = inp_lyr.GetRasterBand(1)
inp_data_type = inp_band.DataType
cellsize_x = inp_transform[1]
rot_1 = inp_transform[2]
rot_2 = inp_transform[4]
cellsize_y = inp_transform[5]
NoData_value = inp_band.GetNoDataValue()
ll_x = ll_corner[0]
ll_y = ll_corner[1]
top_left_x = ll_x
top_left_y = ll_y - cellsize_y * y_ncells
# Change start point
temp_path = tempfile.mkdtemp()
temp_driver = gdal.GetDriverByName('GTiff')
temp_tiff = os.path.join(temp_path, os.path.basename(input_tiff))
temp_source = temp_driver.Create(temp_tiff, x_ncells, y_ncells, 1,
inp_data_type)
temp_source.GetRasterBand(1).SetNoDataValue(NoData_value)
temp_source.SetGeoTransform(
(top_left_x, cellsize_x, rot_1, top_left_y, rot_2, cellsize_y))
temp_source.SetProjection(inp_srs)
# Snap
gdal.ReprojectImage(inp_lyr, temp_source, inp_srs, inp_srs,
gdal.GRA_Bilinear)
temp_source = None
# Read array
d_type = pd.np.dtype(values_type)
out_lyr = gdal.Open(temp_tiff)
array = out_lyr.ReadAsArray(0, 0, out_lyr.RasterXSize,
out_lyr.RasterYSize).astype(d_type)
array[pd.np.isclose(array, NoData_value)] = pd.np.nan
out_lyr = None
return array
def resample_dataset(src_file_name, dst_file_name, dst_spacing_x,
dst_spacing_y):
print("{}|{}|{}|{}".format(src_file_name, dst_file_name, dst_spacing_x,
dst_spacing_y))
dataset = gdal.Open(src_file_name, gdal.gdalconst.GA_ReadOnly)
src_x_size = dataset.RasterXSize
src_y_size = dataset.RasterYSize
print("Source dataset {} of size {}x{}".format(src_file_name, src_x_size,
src_y_size))
src_geo_transform = dataset.GetGeoTransform()
(ulx, uly) = (src_geo_transform[0], src_geo_transform[3])
(lrx, lry) = (
src_geo_transform[0] + src_geo_transform[1] * src_x_size,
src_geo_transform[3] + src_geo_transform[5] * src_y_size,
)
print("Source coordinates ({}, {})-({},{})".format(ulx, uly, lrx, lry))
dst_x_size = int(round((lrx - ulx) / dst_spacing_x))
dst_y_size = int(round((lry - uly) / dst_spacing_y))
print("Destination dataset {} of size {}x{}".format(
dst_file_name, dst_x_size, dst_y_size))
dst_geo_transform = (
ulx,
dst_spacing_x,
src_geo_transform[2],
uly,
src_geo_transform[4],
dst_spacing_y,
)
(ulx, uly) = (dst_geo_transform[0], dst_geo_transform[3])
(lrx, lry) = (
dst_geo_transform[0] + dst_geo_transform[1] * dst_x_size,
dst_geo_transform[3] + dst_geo_transform[5] * dst_y_size,
)
print("Destination coordinates ({}, {})-({},{})".format(
ulx, uly, lrx, lry))
drv = gdal.GetDriverByName("GTiff")
dest = drv.Create(dst_file_name, dst_x_size, dst_y_size, 1,
gdal.GDT_Float32)
dest.SetGeoTransform(dst_geo_transform)
dest.SetProjection(dataset.GetProjection())
gdal.ReprojectImage(dataset, dest, dataset.GetProjection(),
dest.GetProjection(), gdal.GRA_Bilinear)
def match_rasters(match_to, match_from, destination,
resampling_method='GRA_Bilinear', ndv=0):
"""
Match a source raster to a match raster, including resolution and extent.
Parameters
==========
match_to : object
A GeoDataSet object to be matched to
match_from : object
A GeoDataSet object to be clipped
destination : str
PATH where the output will be written
resampling_method : str
Resampling method to use. Options include:
{GRA_NearestNeighbor, GRA_Bilinear (Default),
GRA_Cubic, GRA_CubicSpline, GRA_Lanczos, GRA_Average,
GRA_Mode}
Examples
========
Open an example Apollo 15 Geotiff
>>> from plio import get_path
>>> from plio.io.io_gdal import GeoDataSet
>>> ds = GeoDataSet(get_path('AS15-M-0296_SML_geo.tif'))
"""
import gdalconst # import here so Sphinx can build the docos, mocking is not working
# TODO: If a destination is not provided create an in-memory GeoDataSet object
match_to_srs = match_to.dataset.GetProjection()
match_to_gt = match_to.geotransform
width, height = match_to.raster_size
match_from__srs = match_from.dataset.GetProjection()
match_from__gt = match_from.geotransform
if not has_gdal:
raise ImportError('No module named gdal.')
dst = gdal.GetDriverByName('GTiff').Create(destination, width, height, 1,
gdalconst.GDT_Float64)
dst.SetGeoTransform(match_to_gt)
dst.SetProjection(match_to_srs)
dst.GetRasterBand(1).SetNoDataValue(ndv)
gdal.ReprojectImage(match_from.dataset, dst, None, None, getattr(gdalconst, resampling_method))