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)