def GetXYValueToRowsCols(PanPath,shapePath):
#获得给定数据的投影参考系和地理参考系
def getSRSPair(dataset):
prosrs = osr.SpatialReference()
prosrs.ImportFromWkt(dataset.GetProjection())
geosrs = prosrs.CloneGeogCS()
return prosrs, geosrs;
#将经纬度坐标转为投影坐标（具体的投影坐标系由给定数据确定）
def lonlat2geo(dataset, lon, lat):
prosrs, geosrs = getSRSPair(dataset);
ct = osr.CoordinateTransformation(geosrs, prosrs);
coords = ct.TransformPoint(lon, lat);
return coords[:2];
#根据GDAL的六参数模型将给定的投影转为影像图上坐标（行列号）
def geo2imagexy(dataset, x, y):
trans = dataset.GetGeoTransform();
a = np.array([[trans[1], trans[2]], [trans[4], trans[5]]]);
b = np.array([x - trans[0], y - trans[3]]);
return np.linalg.solve(a, b); # 使用numpy的linalg.solve进行二元一次方程的求解
#获取每个样本点shape的所有点的坐标,并转为全色影像对应的行列号
ogr.RegisterAll(); # 注册所有的驱动
ds = ogr.Open(shapePath,0); lyr = ds.GetLayer(0);
DSpan = gdal.Open(PanPath); # print(DSpan.GetProjection());
RowsCols = []; allLabel = [];
for feat in lyr:
pt = feat.geometry(); OneLabel = feat.GetField('LC');
allLabel.append( int(OneLabel) );
CoordsXY = lonlat2geo(DSpan,pt.GetX(),pt.GetY());
tempRowCol = geo2imagexy(DSpan, CoordsXY[0], CoordsXY[1]);
Row =int(math.floor( tempRowCol[1] )); Col =int( math.floor( tempRowCol[0] ));
RowsCols.append( [Row,Col] );
return RowsCols,allLabel;
def read_pointshp(filepath, filename):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
gdal.SetConfigOption("SHAPE_ENCODING", "")
ogr.RegisterAll()
driver = ogr.GetDriverByName('ESRI Shapefile')
ds = ogr.Open(os.path.join(filepath, filename), 0)
if ds == None:
print('打开文件%s失败！' % os.path.join(filepath, filename))
else:
print('打开文件%s成功！' % os.path.join(filepath, filename))
lyr = ds.GetLayer(0)
feanum = lyr.GetFeatureCount()
print('点个数', feanum)
data_list = []
field_index = [] #属性表表头索引
defn = lyr.GetLayerDefn()
iFieldCount = defn.GetFieldCount()
for index in range(iFieldCount):
oField = defn.GetFieldDefn(index)
field_index.append(oField.GetNameRef())
for i in range(feanum):
feat = lyr.GetNextFeature()
# data_list.append([])
temp = []
for index in field_index:
temp.append(feat.GetField(index))
temp.append(feat.geometry().GetX())
temp.append(feat.geometry().GetY())
temp.append(feat.geometry().GetZ())
data_list.append(temp)
listname_part = ['X','Y','Z']
list_name = field_index + listname_part
data_list.insert(0, list_name)
return(data_list)
def testLoad(serverDS, table, sourceFile):
ogr.RegisterAll()
shapeDS = ogr.Open(sourceFile)
sourceLayer = shapeDS.GetLayerByIndex(0)
options = []
name = serverDS.CopyLayer(sourceLayer, table, options).GetName()
return name
def readShp(self, shp):
# 支持中文路径
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
# 属性表字段支持中文
gdal.SetConfigOption("SHAPE_ENCODING", "UTF-8")
# 注册所有驱动
ogr.RegisterAll()
# 打开data
dataS = ogr.Open(shp)
# 获取该数据源中图层个数，一般shp数据图层只有一个。mdb,dxf等图层会有多个
lyCount = dataS.GetLayerCount()
# 获取第一个图层
oLayer = dataS.GetLayerByIndex(0)
# 图层初始化
oLayer.ResetReading()
# 获取图层中属性表表头并输出，可以定义建表语句
print("属性表信息：")
# 获取schema information,OGRFeatureDefn
oDefn = oLayer.GetLayerDefn()
# 获取字段数
iFieldCount = oDefn.GetFieldCount()
arrayF = []
for i in range(len(iFieldCount)):
# 获取对应i的字段FieldDefn
oField = oDefn.GetFieldDefn(i)
print("%s:%s(%d,%d)" % (
# 获取对应字段的name
oField.GetNameRef(),
# 返回OGRFieldType type fType=oField.GetType()
# 返回char
oField.GetFieldTypeName(oField.GetType()),
# 返回int
oField.GetWidth(),
oField.GetPrecision()))
# fetch field name
arrayF.append(oField.GetNameRef())
arrayF.append('geom')
# feature number
iFeatureCount = oLayer.GetFeatureCount(0)
print(iFeatureCount)
# fetch next feature
oFeature = oLayer.GetNextFeature()
result = []
result.append(arrayF)
while oFeature is not None:
# 清空list
arrayF.clear()
# fetch the content of attribute table
for i in range(len(iFeatureCount)):
# fetch field value(string)
arrayF.append(oFeature.GetfieldAsString)
if i == 1: print(result) #test
# fetch geometry(object)
oGeometry = oFeature.GetGeometryRef()
arrayF.append(str(oGeometry))
result.append(arrayF)
oFeature = oLayer.GetNextFeature()
return result
def createShap():
# 为了支持中文路径，请添加下面这句代码
gdal.SetConfigOption( "GDAL_FILENAME_IS_UTF8", "NO" )
# 为了使属性表字段支持中文，请添加下面这句
gdal.SetConfigOption( "SHAPE_ENCODING", "" )
# 注册所有的驱动
ogr.RegisterAll()
# 数据格式的驱动
driver = ogr.GetDriverByName( 'ESRI Shapefile' )
ds = driver.CreateDataSource( "E:\\arcgis\\point" )
shapLayer = ds.CreateLayer( "poi", geom_type = ogr.wkbPoint );
# 添加字段
fieldDefn = ogr.FieldDefn( 'id', ogr.OFTString )
fieldDefn.SetWidth( 4 )
shapLayer.CreateField( fieldDefn );
# 创建feature
defn = shapLayer.GetLayerDefn()
feature = ogr.Feature( defn ) ;
# 添加属性
feature.SetField( "id", "liu" )
# 添加坐标
point = ogr.Geometry( ogr.wkbPoint )
point.AddPoint( float( 113.56647912 ), float( 22.16128203 ) )
feature.SetGeometry( point );
shapLayer.CreateFeature( feature )
feature.Destroy()
# 指定投影
sr = osr.SpatialReference();
sr.ImportFromEPSG( 32612 );
prjFile = open( "E:\\arcgis\\point\\poi.prj", 'w' );
sr.MorphToESRI();
prjFile.write( sr.ExportToWkt() );
prjFile.close();
ds.Destroy()
def main(argv):
parser = argparse.ArgumentParser(prog=argv[0])
parser.add_argument('-src', '--srcdir', dest='srcdir', required=True)
parser.add_argument('-dst', '--dstdir', dest='dstdir', required=True)
parser.add_argument('-v', '--vector', dest='vector', default=None)
parser.add_argument('-p', '--plant', dest='plant', required=True)
args = parser.parse_args(argv[1:])
if not os.path.exists(args.dstdir):
os.makedirs(args.dstdir)
# 支持中文路径
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
# 支持中文属性字段
gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
# 注册所有ogr驱动
ogr.RegisterAll()
# 注册所有gdal驱动
gdal.AllRegister()
start_time = time.time()
H8_dir_path = args.srcdir
out_dir_path = args.dstdir
shp = args.vector
vegetation_mask = args.plant
action(H8_dir_path, out_dir_path, veg_msk=vegetation_mask, shp_file=shp)
end_time = time.time()
print("time: %.4f secs." % (end_time - start_time))
def _openVectorLayer(dlocation):
ogr.RegisterAll()
drv = ogr.GetDriverByName('ESRI Shapefile')
try:
ds = drv.Open(dlocation)
except Exception, e:
raise Exception, 'Invalid datasource, %s: %s' % (dlocation, str(e))
def renameVector(strOldFile, strNewFile):
# 注册所有的驱动
ogr.RegisterAll()
# 打开矢量
oDS = ogr.Open(strOldFile, 0)
if oDS == None:
return
oDriver = oDS.GetDriver()
if oDriver == None:
return
oDDS = oDriver.CopyDataSource(oDS, strNewFile, [])
oDDS.Destroy()
# 重要：此处需要关闭数据源，如果不关闭，会导致删除shp时，无法完全删除shp文件
oDS.Destroy()
if oDDS == None:
os.rename(strOldFile, strNewFile)
if oDriver.DeleteDataSource(strOldFile) == ogr.OGRERR_NONE:
return
else:
os.rename(strOldFile, strNewFile)
def create_shape_file(file_url, shp_name, spatial_ref, shp_type, field_list):
"""
产生ShpFile格式的文件
:param file_url:ShapeFile存放地址
:param shp_name:shp文件名称
:param spatial_ref:shp文件空间坐标系
:param shp_type:shp类型
:param field_list:字段列表，field_list[i][0]字段名称，field_list[i][1]字段类型，field_list[i][2]字段宽度
:return:数据源、数据层、要素类
"""
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "Yes")
ogr.RegisterAll()
driver = ogr.GetDriverByName("ESRI ShapeFile")
target_data_source = driver.CreateDataSource(file_url)
target_lyr = target_data_source.CreateLayer(shp_name, spatial_ref,
shp_type)
for field in field_list:
field_defined = ogr.FieldDefn(field[0], field[1])
field_defined.SetWidth(field[2])
field_defined.SetPrecision(4)
target_lyr.CreateField(field_defined)
feature_defined = target_lyr.GetLayerDefn()
feature = ogr.Feature(feature_defined)
return target_data_source, target_lyr, feature
def get_intersection(self):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 为了支持中文路径
gdal.SetConfigOption("SHAPE_ENCODING", "CP936") # 为了使属性表字段支持中文
strVectorFile = self.out_name # 定义写入路径及文件名
ogr.RegisterAll() # 注册所有的驱动
strDriverName = "ESRI Shapefile" # 创建数据，这里创建ESRI的shp文件
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
oDS = oDriver.CreateDataSource(strVectorFile) # 创建数据源
if oDS == None:
print("创建文件【%s】失败！", strVectorFile)
srs = osr.SpatialReference() # 创建空间参考
srs.ImportFromEPSG(4326) # 定义地理坐标系WGS1984
papszLCO = []
# 创建图层，创建一个多边形图层,"TestPolygon"->属性表名
oLayer = oDS.CreateLayer(self.layer_name, srs, ogr.wkbPoint, papszLCO)
if oLayer == None:
print("图层创建失败！\n")
oLayer.CreateField(ogr.FieldDefn("Latitude", ogr.OFTReal))
# 创建 名为Latitude 的字段数据类型为 Double 23/15 . ogr.OFTReal->shapefile Double
oLayer.CreateField(ogr.FieldDefn("Longitude", ogr.OFTReal))
oLayer.CreateField(ogr.FieldDefn("shp_i_j", ogr.OFTString))
self.handle_intersection(oLayer, oDS)
return os.path.join(self.out_name, '{}.shp'.format(self.layer_name))
def getBoxFromShp(shapeFile):
"""
把shapefile的格网生成grid列表
返回boxs的列表(fid,Box2d)
"""
boxlist=[]
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8","NO")
gdal.SetConfigOption("SHAPE_ENCODING","")
#i=0
ogr.RegisterAll()
ds=ogr.Open(shapeFile,0)
if ds==None:
return boxlist
olayer=ds.GetLayerByIndex(0)
if olayer==None:
return boxlist
olayer.ResetReading()
oFeature=olayer.GetNextFeature()
if not (olayer.GetGeomType()==3):
return boxlist
while oFeature is not None:
fid=oFeature.GetFID()
print fid
oGeometry=oFeature.GetGeometryRef()
envelope=oGeometry.GetEnvelope()
box=mapnik.Box2d(envelope[0],envelope[2],envelope[1],envelope[3])
boxlist.append((fid,box))
oFeature=olayer.GetNextFeature()
return boxlist
def imagexy2shp(img_path, strVectorFile, bboxes, scores, clss, cls_dict):
im_width, im_height, im_proj, im_geotrans, im_data, dataset = read_img(
img_path)
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 为了支持中文路径
gdal.SetConfigOption("SHAPE_ENCODING", "CP936") # 为了使属性表字段支持中文
ogr.RegisterAll()
strDriverName = "ESRI Shapefile" # 创建数据，这里创建ESRI的shp文件
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
oDS = oDriver.CreateDataSource(strVectorFile) # 创建数据源
if oDS == None:
print("创建文件【%s】失败！", strVectorFile)
# srs = osr.SpatialReference() # 创建空间参考
# srs.ImportFromEPSG(4326) # 定义地理坐标系WGS1984
srs = osr.SpatialReference(
wkt=dataset.GetProjection()
) #我在读栅格图的时候增加了输出dataset，这里就可以不用指定投影，实现全自动了，上面两行可以注释了，并且那个proj参数也可以去掉了，你们自己去掉吧
papszLCO = []
# 创建图层，创建一个多边形图层,"TestPolygon"->属性表名
oLayer = oDS.CreateLayer("TestPolygon", srs, ogr.wkbPolygon, papszLCO)
if oLayer == None:
print("图层创建失败！\n")
'''下面添加矢量数据，属性表数据、矢量数据坐标'''
oFieldID = ogr.FieldDefn("cls", ogr.OFTString) # 创建一个叫FieldID的整型属性
oLayer.CreateField(oFieldID, 1)
oFieldID = ogr.FieldDefn("Confidence", ogr.OFTInteger) # 创建一个叫FieldID的整型属性
oLayer.CreateField(oFieldID, 1)
# oFieldName = ogr.FieldDefn("FieldName", ogr.OFTString) # 创建一个叫FieldName的字符型属性
# oFieldName.SetWidth(100) # 定义字符长度为100
# oLayer.CreateField(oFieldName, 1)
oDefn = oLayer.GetLayerDefn() # 定义要素
# 创建单个面
for bbox, score, cls in zip(bboxes, scores, clss):
oFeatureTriangle = ogr.Feature(oDefn)
oFeatureTriangle.SetField(
0, cls_dict[int(cls)]) # 第一个参数表示第几个字段，第二个参数表示字段的值
oFeatureTriangle.SetField(1, score)
# oFeatureTriangle.SetField(1, "单个面")
ring = ogr.Geometry(ogr.wkbLinearRing) # 构建几何类型:线
ring.AddPoint(bbox[0], bbox[1]) # 添加点01
ring.AddPoint(bbox[2], bbox[1]) # 添加点02
ring.AddPoint(bbox[2], bbox[3]) # 添加点03
ring.AddPoint(bbox[0], bbox[3]) # 添加点04
yard = ogr.Geometry(ogr.wkbPolygon) # 构建几何类型:多边形
yard.AddGeometry(ring)
yard.CloseRings()
geomTriangle = ogr.CreateGeometryFromWkt(str(yard)) # 将封闭后的多边形集添加到属性表
oFeatureTriangle.SetGeometry(geomTriangle)
oLayer.CreateFeature(oFeatureTriangle)
oDS.Destroy()
print("数据集创建完成！\n")
def WriteVectorFile(shp_path, name, polygon):
# 解决中文路径
gdal.SetConfigOption('GDAL_FILENAME_IS_UTF8', 'YES')
# 解决 SHAPE 文件的属性值
gdal.SetConfigOption('SHAPE_ENCODING', 'GBK')
# 注册所有的驱动
ogr.RegisterAll()
# 创建ESRI的shp文件
strDriverName = "ESRI Shapefile"
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("驱动不可用!", )
return
# 创建数据源
oDS = oDriver.CreateDataSource(shp_path)
if oDS == None:
print("创建文件失败!")
return
# 创建空间参考系，WGS84
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
# 创建图层，创建一个多边形图层
papszLCO = []
oLayer = oDS.CreateLayer("TestPolygon", srs, ogr.wkbPolygon, papszLCO)
if oLayer == None:
print("图层创建失败！\n")
return
# 下面创建属性表
# 先创建一个叫FieldID的整型属性
oFieldID = ogr.FieldDefn("FieldID", ogr.OFTInteger)
oLayer.CreateField(oFieldID, 1)
# 再创建一个叫FieldName的字符型属性，字符长度为100
oFieldName = ogr.FieldDefn("FieldName", ogr.OFTString)
oFieldName.SetWidth(100)
oLayer.CreateField(oFieldName, 1)
oDefn = oLayer.GetLayerDefn()
# 创建要素
oFeatureTriangle = ogr.Feature(oDefn)
oFeatureTriangle.SetField(0, 0)
oFeatureTriangle.SetField(1, name)
# geomTriangle =ogr.CreateGeometryFromWkt("POLYGON ((0 0,20 0,10 15,0 0))")
geomTriangle = ogr.CreateGeometryFromWkt(polygon)
oFeatureTriangle.SetGeometry(geomTriangle)
oLayer.CreateFeature(oFeatureTriangle)
oDS.Destroy()
print("数据集创建完成!")
def transform_shp(same_point, shp_path, res_path):
road_tran = affine_fit(
same_point[['x_before', 'y_before']].values.tolist(),
same_point[['x_after', 'y_after']].values.tolist())
# copy_shp(shp_path, res_path)
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
# 为了使属性表字段支持中文，请添加下面这句
gdal.SetConfigOption("SHAPE_ENCODING", "")
res_name = os.path.basename(shp_path)
strVectorFile = os.path.join(res_path, res_name)
# 注册所有的驱动
ogr.RegisterAll()
# 创建数据，这里以创建ESRI的shp文件为例
strDriverName = "ESRI Shapefile"
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
return
# 创建数据源
oDS = oDriver.CreateDataSource(strVectorFile)
if oDS == None:
print("创建文件【%s】失败！", strVectorFile)
return
# 创建图层，创建一个多边形图层，这里没有指定空间参考，如果需要的话，需要在这里进行指定
papszLCO = []
oLayer = oDS.CreateLayer("road", None, ogr.wkbLineString, papszLCO)
if oLayer == None:
print("图层创建失败！\n")
return
# 下面创建属性表
# 先创建一个叫FieldID的整型属性
oLayer.CreateField(ogr.FieldDefn("FieldID", ogr.OFTInteger))
# 再创建一个叫FeatureName的字符型属性，字符长度为50
oLayer.CreateField(ogr.FieldDefn("FieldName", ogr.OFTString))
oDefn = oLayer.GetLayerDefn()
file = shapefile.Reader(shp_path)
polygons = file.shapes() # 一个shp由多个多边形组成
for i, shp_i in enumerate(polygons):
poly_list = []
polygon_point = shp_i.points # 第一个多边形的点集
for j, point in enumerate(polygon_point):
x, y = road_tran.transform([point[0], point[1]])
poly_list.append('{} {}'.format(x, y))
oFeature = ogr.Feature(oDefn)
oFeature.SetField("FieldID", i)
oFeature.SetField("FieldName", "test")
geomLine = ogr.CreateGeometryFromWkt("LINESTRING ({})".format(
",".join(poly_list)))
oFeature.SetGeometry(geomLine)
oLayer.CreateFeature(oFeature)
file.close()
oDS.Destroy()
print("数据集创建完成！\n")
def _vector_transform(self,src_file,dst_file,transform_method,format="shp"):
'''
:param src_file:
:param dst_file:
:param transform_method:
:param format:
:return:
'''
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
ogr.RegisterAll()
ds = ogr.Open(src_file, 0)
if ds is None:
print('Error: Could not open {}'.format(src_file))
sys.exit(1)
oLayer = ds.GetLayer() # shp默认是一个layer
if oLayer == None:
print("Error: The layer did not open correctly!")
sys.exit(1)
sr = oLayer.GetSpatialRef()
judge = self._judeg_isornot_wgs84(sr)
if judge == 1:
geom_type = oLayer.GetGeomType() # 图层几何类型
sr = oLayer.GetSpatialRef()
# 创建输出的layer
outds, outlayer = self._write_vector(dst_file, geom_type, sr)
'''属性表结构获取与创建'''
oDefn = oLayer.GetLayerDefn()
iFieldCount = oDefn.GetFieldCount() # 字段个数
for i in range(iFieldCount):
field_obj = oDefn.GetFieldDefn(i)
(fieldname, fieldtype, fieldlength) = self._get_attribute_fieldname(field_obj)
self._set_attribute_fieldname(outlayer, fieldname, fieldtype, fieldlength) # 输出图层的属性表结构创建
feature_count = oLayer.GetFeatureCount()
outfeatureddefn = outlayer.GetLayerDefn()
for j in tqdm(range(feature_count)):
feature = oLayer.GetFeature(j)
geom = feature.GetGeometryRef() # wktvalue的字符串
wkt_json = json.loads(geom.ExportToJson()) # json格式字符串
'''计算wkt坐标的偏转'''
self._vector_coord_transform(wkt_json, transform_method)
new_geom = asShape(wkt_json)
shape = ogr.CreateGeometryFromWkt(str(new_geom))
outfeature = ogr.Feature(outfeatureddefn)
outfeature.SetFrom(feature)
outfeature.SetGeometry(shape)
outlayer.CreateFeature(outfeature)
outds.Destroy()
else:
print("Warning: The coordinate system of sourse vector file is not WGS84!")
sys.exit(1)
def createShap_point():
'''
原始数据的可视化
:return:
'''
data = read_point()
path_out = r'../DATA/result/SHP'
# 为了支持中文路径，请添加下面这句代码
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
# 为了使属性表字段支持中文，请添加下面这句
gdal.SetConfigOption("SHAPE_ENCODING", "")
# 注册所有的驱动
ogr.RegisterAll()
# 数据格式的驱动
driver = ogr.GetDriverByName('ESRI Shapefile')
ds = driver.CreateDataSource(path_out)
shapLayer = ds.CreateLayer("didi_point", geom_type=ogr.wkbPoint25D)
# 添加字段
# 先创建一个叫FieldID的整型属性
oFieldID = ogr.FieldDefn("car_ID", ogr.OFTInteger)
shapLayer.CreateField(oFieldID, 1)
oFieldtype = ogr.FieldDefn("x", ogr.OFTString)
shapLayer.CreateField(oFieldtype, 1)
oFieldstart = ogr.FieldDefn("y", ogr.OFTString)
shapLayer.CreateField(oFieldstart, 1)
oFieldend = ogr.FieldDefn("t", ogr.OFTInteger)
shapLayer.CreateField(oFieldend, 1)
oFieldend = ogr.FieldDefn("type", ogr.OFTString)
shapLayer.CreateField(oFieldend, 1)
oDefn = shapLayer.GetLayerDefn()
feature = ogr.Feature(oDefn)
for line in data:
feature.SetField(0, line[0])
feature.SetField(1, line[1])
feature.SetField(2, line[2])
feature.SetField(3, int(line[3]))
feature.SetField(4, line[4])
line_f = ogr.Geometry(ogr.wkbPoint25D)
x = float(line[1])
y = float(line[2])
t = (int(line[3]) - 1448380800) / 86400.0
line_f.AddPoint(x, y, t)
feature.SetGeometry(line_f)
shapLayer.CreateFeature(feature)
feature.Destroy()
ds.Destroy()
def writeRecShpFile(GF2Json, outPath, EPSG=4326):
"""
将字典形式的矩形范围写入Shp文件当中
:param GF2Json: 字典形式矩阵范围的Json文件，格式为{GridName:[左上经，左上纬，右下经，右下纬]}
:param outPath: 输出shp路径
:return: None
"""
with open(GF2Json, 'r') as f:
extentDict = json.load(f)
ogr.RegisterAll()
strDriverName = "ESRI Shapefile"
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
return
oDS = oDriver.CreateDataSource(outPath)
if oDS == None:
print("创建文件【%s】失败！", outPath)
return
# 创建WGS84坐标
srs = osr.SpatialReference()
srs.ImportFromEPSG(EPSG)
oLayer = oDS.CreateLayer("GridRec",srs, ogr.wkbPolygon)
if oLayer is None:
print("图层创建失败！")
return
# oFieldID = ogr.FieldDefn("ID",ogr.OFTInteger)
# oLayer.CreateField(oFieldID,1)
oFieldName = ogr.FieldDefn('GridName',ogr.OFTString)
oFieldName.SetWidth(100)
oLayer.CreateField(oFieldName,1)
for c,(k,v) in enumerate(extentDict.items()):
for i,j in enumerate(v):
print('Writing %s %d'%(k,i+1))
extent = j['WGSExtent']
feature = ogr.Feature(oLayer.GetLayerDefn())
# feature.SetField(0,i)
feature.SetField(0,p.get_pinyin(k,'')+str(i+1))
wkt = 'POLYGON((%f %f,%f %f,%f %f,%f %f,%f %f))'%(
extent[0],extent[1],extent[0],extent[3],
extent[2],extent[3],extent[2],extent[1],extent[0],extent[1]
)
geoRec = ogr.CreateGeometryFromWkt(wkt)
feature.SetGeometry(geoRec)
oLayer.CreateFeature(feature)
feature=None
oDS.Destroy()
print("%d 个城市已被统计！"%(c+1))
print("shp文件生成完成!")
def init_create_shp(self):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 为了支持中文路径
gdal.SetConfigOption("SHAPE_ENCODING", "CP936") # 为了使属性表字段支持中文
strVectorFile = self.new_shp_path # 定义写入路径及文件名
ogr.RegisterAll() # 注册所有的驱动
strDriverName = "ESRI Shapefile" # 创建数据，这里创建ESRI的shp文件
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
oDS = oDriver.CreateDataSource(strVectorFile) # 创建数据源
if oDS == None:
print("创建文件【%s】失败！", strVectorFile)
return oDS
def PolygonToRaster(in_path,
out_path,
x_res,
y_res,
field_name,
out_bounds=None,
no_data=65535):
"""
面矢量转为栅格
:param in_path: str 输入矢量文件路径
:param out_path: str 输出栅格文件路径
:param x_res: float 输出栅格x向分辨率
:param y_res: float 输出栅格y向分辨率
:param field_name: str 栅格赋值的矢量字段名
:param out_bounds: tuple 输出栅格范围 [xmin, ymin, xmax, ymax]
:param no_data: int 无效值大小
:return:
"""
try:
if not out_bounds:
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8",
"NO") # 为了支持中文路径，请添加
gdal.SetConfigOption("SHAPE_ENCODING",
"GBK") # 为了使属性表字段支持中文，请添加
ogr.RegisterAll() # 注册所有的驱动
layer = ogr.Open(in_path, gdal.GA_ReadOnly).GetLayer(0)
shp_extent = layer.GetExtent()
out_bounds = (shp_extent[0], shp_extent[2], shp_extent[1],
shp_extent[3])
options = gdal.RasterizeOptions(outputBounds=out_bounds,
outputType=gdal.GDT_UInt16,
noData=no_data,
attribute=field_name,
useZ=False,
xRes=x_res,
yRes=y_res,
format="GTiff")
ds = gdal.Rasterize(out_path, in_path, options=options)
if not ds:
return False
del ds
return True
except Exception as e:
print(e)
return False
def ReadVectorFile(strVectorFile):
# 为了支持中文路径，请添加下面这句代码
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
# 为了使属性表字段支持中文，请添加下面这句
gdal.SetConfigOption("SHAPE_ENCODING", "GB2312")
# 注册所有的驱动
ogr.RegisterAll()
# 打开数据
ds = ogr.Open(strVectorFile, 0)
#判断文件是否存在
if ds == None:
print("打开文件【%s】失败！" % (strVectorFile))
return
#提示打开成功
print("打开文件【%s】成功！" % (strVectorFile))
def open_vector_file(vec_file):
# 支持文件中文路径
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
# 支持文件中文字段
gdal.SetConfigOption("SHAPE_ENCODING", "GB2312")
# 注册驱动
ogr.RegisterAll()
# 打开数据源(以只读的方式)
ds = ogr.Open(vec_file, 0)
# 判断文件是否打开成功
if ds is None:
# 提出文件打开失败
print("打开文件【%s】失败！" % vec_file)
# 跳出循环
return
# 提示文件打开成功
print("打开文件【%s】成功！" % vec_file)
def shp_file_create(self):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
gdal.SetConfigOption("SHAPE_ENCODING", "GBK")
ogr.RegisterAll()
# 注册驱动，打开测试文件和图层
driver = ogr.GetDriverByName("ESRI Shapefile")
# shp_file_path = SHP_FILE_PATH
# 打开输出文件及图层
# 输出模板shp 包含待写入的字段信息
self.outds = driver.CreateDataSource(self.shp_path)
# 创建空间参考
srs = osr.SpatialReference()
srs.ImportFromEPSG(4326)
# 创建图层
self.out_layer = self.outds.CreateLayer("out_polygon", srs,
ogr.wkbMultiPolygon)
def readShap():
# 为了支持中文路径，请添加下面这句代码
gdal.SetConfigOption( "GDAL_FILENAME_IS_UTF8", "NO" )
# 为了使属性表字段支持中文，请添加下面这句
gdal.SetConfigOption( "SHAPE_ENCODING", "" )
# 注册所有的驱动
ogr.RegisterAll()
# 数据格式的驱动
driver = ogr.GetDriverByName( 'ESRI Shapefile' )
ds = driver.Open( 'E:\\arcgis\\data\\Export_Output.shp' );
if ds is None:
print 'Could not open 1km地铁站试验2.shp'
sys.exit( 1 )
# 获取第0个图层
layer0 = ds.GetLayerByIndex( 0 );
# 投影
spatialRef = layer0.GetSpatialRef();
# 输出图层中的要素个数
print( '要素个数=%d', layer0.GetFeatureCount( 0 ) )
print( '属性表结构信息' )
defn = layer0.GetLayerDefn()
iFieldCount = defn.GetFieldCount()
for index in range( iFieldCount ):
oField = defn.GetFieldDefn( index )
print( '%s: %s(%d.%d)' % ( oField.GetNameRef(), oField.GetFieldTypeName( oField.GetType() ), oField.GetWidth(), oField.GetPrecision() ) )
feature = layer0.GetNextFeature()
# 下面开始遍历图层中的要素
while feature is not None:
# 获取要素中的属性表内容
for index in range( iFieldCount ):
oField = defn.GetFieldDefn( index )
line = " %s (%s) = " % ( oField.GetNameRef(), oField.GetFieldTypeName( oField.GetType() ) )
if feature.IsFieldSet( index ):
line = line + "%s" % ( feature.GetFieldAsString( index ) )
else:
line = line + "(null)"
print( line )
# 获取要素中的几何体
geometry = feature.GetGeometryRef()
print geometry
# 为了演示，只输出一个要素信息
break
feature.Destroy()
ds.Destroy()
def __init__(self, stream_data, time_flag, x_flag, y_flag, od_x_flag,
od_y_flag):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "YES")
gdal.SetConfigOption("SHAPE_ENCODING", "")
ogr.RegisterAll()
self._stream_data = stream_data
self._time_flag = time_flag
self._lon_flag = x_flag
self._lat_flag = y_flag
self._od_lon_flag = od_x_flag
self._od_lat_flag = od_y_flag
self._srs_str = "GEOGCS[\"GCS_WGS_1984\",DATUM[\"D_WGS_1984\",SPHEROID[\"WGS_1984\",6378137.0,298.257223563]],PRIMEM[\"Greenwich\",0.0],UNIT[\"Degree\",0.0174532925199433]]"
if (np.issubdtype(stream_data.index, np.datetime64) == False):
self._stream_data[self._time_flag] = pd.to_datetime(
self._stream_data[self._time_flag])
self._stream_data = self._stream_data.set_index(self._time_flag)
def WriteVectorFile(scaled_pred_polygons):
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO")
gdal.SetConfigOption("SHAPE_ENCODING", "")
strVectorFile = "E:/result/UnsupervisedModel/xingqing/15-16/img/quzao/15-16XQDenoising.shp"
ogr.RegisterAll()
strDriverName = "ESRI Shapefile"
oDriver = ogr.GetDriverByName(strDriverName)
if oDriver == None:
print("%s 驱动不可用！\n", strDriverName)
oDS = oDriver.CreateDataSource(strVectorFile)
if oDS == None:
print("创建文件【%s】失败！", strVectorFile)
papszLCO = []
oLayer = oDS.CreateLayer("TestPolygon", None, ogr.wkbPolygon, papszLCO)
if oLayer == None:
print("图层创建失败！\n")
oFieldID = ogr.FieldDefn("FieldID", ogr.OFTInteger)
oLayer.CreateField(oFieldID, 1)
oFieldName = ogr.FieldDefn("FieldName", ogr.OFTString)
oFieldName.SetWidth(100)
oLayer.CreateField(oFieldName, 1)
oDefn = oLayer.GetLayerDefn()
i = 0
for poly in scaled_pred_polygons:
oFeatureTriangle = ogr.Feature(oDefn)
oFeatureTriangle.SetField(0, i)
oFeatureTriangle.SetField(1, "bianhua")
geomTriangle = ogr.CreateGeometryFromWkt(poly.to_wkt())
oFeatureTriangle.SetGeometry(geomTriangle)
oLayer.CreateFeature(oFeatureTriangle)
i = i + 1
oDS.Destroy()
print("数据集创建完成！")
def statisticArea(shpPath):
"""读取属性表面积"""
gdal.SetConfigOption("GDAL_FILENAME_IS_UTF8", "NO") # 为了支持中文路径，请添加
gdal.SetConfigOption("SHAPE_ENCODING", "GBK") # 为了使属性表字段支持中文，请添加
ogr.RegisterAll() # 注册所有的驱动
ds = ogr.Open(shpPath, gdal.GA_ReadOnly)
layer = ds.GetLayer(0)
info = {} # 用一个字典接收属性表记录
fieldName = ['level', 'area']
for field in fieldName:
info[field] = [] # 接受某列数据
for i in range(layer.GetFeatureCount()):
feature = layer.GetFeature(i)
info[field].append(feature.GetField(field))
return pd.DataFrame(info)
