def gdal_grid(self): u_polygon = ogr.CreateGeometryFromWkt(self.u_Wkt) v_polygon = ogr.CreateGeometryFromWkt(self.v_Wkt) print[ np.min(self.u_lon), np.min(self.u_lat), np.max(self.u_lon), np.max(self.u_lat) ] print[ np.min(self.u_lon), np.min(self.u_lat), np.max(self.u_lon), np.max(self.u_lat) ] ds_u = gdal.Grid("", u_polygon.ExportToJson(), \ width=self.options.gridWidth, height=self.options.gridHeight, outputType=gdal.GDT_Float32, outputSRS='EPSG:4326', outputBounds=[np.min(self.u_lon), np.min(self.u_lat), np.max(self.u_lon), np.max(self.u_lat)], \ format='MEM', algorithm='nearest', noData=self.options.inputNoData) cols_u = ds_u.RasterXSize # 获取文件的列数 rows_u = ds_u.RasterYSize # 获取文件的行数 currentBand_u = ds_u.GetRasterBand(1) current_data_u = currentBand_u.ReadAsArray(0, 0, cols_u, rows_u) current_geotransf_u = ds_u.GetGeoTransform() # 获取放射矩阵 (current_lat_u, current_lon_u) = self.createXY(current_geotransf_u, cols_u, rows_u) self.u_lon = current_lon_u self.u_lat = current_lat_u self.u_data = current_data_u[::-1] del ds_u # =============================== ds_v = gdal.Grid("", v_polygon.ExportToJson(), \ width=self.options.gridWidth, height=self.options.gridHeight, outputType=gdal.GDT_Float32, outputSRS='EPSG:4326', outputBounds=[np.min(self.u_lon), np.min(self.u_lat), np.max(self.u_lon), np.max(self.u_lat)], \ format='MEM', algorithm='nearest', noData=self.options.inputNoData) cols_v = ds_v.RasterXSize # 获取文件的列数 rows_v = ds_v.RasterYSize # 获取文件的行数 currentBand_v = ds_v.GetRasterBand(1) current_data_v = currentBand_v.ReadAsArray(0, 0, cols_v, rows_v) current_geotransf_v = ds_v.GetGeoTransform() # 获取放射矩阵 (current_lat_v, current_lon_v) = self.createXY(current_geotransf_v, cols_v, rows_v) self.v_lon = current_lon_v self.v_lat = current_lat_v self.v_data = current_data_v[::-1] del ds_v
def test_gdal_grid_lib_2(): shape_ds = ogr.Open('/vsimem/tmp', update=1) shape_lyr = shape_ds.CreateLayer('test_gdal_grid_lib_2') dst_feat = ogr.Feature(feature_def=shape_lyr.GetLayerDefn()) dst_feat.SetGeometry(ogr.CreateGeometryFromWkt('POINT(0 0 100)')) shape_lyr.CreateFeature(dst_feat) shape_ds = None for env_list in [[('GDAL_USE_AVX', 'NO'), ('GDAL_USE_SSE', 'NO')], [('GDAL_USE_AVX', 'NO')], []]: for (key, value) in env_list: gdal.SetConfigOption(key, value) # Point strictly on grid ds1 = gdal.Grid('', '/vsimem/tmp/test_gdal_grid_lib_2.shp', format='MEM', outputBounds=[-0.5, -0.5, 0.5, 0.5], width=1, height=1, outputType=gdal.GDT_Byte) ds2 = gdal.Grid('', '/vsimem/tmp/test_gdal_grid_lib_2.shp', format='MEM', outputBounds=[-0.4, -0.4, 0.6, 0.6], width=10, height=10, outputType=gdal.GDT_Byte) gdal.SetConfigOption('GDAL_USE_AVX', None) gdal.SetConfigOption('GDAL_USE_SSE', None) cs = ds1.GetRasterBand(1).Checksum() if cs != 2: gdaltest.post_reason('fail') print(cs) return 'fail' cs = ds2.GetRasterBand(1).Checksum() if cs != 1064: gdaltest.post_reason('fail') print(cs) return 'fail' return 'success'
def get(self, factor_name, start_time): start_time = int2str(start_time) stations = select_data_to_geojson(factor_name, start_time) if os.path.exists('./Image_data//{factor}//{time}.png'.format( factor=factor_name, time=start_time.replace(':', '_'))): return "This time factor interpolation picture already exists" json_file = './geojson_data//{factor}//{time}.json'.format( factor=factor_name, time=start_time.replace(':', '_')) tif_file = './tif_data//{factor}//{time}.tif'.format( factor=factor_name, time=start_time.replace(':', '_')) write_content(json_file, stations, 'json') print("写入geojson中...") dataset = gdal.OpenEx(json_file) grid_opt = grid_option( factor_name, 'd', ) print("插值中...") gdal.Grid(tif_file, dataset, options=grid_opt) # 出图 print("生成图片中...") img = Image.open('./state.png') tif = Image.open(tif_file) export_png(img, factor_name, tif, 'd', img_name='{factor}//{time}'.format(factor=factor_name, time=start_time.replace( ':', '_'))) print("出图成功!") return "The image is generated successfully. Please check the corresponding file"
def test_gdal_grid_lib_3(): wkt = 'POLYGON ((37.3495241627097 55.6901648563184 187.680953979492,37.349543273449 55.6901565410051 187.714370727539,37.3495794832707 55.6901531392856 187.67333984375,37.3496210575104 55.6901595647556 187.6396484375,37.3496398329735 55.6901716597552 187.596603393555,37.3496726900339 55.6901780852222 187.681350708008,37.3496793955565 55.6901829988139 187.933898925781,37.3496921360493 55.6901860225623 187.934280395508,37.3497162759304 55.6902037870796 187.435394287109,37.3497484624386 55.6902094566047 187.515319824219,37.3497618734837 55.6902241973661 190.329940795898,37.3497511446476 55.690238560154 190.345748901367,37.3497404158115 55.6902567026153 190.439697265625,37.3497142642736 55.6902650179072 189.086044311523,37.349688783288 55.6902608602615 187.763305664062,37.3496626317501 55.6902468754498 187.53678894043,37.3496378213167 55.6902412059301 187.598648071289,37.3496103286743 55.6902400720261 187.806274414062,37.3495902121067 55.6902313787607 187.759521484375,37.3495734483004 55.6902177719067 187.578125,37.349532879889 55.6902035980954 187.56965637207,37.3495161160827 55.6901939599008 187.541793823242,37.3495187982917 55.6901754394418 187.610427856445,37.3495241627097 55.6901648563184 187.680953979492))' polygon = ogr.CreateGeometryFromWkt(wkt) gdal.Grid('', polygon.ExportToJson(), \ width=115, height=93, outputBounds=[37.3495161160827, 55.6901531392856, 37.3497618734837, 55.6902650179072], \ format='MEM', algorithm='linear') return 'success'
def interpolate(): print(power_option) print(smoothing_option) #power_option = str(power_option) #smoothing_option = str(smoothing_option) algorithm_option = 'invdist:power='+str(power_option)+':smoothing='+str(smoothing_option) gridOptions = gdal.GridOptions(format='Gtiff', algorithm=algorithm_option, zfield="nitr_ran") out = gdal.Grid(outputTest, wellNitrate, options=gridOptions) out = None del out
def test_gdal_grid_lib_1(): # Create an OGR grid from the values of n43.dt0 ds = gdal.Open('../gdrivers/data/n43.dt0') geotransform = ds.GetGeoTransform() shape_drv = ogr.GetDriverByName('ESRI Shapefile') shape_ds = shape_drv.CreateDataSource('/vsimem/tmp') shape_lyr = shape_ds.CreateLayer('n43') data = ds.ReadRaster(0, 0, 121, 121) array_val = struct.unpack('h' * 121 * 121, data) for j in range(121): for i in range(121): wkt = 'POINT(%f %f %s)' % ( geotransform[0] + (i + .5) * geotransform[1], geotransform[3] + (j + .5) * geotransform[5], array_val[j * 121 + i]) dst_feat = ogr.Feature(feature_def=shape_lyr.GetLayerDefn()) dst_feat.SetGeometry(ogr.CreateGeometryFromWkt(wkt)) shape_lyr.CreateFeature(dst_feat) shape_ds.ExecuteSQL('CREATE SPATIAL INDEX ON n43') shape_ds = None spatFilter = None if ogrtest.have_geos(): spatFilter = [-180, -90, 180, 90] # Create a GDAL dataset from the previous generated OGR grid ds2 = gdal.Grid( '', '/vsimem/tmp/n43.shp', format='MEM', outputBounds=[-80.0041667, 42.9958333, -78.9958333, 44.0041667], width=121, height=121, outputType=gdal.GDT_Int16, algorithm='nearest:radius1=0.0:radius2=0.0:angle=0.0', spatFilter=spatFilter) # We should get the same values as in n43.td0 if ds.GetRasterBand(1).Checksum() != ds2.GetRasterBand(1).Checksum(): print( 'bad checksum : got %d, expected %d' % (ds.GetRasterBand(1).Checksum(), ds2.GetRasterBand(1).Checksum())) return 'fail' if ds2.GetRasterBand(1).GetNoDataValue() is not None: print('did not expect nodata value') return 'fail' ds = None ds2 = None return 'success'
def gdal_interpolate_to_regular_grid(values, x_in, y_in, x_out, y_out): """Linear-interpolate irregularly-spaced values to regular grid. Uses `gdal.Grid` for linear interpolation. NOTE: as of 9/2019, this GDAL interpolation is not working, seemingly because of a bug with swig: https://github.com/OSGeo/gdal/issues/1677 Args: values: `tuple` or `list` of `numpy.ma.masked_array`s containing values to be interpolated to the output grid. x_in: `numpy.ndarray` containing x-position of each input value. Length of this array must match the length of each array in `values`. y_in: `numpy.ndarray` containing y-position of each input value. Length of this array must match the length of each array in `values`. x_out: `numpy.ndarray` containing x-positions of output grid columns. y_out: `numpy.ndarray` containing y-positions of output grid rows. Returns: A `tuple` containing the interpolated values for each input array, corresponding with the order specified in `values`. """ srs = osr.SpatialReference() srs.SetWellKnownGeogCS('WGS84') ds = gdal.GetDriverByName('Memory').Create('', 0, 0, 0, gdal.GDT_Float32) layer = ds.CreateLayer('irregular_points', srs=srs, geom_type=ogr.wkbPoint) def field_name(x): return 'field_{}'.format(x) for n in range(len(values)): layer.CreateField(ogr.FieldDefn(field_name(n + 1), ogr.OFTReal)) for i in range(len(x_in)): point = ogr.Geometry(ogr.wkbPoint) point.AddPoint(x_in[i], y_in[i]) feature = ogr.Feature(layer.GetLayerDefn()) feature.SetGeometry(point) for n in range(len(values)): layer.SetField(field_name(n + 1), values[n][i]) layer.CreateFeature(feature) calc_values = [] for n in range(len(values)): calc_values.append( gdal.Grid('.tif'.format(field_name(n + 1)), ds, format='MEM', width=len(x_out), height=len(y_out), algorithm='linear:nodata=0.0', zfield=field_name(n + 1)).ReadAsArray()) return tuple(calc_values)
def createGrid(inputNCPath, outputTifPath, algorithm='invdist'): #output = gdal.Grid(outputTifPath,inputNCPath,algorithm=algorithm) output = gdal.Grid( outputTifPath, inputNCPath, algorithm= 'invdist:power=2.0:smoothing=0.0:radius1=2000.0:radius2=4000.0:angle=0.0:max_points=500:min_points=1:nodata=0.0', format="NetCDF", width=50, height=50) output.FlushCache() return outputTifPath
def gdal_grid(self): polygon = ogr.CreateGeometryFromWkt(self.myWkt) grid_data = gdal.Grid('', polygon.ExportToJson(), \ width=self.pCols, height=self.pRows, outputType=gdal.GDT_Float32, outputSRS='EPSG:4326', outputBounds=[self.lon0, self.lat0, self.lon1, self.lat1], noData=0.0, \ # format='MEM', algorithm='invdist') # format='MEM', algorithm='nearest') format='MEM', algorithm='invdistnn') # format='GTiff', algorithm='linear') self.grid_data = grid_data
def invdistnn(in_path, out_path, field_name, output_bounds=None, param=None): """ 最邻近反距离加权插值 将shp文件插值为TIF :param in_path: 输入的shp文件 :param out_path: 输出的tif文件 :param field_name: 被插值的属性字段 :param output_bounds: 输出的tif四角范围 (xmin, ymin, xmax, ymax) :param param: 插值参数,字符串,不传参以默认值进行 [power:加权系数(默认为3.0) smoothing:平滑参数(默认为0.0) radius:搜索圆的半径,不应为零(默认值为1.0) max_points:要使用的最大数据点数。搜索的点数不要超过此数字。 加权时,发现的点将从最远到最远的距离排名(默认值为12) min_points:要使用的最小数据点数。如果发现的点数量较少,则网格节点被认为是空的,并将被NODATA标记填充(默认值为0) nodata:NODATA标记以填充空白点(默认为0.0)] :return: """ # TODO 是否为密集点时比较试用? # TODO radius设置太小会导致数据镂空 if param: if len(param) != 6 or not all(isinstance(x, str) for x in param): print('input param format error.') return else: param_str = 'invdistnn' param_str += ':power=' + param[0] param_str += ':smoothing=' + param[1] param_str += ':radius=' + param[2] param_str += ':max_points=' + param[3] param_str += ':min_points=' + param[4] param_str += ':nodata=' + param[5] else: param = 'invdistnn:power=3.0:smoothing=0.0:radius=1.0:max_points=0:min_points=0:nodata=0.0' if output_bounds: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name, outputBounds=output_bounds) else: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name) gdal.Grid(destName=out_path, srcDS=in_path, options=options)
def invdist(in_path, out_path, field_name, output_bounds=None, param=None): """ 反距离加权插值 将shp文件插值为TIF :param in_path: 输入shp文件 :param out_path: 输出tif文件 :param field_name: 被插值的属性字段 :param output_bounds: 输出tif四角范围 (xmin, ymin, xmax, ymax) 默认为点shp四角坐标 :param param: 插值参数,字符串,不传参以默认值进行 [ power:加权系数(默认为3.0), smoothing:平滑参数(默认为0.0), radius1:搜索椭圆的第一个半径(如果旋转角度为0,则为X轴),将此参数设置为零以使用整个点数组(默认值为0.0), radius2:搜索椭圆的第二个半径(如果旋转角度为0,则为Y轴),将此参数设置为零以使用整个点数组(默认值为0.0), angle:搜索椭圆的旋转角度,以度为单位(逆时针,默认为0.0), max_points:要使用的最大数据点数。搜索的点数不要超过此数字。仅在设置搜索椭圆(两个半径都不为零)时使用。零表示应使用所有找到的点(默认值为0), min_points:要使用的最小数据点数。如果发现的点数量较少,则网格节点被认为是空的,并将被NODATA标记填充。仅在设置搜索椭圆(两个半径都不为零)时使用(默认值为0), nodata:NODATA标记以填充空白点(默认为0.0)] :return: """ if param: if len(param) != 8 or not all(isinstance(x, str) for x in param): print('input param format error.') return else: param_str = 'invdist' param_str += ':power=' + param[0] param_str += ':smoothing=' + param[1] param_str += ':radius1=' + param[2] param_str += ':radius2=' + param[3] param_str += ':angle=' + param[4] param_str += ':max_points=' + param[5] param_str += ':min_points=' + param[6] param_str += ':nodata=' + param[7] else: param_str = 'invdist:power=3.0:smoothing=0.0:radius1=0.0:radius2=0.0:angle=0.0:max_points=0:min_points=0:nodata=0.0' if output_bounds: options = gdal.GridOptions(algorithm=param_str, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name, outputBounds=output_bounds) else: options = gdal.GridOptions(algorithm=param_str, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name) gdal.Grid(destName=out_path, srcDS=in_path, options=options)
def convertCsv2Tif(inputPath, outputPath, inputFilename, vrtTemplateString): """ Convert CSV to GeoTIFF using gdal.Grid. Output will be written to <outputPath>/<inputFilename>.tif CSV is decribed by the template given as parameter. The following tokens are replaced: - $NAME$ by inputFilename without extension - $FILENAME$ by inputFilename - $PATH$ by the absolute inputPath :param inputPath: path to input CSV :param outputPath: path to where the output GeoTIFF is written :param inputFilename: filename (without path!) of input CSV :param vrtTemplateString: template string for VRT file """ # make input and output path absolute in case it is not already fullInputPath = os.path.abspath(inputPath) fullOutputPath = os.path.abspath(outputPath) fullVrtFilename = fullOutputPath + "/" + inputFilename + ".vrt" logging.info("Opening '{}' for writing...".format(fullVrtFilename)) with open(fullVrtFilename, "w+") as currentVrtFile: logging.info("writing template to: {}".format(fullVrtFilename)) currentVrtString = vrtTemplateString \ .replace("$NAME$", os.path.splitext(inputFilename)[0]) \ .replace("$FILENAME$", inputFilename) \ .replace("$PATH$", fullInputPath) currentVrtFile.write(currentVrtString) logging.info("Closing: {}".format(fullVrtFilename)) currentVrtFile.flush() del currentVrtFile logging.info("Converting CSV to TIF") gdal.Grid( srcDS=fullVrtFilename, destName=fullOutputPath + "/" + inputFilename + ".tif" # as GDAL will interpolate between the points of the CSV, here we make sure, that no values are created, # that has not been in the original CSV file. , algorithm="nearest:radius1=0.0:radius2=0.0:angle=0.0:nodata=9999.0") os.remove(fullVrtFilename) logging.info("done")
def average(in_path, out_path, field_name, output_bounds=None, param=None): """ 移动平均法 将shp文件插值为TIF :param in_path: 输入的shp文件 :param out_path: 输出的tif文件 :param field_name: 被插值的属性字段 :param output_bounds: 输出的tif四角范围 (xmin, ymin, xmax, ymax) :param param: 插值参数,字符串,不传参以默认值进行 [ radius1:搜索椭圆的第一个半径(如果旋转角度为0,则为X轴)。将此参数设置为零以使用整个点数组(默认值为0.0) radius2:搜索椭圆的第二个半径(如果旋转角度为0,则为Y轴)。将此参数设置为零以使用整个点数组(默认值为0.0) angle:搜索椭圆的旋转角度,以度为单位(逆时针,默认为0.0) min_points:要使用的最小数据点数。 如果发现的点数量较少,则网格节点被认为是空的,并将被NODATA标记填充(默认值为0) nodata:NODATA标记以填充空白点(默认为0.0)] :return: """ # TODO 有问题?? if param: if len(param) != 5 or not all(isinstance(x, str) for x in param): print('input param format error.') return else: param_str = 'average' param_str += ':radius1=' + param[0] param_str += ':radius2=' + param[1] param_str += ':angle=' + param[2] param_str += ':min_points=' + param[3] param_str += ':nodata=' + param[4] else: param = 'average:radius1=1:radius2=1:angle=0.0:min_points=0:nodata=0.0' if output_bounds: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name, outputBounds=output_bounds) else: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name) gdal.Grid(destName=out_path, srcDS=in_path, options=options)
def gdal_grid(path): grid_opt = gdal.GridOptions( format='GTiff', outputType=gdal.GDT_Int16, algorithm= 'invdist:power=3.0:smothing=0.0:radius1=0.0:radius2=0.0:angle=0.0:max_points=0:min_points=0:nodata=0.0', layers='bugs', zfield='value', ) # Use .tiff and not .tif try: output = gdal.Grid('/tmp/output.tiff', path, options=grid_opt) status = True return status except: status = False return status
def nearest(in_path, out_path, field_name, output_bounds=None, param=None): """ 最邻近法 将shp文件插值为TIF :param in_path: 输入的shp文件 :param out_path: 输出的tif文件 :param field_name: 被插值的属性字段 :param output_bounds: 输出的tif四角范围 (xmin, ymin, xmax, ymax) :param param: 插值参数,字符串,不传参以默认值进行 [radius1:搜索椭圆的第一个半径(如果旋转角度为0,则为X轴)。将此参数设置为零以使用整个点数组(默认值为0.0) radius2:搜索椭圆的第二个半径(如果旋转角度为0,则为Y轴)。将此参数设置为零以使用整个点数组(默认值为0.0) angle:搜索椭圆的旋转角度,以度为单位(逆时针,默认为0.0) nodata:NODATA标记以填充空白点(默认为0.0)] :return: """ if param: if len(param) != 4 or not all(isinstance(x, str) for x in param): print('input param format error.') return else: param_str = 'nearest' param_str += ':radius1=' + param[0] param_str += ':radius2=' + param[1] param_str += ':angle=' + param[2] param_str += ':nodata=' + param[3] else: param = 'nearest:radius1=0.0:radius2=0.0:angle=0.0:nodata=0.0' if output_bounds: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name, outputBounds=output_bounds) else: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name) gdal.Grid(destName=out_path, srcDS=in_path, options=options)
def linear(in_path, out_path, field_name, output_bounds=None, param=None): """ 线性法 将shp文件插值为TIF :param in_path: 输入的shp文件 :param out_path: 输出的tif文件 :param field_name: 被插值的属性字段 :param output_bounds: 输出的tif四角范围 (xmin, ymin, xmax, ymax) :param param: 插值参数,字符串,不传参以默认值进行 [radius:如果要插入的点不适合Delaunay三角剖分的三角形,请使用该最大距离搜索最近的邻居,否则使用nodata 如果设置为-1,则搜索距离是无限的 如果设置为0,则将始终使用nodata值。默认值为-1 nodata:NODATA标记以填充空白点(默认为0.0)] :return: """ # TODO 外扩性不太好 if param: if len(param) != 2 or not all(isinstance(x, str) for x in param): print('input param format error.') return else: param_str = 'linear' param_str += ':radius=' + param[0] param_str += ':nodata=' + param[1] else: param = 'linear:radius=-1:nodata=0.0' if output_bounds: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name, outputBounds=output_bounds) else: options = gdal.GridOptions(algorithm=param, format="GTiff", outputType=gdal.GDT_Float32, zfield=field_name) gdal.Grid(destName=out_path, srcDS=in_path, options=options)
def grid_var(var_array, coordinates, grid_kwargs): """ A function for gridding a variable array in gdal :param var_array: a column array of the variable to grid :param coordinates: utm coordinate array :param grid_kwargs: keyword argument dictionary for gridding using gdal_grid :return: :param gridded: A gridded array with shape (height, width) :param geotransform: the gdal geotransform for the gridded array """ if len(var_array.shape) == 1: var_array = var_array.reshape([-1, 1]) if grid_kwargs['log_grid']: var_array = np.log10(var_array) temp_a = np.concatenate((coordinates, var_array), axis=1) # Output the points into a temporary csv temp_dir = r'C:\temp\tempfiles' # temp_dir = tempfile.gettempdir() # getting permissions error if not os.path.exists(temp_dir): os.mkdir(temp_dir) os.chdir(temp_dir) temp_file = 'pts2grid_temp.csv' with open(temp_file, 'w') as f: f.write('x,y,z\n') # Write the array np.savetxt(f, temp_a, delimiter=',') # Write vrt vrt_file = misc_utils.write_vrt_from_csv(temp_file, 'x', 'y', 'z') # Now grid using gdal_grid gridopt = gdal.GridOptions( format=grid_kwargs['format'], outputType=gdal.GDT_Float32, algorithm=grid_kwargs['gdal_algorithm'], width=grid_kwargs['width'], height=grid_kwargs['height'], outputSRS=grid_kwargs['outputSRS'], # "EPSG:28352" outputBounds=grid_kwargs['outputBounds'], zfield='z', layers=vrt_file.split('\\')[-1].split('.')[0]) # Getting errors frmo tempdir outfile = 'temp_grid.tif' print("Gridding ", outfile) out_ds = gdal.Grid(destName=outfile, srcDS=vrt_file, options=gridopt) print("Finished gridding ", outfile) geotransform = out_ds.GetGeoTransform() gridded = out_ds.ReadAsArray() # Currently the nulls are very annoyingly retunr zeros null = np.float(grid_kwargs['gdal_algorithm'].split('nodata=')[-1]) gridded[gridded == null] = np.nan if grid_kwargs['log_grid']: gridded = 10**gridded # Remove trash temp_a = None out_ds = None gc.collect() # Delete the temporary files for file in [temp_file, vrt_file, outfile]: try: os.remove(file) except PermissionError: print('Permission error. Unable to delete ', file) return gridded, geotransform
def rasterize_shapefiles(algorithm, short_side, test=False): """ Rasterize yield datasets with inbound algorithm. The generated image preserves the dimensions of the corresponding Block shape. The list of applicable algorithms can be found in http://www.gdal.org/gdal_grid.html. Args: algorithm: The algorithm with which to interpolate the data points. short_side: The length of the shorter side of the generated raster. test: Optional. Whether the function call is for testing or not. Default is False. """ print("Processing") start = time.time() shape_paths = [ os.path.join(data_settings.YIELD_SHAPES_DIR, f) for f in os.listdir(data_settings.YIELD_SHAPES_DIR) if '.shp' in f ] for i, shape_path in enumerate(shape_paths): start_grid = time.time() target_path = os.path.join(data_settings.YIELD_RASTERS_DIR, "grid_{:03d}.tif".format(i)) print("\tFrom\t{}\n\tTo\t{}".format(shape_path, target_path)) try: shape = ogr.Open(shape_path) layer_name = shape.GetLayer(0).GetName() x_min, x_max, y_min, y_max = shape.GetLayer(0).GetExtent() finally: shape = None x_to_y = (x_max - x_min) / (y_max - y_min) x_ratio = max(1, x_to_y) y_ratio = min(1, x_to_y) try: raster = gdal.Grid(destName=target_path, srcDS=shape_path, format='GTiff', noData=0.0, width=short_side * x_ratio, height=short_side / y_ratio, outputType=gdal.GDT_Float32, outputSRS='EPSG:4326', outputBounds=[x_min, y_max, x_max, y_min], zfield='Mass_Yield', layers=[layer_name], algorithm=algorithm) delta_grid = time.time() - start_grid print("\t\tDone in {:.0f} m {:.0f} s".format( delta_grid // 60, delta_grid % 60)) arr = raster.ReadAsArray() plt.rcParams['figure.figsize'] = 2, 2 plt.imshow(arr, cmap='gray', vmin=1500, vmax=15000) plt.axis('off') plt.show() finally: raster = None if test: break delta = time.time() - start print("Processing done in {:.0f} m {:.0f} s".format( delta // 60, delta % 60))
def processFile(job_data, file_data): try: #Set output filename tileName = file_data.fileName + ".tif" tile = os.path.join(dem_directory, tileName).replace("\\","/") csv_data = [] #Open source file and create a array representing csv data with open(file_data.filePath, 'r') as dmr_file: for l in dmr_file: if l != "": xyz_line = l.strip().split(job_data.sourceDel) csv_data.append("{xc},{yc},{h}\n".format(xc=xyz_line[0],yc=xyz_line[1],h=xyz_line[2])) #Check if last row is empty, and remove it if csv_data[len(csv_data) - 1] == "": csv_data.pop() #Check if last row ends with new line, trim row lastrow = csv_data[len(csv_data) - 1] if lastrow.endswith('\n'): lastrow = lastrow.rstrip() csv_data[len(csv_data) - 1] = lastrow csv_file = os.path.join(dem_directory, file_data.fileName + ".csv").replace("\\","/") if os.path.isfile(csv_file): os.remove(csv_file) #Write csv data to file with open(csv_file, 'w') as csf: csf.writelines(csv_data) #Create array representing lines in a vrt file vrtData = [] vrtData.append("<OGRVRTDataSource>\n") vrtData.append(' <OGRVRTLayer name="{name}">\n'.format(name=file_data.fileName)) vrtData.append(' <SrcDataSource>{csvfile}</SrcDataSource>\n'.format(csvfile=csv_file)) vrtData.append(' <GeometryType>wkbPoint25D</GeometryType>\n') vrtData.append(' <LayerSRS>{sepsg}</LayerSRS>\n'.format(sepsg=job_data.sourceEpsg)) vrtData.append(' <GeometryField encoding="PointFromColumns" x="field_1" y="field_2" z="field_3"/>\n') vrtData.append(' </OGRVRTLayer>\n') vrtData.append('</OGRVRTDataSource>') vrt_file = os.path.join(dem_directory, file_data.fileName + ".vrt").replace("\\","/") if os.path.isfile(vrt_file): os.remove(vrt_file) #Write vrt to file with open(vrt_file, 'w') as vrf: vrf.writelines(vrtData) sleep(0.01) vrts = gdal.OpenEx(vrt_file, 0) #Visit https://gdal.org/python/osgeo.gdal-module.html#GridOptions to see other options, like width and height for a higher resolution option = gdal.GridOptions(format='GTiff',width=job_data.tileHeight,height=job_data.tileWidth,outputSRS=job_data.sourceEpsg,algorithm='invdist:power={pow}:smoothing={smo}'.format(pow=job_data.powerVal,smo=job_data.smoothingVal),zfield='field_3') #Interapolate TIN to a grid ds = gdal.Grid(tile,vrts,options=option) ds = None del ds vrts = None #Remove csv and vrt file if cleanup: os.remove(csv_file) os.remove(vrt_file) sleep(0.05) return file_data except Exception as e: QgsMessageLog.logMessage('Error while converting {file}, Error: {er}'.format(file=file_data.fileName, er=str(e)),CATEGORY, Qgis.Info) return None
def main(): temp_dir = os.path.join(tempfile.gettempdir(), 'gdal_interp') if not os.path.exists(temp_dir): os.mkdir(temp_dir) if not os.path.exists(out_dir): os.mkdir(out_dir) prov_dict = { 'SX1': [109.89, 34.3065, 115.00, 40.912], 'SX2': [105.28, 31.59, 111.41, 39.71], 'HB': [112.0, 36.0, 120.01, 43.01], 'HN': [110.0, 31.0, 117.0, 36.0], 'NX': [104.0, 35.0, 107.7, 39.5], 'SC': [97.0, 26.0, 109.0, 34.5], 'SD': [114.5, 34.0, 123.0, 38.5] } # # prov = os.path.splitext(os.path.basename(out_pm25))[0].split('_')[-2] # city = os.path.splitext(os.path.basename(out_pm25))[0].split('_')[-1] with open(csv_file, 'r') as in_csv: csv_str = in_csv.readlines() head_line = csv_str[0].replace('\n', '').split(',') value_id = head_line[-3:] lon_ind = head_line.index('Lon') lat_ind = head_line.index('Lat') for ivalue in range(len(value_id)): ipm_csvfile = os.path.join( temp_dir, 'qixiang_interp_%s.csv' % (value_id[ivalue])) value_ind = head_line.index(value_id[ivalue]) with open(ipm_csvfile, 'w', newline='') as ipm_csv: ipmcsv_writer = csv.writer(ipm_csv, dialect=("excel")) ipmcsv_writer.writerow(['Lon', 'Lat', 'Value']) for idata in csv_str[1:]: idata = idata.replace('\n', '').split(',') ipmcsv_writer.writerow( [idata[lon_ind], idata[lat_ind], idata[value_ind]]) # ipmcsv_writer = None # ipm_csv.close() ivrt_file = os.path.join( temp_dir, '%s_csv2vrt.vrt' % (os.path.splitext(os.path.basename(ipm_csvfile))[0])) ivrt_data = '<OGRVRTDataSource>\n' \ ' <OGRVRTLayer name="%s">\n' \ ' <SrcDataSource>%s</SrcDataSource>\n' \ ' <GeometryType>wkbPoint</GeometryType>\n' \ ' <LayerSRS>WGS84</LayerSRS>\n' \ ' <GeometryField encoding="PointFromColumns" x="Lon" y="Lat" z="%s"/>\n' \ ' </OGRVRTLayer>\n' \ '</OGRVRTDataSource>' % \ (os.path.splitext(os.path.basename(ipm_csvfile))[0], ipm_csvfile, 'Value') with open(ivrt_file, 'wb') as ivrt: ivrt.write(ivrt_data.encode("utf-8")) iout_file = os.path.join( out_dir, '%s.tif' % (os.path.splitext(os.path.basename(ipm_csvfile))[0])) tiff_driver = gdal.GetDriverByName("GTiff") if os.path.exists(iout_file): tiff_driver.Delete(iout_file) in_prov = 'HN' prov_extent = prov_dict[in_prov] prov_width = (prov_extent[2] - prov_extent[0]) / 0.005 + 1 prov_height = (prov_extent[3] - prov_extent[1]) / 0.005 + 1 gdal.Grid(iout_file, ivrt_file, format="GTiff", outputType=gdal.GDT_Float32, algorithm='invdist:power=2.0:smoothing=0.0', noData=0, width=prov_width, height=prov_height, outputBounds=prov_extent) clip_file = os.path.join( out_dir, '%s_sub.tif' % (os.path.splitext(os.path.basename(ipm_csvfile))[0])) clip(iout_file, shp_file, clip_file) os.remove(iout_file) shutil.rmtree(temp_dir)
df_final['NZTMX'] = X df_final['NZTMY'] = Y #-Convert UTC to NZ timezone df_final['time'] = df_final['time'].dt.tz_localize('utc') df_final['time'] = df_final['time'].dt.tz_convert(nzTimeZones) df_final['time'] = df_final['time'].dt.tz_localize(None) #-Get NZ time of the forecast forecastTime = df_final.iloc[0,0] df_final.drop('time', axis=1, inplace=True) #-Write to csv before converting to GTiff df_final.to_csv(csvFile, index=False) df_final = None #-Get the UTC of the nc filename and convert to a datestime of NZ time zone ncFileStr = ncF[-13:].split('.nc')[0] year = int(ncFileStr[:4]) month = int(ncFileStr[4:6]) day = int(ncFileStr[6:8]) hour = int(ncFileStr[8:10]) fileTime = pd.Timestamp(year=year, month=month, day=day, hour=hour, tz='utc').tz_convert(nzTimeZones) fileTime = fileTime.tz_localize(None) #-Convert csv to GTiff tifOut = os.path.join(fProdTifDir, str(i) + 'h_' + forecastTime.strftime('%Y%m%d_%H%M') + '_' + fileTime.strftime('%Y%m%d_%H%M') + '.tif') z = gdal.Grid(tifOut, vrtFile, width = cols, height=rows, algorithm='linear',format='GTiff', outputSRS='EPSG:2193', spatFilter=(xmin,ymin,xmax,ymax), zfield='prec') z=None i+=1 except: errorLog.write('%s could not be processed because of unknown file format\n' %ncF) errorLog.close()
data_time_str = "%s年%s月%s日%s时" % (year, month, day_str, clock_str) data_list = data_reader(db_path, data_time_str) if len(data_list) > 0: result_time = str(year) + str(month) + day_str + clock_str result_dir = os.path.join(output_dir, result_time) if not os.path.exists(result_dir): os.mkdir(result_dir) result_shp_path = os.path.join(result_dir, result_time + '.shp') result_ras_path = os.path.join(result_dir, result_time + '.tif') list2shp(data_list, result_shp_path) # convert shapefile to raster using gdal raw_raster = os.path.join(result_dir, 'raw_ratser.tif') gdal.Grid(raw_raster, result_shp_path, format='GTiff', zfield='Pm2.5', outputBounds=[73.4, 54, 135.1, 18.1], algorithm='invdist:power=2.0:smoothing=0.1') # clip to china extent using gdal gdal.Warp(result_ras_path, raw_raster, format="GTiff", warpOptions="NUM_THREADS=ALL_CPUS", warpMemoryLimit=1024, resampleAlg="cubic", multithread=True, cutlineDSName=china_shp, cropToCutline=True) os.remove(raw_raster)
def main(input_xlsx, out_raster, china_shp): # input_xlsx = 'pm25_geoed.xlsx' # use openpyxl so we can access by field name wb = openpyxl.load_workbook(input_xlsx) ws = wb.get_sheet_by_name('pm25') max_row = ws.max_row gdal.AllRegister() # 为了支持中文路径,请添加下面这句代码 gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 为了使属性表字段支持中文,请添加下面这句 gdal.SetConfigOption("SHAPE_ENCODING", "CP936") # 注册所有的驱动 ogr.RegisterAll() # set up the shapefile driver driver = ogr.GetDriverByName("ESRI Shapefile") # create the data source output_shp = './geoed_excel_to_raster/air_pollution.shp' data_source = driver.CreateDataSource(output_shp) # create the spatial reference, WGS84 srs = osr.SpatialReference() srs.ImportFromEPSG(4326) # create the layer layer = data_source.CreateLayer("surveillance_stations", srs, ogr.wkbPoint) # Add the fields we're interested in field_name = ogr.FieldDefn("Name", ogr.OFTString) field_name.SetWidth(24) layer.CreateField(field_name) field_city = ogr.FieldDefn("City", ogr.OFTString) field_city.SetWidth(24) layer.CreateField(field_city) field_airquality = ogr.FieldDefn("AQ", ogr.OFTString) field_airquality.SetWidth(24) layer.CreateField(field_airquality) field_primepollution = ogr.FieldDefn("PP", ogr.OFTString) field_primepollution.SetWidth(24) layer.CreateField(field_primepollution) field_time = ogr.FieldDefn("Time", ogr.OFTString) field_time.SetWidth(24) layer.CreateField(field_time) layer.CreateField(ogr.FieldDefn("Latitude", ogr.OFTReal)) layer.CreateField(ogr.FieldDefn("Longitude", ogr.OFTReal)) layer.CreateField(ogr.FieldDefn("Pm2.5", ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn("Pm10", ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn("CO", ogr.OFTReal)) layer.CreateField(ogr.FieldDefn("NO2", ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn("O3/1HOUR", ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn("O3/8HOUR", ogr.OFTInteger)) layer.CreateField(ogr.FieldDefn("SO2", ogr.OFTInteger)) # Process the xlsx file and add the attributes and features to the shpfile for i in range(2, max_row + 1): lon = ws['O' + str(i)].value lat = ws['P' + str(i)].value if (lon is not None) and (lat is not None): # create the feature feature = ogr.Feature(layer.GetLayerDefn()) # Set the attributes using the values from the delimited text file feature.SetField("Name", ws['C' + str(i)].value) feature.SetField("City", ws['B' + str(i)].value) feature.SetField("AQ", ws['E' + str(i)].value) feature.SetField("PP", ws['F' + str(i)].value) feature.SetField("Time", ws['N' + str(i)].value) feature.SetField("Latitude", ws['P' + str(i)].value) feature.SetField("Longitude", ws['O' + str(i)].value) feature.SetField("Pm2.5", ws['G' + str(i)].value) feature.SetField("Pm10", ws['H' + str(i)].value) feature.SetField("CO", ws['I' + str(i)].value) feature.SetField("NO2", ws['J' + str(i)].value) feature.SetField("O3/1HOUR", ws['K' + str(i)].value) feature.SetField("O3/8HOUR", ws['L' + str(i)].value) feature.SetField("SO2", ws['M' + str(i)].value) # create the WKT for the feature using Python string formatting wkt = "POINT(%f %f)" % (float(lon), float(lat)) # Create the point from the Well Known Txt point = ogr.CreateGeometryFromWkt(wkt) # Set the feature geometry using the point feature.SetGeometry(point) # Create the feature in the layer (shapefile) layer.CreateFeature(feature) # Dereference the feature feature = None # Save and close the data source data_source = None # convert shapefile to raster using gdal raw_raster = './geoed_excel_to_raster/raw_ratser.tif' gdal.Grid(raw_raster, output_shp, format='GTiff', zfield='pm2.5', outputBounds=[73.4, 54, 135.1, 18.1], algorithm='invdist:power=2.0:smoothing=0.1') # clip to china extent using gdal gdal.Warp(out_raster, raw_raster, format="GTiff", warpOptions="NUM_THREADS=ALL_CPUS", warpMemoryLimit=1024, resampleAlg="cubic", multithread=True, cutlineDSName=china_shp, cropToCutline=True) os.remove(raw_raster)
print(outputTest) wellNitrate = str(wellsShapefile) print(wellNitrate) #creating interpolation for well nitrate data power_option = input("enter a k value > 0: ") smoothing_option = input("enter smoothing variable >= 0") algorithm_option = 'invdist:power='+power_option+':smoothing='+smoothing_option print(algorithm_option) gridOptions = gdal.GridOptions(format='Gtiff', algorithm=algorithm_option, zfield="nitr_ran") out = gdal.Grid(outputTest, wellNitrate, options=gridOptions) print('interpolation complete') print('reprojecting raster') print('input file:', outputTest) print('output file:', rasterWarpOut) out = None del out warpOptions = gdal.WarpOptions(srcSRS='EPSG:4269', dstSRS='EPSG:4269') print('warp options input') warp_out = gdal.Warp(rasterWarpOut, outputTest, options=warpOptions) print('raster reprojected') print('changing resolution')
def gridByTxt(inputPath, outputPath, prjFile, cellSize, extend=None): """ txt文件插值为栅格 TODO 统一输入输出文件规范 :param inputPath: str 输入txt文件路径 :param outputPath: str 输出栅格文件路径 :param cellSize: float 输出栅格分辨率,单位:度 :param extend: tuple 输出栅格范围 (ulx, uly, lrx, lry) :return: """ # shp生成csv tempPath = BaseUtil.file_path_info(inputPath)[0] baseName = BaseUtil.file_path_info(inputPath)[1] # csvName = baseName + ".csv" # csvPath = os.path.join(tempPath, csvName) # ShapeUtil.pointToCsv(inputPath, csvPath, zField) # 生成vrt vrtName = baseName + ".vrt" vrtPath = os.path.join(tempPath, vrtName) dom = XmlUtil.createDom() roodNode = XmlUtil.createRootNode(dom, "OGRVRTDataSource") OGRVRTLayerNode = XmlUtil.appendNode(dom, roodNode, "OGRVRTLayer", attrInfo={"name": baseName}) XmlUtil.appendNode(dom, OGRVRTLayerNode, "SrcDataSource", text=inputPath) XmlUtil.appendNode(dom, OGRVRTLayerNode, "GeometryType", text="wkbPoint") XmlUtil.appendNode(dom, OGRVRTLayerNode, "GeometryField", attrInfo={ "encoding": "PointFromColumns", "x": "field_1", "y": "field_2", "z": "field_3" }) XmlUtil.saveDom(dom, vrtPath) # 计算输出范围 if extend: xMin = extend[0] xMax = extend[2] yMin = extend[3] yMax = extend[1] outputBounds = extend width = int((xMax - xMin) / cellSize) height = int((yMax - yMin) / cellSize) else: csvData = pd.read_csv(inputPath, header=None, sep=" ") xMin = csvData[0].min() xMax = csvData[0].max() yMin = csvData[1].min() yMax = csvData[1].max() outputBounds = (xMin, yMax, xMax, yMin) width = int((xMax - xMin) / cellSize) height = int((yMax - yMin) / cellSize) # 插值算法参数 algo = 'invdist:power=2.0:smoothing=0.0:radius1=0.0:radius2=0.0:angle=0.0:max_points=0:min_points=0:nodata=0.0' options = gdal.GridOptions(outputType=gdal.GDT_Float32, outputBounds=outputBounds, layers=baseName, format='GTiff', algorithm=algo, width=width, height=height, outputSRS=prjFile) gdal.Grid(outputPath, vrtPath, options=options)
def convert_xyz_to_raster(x, y, z, res, method, outfile): """Function to produce raster from point data presented with X, Y, Z Coordinates NOTE: This function still has some issues, particularly with outputting large rasters (which have to be cut into smaller chunks). :param float x: x coordinates :param float y: y coordinates :param float z: z coordinates or other variable that you want to display in the raster :param float res: resolution of the output raster in relevant projection units :param str outfile: file to save raster. NOTE: if size of raster is large, outfile will be split into numbered raster files """ bean = 500 # Minimum size (square) of output raster before cutting it into smaller chunks # This is to resolve an issue with the slowness of gdal.Grid # Determine size of output grid based on desired resolution w1 = np.ceil(np.ptp(x) / res) h1 = np.ceil(np.ptp(y) / res) # Define the algorithm for extrapolating data: alg = method + ':radius1=' + str(res / 2) + ':radius2=' + str( res / 2) + ':nodata=-9999' # As long as output raster size is less than bean x bean, output one raster: if w1 * h1 < bean**2: xyz = np.column_stack((x, y, z)) # Sort by x, then by y: xyz = xyz[xyz[:, 0].argsort()] xyz = xyz[xyz[:, 1].argsort(kind='mergesort')] write_csv_file('grid.csv', xyz) # Write temporary xyz file #Convert to Grid gdal.Grid(outfile, 'grid.vrt', width=w1, height=h1, algorithm=alg) os.remove('./grid.csv') # Remove temporary xyz file print print('Produced single map with filename {}'.format(outfile)) print # If size larger than bean x bean, split large grid into subgrids for faster processing: else: #merge_command = ['', '-o', outfile] #attempting merging rasters; this never worked out # Cutting into squares size bean x bean: Wind = int(np.ceil(w1 / bean)) Hind = int(np.ceil(h1 / bean)) nn = 0 for W in range(Wind): x1 = W * bean * res + np.min(x) x2 = (W + 1) * bean * res + np.min(x) xind = (x >= x1) & (x < x2) if W < Wind: wt = bean else: wt = w1 % bean for H in range(Hind): y1 = (H) * bean * res + np.min(y) y2 = (H + 1) * bean * res + np.min(y) yind = (y >= y1) & (y < y2) ind = xind & yind # Check for data within current square: if any(ind): xyz_temp = np.column_stack((x[ind], y[ind], z[ind])) xyz_temp = xyz_temp[xyz_temp[:, 0].argsort()] xyz = xyz_temp[xyz_temp[:, 1].argsort(kind='mergesort')] if H < Hind: ht = bean else: ht = h1 % bean out = outfile[:-4] + str(nn + 1) + '.tif' # Numbered outfile write_csv_file('grid.csv', xyz_temp) gdal.Grid(out, 'grid.vrt', width=wt, height=ht, algorithm=alg) os.remove('./grid.csv') #Remove temporary xyz file #merge_command.append(out) nn = nn + 1 print print 'Dataset too large for single grid production' print('Produced {} files with the following names: '.format(nn)) for n in range(nn - 1): print('{}'.format(outfile[:-4] + str(n + 1) + '.tif')) print