def test_transformer_4():
ds = gdal.Open('data/sstgeo.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=GEOLOC_ARRAY'])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and pnt[0] == pytest.approx(-81.961341857910156, abs=0.000001) and pnt[1] == pytest.approx(29.612689971923828, abs=0.000001) and pnt[2] == 0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and pnt[0] == pytest.approx(20, abs=0.000001) and pnt[1] == pytest.approx(10, abs=0.000001) and pnt[2] == 0, \
'got wrong reverse transform result.'
def test_transformer_no_reverse_method():
tr = gdal.Transformer(None, None, [
'SRC_SRS=+proj=longlat +ellps=GRS80', 'DST_SRS=+proj=airy +ellps=GRS80'
])
assert tr
(success, pnt) = tr.TransformPoint(0, 2, 49)
assert success
assert pnt[0] == pytest.approx(141270.54731856665, abs=1e-3), pnt
assert pnt[1] == pytest.approx(4656605.104980032, abs=1e-3), pnt
with gdaltest.error_handler():
(success, pnt) = tr.TransformPoint(1, 2, 49)
assert not success
def test_transformer_1():
ds = gdal.Open('data/byte.tif')
tr = gdal.Transformer(ds, None, [])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and pnt[0] == pytest.approx(441920, abs=0.00000001) and pnt[1] == pytest.approx(3750720, abs=0.00000001) and pnt[2] == 0.0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and pnt[0] == pytest.approx(20, abs=0.00000001) and pnt[1] == pytest.approx(10, abs=0.00000001) and pnt[2] == 0.0, \
'got wrong reverse transform result.'
def test_transformer_3():
ds = gdal.Open('data/gcps.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=GCP_TPS'])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and abs(pnt[0] - 441920) <= 0.001 and abs(pnt[1] - 3750720) <= 0.001 and pnt[2] == 0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and abs(pnt[0] - 20) <= 0.001 and abs(pnt[1] - 10) <= 0.001 and pnt[2] == 0, \
'got wrong reverse transform result.'
def test_transformer_1():
ds = gdal.Open('data/byte.tif')
tr = gdal.Transformer(ds, None, [])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and abs(pnt[0] - 441920) <= 0.00000001 and abs(pnt[1] - 3750720) <= 0.00000001 and pnt[2] == 0.0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and abs(pnt[0] - 20) <= 0.00000001 and abs(pnt[1] - 10) <= 0.00000001 and pnt[2] == 0.0, \
'got wrong reverse transform result.'
def test_transformer_4():
ds = gdal.Open('data/sstgeo.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=GEOLOC_ARRAY'])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and abs(pnt[0] + 81.961341857910156) <= 0.000001 and abs(pnt[1] - 29.612689971923828) <= 0.000001 and pnt[2] == 0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and abs(pnt[0] - 20.436627518907024) <= 0.001 and abs(pnt[1] - 10.484599774610549) <= 0.001 and pnt[2] == 0, \
'got wrong reverse transform result.'
def test_transformer_2():
ds = gdal.Open('data/gcps.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=GCP_POLYNOMIAL'])
(success, pnt) = tr.TransformPoint(0, 20, 10)
assert success and pnt[0] == pytest.approx(441920, abs=0.001) and pnt[1] == pytest.approx(3750720, abs=0.001) and pnt[2] == 0, \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and pnt[0] == pytest.approx(20, abs=0.001) and pnt[1] == pytest.approx(10, abs=0.001) and pnt[2] == 0, \
'got wrong reverse transform result.'
def test_geoloc_affine_transformation(step, convention, inverse_method):
shift = 0.5 if convention == 'PIXEL_CENTER' else 0
lon_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lon.tif', 20 // step, 1, 1, gdal.GDT_Float32)
vals = array.array('f', [-80 + step * (x + shift) for x in range(20 // step)])
lon_ds.WriteRaster(0, 0, 20 // step, 1, vals)
lon_ds = None
lat_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lat.tif', 20 // step, 1, 1, gdal.GDT_Float32)
vals = array.array('f', [50 - step * (x + shift) for x in range(20 // step)])
lat_ds.WriteRaster(0, 0, 20 // step, 1, vals)
lat_ds = None
ds = gdal.GetDriverByName('MEM').Create('', 20, 20)
md = {
'LINE_OFFSET': '0',
'LINE_STEP': str(step),
'PIXEL_OFFSET': '0',
'PIXEL_STEP': str(step),
'X_DATASET': '/vsimem/lon.tif',
'X_BAND' : '1',
'Y_DATASET': '/vsimem/lat.tif',
'Y_BAND' : '1',
'SRS': 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AXIS["Latitude",NORTH],AXIS["Longitude",EAST],AUTHORITY["EPSG","4326"]]',
'GEOREFERENCING_CONVENTION' : convention
}
ds.SetMetadata(md, 'GEOLOCATION')
with gdaltest.config_option('GDAL_GEOLOC_INVERSE_METHOD', inverse_method):
tr = gdal.Transformer(ds, None, [])
def check_point(x,y,X,Y):
success, pnt = tr.TransformPoint(False, x, y)
assert success
assert pnt == (X, Y, 0)
success, pnt = tr.TransformPoint(True, pnt[0], pnt[1])
assert success
assert pnt == pytest.approx((x, y, 0))
check_point(10, 10, -70.0, 40.0)
check_point(1.23, 2.34, -78.77, 47.66)
check_point(0, 0, -80.0, 50.0)
check_point(20, 0, -60.0, 50.0)
check_point(0, 20, -80.0, 30.0)
check_point(20, 20, -60.0, 30.0)
ds = None
gdal.Unlink('/vsimem/lon.tif')
gdal.Unlink('/vsimem/lat.tif')
def test_geoloc_affine_transformation_with_noise(step, convention):
r = random.Random(0)
shift = 0.5 if convention == 'PIXEL_CENTER' else 0
lon_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lon.tif', 20 // step, 20 // step, 1, gdal.GDT_Float32)
for y in range(lon_ds.RasterYSize):
vals = array.array('f', [-80 + step * (x + shift) + r.uniform(-0.25,0.25) for x in range(lon_ds.RasterXSize)])
lon_ds.WriteRaster(0, y, lon_ds.RasterXSize, 1, vals)
lon_ds = None
lat_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lat.tif', 20 // step, 20 // step, 1, gdal.GDT_Float32)
for x in range(lat_ds.RasterXSize):
vals = array.array('f', [50 - step * (y + shift) + r.uniform(-0.25,0.25) for y in range(lat_ds.RasterYSize)])
lat_ds.WriteRaster(x, 0, 1, lat_ds.RasterYSize, vals)
lat_ds = None
ds = gdal.GetDriverByName('MEM').Create('', 20, 20)
md = {
'LINE_OFFSET': '0',
'LINE_STEP': str(step),
'PIXEL_OFFSET': '0',
'PIXEL_STEP': str(step),
'X_DATASET': '/vsimem/lon.tif',
'X_BAND' : '1',
'Y_DATASET': '/vsimem/lat.tif',
'Y_BAND' : '1',
'SRS': 'GEOGCS["WGS 84",DATUM["WGS_1984",SPHEROID["WGS 84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.0174532925199433,AUTHORITY["EPSG","9122"]],AXIS["Latitude",NORTH],AXIS["Longitude",EAST],AUTHORITY["EPSG","4326"]]',
'GEOREFERENCING_CONVENTION' : convention
}
ds.SetMetadata(md, 'GEOLOCATION')
tr = gdal.Transformer(ds, None, [])
def check_point(x,y):
success, pnt = tr.TransformPoint(False, x, y)
assert success
success, pnt = tr.TransformPoint(True, pnt[0], pnt[1])
assert success
assert pnt == pytest.approx((x, y, 0))
check_point(10, 10)
check_point(1.23, 2.34)
check_point(0, 0)
check_point(20, 0)
check_point(0, 20)
check_point(20, 20)
ds = None
gdal.Unlink('/vsimem/lon.tif')
gdal.Unlink('/vsimem/lat.tif')
def test_geoloc_error_cases():
lon_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lon.tif', 10, 1, 1,
gdal.GDT_Float32)
lon_ds.WriteRaster(0, 0, 10, 1,
array.array('f', [-179.5 + 1 * x for x in range(10)]))
lon_ds = None
lat_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lat.tif', 10, 1, 1,
gdal.GDT_Float32)
lat_ds.WriteRaster(0, 0, 10, 1,
array.array('f', [89.5 - 1 * x for x in range(10)]))
lat_ds = None
ds = gdal.GetDriverByName('MEM').Create('', 10, 10)
ds.SetMetadata({'invalid': 'content'}, 'GEOLOCATION')
with gdaltest.error_handler():
transformer = gdal.Transformer(ds, None, [])
assert transformer is None
with gdaltest.error_handler():
transformer = gdal.Transformer(None, ds, [])
assert transformer is None
def test_transformer_tps_precision():
ds = gdal.Open('data/gcps_2115.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=GCP_TPS'])
assert tr, 'tps transformation could not be computed'
success = True
maxDiffResult = 0.0
for gcp in ds.GetGCPs():
(s, result) = tr.TransformPoint(0, gcp.GCPPixel, gcp.GCPLine)
success &= s
diffResult = math.sqrt((gcp.GCPX - result[0])**2 + (gcp.GCPY -result[1])**2)
maxDiffResult = max(maxDiffResult, diffResult)
assert success, 'at least one point could not be transformed'
assert maxDiffResult < 1e-3, 'at least one transformation exceeds the error bound'
def test_geoloc_DST_GEOLOC_ARRAY_transformer_option():
geoloc_ds = gdal.GetDriverByName('GTiff').Create('/vsimem/lonlat_DST_GEOLOC_ARRAY.tif', 10, 10, 2, gdal.GDT_Float32)
geoloc_ds.SetMetadataItem('GEOREFERENCING_CONVENTION', 'PIXEL_CENTER')
lon_band = geoloc_ds.GetRasterBand(1)
lat_band = geoloc_ds.GetRasterBand(2)
x0 = -80
y0 = 50
for y in range(geoloc_ds.RasterYSize):
lon_band.WriteRaster(0, 0, 10, 1, array.array('f', [x0 + 0.5 + 1 * x for x in range(10)]))
for x in range(geoloc_ds.RasterXSize):
lat_band.WriteRaster(0, 0, 10, 1, array.array('f', [y0 - 0.5 - 1 * x for x in range(10)]))
geoloc_ds = None
ds = gdal.GetDriverByName('MEM').Create('', 10, 10)
input_ds = gdal.GetDriverByName('MEM').Create('', 10, 10)
input_ds.SetGeoTransform([x0, 1, 0, y0, 0, -1])
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
srs.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
input_ds.SetSpatialRef(srs)
# Non-existing DST_GEOLOC_ARRAY
with gdaltest.error_handler():
assert gdal.Transformer(input_ds, ds, ['DST_GEOLOC_ARRAY=/vsimem/invalid.tif' ]) is None
tr = gdal.Transformer(input_ds, ds, ['DST_GEOLOC_ARRAY=/vsimem/lonlat_DST_GEOLOC_ARRAY.tif' ])
success, pnt = tr.TransformPoint(0, 0.5, 0.5)
assert success
assert pnt == pytest.approx((0.5, 0.5, 0))
ds = None
gdal.Unlink('/vsimem/lonlat_DST_GEOLOC_ARRAY.tif')
def test_overviewds_5():
shutil.copy('data/sstgeo.tif', 'tmp/sstgeo.tif')
shutil.copy('data/sstgeo.vrt', 'tmp/sstgeo.vrt')
ds = gdal.Open('tmp/sstgeo.vrt')
geoloc_md = ds.GetMetadata('GEOLOCATION')
tr = gdal.Transformer(ds, None, ['METHOD=GEOLOC_ARRAY'])
(_, ref_pnt) = tr.TransformPoint(0, 20, 10)
ds.BuildOverviews('NEAR', overviewlist=[2, 4])
ds = None
ds = gdal.OpenEx('tmp/sstgeo.vrt', open_options=['OVERVIEW_LEVEL=0'])
got_md = ds.GetMetadata('GEOLOCATION')
for key in geoloc_md:
assert ds.GetMetadataItem(key, 'GEOLOCATION') == got_md[key]
if key == 'PIXEL_OFFSET' or key == 'LINE_OFFSET':
assert abs(float(got_md[key]) - myfloat(geoloc_md[key]) * 2) <= 1e-1
elif key == 'PIXEL_STEP' or key == 'LINE_STEP':
assert abs(float(got_md[key]) - myfloat(geoloc_md[key]) / 2) <= 1e-1
elif got_md[key] != geoloc_md[key]:
print(got_md[key])
print(geoloc_md[key])
pytest.fail(key)
# Really check that the transformer works
tr = gdal.Transformer(ds, None, ['METHOD=GEOLOC_ARRAY'])
expected_xyz = (20.0 / 2, 10.0 / 2, 0)
(_, pnt) = tr.TransformPoint(1, ref_pnt[0], ref_pnt[1])
for i in range(3):
assert abs(pnt[i] - expected_xyz[i]) <= 0.5
ds = None
def test_transformer_14():
ds = gdal.GetDriverByName('MEM').Create('', 4032, 2688)
rpc = ["MIN_LAT=0",
"MAX_LAT=0",
"MIN_LONG=0",
"MAX_LONG=0",
"HEIGHT_OFF=244.72924043124081",
"HEIGHT_SCALE=391.44066987292678",
"LAT_OFF=0.095493639758799986",
"LAT_SCALE=-0.0977494003085103",
"LINE_DEN_COEFF=1 1.73399671259238e-05 -6.18169396309642e-06 -3.11498839490863e-05 -1.18048814815295e-05 -5.46123898974842e-05 -2.51203895820587e-05 -5.77299008756702e-05 -1.37836923606953e-05 -3.24029327866125e-06 2.06307542696228e-07 -5.16777154466466e-08 2.98762926005741e-07 3.17761145061869e-08 1.48077371641094e-07 -7.69738626480047e-08 2.94990048269861e-08 -3.37468052222007e-08 -3.67859879729462e-08 8.79847359414426e-10 ",
"LINE_NUM_COEFF=0.000721904493927027 1.02330510505135 -1.27742813759689 -0.0973049949136407 -0.014260789316429 0.00229308399354221 -0.0016640916975237 0.0124508639909873 0.00336835383694126 1.1987123734283e-05 -1.85240614830659e-05 4.40716454954686e-05 2.3198555492418e-05 -8.31659287301587e-08 -5.10329082923063e-05 2.56477008932482e-05 1.01465909326012e-05 1.04407036240869e-05 4.27413648628578e-05 2.91696764503125e-07 ",
"LINE_OFF=1343.99369782095",
"LINE_SCALE=1343.96638400536",
"LONG_OFF=-0.034423410000698595",
"LONG_SCALE=0.143444599019706",
"SAMP_DEN_COEFF=1 1.83636704399141e-05 3.55794197969218e-06 -1.33255440425932e-05 -4.25424777986987e-06 -3.95287146748821e-05 1.35786181318561e-05 -3.86131208639696e-05 -1.10085128708761e-05 -1.26863939055319e-05 -2.88045902675552e-07 -1.58732907217101e-07 4.08999884183478e-07 6.6854211618061e-08 -1.46399266323942e-07 -4.69718293745237e-08 -4.14626818788491e-08 -3.00588241056424e-07 4.54784506604435e-08 3.24214474149225e-08 ",
"SAMP_NUM_COEFF=-0.0112062780844554 -1.05096833835297 -0.704023055461029 0.0384547265206585 -0.00987134340336078 -0.00310989611092616 -0.00116937850565916 -0.0102714370609919 0.000930565787504389 7.03834691339565e-05 -3.83216250787844e-05 -3.67841179314918e-05 2.45498653278515e-05 1.06302833544472e-05 -6.26921822677631e-05 1.29769009118128e-05 1.1336284460811e-05 -3.01250967502161e-05 -7.60511798099513e-06 -4.45260900205512e-07 ",
"SAMP_OFF=2015.99417232167",
"SAMP_SCALE=2015.9777295656"
]
ds.SetMetadata(rpc, 'RPC')
old_rpc_inverse_verbose = gdal.GetConfigOption('RPC_INVERSE_VERBOSE')
gdal.SetConfigOption('RPC_INVERSE_VERBOSE', 'YES')
old_rpc_inverse_log = gdal.GetConfigOption('RPC_INVERSE_LOG')
gdal.SetConfigOption('RPC_INVERSE_LOG', '/vsimem/transformer_14.csv')
tr = gdal.Transformer(ds, None, ['METHOD=RPC', 'RPC_DEM=data/transformer_14_dem.tif'])
gdal.SetConfigOption('RPC_INVERSE_VERBOSE', old_rpc_inverse_verbose)
gdal.SetConfigOption('RPC_INVERSE_LOG', old_rpc_inverse_log)
(success, pnt) = tr.TransformPoint(0, 0, 0)
assert success and pnt[0] == pytest.approx(1.9391846640653961e-05, abs=1e-7) and pnt[1] == pytest.approx(-0.0038824752244123275, abs=1e-7)
f = gdal.VSIFOpenL('/vsimem/transformer_14.csvt', 'rb')
if f is not None:
content = gdal.VSIFReadL(1, 1000, f).decode('ASCII')
gdal.VSIFCloseL(f)
assert content.startswith('Integer,Real,Real,Real,String,Real,Real')
f = gdal.VSIFOpenL('/vsimem/transformer_14.csv', 'rb')
if f is not None:
content = gdal.VSIFReadL(1, 1000, f).decode('ASCII')
gdal.VSIFCloseL(f)
assert content.startswith("""iter,long,lat,height,WKT,error_pixel_x,error_pixel_y
0,""")
gdal.Unlink('/vsimem/transformer_14.csvt')
gdal.Unlink('/vsimem/transformer_14.csv')
def _get_shape(dataset,
input_proj,
shape_proj=4326,
dist_proj=4326,
ndist=10,
transformer=None,
min_shape_res=MIN_SHAPE_RES,
max_shape_points=MAX_SHAPE_POINTS):
""" """
if transformer is None:
transformer = gdal.Transformer(dataset, None, ['MAX_GCP_ORDER=-1'])
xsize = dataset.RasterXSize
ysize = dataset.RasterYSize
if dist_proj == 4326:
geod = pyproj.Geod(ellps='WGS84')
# Loop on bottom, right, top, left
xlims = [[0, xsize], [xsize, xsize], [xsize, 0], [0, 0]]
ylims = [[ysize, ysize], [ysize, 0], [0, 0], [0, ysize]]
shape = []
for xlim, ylim in zip(xlims, ylims):
pts = np.array([
np.linspace(xlim[0], xlim[1], ndist + 1),
np.linspace(ylim[0], ylim[1], ndist + 1)
]).transpose()
xyd = _points_to_xy(pts, transformer, input_proj, dist_proj)
if dist_proj == 4326:
dists = geod.inv(xyd[:-1, 0], xyd[:-1, 1], xyd[1:, 0], xyd[1:,
1])[2]
else:
dists = np.sqrt((xyd[1:, 0]-xyd[:-1, 0])**2+\
(xyd[1:, 1]-xyd[:-1, 1])**2)
dist = np.sum(dists)
if dist == 0.:
logger.warning('[WARNING] null distance in shape computation.')
npts = 2
else:
npts = np.ceil(dist / min_shape_res).astype('int') + 1
npts = min(max_shape_points, npts)
pts = np.array([
np.linspace(xlim[0], xlim[1], npts),
np.linspace(ylim[0], ylim[1], npts)
]).transpose()
xys = _points_to_xy(pts, transformer, input_proj, shape_proj)
shape.extend([[x, y] for x, y in zip(xys[:-1, 0], xys[:-1, 1])])
shape.append(shape[0])
return shape
def transformer_6():
ds = gdal.Open('data/rpc_5395.vrt')
tr = gdal.Transformer(ds, None, ['METHOD=RPC'])
(success, pnt) = tr.TransformPoint(0, 0.5, 0.5)
if not success \
or abs(pnt[0]-28.26163232) > 0.0001 \
or abs(pnt[1]--27.79853245) > 0.0001 \
or pnt[2] != 0:
print(success, pnt)
gdaltest.post_reason('got wrong forward transform result.')
return 'fail'
return 'success'
def transformer_7():
ds = gdal.Open('data/byte.tif')
tr = gdal.Transformer(ds, None, [])
(pnt, success) = tr.TransformPoints(0, [(20, 10)])
if success[0] == 0 \
or abs(pnt[0][0]- 441920) > 0.00000001 \
or abs(pnt[0][1]-3750720) > 0.00000001 \
or pnt[0][2] != 0.0:
print(success, pnt)
gdaltest.post_reason('got wrong forward transform result.')
return 'fail'
return 'success'
def transformer_9():
ds = gdal.Open('data/rpc.vrt')
# (long,lat)=(125.64828521533849 39.869345204440144) -> (Easting,Northing)=(213324.662167036 4418634.47813677) in EPSG:32652
ds_dem = gdal.GetDriverByName('GTiff').Create('/vsimem/dem.tif', 100, 100, 1, gdal.GDT_Byte)
sr = osr.SpatialReference()
sr.ImportFromEPSG(4326)
ds_dem.SetProjection(sr.ExportToWkt())
ds_dem.SetGeoTransform([125.647968621436,1.2111052640051412e-05,0,39.869926216038,0,-8.6569068979969188e-06])
import random
random.seed(0)
data = ''.join([ chr(40 + int(10 * random.random()) ) for i in range(100*100) ])
ds_dem.GetRasterBand(1).WriteRaster(0, 0, 100, 100, data)
ds_dem = None
for method in [ 'near', 'bilinear', 'cubic' ]:
tr = gdal.Transformer( ds, None, [ 'METHOD=RPC', 'RPC_DEM=/vsimem/dem.tif', 'RPC_DEMINTERPOLATION=%s' % method ] )
points = []
for i in range(10):
points.append((125.64828521533849, 39.869345204440144))
(pnt, success) = tr.TransformPoints( 1, points )
if not success[0]:
gdaltest.post_reason( 'failure' )
print(method)
return 'fail'
pnt_optimized = pnt[0]
(success,pnt) = tr.TransformPoint( 1, 125.64828521533849, 39.869345204440144, 0 )
if not success:
gdaltest.post_reason( 'failure' )
print(method)
return 'fail'
if pnt != pnt_optimized:
gdaltest.post_reason( 'failure' )
print(method)
print(pnt)
print(pnt_optimized)
return 'fail'
gdal.Unlink('/vsimem/dem.tif')
return 'success'
def transformgeoloc_1():
try:
from osgeo import gdalnumeric
gdalnumeric.zeros
except:
try:
import osgeo.gdal_array as gdalnumeric
except ImportError:
return 'skip'
# Setup 2x2 geolocation arrays in a memory dataset with lat/long values.
drv = gdal.GetDriverByName('MEM')
geoloc_ds = drv.Create('geoloc_1',2,2,3,gdal.GDT_Float64)
lon_array = gdalnumeric.asarray([[-117.0,-116.0],
[-116.5, -115.5]])
lat_array = gdalnumeric.asarray([[45.0, 45.5],
[44.0, 44.5]])
geoloc_ds.GetRasterBand(1).WriteArray(lon_array)
geoloc_ds.GetRasterBand(2).WriteArray(lat_array)
# Z left as default zero.
# Create a wgs84 to utm transformer.
wgs84_wkt = osr.GetUserInputAsWKT('WGS84')
utm_wkt = osr.GetUserInputAsWKT('+proj=utm +zone=11 +datum=WGS84')
ll_utm_transformer = gdal.Transformer(None, None,
['SRC_SRS='+wgs84_wkt,
'DST_SRS='+utm_wkt] )
# transform the geoloc dataset in place.
status = ll_utm_transformer.TransformGeolocations(
geoloc_ds.GetRasterBand(1),
geoloc_ds.GetRasterBand(2),
geoloc_ds.GetRasterBand(3))
print(status)
print(geoloc_ds.ReadAsArray())
return 'success'
def test_tps_1():
drv = gdal.GetDriverByName('MEM')
ds = drv.Create('foo', 2, 2)
gcp_list = [
gdal.GCP(0, 0, 0, 0, 0),
gdal.GCP(0, 50, 0, 0, 50),
gdal.GCP(50, 0, 0, 50, 0),
gdal.GCP(50, 50, 0, 50, 50),
gdal.GCP(0 * 25, 0 * 25, 0, 25, 25),
]
ds.SetGCPs(gcp_list, osr.GetUserInputAsWKT('WGS84'))
utm_wkt = osr.GetUserInputAsWKT('+proj=utm +zone=11 +datum=WGS84')
with gdaltest.error_handler():
transformer = gdal.Transformer(
ds, None, ['DST_SRS=' + utm_wkt, 'METHOD=GCP_TPS'])
assert transformer is None
def get_trajectory_bboxes(input_dset,
nbbox=10,
max_extent=None,
transformer=None):
"""
(for trajectory tiles) Compute bboxes along the trajectory.
"""
if transformer is None:
transformer = gdal.Transformer(input_dset, None, ['MAX_GCP_ORDER=-1'])
pix = np.concatenate((np.zeros(nbbox + 1), np.ones(nbbox + 1)))
_lin = np.linspace(0, input_dset.RasterYSize, num=nbbox + 1)
lin = np.concatenate((_lin, _lin))
pixlin = np.vstack((pix, lin)).transpose()
xyz = np.array(transformer.TransformPoints(0, pixlin)[0])
bboxes = []
for ibbox in range(nbbox):
x = xyz[[ibbox, ibbox + 1, ibbox + nbbox + 1, ibbox + nbbox + 2], 0]
y = xyz[[ibbox, ibbox + 1, ibbox + nbbox + 1, ibbox + nbbox + 2], 1]
if max_extent is None:
bbox = [x.min(), y.min(), x.max(), y.max()]
bboxes.append(bbox)
else:
bbox = [
max([x.min(), max_extent[0]]),
max([y.min(), max_extent[1]]),
min([x.max(), max_extent[2]]),
min([y.max(), max_extent[3]])
]
if bbox[0] <= bbox[2] and bbox[1] <= bbox[3]:
bboxes.append(bbox)
# CHECK
# import matplotlib.pyplot as plt
# plt.plot(xyz[:, 0], xyz[:, 1], '+r')
# for b in bboxes:
# plt.plot([b[0], b[0], b[2], b[2], b[0]],
# [b[1], b[3], b[3], b[1], b[1]], '-b')
# if max_extent is not None:
# e = max_extent
# plt.plot([e[0], e[0], e[2], e[2], e[0]],
# [e[1], e[3], e[3], e[1], e[1]], '-g')
# plt.show()
# import pdb ; pdb.set_trace()
# \CHECK
return bboxes
def transformer_8():
if not gdaltest.have_ng:
return 'skip'
ds = gdal.Open('data/rpc.vrt')
# (long,lat)=(125.64828521533849 39.869345204440144) -> (Easting,Northing)=(213324.662167036 4418634.47813677) in EPSG:32652
ds_dem = gdal.GetDriverByName('GTiff').Create('/vsimem/dem.tif', 100, 100,
1, gdal.GDT_Int16)
sr = osr.SpatialReference()
sr.ImportFromEPSG(32652)
ds_dem.SetProjection(sr.ExportToWkt())
ds_dem.SetGeoTransform([213300, 1, 0, 4418700, 0, -1])
ds_dem.GetRasterBand(1).SetNoDataValue(-32768)
ds_dem.GetRasterBand(1).Fill(-32768)
ds_dem = None
for method in ['near', 'bilinear', 'cubic']:
tr = gdal.Transformer(ds, None, [
'METHOD=RPC', 'RPC_DEM=/vsimem/dem.tif',
'RPC_DEMINTERPOLATION=%s' % method
])
(success, pnt) = tr.TransformPoint(0, 20, 10, 0)
if success:
print(success, pnt)
gdaltest.post_reason('got wrong forward transform result.')
return 'fail'
(success, pnt) = tr.TransformPoint(1, 125.64828521533849,
39.869345204440144, 0)
if success:
print(success, pnt)
gdaltest.post_reason('got wrong reverse transform result.')
return 'fail'
gdal.Unlink('/vsimem/dem.tif')
return 'success'
def tps_1():
drv = gdal.GetDriverByName('MEM')
ds = drv.Create('foo', 2, 2)
gcp_list = [
gdal.GCP(0, 0, 0, 0, 0),
gdal.GCP(0, 50, 0, 0, 50),
gdal.GCP(50, 0, 0, 50, 0),
gdal.GCP(50, 50, 0, 50, 50),
gdal.GCP(0 * 25, 0 * 25, 0, 25, 25),
]
ds.SetGCPs(gcp_list, osr.GetUserInputAsWKT('WGS84'))
utm_wkt = osr.GetUserInputAsWKT('+proj=utm +zone=11 +datum=WGS84')
transformer = gdal.Transformer(ds, None,
['DST_SRS=' + utm_wkt, 'METHOD=GCP_TPS'])
if transformer is None or gdal.GetLastErrorType() == 0:
return 'fail'
return 'success'
def test_transformgeoloc_1():
try:
import numpy
except ImportError:
pytest.skip()
# Setup 2x2 geolocation arrays in a memory dataset with lat/long values.
drv = gdal.GetDriverByName('MEM')
geoloc_ds = drv.Create('geoloc_1', 2, 2, 3, gdal.GDT_Float64)
lon_array = numpy.asarray([[-117.0, -116.0], [-116.5, -115.5]])
lat_array = numpy.asarray([[45.0, 45.5], [44.0, 44.5]])
geoloc_ds.GetRasterBand(1).WriteArray(lon_array)
geoloc_ds.GetRasterBand(2).WriteArray(lat_array)
# Z left as default zero.
# Create a wgs84 to utm transformer.
wgs84_wkt = osr.GetUserInputAsWKT('WGS84')
utm_wkt = osr.GetUserInputAsWKT('+proj=utm +zone=11 +datum=WGS84')
ll_utm_transformer = gdal.Transformer(
None, None, ['SRC_SRS=' + wgs84_wkt, 'DST_SRS=' + utm_wkt])
# transform the geoloc dataset in place.
status = ll_utm_transformer.TransformGeolocations(
geoloc_ds.GetRasterBand(1), geoloc_ds.GetRasterBand(2),
geoloc_ds.GetRasterBand(3))
assert status == 0
expected = numpy.asarray([[[500000., 578126.73752062],
[540087.07398217, 619246.88515195]],
[[4982950.40022655, 5038982.81207855],
[4871994.34702622, 4928503.38229753]],
[[0., 0.], [0., 0.]]])
assert numpy.allclose(geoloc_ds.ReadAsArray(), expected)
def test_transformer_13():
ds = gdal.GetDriverByName('MEM').Create('', 6600, 4400)
rpc = [
"HEIGHT_OFF=79.895358112544", "HEIGHT_SCALE=71.8479951519956",
"LAT_OFF=39.1839631741725", "LAT_SCALE=-0.0993355184710674",
"LINE_DEN_COEFF=1 8.18889582174233e-05 -0.000585027621468826 0.00141894885228522 -0.000585589558894143 2.26848970721562e-05 0.0004556101949561 -0.000807782279739336 -0.00042471862816941 -0.000569244978738162 1.48442578097541e-05 4.05131290592846e-05 2.84884306250279e-05 -5.18205692205965e-06 -6.313878273056e-07 1.53979251356426e-05 -7.18376115203249e-06 -6.17331013601745e-05 -7.21314704472095e-05 4.12297300238455e-06",
"LINE_NUM_COEFF=-0.00742236358913794 -1.34432796989641 1.14742235955483 -0.00419813954264328 -0.00234215180175534 -0.00624463816085957 0.00678228413157904 0.0020362389986917 -0.00187712244349171 -8.03499198655765e-08 -0.00058862905508099 -0.00738644673656152 -0.00769111767189179 0.00076485216017804 0.00714033152180546 0.00597946564795612 -0.000632882594479344 -0.000167672086277102 0.00055226160003967 1.01784884515205e-06",
"LINE_OFF=2199.71134437189", "LINE_SCALE=2197.27163235171",
"LONG_OFF=-108.129788954851", "LONG_SCALE=0.135395601856691",
"SAMP_DEN_COEFF=1 -0.000817668457487893 -0.00151956231901818 0.00117149108953055 0.000514723430775277 0.000357856819755055 0.000655430235824068 -0.00100177312999255 -0.000488725013873637 -0.000500795084518271 -3.31511569640467e-06 4.60608554396048e-05 4.71371559254521e-05 -3.47487113243818e-06 1.0984752288197e-05 1.6421626141648e-05 -6.2866141729034e-06 -6.32966599886646e-05 -7.06552514786235e-05 3.89288575686084e-06",
"SAMP_NUM_COEFF=0.00547379112608157 0.807100297014362 0.845388298829057 0.01082483811889 -0.00320368761068744 0.00357867636379949 0.00459377712275926 -0.00324853865239341 -0.00218177030092682 2.99823054607907e-05 0.000946829367823539 0.00428577519330827 0.0045745876325088 -0.000396201144848935 0.00488772258958395 0.00435309486883759 -0.000402737234433541 0.000402935809278189 0.000642374929382851 -5.26793321752838e-06",
"SAMP_OFF=3299.3111821927", "SAMP_SCALE=3297.19448149873"
]
ds.SetMetadata(rpc, 'RPC')
tr = gdal.Transformer(
ds, None, ['METHOD=RPC', 'RPC_DEM=data/transformer_13_dem.tif'])
(success, pnt) = tr.TransformPoint(0, 6600, 24)
assert success and abs(pnt[0] - -108.00066000065341) <= 1e-7 and abs(
pnt[1] - 39.157694013439489) <= 1e-7
def get_trajectory_gcps(input_dset,
input_srs,
output_srs,
input_transformer=None):
"""
(for trajectory tiles) Get/Compute useful GCPs variables in order to set later
the appropriate trajectory width.
"""
# Read input GCPs and set GCPs transformer
gcps = input_dset.GetGCPs()
if input_transformer is None:
input_transformer = gdal.Transformer(input_dset, None,
['MAX_GCP_ORDER=-1'])
# Get/Compute useful GCPs variables.
gcppixel = np.array([gcp.GCPPixel for gcp in gcps])
gcpline = np.array([gcp.GCPLine for gcp in gcps])
pix = np.zeros((gcppixel.size, 3)) + 0.5
lin = gcpline[:, np.newaxis] + np.array([-0.5, 0., 0.5])[np.newaxis, :]
pixlin = np.vstack((pix.flatten(), lin.flatten())).transpose()
inpxyz = input_transformer.TransformPoints(0, pixlin)[0]
if input_srs.IsSame(output_srs):
outxyz = np.array(inpxyz)
else:
proj_transformer = osr.CoordinateTransformation(input_srs, output_srs)
outxyz = np.array(proj_transformer.TransformPoints(inpxyz))
outx = outxyz[:, 0].reshape(pix.shape)
outy = outxyz[:, 1].reshape(pix.shape)
gcpmiddir = np.arctan2(outy[:, 2] - outy[:, 0], outx[:, 2] - outx[:, 0])
gcpmidx = outx[:, 1]
gcpmidy = outy[:, 1]
return {
'gcppixel': gcppixel,
'gcpline': gcpline,
'gcpmiddir': gcpmiddir,
'gcpmidx': gcpmidx,
'gcpmidy': gcpmidy,
'srs': output_srs
}
def radarGeometryTransformer(latfile, lonfile, epsg=4326):
'''
Create a coordinate transformer to convert map coordinates to radar image line/pixels.
'''
driver = gdal.GetDriverByName('VRT')
inds = gdal.OpenShared(latfile, gdal.GA_ReadOnly)
tempds = driver.Create('', inds.RasterXSize, inds.RasterYSize, 0)
inds = None
tempds.SetMetadata({'SRS' : 'EPSG:{0}'.format(epsg),
'X_DATASET': lonfile,
'X_BAND' : '1',
'Y_DATASET': latfile,
'Y_BAND' : '1',
'PIXEL_OFFSET' : '0',
'LINE_OFFSET' : '0',
'PIXEL_STEP' : '1',
'LINE_STEP' : '1'}, 'GEOLOCATION')
trans = gdal.Transformer( tempds, None, ['METHOD=GEOLOC_ARRAY'])
return trans
def get_trajectory_mean_resolution(input_dset,
input_srs,
input_transformer=None):
"""
(for trajectory tiles) Compute trajectory mean resolution in meters.
"""
if input_transformer is None:
input_transformer = gdal.Transformer(input_dset, None,
['MAX_GCP_ORDER=-1'])
pix = np.zeros(input_dset.RasterYSize + 1) + 0.5
lin = np.arange(input_dset.RasterYSize + 1)
pixlin = np.vstack((pix, lin)).transpose()
inpxyz = input_transformer.TransformPoints(0, pixlin)[0]
srs4326 = osr.SpatialReference()
srs4326.ImportFromEPSG(4326)
if input_srs.IsSame(srs4326):
lonlat = np.array(inpxyz)
else:
proj_tf = osr.CoordinateTransformation(input_srs, srs4326)
lonlat = np.array(proj_tf.TransformPoints(inpxyz))
geod = pyproj.Geod(ellps='WGS84')
_, _, dist = geod.inv(lonlat[:-1, 0], lonlat[:-1, 1], lonlat[1:, 0],
lonlat[1:, 1])
return dist.mean()
def get_trajectory_output_resolutions(input_dset,
input_srs,
output_srs,
input_transformer=None):
"""
(for trajectory tiles) Compute trajectory resolution in output projection for
each point of trajectory.
"""
if input_transformer is None:
input_transformer = gdal.Transformer(input_dset, None,
['MAX_GCP_ORDER=-1'])
proj_tf = osr.CoordinateTransformation(input_srs, output_srs)
pix = np.zeros(input_dset.RasterYSize + 1) + 0.5
lin = np.arange(input_dset.RasterYSize + 1)
pixlin = np.vstack((pix, lin)).transpose()
inpxyz = input_transformer.TransformPoints(0, pixlin)[0]
if input_srs.IsSame(output_srs):
outxyz = np.array(inpxyz)
else:
proj_tf = osr.CoordinateTransformation(input_srs, output_srs)
outxyz = np.array(proj_tf.TransformPoints(inpxyz))
resxy = np.sqrt((outxyz[1:, 0] - outxyz[:-1, 0]) ** 2. + \
(outxyz[1:, 1] - outxyz[:-1, 1]) ** 2.)
return resxy
def test_transformer_dem_overrride_srs():
ds = gdal.Open('data/rpc.vrt')
ds_dem = gdal.GetDriverByName('GTiff').Create('/vsimem/dem.tif', 100, 100,
1)
sr = osr.SpatialReference()
sr.ImportFromEPSG(32652)
ds_dem.SetProjection(sr.ExportToWkt())
ds_dem.SetGeoTransform([213300, 200, 0, 4418700, 0, -200])
ds_dem.GetRasterBand(1).Fill(15)
ds_dem = None
tr = gdal.Transformer(ds, None, [
'METHOD=RPC', 'RPC_HEIGHT_SCALE=2', 'RPC_DEM=/vsimem/dem.tif',
'RPC_DEM_SRS=EPSG:32652+5773'
])
(success, pnt) = tr.TransformPoint(0, 0.5, 0.5, 0)
assert success and pnt[0] == pytest.approx(125.64813723085801, abs=0.000001) and pnt[1] == pytest.approx(39.869345977927146, abs=0.000001), \
'got wrong forward transform result.'
(success, pnt) = tr.TransformPoint(1, pnt[0], pnt[1], pnt[2])
assert success and pnt[0] == pytest.approx(0.5, abs=0.05) and pnt[1] == pytest.approx(0.5, abs=0.05), \
'got wrong reverse transform result.'
gdal.Unlink('/vsimem/dem.tif')
