def check(file_name, i, j, cd_gt, cd_cs):
sd = gdal.Open(file_name)
sd_gt = sd.GetGeoTransform()
sd_cs = osr.SpatialReference()
sd_cs.ImportFromWkt(sd.GetProjectionRef())
sd_ncols = sd.RasterXSize
sd_nrows = sd.RasterYSize
s = [
Convert(l, cd_gt, cd_cs, sd_gt, sd_cs)
for l in [(i, j), (i + 1, j), (i + 1, j + 1), (i, j + 1)]
]
lat = (min([i[0] for i in s]), max([i[0] for i in s]))
lon = (min([i[1] for i in s]), max([i[1] for i in s]))
total_band_value = np.array([0, 0, 0, 0, 0])
n = 0
for i in range(lat[0], lat[1] + 1):
for j in range(lon[0], lon[1] + 1):
if i >= 0 and i < sd_ncols and j >= 0 and j < sd_nrows:
band_value = gdal_array.DatasetReadAsArray(sd, i, j, 1,
1)[:, 0, 0]
if (band_value != np.array([0, 0, 0, 0, 0])).any():
total_band_value = total_band_value + band_value
n = n + 1
if n == 0:
return total_band_value
else:
return total_band_value / n
def each_file_checker(file, i, j, sdb):
sdb_gt = sdb.GetGeoTransform()
sdb_cs = osr.SpatialReference()
sdb_cs.ImportFromWkt(sdb.GetProjectionRef())
sd = gdal.Open(file)
sd_gt = sd.GetGeoTransform()
sd_cs = osr.SpatialReference()
sd_cs.ImportFromWkt(sd.GetProjectionRef())
sd_ncols = sd.RasterXSize
sd_nrows = sd.RasterYSize
l = [(i, j), (i + 1, j), (i + 1, j + 1), (i, j + 1)] #sdb_gt, sdb_cs
s = [
calculate(Convert(ton, old_gt=sdb_gt, old_cs=sdb_cs, new_cs=sd_cs),
sd_gt) for ton in l
] #sd_cs, #sd_gt
lat = (min([I[0] for I in s]), max([I[0] for I in s]))
lon = (min([I[1] for I in s]), max([I[1] for I in s]))
area = 0.0
total_band_values = np.array([0, 0, 0, 0, 0])
for q in range(lat[0], lat[1] + 1):
for w in range(lon[0], lon[1] + 1):
x = (q, w) #sd_cs, sd_gt
if q >= 0 and q < sd_ncols and w >= 0 and w < sd_nrows:
band_value = gdal_array.DatasetReadAsArray(sd, q, w, 1,
1)[:, 0, 0]
area2 = common_area(x, l, sd_cs, sd_gt, sdb_gt, sdb_cs)
if area2 != 0.0 and (band_value == np.array([0, 0, 0, 0, 0
])).all():
return np.array([0, 0, 0, 0, 0])
area = area + area2
total_band_values = total_band_values + band_value * area2
if area != 0:
return total_band_values / area
else:
return np.array([0, 0, 0, 0, 0])
def getRasterInfo(rst):
g = gdal.Open(rst)
data = gdal_array.DatasetReadAsArray(g)
xnum = g.RasterXSize; ynum = g.RasterYSize
x_res = g.GetGeoTransform()[1]; y_res = g.GetGeoTransform()[5];
minX = g.GetGeoTransform()[0]; maxY = g.GetGeoTransform()[3];
maxX = minX + (x_res*xnum); minY = maxY + (y_res*ynum)
extent = [minX, minY, maxX, maxY]
return g,data, extent, round(x_res)
def generate_patch(input_dir:str,output_dir:str,patch_width:int,patch_height:int,x_off:int,y_off:int):
"""
input_dir: input image directory
output_dir: output image directory
patch_width: the width of the cliping image block (pixle)
patch_height: the height of the cliping image block (pixle)
x_off: the overlap on image x axis (pixle)
y_off: the overlap on image y axis (pixle)
"""
img_list=os.listdir(input_dir)
for img_name in tqdm(img_list,ascii=True):
img_path=input_dir+img_name
name_not_tif=img_name.split('.')[0]
img_array = gdal_array.DatasetReadAsArray(
gdal.Open(img_path, GA_ReadOnly))
dimension_img_array=len(img_array.shape)
if dimension_img_array==3:
(_,height, width) = img_array.shape
elif dimension_img_array==2:
(height, width) = img_array.shape
else:
print('The dimension of image is not right')
break
x_num=math.ceil((width-patch_width)/(patch_width-x_off))+1
y_num=math.ceil((height-patch_height)/(patch_height-y_off))+1
k=0
for i in range(y_num):
if i==y_num-1:
s_y=height-patch_height
else:
s_y=i*(patch_height-y_off)
for j in range(x_num):
if j==x_num-1:
s_x=width-patch_width
else:
s_x=j*(patch_width-x_off)
if dimension_img_array==3:
img_clip=img_array[:,s_y:s_y+patch_height,s_x:s_x+patch_width]
elif dimension_img_array==2:
img_clip=img_array[s_y:s_y+patch_height,s_x:s_x+patch_width]
filename=output_dir+name_not_tif+'_'+str(k)+'.tif'
driver = gdal.GetDriverByName("GTiff")
driver.CreateCopy(filename, gdal_array.OpenArray(img_clip, None))#, options=["COMPRESS=LZW", "PREDICTOR=2"])
k+=1
def read_tif(intif, type=np.float):
g = gdal.Open(intif)
a = gdal_array.DatasetReadAsArray(g).astype(type)
print("Read " + os.path.basename(intif))
if a.ndim == 2:
print("the shape of the tif are: " + str(a.shape[0]) + ', ' +
str(a.shape[1]))
else:
print("the shape of the tif are: " + str(a.shape[0]) + ', ' +
str(a.shape[1]) + ', ' + str(a.shape[2]))
return g, a
def imreproj(image_in, epsg_out, mode='nearest'):
"""
Reproject a raster in memory (without write on disk)
:param image_in: path of input raster
:param epsg_out: output epsg (int)
:param mode: interpolation mode ['nearest' (default), 'bicubic', 'average', 'bilinear', 'lanczos']
:return: reprojected raster in memory (RAM)
"""
mode_gdal = gdal.GRA_NearestNeighbour
if mode.lower() == 'average':
mode_gdal = gdal.GRA_Average
elif mode.lower() == 'bilinear':
mode_gdal = gdal.GRA_Bilinear
elif mode.lower() == 'bicubic':
mode_gdal = gdal.GRA_Cubic
elif mode.lower() == 'lanczos':
mode_gdal = gdal.GRA_Lanczos
# Read source dataset
im = gdal.Open(image_in)
proj, dim, tr = geoinfo(image_in)
epsg_in = int(osr.SpatialReference(wkt=proj).GetAttrValue('AUTHORITY', 1))
logging.warning(' Reprojection from epsg:{0:d} to epsg:{1:d}'.format(epsg_in, epsg_out))
# Manage transform
source = osr.SpatialReference()
source.ImportFromEPSG(epsg_in)
source.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
target = osr.SpatialReference()
target.ImportFromEPSG(epsg_out)
target.SetAxisMappingStrategy(osr.OAMS_TRADITIONAL_GIS_ORDER)
transform = osr.CoordinateTransformation(source, target)
ulx, uly, _ = transform.TransformPoint(tr[0], tr[3])
lrx, lry, _ = transform.TransformPoint(tr[0] + tr[1] * dim[0],
tr[3] + tr[5] * dim[1])
px2, _, _ = transform.TransformPoint(tr[0] + tr[1], tr[3])
res = abs(px2 - ulx)
# Reproj
out_dim = (int((lrx - ulx) / res), int((uly - lry) / res))
dest = gdal.GetDriverByName('MEM').Create('', out_dim[0], out_dim[1],
im.RasterCount, im.GetRasterBand(1).DataType)
out_tr = (ulx, res, tr[2], uly, tr[4], -res)
dest.SetGeoTransform(out_tr)
dest.SetProjection(target.ExportToWkt())
_ = gdal.ReprojectImage(im, dest, source.ExportToWkt(), target.ExportToWkt(), mode_gdal)
imr = gdal_array.DatasetReadAsArray(dest)
return imr, target.ExportToWkt(), out_dim, out_tr
def get_training_data_tif(image_path, training_tif_path):
image = gdal.Open(image_path)
training_tif = gdal.Open(training_tif_path)
shape_array = gdal_array.DatasetReadAsArray(training_tif)
# shape_array = training_tif.GetVirtualMemArray()
shape_array[shape_array == -2147483648] = 0
y, x, features = sp.find(shape_array)
training_data = np.empty((len(features), image.RasterCount))
image_array = image.GetVirtualMemArray()
for index in range(len(features)):
# pdb.set_trace()
training_data[index, :] = image_array[:, y[index], x[index]]
return training_data, features
def loadTile(continent, filename):
# Unzip it
zf = zipfile.ZipFile('data/' + continent + '/' + filename + ".hgt.zip")
for name in zf.namelist():
outfile = open('data/' + continent + '/' + name, 'wb')
outfile.write(zf.read(name))
outfile.flush()
outfile.close()
# Read it
srtm = gdal.Open('data/' + continent + '/' + filename + '.hgt')
# Clean up
os.remove('data/' + continent + '/' + filename + '.hgt')
return gdal_array.DatasetReadAsArray(srtm)
def Crop(i, j, sdb_gt, sdb_cs):
lis = os.listdir(main_folder + '/crop_data')
for crop_file in lis:
if crop_file[-4:] == '.tif':
cd = gdal.Open(main_folder + '/crop_data/' + crop_file)
cd_gt = cd.GetGeoTransform()
cd_cs = osr.SpatialReference()
cd_cs.ImportFromWkt(cd.GetProjectionRef())
q = Convert((i, j), old_gt=sdb_gt, old_cs=sdb_cs, new_cs=cd_cs)
ww = calculate(q, cd_gt)
#print(ww)
x = ww[0]
y = ww[1]
if x >= 0 and x < cd.RasterXSize and y >= 0 and y < cd.RasterYSize:
return int(gdal_array.DatasetReadAsArray(cd, x, y, 1, 1))
return 0
def reader(self, filename):
"""
read an asci file, store a numpy array containing all data
"""
dataset = gdal.Open(filename)
self.extent = dataset.GetGeoTransform()
self.ncols = dataset.RasterXSize #ncols
self.nrows = dataset.RasterYSize #nrows
# This extents are correct for shape files
# note for future, when reading shape files with shapelib
# In [43]: mask.extent
#Out[43]: (2.555355548813, 6.4083399774, 49.49721527098, 51.503826015)
#In [44]: r.bbox
#Out[44]: [2.5553558813, 49.49721527038, 6.4083399744, 51.503826015]
# the elements 2 and 3 of extent ans bbox are swapped!
self.xllcorner = self.extent[0]
self.xurcorner = self.xllcorner + self.ncols * self.cellsize
self.yurcorner = self.extent[
3] #self.yllcorner - self.nrows * self.cellsize
self.yllcorner = self.yurcorner - self.nrows * self.cellsize
self.data = gdal_array.DatasetReadAsArray(dataset)
def raster_to_ndarray(in_raster):
src_ds = gdal.Open(in_raster, GA_ReadOnly)
geotransform, projection, datatype, nodata = get_geo_info(src_ds)
array = gdal_array.DatasetReadAsArray(src_ds)
# Force nodata value to avoid divergent input nodata values
nodata_norm = s.NODATA_INT16
if datatype == gdal.GDT_Int16:
nodata_norm = s.NODATA_INT16
elif datatype == gdal.GDT_Float32:
nodata_norm = s.NODATA_FLOAT32
else:
logging.exception('Raster data type %s not implemented' % datatype)
array[array == nodata] = nodata_norm
array = np.ma.masked_values(array, nodata_norm)
# logging.info(array.data)
# logging.info(array.mask)
# logging.info(array.fill_value)
# logging.info(nodata_norm)
# logging.info(array.dtype)
src_ds = None
return array, geotransform, projection, nodata_norm
def load_img_file_as_array(img_path):
img_ds = gdal.Open(img_path)
img_array = gdal_array.DatasetReadAsArray(img_ds)
return img_array
def raster_to_array(raster_path):
raster = gdal.Open(raster_path, GA_ReadOnly)
array = gdal_array.DatasetReadAsArray(raster)
return array
import osgeo.ogr
import csv
# Where is your data?
dirpath = '/home/s1326314/RBGdata'
# get radar image
gRed = gdal.Open(dirpath +
'/PALSAR/N03E016_17_MOS_F02DAR/N03E016_17_sl_HV_F02DAR')
""" Crop shapefiles """
shapefiles_merg = sorted(glob.glob(dirpath + '/shpfiles_merged/*.shp'))
output = []
for shp in shapefiles_merg:
base = os.path.splitext(os.path.basename(shp))[0].replace(' ', '_')
crop_fname = dirpath + '/temp.tif'
os.system('gdalwarp -overwrite -cutline ' + shp.replace(' ', '\ ') +
' -crop_to_cutline ' + filename + ' ' + crop_fname)
g = gdal.Open(crop_fname)
data = gdal_array.DatasetReadAsArray(g)
mean = np.mean(data)
std = np.std(data)
output.append([base, mean, std]) #for each plot, save label, mean, std
print(output)
#export to csv
with open(dirpath + '/stats_radar_merged.csv', "w") as myfile:
writer = csv.writer(myfile, lineterminator='\n')
writer.writerow(('Plot', 'Mean', 'Std'))
writer.writerows(output)
myfile.close()
def gdal2tiles(src, tile_size=500, tile_id_y=None, tile_id_x=None):
""" Load a gdal file to local python instance
:param src: source gdal dataset
:param tile_size: Tile size
:param tile_id_y: Single tile ID for Y
:param tile_id_x: Single tile ID for X
"""
src_ds = gdal_import.src2ds(src)
xsize = src_ds.RasterXSize
ysize = src_ds.RasterYSize
bands = src_ds.RasterCount
nxtiles, nytiles = get_number_tiles(src_ds)
# Read raster as arrays
dtype = [
key for key, value in GdalReader().np2gdal.iteritems()
if value == src_ds.GetRasterBand(1).DataType
][0]
if tile_id_x and str(tile_id_x).isdigit() and tile_id_y and str(
tile_id_y).isdigit():
x_tile_range = [tile_id_x]
y_tile_range = [tile_id_y]
else:
x_tile_range = range(nxtiles + 1)
y_tile_range = range(nytiles + 1)
tiles = {}
for xtile in x_tile_range:
for ytile in y_tile_range:
# DatasetReadAsArray(ds, xoff=0, yoff=0, win_xsize=None, win_ysize=None)
if (tile_size * xtile + tile_size) < xsize and (tile_size * ytile +
tile_size) < ysize:
# arr_i = np.array(gdal_array.DatasetReadAsArray(src_ds, xoff=tile_size * xtile, yoff=tile_size * ytile,
# win_xsize=tile_size, win_ysize=tile_size)).astype(dtype)
arr_i = np.array(
gdal_array.DatasetReadAsArray(src_ds, tile_size * xtile,
tile_size * ytile, tile_size,
tile_size)).astype(dtype)
else:
win_xsize = min(tile_size, xsize - tile_size * xtile)
win_ysize = min(tile_size, ysize - tile_size * ytile)
if win_xsize < 0 or win_ysize < 0:
# Not square shape
continue
# arr_src = np.array(gdal_array.DatasetReadAsArray(src_ds, xoff=tile_size * xtile,
# yoff=tile_size * ytile, win_xsize=win_xsize, win_ysize=win_ysize)).astype(dtype)
arr_src = np.array(
gdal_array.DatasetReadAsArray(src_ds, tile_size * xtile,
tile_size * ytile, win_xsize,
win_ysize)).astype(dtype)
arr_i = np.zeros((bands, win_ysize, win_xsize), dtype=dtype)
arr_i[:, 0:arr_src.shape[1], 0:arr_src.shape[2]] = arr_src
# Create raster
# Geotransform
geotransform = src_ds.GetGeoTransform()
top_left_x = geotransform[0] + geotransform[
1] * tile_size * xtile + geotransform[2] * tile_size * ytile
top_left_y = geotransform[3] + geotransform[
5] * tile_size * ytile + geotransform[4] * tile_size * xtile
new_geotransform = [
top_left_x, geotransform[1], geotransform[2], top_left_y,
geotransform[4], geotransform[5]
]
projection = src_ds.GetProjection()
nodata = src_ds.GetRasterBand(1).GetNoDataValue()
name = src_ds.GetMetadataItem('FilePath')
tiles[str(xtile) + '_' + str(ytile)] = GdalReader().array2ds(
arr_i,
name + '_' + str(xtile) + '_' + str(ytile),
geotransform=new_geotransform,
projection=projection)
return tiles
#monthly time series
for month in range(1, 13):
f_VV = dirpath + '/radar/S1/montly_2016/VV/' + str(month) + '_VV.tif'
f_VH = dirpath + '/radar/S1/montly_2016/VH/' + str(month) + '_VH.tif'
for shp in shapefiles:
base = re.findall('\d+', shp) # get plot number
index = int(base[2])
crop_fname = dirpath + '/outputs/site1/radar/ALOS_PALSAR/temp.tif'
#get VH stats
os.system('gdalwarp -overwrite -cutline ' + shp.replace(' ', '\ ') +
' -crop_to_cutline ' + f_VH + ' ' + crop_fname)
gVH = gdal.Open(crop_fname)
data_VH = gdal_array.DatasetReadAsArray(gVH)
mean_VH = np.mean(data_VH)
std_VH = np.std(data_VH)
#get VV statsdA
os.system('gdalwarp -overwrite -cutline ' + shp.replace(' ', '\ ') +
' -crop_to_cutline ' + f_VV + ' ' + crop_fname)
gVV = gdal.Open(crop_fname)
data_VV = gdal_array.DatasetReadAsArray(gVV)
mean_VV = np.mean(data_VV)
std_VV = np.std(data_VV)
#get HV/HH stats (this ratio is not reported in db)
VH_VV = mean_VH / mean_VV
d_VH_VV = propagation(mean_VH, std_VH, mean_VV, std_VV, VH_VV)
if yr == '96':
yr = ("".join(('19', yr)))
else:
yr = ("".join(('20', yr)))
#crop shapefiles
for shp in shapefiles:
base = re.findall('\d+', shp) # get plot number
index = int(base[2])
crop_fname = dirpath + '/outputs/site1/radar/ALOS_PALSAR/temp.tif'
#get HV stats
os.system('gdalwarp -overwrite -cutline ' + shp.replace(' ', '\ ') +
' -crop_to_cutline ' + f_HV + ' ' + crop_fname)
gHV = gdal.Open(crop_fname)
data_HV = gdal_array.DatasetReadAsArray(gHV)
mean_HV = np.mean(data_HV)
std_HV = np.std(data_HV)
# filtHV = f.reject_outliers(data_HV) # remove outliers
# mean_HV = np.mean(filtHV)
# std_HV = np.std(filtHV)
#get HH stats
os.system('gdalwarp -overwrite -cutline ' + shp.replace(' ', '\ ') +
' -crop_to_cutline ' + f_HH + ' ' + crop_fname)
gHH = gdal.Open(crop_fname)
data_HH = gdal_array.DatasetReadAsArray(gHH)
mean_HH = np.mean(data_HH)
std_HH = np.std(data_HH)
#
last_stop = looped_till['last_stop']
pick_pixel = looped_till['pick_pixel']
linad = dicti['list of base month files']
except FileNotFoundError:
dicti = {}
data = {}
last_stop = 0
sss = 0
shuffle(linad)
for ss in range(sss, len(linad)):
fil = linad[ss]
if fil[-4:] == '.tif':
sdb = gdal.Open(main_folder + '/satdata/' + base_month + '/' + fil)
sdb_ncols = sdb.RasterXSize
sdb_nrows = sdb.RasterYSize
sdb_gt = sdb.GetGeoTransform()
sdb_cs = osr.SpatialReference()
sdb_cs.ImportFromWkt(sdb.GetProjectionRef())
sdb_data = gdal_array.DatasetReadAsArray(sdb, 0, 0, sdb_ncols,
sdb_nrows)
if ss != sss or last_stop == 0:
last_stop = 0
pick_pixel = [
(i, j) for i in range(sdb_ncols) for j in range(sdb_nrows)
if (sdb_data[:, j, i] != np.array([0, 0, 0, 0, 0])).any()
]
print('done creating pick_pixel')
for pra in range(last_stop, len(pick_pixel)):
data = check(pick_pixel[pra], ss, pra, pick_pixel, base_month,
linad, sdb, sdb_gt, sdb_cs, crops, data, fil)
exit()
def readTiff(intif, data_type=np.float32):
g = gdal.Open(intif)
s0 = gdal_array.DatasetReadAsArray(g).astype(data_type)
return g, s0
def poly_clip(raster, polygons, outuput):
"""Clip raster with polygons"""
src_ds = gdal_import.src2ds(raster)
poly_ds = ogr_import.src2ogr(polygons)
# 1.- Reproject vector geometry to same projection as raster
projection = src_ds.GetProjection()
poly_reprojected = ogr_utils.reproject(poly_ds,
wtk_projection=projection,
outname='polygons_reprojected')
poly_ds = ogr_import.src2ogr(poly_reprojected)
poly_lyr = poly_ds.GetLayer()
# Bound box (debbuging code)
# geom_type = poly_lyr.GetGeomType()
# outDataSource = ogrr.create_layer('bound_box', geom_type=geom_type, wkt_proj=projection, file_path=None)
# outLayer = outDataSource.GetLfpayer()
# outLayerDefn = outLayer.GetLayerDefn()
# outFeature = ogr.Feature(outLayerDefn)
# outFeature.SetGeometry(geom)
# outLayer.CreateFeature(outFeature)
# outFeature = None
# outDataSource = None
# 2.- Filter and extract features
# Get Raster Extent
nodata = src_ds.GetRasterBand(1).GetNoDataValue()
r_min_x, r_max_x, r_min_y, r_max_y = GdalReader().get_extent(src_ds)
wkt = 'POLYGON((' + ','.join([
' '.join([str(r_min_x), str(r_max_y)]), ' '.join([
str(r_min_x), str(r_min_y)
]), ' '.join([str(r_max_x), str(r_min_y)]), ' '.join([
str(r_max_x), str(r_max_y)
]), ' '.join([str(r_min_x), str(r_max_y)])
]) + '))'
geom = ogr.CreateGeometryFromWkt(wkt)
poly_lyr.SetSpatialFilter(geom)
mem_driver = ogr.GetDriverByName('MEMORY')
filtered_poly_ds = mem_driver.CreateDataSource('filered_polygons')
# Open the memory datasource with write access and copy content
mem_driver = ogr.GetDriverByName('MEMORY')
mem_driver.Open('filered_polygons', 1)
filtered_poly_ds.CopyLayer(poly_lyr, 'filered_polygons', ['OVERWRITE=YES'])
poly_lyr.SetSpatialFilter(None)
# Intersect geometries with boundary box
geom_type = poly_lyr.GetGeomType()
clipped_poly_ds = ogrr.create_layer('clipped_polygons',
geom_type=geom_type,
wkt_proj=projection,
file_path=None)
clipped_poly_lyr = clipped_poly_ds.GetLayer()
filtered_poly_lyr = filtered_poly_ds.GetLayer()
clipped_lyr_defn = clipped_poly_lyr.GetLayerDefn()
infeature = filtered_poly_lyr.GetNextFeature()
while infeature:
feat_geom = infeature.GetGeometryRef()
intersection_geom = feat_geom.Intersection(geom)
out_feature = ogr.Feature(clipped_lyr_defn)
out_feature.SetGeometry(intersection_geom)
clipped_poly_lyr.CreateFeature(out_feature)
out_feature = None
infeature = filtered_poly_lyr.GetNextFeature()
filtered_poly_lyr.ResetReading()
filtered_poly_lyr = None
# Bound box (debbuging code)
# geom_type = poly_lyr.GetGeomType()
# filtered_poly_ds = ogrr.create_layer('filered_polygons', geom_type=geom_type, wkt_proj=projection,
# file_path=None)
# Clip raster to layer extent
lyr = clipped_poly_lyr
extent = lyr.GetExtent()
# Convert the _vector extent to image pixel coordinates
geo_trans = src_ds.GetGeoTransform()
# projection = rds.GetProjection()
ul_x, ul_y = GdalReader().world2pixel(geo_trans, extent[0], extent[3])
lr_x, lr_y = GdalReader().world2pixel(geo_trans, extent[1], extent[2])
# Create a new geomatrix for the _raster
geo_trans = list(geo_trans)
geo_trans[0] = extent[0]
geo_trans[3] = extent[3]
# Get the new array to layer extent
rarray = gdal_array.DatasetReadAsArray(src_ds)
if len(rarray.shape) == 3:
clip = rarray[:, ul_y:lr_y, ul_x:lr_x]
elif len(rarray.shape) == 2:
clip = rarray[ul_y:lr_y, ul_x:lr_x]
else:
return logging.error('Error in array shape.')
new_array = clip_raster_array(vds=filtered_poly_ds,
raster_array=clip,
geotransform=geo_trans,
nodata=nodata)
return GdalReader().array2ds(src_array=np.array(new_array),
output=outuput,
geotransform=geo_trans,
projection=projection,
nodata=nodata)
124: 'DEVELOPED',
141: 'FOREST',
142: 'FOREST',
243: 'CABBAGE'
}
crop_data_files = ['./crop_data/' + i for i in os.listdir('./crop_data/')]
data = {}
t = 0
for ll in crop_data_files:
cd = gdal.Open(ll)
cd_ncols = cd.RasterXSize
cd_nrows = cd.RasterYSize
cd_gt = cd.GetGeoTransform()
cd_cs = osr.SpatialReference()
cd_cs.ImportFromWkt(cd.GetProjectionRef())
cd_data = gdal_array.DatasetReadAsArray(cd, 0, 0, cd_ncols, cd_nrows)
ncols = list(range(cd_ncols))
shuffle(ncols)
nrows = list(range(cd_nrows))
shuffle(nrows)
for i in ncols:
for j in nrows:
t = t + 1
crop_number = cd_data[j, i]
if crop_number in crops:
band_values = find_sat_data(i, j, cd_gt, cd_cs)
crop_name = crops[crop_number]
if len(band_values) != 0:
try:
data[crop_name].append(band_values)
except KeyError:
def ascii_to_array(in_ascii_path):
ascii = gdal.Open(in_ascii_path, GA_ReadOnly)
array = gdal_array.DatasetReadAsArray(ascii)
return array
#imports
from osgeo import gdal, gdal_array
import numpy as np
import math
import json
from geojson import LineString
dataset = gdal.Open('map', gdal.GA_ReadOnly)
if not dataset:
raise IOError('GDAL failed to open map')
srcArray = gdal_array.DatasetReadAsArray(
dataset).T # Must transpose so that can access [X,Y]
GT = dataset.GetGeoTransform()
cartPositions = {}
start = (-105.81171870231627, 40.42018594917153)
end = (-105.77877581119537, 40.372110495658944)
def GT2Transform(GT):
# GT is GDAL GeoTransform
# Put into Linear Algebra Notation for ease of manipulation
offset = np.matrix([[GT[0]], [GT[3]]])
Q = np.matrix([[GT[1], GT[2]], [GT[4], GT[5]]])
return offset, Q
offset, Q = GT2Transform(GT)
def pos2coord(pos):
# position should be tuple (X, Y)
#Get mask band and set the nodata value
maskBand = maskRaster.GetRasterBand(1)
maskBand.SetNoDataValue(nodatavalue)
# open the vector file and get the first layer
vector_ds = ogr.Open("transectLine_buffer.shp")
vectorLayer = vector_ds.GetLayer()
vectorLayer.SetAttributeFilter("Name = 'name1'")
# rasterize the mask layer. Because tif is raster, buffer is vector.
# we have to convert vector to raster.
# Otherwise we can not do the further computation.
gdal.RasterizeLayer(maskRaster, [1], vectorLayer, burn_values=[1])
maskPX = gdarr.DatasetReadAsArray(maskRaster, 0, 0, x, y)
tempPx13 = gdarr.DatasetReadAsArray(tempDataset13, 0, 0, x, y)
tempPx17 = gdarr.DatasetReadAsArray(tempDataset17, 0, 0, x, y)
# do the multiplication:
# membership value* mask = either store as 0 or store the membership value.
# output is an array
pxResult13 = numpy.multiply(maskPX, tempPx13)
pxResult17 = numpy.multiply(maskPX, tempPx17)
print("hey!")
# remove zeros from the array. convert array to a one dimentional list
pxResult13 = numpy.extract(pxResult13 > 0, pxResult13)
pxResult17 = numpy.extract(pxResult17 > 0, pxResult17)
